diff --git a/.venv_haddock/lib/python3.12/site-packages/_distutils_hack/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/_distutils_hack/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d1165d82095f911acb5cd8cf85408c789a42a587 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/_distutils_hack/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/_distutils_hack/__pycache__/override.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/_distutils_hack/__pycache__/override.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c8fc5bcff58ee69a14a4e6943b1281bf0c3a289a Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/_distutils_hack/__pycache__/override.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/_yaml/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/_yaml/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e452904c271c6318b7a3fa8c344bde56a4fca0fc Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/_yaml/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/freesasa-2.2.1.dist-info/licenses/LICENSE.txt b/.venv_haddock/lib/python3.12/site-packages/freesasa-2.2.1.dist-info/licenses/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..430cb7a557e5b7fdf0db9413a56fba1438937390 --- /dev/null +++ b/.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. + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..65fda5a063d959bb0fe982777b7eed38cfa4aee1 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/bin/contact_fcc b/.venv_haddock/lib/python3.12/site-packages/haddock/bin/contact_fcc new file mode 100644 index 0000000000000000000000000000000000000000..17e84b7305f56f47fcb0294197183e0371840a0d Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/bin/contact_fcc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/bin/contact_fcc.cpython-312-darwin.so b/.venv_haddock/lib/python3.12/site-packages/haddock/bin/contact_fcc.cpython-312-darwin.so new file mode 100644 index 0000000000000000000000000000000000000000..0742ba3c30c90eef3b9bc7cb069dfd99403a50c8 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/bin/contact_fcc.cpython-312-darwin.so differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/bin/fast-rmsdmatrix b/.venv_haddock/lib/python3.12/site-packages/haddock/bin/fast-rmsdmatrix new file mode 100644 index 0000000000000000000000000000000000000000..bebc981b8ad871a14170094b9505c0dee6052704 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/bin/fast-rmsdmatrix differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/bin/fast_rmsdmatrix.cpython-312-darwin.so b/.venv_haddock/lib/python3.12/site-packages/haddock/bin/fast_rmsdmatrix.cpython-312-darwin.so new file mode 100644 index 0000000000000000000000000000000000000000..f9318bc50d0658dc8648988d81d0fc70fd11f873 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/bin/fast_rmsdmatrix.cpython-312-darwin.so differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..768d257c08d65d903d0f1b343cfd4825e0248ceb --- /dev/null +++ b/.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 +""" diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d4053c123019149809f357972770d45a3599faa5 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_analyse.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_analyse.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e0671f10dbf68a12e3d2e4956868b80e517a3995 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_analyse.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_cfg.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_cfg.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..94001850706f6339139d7521e3ff8c36460e5c07 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_cfg.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_clean.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_clean.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ce835e6545f106a324799e3170baf1ab812db3fc Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_clean.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_cp.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_cp.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4194d4adddd99dc7ae47da74229e2437a8bd787c Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_cp.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_dmn.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_dmn.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cb2487fcd38336e958e97de60d26ce9d3db60321 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_dmn.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_mpi.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_mpi.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0a6b397068883fb4aaeeee6309c7b908bf1bdc48 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_mpi.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_pp.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_pp.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bd54095f3445726ebd3a0276643793f46ddf1674 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_pp.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_restraints.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_restraints.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..60dab30a241d22044a9be2f1196c90bc0c974fa2 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_restraints.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_score.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_score.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..afe865b2ee127b9b6b4dd3436230d71274eafa4f Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_score.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_traceback.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_traceback.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1d6a2d4d149e1616f2ce881db41fe965d1b10198 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/cli_traceback.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/wrapper_haddock_restraints.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/wrapper_haddock_restraints.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6e54ee8ce995a087dbac1f3c139d58baf55a3014 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/__pycache__/wrapper_haddock_restraints.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli.py b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli.py new file mode 100644 index 0000000000000000000000000000000000000000..65e4b78e7cf4b17556be81d1433f0fdece4c550b --- /dev/null +++ b/.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 +""" +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 diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_analyse.py b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_analyse.py new file mode 100644 index 0000000000000000000000000000000000000000..6ec4779a0a9abb53b32f530b99e6ca4465ff9cff --- /dev/null +++ b/.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 -m + 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 diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_cfg.py b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_cfg.py new file mode 100644 index 0000000000000000000000000000000000000000..9e06305cd3f4e7419e28c98195cfbf41f0107d7e --- /dev/null +++ b/.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 diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_clean.py b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_clean.py new file mode 100644 index 0000000000000000000000000000000000000000..8d2ec97ca017d929904d113fe8e8dfbc087f8c3c --- /dev/null +++ b/.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 can either be a whole HADDOCK3 run folder or a +specific folder of the workflow step. defines the number of +threads to use; by default uses a single core. + +Usage:: + + haddock3-clean -h + haddock3-clean + 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 diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_cp.py b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_cp.py new file mode 100644 index 0000000000000000000000000000000000000000..95bb419f64e82debad772d77611d89c6d2546f25 --- /dev/null +++ b/.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 -m -o + haddock3-copy -r run1 -m 0 4 -o run2 + +Where, ``-m 0 4`` will copy ``0_topoaa`` and ``4_flexref`` to . + +**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 diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_dmn.py b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_dmn.py new file mode 100644 index 0000000000000000000000000000000000000000..93988913aecd4a05391cd7326c73eccecb3d6d06 --- /dev/null +++ b/.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 --job-limit [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 diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_mpi.py b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_mpi.py new file mode 100644 index 0000000000000000000000000000000000000000..8d50e6c5ebdee2d0fdea6766f4cb19d38067a97a --- /dev/null +++ b/.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 diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_pp.py b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_pp.py new file mode 100644 index 0000000000000000000000000000000000000000..e289531469446c2f23c8f9492502406045a2429e --- /dev/null +++ b/.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 diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_re.py b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_re.py new file mode 100644 index 0000000000000000000000000000000000000000..16c36374155b729368a44aae6dc0147ee44c2dcd --- /dev/null +++ b/.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()) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_restraints.py b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_restraints.py new file mode 100644 index 0000000000000000000000000000000000000000..30807a77176db1dddda0c4ca74709216108c4109 --- /dev/null +++ b/.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 + +For the list of available tasks, run:: + + haddock3-restraints -h + +For the list of arguments for a given task, run:: + + haddock3-restraints -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()) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_score.py b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_score.py new file mode 100644 index 0000000000000000000000000000000000000000..a981996bb7e2f087294a9c145fddd602080a9d9c --- /dev/null +++ b/.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 diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_traceback.py b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_traceback.py new file mode 100644 index 0000000000000000000000000000000000000000..584f447562cd8ea80f45d56b3707332fbdfcf8b5 --- /dev/null +++ b/.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 + +""" +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()) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_unpack.py b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_unpack.py new file mode 100644 index 0000000000000000000000000000000000000000..6dbd5487341a464cf86c6eb7464fc141aae3e231 --- /dev/null +++ b/.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 can either be a whole HADDOCK3 run folder or a +specific folder of the workflow step. defined the number of +threads to use. + +Usage:: + + haddock3-unpack -h + haddock3-unpack -r + 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 diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/clis/wrapper_haddock_restraints.py b/.venv_haddock/lib/python3.12/site-packages/haddock/clis/wrapper_haddock_restraints.py new file mode 100644 index 0000000000000000000000000000000000000000..a7b4108372a4e4857dc4d638de75bb447ad5a9fe --- /dev/null +++ b/.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() diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/core/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/core/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5fbd962b51feb3911d34d031a864f4d7645ac3fa --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/core/__init__.py @@ -0,0 +1,3 @@ +""" +Core haddock3 functionalities. +""" diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/core/cns_paths.py b/.venv_haddock/lib/python3.12/site-packages/haddock/core/cns_paths.py new file mode 100644 index 0000000000000000000000000000000000000000..4907650677204e2dd08ca5e50eb072cd0da27a22 --- /dev/null +++ b/.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) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/core/defaults.py b/.venv_haddock/lib/python3.12/site-packages/haddock/core/defaults.py new file mode 100644 index 0000000000000000000000000000000000000000..a2b504d4b5e997c0a9bec9e9726dcc577ba681fb --- /dev/null +++ b/.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 diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/core/exceptions.py b/.venv_haddock/lib/python3.12/site-packages/haddock/core/exceptions.py new file mode 100644 index 0000000000000000000000000000000000000000..de67a3f67ad22853d991aa69dac2406b675dbebc --- /dev/null +++ b/.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 diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/core/mandatory.yaml b/.venv_haddock/lib/python3.12/site-packages/haddock/core/mandatory.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f32f96b77e45b352ed960a6cb3fb637c716d0f48 --- /dev/null +++ b/.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 diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/core/optional.yaml b/.venv_haddock/lib/python3.12/site-packages/haddock/core/optional.yaml new file mode 100644 index 0000000000000000000000000000000000000000..a07a3d9c1acfcd2131b029a501e6b57105f9e298 --- /dev/null +++ b/.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 diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/core/supported_molecules.py b/.venv_haddock/lib/python3.12/site-packages/haddock/core/supported_molecules.py new file mode 100644 index 0000000000000000000000000000000000000000..4a9f742ce86ab63dd92f96c0368246622ebb830b --- /dev/null +++ b/.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.""" + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/core/typing.py b/.venv_haddock/lib/python3.12/site-packages/haddock/core/typing.py new file mode 100644 index 0000000000000000000000000000000000000000..73a523b0d2eff0c136a7e778134121a39f207a52 --- /dev/null +++ b/.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]) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/deps/contact_fcc.cpp b/.venv_haddock/lib/python3.12/site-packages/haddock/deps/contact_fcc.cpp new file mode 100644 index 0000000000000000000000000000000000000000..50382d213db1f05511dfee1c6e3becd2ff4ae85b --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/deps/contact_fcc.cpp @@ -0,0 +1,124 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace std; + +struct Coor3f { + float x; + float y; + float z; +}; + +struct Residue { + int nr; + vector coor; + vector atom; + int seg; +}; + +vector 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 \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 \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 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 &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 &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); +} diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/deps/fast-rmsdmatrix.c b/.venv_haddock/lib/python3.12/site-packages/haddock/deps/fast-rmsdmatrix.c new file mode 100644 index 0000000000000000000000000000000000000000..d352bbabc311ea6ad0fadbd5187f0dda91ca1cf0 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/deps/fast-rmsdmatrix.c @@ -0,0 +1,883 @@ +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include +#include +#include + +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=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; +} diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/fcc/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/fcc/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/fcc/calc_fcc_matrix.py b/.venv_haddock/lib/python3.12/site-packages/haddock/fcc/calc_fcc_matrix.py new file mode 100644 index 0000000000000000000000000000000000000000..c1e7e2749725e9157677f13f2693e8ae89b9dc49 --- /dev/null +++ b/.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])) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/fcc/cluster_fcc.py b/.venv_haddock/lib/python3.12/site-packages/haddock/fcc/cluster_fcc.py new file mode 100644 index 0000000000000000000000000000000000000000..a5fc5e36527443709a00ace5b5c0e87e3914a6e5 --- /dev/null +++ b/.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 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") diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/gear/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e592753e5d233937759ca3e52b1c0d6555c4ce75 --- /dev/null +++ b/.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. +""" diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/gear/clean_steps.py b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/clean_steps.py new file mode 100644 index 0000000000000000000000000000000000000000..b7fddc6307fbef2fea004580b733c12a5f31fbf4 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/clean_steps.py @@ -0,0 +1,254 @@ +""" +Clean workflow steps' output. + +This module concerns removing unnecessary files, compressing, and +archiving files with the same extension to reduce space and stress when +listing files in the modules' step folders. + +The two main functions of this module are: + +* :py:func:`clean_output` +* :py:func:`unpack_compressed_and_archived_files` + +See also the command-line clients ``haddock3-clean`` and +``haddock3-unpack``. +""" +import gzip +import shutil +import tarfile + +from functools import partial +from multiprocessing import Pool +from pathlib import Path + +from haddock import log +from haddock.core.typing import FilePath, FilePathT, Iterable +from haddock.libs.libio import ( + archive_files_ext, + compress_files_ext, + glob_folder, + remove_files_with_ext, + ) + + +UNPACK_FOLDERS: list[FilePath] = [] + + +def clean_output(path: FilePath, ncores: int = 1) -> None: + """ + Clean the output of step folders. + + This functions performs file archiving and file compressing + operations. Files with extension ``seed``, ``inp``, ``out``, and + ``con`` are compressed and archived into ``.tgz`` files. The + original files are deleted. + + Files with ``.pdb`` and ``.psf`` extension are compressed to `.gz` + files. + + Parameters + ---------- + path : str or pathlib.Path + The path to clean. Should point to a folder from a workflow step. + + ncores : int + The number of cores. + """ + log.info(f"Cleaning output for {str(path)!r} using {ncores} cores.") + # add any formats generated to + # `unpack_compressed_and_archived_files` so that the + # uncompressing routines when restarting the run work. + + # Files to delete (all) + file_to_delete_all = ( + "mpi.pkl", + ) + for extension in file_to_delete_all: + for file_ in glob_folder(path, extension): + Path(file_).unlink() + + # Files to delete + # deletes all except the first one + # (keeping one for debugging purposes) + files_to_delete = ( + ".inp", + ".inp.gz", + ".out", + ".out.gz", + ".job", + ".err", + ) + + for extension in files_to_delete: + flist = glob_folder(path, extension) + for file_ in flist[1:]: + Path(file_).unlink() + + # files to archive (all files in single .gz) + files_to_archive = ( + ".seed", + ".seed.gz", + ".con", + ) + + archive_ready = partial(_archive_and_remove_files, path=path) + _ncores = min(ncores, len(files_to_archive)) + with Pool(_ncores) as pool: + imap = pool.imap_unordered(archive_ready, files_to_archive) + for _ in imap: + pass + + # files to compress in .gz + files_to_compress = ( + ".inp", + ".out", + ".pdb", + ".psf", + ".cnserr", + ) + + for ftc in files_to_compress: + found = compress_files_ext(path, ftc, ncores=ncores) + if found: + remove_files_with_ext(path, ftc) + + +def _archive_and_remove_files(fta: str, path: FilePath) -> None: + found = archive_files_ext(path, fta) + if found: + remove_files_with_ext(path, fta) + + +# eventually this function can be moved to `libs.libio` in case of future need. +def unpack_compressed_and_archived_files( + folders: Iterable[FilePathT], + ncores: int = 1, + dec_all: bool = False, + ) -> None: + """ + Unpack compressed and archived files in a folders. + + Works on `.gz` and `.tgz` files. + + Registers folders in :py:data:`UNPACK_FOLDERS` where compressed + and archived files were found. + + Parameters + ---------- + folders : list + List of folders to operate. + + ncores : int + The number of cores. + """ + global UNPACK_FOLDERS + UNPACK_FOLDERS.clear() + + files_to_decompress = [ + ".pdb.gz", + ".psf.gz", + ".seed.gz", + ] + + for folder in folders: + gz_files: list[Path] = [] + for file_to_dec in files_to_decompress: + gz_files.extend(list(glob_folder(folder, file_to_dec))) + + if dec_all: + for dec_all_files in ('.inp.gz', '.out.gz'): + gz_files.extend(list(glob_folder(folder, dec_all_files))) + + tar_files = glob_folder(folder, '.tgz') + + if gz_files or tar_files: + # register the folders that where unpacked + # this is useful for some functionalities of haddock3 + # namely the `--extend-run` option. + UNPACK_FOLDERS.append(folder) + + if gz_files: # avoids creating the Pool if there are no .gz files + with Pool(ncores) as pool: + imap = pool.imap_unordered(_unpack_gz, gz_files) + for _ in imap: + pass + + for tar_file in tar_files: + from haddock.libs.libio import extract_files_flat + extract_files_flat(tar_file, folder) + + tar_file.unlink() + + +def _unpack_gz(gz_file: Path) -> None: + out_file = Path(gz_file.parent, gz_file.stem) + + with gzip.open(gz_file, "rb") as fin, \ + open(out_file, "wb") as fout: + shutil.copyfileobj(fin, fout, 2 * 10**8) + + gz_file.unlink() + + +def update_unpacked_names(prev: Iterable[FilePath], new: Iterable[FilePath], + original: list[FilePath]) -> None: + """ + Update the unpacked path names. + + Sometimes the step folders are renamed to ajust their index number. + Such operation happens after the output data is unpacked. This module, + :py:mod:`haddock.gear.clean_steps`, keeps registry of the folders + unpacked to the correct funtioning of the `extend_run` module. + + Given the : list[FilePath] names and the new names of the step folders, + this function updates them in the storing list. + + Examples + -------- + >>> : list[FilePath] = ['0_topoaa', '4_flexref'] + >>> prev = ['0_topoaa', '4_flexref', '5_seletopclusts'] + >>> new = ['0_topoaa', '1_flexref', '5_seletopclusts'] + >>> update_unpacked_names(prev, new, original) + >>> original + ['0_topoaa', '1_flexref'] + + This function only evaluate the name of the last folder. And + maintains the type in the ``original`` list. + + >>> original = ['0_topoaa', Path('4_flexref'), '5_seletopclusts'] + >>> prev = ['0_topoaa', 'run_dir/4_flexref', '5_seletopclusts'] + >>> new = ['run_dir/0_topoaa', '1_flexref', 'run_dir/2_seletopclusts'] + >>> update_unpacked_names(prev, new, original) + >>> assert original == ['0_topoaa', Path('1_flexref'), '2_seletopclusts'] + + Parameters + ---------- + prev : list of str or pathlib.Path + The list of the original names before they were changed. + + new : list of str or pathlib.Path + The list of the new folder names. + + original : list of pathlib.Path + The list containing the names to record and which names + will be changed. + + Returns + ------- + None + Edits ``original`` in place. + """ + prevs = map(Path, prev) + news = map(Path, new) + original_names = [Path(o).name for o in original] + + # this is used to keep the original types of values in the ``original`` list + + for prev_, new_ in zip(prevs, news): + try: + idx = original_names.index(prev_.name) + except ValueError: # not present + continue + else: + _p = original[idx] + original[idx] = type(_p)(Path(Path(_p).parent, new_.name)) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/gear/config.py b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/config.py new file mode 100644 index 0000000000000000000000000000000000000000..3a21574b3de8c95810c29b23129aeaee23a730b0 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/config.py @@ -0,0 +1,339 @@ +""" +Module to read and write HADDOCK3 configuration files. + +HADDOCK3 user configuration files follow TOML syntax plus additional +features required for HADDOCK3. Therefore, we have implemented our own +TOML-like parser to accommodate the extra features needed for HADDOCK3. +However, HADDOCK3 can also read pure TOML files. + +The most relevant features of HADDOCK3 user configuration files are the +hability to prepare TOML-like files but with repeated header names, for +example: + +.. code:: toml + + [topoaa] + # parameters here... + + [rigidbody] + # parameters here... + + [caprieval] + # parameters here... + + [flexref] + # parameters here... + + [caprieval] + # parameters here... + +From the user perspective, everything else just behaves as in TOML. +Actually, HADDOCK3 uses TOML to finally read the configuration files. +Users can also provide pure TOML compatible files, for example: + +.. code:: toml + + [topoaa] + # parameters here... + + [rigidbody] + # parameters here... + + [caprieval] + # parameters here... + + [flexref] + # parameters here... + + ['caprieval.1'] + # parameters here... + +Because HADDOCK3 uses TOML in the end to read the configuration files, +all TOML rules apply regarding defining ``parameter = value`` pairs. + +Read more about TOML for Python here: https://pypi.org/project/toml/ +""" +import collections.abc +import os +import re +from pathlib import Path + +import toml + +from haddock import EmptyPath +from haddock.core.defaults import RUNDIR +from haddock.core.exceptions import ConfigurationError +from haddock.core.typing import FilePath, ParamDict, ParamMap, ParamMapT, Union +from haddock.libs.libutil import ( + recursive_convert_paths_to_strings, + transform_to_list, +) + + +# the re.ASCII parameter makes sure non-ascii chars are rejected in the \w key + +# Captures the main headers. +# https://regex101.com/r/9urqti/1 +_main_header_re = re.compile(r"^ *\[(\w+)\]", re.ASCII) + +# regex by @sverhoeven +# Matches ['.'] +_main_quoted_header_re = re.compile(r"^ *\[\'(\w+)\.\d+\'\]", re.ASCII) + +# Captures sub-headers +# https://regex101.com/r/6OpJJ8/1 +# thanks https://stackoverflow.com/questions/39158902 +_sub_header_re = re.compile(r"^ *\[(\w+)((?:\.\w+)+)\]", re.ASCII) + +# regex by @sverhoeven +_sub_quoted_header_re = re.compile( + r"^ *\[\'(\w+)\.\d+\'((?:\.\w+)+)\]", + re.ASCII, +) + +# Captures parameter uppercase boolean +_uppercase_bool_re = re.compile(r"(_?\w+((_?\w+?)+)?\s*=\s*)(True|False)", re.ASCII) + +# Some parameters are paths. The configuration reader reads those as +# pathlib.Path so that they are injected properly in the rest of the +# workflow. In general, any parameter ending with `_fname` is a path, +# but there are also other parameters that are paths. Those need to be +# added to this list bellow: +_keys_that_accept_files = [ + "cns_exec", + "executable", + RUNDIR, +] + + +class ConfigFormatError(Exception): + """Exception if there is a format error.""" + + pass + + +# main public API +def load(fpath: FilePath) -> ParamDict: + """ + Load an HADDOCK3 configuration file to a dictionary. + + Accepts HADDOCK3 ``cfg`` files or pure ``toml`` files. + + Parameters + ---------- + fpath : str or :external:py:class:`pathlib.Path` + Path to user configuration file. + + Returns + ------- + dictionary + Representing the user configuration file where first level of + keys are the module names. Step keys will have a numeric + suffix, for example: ``module.1``. + + .. see-also:: + * :py:func:`loads` + """ + try: + return loads(Path(fpath).read_text()) + except Exception as err: + raise ConfigurationError( + "Something is wrong with the config file." + ) from err # noqa: E501 + + +def loads(cfg_str: str) -> ParamDict: + """ + Read a string representing a config file to a dictionary. + + Config strings are converted to toml-compatible format and finally + read by the toml library. + + All headers (dictionary keys) will be suffixed by an integer + starting at ``1``. For example: ``topoaa.1``. If the key is + repeated, ``2`` is appended, and so forth. Even if specific + integers are provided by the user, the suffix integers will be + normalized. + + Parameters + ---------- + cfg_str : str + The string representing the config file. Accepted formats are + the HADDOCK3 config file or pure `toml` syntax. + + Returns + ------- + all_configs : dict + A dictionary holding all the configuration file steps: + + - 'raw_input': Original input file as provided by user. + - 'cleaned_input': Regex cleaned input file. + - 'loaded_cleaned_input': Dict of toml loaded cleaned input. + - 'final_cfg': The config in the form of a dictionary. In which + the order of the keys matters as it defines the order of the + steps in the workflow. + """ + new_lines: list[str] = [] + cfg_lines = cfg_str.split(os.linesep) + counter: dict[str, int] = {} + + # this for-loop normalizes all headers regardless of their input format. + for line in cfg_lines: + if group := _main_header_re.match(line): + name = group[1] + counter.setdefault(name, 0) + counter[name] += 1 + count = counter[name] + new_line = f"['{name}.{count}']" + + elif group := _main_quoted_header_re.match(line): + name = group[1] + counter.setdefault(name, 0) + counter[name] += 1 + count = counter[name] + new_line = f"['{name}.{count}']" + + elif group := _sub_header_re.match(line): + name = group[1] + count = counter[name] # name should be already defined here + new_line = f"['{name}.{count}'{group[2]}]" + + elif group := _sub_quoted_header_re.match(line): + name = group[1] + count = counter[name] # name should be already defined here + new_line = f"['{name}.{count}'{group[2]}]" + + elif group := _uppercase_bool_re.match(line): + param = group[1] # Catches 'param = ' + uppercase_bool = group[4] + new_line = f"{param}{uppercase_bool.lower()}" # Lowercase bool + + else: + new_line = line + + new_lines.append(new_line) + + # Re-build workflow configuration file + cfg = os.linesep.join(new_lines) + + try: + cfg_dict = toml.loads(cfg) # Try to load it with the toml library + except Exception as err: + raise ConfigurationError( + "Some thing is wrong with the config file: " f"{str(err)}" + ) from err + + final_cfg = convert_variables_to_paths(cfg_dict) + + all_configs = { + "raw_input": cfg_str, + "cleaned_input": cfg, + "loaded_cleaned_input": cfg_dict, + "final_cfg": final_cfg, + } + + # Return all configuration steps + return all_configs + + +def convert_variables_to_paths(cfg: ParamMapT) -> ParamMapT: + """ + Convert config variables to paths. + + Applies only to those variables HADDOCK3 needs as paths. + + Parameters + ---------- + cfg : dictionary + A dictionary containing the HADDOCK3 parameters. + + .. see-also:: + :py:func:`match_path_criteria` + """ + for param, value in cfg.items(): + if param == "molecules": + # `transform_to_list` is needed to allow strings OR lists in the + # `molecule` parameter + cfg[param] = [convert_to_path(v) for v in transform_to_list(value)] + + elif match_path_criteria(param): + cfg[param] = convert_to_path(value) + + elif isinstance(value, collections.abc.Mapping): + cfg[param] = convert_variables_to_paths(value) # type: ignore + + return cfg + + +def convert_to_path(value: FilePath) -> Union[Path, EmptyPath]: + """Convert a variable to Path if variable evaluates to true.""" + if value: + return Path(value) + else: + return EmptyPath() + + +def match_path_criteria(param: str) -> bool: + """ + Confirm a parameter should be converted to path. + + This function contains the rules defining which parameter need to be + converted to Path before be sent to HADDOCK3. + """ + return param.endswith("_fname") or param in _keys_that_accept_files + + +def get_module_name(name: str) -> str: + """ + Get the module name according to the config parser. + + Get the name without the integer suffix. + """ + return name.split(".")[0] + + +def save(params: ParamMap, path: FilePath, pure_toml: bool = False) -> None: + """ + Write a dictionary to a HADDOCK3 config file. + + Write the HADDOCK3 parameter dictionary to a `.cfg` file. There is + also the option to write in pure TOML format. Both are compatible with + HADDOCK3. + + Parameters + ---------- + params : dict + The dictionary containing the parameters. + + path : str or pathlib.Path + File name where to save the configuration file. + + pure_toml : bool + Save config in pure toml format. + """ + params = recursive_convert_paths_to_strings(params) + + if pure_toml: + with open(path, "w") as fout: + toml.dump(params, fout) + return + + cfg_str = toml.dumps(params).split(os.linesep) + + new_lines: list[str] = [] + for line in cfg_str: + if group := _main_quoted_header_re.match(line): + name = group[1] + new_line = f"[{name}]" + + elif group := _sub_quoted_header_re.match(line): + name = group[1] + new_line = f"[{name}{group[2]}]" + else: + new_line = line + new_lines.append(new_line) + + cfg_str = os.linesep.join(new_lines) # type: ignore + + with open(path, "w") as fout: + fout.write(cfg_str) # type: ignore diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/gear/expandable_parameters.py b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/expandable_parameters.py new file mode 100644 index 0000000000000000000000000000000000000000..1676843b1662f8335ca9888946abb39a04b13c5e --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/expandable_parameters.py @@ -0,0 +1,934 @@ +""" +Expandable parameter module. + +This module contains all logic for reading and preparing expandable parameters. + +Expandable parameters are parameters that follow a specific name structure. +They can be repeated multiple times (in groups) in the user configuration file +while being defined only once in the `defaults.yaml` files. For example, in the +`refinement.flexref` module there are the parameters: + +- `fle_sta_1_1` +- `fle_end_1_1` + +For these cases, you can also define in the user configuration file the +following: + +- `fle_sta_1_2` +- `fle_end_1_2` + +The above parameters will be accepted and used in the CNS modules. We +say they are the second groupd of the `fle1` group. We explain in detail +below. + +Currently, there are three types of expandable parameters: + +1 - Parameters following the name structure: + +- `name_something_1`, +- `name_something_else_1` + +These two parameters belong to the parameter name `name` and group `1`. +The two parameters have the name `something` and `something_else`. +Therefore, you could define also: + +- `name_something_2` +- `name_something_else_2` + +Numbers are allowed as long as in combination with word characters, for +example: `name_something1_2`, but not `name_something_1_1` because the +latter is of the second type. + +2 - Parameters following the name structure: + +- `name_something_X_Y` +- `name_else_X_Y` + +In these cases, the parameter name is `nameX`, where `X` is an integer. +`Y` is the number of the group, and `something` and `else` are the name +of the parameters. Taking example: + +- `fle_sta_1_1` +- `fle_end_1_1` + +The parameter name is `fle1` and the parameters belonging to the groups +are `sta` and `end`, and the group is either `1`. + +3 - The simplest parameters in the form of: + +- `param_1` + +In these cases, you can define `param_2`, `param_3`, etc, in the user +configuration file despite those are not defined in the `defaults.yaml`. +However, because `_` is too much of a simple rule, we +need to define in this module which parameters are actualy expandable. +If you are developing here look for the `type_simplest_ep` variable. + +4. Parameters that are expandable to the max number of molecules: + +Those are the parameters starting with `mol`. For example: +`mol_fix_origin_1`, which refers to the `fix_origin` parameter for +molecule 1. These parameters are allowed to expand only to the maximum +of input molecules, and at most to the max number of molecules allowed. +""" +import itertools as it +from copy import deepcopy +from functools import partial + +from haddock.core.defaults import max_molecules_allowed +from haddock.core.exceptions import ConfigurationError +from haddock.core.typing import ( + Any, + AnyT, + Callable, + Iterable, + Optional, + ParamMap, + Sequence, + SupportsAddT, +) + + +# error messages used in _read_groups_in_user_config function +# errors messages for single indexed groups +_emsg_no_group_single = ( + "The parameter block '{}_*_{}' is not a valid expandable parameter." +) +_emsg_unexpected_params_single = ( + "These parameters do not belong to the block '{}_*_{}': {!r}." +) + +# errors messages for multiple indexed groups +_emsg_no_group_multiple = ( + "The parameter block '{}_*_{}_*' is not a valid expandable parameter." +) +_emsg_unexpected_params_multiple = ( + "These parameters do not belong to the block '{}_*_{}_*': {!r}." +) + +# common error messages +_emsg_num_differ = ( + "The parameter block {!r} expects " + "{} parameters ({}), but {} are present " + "in the user configuration file: {}. " + "Parameter(s) {} are missing." +) + + +# this dictionary defines which parameters of the form "param_1" are +# expandable, and for which modules. We cannot define a general +# expandable rule for such a simple parameter name because there can be +# many other parameters with the same structure but that are not +# supposed to be expandable. +type_simplest_ep = { + "topoaa": { + "hisd", # hisd_1 should be defined in the `defaults.yaml` + "hise", # hise_1 should be defined in the `defaults.yaml` + }, +} + + +GroupDict = dict[tuple[str, str], Any] + + +# this is an engine function that must be populated with the respective +# functions the specify its behaviour. This engine is used in +# `get_single_index_groups` and `get_multiple_index_groups`, for +# example. The latter are defined later on with `partial`. +def _get_groups( + config: ParamMap, + belongs_to_group: Callable[[Sequence[str]], bool], + make_param_name: Callable[[Sequence[str]], tuple[str, str]], + rejoin_parts: Callable[[Sequence[str]], str], + minimum: int = 2, + reference: bool = True, +) -> GroupDict: + """ + Identify expandable parameter groups - main engine function. + + Parameters + ---------- + config : dict + The configuration file, where keys are the parameter names. + + belongs_to_group : callable + A callable receiving the parameter name after str.split("_") + that returns a boolean identifying if the parameter belongs a + given expadanble group. + + make_param_name : callable + Recreates the parameter preffix from the parameter parts. + + rejoin_parts : callable + Recreates the parameter name from the parts. For example: + `something_else` in `param_something_else_1`. + + minimum : int + Consider only the groups with at least `minimum` parameters. + + reference : bool + Whether reading a default config file or not. If true, only + groups ending with "1" will be considered. This avoids capturing + parameters for molecules, such as "mol_fix_origin_1", + "mol_fix_origin_2", etc. + """ + splitted = (parameter.split("_") for parameter in config) + parts = (_parts for _parts in splitted if belongs_to_group(_parts)) + + # identify groups in config + groups: GroupDict = {} + for p in parts: + group_identity = make_param_name(p) # ("param", "1") + + new = groups.setdefault(group_identity, {}) + + # counts the number of parameters within the block + new.setdefault("counts", 0) + new["counts"] += 1 + + # registers the parameters belonging to the group + new.setdefault("mid", set()) + new["mid"].add(rejoin_parts(p)) + + if reference: + groups = remove_ghost_groups(groups) + + # creates the final dictionary + final_groups = {k: v["mid"] for k, v in groups.items() if v["counts"] >= minimum} + + return final_groups + + +def remove_ghost_groups(groups: GroupDict) -> GroupDict: + """ + Remove ghost groups from dictionary. + + Ghost groups are parameters that are defined in the defaults + in a manner that they look they are already expanded. For example: + + - mol_shape_1 + - mol_shape_2 + - mol_shape_3 + - mol_fix_origin_1 + - mol_fix_origin_2 + - mol_fix_origin_3 + + These integer suffix refer to the input molecules and not to + expandable groups. + + Parameters + ---------- + groups : dict + A dictionary containing the groups. For example as those created + by `get_single_index_groups`. + """ + counter: dict[str, int] = {} + for key in groups: + counter.setdefault(key[0], 0) + counter[key[0]] += 1 + + new_groups = deepcopy(groups) + + for key, value in counter.items(): # type: ignore + if value > 1: + for gk in groups.keys(): + if gk[0] == key: + new_groups.pop(gk) + + return new_groups + + +# this is an engine function that must be populated with the respective +# functions the specify its behaviour. This engine is used in +# `read_single_idx_groups_user_config` and +# `read_multiple_idx_groups_user_config`, for example. The latter are +# defined later on with `partial`. +def _read_groups_in_user_config( + user_config: Iterable[str], + default_groups: GroupDict, + get_user_groups: Callable[..., GroupDict], + extract_params: Callable[..., set[str]], + _emsg_no_group: str = "Parameter block is not a valid expandable group", + _emsg_unexpected_params: str = "Unexpected params for group", +) -> tuple[set[str], dict[str, int]]: + """ + Read groups in user config. + + This is an engine-like function that serves the different expandable + parameter rules. This function should be parametrized with the correct + functions that provide functionality. See `get_` and `read_` functions + defined in this module. + + Parameters + ---------- + user_config : dict + The user configuration dictionary. + + default_groups : dict + The groups present in the default configuration file for the + specific module. This dictionary is that created by, + `get_single_index_groups`, or `get_multiple_index_groups`. + + get_user_groups : callable + A function to extract groups from a parameter dictionary. + See `get_single_index_groups` and `get_multiple_index_groups`. + + extract_params : callable + A function to extract parameters from a parameter dictionary + according to the selected group. See `extract_single_index_params`, + `extract_multiple_index_params`. + + Returns + ------- + new : set[str] + A set with the new parameters in the user configuration file + that are acceptable according to the expandable rules. + param_name_counts : dict[str, int] + Count of expendable parameter parameter names + """ + # minimum=1 is used to capture groups with missing parameters + user_groups = get_user_groups(user_config, minimum=1, reference=False) + default_group_names = set(group[0] for group in default_groups) + + new: set[str] = set() + param_name_counts: dict[str, int] = {} + for (param_name, group_idx), params in user_groups.items(): + if param_name not in default_group_names: + emsg = _emsg_no_group.format(param_name, group_idx) + raise ConfigurationError(emsg) + + default_key = (param_name, "1") + expected_params = default_groups[default_key] + diff = params.difference(expected_params) + if diff: + emsg = _emsg_unexpected_params.format( + param_name, + group_idx, + ", ".join(diff), + ) + raise ConfigurationError(emsg) + + num_found = len(params) + num_expected = len(expected_params) + + # it should only trigger when num_found < num_expected + # when num_found > num_expected the error about in `diff` is + # triggered instead + if num_found != num_expected: + expected_missings = set(expected_params).difference(params) + emsg = _emsg_num_differ.format( + param_name, + num_expected, + ", ".join(expected_params), + num_found, + ", ".join(params), + ", ".join([f"`{p}`" for p in expected_missings]), + ) + raise ConfigurationError(emsg) + + related_params = extract_params(user_config, param_name, group_idx) + # Increment counts for this parameter + if related_params: + param_name_counts.setdefault(param_name, 0) + param_name_counts[param_name] += 1 + new.update(related_params) + return new, param_name_counts + + +def read_simplest_expandable( + config: Iterable[str], expparams: Iterable[str], +) -> set[str]: + """ + Read expandable parameters from config file of the type `param_1`. + + Parameters + ---------- + config : dict, dict.keys, set, or alike + The user configuration file. + expparams : dict, dict.keys, set, or alike + The parameter names that should be considered as expandable. + Usually, this is a module subdictionary of `type_simplest_ep`. + + Returns + ------- + set of str + The parameters in `config` that comply with `expparams`. + """ + new: set[str] = set() + for param in config: + try: + name, idx = param.split("_") + except ValueError: + continue + if idx.isdigit() and name in expparams: + new.add(param) + return new + + +def get_mol_parameters(config: Iterable[str]) -> set[str]: + """Identify expandable `mol` parameters.""" + return set(param for param in config if is_mol_parameter(param)) + + +def is_mol_parameter(param: str) -> bool: + """Identify if a parameter is a `mol` parameter.""" + parts = param.split("_") + return param.startswith("mol_") and parts[-1].isdigit() and len(parts) > 2 + + +def read_mol_parameters( + user_config: ParamMap, + default_groups: Iterable[str], + max_mols: int = max_molecules_allowed, +) -> set[str]: + """ + Read the mol parameters in the user_config following expectations. + + Parameters + ---------- + user_config : dict + The user configuration dictionary. + + default_groups : dict or set. + The mol parameters present in the default configuration file for + the specific module. These are defined by `get_mol_parameters`. + + max_mols : int + HADDOCK3 has a limit in the number of different molecules it + accepts for a calculation. Expandable parameters affecting molecules + should not be allowed to go beyond that number. Defaults to + `core.default.max_molecules_allowed`. + + Returns + ------- + set + The allowed parameters according to the default config and the + max allowed molecules. + """ + # removes the integer suffix from the default mol parameters + default_names = [remove_trail_idx(p) for p in default_groups] + + new: set[str] = set() + for param in get_mol_parameters(user_config): + param_name = remove_trail_idx(param) + param_idx = param.split("_")[-1] + if param_name in default_names and int(param_idx) <= max_mols: + new.add(param) + return new + + +def remove_trail_idx(param: str) -> str: + """ + Remove the trailing integer from a parameter. + + If trail is defined by an underscore "_". + + Examples + -------- + remove_trail_idx('some_parameter_1') + >>> 'some_parameter' + + remove_trail_idx('some_parameter') + >>> 'some_parameter' + + remove_trail_idx('parameter') + >>> 'parameter' + + Parameters + ---------- + param : str + A parameter name. + """ + under_parts = param.rpartition("_") + if under_parts[2].isdigit(): + return under_parts[0] + return param + + +def get_trail_index(param: str) -> Optional[str]: + """ + Get the trail index if underscored. + + Examples + -------- + has_trail_index('some_parameter_1') + >>> '1' + + has_trail_index('some_parameter1') + >>> None + + has_trail_index('some_parameter_1_1') + >>> '1' + + has_trail_index('some_parameter_1-1') + >>> None + + has_trail_index('some_parameter') + >>> None + + Parameters + ---------- + param : str + A parameter name. + + Returns + ------- + str or None + The trail index if exist. ``None`` if not found. + """ + under_parts = param.rpartition("_") + if under_parts[2].isdigit(): + return under_parts[2] + return None + + +def make_param_name_single_index(param_parts: Sequence[AnyT]) -> tuple[AnyT, AnyT]: + """ + Make the key name from param parts. + + For example, ("param", "tag", "1") -> ("param", "1"). + """ + return (param_parts[0], param_parts[-1]) + + +def make_param_name_multiple_index( + param_parts: Sequence[SupportsAddT], +) -> tuple[SupportsAddT, SupportsAddT]: + """ + Make the key name from param parts. + + For example, ("param", "tag", "2", "1") -> ("param2", "1"). + """ + return (param_parts[0] + param_parts[-2], param_parts[-1]) + + +def belongs_to_single_index(param_parts: Sequence[str]) -> bool: + """ + Assert param belong to single index group. + + Parameters + ---------- + param_parts : list of str + The parameter name parts after `str.split("_")`. + + Returns + ------- + boolean + True if the parameter name follows the rules of single index + expandable parameters. + + Rules: + - param names have more than 2 parts + - the last part is a digit + - the part before last is not a digit + """ + return ( + len(param_parts) > 2 + and param_parts[-1].isdigit() + and not param_parts[-2].isdigit() + and not param_parts[0].startswith("mol") + ) + + +def belongs_to_multiple_index(param_parts: Sequence[str]) -> bool: + """ + Assert param belong to multiple index group. + + Parameters + ---------- + param_parts : list of str + The parameter name parts after `str.split("_")`. + + Returns + ------- + boolean + True if the parameter name follows the rules of multiple index + expandable parameters. + + Rules: + - param names have more than 4 parts + - the last part is a digit + - the part before last is a digit + """ + return ( + len(param_parts) >= 4 + and param_parts[-1].isdigit() + and param_parts[-2].isdigit() + and not param_parts[0].startswith("mol") + ) + + +def rejoin_parts_single_index(param_parts: Sequence[str]) -> str: + """Join parameter name parts.""" + return "_".join(param_parts[1:-1]) + + +def rejoin_parts_multiple_index(param_parts: Sequence[str]) -> str: + """Join parameter name parts.""" + return "_".join(param_parts[1:-2]) + + +def extract_single_index_params( + user_config: Iterable[str], param_name: str, group_idx: str +) -> set[str]: + """ + Extract the parameters belonging to a group. + + Descriminates between parameters of other expandable groups. + See: `belongs_to_single_index`. + + Examples + -------- + >>> ES = extract_single_index_params + + >>> ES({"param_some_1", "param_other_1", "param2", "ppp_ooo"}, "param", "1") + {"param_some_1", "param_other_1"} + + >>> ES( + {"param_some_1", "param_other_1", "param_some_2", "param_other_2"}, + "param", "2") + {"param_some_2", "param_other_2"} + + >>> ES( + {"param_some_1", "param_other_1", "par_some_2_2", "par_other_2_2"}, + "param", "1") + {"param_some_1", "param_other_1"} + + >>> ES( + {"param_some_1", "param_other_1", "par_some_2_2", "par_other_2_2"}, + "par", "2") + set() + + >>> ES( + {"param_some_1", "param_other_1", "par_some_2_2", "par_other_2_2"}, + "por", "2") + set() + + Parameters + ---------- + user_config : dict, or dict.keys(), or similar + The user configuration file - parameter keys should be parameter + names. + + param_name : str + The parameter name of the group to select. For example: `c3sym`. + + group_idx : str + The number of the group: "1", "2", "3", etc. Only that group + number will be selected. + + Returns + ------- + set of strings + A set with the selected parameters. + """ + new: set[str] = set() + for param in user_config: + parts = param.split("_") + try: + pname, *_, pidx = parts + except ValueError: + continue + if pname == param_name and pidx == group_idx and belongs_to_single_index(parts): + new.add(param) + return new + + +def extract_multiple_index_params( + user_config: Iterable[str], param_name: str, group_idx: str +) -> set[str]: + """ + Extract the parameters belonging to a group. + + See also: `belongs_to_multiple_index`. + + Examples + -------- + >>> EM = extract_multiple_index_params + + >>> EM({"param_some_1", "param_other_1", "param2", "ppp_ooo"}, "param", "1") + set() + + >>> EM( + {"param_some_1", "param_other_1", "param_some_2", "param_other_2"}, + "param", "2") + set() + + >>> EM( + {"param_some_1", "param_other_1", "par_some_2_2", "par_other_2_2"}, + "param", "1") + {"par_some_2_2", "par_other_2_2"}, + + >>> EM( + {"param_some_1", "param_other_1", "par_some_2_2", "par_other_2_2"}, + "par", "2") + set() + + >>> EM( + {"param_some_1", "param_other_1", "par_some_2_2", "par_other_2_2"}, + "por", "2") + set() + + Parameters + ---------- + user_config : dict, or dict.keys(), or similar + The user configuration file - parameter keys should be parameter + names. + + param_name : str + The parameter name of the group to select. For example: `c3sym`. + + group_idx : str + The number of the group: "1", "2", "3", etc. Only that group + number will be selected. + + Returns + ------- + set of strings + A set with the selected parameters. + """ + new: set[str] = set() + for param in user_config: + parts = param.split("_") + try: + pname, *_, molidx, pidx = parts + except ValueError: + continue + if ( + pname + molidx == param_name + and pidx == group_idx + and belongs_to_multiple_index(parts) + ): + new.add(param) + return new + + +# define public API by functionalizing the engines with the specific +# functions. The docstring below is the docstring of the function. +get_single_index_groups = partial( + _get_groups, + belongs_to_group=belongs_to_single_index, + make_param_name=make_param_name_single_index, + rejoin_parts=rejoin_parts_single_index, +) +""" +Get single indexed blocks from a configuration. + +Block parameters follow the rule __. + +These belong to the same parameter (`param`) of the group `1`: + +- param_something1_1 +- param_something2_1 +- param_something_else_1 +- param_something4_1 + +You could expand these with: + +- param_something1_2 +- param_something2_2 +- param_something_else_2 +- param_something4_2 + +When used to read the modules' default configuration we expect the + to be only "_1". But having allows to identify +blocks from the user configuration. See `reference` parameter. + +When we execute this function, we want to know: + +- param, the parameter name preffix +- how many parameters exist of the block (`something1`, `something2`, ...) +- _1, defines the number of the block + +Returns a dictionary in the form of:: + + { + ("param", "1"): { + "something1", "something2", + "something_else", "something4" + }, + ("otherparam", "1"): {"somename", "othername"}, + } + +Parameters +---------- +config : dictionary + Where keys are the parameter names. The values are not important. + +minimum : int + Consider only the groups with at least `minimum` parameters. + +reference : bool + Whether reading a default config file or not. If true, only + groups ending with "1" will be considered. This avoids capturing + parameters for molecules, such as "mol_fix_origin_1", + "mol_fix_origin_2", etc. + +Returns +------- +dictionary - {tuple: dict} +""" + +get_multiple_index_groups = partial( + _get_groups, + belongs_to_group=belongs_to_multiple_index, + make_param_name=make_param_name_multiple_index, + rejoin_parts=rejoin_parts_multiple_index, +) +""" +Get parameter blocks with multiple indexes. + +These blocks of params apply, for example, to different molecules. +That's why they have two looping indexes: one for the molecule and +other for the group. + +This block of parameters follow the rule: + +___ + +Where the actual param name is `paramN`, where `N` is an integer. + + be can any combination of alphanumeric chars and +underscores. + + is the number of the group, the will be incremented as we +expand. + +These belong to the same parameter (`param1`) of the group `1`: + +- param_something_1_1 +- param_something2_1_1 +- param_something_else_1_1 +- param_something4_1 + +You could expand these with: + +- param_something_1_2 +- param_something2_1_2 +- param_something_else_1_2 +- param_something4_2 + +When used to read the modules' default configuration we expect the + to be only "_1". But having allows to identify +blocks from the user configuration. + +Returns a dictionary in the form of:: + + {("param1", "1"): { + "something1", "something2", "something_else", "something4"} + +Parameters +---------- +config : dict + Where keys are the parameter names. The values are not important. + +minimum : int + Consider only the groups with at least `minimum` parameters. + +reference : bool + Whether reading a default config file or not. If true, only + groups ending with "1" will be considered. This avoids capturing + parameters for molecules, such as "mol_fix_origin_1", + "mol_fix_origin_2", etc. + +Returns +------- +dictionary : {(tuple): dict} +""" + +read_single_idx_groups_user_config = partial( + _read_groups_in_user_config, + get_user_groups=get_single_index_groups, + extract_params=extract_single_index_params, + _emsg_no_group=_emsg_no_group_single, + _emsg_unexpected_params=_emsg_unexpected_params_single, +) +""" +Read single indexed groups in user config. + +Parameters +---------- +user_config : dict + The user configuration dictionary. + +default_groups : dict + The groups present in the default configuration file for the + specific module. This is the dictionary created by, + `get_single_index_groups`. + +Returns +------- +set + A set with the new parameters in the user configuration file + that are acceptable according to the expandable rules. +""" + +read_multiple_idx_groups_user_config = partial( + _read_groups_in_user_config, + get_user_groups=get_multiple_index_groups, + extract_params=extract_multiple_index_params, + _emsg_no_group=_emsg_no_group_multiple, + _emsg_unexpected_params=_emsg_unexpected_params_multiple, +) +""" +Read multiple indexed groups in user config. + +Parameters +---------- +user_config : dict + The user configuration dictionary. + +default_groups : dict + The groups present in the default configuration file for the + specific module. This is the dictionary created by + `get_multiple_index_groups`. + +Returns +------- +set + A set with the new parameters in the user configuration file + that are acceptable according to the expandable rules. +""" + + +def populate_mol_parameters_in_module( + params: ParamMap, num_mols: int, defaults: ParamMap +) -> None: + """ + Populate parameters dictionary with the needed molecule `mol_` parameters. + + The `mol_` prefixed parameters is a subclass of the expandable parameters. + + See :py:mod:`haddock.gear.expandable_parameters`. + + Modules require these parameters to be repeated for the number of input + molecules. + + This function adds `mol_` parameters to the user input parameters, + one per each `molecule` and for those which a values has not been + added yet. + + Parameters + ---------- + modules_params : dict + A dictionary of parameters. + + Returns + ------- + None + Alter the dictionary in place. + """ + # filter to get only the `mol_` parameters that are defaults + # the get_trail_index is needed because defaults only have the '1' + # suffixed parameters. + mol_params = ( + p + for p in list(params.keys()) + if is_mol_parameter(p) and get_trail_index(p) == "1" + ) + + for param, i in it.product(mol_params, range(1, num_mols + 1)): + param_name = remove_trail_idx(param) + params.setdefault(f"{param_name}_{i}", defaults[param]) + + return diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/gear/extend_run.py b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/extend_run.py new file mode 100644 index 0000000000000000000000000000000000000000..2a9ed9d57ccc9c89ba7176d3c7d493485404ed8a --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/extend_run.py @@ -0,0 +1,283 @@ +"""Gear for ``haddock3-copy`` CLI and `--extend-run`` flag.""" +import shutil +from pathlib import Path + +from haddock import log +from haddock.core.defaults import MODULE_IO_FILE +from haddock.core.exceptions import HaddockTermination +from haddock.core.typing import ( + Any, + ArgumentParser, + FilePath, + FilePathT, + Iterable, + ModuleParams, + Optional, + ) +from haddock.gear.clean_steps import UNPACK_FOLDERS, clean_output +from haddock.gear.zerofill import zero_fill +from haddock.libs.libontology import ModuleIO +from haddock.libs.libtimer import log_time +from haddock.libs.libworkflow import Workflow, WorkflowManager +from haddock.modules import get_module_steps_folders + + +EXTEND_RUN_DEFAULT = None + + +class WorkflowManagerExtend(WorkflowManager): + """Workflow to extend a run.""" + + def __init__(self, + workflow_params: ModuleParams, + start: Optional[int] = 0, + **other_params: Any) -> None: + self.start = start + self.recipe = Workflow(workflow_params, start=start, **other_params) + # terminate is used to synchronize the `clean` option with the + # `exit` module. If the `exit` module is removed in the future, + # you can also remove and clean the `terminate` part here. + self._terminated = 0 + + def run(self) -> None: + """High level workflow composer.""" + for i, step in enumerate(self.recipe.steps, start=0): + try: + step.execute() + except HaddockTermination: + self._terminated = i + break + + def clean(self) -> None: + """Clean the step output.""" + # return compression to the original state + cwd = Path.cwd().name + + # because this WorkflowManagerExtended has no direct access to the + # ncores parameters, it needs to take it from the steps. + ncores: int = max(s.config["ncores"] for s in self.recipe.steps) + + for folder in UNPACK_FOLDERS: + # temporary hack to get the step folder name. + # ensures we can work under the CLI working directory + # or inside the run dir. + folder_ = str(folder).split(cwd)[1][1:] + + log.info( + f'Compressing original folder: {folder_!r} because it ' + 'was originally compressed.' + ) + + with log_time("cleaning output files took"): + clean_output(folder_, ncores) + + # apply compression to the new modules + super().clean(terminated=self._terminated) + + +def add_extend_run(parser: ArgumentParser) -> None: + """Add option to ``--extend-run``.""" + parser.add_argument( + '--extend-run', + help=( + "Start a run from a run directory previously prepared with " + "the `haddock3-copy` CLI. Provide the run directory created " + "with `haddock3-copy` CLI." + ), + default=EXTEND_RUN_DEFAULT, + type=Path, + ) + + +def read_num_molecules_from_folder(folder: FilePath) -> int: + """ + Read the number of molecules from the first step folder. + + 1. Find the lower indexed step folder in `folder`. + 2. Read the `io.json` file. + 3. Count the number of items in the "output" key. + 4. The above is the number of molecules. + + Parameters + ---------- + folder : Path or string + The run directory. + + Returns + ------- + int + The number of molecules found. + """ + parent = Path(folder).resolve() + previous = get_module_steps_folders(folder) + + io = ModuleIO() + previous_io = Path(parent, previous[0], MODULE_IO_FILE) + io.load(previous_io) + + return len(io.output) + + +def copy_renum_step_folders(indir: FilePath, destdir: FilePath, + steps: list[FilePathT]) -> list[Path]: + """ + Copy step folders renumbering them sequentially in the run directory. + + The content of the files is not modified. + See :py:func:`rename_step_contents`. + + py:`gear.zerofill.zero_fill`: must be previously calibrated. + + Example + ------- + >>> steps = ['0_topoaa', '4_flexref'] + >>> zero_fill.set_zerofill_number(len(steps)) + >>> copy_renum_step_folders('run1', 'newrun', steps) + + The initial structure:: + + run1/ + 0_topoaa/ + 1_rigidbody/ + 2_caprieval/ + 3_seletop/ + 4_flexref/ + (etc...) + + Results in:: + + newrun/ + 0_topoaa/ + 1_flexref/ + + Parameters + ---------- + indir : str or Path + The input directory where the original steps reside. + + destdir : str or Path + The output directory where to copy the steps to. + + steps : list of (str or Path) + The list of the folder names in `indir` to copy. + + Returns + ------- + list + The new paths created. + """ + new_steps: list[Path] = [] + step_names = (Path(step).name for step in steps) + for i, step in enumerate(step_names): + ori = Path(indir, step) + _modname = step.split("_")[-1] + dest = Path(destdir, zero_fill.fill(_modname, i)) + shutil.copytree(ori, dest) + log.info(f"Copied {str(ori)} -> {str(dest)}") + new_steps.append(dest) + return new_steps + + +def renum_step_folders(folder: FilePath) -> tuple[list[str], list[str]]: + """ + Renumber the step folders sequentially in the run directory. + + The content of the files is not modified. + + See :py:func:`rename_step_contents`. + + Example + ------- + + The initial structure:: + + folder/ + 0_topoaa/ + 4_flexref/ + + Results in:: + + folder/ + 0_topoaa/ + 1_flexref/ + + Returns + ------- + list + The list of the original step folder names. + + list + The list of the new step folder names. + """ + # these come sorted already + step_folders = get_module_steps_folders(folder) + new_names: list[str] = [] + + # move folders + for i, sf in enumerate(step_folders): + mod_name = sf.split("_")[-1] + new_name = zero_fill.fill(mod_name, i) + new_names.append(new_name) + shutil.move(Path(folder, sf), Path(folder, new_name)) + + return step_folders, new_names + + +def update_contents_of_new_steps(selected_steps: Iterable[str], + olddir: FilePath, newdir: FilePath) -> None: + """ + Find-replace run references in step folders files. + + Find and replaces (updates) all references to step folders and to + the old run directory in all files of selected step folders. + + Example + ------- + >>> update_contents_of_new_steps( + ['0_topoaa', '1_rigidbody'], + 'run1', + 'run2', + ) + + Parameters + ---------- + selected_steps : list of str + The names of the original step folder names that to find in the + new step folders. This function uses + :py:func:`haddock.modules.get_module_steps_folders` to find + the new step folders. ``selected_steps`` must be synchronized + with the new folders; that is, the names in ``selected_steps`` + must be the old names of the new step folders. + + olddir : str or Path + The original run directory to be replaced by `newdir`. + + newdir : str or Path + The new run directory. + + Returns + ------- + None + Save files in place. + + See Also + -------- + :py:func:`haddock.gear.prepare_run.update_step_contents_to_step_names` + """ + olddir = Path(olddir) + newdir = Path(newdir) + new_steps = get_module_steps_folders(newdir) + for ns in new_steps: + new_step = Path(newdir, ns) + for file_ in new_step.iterdir(): + try: + text = file_.read_text() + except UnicodeDecodeError as err: + log.warning(f"Failed to read file {file_}. Error is {err}") + continue + for s1, s2 in zip(selected_steps, new_steps): + text = text.replace(s1, s2) + text = text.replace(olddir.name, newdir.name) + file_.write_text(text) + + log.info("File references updated correctly.") diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/gear/greetings.py b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/greetings.py new file mode 100644 index 0000000000000000000000000000000000000000..b6de6c9ed3e8735abfa1a807dd9e9d8030ee0fd1 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/greetings.py @@ -0,0 +1,116 @@ +"""Greeting messages for the command line clients.""" + +import os +import random +import sys +from datetime import datetime +from functools import partial +from typing import Callable, Sequence + +from haddock import contact_us, version + + +international_good_byes = [ + "Adéu-siau", + "Agur", + "Até logo", + "Au revoir", + "Ciao", + "Dovidenia", + "Good bye", + "Tot ziens", + "La revedere", + "Adiós", + "Do pobachennya", + "Tchau", + "再见", + "Hoşça kal", + "Slán", + "Do widzenia", + "Mandi", + "Αντίο", + "Auf Wiedersehen", +] + +# List of urls to be printed to the screen at the end of a workflow +# Do not hesitate to update / comment one of these +feedback_urls = { + "GitHub issues": "https://github.com/haddocking/haddock3/issues", + "BioExcel feedback": "https://www.bonvinlab.org/feedback", + "BioExcel forum": "https://ask.bioexcel.eu/c/haddock/6", + "Haddock3 user manual": "https://www.bonvinlab.org/haddock3-user-manual/", +} + + +DISCLAIMER = ( + "!! Some of the HADDOCK3 components use CNS (Crystallographic and NMR System)" + f" which is free of use for non-profit applications. !!{os.linesep}" + "!! For commercial use it is your own responsibility" + f" to have a proper license. !!{os.linesep}" + "!! For details refer to the DISCLAIMER file in the HADDOCK3 repository. !!" +) + + +def get_initial_greeting() -> str: + """Create initial greeting message.""" + now = datetime.now().replace(second=0, microsecond=0) + python_version = sys.version + message = ( + f"""{os.linesep}""" + f"""##############################################{os.linesep}""" + f"""# #{os.linesep}""" + f"""# HADDOCK3 #{os.linesep}""" + f"""# #{os.linesep}""" + f"""##############################################{os.linesep}""" + f"""{os.linesep}""" + f"""{DISCLAIMER}{os.linesep}""" + f"""{os.linesep}""" + f"""Starting HADDOCK3 v{version} on {now}{os.linesep}""" + f"""{os.linesep}""" + f"""Python {python_version}{os.linesep}""" + ) + return message + + +def get_greetings( + options: Sequence[str], how_many: int = 3, sep: str = " ", exclamation: str = "!" +) -> str: + """Get greeting messages.""" + n = how_many % len(options) + return sep.join(s + exclamation for s in random.sample(options, k=n)) + + +def get_adieu() -> str: + """Create end-run greeting message.""" + end = datetime.now().strftime("%d/%m/%Y %H:%M:%S") + bye = get_goodbye_greetings() + message = f"Finished at {end}. {bye}" + return message + + +def get_goodbye_help() -> str: + """Create good-bye message with help.""" + end = datetime.now().strftime("%d/%m/%Y %H:%M:%S") + bye = get_goodbye_greetings() + message = f"Finished at {end}. For any help contact us at {contact_us}." + message += f" {bye}." + return message + + +def gen_feedback_messages(print_function: Callable) -> None: + """Print list of feedbacks urls. + + Parameters + ---------- + print_function : Callable + The function used to print message on screen. + This function must accept str as first argument. + """ + print_function( + ("Your feedback matters in Haddock3! Share your experience and help us grow:") + ) + for name, url in feedback_urls.items(): + print_function(f"{name}: {url}") + + +get_goodbye_greetings = partial(get_greetings, international_good_byes) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/gear/haddockmodel.py b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/haddockmodel.py new file mode 100644 index 0000000000000000000000000000000000000000..8f02c38807384d62579b00732ac08210c7224401 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/haddockmodel.py @@ -0,0 +1,155 @@ +"""Represent an Haddock model.""" + +from haddock.core.typing import FilePath + + +class HaddockModel: + """Represent HADDOCK model.""" + + def __init__(self, pdb_f: FilePath) -> None: + remarks = self._load_remarks(pdb_f) + self.energies = self._load_energies(remarks) + self.interface_energies = self._load_per_interface_energies(remarks) + + @staticmethod + def _load_remarks(pdb_f: FilePath) -> list[str]: + """Load remark lines from PDB file + + Parameters + ---------- + pdb_f : FilePath + Path to a PDB file + + Returns + ------- + remarks : list[str] + List of PDB lines containing remarks. + """ + remarks: list[str] = [] + with open(pdb_f) as fh: + for line in fh.readlines(): + if line.startswith('REMARK'): + remarks.append(line) + return remarks + + @staticmethod + def _load_energies(remarks: list[str]) -> dict[str, float]: + """Load HADDOCK energy terms from PDB remarks. + + Parameters + ---------- + remarks : list[str] + List of PDB lines containing remarks. + + Returns + ------- + energy_dic : dict[str, float] + Dictionary of energy terms with their values + """ + energy_dic: dict[str, float] = {} + for line in remarks: + # TODO: use regex to do this + if 'energies' in line: + energy_values = map( + float, + line.rstrip().split(':')[-1].split(',') + ) + total, bonds, angles, improper, dihe, vdw, elec, air, cdih, coup, rdcs, vean, dani, xpcs, rg = energy_values # noqa: E501 + energy_dic['total'] = total + energy_dic['bonds'] = bonds + energy_dic['angles'] = angles + energy_dic['improper'] = improper + energy_dic['dihe'] = dihe + energy_dic['vdw'] = vdw + energy_dic['elec'] = elec + energy_dic['air'] = air + energy_dic['cdih'] = cdih + energy_dic['coup'] = coup + energy_dic['rdcs'] = rdcs + energy_dic['vean'] = vean + energy_dic['dani'] = dani + energy_dic['xpcs'] = xpcs + energy_dic['rg'] = rg + if 'buried surface area' in line: + bsa = float(line.rstrip().split(':')[-1]) + energy_dic['bsa'] = bsa + if 'Desolvation energy' in line: + desolv = float(line.rstrip().split(':')[-1]) + energy_dic['desolv'] = desolv + if 'Symmetry energy' in line: + sym = float(line.rstrip().split(':')[-1]) + energy_dic['sym'] = sym + + return energy_dic + + @staticmethod + def _load_per_interface_energies( + remarks: list[str], + ) -> dict[str, dict[str, float]]: + """Read a pdb file and parse per interface scores. + + Parameters + ---------- + remarks : list[str] + List of PDB lines containing remarks. + + Returns + ------- + interfaces_scores : dict[str, dict[str, float]] + Dictionary holding per interfaces scores. + """ + header = None + interfaces_scores: dict[str, dict[str, float]] = {} + for _ in remarks: + if _.startswith("REMARK Interface"): + s_ = _.strip().split()[2:] + # Extract header + if not header: + header = s_ + # Extract data + else: + chain1 = s_[header.index("Chain1")] + chain2 = s_[header.index("Chain2")] + haddockscore = float(s_[header.index("HADDOCKscore")]) + evdw = float(s_[header.index("Evdw")]) + eelec = float(s_[header.index("Eelec")]) + edesol = float(s_[header.index("Edesol")]) + bsa = float(s_[header.index("BSA")]) + # Combine chains together + chains_key = f"{chain1}_{chain2}" + # Hold data + interfaces_scores[chains_key] = { + "HADDOCKscore": haddockscore, + "vdw": evdw, + "elec": eelec, + "desolv": edesol, + "bsa": bsa, + } + return interfaces_scores + + def calc_haddock_score(self, **weights: float) -> float: + """Calculate the haddock score based on the weights and energies.""" + return self.calc_score(self.energies, **weights) + + @staticmethod + def calc_score(energies: dict[str, float], **weights: float) -> float: + """Compute sum of weighted energy terms. + + Parameters + ---------- + energies : dict[str, float] + Dict of energy values for each energy term + + Returns + ------- + weighted_score : float + Sum of weighted energy terms + """ + weighted_score: float = 0.0 + for weight_name, weight_value in weights.items(): + component_id = weight_name.split("_")[1] + try: + weighted_score += energies[component_id] * weight_value + except KeyError: + continue + return weighted_score diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/gear/known_cns_errors.py b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/known_cns_errors.py new file mode 100644 index 0000000000000000000000000000000000000000..6335895f491458bb95086eb3a097e6fef40c51d9 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/known_cns_errors.py @@ -0,0 +1,183 @@ +"""Detect known/common CNS errors. + +Inspired from: +https://github.com/haddocking/haddock25/blob/main/tools/check-error-messages.sh +""" + +import gzip +from io import BufferedReader +from pathlib import Path + +from haddock.core.exceptions import KnownCNSError +from haddock.core.typing import FilePath, Optional, Union + +# Dictionary of known errors +# as key: How to catch it in the cns.cnserr +# as value: Message to user +KNOWN_ERRORS = { + "CHAIN LENGTH FOR SYMMETRY RESTRAINTS DOES NOT MATCH": ( + "Mismatch between chain length for symmetry restraints. " + "Check your input molecules and symmetry restraints." + ), + "NCS-restraints error encountered: Improperly defined non-crystallographic symmetry": ( # noqa : E501 + "Improperly defined non-crystallographic symmetry (NCS). " + "Check your symmetry restraints definition." + ), + "error in SYMMETRY potential, check NOE table": ( + "Check your symmetry restraints definition." + ), + "exceeded allocation for NOE-restraints": ( + "Too many distance restraints defined. " + "Try to reduce this number by checking your definition of active " + "and passive residues. " + "Make sure to filter those for solvent accessibility. " + "Or alternatively increase the nres parameter in the noe statements" + " in the relevant CNS scripts." + ), + "SELRPN error encountered: parsing error": ( + "Check your restraint files." + ), + "PARSER error encountered: Encountered too many parsing errors": ( + "Encountered too many parsing errors. " + "Check your input molecules and symmetry restraints." + ), + "XMREAD error encountered: sectioning of map incompatible with resolution": ( # noqa : E501 + "Check your EM map resolution and sectioning." + ), + "ALLHP error encountered: not enough memory available": ( + "Too many distance restraints defined. " + "Try to reduce this number by checking your definition of active and " + "passive residues. " + "Make sure to filter those for solvent accessibility. " + "Try to decrease the size of your system where possible." + ), + "error encountered: missing SCATter definition for SELEcted atoms": ( + "Unsupported atoms/molecules for cryo-EM restraints." + ), + "ROTMAT error encountered: rotation vector has zero length": ( + "Check your input parameters and restraints. " + "Possibly try turning off the sampling of 180 degrees rotation." + ) + } + + +def find_cns_errors(cns_out_fpath: FilePath) -> Optional[KnownCNSError]: + """Detect if a known CNS error is in a cns.cnserr file. + + Parameters + ---------- + cns_out_fpath : FilePath -> Union[str, Path] + Path to the cns.cnserr file to check. + + Returns + ------- + Optional[KnownCNSError] + An exception for known CNS errors, with its hint on how to solve it! + """ + # Check for file extension to open it the appropriate way + if Path(cns_out_fpath).suffix == ".gz": + file_handle = gzip.open(cns_out_fpath, "rb") + else: + file_handle = open(cns_out_fpath, "rb") + # Read the file + try: + _find_cns_errors(file_handle, KNOWN_ERRORS, filepath=cns_out_fpath) + except KnownCNSError as err: + return err + else: + # return the cause + return KnownCNSError( + "An unfortunate CNS error occured at exection time...", + f"Manually check the file `{cns_out_fpath}` to understand why!", + cns_out_fpath, + ) + + +def _find_cns_errors( + file_handle: Union[gzip.GzipFile, BufferedReader], + known_errors: dict[str, str], + chunk_size: int = 4096, + filepath: FilePath = "", + ) -> None: + """Backward reading and detect first known CNS error in file. + + Parameters + ---------- + file_handle: Union[gzip.GzipFile, BufferedReader] + An opened file in read bytes mode. + known_errors : dict[str, str] + Dict of known errors and their hints + chunk_size : int, optional + Check size (in bytes) to read the file backwards, by default 4096 + filepath : FilePath -> Union[str, Path] + Path to the cns.cnserr file currently checked. + + Raises + ------ + KnownCNSError + An exception for known CNS errors, with its hint on how to solve it! + """ + # Find file size + file_handle.seek(0, 2) + size = file_handle.tell() + buffer = b'' + # Set the number of lines to parse + # initiated with high value to read all lines the first time + # updated to the number of lines that were already parsed + # after each chunk iteration, so we do not parse the same lines + parsed_lines = 99999 + for i in range(size - 1, -1, -chunk_size): + # Go to location in file + file_handle.seek(max(i - chunk_size, 0)) + # Read next chunk + chunk = file_handle.read(min(chunk_size, i + 1)) + # Increment buffer + buffer = chunk + buffer + lines = buffer.split(b'\n') + # Read lines + for line in reversed(lines[-len(lines):parsed_lines]): + decoded_line = line.decode('utf-8', errors='replace') + # Loop over known errors + for error_string, hint in known_errors.items(): + # Check if this error is known + if error_string in decoded_line: + # return the cause + raise KnownCNSError( + error_string, + hint, + filepath, + ) + # Update number of parsed lines so we do not check them again + parsed_lines = -len(lines) + + +def find_all_cns_errors( + directory_path: FilePath, + ) -> dict[str, dict[str, Union[int, KnownCNSError]]]: + """Find all errors in a directory. + + Parameters + ---------- + directory_path : FilePath + Path to the directory to be checked. + + Returns + ------- + all_errors : dict[str, dict[str, Union[list[FilePath], KnownCNSError]]] + Dictionary containing all errors found in this directory. + """ + all_errors: dict[str, dict[str, Union[int, KnownCNSError]]] = {} + # Gather list of all `.cnserr` and `.cnserr.gz` files present in directory + all_cns_out_files = list(Path(directory_path).glob("*.cnserr.gz")) + all_cns_out_files += list(Path(directory_path).glob("*.cnserr")) + # Loop over all .cnserr files + for fpath in all_cns_out_files: + # Try to dectect an error + if (detected_error := find_cns_errors(fpath)): + # Hold data if an error is present in that file + error_type = all_errors.setdefault( + detected_error.cns_error, + {"files": [], "error": detected_error} + ) + error_type["files"].append(detected_error.filepath) + return all_errors diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/gear/parameters.py b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/parameters.py new file mode 100644 index 0000000000000000000000000000000000000000..1ab2a6cd6cb58d0285651ffd88ffe7802a2bf2e9 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/parameters.py @@ -0,0 +1,18 @@ +"""Relates to logic or definition of parameters.""" +from pathlib import Path + +from haddock import haddock3_source_path +from haddock.gear.yaml2cfg import read_from_yaml_config + + +MANDATORY_YAML = Path(haddock3_source_path, "core", "mandatory.yaml") +"""The mandatory general arguments of the configuration file.""" + +OPTIONAL_YAML = Path(haddock3_source_path, "core", "optional.yaml") +"""The optional general arguments of the configuration file.""" + +_mandatory_parameters = read_from_yaml_config(MANDATORY_YAML) +config_mandatory_general_parameters = set(_mandatory_parameters) + +config_optional_general_parameters_dict = read_from_yaml_config(OPTIONAL_YAML) +config_optional_general_parameters = set(config_optional_general_parameters_dict) # noqa: E501 diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/gear/postprocessing.py b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/postprocessing.py new file mode 100644 index 0000000000000000000000000000000000000000..349dcbb6b991d53be268bfebb94afb3cb13261da --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/postprocessing.py @@ -0,0 +1,46 @@ +"""Tools for post-processing haddock3 runs.""" + +import os +import shutil +import tarfile + +from haddock import log +from haddock.clis.cli_analyse import ANA_FOLDER +from haddock.core.typing import Optional + + +def archive_run(run_dir: str, delete: bool = True) -> tuple[str, Optional[str]]: + """Create an archive of the haddock3 run directory and analysis. + + Parameters + ---------- + run_dir : str + Path to the run directory + delete : bool, optional + Should the un-archived directory be deleted?, by default False + + Returns + ------- + tuple[str, Optional[str]] + run_archive_fname : str + Path to the run archive + analysis_archive_fname : Optional[str] + Path to the run analysis archive + """ + log.info("Creating an archive of the run") + # Start by archiving the run_directory + run_archive_fname = f"{run_dir}.tgz" + with tarfile.open(run_archive_fname, "w:gz") as tar: + tar.add(run_dir, arcname=os.path.basename(run_dir)) + + # Archive the analysis directory + analysis_archive_fname = None + if os.path.exists(f"{run_dir}/{ANA_FOLDER}"): + analysis_archive_fname = f"{run_dir}_{ANA_FOLDER}.tgz" + with tarfile.open(analysis_archive_fname, "w:gz") as tar: + tar.add(f"{run_dir}/{ANA_FOLDER}", arcname=f"{run_dir}_{ANA_FOLDER}") + + if delete: + shutil.rmtree(run_dir) + + return run_archive_fname, analysis_archive_fname \ No newline at end of file diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/gear/prepare_run.py b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/prepare_run.py new file mode 100644 index 0000000000000000000000000000000000000000..8f1ee274b0a7214445315e37c919a714cc14198f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/prepare_run.py @@ -0,0 +1,1470 @@ +"""Logic pertraining to preparing the run files and folders.""" + +import difflib +import importlib +import itertools as it +import json +import os +import shutil +import string +import sys +import tarfile +from contextlib import contextmanager, suppress +from copy import copy, deepcopy +from functools import lru_cache, wraps +from pathlib import Path, PosixPath + +from haddock import EmptyPath, contact_us, haddock3_source_path, log +from haddock.core.defaults import RUNDIR, max_molecules_allowed +from haddock.core.exceptions import ConfigurationError, ModuleError +from haddock.core.typing import ( + Any, + Callable, + FilePath, + Generator, + Iterable, + Optional, + ParamDict, + ParamMap, + Union, +) +from haddock.gear.clean_steps import ( + UNPACK_FOLDERS, + unpack_compressed_and_archived_files, + update_unpacked_names, +) +from haddock.gear.config import get_module_name +from haddock.gear.config import load as read_config +from haddock.gear.config import save as save_config +from haddock.gear.expandable_parameters import ( + get_mol_parameters, + get_multiple_index_groups, + get_single_index_groups, + is_mol_parameter, + read_mol_parameters, + read_multiple_idx_groups_user_config, + read_simplest_expandable, + read_single_idx_groups_user_config, + remove_trail_idx, + type_simplest_ep, +) +from haddock.gear.extend_run import ( + read_num_molecules_from_folder, + renum_step_folders, +) +from haddock.gear.greetings import get_goodbye_help +from haddock.gear.parameters import ( + config_mandatory_general_parameters, + config_optional_general_parameters, + config_optional_general_parameters_dict, +) +from haddock.gear.preprocessing import process_pdbs, read_additional_residues +from haddock.gear.restart_run import remove_folders_after_number +from haddock.gear.validations import ( + v_rundir, + validate_defaults_yaml, + ) +from haddock.gear.yaml2cfg import ( + read_from_yaml_config, + find_incompatible_parameters, + ) +from haddock.gear.zerofill import zero_fill +from haddock.libs.libfunc import not_none +from haddock.libs.libio import make_writeable_recursive, extract_files_flat +from haddock.libs.libutil import ( + extract_keys_recursive, + recursive_convert_paths_to_strings, + recursive_dict_update, + remove_dict_keys, + transform_to_list, +) +from haddock.modules import ( + get_module_steps_folders, + modules_category, + modules_names, + non_mandatory_general_parameters_defaults, + incompatible_defaults_params, +) +from haddock.modules.analysis import ( + confirm_resdic_chainid_length, + modules_using_resdic, +) + + +ALL_POSSIBLE_GENERAL_PARAMETERS = set.union( + set(config_mandatory_general_parameters), + set(non_mandatory_general_parameters_defaults), + config_optional_general_parameters, +) + +# Dict mapping string types (in default.yaml) into python3 objects types +TYPES_MAPPER = { + "boolean": (bool,), + "bool": (bool,), + "integer": ( + int, + float, + ), + "int": ( + int, + float, + ), + "long": ( + float, + int, + ), + "float": ( + float, + int, + ), + "double": (float,), + "string": (str,), + "str": (str,), + "list": (list,), + "array": (list,), + "path": ( + str, + Path, + PosixPath, + EmptyPath, + ), + "file": ( + str, + Path, + PosixPath, + EmptyPath, + ), + "dict": ( + dict, + ) +} + + +@contextmanager +def config_key_error() -> Generator[None, None, None]: + """Raise ConfigurationError on KeyError.""" + try: + yield + except KeyError as err: + msg = f"Expected {err.args[0]!r} parameter in configuration file." + raise ConfigurationError(msg) from err + + +def with_config_error(func: Callable[..., Any]) -> Callable[..., Any]: + """Add config error context.""" + + @wraps(func) + def wrapper(*args: Any, **kwargs: Any) -> Callable[..., Any]: + with config_key_error(): + return func(*args, **kwargs) + + return wrapper + + +@lru_cache +def _read_defaults(module_name, default_only=True): + """Read the defaults.yaml given a module name. + + Parameters + ---------- + module_name : str + Name of the HADDOCK3 module + default_only : bool + If True, only the default value of each parameters found in the + default.yaml will be return, else all information are retrieved. + + Return + ------ + mod_default_config : dict + A dict holding default value for each parameters of the module if + default_only == True, + Else a dict of dict, contraining all information present in the + default.yaml file of the module. + """ + module_name_ = get_module_name(module_name) + pdef = gen_defaults_module_param_path(module_name_) + validate_defaults_yaml(pdef) + mod_default_config = read_from_yaml_config(pdef, default_only=default_only) + return mod_default_config + + +def gen_defaults_module_param_path(module_name_: str) -> Path: + """Build path to default parameters of a module. + + Parameters + ---------- + module_name_ : str + Name of the module + + Returns + ------- + Path + Path to the module YAML defaults parameter. + """ + params_defaults_path = Path( + haddock3_source_path, + "modules", + modules_category[module_name_], + module_name_, + "defaults.yaml", + ).resolve() + return params_defaults_path + + +def setup_run( + workflow_path: FilePath, + restart_from: Optional[int] = None, + extend_run: Optional[FilePath] = None, +) -> tuple[ParamDict, ParamDict]: + """ + Set up an HADDOCK3 run. + + This function sets up a HADDOCK3 considering the options `--restart` + and `--extend-run`. The list of actions presented below does + not necessary represents the exact order in which it happens. + + Always performed: + + #. read the user configuration file + #. completes the user configuration file with the default values + for the non-specified parameters + #. validate the config file + * confirm modules' names are correctly spelled + * check if requested modules are installed + * check additional validations + #. validate modules' parameters + #. copy input files to data/ directory + * for ``--restart`` copies only after the restart number + + Performed when ``--restart``: + + #. remove folders after --restart number + #. remove also folders from `data/` dir after the ``--restart`` num + #. renumber step folders according to the number of modules + + Performed when ``--extend-run``: + + #. renumber step folders according to the number of modules + + Performed when start from scratch: + + #. check mandatory arguments are present in the config file + #. check run-dir exists + #. copy molecules to topology key (also in ``--restart``) + #. populate topology parameters (also in ``--restart``) + #. copy molecules to data dir + + Parameters + ---------- + workflow_path : str or pathlib.Path + The path to the configuration file. + + restart_from : 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. + + Returns + ------- + tuple of two dicts + A dictionary with the parameters for the haddock3 modules. + A dictionary with the general run parameters. + """ + # read the user config file from path + config_files = read_config(workflow_path) + + # update default non-mandatory parameters with user params + params = recursive_dict_update( + config_optional_general_parameters_dict, config_files["final_cfg"] + ) + + params = recursive_dict_update( + non_mandatory_general_parameters_defaults, + params, + ) + + validate_module_names_are_not_misspelled(params) + + # separate general from modules' parameters + _modules_keys = identify_modules(params) + general_params = remove_dict_keys(params, _modules_keys) + modules_params = remove_dict_keys(params, list(general_params.keys())) + + validate_parameters_are_not_misspelled( + general_params, + reference_parameters=ALL_POSSIBLE_GENERAL_PARAMETERS, + ) + + # Validate there is no incompatible parameters in global parameters + validate_parameters_are_not_incompatible( + general_params, + incompatible_defaults_params, + ) + + # --extend-run configs do not define the run directory + # in the config file. So we take it from the argument. + if not_none(extend_run): + with suppress(TypeError): + extend_run = Path(extend_run) + + general_params[RUNDIR] = extend_run + + check_if_modules_are_installed(modules_params) + check_specific_validations(general_params) + + # define starting conditions + # consider a deeper refactor if additional conditions are implemented + # @joaomcteixeira, 09 May 2022 + from_scratch = restart_from is None and extend_run is None + scratch_rest0 = from_scratch or restart_from == 0 + restarting_from = not_none(restart_from) + starting_from_copy = not_none(extend_run) + + if from_scratch: + check_run_dir_exists(general_params[RUNDIR]) + + if scratch_rest0: + check_mandatory_argments_are_present(general_params) + + if restarting_from: + remove_folders_after_number(general_params[RUNDIR], restart_from) + _data_dir = Path(general_params[RUNDIR], "data") + remove_folders_after_number(_data_dir, restart_from) + + if restarting_from or starting_from_copy: + # get run files in folder + step_folders = get_module_steps_folders(general_params[RUNDIR]) + + log.info( + "Uncompressing previous output files for folders: " + f'{", ".join(step_folders)}' + ) + # unpack the possible compressed and archived files + _step_folders = (Path(general_params[RUNDIR], p) for p in step_folders) + unpack_compressed_and_archived_files( + _step_folders, + general_params["ncores"], + dec_all=True, + ) + + if starting_from_copy: + num_steps = len(step_folders) + _num_modules = len(modules_params) + # has to consider the folders already present, plus the new folders + # in the configuration file + zero_fill.set_zerofill_number(num_steps + _num_modules) + + max_mols = read_num_molecules_from_folder(extend_run) + + else: + copy_molecules_to_topology( + general_params["molecules"], + modules_params["topoaa.1"], + ) + + if len(modules_params["topoaa.1"]["molecules"]) > max_molecules_allowed: + raise ConfigurationError( + f"Too many molecules defined, max is {max_molecules_allowed}." + ) # noqa: E501 + + zero_fill.read(modules_params) + + populate_topology_molecule_params(modules_params["topoaa.1"]) + populate_mol_parameters(modules_params) + + max_mols = len(modules_params["topoaa.1"]["molecules"]) + + if not from_scratch: + _prev, _new = renum_step_folders(general_params[RUNDIR]) + renum_step_folders(Path(general_params[RUNDIR], "data")) + if UNPACK_FOLDERS: # only if there was any folder unpacked + update_unpacked_names(_prev, _new, UNPACK_FOLDERS) + update_step_contents_to_step_names( + _prev, + _new, + general_params[RUNDIR], + ) + + validate_modules_params(modules_params, max_mols) + + # create datadir + data_dir = create_data_dir(general_params[RUNDIR]) + + # Add workflow configuration file in data directory + enhanced_haddock_params = deepcopy(general_params) + enhanced_haddock_params.update(modules_params) + config_files["enhanced_haddock_params"] = enhanced_haddock_params + config_saves = save_configuration_files(config_files, data_dir) # noqa : F841 + + if scratch_rest0: + copy_molecules_to_data_dir( + data_dir, + modules_params["topoaa.1"], + preprocess=general_params["preprocess"], + ) + + if starting_from_copy: + copy_input_files_to_data_dir(data_dir, modules_params, start=num_steps) + + elif restarting_from: + # copies only the input molecules needed + _keys = list(modules_params.keys()) + _partial_params = {k: modules_params[k] for k in _keys[restart_from:]} + copy_input_files_to_data_dir( + data_dir, + _partial_params, + start=restart_from, + ) + + else: + # copies everything + copy_input_files_to_data_dir(data_dir, modules_params) + + # grant write permissions to data/ dir + make_writeable_recursive(data_dir) + + # return the modules' parameters and general parameters separately + return modules_params, general_params + + +def save_configuration_files(configs: dict, datadir: Union[str, Path]) -> dict: + """Write a copy of configuration files (GitHub issue #578). + + Parameters + ---------- + configs : dict + Dictionnary holding the various configuration files + ['raw_input, 'cleaned_input', 'loaded_cleaned_input', + 'final_cfg', 'enhanced_haddock_params'] + datadir : str or :py:class:`libpath.Path` + Directory where to write the configuration. + + Return + ------ + added_files : dict + Dictionary of paths leading to saved configuration files. + """ + # Create directory + confpaths = Path(datadir, "configurations/") + confpaths.mkdir(parents=True, exist_ok=True) + # Initiate files data + infofile = { + "raw_input": ( + "An untouched copy of the raw input file, " "as provided by the user." + ), + "cleaned_input": ( + "Pre-parsed input file where (eventually) " + "some indexing and modifications were " + "applied to ensure further processing." + ), + "enhanced_haddock_params": ( + "Final input file with detailed default parameters." + ), + } + added_files = {} + # Set list of configurations that wish to be saved + list_save_conf = [ + "raw_input", + "cleaned_input", + "enhanced_haddock_params", + ] + + # Loop over configuration files + for confname in list_save_conf: + try: + confdt = configs[confname] + except KeyError: + continue + + toml_fpath = Path(confpaths, f"{confname}.toml") + if isinstance(confdt, dict): + # Save toml version + save_config(confdt, toml_fpath) + # Save json version + json_fpath = Path(confpaths, f"{confname}.json") + jsonconf = recursive_convert_paths_to_strings(confdt) + with open(json_fpath, "w", encoding="utf-8") as f: + json.dump(jsonconf, f, indent=4) + else: + with open(toml_fpath, "w") as f: + f.write(confdt) + + added_files[confname] = toml_fpath + + # Add README to help user + readmepath = Path(confpaths, "README.txt") + with open(readmepath, "w") as f: + f.write( + f"{'#'*80}\n# Information about configuration " + f"files present in the same directory #\n{'#'*80}\n" + ) + for confname in list_save_conf: + if confname not in added_files.keys(): + continue + f.write(f'"{added_files[confname]}": {infofile[confname]}\n') + added_files["readme"] = readmepath + + # Return mapper to added files + return added_files + + +def validate_params(params): + """ + Validate the parameter file. + + #1 : checks for mandatory parameters + #2 : checks for correct modules + """ + check_mandatory_argments_are_present(params) + validate_modules_names(params) + + +def check_mandatory_argments_are_present(params: Iterable[str]) -> None: + """Confirm order key exists in config.""" + for arg in config_mandatory_general_parameters: + if arg not in params: + _msg = ( + f"Parameter {arg!r} is not defined in the configuration file. " + "Please refer to DOCUMENTATION-LINK for more information." + ) + raise ConfigurationError(_msg) + return + + +@with_config_error +def validate_modules_names(params: Iterable[str]) -> None: + """Validate all modules names are spelled correctly.""" + keys = ( + set(params) + - set(config_mandatory_general_parameters) + - set(non_mandatory_general_parameters_defaults) + ) + + for module in keys: + if get_module_name(module) not in modules_category.keys(): + _msg = ( + f"Module {module} not found in HADDOCK3 library. " + "Please refer to the list of available modules at: " + "DOCUMENTATION-LINK" + ) + raise ConfigurationError(_msg) + + +@with_config_error +def validate_modules_params(modules_params: ParamMap, max_mols: int) -> None: + """Validate individual parameters for each module. + + Raises + ------ + ConfigError + If there is any parameter given by the user that is not defined + in the defaults.cfg of the module. + """ + for module_name, args in modules_params.items(): + module_name = get_module_name(module_name) + defaults = _read_defaults(module_name) + if not defaults: + continue + + # Check for parameter incompatibilities + module_incompatibilities = find_incompatible_parameters( + gen_defaults_module_param_path(module_name) + ) + try: + validate_parameters_are_not_incompatible( + args, + module_incompatibilities, + ) + except ValueError as e: + raise ConfigurationError( + f"An issue was discovered in module [{module_name}]: " + f"{e.args[0]}" + ) + + if module_name in modules_using_resdic: + confirm_resdic_chainid_length(args) + + expandable_params = get_expandable_parameters( + args, + defaults, + module_name, + max_mols, + ) + + all_parameters = set.union( + set(extract_keys_recursive(defaults)), + set(non_mandatory_general_parameters_defaults.keys()), + expandable_params, + ) + + diff = set(extract_keys_recursive(args)) - all_parameters + + if diff: + matched = fuzzy_match(diff, all_parameters) + + def pretty_print(match: tuple[str, str]) -> str: + return f" * '{match[0]}' did you mean '{match[1]}'?" + + _msg = ( + "The following parameters do not match any expected " + f"parameters for module {module_name!r}: {os.linesep}" + f"{os.linesep.join(map(pretty_print, matched))}." + ) + raise ConfigurationError(_msg) + + # Now that existence of the parameter was checked, + # it is time to validate the type and value taken by this param + validate_module_params_values(module_name, args) + # Validate ncs parameters + validate_ncs_params(args) + + # Update parameters with defaults ones + _missing_defaults = { + param: default + for param, default in defaults.items() + if param not in args.keys() + } + args.update(_missing_defaults) + + +def validate_module_params_values(module_name: str, args: dict) -> None: + """Validate individual parameters for a module. + + Parameters + ---------- + module_name : + Name of the module to be analyzed + args : dict + Dictionnary of key/value present in user config file for a module + + Raises + ------ + ConfigError + If there is any parameter given by the user that is not following the + types or ranges/choices allowed in the defaults.cfg of the module. + """ + # Load all parameters information from 'defaults.cfg' + default_conf_params = _read_defaults(module_name, default_only=False) + # Loop over user queried parameters keys/values + for key, val in args.items(): + validate_value(default_conf_params, key, val) + + +def validate_value(default_yaml: dict, key: str, value: Any) -> None: + """Validate queried value for a specific parameter of a module. + + Parameters + ---------- + default_yaml : dict + Dictionnary of key/value present in user config file for a module + key : str + Key to be analyzed + value : [bool, int, float, str, list] + The provided value for a parameter + + Raises + ------ + ConfigError + If there is any parameter given by the user that is not following the + types or ranges/choices allowed in the defaults.cfg of the module. + """ + # Special case for molecules... + if key not in default_yaml.keys(): + return + if "group" in default_yaml[key].keys(): + if default_yaml[key]["group"] == "molecules": + return + + # Series of checks + if _msg := validate_param_type(default_yaml[key], value): + raise ConfigurationError(f'Config error for parameter "{key}": {_msg}') + if _msg := validate_param_range(default_yaml[key], value): + raise ConfigurationError(f'Config error for parameter "{key}": {_msg}') + # FIXME: add more checks here ? + + +def validate_param_type(param: dict, val: Any) -> Optional[str]: + """Check if provided parameter type is similar to defined defaults ones. + + Parameters + ---------- + param : dict + Dictionnary of key/value present in user config file for a module + val : [bool, int, float, str, list] + The provided value for a parameter + + Return + ------ + May return a string explaining the issue with the provided value type + """ + if "type" not in param.keys(): + return + # Load type from string to python class + try: + allowed_types = TYPES_MAPPER[param["type"]] + except KeyError as e: + return f'Unrecognized default type "{e}"' + # Check if both of the same type + if (query_type := type(val)) not in allowed_types: + return ( + f'Wrong provided type "{query_type}" with value "{val}". ' + f'It should be of type "{param["type"]}" ' + f'(e.g: {param["default"]})' + ) + + +def validate_param_range(param: dict, val: Any) -> Optional[str]: + """Check if provided value is in range/choices defined for this parameter. + + Parameters + ---------- + param : dict + Dictionnary of key/value present in user config file for a module + val : [bool, int, float, str, list] + The provided value for a parameter + + Return + ------ + May return a string explaining the issue with the provided value range + """ + # Case for choices + if "choices" in param.keys(): + if val not in (choices := param["choices"]): + return f'Value "{val}" is not among the accepted choices: {choices}' # noqa : E501 + # Case for ranges + elif "min" in param.keys() and "max" in param.keys(): + if val < param["min"] or val > param["max"]: + return ( + f'Value "{val}" is not in the allowed boundaries ' + f'ranging from {param["min"]} to {param["max"]}' + ) + # Case for lists + elif "minitems" in param.keys() and "maxitems" in param.keys(): + if (nbitems := len(val)) < param["minitems"] or nbitems > param["maxitems"]: + _desc = "under" if nbitems < param["minitems"] else "exceeding" + return ( + f'Number of items found in "{val}" is {_desc} the ' + "permitted limit. It should range from " + f'{param["minitems"]} to {param["maxitems"]}' + ) + # Case for strings + elif "minchars" in param.keys() and "maxchars" in param.keys(): + if (nbchars := len(val)) < param["minchars"] or nbchars > param["maxchars"]: + _desc = "under" if nbchars < param["minitems"] else "exceeding" + return ( + f'Number of items found in "{val}" is {_desc} the ' + "permitted limit. It should range from " + f'{param["minchars"]} to {param["maxchars"]}' + ) + + +def validate_ncs_params(params: dict) -> None: + """Validate Non-Crystallographic Symmetry parameters. + + This is a particular case where: + - ncs_sta1_X == ncs_sta2_X + - ncs_end1_X == ncs_end2_X + - ncs_seg1_X != ncs_seg2_X + + Parameters + ---------- + params : dict + Dictionary of key/value present in user config file for a module + + Raises + ------ + ConfigurationError + Issue detected when validating NCS parameters. + """ + try: + # Check if ncs_on == False + if not params["ncs_on"]: + return None + # Maybe this module do not have ncs parameters, so we skip it + except KeyError: + return None + # At this stage, ncs_on == True + base_ncs_param_names = ("ncs_sta", "ncs_end", "ncs_seg", ) + # Read and group ncs parameters together + groupped_ncs: dict[int, dict[str, dict[int, Union[int, str]]]] = {} + for paramname, value in params.items(): + # Check if this is a ncs parameter + if paramname[:7] in base_ncs_param_names: + # Point two interesting values here + first_or_second = int(paramname[7]) + x = int(paramname[-1]) + # Point param type ("sta", "end", or "seg") + param_type = paramname.split('_')[1][:-1] + # Point/Create holding dict(s) + ncs_group = groupped_ncs.setdefault(x, {}) + ncs_type = ncs_group.setdefault(param_type, {}) + # Hold value + ncs_type[first_or_second] = value + + # Validate them + error_list: list[str] = [] + # Loop over number of definitions (_X) + for x, paramtype_values in groupped_ncs.items(): + # Loop over parameter types + for paramtype, values in paramtype_values.items(): + two_values = tuple(values.values()) + # First make sure both are defined ! + if len(two_values) != 2: + msg = f"Not two values set of `ncs_{paramtype}Y_{x}" + error_list.append(msg) + continue + if paramtype in ("sta", "end", ): + # Check they are not similar (wrong!) + if not len(set(two_values)) == 1: + msg = ( + f"Values set of `ncs_{paramtype}Y_{x} must be equal: " + f"we parsed `{two_values[0]}` and `{two_values[1]}`" + ) + error_list.append(msg) + else: # paramtype == "seg" + # Check they are similar (wrong!) + if len(set(values.values())) == 1: + msg = ( + f"Chain/Segment IDs for `ncs_{paramtype}Y_{x} must be " + f"different: we parsed `{two_values[0]}` and" + f" `{two_values[1]}`" + ) + error_list.append(msg) + + # Validate value of `numncs` + ncs_suffixes = list(groupped_ncs.keys()) + # Case when number of definition do not match + if params["nncs"] != len(ncs_suffixes): + msg = ( + f'Number of NCS restraints (`nncs = {params["nncs"]}`) ' + " do not match with the number of defined NCS restraints " + f"({len(ncs_suffixes)})" + ) + error_list.append(msg) + else: + # Case when numbers do not match + if max(ncs_suffixes) != params["nncs"]: + msg = ( + f'Number of NCS restraints (`nncs = {params["nncs"]}`) ' + " do not match with the number of defined NCS restraints " + f"({', '.join([str(s) for s in ncs_suffixes])})" + ) + error_list.append(msg) + + # Here we fall into the error case + if len(error_list) > 0: + # Build user message + _msg = ( + "Some errors were discovered in the NCS restraints definition:" + f"{os.linesep}" + f"{os.linesep.join(error_list)}" + ) + # Raise error + raise ConfigurationError(_msg) + return None + + +def check_if_modules_are_installed(params: ParamMap) -> None: + """Validate if third party-libraries are installed.""" + for module_name in params.keys(): + module_import_name = ".".join( + [ + "haddock", + "modules", + modules_category[get_module_name(module_name)], + get_module_name(module_name), + ] + ) + module_lib = importlib.import_module(module_import_name) + try: + module_lib.HaddockModule.confirm_installation() + except Exception as err: + _msg = ( + "A problem occurred while assessing if module " + f"{module_name!r} is installed in your system. Have you " + "installed the packages required to run this module? If " + f"yes, write us at {contact_us!r} describing your system " + "and the problems you are facing. If not, please install " + "the required packages to use the module." + ) + raise ModuleError(_msg) from err + + +# depecrated +# def convert_params_to_path(params): +# """Convert parameters to path.""" +# convert_molecules_to_path(params) +# convert_run_dir_to_path(params) +# return +# +# +# @with_config_error +# def convert_molecules_to_path(params): +# """ +# Convert molecules path strings to Python Paths. +# +# And... convert `molecules` in `params` to a dictionary where keys +# are `key` + `sep` + enumerate(`start`), and values are the new Path +# values. +# """ +# molecules = make_list_if_string(params['molecules']) +# params['molecules'] = [Path(i).resolve() for i in molecules] +# return +# +# +# @with_config_error +# def convert_run_dir_to_path(params): +# """Convert run directory value to Python Path.""" +# params[RUNDIR] = Path(params[RUNDIR]) +# return + + +@with_config_error +def create_data_dir(run_dir: FilePath) -> Path: + """ + Create initial files for HADDOCK3 run. + + Returns + ------- + pathlib.Path + A path referring only to 'data'. + """ + data_dir = Path(run_dir, "data") + data_dir.mkdir(parents=True, exist_ok=True) + return data_dir + + +@with_config_error +def copy_molecules_to_topology( + molecules: Iterable[str], topoaa_params: ParamMap +) -> None: + """Copy molecules to mandatory topology module.""" + topoaa_params["molecules"] = list(map(Path, transform_to_list(molecules))) + + +def copy_molecules_to_data_dir( + data_dir: Path, topoaa_params: ParamMap, preprocess: bool = True +) -> None: + """ + Copy molecules to data directory and to topoaa parameters. + + Parameters + ---------- + data_dir : Path + The data/ directory inside the run directory. Must contain + reference to the run directory. + + topoaa_params : dict + A dictionary containing the topoaa parameters. + + preprocess : bool + Whether to preprocess input molecules. Defaults to ``True``. + See :py:mod:`haddock.gear.preprocessing`. + """ + topoaa_dir = zero_fill.fill("topoaa", 0) + + # define paths + data_topoaa_dir = Path(data_dir, topoaa_dir) + data_topoaa_dir.mkdir(parents=True, exist_ok=True) + rel_data_topoaa_dir = Path(data_dir.name, topoaa_dir) + original_mol_dir = Path(data_dir, "original_molecules") + + new_molecules: list[Path] = [] + for molecule in copy(topoaa_params["molecules"]): + check_if_path_exists(molecule) + + mol_name = Path(molecule).name + + if preprocess: # preprocess PDB files + top_fname = topoaa_params.get("ligand_top_fname", False) + new_residues = read_additional_residues(top_fname) if top_fname else None + + new_pdbs = process_pdbs(molecule, user_supported_residues=new_residues) + + # copy the original molecule + original_mol_dir.mkdir(parents=True, exist_ok=True) + original_mol = Path(original_mol_dir, mol_name) + shutil.copy(molecule, original_mol) + + # write the new processed molecule + new_pdb = os.linesep.join(new_pdbs[0]) + Path(data_topoaa_dir, mol_name).write_text(new_pdb) + + else: + shutil.copy(molecule, Path(data_topoaa_dir, mol_name)) + + new_molecules.append(Path(rel_data_topoaa_dir, mol_name)) + + topoaa_params["molecules"] = copy(new_molecules) + + +def copy_input_files_to_data_dir( + data_dir: Path, modules_params: ParamMap, start: int = 0 +) -> None: + """ + Copy input files to data directory. + + Parameters + ---------- + data_dir : Path + The data/ directory inside the run directory. Must contain + reference to the run directory. + + modules_params : dict + A dictionary with the parameters of the modules. The paths to + data in the dictionary are updated to the new paths copied + to the data/ folder. + + start : int, default to 0 + The starting number of the step folders prefix. + """ + rel_data_dir = data_dir.name + for i, (module, params) in enumerate(modules_params.items(), start=start): + end_path = Path(zero_fill.fill(get_module_name(module), i)) + for parameter, value in params.items(): + if parameter.endswith("_fname"): + if value: + name = Path(value).name + # path is created here to avoid creating empty folders + # for those modules without '_fname' parameters + pf = Path(data_dir, end_path) + pf.mkdir(exist_ok=True) + check_if_path_exists(value) + target_path = Path(pf, name) + shutil.copy(value, target_path) + _p = Path(rel_data_dir, end_path, name) + modules_params[module][parameter] = _p + # account for input .tgz files + if name.endswith("tgz"): + log.info(f"Uncompressing tar {value}") + extract_files_flat(value, pf) + + +def check_run_dir_exists(run_dir: FilePath) -> None: + """Check whether the run directory exists.""" + _p = Path(run_dir) + if _p.exists() and len(list(_p.iterdir())) > 0: + log.info( + f"The {RUNDIR!r} {str(_p)!r} exists and is not empty. " + "We can't work on it unless you provide the `--restart` " + "option. If you want to start a run from scratch, " + "indicate a new folder, or manually delete this one first, " + "or use `--restart 0`." + ) + sys.exit(get_goodbye_help()) + + +def identify_modules(params: Iterable[str]) -> list[str]: + """Identify keys (headings) belonging to HADDOCK3 modules.""" + modules_keys = [k for k in params if get_module_name(k) in modules_category] + return modules_keys + + +def inject_in_modules(modules_params: ParamMap, key: Any, value: Any) -> None: + """Inject a parameter in each module.""" + for params in modules_params.values(): + if key in params: + raise ValueError( + "key {key!r} already in {module!r} parameters. " "Can't inject." + ) + params[key] = value + + +def validate_module_names_are_not_misspelled(params: ParamMap) -> None: + """ + Validate module names are not misspelled in step definitions. + + Parameters + ---------- + params : dict + The user configuration file. + """ + params_to_check = [ + get_module_name(param) + for param, value in params.items() + if isinstance(value, dict) + ] + + validate_parameters_are_not_misspelled( + params_to_check, + reference_parameters=modules_names, + ) + + return + + +def validate_parameters_are_not_incompatible( + params: ParamMap, + incompatible_params: ParamMap, + ) -> None: + """ + Validate parameters are not incompatible. + + Parameters + ---------- + params : ParamMap + A mapping of parameter names to their values. + + Raises + ------ + ValueError + If any parameter in `params` is incompatible with another parameter + as defined by `incompatible_params`. + """ + for limiting_param, incompatibilities in incompatible_params.items(): + # Check if the limiting parameter is present in the parameters + if limiting_param in params: + # Point incompatibilities for the value of the limiting parameter + if params[limiting_param] not in incompatibilities.keys(): + continue + active_incompatibilities = incompatibilities[params[limiting_param]] + # Check each incompatibility for the limiting parameter + for incompatible_param, incompatible_value in active_incompatibilities.items(): + # Check if the incompatible parameter is present and has the incompatible value + if params.get(incompatible_param) == incompatible_value: + raise ValueError( + f"Parameter `{limiting_param}` with value " + f"`{params[limiting_param]}` is incompatible with " + f"`{incompatible_param}={incompatible_value}`." + ) + + +def validate_parameters_are_not_misspelled( + params: Iterable[str], reference_parameters: Iterable[str] +) -> None: + """Validate general parameters are not misspelled.""" + for param_name in params: + if param_name not in reference_parameters: + matched = fuzzy_match([param_name], reference_parameters) + emsg = ( + f"Parameter {param_name!r} is not a valid general parameter," + f" did you mean {matched[0][1]!r}?" + ) + raise ValueError(emsg) + + +@with_config_error +def check_specific_validations(params: ParamMap) -> None: + """Make specific validations.""" + # double check though this is confirmed already in the config reader + v_rundir(params[RUNDIR]) + + +def get_expandable_parameters( + user_config: ParamMap, defaults: ParamMap, module_name: str, max_mols: int +) -> set[str]: + """ + Get configuration expandable blocks. + + Parameters + ---------- + user_config : dict + The user configuration file for a module. + + defaults : dict + The default configuration file defined for the module. + + module_name : str + The name the module being processed. + + max_mols : int + The max number of molecules allowed. + """ + # the topoaa module is an exception because it has subdictionaries + # for the `mol` parameter. Instead of defining a general recursive + # function, I decided to add a simple if/else exception. + # no other module should have subdictionaries has parameters + if get_module_name(module_name) == "topoaa": + ap: set[str] = set() # allowed_parameters + ap.update(_get_expandable(user_config, defaults, module_name, max_mols)) + for i in range(1, max_mols + 1): + key = f"mol{i}" + with suppress(KeyError): + ap.update( + _get_expandable( + user_config[key], + defaults["mol1"], + module_name, + max_mols, + ) + ) + + return ap + + elif module_name in modules_using_resdic: + ep = _get_expandable(user_config, defaults, module_name, max_mols) + for _param in user_config.keys(): + if _param.startswith("resdic_"): + ep.add(_param) + return ep + + else: + return _get_expandable(user_config, defaults, module_name, max_mols) + + +# reading parameter blocks +def _get_expandable( + user_config: ParamMap, defaults: ParamMap, module_name: str, max_mols: int +) -> set[str]: + # Set parsing vars + allowed_params: set[str] = set() + all_counts: dict[str, int] = {} + # Read single indexed groups (terminating by `_X`) + news_t1, counts_t1 = read_single_idx_groups_user_config( + user_config, + get_single_index_groups(defaults), + ) + allowed_params.update(news_t1) + all_counts.update(counts_t1) + # Read multiple indexed groups (terminating by `_X_Y`) + news_t2, counts_t2 = read_multiple_idx_groups_user_config( + user_config, + get_multiple_index_groups(defaults), + ) + allowed_params.update(news_t2) + all_counts.update(counts_t2) + + with suppress(KeyError): + news_t3 = read_simplest_expandable( + user_config, + type_simplest_ep[get_module_name(module_name)], + ) + allowed_params.update(news_t3) + # Read molecule paramters (starting by `mol_`) + _ = read_mol_parameters( + user_config, + get_mol_parameters(defaults), + max_mols=max_mols, + ) + allowed_params.update(_) + + # Add counted parameters to hidden user parameters + for param, count in all_counts.items(): + count_param_name = f"n{param}" + if count_param_name in defaults.keys(): + user_config[count_param_name] = count + # Return new set of allowed parameters + return allowed_params + + +def populate_topology_molecule_params(topoaa: ParamMap) -> None: + """Populate topoaa `molX` subdictionaries.""" + topoaa_dft = _read_defaults("topoaa.1") + + for i in range(1, len(topoaa["molecules"]) + 1): + mol = f"mol{i}" + + topoaa[mol] = recursive_dict_update( + topoaa_dft["mol1"], + topoaa[mol] if mol in topoaa else {}, + ) + return + + +def populate_mol_parameters(modules_params: ParamMap) -> None: + """ + Populate modules subdictionaries with the needed molecule `mol_` parameters. + + The `mol_` prefixed parameters is a subclass of the expandable parameters. + + See `gear.expandable_parameters`. + + Modules require these parameters to be repeated for the number of input + molecules. + + This function adds `mol_` parameters to the user input parameters, + one per each `molecule`. + + Parameters + ---------- + modules_params : dict + A dictionary containing only modules' keys:subdictionaries + parameters. That is, without the general parameters. + + Returns + ------- + None + Alter the dictionary in place. + """ + # the starting number of the `mol_` parameters is 1 by CNS definition. + num_mols = range(1, len(modules_params["topoaa.1"]["molecules"]) + 1) + for module_name, _ in modules_params.items(): + # read the modules default parameters + defaults = _read_defaults(module_name) + + # if there are no `mol_` parameters in the modules default values, + # the `mol_params` generator will be empty and the for-loop below + # won't run. + mol_params = (p for p in list(defaults.keys()) if is_mol_parameter(p)) + + for param, i in it.product(mol_params, num_mols): + param_name = remove_trail_idx(param) + + # the `setdefault` grants that the value is only added if + # the parameter is not present. + modules_params[module_name].setdefault( + f"{param_name}_{i}", + defaults[param], + ) + return + + +def check_if_path_exists(path: FilePath) -> None: + """ + Check if a path exists and raises an error if it does not exist. + + For example given this path "../config/project_01/file.txt" it would find + the following path "../config/project-01". + + Parameters + ---------- + path : AnyStr | PathLike + The path to check. + + Returns + ------- + None + If the path does exist. + + Raises + ------ + ValueError + If the path does not exist. + """ + path = os.path.normpath(path) + if os.path.exists(path): + return None + + reconstituted_path: str = "./" + error = ("", "", "") + elements = Path(path).parts + if elements[0] == ".": + elements = elements[1:] + for part in elements: + next_folder = Path(reconstituted_path, part) + if not next_folder.exists(): + error = ( + reconstituted_path, + fuzzy_match([part], os.listdir(reconstituted_path))[0][1], + part, + ) + break + reconstituted_path = str(next_folder) + + msg = ( + f"The following file could not be found: '{path}'. " + f"In the folder '{error[0]}' the following '{error[1]}' " + f"is the closest match to the supplied '{error[2]}', did " + "you mean to open this?" + ) + raise ValueError(msg) + + +def fuzzy_match( + user_input: Iterable[str], possibilities: Iterable[str] +) -> list[tuple[str, str]]: + """ + Find the closest possibility to the user supplied input. + + Parameters + ---------- + user_input : list(string) + List of strings with the faulty input given by the user. + + possibilities : list(string) + List of strings with all possible options that would be + valid in this context. + + Returns + ------- + list(string, string) + The closest string from the possibilities to each string of the + `user_input`. With as first element of the tuple the user_input + string, and as second element the matched possibility. + """ + results: list[tuple[str, str]] = list() + + for user_word in transform_to_list(user_input): + best: tuple[float, Any] = (-1, "") + for possibility in possibilities: + distance = difflib.SequenceMatcher( + a=user_word, b=possibility + ).ratio() # noqa: E501 + if distance > best[0]: + best = (distance, possibility) + results.append((user_word, best[1])) + + return results + + +def update_step_contents_to_step_names( + prev_names: Iterable[str], new_names: Iterable[str], folder: FilePath +) -> None: + """ + Update step folder names in files after the `--restart` option. + + Runs over the folders defined in `new_names`. + + Parameters + ---------- + prev_names : list + List of step names to find in file contents. + + new_names : list + List of new step names to replace `prev_names`. Both lists need + to be synchronized. That is, the first index of `prev_names` should + correspond to the old names of `new_names`. + + folder : str or Path + Folder where the step folders are. Usually run directory or + data directory. + + Returns + ------- + None + Save files in place. + """ + for new_step in new_names: + new_step_p = Path(folder, new_step) + for file_ in new_step_p.iterdir(): + # goes recursive into the next folder + if file_.is_dir(): + update_step_names_in_subfolders(file_, prev_names, new_names) + + else: + update_step_names_in_file(file_, prev_names, new_names) + + +def update_step_names_in_subfolders( + folder: Path, prev_names: Iterable[str], new_names: Iterable[str] +) -> None: + """ + Update step names in subfolders. + + Some modules may generate subfolders. This function update + its files accordingly to the `--restart` feature. + """ + for file_ in folder.iterdir(): + if file_.is_dir(): + update_step_names_in_subfolders(file_, prev_names, new_names) + else: + update_step_names_in_file(file_, prev_names, new_names) + return + + +def update_step_names_in_file( + file_: Path, prev_names: Iterable[str], new_names: Iterable[str] +) -> None: + """Update step names in file following the `--restart` option.""" + try: + text = file_.read_text() + except UnicodeDecodeError as err: + log.warning(f"Failed to read file {file_}. Error is {err}") + return + for s1, s2 in zip(prev_names, new_names): + text = text.replace(s1, s2) + file_.write_text(text) + return diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/gear/preprocessing.py b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/preprocessing.py new file mode 100644 index 0000000000000000000000000000000000000000..1df1db513b3bc9b2a8fa3a0d6ab5b203e1dc83a7 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/preprocessing.py @@ -0,0 +1,1090 @@ +# TODO: +# 1. single_ions may contain PO4 - verify +# 2. the single_ions_elements map seems not needed +""" +Process input PDB files to ensure compatibility with HADDOCK3. + +This module checks and modifies PDB files for compatibility with +HADDOCK3. There are three types of checks/modifications: + +1. Performed to each PDB line-by-line, in a equal fashion of ``pdb-tools``. + In fact, this step mostly uses the ``pdb-tools`` package. +2. Performed on each PDB as a whole. +3. Performed on all PDBs together. + +Main functions +-------------- + +* :py:func:`process_pdbs` +* :py:func:`read_additional_residues` + +Corrections performed on 1) +--------------------------- + +The following actions are perfomed sequentially over all PDBs: + +#. from ``pdb-tools``: ``pdb_keepcoord`` +#. from ``pdb-tools``: ``pdb_tidy`` with ``strict=True`` +#. from ``pdb-toos``: ``pdb_element`` +#. from ``pdb-tools``: ``pdb_selaltloc`` +#. from ``pdb-tools``: ``pdb_pdb_occ`` with ``occupancy=1.00`` +#. replace ``MSE`` to ``MET`` +#. replace ``HSD`` to ``HIS`` +#. replace ``HSE`` to ``HIS`` +#. replace ``HID`` to ``HIS`` +#. replace ``HIE`` to ``HIS`` +#. add_charges_to_ions, see :py:func:`add_charges_to_ions` +#. convert ``ATOM`` to ``HETATM`` for those atoms that should be ``HETATM``. + Considers the additional residues provided by the user. + See :py:func:`convert_ATOM_to_HETATM`. +#. convert ``HETATM`` to ``ATOM`` for those atoms that should be ``ATOM``, +#. from ``pdb-toos``: ``pdb_fixinsert``, with ``option_list=[]``. +#. remove unsupported ``HETATM``. Considers residues provided by the user. +#. remove unsupported ``ATOM``. Considers residues provided by the user. +#. from ``pdb-tools``: ``pdb_reatom``, start from ``1``. +#. from ``pdb-tools``: ``pdb_tidy`` with ``strict=True`` + +Corrections performed on 2) +--------------------------- + +The following actions are performed sequentially for each PDB: + +* :py:func:`models_should_have_the_same_labels` +* :py:func:`solve_no_chainID_no_segID` +* :py:func:`homogenize_chains` + +Read the documentation of the above functions for details what they do. + +Corrections performed on 3) +--------------------------- + +The following actions are performed to all PDBs together: + +* :py:func:`correct_equal_chain_segids` + +Read the documentation of the above functions for details what they do. + +When it happens +--------------- + +The PDB processing step is performed by default when reading the input +molecules and copying them to the `data/` folder inside the run +directory. When PDBs are processed, a copy of the original input PDBs is +also stored in the `data/` folder. + +To deactivate this initial PDB processing, set ``skip_preprocess = False`` +in the general parameters of the configuration file. + +Additional information +---------------------- + +If you are a developer and want to read more about the history of this +preprocessing module, visit: + +https://github.com/haddocking/haddock3/projects/16 +""" +import io +import itertools as it +import re +import string +from functools import partial, wraps +from os import linesep +from pathlib import Path + +from pdbtools import ( + pdb_chain, + pdb_chainxseg, + pdb_element, + pdb_fixinsert, + pdb_keepcoord, + pdb_occ, + pdb_reatom, + pdb_rplresname, + pdb_segxchain, + pdb_selaltloc, + pdb_shiftres, + pdb_tidy, +) + +from haddock import log +from haddock.core.exceptions import HaddockError +from haddock.core.supported_molecules import ( + supported_ATOM, + supported_HETATM, + supported_non_ions, + supported_single_ions_atoms_map, + supported_single_ions_resnames_map, +) +from haddock.core.typing import ( + Any, + Callable, + Container, + Generator, + Iterable, + LineIterSource, + Optional, + Union, +) +from haddock.libs.libfunc import chainf +from haddock.libs.libio import read_lines +from haddock.libs.libpdb import ( + format_atom_name, + read_chainids, + read_segids, + slc_charge, + slc_element, + slc_name, + slc_resname, +) + + +# defines chain letters for chain and seg IDs +_ascii_letters = list(string.ascii_uppercase + string.ascii_lowercase) +_CHAINS = it.cycle(_ascii_letters) + + +class ModelsDifferError(HaddockError): + """MODELS of the PDB differ in atom labels.""" + + pass + + +def _report(log_msg: str) -> Callable[..., Any]: + """ + Add report functionality to the function (decorator). + + Functions decorated with `_report` log the difference between the + input and the output. Decorated functions gain an additional boolean + parameter `report` to activate or deactivate the report + functionality; defaults to ``False``. + + Note that a generator decorated with ``_report`` no longer behaves + as a generator if ``report=True`` is given. Instead, it returns a + list from the exhausted generator. + + **Important:** Do NOT use ``_report`` with infinite generators, + such as ``itertools.cycle``. + """ + + def decorator(function: Callable[..., Any]) -> Callable[..., Any]: + @wraps(function) + def wrapper( + lines: Iterable[Any], *args: Any, report: bool = False, **kwargs: Any + ) -> Any: + if report: + in_lines = list(lines) + result = list(function(in_lines, *args, **kwargs)) + + # Here we could use sets to increase speed, but for the size + # of the systems, we can actually use lists and get a sorted + # result by default. I tried using difflib from STD but it is + # just too slow. + + # _ is line + additions = [_ for _ in result if _ not in in_lines] + deletions = [_ for _ in in_lines if _ not in result] + + la = len(additions) + ld = len(deletions) + + add_lines = linesep.join(f"+ {_}" for _ in additions) + del_lines = linesep.join(f"- {_}" for _ in deletions) + + log_msg_ = log_msg.format(*args, *kwargs.values()) + extended_log = ( + f"[{log_msg_}] + {la} - {ld} lines", + add_lines, + del_lines, + ) + + log.info(linesep.join(extended_log)) + return result + + # If report=False, maintain the original behaviour + else: + return function(lines, *args, **kwargs) + + return wrapper + + return decorator + + +def _open_or_give(inputdata: Iterable[LineIterSource]) -> list[list[str]]: + """ + Adapt input to the functions. + + Used in py:func:`process_pdbs`. + + Homogenizes input by: + + * removing new line characters at the end of the line + * removing empty lines + + Parameters + ---------- + inputdata : list + A **flat** list where in each index it can contain: + + * file objects + * paths to files + * strings representing paths + * lists or tuples of lines + + The above types can be mixed in the input list. + + Files are read to lines in a list. Line separators are stripped. + + Do not provide nested lists with lists containing paths inside + lists. + + Returns + ------- + list of list of strings + Each sublist has the contents of the input in the same order. + + Raises + ------ + TypeError + In any other circumstances. + """ + + def get_line(lines: Iterable[str]) -> list[str]: + """Ignore empty lines.""" + return [line.rstrip(linesep) for line in lines if line] + + lines: list[list[str]] = [] + for idata in inputdata: + if isinstance(idata, (Path, str)): + lines.append(get_line(Path(idata).read_text().split(linesep))) + + elif isinstance(idata, io.TextIOBase): + lines.append(get_line(idata.readlines())) + + elif isinstance(idata, (list, tuple)): + lines.append(get_line(idata)) + + else: + emsg = f"Unexpected type in `inputdata`: {type(idata)}" + raise TypeError(emsg) + + return lines + + +@read_lines +def read_additional_residues( + lines: Iterable[str], *ignore: Any, **everything: Any +) -> tuple[str, ...]: + """ + Read additional residues listed in a ``*.top`` filename. + + Expects new residues to be defined as:: + + RESIdue XXX + RESI XXX + residue XXX + + where, XXX is the new residue name. Does not read ATOM or charge + information. Reads only the residue name. + + Examples + -------- + Read directly the file: + + >>> read_additional_residues(fpath) + + Read the lines instead: + + >>> lines = Path(fpath).read_text().split(os.linesep) + >>> read_additional_residues.original(lines) + + Parameters + ---------- + fpath : str or pathlib.Path + The path to the file. + + lines : list of lines + You can also use this function in the form of + ``read_additional_residues.original(...)`` and directly give it + a list containing the lines of the file. + + Returns + ------- + tuple + A tuple with the new identified residues names. + """ + # https://regex101.com/r/1H44kO/1 + res_regex = re.compile(r"^(RESIdue|residue|RESI) ([A-Z0-9]{1,3}).*$") + residues: list[str] = [] + for line in map(str.strip, lines): + name = res_regex.findall(line) + if name: + residues.append(name[0][1]) + + return tuple(residues) + + +def process_pdbs( + *inputdata: LineIterSource, + dry: bool = False, + user_supported_residues: Optional[Iterable[str]] = None, +) -> list[list[str]]: + """ + Process PDB file contents for compatibility with HADDOCK3. + + Parameters + ---------- + inputdata : list of (str, path, list of str [lines], file handler) + + A **flat** list where in each index it can contain: + + * file objects + * paths to files + * strings representing paths + * lists or tuples of lines + + The above types can be mixed in the input list. + + Files are read to lines in a list. Line separators are stripped. + + Do not provide nested lists with lists containing paths inside + lists. + + dry : bool + Perform a dry run. That is, does not change anything, and just + report. + + user_supported_residues : list, tuple, or set + The new residues that are allowed. + + Returns + ------- + list of (list of str) + The corrected (processed) PDB content in the same order as + ``inputdata``. + """ + structures = _open_or_give(inputdata) + + # these are the processing or checking functions that should (if needed) + # modify the input PDB and return the corrected lines. + # Follows the same style as for pdb-tools. + # these functions yield line-by-line. + line_by_line_processing_steps = [ + wrep_pdb_keepcoord, # also discards ANISOU + # tidy is important before some other corrections + wrep_pdb_tidy_strict, + wrep_pdb_element, + wrep_pdb_selaltloc, + partial(wrep_pdb_occ, occupancy=1.00), + replace_MSE_to_MET, + replace_HSD_to_HIS, + replace_HSE_to_HIS, + replace_HID_to_HIS, + replace_HIE_to_HIS, + add_charges_to_ions, + partial( + convert_ATOM_to_HETATM, + residues=set.union( + supported_HETATM, + user_supported_residues or set(), + ), + ), + convert_HETATM_to_ATOM, + partial(wrep_pdb_fixinsert, option_list=[]), + ##### + partial( + remove_unsupported_hetatm, user_defined=user_supported_residues + ), # noqa: E501 + partial(remove_unsupported_atom), + #### + # partial(wrep_pdb_shiftres, shifting_factor=0), + partial(wrep_pdb_reatom, starting_value=1), + wrep_pdb_tidy, + ### + wrep_rstrip, + ] + + # these functions take the whole PDB content, evaluate it, and + # modify it if needed. + whole_pdb_processing_steps = [ + models_should_have_the_same_labels, + solve_no_chainID_no_segID, + homogenize_chains, + ] + + # these functions take all structures combined, evulate them + # togehter, and modify them if needed. + processed_combined_steps = [ + correct_equal_chain_segids, + ] + + # START THE ACTUAL PROCESSING + + # individual processing (line-by-line) + result_1 = [ + list(chainf(structure, *line_by_line_processing_steps, report=dry)) + for structure in structures + ] + + # whole structure processing + result_2 = [ + list(chainf(structure, *whole_pdb_processing_steps, report=dry)) + for structure in result_1 + ] + + # combined processing + final_result = chainf(result_2, *processed_combined_steps) + + return final_result + + +# Functions operating line-by-line + +# make pdb-tools reportable +wrep_pdb_chain = _report("pdb_chain")(pdb_chain.run) +wrep_pdb_chainxseg = _report("pbd_segxchain")(pdb_chainxseg.run) +wrep_pdb_element = _report("pdb_element")(pdb_element.run) +wrep_pdb_fixinsert = _report("pdb_fixinsert")(pdb_fixinsert.run) +wrep_pdb_keepcoord = _report("pdb_keepcoord")(pdb_keepcoord.run) +wrep_pdb_occ = _report("pdb_occ")(pdb_occ.run) +wrep_pdb_reatom = _report("pdb_reatom")(pdb_reatom.run) +wrep_pdb_shiftres = _report("pdb_shiftres")(pdb_shiftres.run) +wrep_pdb_rplresname = _report("pdb_rplresname")(pdb_rplresname.run) +wrep_pdb_segxchain = _report("pdb_segxchain")(pdb_segxchain.run) +wrep_pdb_selaltloc = _report("pdb_selaltloc")(pdb_selaltloc.run) +wrep_pdb_tidy = _report("pdb_tidy")(pdb_tidy.run) +wrep_pdb_tidy_strict = _report("pdb_tidy")(partial(pdb_tidy.run, strict=True)) +wrep_rstrip = _report("str.rstrip")( + partial(map, lambda x: x.rstrip(linesep)) +) # noqa: E501 + + +@_report("Replacing HETATM to ATOM for residue {!r}") +def replace_HETATM_to_ATOM( + fhandler: Iterable[str], res: str +) -> Generator[str, None, None]: + """ + Replace record `HETATM` to `ATOM` for `res`. + + Do not alter other lines. + + Parameters + ---------- + fhanlder : file handler or list of lines + List-like of file lines. Consumes over a ``for`` loop. + + res : str + Residue name to match for the substitution. + + Yields + ------ + str + Yield line-by-line. + """ + for line in fhandler: + if line.startswith("HETATM") and line[slc_resname].strip() == res: + yield "ATOM " + line[6:] + else: + yield line + + +@_report("Replace residue ATOM/HETATM {!r} to ATOM {!r}") +def replace_residue( + fhandler: Iterable[str], resin: str, resout: str +) -> Generator[str, None, None]: + """ + Replace residue by another and changes ``HETATM`` to ``ATOM`` if needed. + + Do not alter other lines. + + Parameters + ---------- + fhanlder : file handler or list of lines + List-like of file lines. Consumes over a ``for`` loop. + + resin : str + Residue name to match for the substitution. + + resout : str + Name of the new residue. Renames ``resin`` to ``resout``. + + Yields + ------ + str + Yield line-by-line. + + See Also + -------- + + * :py:func:`replace_HETATM_to_ATOM` + * ``pdb_rplresname`` from ``pdb-tools`` + """ + _ = replace_HETATM_to_ATOM(fhandler, res=resin) + yield from pdb_rplresname.run(_, name_from=resin, name_to=resout) + + +replace_MSE_to_MET = partial(replace_residue, resin="MSE", resout="MET") +""" +Replace ``MSE`` to ``MET``. + +See Also +-------- +* :py:func:`replace_residue` +""" + +replace_HSD_to_HIS = partial(replace_residue, resin="HSD", resout="HIS") +""" +Replace ``HSD`` to ``HIS``. + +See Also +-------- +* :py:func:`replace_residue` +""" + +replace_HSE_to_HIS = partial(replace_residue, resin="HSE", resout="HIS") +""" +Replace ``HSE`` to ``HIS``. + +See Also +-------- +* :py:func:`replace_residue` +""" + +replace_HID_to_HIS = partial(replace_residue, resin="HID", resout="HIS") +""" +Replace ``HID`` to ``HIS``. + +See Also +-------- +* :py:func:`replace_residue` +""" + +replace_HIE_to_HIS = partial(replace_residue, resin="HIE", resout="HIS") +""" +Replace ``HIE`` to ``HIS``. + +See Also +-------- +* :py:func:`replace_residue` +""" + + +@_report("Remove unsupported molecules") +def remove_unsupported_molecules( + lines: Iterable[str], + haddock3_defined: Optional[set[str]] = None, + user_defined: Optional[set[str]] = None, + line_startswith: Union[str, tuple[str, ...]] = ("ATOM", "HETATM"), +) -> Generator[str, None, None]: + """ + Remove HADDOCK3 unsupported molecules. + + This function is abstract and you need to provide the set of + residues supported by HADDOCK3. See parameters. + + Residues not provided in ``haddock3_defined`` and ``user_defined`` + are removed from the PDB lines. + + Other lines are yieled unmodified. + + Parameters + ---------- + lines : list or list-like + Lines of the PDB file. This function will consumes lines over a + ``for`` loop; mind it if you use a generator. + + haddock3_defined : set + Set of residues supported by HADDOCK3. + Defaults to ``None``. + + user_defined : set + An additional set of allowed residues given by the user. + Defaults to ``None``. + + line_startswith : tuple + The lines to consider. Defaults to ``("ATOM", "HETATM")``. + + Yields + ------ + line : str + Line-by-line. + Lines for residues not supported are *not* yielded. + + See Also + -------- + Other functions use this function to create context. + + * :py:func:`remove_unsupported_atom` + * :py:func:`remove_unsupported_hetatm` + """ + user_defined = user_defined or set() + haddock3_defined = haddock3_defined or set() + allowed = set.union(haddock3_defined, user_defined) + + # find a way to report this + not_allowed_found: set[str] = set() + + for line in lines: + if line.startswith(line_startswith): + residue = line[slc_resname].strip() + if residue in allowed: + yield line + else: + not_allowed_found.add(residue) + continue + else: + yield line + + return + + +remove_unsupported_hetatm = partial( + remove_unsupported_molecules, + haddock3_defined=supported_HETATM, + line_startswith="HETATM", +) +""" +Remove unsupported molecules in ``HETATM`` lines. + +Uses :py:func:`remove_unsupported_molecules` by populating its +``haddock3_define`` and ``line_startswith`` parameters. + +See Also +-------- +* :py:func:`remove_unsupported_atom` +""" + +remove_unsupported_atom = partial( + remove_unsupported_molecules, + haddock3_defined=supported_ATOM, + line_startswith="ATOM", +) +""" +Remove unsupported molecules in ``ATOM`` lines. + +Uses :py:func:`remove_unsupported_molecules` by populating its +``haddock3_define`` and ``line_startswith`` parameters. + +See Also +-------- +* :py:func:`remove_unsupported_hetatm` +""" + + +@_report("Add charges to ions.") +def add_charges_to_ions(fhandler: Iterable[str]) -> Generator[str, None, None]: + """ + Add charges to ions according to HADDOCK3 specifications. + + 1. Check if charge is correctly defined in residue name. + If so, yield the line with correct residue name and charge at the + end. + 2. Check if charge is correctly defined in atom name. + 3. Create charge from element. This might need manual edit in case + the atom as an unconventional charge. + + Parameters + ---------- + fhandler : file-hanlder, list, or list-like + Lines of the PDB file. This function will consumes lines over a + ``for`` loop; mind it if you use a generator. + + Yields + ------ + line : str + Line-by-line: modified ion lines and any other line. + """ + # list of functions that correct ion entries + # by order of preference in case a preference is not found. + # see further + ion_correction_cases = [ + _process_ion_case_atom, + _process_ion_case_resname, + _process_ion_case_element_charge, + ] + + for line in fhandler: + if line.startswith(("ATOM", "ANISOU", "HETATM")): + # get values + atom = line[slc_name].strip() # max 4 chars + resname = line[slc_resname].strip() # max 3 chars + element = line[slc_element].strip() # max 2 chars + charge = line[slc_charge].strip() # max 2 chars + + if resname in supported_non_ions: + yield line + continue + + # Which of the above fields has information on the charge? + # If more than one have information on the charge, we give + # the preference to the atom, resname, and then charge + func_to_apply = False + if atom[-1].isdigit(): + func_to_apply = _process_ion_case_atom # type: ignore + elif resname[-1].isdigit(): + func_to_apply = _process_ion_case_resname # type: ignore + elif element and charge and charge[-1].isdigit(): + func_to_apply = _process_ion_case_element_charge # type: ignore + + if func_to_apply: + yield func_to_apply(line) # type: ignore + + # in case none of the fields has information on the charge, + # applies the process functions by giving preference to the + # residue names. + else: + for func in ion_correction_cases: + try: + yield func(line) + except Exception: + # test the next function + continue + else: + break # done + else: + yield line # lines that do not concern to ions + + else: + yield line # lines that are not atoms + + +def _process_ion_case_resname(line: str) -> str: + """ + Process ion information based on resnames. + + case 1: charge is correctly defined in resname, for example, ZN2. + In this case, ignore other fields and write ion information from + scratch even if it's already correct. + """ + resname = line[slc_resname].strip() # max 3 chars + new_atom = supported_single_ions_resnames_map[resname].atoms[0] + new_element = supported_single_ions_resnames_map[resname].elements[0] + charge = new_atom[-2:] if len(new_atom) > 2 else " " + + new_line = ( + line[:12] + + format_atom_name(new_atom, new_element) + + line[16] + + resname.rjust(3, " ") + + line[20:76] + + new_element.rjust(2, " ") + + charge + ) + + return new_line + + +def _process_ion_case_atom(line: str) -> str: + """ + Process ion information based on atom names. + + case 2: charge is correctly defined in atom name ignore other fields + and write them from scratch even if they are already correct. + """ + element = line[slc_element].strip() # max 2 chars + if element == "C": + # element C can have atom name CA which conflicts carbon alpha + # and calcium + raise ValueError("Element is 'C', does not apply to this case.") + + atom = line[slc_name].strip() # max 4 chars + new_resname = supported_single_ions_atoms_map[atom].resname + new_element = supported_single_ions_atoms_map[atom].elements[0] + charge = atom[-2:] if len(atom) > 2 else " " + + new_line = ( + line[:12] + + format_atom_name(atom, new_element) + + line[16] + + new_resname.rjust(3, " ") + + line[20:76] + + new_element.rjust(2, " ") + + charge + ) + + return new_line + + +def _process_ion_case_element_charge(line: str) -> str: + """ + Process ion information based on element and charge. + + case 3: charge is correctly defined in atom name ignore other fields + and write them from scratch even if they are already correct. + """ + element = line[slc_element].strip() # max 2 chars + charge = line[slc_charge].strip() # max 2 chars + atom = element + charge + new_resname = supported_single_ions_atoms_map[atom].resname + + new_line = ( + line[:12] + + format_atom_name(atom, element) + + line[16] + + new_resname.rjust(3, " ") + + line[20:76] + + element.rjust(2, " ") + + charge + ) + + return new_line + + +@_report("Convert record: {!r} to {!r}.") +def convert_record( + fhandler: Iterable[str], record: str, other_record: str, residues: Container[str] +) -> Generator[str, None, None]: + """ + Convert on record to another for specified residues. + + For example, replace ``ATOM`` by ``HETATM`` for specific residues. + + Parameters + ---------- + fhandler : list-like + Contains lines of file. + + record : str + The PDB RECORD to match; for example, ``ATOM`` or ``HETATM``. + + other_record : str + The PDB RECORD to replace with; for example, ``ATOM`` or ``HETATM``. + + residues : list, tuple, or set + List of residues to replace the record. + """ + for line in fhandler: + if line.startswith(record): + resname = line[slc_resname].strip() + if resname in residues: + yield other_record + line[6:] + continue + yield line + + +convert_ATOM_to_HETATM = partial( + convert_record, + record="ATOM", + other_record="HETATM", + residues=supported_HETATM, +) +""" +Convert ``ATOM`` to ``HETATM`` for HADDOCK3 supported ``HETATM``. + +See Also +-------- +* :py:data:`haddock.core.supported_molecules.supported_HETATM` +""" + +convert_HETATM_to_ATOM = partial( + convert_record, + record="HETATM", + other_record="ATOM ", + residues=supported_ATOM, +) +""" +Convert ``HETATM`` to ``ATOM`` for HADDOCK3 supported ``ATOM``. + +See Also +-------- +* :py:data:`haddock.core.supported_molecules.supported_ATOM` +""" + + +# Functions operating in the whole PDB + + +@_report("Solving chain/seg ID issues.") +def solve_no_chainID_no_segID(lines: Iterable[str]) -> Iterable[str]: + """ + Solve inconsistencies with chainID and segID. + + If segID is non-existant, copy chainID over segID, and vice-versa. + If none are present, adds an upper case char starting from A. This + char is not repeated until the alphabet exhausts. + If chainIDs and segIDs differ, copy chainIDs over segIDs. + + Parameters + ---------- + lines : list of str + The lines of a PDB file. + + Returns + ------- + list + With new lines. Or the input ones if no modification was made. + """ + chainids = read_chainids(lines) + segids = read_segids(lines) + + if not chainids and segids: + new_lines = pdb_segxchain.run(lines) + + elif chainids and not segids: + new_lines = pdb_chainxseg.run(lines) + + elif not chainids and not segids: + _chains = pdb_chain.run(lines, next(_CHAINS)) + new_lines = pdb_chainxseg.run(_chains) + + # gives priority to chains + elif chainids != segids: + new_lines = pdb_chainxseg.run(lines) + + else: + # nothing to do + return lines + + return list(new_lines) + + +# TODO: needs to become an option. +# change chain ID and shift the residue of the other chains. +# also needs to be sync with the restraints. +# maybe not an automatic.. maybe used as a CLI +# maybe is a place to have a CHECK instead of a autoprocess +@_report("Homogenizes chains") +def homogenize_chains(lines: list[str]) -> list[str]: + """ + Homogenize chainIDs within the same PDB. + + If there are multiple chain identifiers in the PDB file, make all + them equal to the first one. + + ChainIDs are copied to segIDs afterwards. + + Returns + ------- + list + The modified lines. + """ + chainids = read_chainids(lines) + if len(set(chainids)) > 1: + return list( + chainf( + lines, + partial(pdb_chain.run, chain_id=chainids[0]), + pdb_chainxseg.run, + ) + ) + else: + return lines + + +# Functions operating in all PDBs at once + + +def correct_equal_chain_segids(structures: list[list[str]]) -> list[list[str]]: + """ + Correct for repeated chainID in the input PDB files. + + Repeated chain IDs are replaced by an upper case character (``[A-Z]``) + in order. + + Parameters + ---------- + structures : list of lists of str + The input data. + + Returns + ------- + list of lists of str + The new structures. + """ + _all_chains = (read_chainids(s) for s in structures) + # set of all chain IDs present in the input PDBs + all_chain_ids = set(it.chain.from_iterable(_all_chains)) + + # the remaining available chain characters are the A-Z minus the + # `all_chain_ids` + remaining_chars = it.cycle(sorted(set(_ascii_letters).difference(all_chain_ids))) + + chain_ids: list[Iterable[str]] = [] + new_structures: list[list[str]] = [] + for lines in structures: + new_lines: Optional[list[str]] = None + + # read chain IDs from the structure + chain_id = read_chainids(lines) + + # if chain_id is repeated + if chain_id in chain_ids: + new_lines = list( + chainf( + lines, + # change the chain ID by a new one + partial(pdb_chain.run, chain_id=next(remaining_chars)), + # applies chain ID to seg ID as well + pdb_chainxseg.run, + ) + ) + else: + chain_ids.append(chain_id) + + new_structures.append(new_lines or lines) + + if len(new_structures) != len(structures): + raise AssertionError("Number of lines differ. This is a bug!") + return new_structures + + +# this id bad +@_report("Check models are the same") +def models_should_have_the_same_labels(lines: Iterable[str]) -> Iterable[str]: + """ + Confirm models have the same labels. + + In an ensemble of structures, where the PDB file has multiple MODELS, + all models should have the same labels; hence the same number and + typ of atoms. + + Parameters + ---------- + lines : list of strings. + List containing the lines of the PDB file. Must NOT be a generator. + + Returns + ------- + list + The original ``lines`` in case no errors are found. + + Raises + ------ + ModelsDifferError + In case MODELS differ. Reports on which models differ. + """ + # searchers for the first MODEL line. If found, break the loop + # and continue to the rest of the function. + # + # if not found, return the same input lines. + for line in lines: + if line.startswith("MODEL"): + break + else: + return lines + + # captures all the models + models: dict[Optional[int], set[str]] = {} + new_model: list[str] = [] + new_model_id = None + for line in lines: + if line.startswith("MODEL"): + if new_model_id is not None: + models[new_model_id] = set(new_model) + new_model.clear() + new_model_id = int(line[10:14]) + + elif line.startswith(("ATOM", "HETATM")): + new_model.append(line[12:27]) + else: + models[new_model_id] = set(new_model) + new_model.clear() + + # check if all MODELS are equal, performing all vs all comparison + keys = list(models.keys()) + first_key = keys[0] + for model_num in keys[1:]: + if models[model_num] != models[first_key]: + emsg = f"Labels in MODEL {model_num} differ from MODEL {first_key}." + raise ModelsDifferError(emsg) + + return lines diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/gear/restart_run.py b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/restart_run.py new file mode 100644 index 0000000000000000000000000000000000000000..a973bc960104ae70efc0a6299f25a84a8faa3452 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/restart_run.py @@ -0,0 +1,67 @@ +"""Features to allow run restart from a given step.""" +from argparse import ArgumentParser, ArgumentTypeError +from functools import partial +from pathlib import Path + +from haddock.libs.libutil import non_negative_int, remove_folder +from haddock.modules import get_module_steps_folders + + +_help_cli = """Restart the run from a given step. Previous folders from +the selected step onward will be deleted.""" + + +_arg_non_neg_int = partial( + non_negative_int, + exception=ArgumentTypeError, + emsg="Minimum value is 0, {!r} given.", + ) + + +def add_restart_arg(parser: ArgumentParser) -> None: + """Add `--restart` option to argument parser.""" + parser.add_argument( + "--restart", + type=_arg_non_neg_int, + default=None, + help=_help_cli, + ) + + +def remove_folders_after_number(run_dir: Path, num: int) -> None: + """ + Remove calculation folder after (included) a given number. + + Example + ------- + If the following step folders exist: + + 00_topoaa + 01_rigidbody + 02_mdref + 03_flexref + + and the number `2` is given, folders `02_` and `03_` will be + deleted. + + Parameters + ---------- + run_dir : pathlib.Path + The run directory. + + num : int + The number of the folder from which to delete calculation step + folders. `num` must be non-negative integer, or equivalent + representation. + """ + num = _arg_non_neg_int(num) + previous = get_module_steps_folders(run_dir.resolve()) + # Filters step folders based on their indices + from_num_folders = [ + folder for folder in previous + if int(folder.split('_')[0]) >= num + ] + # Loop over folders to remove + for torm_folder in from_num_folders: + remove_folder(Path(run_dir, torm_folder)) + return diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/gear/validations.py b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/validations.py new file mode 100644 index 0000000000000000000000000000000000000000..3279584c00fc3dd94d6d3a2593303ece9514845d --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/validations.py @@ -0,0 +1,107 @@ +"""Module to define specific validations in Haddock3.""" +from haddock import config_expert_levels, _hidden_level +from haddock.core.defaults import RUNDIR, valid_run_dir_chars +from haddock.core.exceptions import ConfigurationError +from haddock.core.typing import FilePath, Any, ParamDict +from haddock.libs.libio import read_from_yaml, check_yaml_duplicated_parameters + +_allowed_expert_levels = config_expert_levels + ("all", _hidden_level) +YAML_PARAMETER_BASE_SCHEME = ( + 'title', 'short', 'long', 'group', 'explevel', 'type', 'default', + ) +TYPE_SPECIFIC_SCHEMES = { + "integer": ("min", "max", ), + "float": ("min", "max", "precision", ), + "string": ("minchars", "maxchars", ), + "list": ("minitems", "maxitems", ), + "boolean": (), + "file": (), + "dict": (), + } + + +def v_rundir(rundir: FilePath) -> None: + """Validate string defining the run directory.""" + if set(str(rundir)) - set(valid_run_dir_chars): + emsg = ( + f"The {RUNDIR!r} parameter can only have " + r"[a-zA-Z0-9._-/\] characters." + ) + raise ConfigurationError(emsg) + + +def validate_yaml_params_scheme(yaml_fpath: FilePath) -> None: + """Validate a defaults.yaml file module parameters schemes. + + Parameters + ---------- + yaml_fpath : str + Path to the defaults.yaml file to check. + """ + ycfg = read_from_yaml(yaml_fpath) + # Loop over parameters + for param_name, parameters in ycfg.items(): + try: + validate_parameter_scheme(param_name, parameters) + except AssertionError as error: + raise AssertionError(f"{error} (in {yaml_fpath})") + + +def validate_parameter_scheme( + param_name: str, + parameters: ParamDict, + ) -> None: + """Validate a parameter scheme. + + Parameters + ---------- + param_name : str + Name of this parameter. + parameters : dict[str, Any] + Dictionary of param, value for this parameter. + """ + for base_subparam in YAML_PARAMETER_BASE_SCHEME: + # Check that this parameter contain the basic subparameters + assert base_subparam in parameters.keys(), f"Parameter '{param_name}' is missing base subparam '{base_subparam}'" # noqa : E501 + # Point avlue of this parameter + param_value = parameters[base_subparam] + # Evaluate expertize level + if base_subparam == "explevel": + # Check if expert level is ok + assert parameters[base_subparam] in _allowed_expert_levels, f"Parameter '{param_name}' do not contain appropriate expert level" # noqa : E501 + # Once we know the type, we can make parameter type specific checks + elif base_subparam == "type": + # Check if known type + assert param_value in TYPE_SPECIFIC_SCHEMES.keys(), f"Parameter '{param_name}' contain an unknown parameter type: '{param_value}'" # noqa : E501 + # Skip subsequent checks in case of type: dict + if param_value == "dict": + # Loop over nested parameters + for dict_param_name, dict_param in parameters.items(): + # Make sure they are parameters and not base ones + if dict_param_name not in YAML_PARAMETER_BASE_SCHEME: + # Recursive calls for nested parameters + validate_parameter_scheme(dict_param_name, dict_param) + # Special case of dict, they do not have a default value... + # So we skip the presence of 'default' in this type of params. + # We break the loop before this check + break + + # Check if all specific param for this type of parameter + # are properly specified + for specific_param in TYPE_SPECIFIC_SCHEMES[param_value]: + assert specific_param in parameters.keys(), f"Parameter {param_name} is missing specific subparam '{specific_param}' for type '{base_subparam}'" # noqa : E501 + + +def validate_defaults_yaml(yaml_fpath: FilePath) -> None: + """Validate a defaults.yaml file. + + Parameters + ---------- + yaml_fpath : str + Path to the defaults.yaml file to validate. + """ + try: + check_yaml_duplicated_parameters(yaml_fpath) + validate_yaml_params_scheme(yaml_fpath) + except AssertionError as assert_error: + raise ConfigurationError(assert_error) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/gear/yaml2cfg.py b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/yaml2cfg.py new file mode 100644 index 0000000000000000000000000000000000000000..be397fa9d4373900fdbe95549597af3fbdbee263 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/yaml2cfg.py @@ -0,0 +1,287 @@ +""" +Parse data from HADDOCK3 to YAML and YAML to HADDOCK3 and related. + +Accross this file you will see references to "yaml" as variables and +function names. In these cases, we always mean the HADDOCK3 YAML +configuration files which have specific keys. +""" + +import os +from collections.abc import Mapping +from pathlib import Path +from typing import Union + +from haddock import _hidden_level, config_expert_levels +from haddock.core.exceptions import ConfigurationError +from haddock.core.typing import ( + ExpertLevel, + FilePath, + Optional, + ParamDict, + ParamMap, +) +from haddock.libs.libio import read_from_yaml + + +def yaml2cfg_text( + ymlcfg: dict, + module: str, + explevel: str, + details: bool = False, + mandatory_param: bool = False, +) -> str: + """ + Convert HADDOCK3 YAML config to HADDOCK3 user config text. + + Adds commentaries with help strings. + + Parameters + ---------- + ymlcfg : dict + The dictionary representing the HADDOCK3 config file. + + module : str + The module to which the config belongs to. + + explevel : str + The expert level to consider. Provides all parameters for that + level and those of inferior hierarchy. If you give "all", all + parameters will be considered. + + details : bool + Whether to add the 'long' description of each parameter. + + mandatory_param : bool + Whether this current parameters are mandatory ones. Special case where + this must be set as they do not contain `default` value, therefore the + downstream functions are not valid anymore. + + Returns + ------- + textual_config : str + Textual representation of a YAML configuration file. + """ + new_config: list[str] = [] + if module is not None: + new_config.append(f"[{module}]") + + new_config.append( + _yaml2cfg_text( + ymlcfg, + module, + explevel, + details=details, + mandatory_param=mandatory_param, + ) + ) + textual_config = os.linesep.join(new_config) + os.linesep + return textual_config + + +def _yaml2cfg_text( + ymlcfg: dict, + module: str, + explevel: str, + details: bool = False, + mandatory_param: bool = False, +) -> str: + """ + Convert HADDOCK3 YAML config to HADDOCK3 user config text. + + Does not consider expert levels. + See :func:`yaml2cfg_text_with_explevels` instead. + + Parameters + ---------- + ymlcfg : dict + The dictionary representing the HADDOCK3 YAML configuration. + This configuration should NOT have the expertise levels. It + expectes the first level of keys to be the parameter name. + + module : str + The module to which the config belongs to. + + explevel : str + The expert level to consider. Provides all parameters for that + level and those of inferior hierarchy. If you give "all", all + parameters will be considered. + + details : bool + Whether to add the 'long' description of each parameter. + + mandatory_param : bool + Whether this current parameters are mandatory ones. Special case where + this must be set as they do not contain `default` value, therefore the + downstream functions are not valid anymore. + + Returns + ------- + str_config : str + String representation of the YAML configuration file. + """ + params: list[str] = [] + exp_levels = { + _el: i for i, _el in enumerate(config_expert_levels + ("all", _hidden_level)) + } + exp_level_idx = exp_levels[explevel] + + # define set of undesired parameter keys + undesired = ["default", "explevel", "type"] + if not details: + # Add long description to undesired if not asked for detailed info + undesired.append("long") + + for param_name, param in ymlcfg.items(): + # Check if param is a dictionary + if isinstance(param, Mapping): + # Without `default` key parameter, assumes this `param` + # is a subdictionaries of parameters + if "default" not in param and not mandatory_param: + params.append("") # give extra space + if module is not None: + curr_module = f"{module}.{param_name}" + else: + curr_module = param_name + params.append(f"[{curr_module}]") + _ = _yaml2cfg_text( + param, # type: ignore + module=curr_module, + explevel=explevel, + details=details, + ) + params.append(_) + + # treats normal parameters + else: + if exp_levels[param["explevel"]] > exp_level_idx: + # ignore this parameter because is of an expert level + # superior to the one request: + continue + + comment: list[str] = [] + for _comment, cvalue in param.items(): + if _comment in undesired: + continue + + if cvalue == "": + continue + + comment.append(f"${_comment} {cvalue}") + + # In the case of mandatory global parameters, there is + # no defined default parameters, so we create a `fake` one + if mandatory_param: + default_value = "Must be defined!" + else: + default_value = param["default"] + + # boolean values have to be lower for compatibility + # with toml cfg + if isinstance(default_value, bool): + default_value = str(default_value).lower() + param_line = "{} = {} # {}" + else: + param_line = "{} = {!r} # {}" + + params.append( + param_line.format( + param_name, + default_value, + " / ".join(comment), + ) + ) + + if param["type"] == "list": + params.append(os.linesep) + + else: + # ignore some other parameters that are defined for sections. + continue + + # Generate one single string containing all parameters representation + str_config = os.linesep.join(params) + return str_config + + +def read_from_yaml_config( + cfg_file: Union[Path, str], default_only: bool = True +) -> dict: + """Read config from yaml by collapsing the expert levels. + + Parameters + ---------- + cfg_file : + Path to a .yaml configuration file + default_only : bool + Set the return value of this function; if True (default value), only + returns default values, else return the fully loaded configuration file + + Return + ------ + ycfg : dict + The full default configuration file as a dict + OR + cfg : dict + A dictionary containing only the default parameters values + """ + ycfg = read_from_yaml(cfg_file) + if default_only: + # there's no need to make a deep copy here, a shallow copy suffices. + cfg = {} + cfg.update(flat_yaml_cfg(ycfg)) + return cfg + return ycfg + + +def flat_yaml_cfg(cfg: ParamMap) -> ParamDict: + """Flat a yaml config.""" + new: ParamDict = {} + for param, values in cfg.items(): + try: + new_value = values["default"] + except KeyError: + new_value = flat_yaml_cfg(values) + except TypeError: + # happens when values is a string for example, + # addresses `explevel` in `mol*` topoaa. + continue + else: + # coordinates with tests. + # users should not edit yaml files. So this error triggers + # only during development + if "explevel" not in values: + emsg = f"`explevel` not defined for: {param!r}" + raise ConfigurationError(emsg) + + new[param] = new_value + + return new + + +def find_incompatible_parameters(yaml_file: Path) -> dict[str, ParamDict]: + """ + Reads a YAML configuration file and identifies nodes containing the 'incompatible' key. + + This function takes the path to a YAML file, reads its contents, and searches for nodes + that include an 'incompatible' key. It returns a dictionary where each key is a node name + and each value is another dictionary representing the 'incompatible' parameters for that node. + + Parameters + ---------- + yaml_file : Path + The path to the YAML file to be read. + + Return + ------ + incompatible_parameters : dict[str, dict[str, str]] + A dictionary with node names as keys and their corresponding + 'incompatible' parameters as values. + """ + config = read_from_yaml(yaml_file=yaml_file) + + # Go over each node and see which contains the `incompatible` key + incompatible_parameters = {} + for node, values in config.items(): + if "incompatible" in values: + incompatible_parameters[node] = values["incompatible"] + return incompatible_parameters diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/gear/zerofill.py b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/zerofill.py new file mode 100644 index 0000000000000000000000000000000000000000..ec0f3bef69a95069d3d43be091ec82423b59814f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/gear/zerofill.py @@ -0,0 +1,135 @@ +""" +Handles zero filling prefix for module folder names. + +To facilitate folder sorting, HADDOCK3 module run folder names have a +integer prefix starting at 0. + +Depending on the number of modules of the run, the integer prefix is a +single digit number or multi-digit number (00, 01, 02, 03...). + +This gear module contains the "zero filling" logic in HADDOCK 3. + +The main class of this module `zerofill` is already instantiated such +that its state can be used and edited throughout the HADDOCK3 library. + +Examples +-------- +>>> from haddock.gear import zerofill +>>> zerofill.read(modules) # a dictionary containing 11 modules +>>> zerofill.zfnum +2 +>>> zerofill.fill("topoaa", 0) +"00_topoaa" +""" +from math import ceil, log10 +from typing import Sized + + +class _ZeroFill: + """ + Register the zero fill number. + + Examples + -------- + >>> _ZeroFill() + >>> zerofill.read(modules) # a dictionary containing five modules + >>> zerofill.zfnum + 1 + + >>> zerofill.fill("topoaa", 0) + "0_topoaa" + + >>> zerofill.fill("rigidbody", 2) + "2_rigidbody" + """ + + def __init__(self, zfnum: int = 1) -> None: + self._zfnum = zfnum + return + + @property + def zfnum(self) -> int: + """ + The zerofill number. + + That is, the number of digits that the numeric prefix has. + """ # noqa: D401 + return self._zfnum + + def set_zerofill_number(self, num_steps: int) -> None: + """ + Register the zerofill number given a certain number of steps. + + Parameters + ---------- + num_steps : int + The number of steps in the run. + """ + self._zfnum = get_zerofill_for_modules(list(range(num_steps))) + + def read(self, modules: Sized) -> None: + """ + Register the zerofill number for current run. + + Zero fill number if available through the attribute: `zfnum`. + + Parameters + ---------- + iterable + Usually a dictionary or a list of the modules names. + Any object implementing `len`. + """ + self._zfnum = get_zerofill_for_modules(modules) + + def fill(self, name: str, num: int) -> str: + """ + Fill a name with the corresponding zero filling. + + Examples + -------- + >>> zerofill.zfum + 1 + + >>> zerofill.fill("topoaa", 0) + "0_topoaa" + + >>> zerofill.fill("rigidody", 1) + "1_rigidbody" + """ + return make_zero_fill(num, self.zfnum) + "_" + name + + +zero_fill = _ZeroFill() + + +def get_number_of_digits(num: int) -> int: + """ + Get the number of digits of a number. + + 10 has two digits. + 100 has three digits. + """ + # also: return len(str(num)) :-) + return max(ceil(log10(num + 1)), 1) + + +def get_zerofill_for_modules(modules: Sized) -> int: + """ + Get a the prefix zerofill for modules. + + If there are 5 modules, zerofill digits is 1. + + If there are 10 modules, zerofill digits is 1 because counting + starts at 0 (for topoaa). + + If there are 100 modules, zerofill digits is 2 because counting + starts at 0 (for topoaa). + + This function is used in combination with `zero_fill`. + """ + return get_number_of_digits(len(modules) - 1) + + +def make_zero_fill(number: int, digits: int) -> str: + """Make a number string zero filled to the left.""" + return str(number).zfill(digits) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/libs/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b88c12c4174af859ad88109193df36442c89c4df --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/__init__.py @@ -0,0 +1,3 @@ +""" +Libraries used throughout the project. +""" diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libalign.py b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libalign.py new file mode 100644 index 0000000000000000000000000000000000000000..365dd93fb6c896eefa65f171d1ebdcc475fa5616 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libalign.py @@ -0,0 +1,1387 @@ +""" +Library of functions to perform sequence and structural alignments. + +Main functions +-------------- + +* :py:func:`calc_rmsd` +* :py:func:`centroid` +* :py:func:`kabsch` +* :py:func:`load_coords` +* :py:func:`pdb2fastadic` +* :py:func:`get_atoms` +* :py:func:`get_align` +* :py:func:`align_struct` +* :py:func:`align_seq` +* :py:func:`make_range` +* :py:func:`dump_as_izone` +""" + +import os +import shlex +import subprocess +from functools import partial +from pathlib import Path + +import numpy as np +from Bio import Align +from Bio.Align import substitution_matrices +from Bio.Seq import Seq + +from haddock import log +from haddock.core.typing import AtomsDict, FilePath, Literal, NDFloat, Optional +from haddock.libs.libio import pdb_path_exists +from haddock.libs.libontology import PDBFile, PDBPath +from haddock.libs.libpdb import ( + slc_chainid, + slc_element, + slc_name, + slc_resname, + slc_resseq, + slc_x, + slc_y, + slc_z, + split_by_chain, + ) + + +RES_TO_BE_IGNORED = ["SHA", "WAT"] + +PROT_RES = [ + "ALA", + "ARG", + "ASN", + "ASP", + "CYS", + "GLN", + "GLU", + "GLY", + "HIS", + "ILE", + "LEU", + "LYS", + "MET", + "PHE", + "PRO", + "SER", + "THR", + "TRP", + "TYR", + "VAL", +] + +DNA_RES = ["DA", "DC", "DT", "DG"] +# Backbone +PROT_ATOMS = ["C", "N", "CA", "O"] +# Side chains +PROT_SIDE_CHAINS_DICT = { + "ALA": ["C", "N", "CA", "O", "CB"], + "ARG": ["C", "N", "CA", "O", "CB", "CG", "CD", "NE", "CZ", "NH1", "NH2"], + "ASN": ["C", "N", "CA", "O", "CB", "CG", "OD1", "ND2"], + "ASP": ["C", "N", "CA", "O", "CB", "CG", "OD1", "OD2"], + "CYS": ["C", "N", "CA", "O", "CB", "SG"], + "GLN": ["C", "N", "CA", "O", "CB", "CG", "CD", "OE1", "NE2"], + "GLU": ["C", "N", "CA", "O", "CB", "CG", "CD", "OE1", "OE2"], + "GLY": ["C", "N", "CA", "O"], + "HIS": ["C", "N", "CA", "O", "CB", "CG", "ND1", "CD2", "CE1", "NE2"], + "ILE": ["C", "N", "CA", "O", "CB", "CG1", "CG2", "CD1"], + "LEU": ["C", "N", "CA", "O", "CB", "CG", "CD1", "CD2"], + "LYS": ["C", "N", "CA", "O", "CB", "CG", "CD", "CE", "NZ"], + "MET": ["C", "N", "CA", "O", "CB", "CG", "SD", "CE"], + "PHE": ["C", "N", "CA", "O", "CB", "CG", "CD1", "CD2", "CE1", "CE2", "CZ"], + "PRO": ["C", "N", "CA", "O", "CB", "CG", "CD"], + "SER": ["C", "N", "CA", "O", "CB", "OG"], + "THR": ["C", "N", "CA", "O", "CB", "OG1", "CG2"], + "TRP": [ + "C", + "N", + "CA", + "O", + "CB", + "CG", + "CD1", + "CD2", + "NE1", + "CE2", + "CE3", + "CZ2", + "CZ3", + "CH2", + ], + "TYR": [ + "C", + "N", + "CA", + "O", + "CB", + "CG", + "CD1", + "CD2", + "CE1", + "CE2", + "CZ", + "OH", + ], + "VAL": ["C", "N", "CA", "O", "CB", "CG1", "CG2"], +} + +# Bases +DNA_ATOMS = [ + "C5", + "N9", + "N2", + "C8", + "O2", + "N4", + "N7", + "C7", + "N1", + "N6", + "C2", + "O4", + "C6", + "N3", + "C4", + "O6", +] + +DNA_FULL_DICT = { + "DA": [ + "P", + "O1P", + "O2P", + "O5'", + "C5'", + "C4'", + "O4'", + "C1'", + "N9", + "C4", + "N3", + "C2", + "N1", + "C6", + "N6", + "C5", + "N7", + "C8", + "C2'", + "C3'", + "O3'", + "N2", + "O2", + "N4", + "C7", + "O4", + "O6", + ], + "DG": [ + "P", + "O1P", + "O2P", + "O5'", + "C5'", + "C4'", + "O4'", + "C1'", + "N9", + "C4", + "N3", + "C2", + "N2", + "N1", + "C6", + "O6", + "C5", + "N7", + "C8", + "C2'", + "C3'", + "O3'", + "O2", + "N4", + "C7", + "N6", + "O4", + ], + "DC": [ + "P", + "O1P", + "O2P", + "O5'", + "C5'", + "C4'", + "O4'", + "C1'", + "N1", + "C6", + "C2", + "O2", + "N3", + "C4", + "N4", + "C5", + "C2'", + "C3'", + "O3'", + "N9", + "N2", + "C8", + "N7", + "C7", + "N6", + "O4", + "O6", + ], + "DT": [ + "P", + "O1P", + "O2P", + "O5'", + "C5'", + "C4'", + "O4'", + "C1'", + "N1", + "C6", + "C2", + "O2", + "N3", + "C4", + "O4", + "C5", + "C7", + "C2'", + "C3'", + "O3'", + "N9", + "N2", + "C8", + "N4", + "N7", + "N6", + "O6", + ], +} + +RNA_RES = ["A", "G", "C", "U"] +RNA_ATOMS = ["P", "O5'", "C5'", "C4'", "C3'", "O3'"] + +RNA_FULL_DICT = { + "A": [ + "P", + "OP1", + "OP2", + "O5'", + "C5'", + "C4'", + "O4'", + "C3'", + "O3'", + "C2'", + "O2'", + "C1'", + "N9", + "C8", + "N7", + "C5", + "C6", + "N6", + "N1", + "C2", + "N3", + "C4", + ], + "G": [ + "P", + "OP1", + "OP2", + "O5'", + "C5'", + "C4'", + "O4'", + "C3'", + "O3'", + "C2'", + "O2'", + "C1'", + "N9", + "C8", + "N7", + "C5", + "C6", + "O6", + "N1", + "C2", + "N2", + "N3", + "C4", + ], + "C": [ + "P", + "OP1", + "OP2", + "O5'", + "C5'", + "C4'", + "O4'", + "C3'", + "O3'", + "C2'", + "O2'", + "C1'", + "N9", + "C5", + "C6", + "O6", + "N1", + "C2", + "N2", + "N3", + "C4", + "N4", + ], + "U": [ + "P", + "OP1", + "OP2", + "O5'", + "C5'", + "C4'", + "O4'", + "C3'", + "O3'", + "C2'", + "O2'", + "C1'", + "N1", + "C2", + "O2", + "N3", + "C4", + "O4", + "C5", + "C6", + ], +} + + +class ALIGNError(Exception): + """Raised when something goes wrong with the ALIGNMENT library.""" + + def __init__(self, msg: object = "") -> None: + self.msg = msg + super().__init__(self.msg) + + +def calc_rmsd(V: NDFloat, W: NDFloat) -> float: + """ + Calculate the RMSD from two vectors. + + Parameters + ---------- + V : np.array dtype=float, shape=(n_atoms,3) + W : np.array dtype=float, shape=(n_atoms,3) + + Returns + ------- + rmsd : float + """ + diff = np.array(V) - np.array(W) + N = len(V) + rmsd = np.sqrt((diff * diff).sum() / N) + return rmsd + + +def kabsch(P: NDFloat, Q: NDFloat) -> NDFloat: + """ + Find the rotation matrix using Kabsch algorithm. + + Parameters + ---------- + P : np.array dtype=float, shape=(n_atoms,3) + Q : np.array dtype=float, shape=(n_atoms,3) + + Returns + ------- + U : np.array dtype=float, shape=(3,3) + """ + # Covariance matrix + P = np.array(P) + Q = np.array(Q) + C = np.dot(np.transpose(P), Q) + # use SVD + V, S, W = np.linalg.svd(C) + d = (np.linalg.det(V) * np.linalg.det(W)) < 0.0 + if d: + S[-1] = -S[-1] + V[:, -1] = -V[:, -1] + # Create Rotation matrix U + U = np.dot(V, W) + return U + + +def centroid(X: NDFloat) -> NDFloat: + """ + Get the centroid. + + Parameters + ---------- + X : np.array dtype=float, shape=(n_atoms,3) + + Returns + ------- + C : np.array dtype=float, shape=(3,) + """ + X = np.array(X) + C = X.mean(axis=0) + return C + + +def load_coords( + pdb_f, + atoms, + filter_resdic=None, + numbering_dic=None, + model2ref_chain_dict=None, + add_resname=None, + keep_hetatm: bool = False, +): + """Load coordinates from PDB. + + Parameters + ---------- + pdb_f : PDBFile + + atoms : dict + dictionary of atoms + + filter_resdic : dict + dictionary of residues to be loaded (one list per chain) + + numbering_dic : dict + dict of numbering dictionaries (one dictionary per chain) + + add_resname : bool + use the residue name in the identifier + + keep_hetatm : bool + Should HETATM lines be considered ? + + Returns + ------- + coord_dic : dict + dictionary of coordinates (one per chain) + + chain_ranges: dict + dictionary of chain ranges + """ + coord_dic: CoordsDict = {} + chain_dic: ResDict = {} + idx: int = 0 + # Set types of coordinates lines to extract + if keep_hetatm: + coordinates_line_to_extract = ("ATOM", "HETATM", ) + else: + coordinates_line_to_extract = ("ATOM", ) + # Check filetype + if isinstance(pdb_f, PDBFile): + pdb_f = pdb_f.rel_path + # Read file + with open(pdb_f, "r") as fh: + for line in fh.readlines(): + # Skip non ATOM records lines + if not line.startswith(coordinates_line_to_extract): + continue + # Extract PDB line data + atom_name = line[slc_name].strip() + resname = line[slc_resname].strip() + # Skip entries to be ignored + if resname in RES_TO_BE_IGNORED: + continue + else: + if atom_name not in atoms[resname]: + continue + # Continue parsing of the PDB line + chain = line[slc_chainid] + resnum = int(line[slc_resseq]) + x = float(line[slc_x]) + y = float(line[slc_y]) + z = float(line[slc_z]) + coords = np.asarray([x, y, z]) + # Remap chain name + if model2ref_chain_dict: + # Skip chain matching if not present in reference structure + if chain not in model2ref_chain_dict.keys(): + continue + chain = model2ref_chain_dict[chain] + + if numbering_dic: + try: + resnum = numbering_dic[chain][resnum] + except KeyError: + # this residue is not matched, and so it should + # not be considered + # self.log( + # f"WARNING: {chain}.{resnum}.{atom_name}" + # " was not matched!" + # ) + continue + + # Create identifier tuple + if add_resname is True: + identifier = (chain, resnum, atom_name, resname) + else: + identifier = (chain, resnum, atom_name) + # Create empty chain entries + if chain not in chain_dic.keys(): + if filter_resdic: + if chain in filter_resdic.keys(): + chain_dic[chain] = [] + else: + chain_dic[chain] = [] + + # Check if must eventually filter this entry + if filter_resdic: + # Only retrieve coordinates from the filter_resdic + if chain in filter_resdic.keys(): + if resnum in filter_resdic[chain]: + coord_dic[identifier] = coords + chain_dic[chain].append(idx) + idx += 1 + else: + # retrieve everything + coord_dic[identifier] = coords + chain_dic[chain].append(idx) + idx += 1 + + # Obtain chain ranges + chain_ranges: ChainsRange = {} + for chain, indice in chain_dic.items(): + # Check if NONE residues indices were extracted (empty list) + if not indice: + continue + else: + min_idx = min(indice) + max_idx = max(indice) + chain_ranges[chain] = (min_idx, max_idx) + + # Check that chain_ranges is not empty + # NOTE: this may happen when filter_resdic is defined on a different set + # of chains or residues + if chain_ranges == {}: + # Build error message + _err_msg = ( + f"Chain matching error on {pdb_f}! " + f"Filtering scheme used: {filter_resdic}." + "\nPlease check the input file and queried filterings." + ) + # Raise the error + raise ALIGNError(_err_msg) + return coord_dic, chain_ranges + + +def get_atoms(pdb: PDBPath, full: bool = False) -> AtomsDict: + """Identify what is the molecule type of each PDB. + + Parameters + ---------- + pdb : PosixPath or :py:class:`haddock.libs.libontology.PDBFile` + PDB file to have its atoms identified + full : bool + Weather or not to take `full` atoms into consideration. + If False, only main-chain atoms retrieved. + If True, all heavy atoms retrieved. + + Returns + ------- + atom_dic : dict + dictionary of atoms + """ + atom_dic: AtomsDict = {} + atom_dic.update((r, PROT_ATOMS) for r in PROT_RES) + atom_dic.update((r, DNA_ATOMS) for r in DNA_RES) + atom_dic.update((r, RNA_ATOMS) for r in RNA_RES) + if full: + atom_dic.update(PROT_SIDE_CHAINS_DICT) + atom_dic.update(DNA_FULL_DICT) + atom_dic.update(RNA_FULL_DICT) + + if isinstance(pdb, PDBFile): + pdb = pdb.rel_path + + exists, msg = pdb_path_exists(pdb) + if not exists: + raise Exception(msg) + + with open(pdb) as fh: + for line in fh.readlines(): + if line.startswith(("ATOM", "HETATM")): + resname = line[slc_resname].strip() + atom_name = line[slc_name].strip() + element = line[slc_element].strip() + if all( + [ + resname not in PROT_RES, + resname not in DNA_RES, + resname not in RNA_RES, + resname not in RES_TO_BE_IGNORED, + ] + ): + # its neither DNA/RNA nor protein, use the heavy atoms + # WARNING: Atoms that belong to unknown residues must + # be bound to a residue name; + # For example: residue NEP, also contains + # CB and CG atoms, if we do not bind it to the + # residue name, the next functions will include + # CG and CG atoms in the calculations for all + # other residue names + if element != "H": + if resname not in atom_dic: + atom_dic[resname] = [] + if atom_name not in atom_dic[resname]: + atom_dic[resname].append(atom_name) + return atom_dic + + +ResCode = Literal[ + "C", + "D", + "S", + "Q", + "K", + "I", + "P", + "T", + "F", + "N", + "G", + "H", + "L", + "R", + "W", + "A", + "V", + "E", + "Y", + "M", + "A", + "G", + "C", + "T", + "X", +] +""" +The single letter code of a residue. + +Unrecognized residues' code is `X`. +""" + + +def pdb2fastadic(pdb_f: PDBPath, keep_hetatm: bool = False) -> dict[str, dict[int, str]]: + """ + Write the sequence as a fasta. + + Parameters + ---------- + pdb_f : PosixPath or :py:class:`haddock.libs.libontology.PDBFile` + Path to a PDB file. + keep_hetatm : bool + Should HETATM coordinates be kept ? + + Returns + ------- + seq_dic : dict + dict of fasta sequences (one per chain) + """ + res_codes = dict( + [ + ("CYS", "C"), + ("ASP", "D"), + ("SER", "S"), + ("GLN", "Q"), + ("LYS", "K"), + ("ILE", "I"), + ("PRO", "P"), + ("THR", "T"), + ("PHE", "F"), + ("ASN", "N"), + ("GLY", "G"), + ("HIS", "H"), + ("LEU", "L"), + ("ARG", "R"), + ("TRP", "W"), + ("ALA", "A"), + ("VAL", "V"), + ("GLU", "E"), + ("TYR", "Y"), + ("MET", "M"), + ("DA", "A"), + ("DG", "G"), + ("DC", "C"), + ( + "DT", + "T", + ), # 9/8/2023: adding non-standard amino-acids (src/haddock/cns/toppar/protein-allhdg5-4.top) # noqa: E501 + ("ALY", "K"), + ("ASH", "D"), + ("CFE", "C"), + ("CSP", "C"), + ("CYC", "C"), + ("CYF", "C"), + ("CYM", "C"), + ("DDZ", "A"), + ("GLH", "E"), + ("HLY", "P"), + ("HY3", "P"), + ("HYP", "P"), + ("M3L", "K"), + ("MLY", "K"), + ("MLZ", "K"), + ("MSE", "M"), + ("NEP", "H"), + ("PNS", "S"), + ("PTR", "Y"), + ("SEP", "S"), + ("TOP", "T"), + ("TYP", "Y"), + ("TYS", "Y"), + ] + ) + + seq_dic: dict[str, dict[int, str]] = {} + + if isinstance(pdb_f, PDBFile): + pdb_f = pdb_f.rel_path + + coord_req = ("ATOM", "HETATM", ) if keep_hetatm else ("ATOM", ) + with open(pdb_f) as fh: + for line in fh.readlines(): + if line.startswith(coord_req): + res_num = int(line[slc_resseq]) + res_name = line[slc_resname].strip() + chain = line[slc_chainid] + if res_name in RES_TO_BE_IGNORED: + continue + try: + one_letter = res_codes[res_name] + except KeyError: + one_letter = "X" + if chain not in seq_dic: + seq_dic[chain] = {} + seq_dic[chain][res_num] = one_letter + return seq_dic + + +def get_align( + method: str, lovoalign_exec: FilePath, keep_hetatm: bool = False, +) -> partial[dict[str, dict[int, int]]]: + """ + Get the alignment function. + + Parameters + ---------- + method : str + Available options: ``sequence`` and ``structure``. + + lovoalign_exec : str + Path to the lovoalign executable. + + keep_hetatm : bool + Should HETATM be considered in the analysis ? + + Returns + ------- + align_func : functools.partial + desired alignment function + """ + if method == "structure": + align_func = partial(align_strct, lovoalign_exec=lovoalign_exec) + elif method == "sequence": + align_func = partial(align_seq, keep_hetatm=keep_hetatm) + else: + available_alns = ("sequence", "structure") + raise ValueError( + f"Alignment method {method!r} not recognized. " + f"Available options are {', '.join(available_alns)}" + ) + return align_func + + +def align_strct( + reference: PDBFile, + model: PDBFile, + output_path: FilePath, + lovoalign_exec: Optional[FilePath] = None, +) -> dict[str, dict[int, int]]: + """ + Structuraly align and get numbering relationship. + + Parameters + ---------- + reference : :py:class:`haddock.libs.libontology.PDBFile` + + model : :py:class:`haddock.libs.libontology.PDBFile` + + output_path : Path + + lovoalign_exec : Path + lovoalign executable + + Returns + ------- + numbering_dic : dict + dict of numbering dictionaries (one dictionary per chain) + """ + if lovoalign_exec is None: + log.error( + "Structural alignment needs LovoAlign " "get it at github.com/m3g/lovoalign" + ) + raise ALIGNError("Path to LovoAlign executable required.") + + if not lovoalign_exec: + raise ALIGNError("lovoalign_exec parameter not defined ") + + if not os.access(lovoalign_exec, os.X_OK): + raise ALIGNError(f"{lovoalign_exec!r} for LovoAlign is not executable") + + numbering_dic: dict[str, dict[int, int]] = {} + protein_a_dic = { + e.stem.split("_")[-1]: e for e in split_by_chain(reference.rel_path) + } + protein_b_dic = {e.stem.split("_")[-1]: e for e in split_by_chain(model.rel_path)} + + # check if chain ids match + if protein_a_dic.keys() != protein_b_dic.keys(): + # TODO: Make this a clearer raise + return numbering_dic + + for chain in protein_a_dic.keys(): + pa_seqdic = pdb2fastadic(protein_a_dic[chain]) + pb_seqdic = pdb2fastadic(protein_b_dic[chain]) + # logging.debug(f"Structurally aligning chain {chain}") + numbering_dic[chain] = {} + cmd = ( + f"{lovoalign_exec} -p1 {protein_a_dic[chain]} " + f"-p2 {protein_b_dic[chain]} " + f"-c1 {chain} -c2 {chain}" + ) + + # logging.debug(f"Command is: {cmd}") + p = subprocess.run(shlex.split(cmd), capture_output=True, text=True) + lovoalign_out = p.stdout.split(os.linesep) + + # we don"t need the splitted proteins anymore + protein_a_dic[chain].unlink() + protein_b_dic[chain].unlink() + + # find out where the alignment starts and ends + alignment_pass = True + for i, line in enumerate(lovoalign_out): + if "SEQUENCE ALIGNMENT" in line: + # there are 2 extra white lines after this header + alignment_start_index = i + 2 + elif "FINAL" in line: + # there are 2 extra white lines after this header + alignment_end_index = i - 2 + elif "ERROR" in line: + failed_pdb = line.split()[-1] + _msg = f"LovoAlign could not read {failed_pdb} " "is it a ligand?" + log.warning(_msg) + alignment_pass = False + + for elem in [k for k in pa_seqdic[chain]]: + numbering_dic[chain][elem] = elem + + if not alignment_pass: + # This alignment failed, move on to the next + log.warning( + f"Skipping alignment of chain {chain}, " "used sequential matching" + ) + continue + + aln_l = lovoalign_out[alignment_start_index:alignment_end_index] + + # dump this alignment to a file + aln_fname = Path(output_path, f"lovoalign_{chain}.aln") + with open(aln_fname, "w") as fh: + fh.write(os.linesep.join(aln_l)) + + # remove the line between the alignment segments + alignment = [aln_l[i : i + 3][:2] for i in range(0, len(aln_l), 3)] + # 100% (5 identical nucleotides / min(length(A),length(B))). + len_seq_a = len(pa_seqdic[chain]) + len_seq_b = len(pb_seqdic[chain]) + identity = ( + (len_seq_a - sum([e[0].count("-") for e in alignment])) + / min(len_seq_a, len_seq_b) + * 100 + ) + + if identity <= 40.0: + log.warning( + f'"Structural" identity of chain {chain} is {identity:.2f}%' + ", please check the results carefully" + ) + else: + log.info(f'"Structural" identity of chain {chain} is {identity:.2f}%') + + # logging.debug("Reading alignment and matching numbering") + for element in alignment: + line_a, line_b = element + + resnum_a, seq_a, _ = line_a.split() + resnum_b, seq_b, _ = line_b.split() + + resnum_a = int(resnum_a) - 1 # type: ignore + resnum_b = int(resnum_b) - 1 # type: ignore + + for resname_a, resname_b in zip(seq_a, seq_b): + if resname_a != "-": + resnum_a += 1 # type: ignore + + if resname_b != "-": + resnum_b += 1 # type: ignore + + if resname_a != "-" and resname_b != "-": + numbering_dic[chain][resnum_b] = resnum_a # type: ignore + + izone_fname = Path(output_path, "lovoalign.izone") + dump_as_izone(izone_fname, numbering_dic) + + return numbering_dic + + +def write_alignment(top_aln, output_path, ref_ch): + """ + Write the alignment to a file. + + Parameters + ---------- + top_aln : Bio.Align.PairwiseAlignments + alignment object + + ref_ch : str + reference chain + """ + aln_fname = Path(output_path, f"blosum62_{ref_ch}.aln") + with open(aln_fname, "w") as fh: + fh.write(str(top_aln)) + return aln_fname + + +def sequence_alignment(seq_ref, seq_model): + """ + Perform a sequence alignment. + + Parameters + ---------- + seq_ref : str + reference sequence + + seq_model : str + model sequence + + Returns + ------- + identity : float + sequence identity + + top_aln : Bio.Align.PairwiseAlignments + alignment object + + aln_ref_seg : tuple + aligned reference segment + + aln_mod_seg : tuple + aligned model segment + """ + aligner = Align.PairwiseAligner() + aligner.substitution_matrix = substitution_matrices.load("BLOSUM62") + alns = aligner.align(seq_ref, seq_model) + top_aln = alns[0] + + aln_denom = min(len(seq_ref), len(seq_model)) + identity = (str(top_aln).count("|") / float(aln_denom)) * 100 + + aln_ref_seg, aln_mod_seg = top_aln.aligned + # check alignment length + len_ref = len(aln_ref_seg) + len_mod = len(aln_mod_seg) + if len_ref != len_mod: + raise ALIGNError(f"Alignment length mismatch ({len_ref} != {len_mod})") + + return identity, top_aln, aln_ref_seg, aln_mod_seg + + +class SeqAlign: + """SeqAlign class.""" + + def __init__(self): + """Initialize the class.""" + self.align_dic = {} # the alignment dictionary, important for CAPRI + self.model2ref_chain_dict = {} # model to reference chain dictionary + self.ref2model_chain_dict = {} # reference to model chain dictionary + self.seqdic_ref = None # reference sequence dictionary + self.seqdic_model = None # model sequence dictionary + self.seqs_ref = {} # reference sequences + self.seqs_model = {} # model sequences + self.identities = [] # list of identity values + self.aln_model_segs = [] # list of aligned model segments + self.aln_ref_segs = [] # list of aligned reference segments + self.top_alns = [] # list of alignment objects + + def postprocess_alignment(self, ref_ch, mod_ch, align_id): + """ + Postprocess the alignment. + + Parameters + ---------- + ref_ch : str + reference chain + mod_ch : str + model chain + align_id : int + alignment id (index of the alignment) + """ + self.align_dic[ref_ch] = {} + if not np.any(self.top_alns[align_id].aligned): + # No alignment! + log.warning( + f"No alignment for chain {ref_ch} is it protein/dna-rna? " + "Matching sequentially" + ) + if all("X" in s for s in self.seqs_ref[ref_ch]) and all( + "X" in s for s in self.seqs_model[mod_ch] + ): + # this sequence contains only ligands, do it manually + if len(self.seqs_ref[ref_ch]) != len(self.seqs_model[mod_ch]): + # we cannot handle this + # FIXME: This should raise a proper exception instead + raise f"Cannot align chain {mod_ch}" # noqa: B016 + for ref_res, model_res in zip( + self.seqdic_ref[ref_ch], self.seqdic_model[mod_ch] + ): + self.align_dic[ref_ch].update({model_res: ref_res}) + else: + identity = self.identities[align_id] + if identity <= 40.0: + # Identity is very low + log.warning( + f"Sequence identity of chain {ref_ch} is " + f"{identity:.2f}%, please check the results carefully" + ) + else: + log.debug( + f"Sequence identity between chain {ref_ch} " + f" of reference and {mod_ch} of model is " + f"{identity:.2f}%" + ) + for ref_segment, model_segment in zip( + self.aln_ref_segs[align_id], self.aln_model_segs[align_id] + ): + start_ref_segment, end_ref_segment = ref_segment + start_model_segment, end_model_segment = model_segment + reslist_ref = list(self.seqdic_ref[ref_ch].keys())[ + start_ref_segment:end_ref_segment + ] + reslist_model = list(self.seqdic_model[mod_ch].keys())[ + start_model_segment:end_model_segment + ] + for _ref_res, _model_res in zip(reslist_ref, reslist_model): + self.align_dic[ref_ch].update({_model_res: _ref_res}) + + +def align_seq(reference, model, output_path, keep_hetatm: bool = False): + """ + Sequence align and get the numbering relationship. + + Parameters + ---------- + reference : PosixPath or :py:class:`haddock.libs.libontology.PDBFile` + + model : PosixPath or :py:class:`haddock.libs.libontology.PDBFile` + + output_path : Path + + keep_hetatm : bool + Should HETATM be considered when performing the alignment ? + + Returns + ------- + align_dic : dict + dictionary of sequence alignments (one per chain) + """ + SeqAln = SeqAlign() + SeqAln.seqdic_ref = pdb2fastadic(reference, keep_hetatm=keep_hetatm) + SeqAln.seqdic_model = pdb2fastadic(model, keep_hetatm=keep_hetatm) + + # assign sequences + for ref_ch in SeqAln.seqdic_ref.keys(): + ref_seq = Seq("".join(SeqAln.seqdic_ref[ref_ch].values())) + SeqAln.seqs_ref[ref_ch] = ref_seq + for mod_ch in SeqAln.seqdic_model.keys(): + mod_seq = Seq("".join(SeqAln.seqdic_model[mod_ch].values())) + SeqAln.seqs_model[mod_ch] = mod_seq + + # check if chain ids match + if SeqAln.seqdic_ref.keys() != SeqAln.seqdic_model.keys(): + # they do not match, we need to do chain matching + n_partners = min(len(SeqAln.seqdic_ref.keys()), len(SeqAln.seqdic_model.keys())) + + # unique combinations of chains + combs = [] + for ref_key in SeqAln.seqdic_ref.keys(): + for mod_key in SeqAln.seqdic_model.keys(): + combs.append((ref_key, mod_key)) + identities = [] + aln_model_segs = [] + aln_ref_segs = [] + top_alns = [] + # loop over combinations + for ref_ch, mod_ch in combs: + # align + identity, top_aln, aln_ref_seg, aln_mod_seg = sequence_alignment( + SeqAln.seqs_ref[ref_ch], SeqAln.seqs_model[mod_ch] + ) + # append values to lists + identities.append(identity) + aln_model_segs.append(aln_mod_seg) + aln_ref_segs.append(aln_ref_seg) + top_alns.append(top_aln) + # chain matching + matches = 0 # counter for matched chains + while matches < n_partners: + # get the best alignment + max_identity = max(identities) + max_idx = identities.index(max_identity) + # assigning chains + ref_ch, mod_ch = combs[max_idx] + SeqAln.model2ref_chain_dict[mod_ch] = ref_ch + SeqAln.ref2model_chain_dict[ref_ch] = mod_ch + SeqAln.aln_ref_segs.append(aln_ref_segs[max_idx]) + SeqAln.aln_model_segs.append(aln_model_segs[max_idx]) + SeqAln.identities.append(identities[max_idx]) + SeqAln.top_alns.append(top_alns[max_idx]) + + # writing the alignment + write_alignment(top_alns[max_idx], output_path, ref_ch) + + # postprocess alignment + SeqAln.postprocess_alignment(ref_ch, mod_ch, matches) + # update identities to avoid double matches + identities = [ + identities[n] if combs[n][0] != ref_ch and combs[n][1] != mod_ch else -1 + for n in range(len(combs)) + ] + matches += 1 + log.info(f"model2ref chain matching is {SeqAln.model2ref_chain_dict}") + else: + # chains do match. no need to do chain matching. Chains are the same. + # of course if the structures do not correspond the output will be a + # mess + matches = 0 + for ref_ch in SeqAln.seqdic_ref.keys(): + SeqAln.model2ref_chain_dict[ref_ch] = ref_ch + SeqAln.ref2model_chain_dict[ref_ch] = ref_ch + # extract sequences + seq_ref = SeqAln.seqs_ref[ref_ch] + seq_model = SeqAln.seqs_model[ref_ch] + # sequence alignment + identity, top_aln, aln_ref_seg, aln_mod_seg = sequence_alignment( + seq_ref, seq_model + ) + # update quantities + SeqAln.identities.append(identity) + SeqAln.aln_model_segs.append(aln_mod_seg) + SeqAln.aln_ref_segs.append(aln_ref_seg) + SeqAln.top_alns.append(top_aln) + # write alignment + write_alignment(top_aln, output_path, ref_ch) + # postprocess alignment + SeqAln.postprocess_alignment(ref_ch, ref_ch, matches) + matches += 1 + # dump the .izone file + izone_fname = Path(output_path, "blosum62.izone") + dump_as_izone(izone_fname, SeqAln.align_dic, SeqAln.ref2model_chain_dict) + + return SeqAln.align_dic, SeqAln.model2ref_chain_dict + + +def make_range( + chain_range_dic: dict[str, list[int]], +) -> dict[str, tuple[int, int]]: + """ + Expand a chain dictionary into ranges. + + Parameters + ---------- + chain_range_dic : dict + dictionary of chain indexes (one list per chain) + + Returns + ------- + chain_ranges : dict + dictionary of chain ranges (one tuple per chain) + """ + chain_ranges: dict[str, tuple[int, int]] = {} + for chain in chain_range_dic: + min_idx = min(chain_range_dic[chain]) + max_idx = max(chain_range_dic[chain]) + chain_ranges[chain] = (min_idx, max_idx) + return chain_ranges + + +def dump_as_izone(fname, numbering_dic, model2ref_chain_dict=None): + """ + Dump the numbering dictionary as .izone. + + Parameters + ---------- + fname : str + output filename + + numbering_dic : dict + dict of numbering dictionaries (one dictionary per chain) + """ + # FIXME: Collapse the izones so its faster to load in profit + with open(fname, "w") as fh: + for chain in numbering_dic: + for bound_res in numbering_dic[chain]: + unbound_res = numbering_dic[chain][bound_res] + unb_chain = chain + if model2ref_chain_dict: + unb_chain = model2ref_chain_dict[chain] + # + izone_str = ( + "ZONE " + f"{chain}{bound_res}:{unb_chain}{unbound_res}" + f"{os.linesep}" + ) + fh.write(izone_str) + + +def rearrange_xyz_files(output_name: FilePath, path: FilePath, ncores: int) -> None: + """Combine different xyz outputs in a single file. + + Parameters + ---------- + output_name : FilePath + output name + + path : FilePath + path to the output files + + ncores : int + number of cores + """ + output_fname = Path(path, output_name) + # take the name without the xyz extension + output_fname_str = output_fname.stem + log.info(f"rearranging xyz files into {output_fname}") + # Combine files + with open(output_fname, "w") as out_file: + for core in range(ncores): + tmp_file = Path(path, output_fname_str + "_" + str(core) + ".xyz") + with open(tmp_file) as infile: + out_file.write(infile.read()) + log.debug(f"File number {core} written") + tmp_file.unlink() + log.info("Completed reconstruction of xyz files.") + log.info(f"{output_fname} created.") + + +def check_common_atoms(models, filter_resdic, allatoms, atom_similarity): + """ + Check if the models share the same atoms. + + Parameters + ---------- + models : list + list of models + + filter_resdic : dict + dictionary of residues to be loaded (one list per chain) + + allatoms : bool + use all the heavy atoms + + atom_similarity : float + minimum atom similarity required between models + + Returns + ------- + n_atoms : int + number of common atoms + + common_keys : list + list of common atom keys + """ + # checking the common keys + common_keys: list[str] = [] + coord_keys_lengths = [] + for mod in models: + atoms: AtomsDict = get_atoms(mod, allatoms) + + ref_coord_dic, _ = load_coords(mod, atoms, filter_resdic) + coord_keys_lengths.append(len(ref_coord_dic.keys())) + if common_keys != []: + common_keys = set(ref_coord_dic.keys()).intersection(common_keys) + else: + common_keys = ref_coord_dic.keys() + + # checking the common atoms + n_atoms = len(common_keys) # common atoms + max_n_atoms = max(coord_keys_lengths) + perc = (n_atoms / max_n_atoms) * 100 + if perc == 100.0: + log.info("All the models share the same atoms.") + elif perc > atom_similarity and perc < 100.0: + # if it's between 0.9 and 1, it's likely that the models share the same atoms + # but still the user may want to see a warning + log.warning( + "Not all the atoms are common to all the models." + f" Common atoms ({n_atoms}) != max_n_atoms {max_n_atoms}. Similarity ({perc:.2f}%) higher than allowed ({atom_similarity:.2f}%)." + ) + else: + # common keys are less than 90% of the previous keys + # something is likely wrong + _err_msg = ( + "Input atoms are not the same for all the models." + f" Common atoms ({n_atoms}) != max_n_atoms {max_n_atoms}. Similarity ({perc:.2f}%) lower than allowed ({atom_similarity:.2f}%)." + " Please check the input ensemble." + ) + raise ALIGNError(_err_msg) + return n_atoms, list(common_keys) + + +# TODO: Add type signature +def check_chains(obs_chains, inp_r_chain, inp_l_chains): + """Check observed chains against the expected ones. + + Logic: if at least one of inp_l_chains is among the observed chains and is + not selected as the receptor chain, then ligand_chains is equal to this + interesection. Otherwise, ligand_chains becomes equal to all the other + chains (once receptor chain is removed). + + Parameters + ---------- + obs_chains : list + List of observed chains. + + inp_r_chain : str + Receptor chain. + + inp_l_chains : list + List of ligand chains. + """ + # Find receptor chain + r_chain = inp_r_chain if inp_r_chain in obs_chains else obs_chains[0] + # Remove it so cannot be selected as ligand chain + obs_chains.remove(r_chain) + # Define ligand chain(s) + l_chains = [el for el in inp_l_chains if el in obs_chains] + # If empty, select all remaining chains + if not l_chains: + l_chains = [el for el in obs_chains] + return r_chain, l_chains diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libcli.py b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libcli.py new file mode 100644 index 0000000000000000000000000000000000000000..d3bbe6d80f98b22e3e7f68af8f8ce9c9a44adb3e --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libcli.py @@ -0,0 +1,105 @@ +"""Add functionalities for CLIs.""" +from argparse import Action, ArgumentParser, ArgumentTypeError +from functools import partial +from pathlib import Path + +from haddock import version +from haddock.libs.libio import file_exists, folder_exists + + +arg_file_exist = partial( + file_exists, + exception=ArgumentTypeError, + emsg="File {!r} does not exist or is not a file.", +) + +arg_folder_exist = partial( + folder_exists, + exception=ArgumentTypeError, + emsg="Folder {!r} does not exist.", +) + + +def add_version_arg(ap: ArgumentParser) -> None: + """Add version `-v` argument to client.""" + ap.add_argument( + "-v", + "--version", + help="show version", + action="version", + version=f"{ap.prog} - {version}", + ) + + +def add_rundir_arg(ap: ArgumentParser) -> None: + """Add run directory option.""" + ap.add_argument( + "run_dir", + help="The run directory.", + type=arg_folder_exist, + ) + + +def add_ncores_arg(ap: ArgumentParser) -> None: + """Add number of cores option.""" + ap.add_argument( + "-n", + "--ncores", + dest="ncores", + help=( + "The number of threads to use. Uses 1 if not specified. " + "Uses all available threads if `-n` is given. Else, uses the " + "number indicated, for example: `-n 4` will use 4 threads." + ), + type=int, + default=1, + const=None, + nargs="?", + ) + + +def add_output_dir_arg(ap: ArgumentParser) -> None: + """Add output dir argument.""" + ap.add_argument( + "-odir", + "--output-directory", + dest="output_directory", + help="The directory where to save the output.", + type=Path, + default=Path.cwd(), + ) + + +class _ParamsToDict(Action): + """ + Convert command-line parameters in an argument to a dictionary. + + Example + ------- + + Where ``-x`` is an optional argument of the command-line client + interface. + + >>> par1 1 par2 'my name' par3 [1,2,3] par4 True + >>> {'par1': 1, 'par2': 'my name', 'par3': [1, 2, 3]} + + """ + + def __call__(self, parser, namespace, ivalues, option_string=None): + """Execute.""" + params = ivalues[::2] + values = ivalues[1::2] + + if len(params) != len(values): + raise parser.error( + "The parameters and value pairs " "do not match for argument `-p`" + ) + + param_dict = {} + for k, v in zip(params, values): + try: + param_dict[k] = v + except (ValueError, TypeError, SyntaxError): + raise parser.error(f"Parameter {k} with invalid value {v}") + + setattr(namespace, self.dest, param_dict) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libclust.py b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libclust.py new file mode 100644 index 0000000000000000000000000000000000000000..3650e97fe7251961c6c3091ee18b0670f34ee3a7 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libclust.py @@ -0,0 +1,316 @@ +""" +Library of functions related to the clustering modules. + +Main functions +-------------- + +* :py:func:`write_unclustered_list` +* :py:func:`plot_cluster_matrix` +""" + +import os +from pathlib import Path + +from haddock import log +from haddock.core.typing import FilePath, Union, ParamDictT, Optional +from haddock.libs.libontology import PDBFile +from haddock.libs.libplots import heatmap_plotly + +import numpy as np +from scipy.spatial.distance import squareform + + +MAX_NB_ENTRY_HTML_MATRIX = 3100 + + +def write_structure_list(input_models: list[PDBFile], + clustered_models: list[PDBFile], + out_fname: FilePath) -> None: + """ + Get the list of unclustered structures. + + Parameters + ---------- + input_models : list + list of input models + clustered_models : list + list of clustered models + """ + output_fname = Path(out_fname) + output_str = f'rank\tmodel_name\tscore\tcluster_id{os.linesep}' + structure_list: list[PDBFile] = [] + # checking which input models have not been clustered + for model in input_models: + if model not in clustered_models: + model.clt_id = "-" + structure_list.append(model) + # extending and sorting + structure_list.extend(clustered_models) + structure_list.sort(key=lambda model: model.score) + # adding models to output string + for mdl_rank, mdl in enumerate(structure_list, start=1): + output_str += ( + f'{mdl_rank}\t{mdl.file_name}\t{mdl.score:.2f}\t{mdl.clt_id}' + f'{os.linesep}' + ) + output_str += os.linesep + log.info(f'Saving structure list to {out_fname}') + with open(output_fname, 'w') as out_fh: + out_fh.write(output_str) + + +def plot_cluster_matrix( + matrix_path: Union[Path, FilePath, str], + final_order_idx: list[int], + labels: list[str], + dttype: str = '', + diag_fill: Union[int, float] = 1, + color_scale: str = "Blues", + reverse: bool = False, + output_fname: Union[str, Path, FilePath] = 'clust_matrix', + matrix_cluster_dt: Optional[list[list[list[int]]]] = None, + cluster_limits: Optional[list[dict[str, float]]] = None, + ) -> Optional[str]: + """Plot a plotly heatmap of a matrix file. + + Parameters + ---------- + matrix_path : Union[Path, FilePath, str] + Path to a half-matrix + final_order_idx : list[int] + Index orders + labels : list[str] + Ordered labels + dttype : str + Name of the data type, by default `` + color_scale : str, optional + Color scale for the plot, by default "Blues" + reversed : bool, optional + Should the color scale be reversed ?, by default False + output_fname : Union[str, Path, FilePath], optional + Name of the output file to generate, by default 'clust_matrix.html' + matrix_cluster_dt: Optional[list[list[list[int]]]] + A matrix of cluster ids, used for extra hover annotation in plotly. + cluster_limits: Optional[list[dict[str, float]]] + A list of dict enabling to draw lines separating cluster ids. + + Return + ------ + output_fname_ext : str + Path to the generated file containing the figure. + """ + # Check that we will be able to generate a functional interactive plot + if len(final_order_idx) > MAX_NB_ENTRY_HTML_MATRIX: + return None + + upper_diag, lower_diag = [], [] + # Read matrix + with open(matrix_path, "r") as f: + # Loop over lines + for _ in f: + # Split line + s_ = _.strip().split() + # Point first value + uv = float(s_[2]) + # Point second value (if exists) + lv = float(s_[3]) if len(s_) == 4 else uv + # Hold them + upper_diag.append(uv) + lower_diag.append(lv) + + # Genereate full matrix from N*(N-1)/2 vector + upper_matrix = squareform(upper_diag) + lower_matrix = squareform(lower_diag) + # Update diagonal with data + np.fill_diagonal(upper_matrix, diag_fill) + + # Full matrix (lower triangle + upper triangle) + full_matrix = np.tril(lower_matrix, k=-1) + np.triu(upper_matrix) + + # Extract submatrix of selected models and re-order them + submat = full_matrix[np.ix_(final_order_idx, final_order_idx)] + + # Check if must reverse the colorscale + if reverse: + if color_scale[-2:] == '_r': + color_scale = color_scale[:-2] + else: + color_scale += '_r' + + # Define hovering tempalte string + if matrix_cluster_dt: + hovertemplate = ( + f' {dttype}: %{{z}}
' + f' Model1: %{{x}} ClusterID: %{{customdata[0]}}
' + f' Model2: %{{y}} ClusterID: %{{customdata[1]}} ' + '' + ) + else: + hovertemplate = ( + f' {dttype}: %{{z}}
' + f' Model1: %{{x}}
' + f' Model2: %{{y}} ' + '' + ) + + # Generate file name + output_fname_ext = f"{output_fname}.html" + # Draw heatmap + heatmap_plotly( + submat, + labels={'color': dttype}, + xlabels=labels, + ylabels=labels, + color_scale=color_scale, + title=f"{dttype} clustering matrix", + output_fname=output_fname_ext, + hovertemplate=hovertemplate, + customdata=matrix_cluster_dt, + delineation_traces=cluster_limits, + ) + # Return generated filepath + return output_fname_ext + + +def get_cluster_matrix_plot_clt_dt( + cluster_ids: list[int], + ) -> tuple[list[list[list[int]]], list[dict[str, float]]]: + """Generate cluster matrix data for plotly. + + Parameters + ---------- + cluster_ids : list[int] + List containing ordered cluster ids. + + Returns + ------- + matrix_cluster_dt: list[list[list[int]]] + A matrix of cluster ids, used for plotly. + + cluster_limits: list[dict[str, float]]] + Boundaries to draw lines between clusters with plotly. + """ + # Set custom data + matrix_cluster_dt = [ + [[clix, cliy] for clix in cluster_ids] + for cliy in cluster_ids + ] + # Build delineation lines + del_ind = -0.5 + del_posi = [] + current_clid = cluster_ids[0] + for clid in cluster_ids: + if clid != current_clid: + del_posi.append(del_ind) + current_clid = clid + del_ind += 1 + cluster_limits = [ + { + "x0": delpos, + "x1": delpos, + "y0": -0.5, + "y1": len(cluster_ids) - 0.5, + } + for delpos in del_posi + ] + [ + { + "y0": delpos, + "y1": delpos, + "x0": -0.5, + "x1": len(cluster_ids) - 0.5, + } + for delpos in del_posi + ] + return matrix_cluster_dt, cluster_limits + + +def rank_clusters(clt_dic, threshold): + """ + Rank the clusters by their average score. + + Parameters + ---------- + clt_dic : :obj:`dict` + Dictionary with the clusters. + + threshold : int + Number of models to consider for the average score. + + Returns + ------- + score_dic : :obj:`dict` + Dictionary with the cluster ID as key and the average score as value. + + sorted_score_dic : :obj:`list` + List of tuples with the cluster ID and the average score, sorted by + the average score. + """ + score_dic = {} + for clt_id in clt_dic: + score_l = [p.score for p in clt_dic[clt_id]] + score_l.sort() + denom = float(min(threshold, len(score_l))) + top4_score = sum(score_l[:threshold]) / denom + score_dic[clt_id] = top4_score + + sorted_score_dic = sorted(score_dic.items(), key=lambda k: k[1]) + return score_dic, sorted_score_dic + + +def add_cluster_info(sorted_score_dic, clt_dic): + """ + Add cluster information to the models. + + Parameters + ---------- + sorted_score_dic : :obj:`list` + List of tuples with the cluster ID and the average score, sorted by + the average score. + + clt_dic : :obj:`dict` + Dictionary with the clusters. + + Returns + ------- + output_models : :obj:`list` + List of models with the cluster information. + """ + # Add this info to the models + output_models = [] + for cluster_rank, _e in enumerate(sorted_score_dic, start=1): + cluster_id, _ = _e + # sort the models by score + clt_dic[cluster_id].sort() + # rank the models + for model_ranking, pdb in enumerate(clt_dic[cluster_id], + start=1): + pdb.clt_id = int(cluster_id) + pdb.clt_rank = cluster_rank + pdb.clt_model_rank = model_ranking + output_models.append(pdb) + return output_models + + +def clustrmsd_tolerance_params( + parameters: ParamDictT, + ) -> tuple[str, Union[int, float]]: + """Provide parameters of interest for clust rmsd. + + Parameters + ---------- + parameters : ParamDictT + The clustrmsd module parameters + + Returns + ------- + tuple[str, Union[int, float]] + Name of the tolerance parameter and its value. + """ + # adjust the parameters + if parameters["criterion"] == "maxclust": + tolerance_param_name = "n_clusters" + tolerance = parameters[tolerance_param_name] + else: # Expected to be parameters["criterion"] == "distance" + tolerance_param_name = "clust_cutoff" + tolerance = parameters[tolerance_param_name] + return tolerance_param_name, tolerance diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libcns.py b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libcns.py new file mode 100644 index 0000000000000000000000000000000000000000..f39bc8b78ec8e5bcb03190a7000dd93560c6ad4f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libcns.py @@ -0,0 +1,441 @@ +"""CNS scripts util functions.""" + +import itertools +import math +from functools import partial +from os import linesep +from pathlib import Path + +from haddock import EmptyPath, log +from haddock.core import cns_paths +from haddock.core.typing import Any, FilePath, FilePathT, Optional, Union +from haddock.libs import libpdb +from haddock.libs.libfunc import false, true +from haddock.libs.libmath import RandomNumberGenerator +from haddock.libs.libontology import PDBFile +from haddock.libs.libpdb import check_combination_chains +from haddock.libs.libutil import transform_to_list + + +RND = RandomNumberGenerator() + + +def generate_default_header( + path: Optional[FilePath] = None, +) -> tuple[str, str, str, str, str, str]: + """Generate CNS default header.""" + # TODO: Remove the `type: ignore` comments + if path is not None: + axis = load_axis(**cns_paths.get_axis(path)) # type: ignore + link = load_link(Path(path, cns_paths.LINK_FILE)) + scatter = load_scatter(Path(path, cns_paths.SCATTER_LIB)) + tensor = load_tensor(**cns_paths.get_tensors(path)) # type: ignore + trans_vec = load_trans_vectors( + **cns_paths.get_translation_vectors(path) # type: ignore + ) # noqa: E501 + water_box = load_boxtyp20(cns_paths.get_water_box(path)["boxtyp20"]) + + else: + axis = load_axis(**cns_paths.axis) # type: ignore + link = load_link(cns_paths.link_file) + scatter = load_scatter(cns_paths.scatter_lib) + tensor = load_tensor(**cns_paths.tensors) # type: ignore + trans_vec = load_trans_vectors(**cns_paths.translation_vectors) # type: ignore + water_box = load_boxtyp20(cns_paths.water_box["boxtyp20"]) + + return ( + link, + trans_vec, + tensor, + scatter, + axis, + water_box, + ) + + +def find_desired_linkfiles( + charged_nter: bool = False, + charged_cter: bool = False, + phosphate_5: bool = False, + path: Optional[FilePath] = None, + ) -> dict[str, Path]: + """Find appropriate link files to use depending on terminis states. + + Parameters + ---------- + charged_nter : bool, optional + Must the Nter be charged ?, by default False + charged_cter : bool, optional + Must the Cter be charged ?, by default False + phosphate_5 : bool, optional + Must 5' be a phosphate ?, by default False + path : Optional[FilePath], optional + Path to where CNS topology/parameters are, by default None + + Returns + ------- + linkfiles : dict[str, Path] + Dict of CNS parameters/arguments/variable as keys + and Path to link files to be used during topology + generation. + """ + # Set output variable + linkfiles = {} + # Logic to find appropriate link for proteins + if charged_nter and charged_cter: + prot_link_key = "NH3+,COO-" + elif not charged_nter and charged_cter: + prot_link_key = "NH,COO-" + elif charged_nter and not charged_cter: + prot_link_key= "NH3+,CO" + elif not charged_nter and not charged_cter: + prot_link_key = "NH,CO" + # Point to corresponding file + linkfiles["prot_link_infile"] = cns_paths.PROTEIN_LINK_FILES[prot_link_key] + + # Logic to find linkfile for dna + nucl_link_key = "5'Phosphate" if phosphate_5 else "5'OH" + # Point to corresponding file + linkfiles["nucl_link_infile"] = cns_paths.NUCL_LINK_FILES[nucl_link_key] + # Converts to real paths + if path is not None: + linkfiles = {key: Path(path, p) for key, p in linkfiles.items()} + return linkfiles + + +def _is_nan(x: Any) -> bool: + """Inspect if is nan.""" + try: + return math.isnan(x) + except (ValueError, TypeError): + return False + + +def filter_empty_vars(v: Any) -> bool: + """ + Filter empty variables. + + See: https://github.com/haddocking/haddock3/issues/162 + + Returns + ------- + bool + Returns `True` if the variable is not empty, and `False` if + the variable is empty. That is, `False` reflects those variables + that should not be written in CNS. + + Raises + ------ + TypeError + If the type of `value` is not supported by CNS. + """ + cases = ( + (lambda x: _is_nan(x), false), + (lambda x: isinstance(x, str) and bool(x), true), + (lambda x: isinstance(x, str) and not bool(x), false), + (lambda x: isinstance(x, bool), true), # it should return True + (lambda x: isinstance(x, (EmptyPath, Path)), true), + (lambda x: type(x) in (int, float), true), + (lambda x: x is None, false), + ) + + for detect, give in cases: + if detect(v): + return give(v) + else: + emsg = f"Value {v!r} has a unknown type for CNS: {type(v)}." + log.error(emsg) + raise TypeError(emsg) + + +def load_workflow_params( + param_header: str = f"{linesep}! Parameters{linesep}", + **params: Any, +) -> str: + """ + Write the values at the header section. + + "Empty variables" are ignored. These are defined accoring to + :func:`filter_empty_vars`. + + Parameters + ---------- + params : dict + Dictionary containing the key:value pairs for the parameters to + be written to CNS. Values cannot be of dictionary type. + + Returns + ------- + param_header: str + The string with the CNS parameters defined. + """ + non_empty_parameters = ( + (k, v) for k, v in params.items() + if filter_empty_vars(v) + ) + + # types besides the ones in the if-statements should not enter this loop + for param, v in non_empty_parameters: + param_header += write_eval_line(param, v) + + assert isinstance(param_header, str) + return param_header + + +def write_eval_line(param: Any, value: Any, eval_line: str = "eval (${}={})") -> str: + """Write the CNS eval line depending on the type of `value`.""" + eval_line += linesep + + if isinstance(value, bool): + value = str(value).lower() + return eval_line.format(param, value) + + elif isinstance(value, str): + value = '"' + value + '"' + return eval_line.format(param, value) + + elif isinstance(value, Path): + value = '"' + str(value) + '"' + return eval_line.format(param, value) + + elif isinstance(value, EmptyPath): + return eval_line.format(param, '""') + + elif isinstance(value, (int, float)): + return eval_line.format(param, value) + + else: + emsg = f"Unexpected type when writing CNS header: {type(value)}" + log.error(emsg) + raise TypeError(emsg) + + +def load_link(mol_link: Path) -> str: + """Add the link header.""" + return load_workflow_params( + param_header=f"{linesep}! Link file{linesep}", + prot_link_infile=mol_link, + ) + + +load_axis = partial( + load_workflow_params, param_header=f"{linesep}! Axis{linesep}" +) # noqa: E501 +load_tensor = partial( + load_workflow_params, param_header=f"{linesep}! Tensors{linesep}" +) # noqa: E501 +prepare_output = partial( + load_workflow_params, param_header=f"{linesep}! Output structure{linesep}" +) # noqa: E501 +load_trans_vectors = partial( + load_workflow_params, param_header=f"{linesep}! Translation vectors{linesep}" +) # noqa: E501 + +load_ambig = partial(write_eval_line, "ambig_fname") +load_unambig = partial(write_eval_line, "unambig_fname") +load_hbond = partial(write_eval_line, "hbond_fname") +load_dihe = partial(write_eval_line, "dihe_f") +load_tensor_tbl = partial(write_eval_line, "tensor_tbl") + + +def load_scatter(scatter_lib: Path) -> str: + """Add scatter library.""" + return load_workflow_params( + param_header=f"{linesep}! Scatter lib{linesep}", scatter_lib=scatter_lib + ) + + +def load_boxtyp20(waterbox_param: Path) -> str: + """Add boxtyp20 eval line.""" + return load_workflow_params( + param_header=f"{linesep}! Water box{linesep}", boxtyp20=waterbox_param + ) + + +# This is used by docking +def prepare_multiple_input(pdb_input_list: list[str], psf_input_list: list[str]) -> str: + """Prepare multiple input files.""" + input_str = f"{linesep}! Input structure{linesep}" + for psf in psf_input_list: + input_str += f"structure{linesep}" + input_str += f" @@{psf}{linesep}" + input_str += f"end{linesep}" + + ncount = 1 + for pdb in pdb_input_list: + input_str += f"coor @@{pdb}{linesep}" + input_str += write_eval_line(f"input_pdb_filename_{ncount}", pdb) + ncount += 1 + + # check how many chains there are across all the PDBs + chain_l: list[list[str]] = [] + for pdb in pdb_input_list: + for element in libpdb.identify_chainseg(pdb): + chain_l.append(element) + ncomponents = len(set(itertools.chain(*chain_l))) + input_str += write_eval_line("ncomponents", ncomponents) + + return input_str + + +# This is used by Topology and Scoring +def prepare_single_input( + pdb_input: FilePath, psf_input: Union[None, FilePath, list[FilePathT]] = None +) -> str: + """Input of the CNS file. + + This section will be written for any recipe even if some CNS variables + are not used, it should not be an issue. + """ + input_str = f"{linesep}! Input structure{linesep}" + + if psf_input: + # if isinstance(psf_input, str): + input_str += f"structure{linesep}" + input_str += f" @@{psf_input}{linesep}" + input_str += f"end{linesep}" + input_str += f"coor @@{pdb_input}{linesep}" + if isinstance(psf_input, list): + input_str += f"structure{linesep}" + for psf in psf_input: + input_str += f" @@{psf}{linesep}" + input_str += f"end{linesep}" + + # $file variable is still used by some CNS recipes, need refactoring! + input_str += write_eval_line("file", pdb_input) + segids, chains = libpdb.identify_chainseg(pdb_input) + chainsegs = sorted(list(set(segids) | set(chains))) + + ncomponents = len(chainsegs) + input_str += write_eval_line("ncomponents", ncomponents) + + for i, segid in enumerate(chainsegs, start=1): + input_str += write_eval_line(f"prot_segid_{i}", segid) + + seed = RND.randint(100, 99999) + input_str += write_eval_line("seed", seed) + + return input_str + + +def prepare_cns_input( + model_number: int, + input_element: Union[PDBFile, list[PDBFile]], + step_path: FilePath, + recipe_str: str, + defaults: Any, + identifier: str, + ambig_fname: FilePath = "", + native_segid: bool = False, + default_params_path: Optional[Path] = None, + debug: Optional[bool] = False, + seed: Optional[int] = None, +) -> Union[Path, str]: + """ + Generate the .inp file needed by the CNS engine. + + Parameters + ---------- + model_number : int + The number of the model. Will be used as file name suffix. + + input_element : `libs.libontology.Persisten`, list of those + """ + # TODO: Refactor this function into smaller functions or classes + # read the default parameters + default_params = load_workflow_params(**defaults) + default_params += write_eval_line("ambig_fname", ambig_fname) + + # write the PDBs + pdb_list = [pdb.rel_path for pdb in transform_to_list(input_element)] + + # write the PSFs + psf_list: list[Path] = [] + if isinstance(input_element, (list, tuple)): + for pdb in input_element: + if isinstance(pdb.topology, (list, tuple)): + for psf in pdb.topology: + psf_fname = psf.rel_path + psf_list.append(psf_fname) + else: + if pdb.topology is None: + raise ValueError(f"Topology not found for pdb {pdb.rel_path}.") + psf_fname = pdb.topology.rel_path + psf_list.append(psf_fname) + + elif isinstance(input_element.topology, (list, tuple)): + pdb = input_element # for clarity + if pdb.topology is None: + raise ValueError(f"Topology not found for pdb {pdb.rel_path}.") + for psf in pdb.topology: + psf_fname = psf.rel_path + psf_list.append(psf_fname) + else: + pdb = input_element # for clarity + if pdb.topology is None: + raise ValueError(f"Topology not found for pdb {pdb.rel_path}.") + psf_fname = pdb.topology.rel_path + psf_list.append(psf_fname) + + input_str = prepare_multiple_input( + pdb_input_list=[str(p) for p in pdb_list], + psf_input_list=[str(p) for p in psf_list], + ) + + output_pdb_filename = f"{identifier}_{model_number}.pdb" + + output = f"{linesep}! Output structure{linesep}" + output += write_eval_line("output_pdb_filename", output_pdb_filename) + + # prepare chain/seg IDs + segid_str = "" + if native_segid: + if isinstance(input_element, (list, tuple)): + chainid_list = check_combination_chains(input_element) + + for i, _chainseg in enumerate(chainid_list, start=1): + segid_str += write_eval_line(f"prot_segid_{i}", _chainseg) + + else: + chainid_list: list[str] = [] + segids, chains = libpdb.identify_chainseg( + input_element.rel_path, sort=False + ) + + chainsegs = sorted(list(set(segids) | set(chains))) + + for i, _chainseg in enumerate(chainsegs, start=1): + segid_str += write_eval_line(f"prot_segid_{i}", _chainseg) + + output += write_eval_line("count", model_number) + + if seed is None: + seed = RND.randint(100, 99999) + + seed_str = write_eval_line("seed", seed) + + inp = default_params + input_str + seed_str + output + segid_str + recipe_str + + if not debug: + return inp + else: + inp_file = Path(f"{identifier}_{model_number}.inp") + inp_file.write_text(inp) + return inp_file + + +def prepare_expected_pdb( + model_obj: Union[PDBFile, tuple[PDBFile, ...]], + model_nb: int, + path: FilePath, + identifier: str, +) -> PDBFile: + """Prepare a PDBobject.""" + expected_pdb_fname = Path(path, f"{identifier}_{model_nb}.pdb") + pdb = PDBFile(expected_pdb_fname, path=path) + if isinstance(model_obj, tuple): + pdb.topology = [p.topology for p in model_obj] + else: + pdb.topology = model_obj.topology + pdb.seed = model_obj.seed + return pdb diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libfcc.py b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libfcc.py new file mode 100644 index 0000000000000000000000000000000000000000..bdce73dcf2224a52df6c5fee3d8e3783efb6b79f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libfcc.py @@ -0,0 +1,250 @@ +"""FCC related functions + +NOTE: This functions were ported directly from `https://github.com/haddocking/fcc`! +""" + + +class Element: + """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: + """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. + """ + line = self.members + line.append(element) + element.assign_cluster(self.name) + + +def cluster_elements(e_pool, threshold): + """ + Groups Elements within a given threshold + together in the same cluster. + """ + + cluster_list = [] + threshold -= 1 # Account for center + ep = e_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 + cluster_list.append(c) + + return ep, cluster_list + + +def output_clusters(handle, cluster): + """Outputs the cluster name, center, and members.""" + + write = handle.write + + for c in cluster: + 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") + + +def load_matrix(matrix_path) -> list[tuple[int, int, float, float]]: + """Read in a four column matrix (1 2 0.123 0.456\n) + + Parameters + ---------- + matrix_path : str or Path + Path to the matrix file + + Returns + ------- + matrix : list[tuple[int, int, float, float]] + Content of the matrix + """ + matrix: list[tuple[int, int, float, float]] = [] + with open(matrix_path, "r") as fin: + for line in fin: + ref, mobi, d_rm, d_mr = line.split() + ref = int(ref) + mobi = int(mobi) + d_rm = float(d_rm) + d_mr = float(d_mr) + matrix.append((ref, mobi, d_rm, d_mr)) + return matrix + + +def create_elements(matrix, cutoff_param, strictness): + """Creates an dictionary of Elements. + + The strictness factor is a 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_param = float(cutoff_param) + partner_cutoff = float(cutoff_param) * float(strictness) + + elements = {} + + # Loop over matrix rows + for row in matrix: + ref, mobi, d_rm, d_mr = row + + # 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 d_rm >= cutoff_param and d_mr >= partner_cutoff: + r.add_neighbor(m) + if d_mr >= cutoff_param and d_rm >= partner_cutoff: + m.add_neighbor(r) + + return elements + + +def parse_contact_file(f_list, ignore_chain): + """Parses a list of contact files.""" + + if ignore_chain: + contacts = [ + [int(line[0:5] + line[6:-1]) for line in open(con_f)] + for con_f in f_list + if con_f.strip() + ] + else: + contacts = [ + set([int(line) for line in open(con_f)]) + for con_f in f_list + if con_f.strip() + ] + + return contacts + + +def calculate_fcc(list_a, list_b): + """ + Calculates the fraction of common elements between two lists + taking into account chain IDs + """ + + cc = len(list_a.intersection(list_b)) + cc_v = len(list_b.intersection(list_a)) + + return cc, cc_v + + +def calculate_fcc_nc(list_a, list_b): + """ + Calculates the fraction of common elements between two lists + not taking into account chain IDs. Much Slower. + """ + + largest, smallest = sorted([list_a, list_b], key=len) + ncommon = len([ele for ele in largest if ele in smallest]) + return ncommon, ncommon + + +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 con in contacts: + try: + ic = 1.0 / len(con) + 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 diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libfunc.py b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libfunc.py new file mode 100644 index 0000000000000000000000000000000000000000..ab52826d33e5ad500a02caab9658b5a806f74432 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libfunc.py @@ -0,0 +1,100 @@ +""" +Tools for Functional-Programming in Python. + +From: https://github.com/joaomcteixeira/libfuncpy +""" +import time + +from functools import wraps +from operator import is_not +from typing import Any, Callable, Literal + + +def chainf(init: Any, *funcs: Callable[..., Any], **common: Any) -> Any: + """ + Apply a sequence of functions to an initial value. + + Example + ------- + >>> chainf(2, *[str, int, float]) + 2.0 + + Parameters + ---------- + init : anything + The initial value. + + **common : keyword arguments + Common key word arguments to all functions. + + Returns + ------- + anything + The result of the chain of functions; this is, the return value + of the last function. + """ + for func in funcs: + init = func(init, **common) + return init + + +def chainfs(*funcs: Callable[..., Any], **common: Any) -> Callable[..., Any]: + """ + Store functions be executed on a value. + + Example + ------- + >>> do = chainfs(str, int, float) + >>> do(2) + 2.0 + + See Also + -------- + :py:func:`chainf` + """ + def execute(value: Any) -> Any: + return chainf(value, *funcs, **common) + + return execute + + +def give_same(value: Any) -> Any: + """Return what is given.""" + return value + + +def true(*ignore: Any, **everything: Any) -> Literal[True]: + """Give True regardless of the input.""" + return True + + +def false(*ignore: Any, **everything: Any) -> Literal[False]: + """Give False regardless of the input.""" + return False + + +def none(*ignore: Any, **everything: Any) -> Literal[None]: + """Give None regardless of the input.""" + return None + + +def nan(*ignore: Any, **everything: Any) -> float: + """Give nan regardless of the input.""" + return float('nan') + + +def not_none(value: Any) -> bool: + """Give True if value is not None, or False otherwise.""" + return is_not(value, None) + + +def exec_time(func): + @wraps(func) + def timeit_wrapper(*args, **kwargs): + start_time = time.perf_counter() + result = func(*args, **kwargs) + end_time = time.perf_counter() + total_time = end_time - start_time + print(f'Function {func.__name__}{args} {kwargs} Took {total_time:.4f} seconds') + return result + return timeit_wrapper diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libgrid.py b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libgrid.py new file mode 100644 index 0000000000000000000000000000000000000000..d0c302659cd9c89dde3c32092db3dc79d0b9424c --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libgrid.py @@ -0,0 +1,798 @@ +import glob +import math +import os +import random +import re +import shutil +import subprocess +import tempfile +import uuid +import warnings +import zipfile +from abc import ABC, abstractmethod +from concurrent.futures import ThreadPoolExecutor +from datetime import datetime +from enum import Enum +from pathlib import Path +from typing import Optional, Tuple, Union + +from haddock import log +from haddock.core.defaults import cns_exec_linux as CNS_EXEC +from haddock.libs.libsubprocess import CNSJob +from haddock.libs.libutil import parse_ncores + +# NOTE: When creating the payload.zip, this warning appears because we are replicating `toppar_path` +# subdirectory structure. It can be ignored safely, but keep an eye on it to make sure +# not many operations are being duplicated +warnings.filterwarnings("ignore", message="Duplicate name:*", category=UserWarning) +# =====================================================================# +# EXPLANATION # +# =====================================================================# +# `JOB_TYPE` is an environment variable that can be set to specify the +# type of job associated with a given VO. This is usually important for +# accounting purposes, as different job types may have different resources +# associated with it. +# There is an explanation about this in the user manual. +# =====================================================================# +JOB_TYPE = os.getenv("HADDOCK3_GRID_JOB_TYPE", "WeNMR-DEV") +MAX_RETRIES = 10 + +# Important patterns to adjust the paths in the `.inp` file +OUTPUT_PATTERN = r'\$output_\w+\s*=\s*"([^"]+)"|\$output_\w+\s*=\s*([^\s;]+)' +VAR_PATTERN = r"\(\$\s*[^=]*=(?!.?\$)(.*)\)" # https://regex101.com/r/dYqlZP/1 +AT_PATTERN = r"@@(?!\$)(.*)" + + +def ping_dirac() -> bool: + """Ping the Dirac server to check if it's reachable.""" + if not validate_dirac(): + return False + + result = subprocess.run(["dirac-proxy-info"], capture_output=True) + if result.returncode != 0: + log.error(f"Dirac proxy info failed: {result.stderr.decode().strip()}") + return False + + return True + + +def validate_dirac() -> bool: + """Check if the DIRAC client is valid and configured.""" + expected_cmds = [ + "dirac-proxy-info", + "dirac-wms-job-submit", + "dirac-wms-job-status", + "dirac-wms-job-get-output", + ] + + for cmd in expected_cmds: + # Expect the commands to be in the PATH + which_cmd = shutil.which(cmd) + if not which_cmd: + log.error(f"Command '{cmd}' not found in PATH.") + return False + + return True + + +class JobStatus(Enum): + WAITING = "Waiting" + RUNNING = "Running" + UNKNOWN = "Unknown" + DONE = "Done" + MATCHED = "Matched" + COMPLETING = "Completing" + FAILED = "Failed" + STAGED = "Staged" + + @classmethod + def from_string(cls, value): + """Convert string to JobStatus enum.""" + value = value.strip().lower() + for status in cls: + if status.value.lower() == value: + return status + return cls.UNKNOWN + + +class Tag(Enum): + PROBING = "Probing" + DEFAULT = "Default" + + +class GridInterface(ABC): + + def __init__( + self, + input: Union[Path, str, list[str]], + toppar_path: Path, + module_path: Path, + ) -> None: + # Common attributes for all grid jobs can be defined here + # Unique name for the job + self.name = str(uuid.uuid4()) + # Create a temporary directory for the job + self.loc = Path(tempfile.mkdtemp(prefix="haddock_grid_")) + # working directory where the GridJob was created, this is important + # so we know where to put the files coming from the grid + self.wd = Path.cwd() + # `id` is given by DIRAC + self.id = None + # Site where the job is running + self.site = None + # Script that will be executed in the grid + self.job_script = self.loc / "job.sh" + # JDL file that describes the job to DIRAC + self.jdl = self.loc / "job.jdl" + # Internal status of the job + self.status = JobStatus.STAGED + # `expected_outputs` is what will be produced by this `.inp` file + self.expected_outputs = [] + # Output and error files generated by the job.sh execution + self.stdout_f = None + self.stderr_f = None + # List of files to be included in the payload + self.payload_fnames = [] + # Counter for retries + self.retries = 0 + # Tracker for timings + self.timings: dict[JobStatus, datetime] = {} + # Tag for the job + self.tag = Tag.DEFAULT + # `input_str` is the content of the `.inp` file + self.input_str = "" + # `input_str_list` is a list of separate recipes` + self.input_str_list = [] # Initialize the list to store separate recipes + # `module_path` is the path to the CNS module files + self.module_path = module_path + # `toppar_path` is the path to the TOPPAR files` + self.toppar_path = toppar_path + # Indicator if this job has been packaged + self.packaged = False + + # `parse_input` is an abstract compatibility method that will handle + # different types of input. It can be either a string, a path or + # a list of paths/strings + self.parse_input(input) + + def package(self) -> None: + + # We need to process the input file first to adjust paths and identify outputs + self.process_input_f() + + # CREATE JOB FILE + self.create_job_script() + + # CREATE THE JDL + self.create_jdl() + + # CREATE PAYLOAD + self.prepare_payload( + cns_script_path=Path(self.module_path), + toppar_path=Path(self.toppar_path), + ) + + self.packaged = True + + @abstractmethod + def parse_input(self, input: Union[Path, str, list[str]]) -> None: + """placeholder""" + pass + + @abstractmethod + def create_job_script(self) -> None: + """Create the job script that will be executed in the grid.""" + pass + + @abstractmethod + def process_input_f(self) -> None: + """Process the input file to adjust paths and identify outputs.""" + pass + + def create_jdl(self) -> None: + """Create the JDL file that describes the job to DIRAC.""" + output_sandbox = ["job.out", "job.err"] + output_sandbox.extend(self.expected_outputs) + output_sandbox_str = ", ".join(f'"{fname}"' for fname in output_sandbox) + jdl_lines = [ + f'JobName = "{self.name}";', + 'Executable = "job.sh";', + 'Arguments = "";', + 'StdOutput = "job.out";', + 'StdError = "job.err";', + f'JobType = "{JOB_TYPE}";', + 'InputSandbox = {"job.sh", "payload.zip"};', + "OutputSandbox = {" + f"{output_sandbox_str}" + "};", + ] + + jdl_string = "[\n " + "\n ".join(jdl_lines) + "\n]\n" + # log.debug(f"JDL for job {self.name}:\n{jdl_string}") + + with open(self.jdl, "w") as f: + f.write(jdl_string) + + def update_status(self) -> None: + """Update the status of the job by querying DIRAC.""" + try: + result = subprocess.run( + ["dirac-wms-job-status", str(self.id)], + shell=False, + capture_output=True, + text=True, + ) + except subprocess.CalledProcessError as e: + log.error( + f"Updating the status failed: {e}\nStdout: {e.stdout}\nStderr: {e.stderr}" + ) + raise + + output_dict = self.parse_output(result.stdout) + + self.id = output_dict["JobID"] + self.status = JobStatus.from_string(output_dict["Status"]) + self.site = output_dict.get("Site", "Unknown") + + log.debug(self) + + if self.status == JobStatus.RUNNING and JobStatus.RUNNING not in self.timings: + # job is running and we have not tracket it yet, save the time + self.timings[JobStatus.RUNNING] = datetime.now() + elif self.status == JobStatus.DONE and JobStatus.DONE not in self.timings: + # job is done and we have not tracked it yet, save the time + self.timings[JobStatus.DONE] = datetime.now() + + def prepare_payload(self, cns_script_path: Path, toppar_path: Path) -> None: + """Prepare the payload.zip file containing all necessary files.""" + + # Find the CNS scripts that should be inside the payload + for f in cns_script_path.glob("*"): + self.payload_fnames.append(Path(f)) + + # Find the TOPPAR files that should be inside the payload + for f in toppar_path.rglob("*"): + if f.is_file(): # Only add files, not directories + self.payload_fnames.append(f) + + # Create the payload.zip + with zipfile.ZipFile(f"{self.loc}/payload.zip", "w") as z: + # It must contain the CNS executable and the input file, + # z.write(self.input_f, arcname=f"{self.input_f.name}") + z.write(CNS_EXEC, arcname="cns") + for f in set(self.payload_fnames): + # NOTE: Preserve the relative path structure from `toppar_path`! + # This is important because some CNS scripts have relative paths + # hardcoded in it + if f.is_relative_to(toppar_path): + relative_path = f.relative_to(toppar_path) + z.write(f, arcname=str(relative_path)) + else: + z.write(f, arcname=Path(f).name) + + def submit(self) -> None: + """Interface to submit the job to DIRAC.""" + + # If this is a re-submission the timings will already be set, + # make sure it is clean + self.clean_timings() + + if not self.packaged: + self.package() + + self.timings[JobStatus.WAITING] = datetime.now() + + try: + # The SUBMIT_CMD returns the job ID in stdout + result = subprocess.run( + ["dirac-wms-job-submit", f"{self.loc}/job.jdl"], + shell=False, + capture_output=True, + text=True, + cwd=self.loc, + check=True, + ) + except subprocess.CalledProcessError as e: + log.error( + f"Job submission failed: {e}\nStdout: {e.stdout}\nStderr: {e.stderr}" + ) + # TODO: Add some sort of retry/fallback mechanism here? + raise + + # Add the ID to the object + self.id = int(result.stdout.split()[-1]) + + # Update the status + self.update_status() + + def retrieve_output(self) -> None: + """Retrieve the output files from DIRAC. + + The `dirac-wms-job-get-output` command downloads the output sandbox, this means that + anything that was specified in the `OutputSandbox` section of the JDL file will be + put in the current working directory following the pattern: `working_dir/job_id/` + """ + try: + subprocess.run( + ["dirac-wms-job-get-output", str(self.id)], + shell=False, + capture_output=True, + text=True, + cwd=self.loc, + ) + except subprocess.CalledProcessError as e: + log.error( + f"Retrieving output failed: {e}\nStdout: {e.stdout}\nStderr: {e.stderr}" + ) + raise + + # NOTE: This is the output of the `job.sh` + self.stdout_f = Path(f"{self.loc}/{self.id}/job.out") + self.stderr_f = Path(f"{self.loc}/{self.id}/job.err") + + # If the job failed for some reason, save the output + if self.stderr_f.exists(): + dst = Path(self.wd / f"{self.id}_dirac.err") + shutil.copy(self.stderr_f, dst) + log.debug(f"ID stderr: {self.stderr_f.read_text()}") + + ls = glob.glob(f"{self.loc}/{self.id}/*") + log.debug(f"Files in the output sandbox: {ls}") + log.debug(f"Expected outputs: {self.expected_outputs}") + + # Copy the output to the expected location + for output_f in self.expected_outputs: + src = Path(f"{self.loc}/{self.id}/{output_f}") + dst = Path(self.wd / f"{output_f}") + shutil.copy(src, dst) + + def clean_timings(self) -> None: + """Clean the timings dictionary.""" + self.timings = {} + + def clean(self) -> None: + """Clean up the temporary directory where the job lives.""" + shutil.rmtree(self.loc) + + @staticmethod + def parse_output(output_str: str) -> dict[str, str]: + """Parse the output string from DIRAC commands into a dictionary.""" + items = output_str.replace(";", "") + status_dict = {} + for item in items.split(" "): + if "=" in item: + key, value = item.split("=", 1) + status_dict[key.strip()] = value.strip() + return status_dict + + @staticmethod + def _process_line(line: str) -> Tuple[str, Optional[str]]: + """Process a line to identify and adjust paths.""" + + match_var = re.findall(VAR_PATTERN, line) + match_at = re.findall(AT_PATTERN, line) + + # NOTE: In CNS it cannot match both patterns at the same time + if match_at: + item = match_at[0].strip('"').strip("'") + elif match_var: + item = match_var[0].strip('"').strip("'") + else: + # no match + return line, None + + if Path(item).exists(): + # This is a path + return line.replace(item, Path(item).name), item + else: + # This is not a path + return line, None + + @staticmethod + def _find_output(line) -> Optional[str]: + """Parse the line and identify if this contains an output file declaration.""" + match = re.search(OUTPUT_PATTERN, line) + if match: + return match.group(1) if match.group(1) else match.group(2) + return None + + def __repr__(self) -> str: + return f"ID: {self.id} Name: {self.name} Output: {self.expected_outputs} Status: {self.status.value} Site: {self.site}" + + +class GridJob(GridInterface): + """GridJob is a class tha represents a job to be run on the GRID via DIRAC.""" + + def __init__( + self, + input: Union[Path, str], + toppar_path: Path, + module_path: Path, + ) -> None: + super().__init__( + input=input, + toppar_path=toppar_path, + module_path=module_path, + ) # initialize the base class + + def parse_input(self, input: Union[Path, str, list[str]]) -> None: + """placeholder""" + # NOTE: `input` can be a string or a path, handle the polymorfism here + if isinstance(input, Path): + self.input_str = input.read_text() + + elif isinstance(input, str): + self.input_str = input + + elif isinstance(input, list): + raise ValueError("GridJob input cannot be a list, use CompositeGridJob") + + def create_job_script(self) -> None: + """Create the job script that will be executed in the grid.""" + # NOTE: We use `\n` instead of `os.linesep` because this will + # be executed in a Linux environment inside the grid + inp_name = f"{self.name}.inp" + cns_out_name = f"{self.name}.out" + self.expected_outputs.append(cns_out_name) + + instructions = "#!/bin/bash\n" + instructions += "export MODULE=./\n" + instructions += "export TOPPAR=./\n" + instructions += "unzip payload.zip\n" + instructions += f"./cns < {inp_name} > {cns_out_name}\n" + # Remove `cns.log` if there is no error + instructions += f"[ $? -eq 0 ] && rm {cns_out_name} || exit 1\n" + + with open(self.job_script, "w") as f: + f.write(instructions) + + def process_input_f(self) -> None: + """Process the input file to adjust paths and identify outputs.""" + + # Write the modified lines back + inp_name = Path(f"{self.loc}/{self.name}.inp") + self.payload_fnames.append(inp_name) + with open(inp_name, "w") as f: + for line in self.input_str.splitlines(keepends=True): + + # Parse this line and try to identify output files + output = self._find_output(line) + if output: + self.expected_outputs.append(output) + + # Process the line to adjust paths, if any + new_line, found_fname = self._process_line(line) + + f.write(new_line) + + # Collect the files that need to be in the payload + if found_fname: + src_path = Path(found_fname) + dst_path = self.loc / Path(found_fname).name + shutil.copy(src_path, dst_path) + self.payload_fnames.append(dst_path) + + +class CompositeGridJob(GridInterface): + + def __init__( + self, + input: list[str], + toppar_path: Path, + module_path: Path, + ) -> None: + super().__init__( + input=input, + toppar_path=toppar_path, + module_path=module_path, + ) # initialize the base class + + def create_job_script(self) -> None: + """Create the job script that will be executed in the grid.""" + # NOTE: We use `\n` instead of `os.linesep` because this will + # be executed in a Linux environment inside the grid + instructions = "#!/bin/bash\n" + instructions += "export MODULE=./\n" + instructions += "export TOPPAR=./\n" + instructions += "unzip payload.zip\n" + for idx, _ in enumerate(self.input_str_list): + inp_name = f"{idx}_{self.name}.inp" + cns_out_name = f"{idx}_{self.name}.out" + self.expected_outputs.append(cns_out_name) + instructions += f"./cns < {inp_name} > {cns_out_name}\n" + instructions += f"[ $? -eq 0 ] && rm {cns_out_name} || exit 1\n" + + with open(self.job_script, "w") as f: + f.write(instructions) + + def parse_input(self, input: Union[Path, str, list[str]]) -> None: + """Read a concatenated list of `.inp` files and split them into separate recipes.""" + if not isinstance(input, list): + raise ValueError("CompositeGridJob input must be a list of strings") + + # Join all the `.inp` contents into a single string + inp = "".join(input) + _input = "" + + lines_iter = iter(inp.split("\n")) + for line in lines_iter: + if line.startswith("stop"): + _input += "! end of the recipe\nstop\n" + self.input_str_list.append(_input.rstrip("\n")) + _input = "" # Reset for next recipe + else: + # If next line is not "stop", we still need to add it back + _input += line + "\n" + + # If there's remaining content without a termination signal, add it as the last recipe + if _input.strip(): + _input += "! end of the recipe\nstop\n" + self.input_str_list.append(_input.rstrip("\n")) + + # Keep the original behavior for backward compatibility + self.input_str = "\n".join(self.input_str_list) + + def process_input_f(self) -> None: + """Process each recipe section separately.""" + for recipe_idx, recipe_str in enumerate(self.input_str_list): + inp_name = Path(f"{self.loc}/{recipe_idx}_{self.name}.inp") + self.payload_fnames.append(inp_name) + with open(inp_name, "w") as f: + for line in recipe_str.splitlines(keepends=True): + # Parse this line and try to identify output files + output = self._find_output(line) + if output: + self.expected_outputs.append(output) + + # Process the line to adjust paths, if any + new_line, found_fname = self._process_line(line) + + # Collect the files that need to be in the payload + if found_fname: + src_path = Path(found_fname) + dst_path = self.loc / Path(found_fname).name + shutil.copy(src_path, dst_path) + self.payload_fnames.append(dst_path) + + f.write(new_line) + + +class GRIDScheduler: + """Scheduler to manage and run jobs on the GRID via DIRAC.""" + + def __init__( + self, tasks: list[CNSJob], params: dict, probing: float = 0.05 + ) -> None: + + self.probing: bool = True + self.ncores = parse_ncores(params["ncores"]) + self.batch_size = 1 + + self.workload: list[GridJob] = [ + GridJob( + input=t.input_file, + toppar_path=t.envvars["TOPPAR"], + module_path=t.envvars["MODULE"], + ) + for t in tasks + ] + + # ===============================================================# + # + # ! IMPORTANT ! + # + # The `subset_size` is the number of jobs to be used for probing the grid + # In theory we could send any number of jobs, but in practice we need to + # consider that the submission itself takes time. So we can come to the + # scenario in which we spend more time submitting jobs than measuring, + # this means that we would not be able to properly evaluate the grid + # capacity. + # Here we set the `subset_size` to be the minimum between `ncores` + # and the 5% of the total number of jobs. By setting it to the number + # of cores, we can be sure that we will be able to measure the metrics. + # We also need to ensure there is at least one job to probe the grid. + # + # HACK: This is not ideal, but it is a compromise between accuracy and speed. + subset_size = min(self.ncores, max(1, math.ceil(len(self.workload) * probing))) + # ===============================================================# + + # Randomly select that many jobs + if len(self.workload) >= subset_size: + for i in random.sample(range(len(self.workload)), subset_size): + self.workload[i].tag = Tag.PROBING + else: + log.warning("> Not enough jobs to probe the grid, skipping probing step <") + self.probing = False + + def run(self) -> None: + """Execute the tasks.""" + log.info("#" * 42) + log.info("=== Running tasks with GRID Scheduler ===") + + self.probe_grid_efficiency() + + self.create_batches() + + self.submit_jobs() + + self.wait_for_completion() + + log.info("#" * 42) + + def create_batches(self) -> None: + """Create batches of jobs to be submitted together.""" + log.info("++ Concatenating jobs to increase efficiency...") + + jobs = [j for j in self.workload if j.tag == Tag.DEFAULT] + + toppar_path = jobs[0].toppar_path + module_path = jobs[0].module_path + + composite_jobs = [] + for i, batch in enumerate(range(0, len(jobs), self.batch_size), start=1): + input = [j.input_str for j in jobs[batch : batch + self.batch_size]] + log.debug(f" Payload {i}, n={len(input)} job(s)") + job = CompositeGridJob( + input=input, + toppar_path=toppar_path, + module_path=module_path, + ) + composite_jobs.append(job) + + log.info( + f"++ Created {len(composite_jobs)} payload(s) with up to {self.batch_size} job(s) each" + ) + self.workload = composite_jobs + + def wait_for_completion(self) -> None: + """Wait for jobs with status WAITING or RUNNING to complete.""" + log.info("++ Waiting...") + complete = False + while not complete: + jobs_to_check = [ + job + for job in self.workload + if job.status + not in {JobStatus.STAGED, JobStatus.DONE, JobStatus.FAILED} + ] + if jobs_to_check: + log.debug(f"+ Checking status of {len(jobs_to_check)} payload(s)...") + with ThreadPoolExecutor(max_workers=self.ncores) as executor: + executor.map(self.process_job, jobs_to_check) + else: + complete = True + + def submit_jobs(self, tag: Tag = Tag.DEFAULT) -> None: + """Submit jobs to the GRID in parallel.""" + queue = [ + job + for job in self.workload + if job.tag == tag and job.status == JobStatus.STAGED + ] + + log.info(f"++ Submitting {len(queue)} '{tag.value}' payloads to the grid...") + with ThreadPoolExecutor(max_workers=self.ncores) as executor: + executor.map(lambda job: job.package(), queue) + + with ThreadPoolExecutor(max_workers=self.ncores) as executor: + executor.map(lambda job: job.submit(), queue) + + def probe_grid_efficiency(self) -> None: + """Submit a small number of jobs to probe the efficiency of the GRID.""" + if not self.probing: + return + + log.info("++ Probing grid efficiency...") + + # Submit + self.submit_jobs(tag=Tag.PROBING) + + # Wait + self.wait_for_completion() + + # Calculate actual durations from timestamps + waiting_durations = [] + running_durations = [] + + for job in self.workload: + wait_start = job.timings.get(JobStatus.WAITING) + run_start = job.timings.get(JobStatus.RUNNING) + done_time = job.timings.get(JobStatus.DONE) + + if wait_start is None or run_start is None or done_time is None: + continue # Skip jobs without complete timing info + + else: + log.debug(f"Job {job.expected_outputs}") + log.debug(f" timings: {job.timings}") + + # Calculate waiting duration (WAITING to RUNNING) + waiting_duration = (run_start - wait_start).total_seconds() + waiting_durations.append(waiting_duration) + + # Calculate running duration (RUNNING to DONE) + running_duration = (done_time - run_start).total_seconds() + running_durations.append(running_duration) + + if not running_durations or not waiting_durations: + log.warning( + "> Average running time is zero, cannot calculate optimal batch size <" + ) + return + + # Calculate average durations + avg_waiting = sum(waiting_durations) / len(waiting_durations) + avg_running = sum(running_durations) / len(running_durations) + + target_efficiency = 0.9 + batch_size = self.calculate_optimal_batch_size( + N=self.batch_size, + W=avg_waiting, + R=avg_running, + T=target_efficiency, + ) + + # Make sure batch size is not larger than the number of default jobs + # TODO: Add a warning if this happens? + batch_size = min( + batch_size, len([j for j in self.workload if j.tag == Tag.DEFAULT]) + ) + + self.batch_size = batch_size + + @staticmethod + def calculate_optimal_batch_size(N: int, W: float, R: float, T: float) -> int: + """Calculate the optimal batch size to achieve target efficiency.""" + # The efficiency of a given batch can be described as: + # + # E = N * R / W + N * R + # + # Where E is efficiency, N is the number of jobs running at the same time + # R is the average running time, W is the average waiting time + # + # The current efficiency is then: + E = (N * R) / (W + N * R) + + log.info(f"+ Current efficiency with {N} job(s) per payload: {E:.1%}") + + # So to achieve a target efficiency T + # We solve for N, which is the batch size: + # E = N * R / W + N * R + # T * (W + N * R) = N * R + # T * W + T * N * R = N * R + # T * W = N * R - T * N * R + # T * W = N * R * (1 - T) + # N = T * W / R * (1 - T) + batch_size = (T * W) / (R * (1 - T)) + + batch_size = max(1, round(batch_size)) # Ensure at least 1 job + return batch_size + + @staticmethod + def process_job(job: GridJob) -> None: + """Process a single job: update status, retrieve output if done, handle retries if failed. + + NOTE: This function is parallelized, that is why things like cleaning, download, retry + are here. If you are adding new functionality, consider if it should be here or in the + sequential part of the code. + """ + + job.update_status() + + if job.status == JobStatus.FAILED: + # Jobs on the grid can fail for many reasons outside our control + # So if the job is failed, resubmit it up to MAX_RETRIES times + if job.retries < MAX_RETRIES: + expected_output_str = ",".join(job.expected_outputs) + job.retries += 1 + log.warning( + f"> Job {job.name} ({expected_output_str}) failed on {job.site}, re-submitting - {job.retries}/{MAX_RETRIES} <" + ) + log.debug(f"job {job.name} at {job.loc}") + job.submit() + + # TODO: Add some sort of fallback mechanism here if it reaches the MAX_RETRIES + + if job.status == JobStatus.DONE: + log.debug(f"Job {job.name} is done, retrieving output...") + job.retrieve_output() + log.debug(f"job {job.name} at {job.loc}") + job.clean() diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libhpc.py b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libhpc.py new file mode 100644 index 0000000000000000000000000000000000000000..651eb870d2ecda8e3563c4afde39a8ff86ab86d8 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libhpc.py @@ -0,0 +1,392 @@ +"""Module in charge of running tasks in HPC.""" + +import os +import re +import shlex +import subprocess +import time +from pathlib import Path + +from haddock import log, modules_defaults_path +from haddock.core.typing import Any, Container, FilePath, Optional +from haddock.gear.yaml2cfg import read_from_yaml_config +from haddock.libs.libsubprocess import CNSJob + + +STATE_REGEX = r"JobState=(\w*)" + +JOB_STATUS_DIC = { + "PENDING": "submitted", + "RUNNING": "running", + "SUSPENDED": "hold", + "COMPLETING": "running", + "COMPLETED": "finished", + "FAILED": "failed", + "TIMEOUT": "timed-out", +} + +TERMINATED_STATUS = ( + "finished", + "failed", + "timed-out", +) + +# if you change these defaults, change also the values in the +# modules/defaults.cfg file +_tmpcfg = read_from_yaml_config(modules_defaults_path) +HPCScheduler_CONCAT_DEFAULT: int = _tmpcfg["concat"] # original value 1 +HPCWorker_QUEUE_LIMIT_DEFAULT: int = _tmpcfg[ + "queue_limit" +] # original value 100 # noqa: E501 +HPCWorker_QUEUE_DEFAULT: str = _tmpcfg["queue"] # original value "" +del _tmpcfg + + +class HPCWorker: + """Defines the HPC Job.""" + + def __init__( + self, + tasks: list[CNSJob], + num: int, + job_id: Optional[int] = None, + workfload_manager: str = "slurm", + queue: Optional[str] = None, + ) -> None: + """ + Define the HPC job. + + Parameters + ---------- + tasks : list of libs.libcns.CNSJob objects + + num : int + The number of the worker. + """ + self.tasks = tasks + log.debug(f"HPCWorker ready with {len(self.tasks)}") + self.job_num = num + self.job_id = job_id + self.job_status = "unknown" + + self.moddir = Path(tasks[0].envvars["MODDIR"]) + self.toppar = tasks[0].envvars["TOPPAR"] + self.cns_folder = tasks[0].envvars["MODULE"] + module_name = Path(tasks[0].envvars["MODDIR"]).resolve().stem.split("_")[-1] + self.job_fname = Path(self.moddir, f"{module_name}_{num}.job") + self.workload_manager = workfload_manager + self.queue = queue + + def prepare_job_file(self, queue_type: str = "slurm") -> None: + """Prepare the job file for all the jobs in the task list.""" + job_file_contents = create_job_header_funcs[queue_type]( + job_name="haddock3", + queue=self.queue, + ncores=1, + work_dir=self.moddir, + stdout_path=self.job_fname.with_suffix(".out"), + stderr_path=self.job_fname.with_suffix(".err"), + ) + + job_file_contents += create_CNS_export_envvars( + MODDIR=self.moddir, + MODULE=self.cns_folder, + TOPPAR=self.toppar, + ) + + job_file_contents += f"cd {self.moddir}{os.linesep}" + for job in self.tasks: + cmd = ( + f"{job.cns_exec} < {job.input_file} > {job.output_file}" f"{os.linesep}" + ) + job_file_contents += cmd + + self.job_fname.write_text(job_file_contents) + + def run(self) -> None: + """Execute the tasks.""" + self.prepare_job_file(queue_type=self.workload_manager) + cmd = f"sbatch {self.job_fname}" + p = subprocess.run(shlex.split(cmd), capture_output=True) + self.job_id = int(p.stdout.decode("utf-8").split()[-1]) + self.job_status = "submitted" + + def update_status(self) -> str: + """Retrieve the status of this worker.""" + cmd = f"scontrol show jobid -dd {self.job_id}" + p = subprocess.run(shlex.split(cmd), capture_output=True) + out = p.stdout.decode("utf-8") + # err = p.stderr.decode('utf-8') + if out: + status = extract_slurm_status(out) + self.job_status = JOB_STATUS_DIC[status] + else: + self.job_status = "finished" + + return self.job_status + + def cancel(self, bypass_statuses: Container[str] = ("finished", "failed")) -> None: + """Cancel the execution.""" + if self.update_status() not in bypass_statuses: + log.info(f"Canceling {self.job_fname.name} - {self.job_id}") + cmd = f"scancel {self.job_id}" + _ = subprocess.run(shlex.split(cmd), capture_output=True) + + +class HPCScheduler: + """Schedules tasks to run in HPC.""" + + def __init__( + self, + task_list: list[CNSJob], + target_queue: str = HPCWorker_QUEUE_DEFAULT, + queue_limit: int = HPCWorker_QUEUE_LIMIT_DEFAULT, + concat: int = HPCScheduler_CONCAT_DEFAULT, + ) -> None: + self.num_tasks = len(task_list) + self.queue_limit = queue_limit + self.concat = concat + + # split tasks according to concat level + if concat > 1: + log.info( + f"Concatenating, each .job will produce {concat} " "(or less) models" + ) + job_list = [task_list[i : i + concat] for i in range(0, len(task_list), concat)] + + self.worker_list = [HPCWorker(t, j) for j, t in enumerate(job_list, start=1)] + + # set the queue + # (this is outside the comprehension for clarity) + if target_queue: + for worker in self.worker_list: + worker.queue = target_queue + + log.debug(f"{self.num_tasks} HPC tasks ready.") + + def run(self) -> None: + """Run tasks in the Queue.""" + # split by maximum number of submission so we do it in batches + batch = [ + self.worker_list[i : i + self.queue_limit] + for i in range(0, len(self.worker_list), self.queue_limit) + ] + total_batches = len(batch) + try: + for batch_num, worker_list in enumerate(batch, start=1): + log.info(f"> Running batch {batch_num}/{total_batches}") + start = time.time() + for worker in worker_list: + worker.run() + + # check if those finished + completed: bool = False + elapsed: float = 0.0 + while not completed: + # Initiate count of terminated jobs + terminated_count: int = 0 + # Loop over workers + for worker in worker_list: + worker.update_status() + # Log status if not finished + if worker.job_status != "finished": + log.info( + f">> {worker.job_fname.name}" f" {worker.job_status}" + ) + # Increment number of terminated works + if worker.job_status in TERMINATED_STATUS: + terminated_count += 1 + + # Check if all terminated + if terminated_count == len(worker_list): + # Set while loop condition + completed = True + end = time.time() + elapsed = end - start + else: + # use pre-defined waits + if len(worker_list) < 10: + sleep_timer = 10 + elif len(worker_list) < 50: + sleep_timer = 30 + else: + sleep_timer = 60 + log.info(f">> Waiting... ({sleep_timer:.2f}s)") + time.sleep(sleep_timer) + + per = (float(batch_num) / float(total_batches)) * 100 + log.info( + f">> Batch {batch_num}/{total_batches} took " + f"{elapsed:.2f}s to finish, {per:.2f}% complete" + ) + + except KeyboardInterrupt as err: + self.terminate() + raise err + + def terminate(self) -> None: + """Terminate all jobs in the queue in a controlled way.""" + log.info("Terminate signal received, removing jobs from the queue...") + for worker in self.worker_list: + worker.cancel() + + log.info("The jobs in the queue were terminated in a controlled way") + + +def create_slurm_header( + job_name: FilePath = "haddock3_slurm_job", + work_dir: FilePath = ".", + stdout_path: FilePath = "haddock3_job.out", + stderr_path: FilePath = "haddock3_job.err", + queue: Optional[str] = None, + ncores: int = 48, +) -> str: + """ + Create HADDOCK3 Slurm Batch job file. + + Parameters + ---------- + job_name : str + The name of the job. + + work_dir : pathlib.Path + The working dir of the example. That is, the directory where + `input`, `jobs`, and `logs` reside. Injected in `create_job_header`. + + time : int + Time in minutes before job reach TIMEOUT status. + + **job_params + According to `job_setup`. + + Return + ------ + str + Slurm-based job file for HADDOCK3. + """ + header = f"#!/usr/bin/env bash{os.linesep}" + header += f"#SBATCH -J {job_name}{os.linesep}" + if queue: + header += f"#SBATCH -p {queue}{os.linesep}" + header += f"#SBATCH --nodes=1{os.linesep}" + header += f"#SBATCH --tasks-per-node={str(ncores)}{os.linesep}" + header += f"#SBATCH --output={stdout_path}{os.linesep}" + header += f"#SBATCH --error={stderr_path}{os.linesep}" + # commenting the workdir option (not supported by all versions of slurm) + # header += f"#SBATCH --workdir={work_dir}{os.linesep}" + return header + + +def create_torque_header( + job_name: FilePath = "haddock3_slurm_job", + work_dir: FilePath = ".", + stdout_path: FilePath = "haddock3_job.out", + stderr_path: FilePath = "haddock3_job.err", + queue: Optional[str] = None, + ncores: int = 48, +) -> str: + """ + Create HADDOCK3 Alcazar job file. + + Parameters + ---------- + job_name : str + The name of the job. + + work_dir : pathlib.Path + The working dir of the example. That is, the directory where + `input`, `jobs`, and `logs` reside. Injected in `create_job_header`. + + **job_params + According to `job_setup`. + + Return + ------ + str + Torque-based job file for HADDOCK3 benchmarking. + """ + header = f"#!/usr/bin/env tcsh{os.linesep}" + header += f"#PBS -N {job_name}{os.linesep}" + if queue: + header += f"#PBS -q {queue}{os.linesep}" + header += f"#PBS -l nodes=1:ppn={str(ncores)}{os.linesep}" + header += f"#PBS -S /bin/tcsh{os.linesep}" + header += f"#PBS -o {stdout_path}{os.linesep}" + header += f"#PBS -e {stderr_path}{os.linesep}" + header += f"#PBS -wd {work_dir}{os.linesep}" + return header + + +def to_torque_time(time: int) -> str: + """Convert time in minutes to the form hh:mm:ss. + + Parameters + ---------- + time : int + Time in minutes. + + Return + ------ + hh_mm_ss : str + Time in the form for HH:MM:SS + """ + hours = time // 60 + remain_mins = time - (hours * 60) + # Convert to hh:mm:ss string + hh_mm_ss_l = [hours, remain_mins, 0] + # Make sure hours contain at least 2 characters + hh_mm_ss = "{0:02d}:{1:02d}:{2:02d}".format(*hh_mm_ss_l) + return hh_mm_ss + + +def extract_slurm_status(slurm_out: str) -> str: + """Extract job status from slurm scontrol stdout. + + Parameters + ---------- + slurm_out : str + StdOut of `scontrol show jobid -dd {job_id}` command. + Return + ------ + status : str + Status of the slurm job. + May also return `error`, when job do not exists. + """ + try: + # https://regex101.com/r/M2vbAc/1 + status = re.findall(STATE_REGEX, slurm_out)[0] + except IndexError: + status = "FAILED" + return status + + +def create_CNS_export_envvars(**envvars: Any) -> str: + """Create a string exporting envvars needed for CNS. + + Parameters + ---------- + envvars : dict + A dictionary containing envvariables where keys are var names + and values are the values. + + Returns + ------- + str + In the form of: + export VAR1=VALUE1 + export VAR2=VALUE2 + export VAR3=VALUE3 + + """ + exports = os.linesep.join( + f"export {key.upper()}={value}" for key, value in envvars.items() + ) + + return exports + os.linesep + os.linesep + + +# the different job submission queues +create_job_header_funcs = { + "torque": create_torque_header, + "slurm": create_slurm_header, +} diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libinteractive.py b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libinteractive.py new file mode 100644 index 0000000000000000000000000000000000000000..fbba30f14c8e1b2ee05e542770786d10114897fe --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libinteractive.py @@ -0,0 +1,202 @@ +"""Set of functions related to haddock3 interactive rescoring `haddock3-re`.""" + +from haddock import log +from haddock.clis.cli_traceback import get_steps_without_pdbs +from haddock.core.typing import Union +import pandas as pd +import numpy as np +from pathlib import Path +from haddock.libs.libplots import read_capri_table +from haddock.modules import get_module_steps_folders + + +def handle_ss_file( + df_ss: pd.DataFrame, + ) -> tuple[pd.DataFrame, dict]: + """ + Manage a caprieval capri_ss file focusing on 4 first elements + per cluster. + + Parameters + ---------- + df_ss : pd.DataFrame + The caprieval ss data. + + Returns + ------- + df_ss : pd.DataFrame + The input dataframe + clt_ranks_dict : dict + Dictionary with the cluster ranks + """ + # now we want to calculate mean and std dev of the scores on df_ss + # first sort the dataframe by score + df_ss.sort_values(by=["score", "caprieval_rank"], inplace=True) + # groupby cluster_id + df_ss_grouped = df_ss.groupby("cluster_id") + # calculate the mean and standard deviation of the first 4 elements + # of each group + new_values = [] + # loop over df_ss_grouped with enumerate + for clt_id in df_ss_grouped: + ave_score = np.mean(clt_id[1]["score"].iloc[:4]) + std_score = np.std(clt_id[1]["score"].iloc[:4]) + new_values.append([ave_score, std_score, clt_id[0]]) + # get the index that sorts the array by the first column + new_values_arr = np.array(new_values) + clt_ranks = np.argsort(new_values_arr[:, 0]) + # the ranked clusters are the third column of the new_values array + clt_sorted = new_values_arr[clt_ranks, 2] + clt_ranks_dict = {clt_sorted[i]: i + 1 for i in range(len(clt_sorted))} + # adjust clustering values if there are clusters + if list(np.unique(df_ss["cluster_id"])) != ["-"]: + df_ss['model-cluster_ranking'] = df_ss.groupby('cluster_id')['score'].rank(ascending=True).astype(int) # noqa : E501 + # assign to the values of cluster_ranking the corresponding clt_ranks + df_ss["cluster_ranking"] = df_ss["cluster_id"].apply(lambda x: clt_ranks_dict[x]) # noqa : E501 + # assign to the column caprieval_rank the index of the dataframe + df_ss.index = range(1, len(df_ss) + 1) + df_ss["caprieval_rank"] = df_ss.index + return df_ss, clt_ranks_dict + + +def rewrite_capri_tables( + caprieval_folder: str, + clt_dic: dict, + outdir: str, + ) -> None: + """Rewrite the capri tables with new values. + + Parameters + ---------- + caprieval_folder : str + Path to the capriveal folder to be changed + clt_dic : dict + Data for each cluster + outdir : str + Output directory + """ + capri_ss = Path(caprieval_folder, "capri_ss.tsv") + capri_clt = Path(caprieval_folder, "capri_clt.tsv") + if not capri_ss.exists() or not capri_clt.exists(): + # raise warning and exit + log.warning("Capri evaluation files not found. Skipping...") + return + # ss file + df_ss = read_capri_table(capri_ss) + for cl in clt_dic: + models = [ + f"../{model.path.split('/')[-1]}/{model.file_name}" + for model in clt_dic[cl] + ] + # all the models should now have the cluster_id field + df_ss.loc[df_ss['model'].isin(models), 'cluster_id'] = cl + + # delete all the models that are not in the clusters + df_ss = df_ss[df_ss['cluster_id'] != "-"] + # assign cluster_ranking to cluster_id (aka random assignment) + df_ss['cluster_ranking'] = df_ss['cluster_id'] + # handle ss file + df_ss, clt_ranks_dict = handle_ss_file(df_ss) + + # save capri_ss file + capri_ss_file = Path(outdir, "capri_ss.tsv") + log.info(f"Saving capri_ss file to {capri_ss_file}") + df_ss.to_csv(capri_ss_file, sep="\t", index=False) + + # retrieve df_clt object + df_clt = handle_clt_file(df_ss, clt_ranks_dict) + # save capri_clt file + capri_clt_file = Path(outdir, "capri_clt.tsv") + log.info(f"Saving capri_clt file to {capri_clt_file}") + df_clt.to_csv(capri_clt_file, sep="\t", index=False, float_format='%.3f') + return + + +def look_for_capri(run_dir: str, module_id: int) -> Union[Path, None]: + """Look for capri evaluation files previous to clustfcc_dir. + + Parameters + ---------- + run_dir : str + Path to the haddock3 run directory + module_id : int + Id of the module. + + Returns + ------- + capri_eval : Path + Path to the capri evaluation file + """ + prev_modules_id = range(1, module_id) + prev_modules = get_module_steps_folders(run_dir, prev_modules_id) + # remove possible interactive modules + prev_modules = [ + mod for mod in prev_modules + if not mod.endswith("interactive") + ] + # analysis modules + ana_modules = get_steps_without_pdbs(run_dir, prev_modules) + # loop over the reversed list of previous modules + capri_folder = None + for prev_module in reversed(prev_modules): + log.info(f"prev_module {prev_module}") + if prev_module.endswith("caprieval"): + # caprieval module found before any module that generates models + capri_folder = Path(run_dir, prev_module) + break + elif prev_module not in ana_modules: + break + else: + continue + log.info(f"capri_folder {capri_folder}") + return capri_folder + + +def handle_clt_file(df_ss, clt_ranks_dict): + """Handle capri.clt file. + + Parameters + ---------- + df_ss : pd.DataFrame + The caprieval ss data. + clt_ranks_dict : dict + New cluster ranking dictionary. + + Reclustering modifies the cluster data, so capri_clt.tsv must be updated. + """ + capri_keys = ["score", "irmsd", "fnat", "lrmsd", "dockq"] + model_keys = ["air", "bsa", "desolv", "elec", "total", "vdw"] + df_ss_grouped = df_ss.groupby("cluster_id") + # loop over df_ss_grouped + cl_data = [] + for clt_id in df_ss_grouped: + cl_rank = clt_ranks_dict[clt_id[0]] # the rank of the cluster is the key + data = [cl_rank, clt_id[0], clt_id[1].shape[0], "-", ] + # updating capri quantities + for column in capri_keys: + ave_score = np.mean(clt_id[1][column].iloc[:4]) + std_score = np.std(clt_id[1][column].iloc[:4]) + data.extend([ave_score, std_score]) + # updating model quantities + for column in model_keys: + ave_score = np.mean(clt_id[1][column].iloc[:4]) + std_score = np.std(clt_id[1][column].iloc[:4]) + data.extend([ave_score, std_score]) + cl_data.append(data) + + # create the dataframe + capri_clt_columns = ["cluster_rank", "cluster_id", "n", "under_eval"] + for column in capri_keys: + capri_clt_columns.append(f"{column}") + capri_clt_columns.append(f"{column}_std") + for column in model_keys: + capri_clt_columns.append(f"{column}") + capri_clt_columns.append(f"{column}_std") + # capri_clt_columns.append("caprieval_rank") + df_clt = pd.DataFrame(cl_data, columns=capri_clt_columns) + df_clt.sort_values(by="score", inplace=True) + df_clt.index = range(1, len(df_clt) + 1) + df_clt["caprieval_rank"] = df_clt.index + # + df_clt.sort_values(by="caprieval_rank", inplace=True) + return df_clt diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libio.py b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libio.py new file mode 100644 index 0000000000000000000000000000000000000000..8f0b17c7788596943feb9722f2f48778db897e31 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libio.py @@ -0,0 +1,638 @@ +"""Lib I/O.""" +import contextlib +import glob +import gzip +import os +import stat +import tarfile +import re +from functools import partial +from multiprocessing import Pool +from pathlib import Path + +import yaml + +from haddock import log +from haddock.core.typing import ( + Any, + Callable, + FilePath, + Generator, + Iterable, + Mapping, + Optional, + Union, + ) +from haddock.libs.libontology import PDBFile +from haddock.libs.libutil import sort_numbered_paths + + +def clean_suffix(ext: str) -> str: + """ + Remove the preffix dot of an extension if exists. + + Parameters + ---------- + ext : str + The extension string. + + Examples + -------- + >>> clean_suffix('.pdb') + 'pdb' + + >>> clean_suffix('pdb') + 'pdb' + """ + return ext.lstrip(r".") + + +def dot_suffix(ext: str) -> str: + """ + Add the dot preffix to an extension if missing. + + Parameters + ---------- + ext : str + The extension string. + + Examples + -------- + >>> clean_suffix('.pdb') + '.pdb' + + >>> clean_suffix('pdb') + '.pdb' + """ + return "." + clean_suffix(ext) + + +def read_lines(func: Callable[..., Any]) -> Callable[..., Any]: + """ + Open the file and read lines for the decorated function. + + Send to the decorated function the lines of the file in the form + of list. + """ + + def wrapper(fpath: FilePath, *args: Any, **kwargs: Any) -> Any: + lines = Path(fpath).read_text().split(os.linesep) + return func(lines, *args, **kwargs) + + # manual wrapping for displaying documentation properly + wrapper.original = func # type: ignore + wrapper.__doc__ = func.__doc__ + wrapper.__name__ = func.__name__ + return wrapper + + +def read_from_yaml(yaml_file: FilePath) -> dict[Any, Any]: + """ + Read a YAML file to a dictionary. + + Used internally to read HADDOCK3's default configuration files. + + Parameters + ---------- + yaml_file : str or Path + Path to the YAML file. + + Returns + ------- + dict + Always returns a dictionary. + Returns empty dictionary if yaml_file is empty. + """ + # Check that this yaml file do not contain duplicated parameters + check_yaml_duplicated_parameters(yaml_file) + + # Load yaml file using the yaml lib + with open(yaml_file, "r") as fin: + ycfg = yaml.safe_load(fin) + + # ycfg is None if yaml_file is empty + # returns an empty dictionary to comply with HADDOCK workflow + if ycfg is None: + return {} + + assert isinstance(ycfg, dict), type(ycfg) + return ycfg + + +def check_yaml_duplicated_parameters(yaml_fpath: str) -> None: + """Make sure the provided yaml file do not contain duplicated parameters. + + Parameters + ---------- + yaml_fpath : str + Path to a yaml file + """ + # Build regular expression + # Note: Understand behavior here -> https://regex101.com/r/AaFHp4/1 + yaml_param_regex = re.compile("^(([A-Za-z0-9]_?)+):") + # Read content as string + with open(yaml_fpath, 'r') as filin: + yaml_content = filin.readlines() + parsed_param_names: dict[str, int] = {} + # Loop over lines + for i, line in enumerate(yaml_content, start=1): + # Check if new parameter + if (match := yaml_param_regex.search(line)): + # Point parameter name + param_name = match.group(1) + # Make sure this parameter has not yet been used + assert param_name not in parsed_param_names.keys(), f"Parameter '{param_name}' in {yaml_fpath} has duplicates: l.{parsed_param_names[param_name]} and l.{i}" # noqa : E501 + # Hold line were this parameter is, in case of duplication, to help + parsed_param_names[param_name] = i + + +def open_files_to_lines(*files: FilePath) -> list[list[str]]: + """ + Open files to lines. + + New-lines are stripped. + + Returns + ------- + list of lists of strings + The lines of the files. + Input order is maintained. + """ + f_paths = map(Path, files) + return [f.read_text().split(os.linesep) for f in f_paths] + + +def save_lines_to_files( + files: Iterable[FilePath], + lines: Iterable[Iterable[str]] + ) -> None: + """ + Save a list of list of lines to files. + + The first list of strings in `lines` will be saved in the first file + of `files`, and so on. + + Lines are saved using `pathlib.Path.write_text` function. + + Parameters + ---------- + files : list + The list of file names to save. + + lines : list of lists of str + A list containing lists of lines that are the file contents. + Must be synched with `files`. + """ + for file_, content in zip(files, lines): + Path(file_).write_text(os.linesep.join(content) + os.linesep) + + return + + +def add_suffix_to_files( + files: Iterable[FilePath], + suffix: str + ) -> Generator[Path, None, None]: + """ + Add a suffix to file paths. + + Yields + ------ + pathlib.Path objects + Exhausts when files exhaust. + """ + for file_ in files: + p = Path(file_) + folder = p.parent + psuffix = p.suffix + name = p.stem + suffix + psuffix + path = Path(folder, name) + yield path + + +def write_dic_to_file( + data_dict: Mapping[Any, Any], + output_fname: FilePath, + info_header: str = "", + sep: str = "\t", + ) -> None: + """ + Create a table from a dictionary. + + Parameters + ---------- + data_dict : dict + Dictionary to write. + output_fname : str or Path + Name of the output file. + info_header : str + Header to write before the data. + """ + header = "\t".join(data_dict.keys()) + + if info_header: + header = info_header + os.linesep + header + + with open(output_fname, "w") as out_fh: + out_fh.write(header + os.linesep) + row_l: list[str] = [] + for element in data_dict: + value = data_dict[element] + if isinstance(value, Path): + row_l.append(str(value)) + elif isinstance(value, PDBFile): + row_l.append(str(value.rel_path)) + elif isinstance(value, int): + row_l.append(f"{value}") + elif isinstance(value, str): + row_l.append(f"{value}") + elif value is None: + row_l.append("-") + else: + row_l.append(f"{value:.3f}") + out_fh.write(sep.join(row_l) + os.linesep) + + +def write_nested_dic_to_file( + data_dict: Mapping[Any, Any], + output_fname: FilePath, + info_header: str = "", + sep: str = "\t", + ) -> None: + """ + Create a table from a nested dictionary. + + Parameters + ---------- + data_dict : dict + Dictionary to write. + output_fname : str or Path + Name of the output file. + + Notes + ----- + This function is used to write nested dictionaries. + {int: {key: value}}, the int key will be discarded. + """ + first_key = list(data_dict.keys())[0] + header = "\t".join(data_dict[first_key].keys()) + + if info_header: + header = info_header + os.linesep + header + + with open(output_fname, "w") as out_fh: + out_fh.write(header + os.linesep) + for row in data_dict: + row_l: list[str] = [] + for element in data_dict[row]: + value = data_dict[row][element] + if isinstance(value, Path): + row_l.append(str(value)) + elif isinstance(value, PDBFile): + row_l.append(str(value.rel_path)) + elif isinstance(value, int): + row_l.append(f"{value}") + elif isinstance(value, str): + row_l.append(f"{value}") + elif value is None: + row_l.append("-") + else: + row_l.append(f"{value:.3f}") + out_fh.write(sep.join(row_l) + os.linesep) + + +# thanks to @brianjimenez +@contextlib.contextmanager +def working_directory(path: FilePath) -> Generator[None, None, None]: + """Change working directory and returns to previous on exit.""" + prev_cwd = Path.cwd() + os.chdir(path) + try: + yield + finally: + os.chdir(prev_cwd) + + +def compress_files_ext( + path: FilePath, + ext: str, + ncores: int = 1, + **kwargs: Any + ) -> bool: + """ + Compress all files with same extension in folder to `.gz`. + + Do not archive the files in TAR, only compress files individually. + + Parameters + ---------- + path : str or :external:py:class:`pathlib.Path` + The folder containing the files. + + ext : str + The extension of the files. + + **kwargs : anything + Arguments passed to :py:func:`gzip_files`. + + Returns + ------- + bool + ``True`` if files with ``ext`` were found and the compressed + `.gz` files created. + + ``False`` if no files with ``ext`` were found and, hence, the + `.gz` files were not created. + """ + files = glob_folder(path, ext) + gzip_ready = partial(gzip_files, **kwargs) + if files: + with Pool(ncores) as pool: + imap = pool.imap_unordered(gzip_ready, files) + for _ in imap: + pass + return True + return False + + +def gzip_files( + file_: FilePath, + block_size: Optional[int] = None, + compresslevel: int = 9, + remove_original: bool = False, + ) -> None: + """ + Gzip a file. + + Parameters + ---------- + file_ : str or :external:py:class:`pathlib.Path` + The path to the file to compress. + + block_size : int + The block size to treat per cycle. Defaults to 200MB (2*10**8 + (2*10**8). + + compresslevel : int + The compress level. Defaults to 9. + """ + if block_size is None: + block_size = 2 * 10**8 + + gfile = str(file_) + ".gz" + with open(file_, "rb") as fin, gzip.open( + gfile, mode="wb", compresslevel=compresslevel + ) as gout: + content = fin.read(block_size) # read the first + while content: + gout.write(content) + content = fin.read(block_size) + + if remove_original: + Path(file_).unlink() + + +def archive_files_ext(path: FilePath, ext: str, compresslevel: int = 9) -> bool: + """ + Archive all files with same extension in folder. + + Parameters + ---------- + path : str or :external:py:class:`pathlib.Path` + The folder containing the files. + + ext : str + The extension of the files. + + compresslevel : int + The compression level. + + Returns + ------- + bool + ``True`` if files with ``ext`` were found and the Zip files created. + ``False`` if no files with ``ext`` were found and, hence, the + Zip files was not created. + """ + files = glob_folder(path, clean_suffix(ext)) + + ext = clean_suffix(ext) + + if files: + with tarfile.open( + Path(path, f"{ext}.tgz"), + mode="w:gz", + compresslevel=compresslevel, + ) as tarout: + for file_ in files: + tarout.add(file_, arcname=file_.name) + + return True + return False + + +def glob_folder(folder: FilePath, ext: str) -> list[Path]: + """ + List files with extention `ext` in `folder`. + + Does NOT perform recursive search. + + Parameters + ---------- + folder : str + The path to the folder to investigate. + + ext : str + The file extention. Can be with or without the dot [.] + preffix. + + Returns + ------- + list of Path objects + SORTED list of matching results. + """ + ext = f"*{dot_suffix(ext)}" + files = glob.glob(str(Path(folder, ext))) + return sort_numbered_paths(*(Path(file) for file in files)) + + +def remove_files_with_ext(folder: FilePath, ext: str) -> None: + """ + Remove files with ``ext`` in folder. + + Parameters + ---------- + folder : str + The path to the folder. + + ext : str + The extention of files to delete. Can be with or without the dot ``.`` + preffix. + """ + files = sort_numbered_paths(*glob_folder(folder, ext)) + # if there are no files, the for loop won't run. + for file_ in files: + log.debug(f"removing: {file_}") + file_.unlink() + + +def folder_exists( + path: FilePath, + exception: type[Exception] = ValueError, + emsg: str = "The folder {!r} does not exist or is not a folder.", + ) -> Path: + """ + Assert if a folder exist. + + Parameters + ---------- + path : str or pathlib.Path + The path to the folder. + + exception : Exception + The Exception to raise in case `path` is not file or does not + exist. + + emsg : str + The error message to give to `exception`. May accept formatting + to pass `path`. + + Returns + ------- + pathlib.Path + The Path representation of the input ``path`` if condition is + true. + + Raises + ------ + Exception + Any exception that pathlib.Path can raise. + """ + p = Path(path) + + valid = [p.exists, p.is_dir] + + if all(f() for f in valid): + return p + + # don't change to f-strings, .format has a purpose + raise exception(emsg.format(str(path))) + + +def file_exists( + path: FilePath, + exception: type[Exception] = ValueError, + emsg: str = "`path` is not a file or does not exist", + ) -> Path: + """ + Assert if file exist. + + Parameters + ---------- + path : str or pathlib.Path + The file path. + + exception : Exception + The Exception to raise in case `path` is not file or does not + exist. + + emsg : str + The error message to give to `exception`. May accept formatting + to pass `path`. + + Returns + ------- + pathlib.Path + The Path representation of the input ``path`` if condition is + true. + + Raises + ------ + Exception + Any exception that pathlib.Path can raise. + """ + p = Path(path) + + valid = [p.exists, p.is_file] + + if all(f() for f in valid): + return p + + # don't change to f-strings, .format has a purpose + raise exception(emsg.format(str(path))) + + +def pdb_path_exists(pdb_path: Path) -> tuple[bool, Optional[str]]: + """ + Check if a pdb path exists. + + If not, checks for the existence of a gzipped pdb file and informs the user + that the file is gzipped + + Parameters + ---------- + pdb_path : pathlib.Path + path to the pdb + + Returns + ------- + exists : bool + True if file exists + msg : str or None + the error message + """ + exists, msg = True, None + if not pdb_path.exists(): + msg = f"PDB file {pdb_path} not found." + gz_pdb_path = pdb_path.with_suffix(pdb_path.suffix + ".gz") + if gz_pdb_path.exists(): + msg += f" A compressed file ({gz_pdb_path}) exists though." + msg += "Use haddock3-unpack to unpack the run." + exists = False + return exists, msg + + +def get_perm(fname: FilePath) -> int: + """Get permissions of file.""" + # https://stackoverflow.com/questions/6874970 + return stat.S_IMODE(os.lstat(fname)[stat.ST_MODE]) + + +def make_writeable_recursive(path: FilePath) -> None: + """ + Add writing to a folder, its subfolders and files. + + Parameters + ---------- + path : str or Path + The path to add writing permissions. + """ + # https://stackoverflow.com/questions/6874970 + for root, dirs, files in os.walk(path, topdown=False): + for dir_ in (os.path.join(root, d) for d in dirs): + os.chmod(dir_, get_perm(dir_) | stat.S_IWUSR) + + for file_ in (os.path.join(root, f) for f in files): + os.chmod(file_, get_perm(file_) | stat.S_IWUSR) + + +def extract_files_flat(tar_path: Union[str, FilePath], + dest_path: Union[str, FilePath]) -> None: + """ + Extract files from a tarball to a destination folder. + + Parameters + ---------- + tar_path : str or Path + The path to the tarball file. + + dest_path : str or Path + The path to the destination folder. + """ + with tarfile.open(tar_path, "r:gz") as tar: + for member in tar.getmembers(): + # Extract only files (skip directories) + if member.isfile(): + # Modify the member name to remove the directory structure + member.name = os.path.basename(member.name) + tar.extract(member, dest_path) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libligand.py b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libligand.py new file mode 100644 index 0000000000000000000000000000000000000000..426fb14cfd924e6c718fdd0142b161feb594ea22 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libligand.py @@ -0,0 +1,172 @@ +"""Ligand topology utilities.""" + +import re +import subprocess +import tempfile +from pathlib import Path + +from haddock.core.supported_molecules import supported_residues +from haddock.core.defaults import prodrg_exec, prodrg_param +from haddock import log +import shutil + +from haddock.core.typing import FilePath + + +def identify_unknown_hetatms(pdb_file: FilePath) -> list[str]: + """Return residue names in a PDB that are not in the supported residues. + + Parameters + ---------- + pdb_file : FilePath + Path to the PDB file to inspect. + + Returns + ------- + list[str] + Unique residue names not found in the supported residues set, + in order of first appearance. + """ + seen: list[str] = [] + with open(pdb_file) as fh: + for line in fh: + if not line.startswith(("ATOM ", "HETATM")): + continue + resname = line[17:20].strip() + if resname and resname not in supported_residues and resname not in seen: + seen.append(resname) + return seen + + +def run_prodrg( + pdb_file: FilePath, + output_dir: FilePath, +) -> tuple[Path, Path]: + """Run prodrg on a ligand PDB and write CNS topology and parameter files. + + prodrg writes its output to fixed filenames in the current working + directory, so the process is executed inside a managed temporary directory + that is cleaned up automatically. The resulting files are written to + ``output_dir`` named after the input PDB stem. + + Parameters + ---------- + pdb_file : FilePath + Path to the ligand PDB file. + output_dir : FilePath + Directory where the named ``.top`` and ``.param`` files are written. + + Returns + ------- + tuple[Path, Path] + Paths to the written ``_prodrg.top`` and ``_prodg.param`` files. + + Raises + ------ + RuntimeError + If prodrg exits with a non-zero return code or the expected output + files are not created. + """ + if prodrg_exec is None or prodrg_param is None: + raise RuntimeError( + "prodrg is not available on this platform. " + "Provide the binary path via the PRODRG_EXEC environment variable." + ) + + pdb_file = Path(pdb_file).resolve() + output_dir = Path(output_dir).resolve() + + # PRODRG will write its output in its `pwd`, so run it in a temporary one + with tempfile.TemporaryDirectory() as tmpdir: + # NOTE: PRODRG has a max of 79 chars as input, make sure to pass relative paths + # so we need to copy everything to this temporary dir + dst = Path(tmpdir, prodrg_param.name) + shutil.copy(prodrg_param, dst) + + dst = Path(tmpdir, pdb_file.name) + shutil.copy(pdb_file, dst) + + result = subprocess.run( + # NOTE: We need this `PDBELEM` flag here + [str(prodrg_exec), str(pdb_file.name), str(prodrg_param.name), "PDBELEM"], + cwd=tmpdir, + capture_output=True, + text=True, + ) + + if result.returncode != 0: + raise RuntimeError( + f"prodrg failed with return code {result.returncode}:\n{result.stderr}" + ) + + tmp_top = Path(tmpdir) / "DRGCNS.TOP" + tmp_par = Path(tmpdir) / "DRGCNS.PAR" + + # TODO: Check if the atom names have been changed! + # tmp_pdb = Path(tmpdir) / ".pdb" + + if not tmp_top.exists() or not tmp_par.exists(): + ls = list(Path(tmpdir).iterdir()) + prodrg_err = Path(tmpdir) / "DRGDRG.ERR" + prodrg_log = Path(tmpdir) / "DRGDRG.LOG" + log.error(f"DRGDRG.log: {prodrg_log.read_text()}") + log.error(f"DRGDRG.err: {prodrg_err.read_text()}") + log.debug(f"ls: {ls}") + raise RuntimeError( + f"prodrg finished but expected output files are missing in {tmpdir} " + ) + + top_path = output_dir / f"{pdb_file.stem}_prodrg.top" + par_path = output_dir / f"{pdb_file.stem}_prodrg.param" + + top_content = _sanitize_atom_names(tmp_top.read_text()) + par_content = _sanitize_atom_names(_remove_nbonds(tmp_par.read_text())) + + top_path.write_text(top_content) + par_path.write_text(par_content) + + return top_path, par_path + + +def _sanitize_atom_names(content: str) -> str: + """Remove colons from atom type names in prodrg CNS output. + + prodrg may generate atom type names containing colons (e.g. ``HT:A``) + and this is not compatible with CNS so they must be removed. + + Parameters + ---------- + content : str + Contents of a prodrg-generated CNS file. + + Returns + ------- + str + Content with colons stripped from non-comment lines. + """ + lines = [] + for line in content.splitlines(keepends=True): + if line.lstrip().startswith("!"): + lines.append(line) + else: + lines.append(line.replace(":", "")) + return "".join(lines) + + +def _remove_nbonds(par_content: str) -> str: + """Remove the NBONds...END block from a prodrg CNS parameter string. + + PRODRG definition of NBONds might interfere with HADDOCK's internal parameters, + so we must remove the NBONds lines from the param generated by HADDOCK + + Parameters + ---------- + par_content : str + Contents of the ``DRGCNS.PAR`` file. + + Returns + ------- + str + Parameter content with the NBONds block removed. + """ + return re.sub(r"(?s)NBONds.*?END", "", par_content) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/libs/liblog.py b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/liblog.py new file mode 100644 index 0000000000000000000000000000000000000000..0fe401ff85883e1d83ee9c0a22db7d3cc1d50319 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/liblog.py @@ -0,0 +1,83 @@ +"""Manage logging and logging helper functions.""" +import io +import logging +import sys +from argparse import ArgumentParser +from functools import partial +from logging import FileHandler, Logger, StreamHandler +from typing import TextIO, Union + +from haddock.core.typing import FilePath, StreamHandlerT + + +log_file_name = 'log' + + +info_formatter = '[%(asctime)s %(module)s %(levelname)s] %(message)s' +debug_formatter = ( + "[%(asctime)s] " + "%(filename)s:%(name)s:%(funcName)s:%(lineno)d: " + "%(message)s" + ) + +log_formatters = { + 'DEBUG': debug_formatter, + 'INFO': info_formatter, + 'WARNING': info_formatter, + 'ERROR': info_formatter, + 'CRITICAL': info_formatter, + } + +log_levels = { + 'DEBUG': logging.DEBUG, + 'INFO': logging.INFO, + 'WARNING': logging.WARNING, + 'ERROR': logging.ERROR, + 'CRITICAL': logging.CRITICAL, + } + + +def add_loglevel_arg(parser: ArgumentParser) -> None: + """Add log level argument to CLI.""" + parser.add_argument( + "--log-level", + default='INFO', + choices=list(log_levels.keys()), + ) + return + + +def add_handler( + log_obj: Logger, + handler: type[StreamHandlerT], + stream: Union[FilePath, TextIO], + log_level: str = 'INFO', + formatter: str = info_formatter, + ) -> StreamHandlerT: + """Add a logging Handler to the log object.""" + ch = handler(stream) + ch.setLevel(log_levels[log_level.upper()]) + ch.setFormatter(logging.Formatter(formatter)) + log_obj.addHandler(ch) + return ch + + +def add_log_for_CLI(log: Logger, log_level: str, logfile: FilePath) -> None: + """Configure log for command-line clients.""" + llu = log_level.upper() + + params = { + 'log_level': llu, + 'formatter': log_formatters[llu], + } + + log.handlers.clear() + add_sysout_handler(log, **params) + add_logfile_handler(log, stream=logfile, **params) + return + + +add_sysout_handler = partial(add_handler, handler=StreamHandler, stream=sys.stdout) # noqa: E501 +add_syserr_handler = partial(add_handler, handler=StreamHandler, stream=sys.stderr, log_level='ERROR') # noqa: E501 +add_logfile_handler = partial(add_handler, handler=FileHandler, stream=log_file_name) # noqa: E501 +add_stringio_handler = partial(add_handler, handler=StreamHandler, stream=io.StringIO()) # noqa: E501 diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libmath.py b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libmath.py new file mode 100644 index 0000000000000000000000000000000000000000..26a1d92118c3a1d8bc2ff28ccd5f850fb13a9f71 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libmath.py @@ -0,0 +1,27 @@ +"""Mathematical functions.""" +import random + + +class RandomNumberGenerator: + """ + Generate random numbers. + + Python uses the Mersenne Twister as the core generator. + It produces 53-bit precision floats and has a period of 2**19937-1 + """ + + def __init__(self, seed: int = 494) -> None: + """494 = sum([ord(i) for i in 'HADDOCK']).""" + self.seed = seed + self.random = random.Random() + self.random.seed(self.seed) + + def __call__(self, + lower_limit: float = 0., + upper_limit: float = 1.) -> float: + """Generate a random number between range.""" + return self.random.uniform(lower_limit, upper_limit) + + def randint(self, lower_limit: int = 0, upper_limit: int = 9) -> int: + """Generate a random integer.""" + return int(self() * (upper_limit + 1)) + lower_limit diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libmpi.py b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libmpi.py new file mode 100644 index 0000000000000000000000000000000000000000..6de88d4ba4409a0f1285819db29608ed43e2b669 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libmpi.py @@ -0,0 +1,58 @@ +"""Module in charge of MPI execution of tasks.""" +import pickle +import shlex +import subprocess +import sys +from pathlib import Path +from typing import Any, Optional +from shutil import which + +from haddock import log +from haddock.core.exceptions import HaddockTermination + + +class MPIScheduler: + """Schedules tasks to be executed via MPI.""" + + def __init__(self, tasks: list[Any], ncores: Optional[int] = None) -> None: + self.tasks = tasks + self.cwd = Path.cwd() + self.ncores = ncores + + def run(self) -> None: + """Send it to the haddock3-mpitask runner.""" + pkl_tasks = self._pickle_tasks() + log.info( + f"Executing tasks with the haddock3-mpitask runner using " + f"{self.ncores} processors..." + ) + if which("mpirun") is not None: + cmd = f"mpirun -np {self.ncores} haddock3-mpitask {pkl_tasks}" + elif which("srun") is not None: + cmd = f"srun haddock3-mpitask {pkl_tasks}" + else: + log.error("mpirun or srun are not available on the system") + log.error("Terminating run!") + raise HaddockTermination + + log.debug(f"MPI cmd is {cmd}") + + p = subprocess.run( + shlex.split(cmd), stdout=subprocess.PIPE, stderr=subprocess.PIPE + ) + + # out = p.stdout.decode("utf-8") + err = p.stderr.decode("utf-8") + + if err: + log.error(err) + log.error("Terminating run!") + raise HaddockTermination + + def _pickle_tasks(self) -> Path: + """Pickle the tasks.""" + fpath = Path(self.cwd, "mpi.pkl") + log.debug(f"Pickling the tasks at {fpath}") + with open(fpath, "wb") as output_handler: + pickle.dump(self.tasks, output_handler) + return fpath diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libnotebooks.py b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libnotebooks.py new file mode 100644 index 0000000000000000000000000000000000000000..e61dc39151d618a58f4cdea82dc48710aaf9d64d --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libnotebooks.py @@ -0,0 +1,293 @@ +""" +Helper functions for HADDOCK3 notebooks +""" + +import gzip +import os +from io import StringIO + +from Bio.PDB import PDBIO, PDBParser, Superimposer + +# NOTE: `py3Dmol` is an optional dependency, it might not be installed +# this is why we have the conditional import here +try: + import py3Dmol +except ImportError: + py3Dmol = None + + +def load_pdb_file(file_path): + """.""" + if not os.path.exists(file_path): + print(f"Error: File not found at {file_path}") + return None + + if file_path.endswith(".gz"): + with gzip.open(file_path, "rt") as f: + return f.read() + else: + with open(file_path, "r") as f: + return f.read() + + +def pdb_string_to_structure(pdb_string, structure_id): + """.""" + parser = PDBParser(QUIET=True) + pdb_io = StringIO(pdb_string) + structure = parser.get_structure(structure_id, pdb_io) + return structure + + +def structure_to_pdb_string(structure): + """.""" + pdb_io = PDBIO() + pdb_io.set_structure(structure) + output = StringIO() + pdb_io.save(output) + return output.getvalue() + + +# Full alignement - user-given chains used +# FIXME: This function has too many arguments, needs to be refactored +def align_full( + pdb_path1, + pdb_path2, + chains=["A", "B"], + width=800, + height=600, + model1_colors={"A": "red", "B": "orange", "C": "pink"}, + model2_colors={"A": "blue", "B": "green", "C": "lime"}, + atom_types=["P", "C1", "CA"], + show_labels=False, + show_per_chain_rmsd=True, +): + """.""" + """ + Align two protein structures using all specified chains and visualize with py3Dmol. + + Parameters: + ----------- + pdb_path1 : str + Path to the first (reference) PDB file + pdb_path2 : str + Path to the second PDB file to align to the first + chains : list, default ['A', 'B'] + List of chain IDs to include in alignment + width : int, default 800 + Viewer width in pixels + height : int, default 600 + Viewer height in pixels + model1_colors : dict, default {'A': 'red', 'B': 'orange'} + Colors for chains in model 1 + model2_colors : dict, default {'A': 'blue', 'B': 'green'} + Colors for chains in model 2 + atom_types : list, default ['CA', 'P', 'C1'] + Atom types to use for alignment (['CA'] or ['CA', 'CB', 'N', 'C']) + show_labels : bool, default False + Whether to show descriptive labels + show_per_chain_rmsd : bool, default True + Whether to calculate and display per-chain RMSD values + + Returns: + -------- + py3Dmol.view object + + Example: + -------- + align_full_molecule('model1.pdb.gz', 'model2.pdb.gz') + """ + + def get_atoms_from_chains(structure, chain_ids, atom_types): + atoms = [] + chain_info = {} + + for model in structure: + for chain_id in chain_ids: + if chain_id in model: + chain = model[chain_id] + chain_atoms = [] + for residue in chain: + for atom_type in atom_types: + if atom_type in residue: + atoms.append(residue[atom_type]) + chain_atoms.append(residue[atom_type]) + chain_info[chain_id] = len(chain_atoms) + + return atoms, chain_info + + # Create viewer + view = py3Dmol.view(width=width, height=height) + + # Load PDB files + model_1_data = load_pdb_file(pdb_path1) + model_2_data = load_pdb_file(pdb_path2) + + if not (model_1_data and model_2_data): + print("Failed to load one or both PDB files") + return view, None, {} + + overall_rmsd = None + per_chain_rmsd = {} + + try: + # Parse structures + struct1 = pdb_string_to_structure(model_1_data, "model1") + struct2 = pdb_string_to_structure(model_2_data, "model2") + + # Get atoms from all specified chains + atoms_1, chain_info_1 = get_atoms_from_chains(struct1, chains, atom_types) + atoms_2, chain_info_2 = get_atoms_from_chains(struct2, chains, atom_types) + + print(f"Atoms for alignment - Model 1: {chain_info_1}, Total: {len(atoms_1)}") + print(f"Atoms for alignment - Model 2: {chain_info_2}, Total: {len(atoms_2)}") + print( + "Model 1: " + + "; ".join( + [ + f"chain {chain} in {color}" + for chain, color in model1_colors.items() + if chain in chains + ] + ) + ) + print( + "Model 2: " + + "; ".join( + [ + f"chain {chain} in {color}" + for chain, color in model2_colors.items() + if chain in chains + ] + ) + ) + + if len(atoms_1) > 0 and len(atoms_2) > 0: + # Align using all atoms from specified chains + min_atoms = min(len(atoms_1), len(atoms_2)) + ref_atoms = atoms_1[:min_atoms] + alt_atoms = atoms_2[:min_atoms] + + print(f"Using {min_atoms} atom pairs for alignment") + + # Perform superimposition + sup = Superimposer() + sup.set_atoms(ref_atoms, alt_atoms) + overall_rmsd = sup.rms + + print(f"Whole molecule alignment RMSD: {overall_rmsd:.3f} Å") + + # Apply transformation to all atoms in structure 2 + sup.apply(struct2.get_atoms()) + + # Calculate per-chain RMSD if requested + if show_per_chain_rmsd: + for chain_id in chains: + try: + chain_atoms_1, _ = get_atoms_from_chains( + struct1, [chain_id], atom_types + ) + chain_atoms_2, _ = get_atoms_from_chains( + struct2, [chain_id], atom_types + ) + if len(chain_atoms_1) > 0 and len(chain_atoms_2) > 0: + min_chain = min(len(chain_atoms_1), len(chain_atoms_2)) + sup_chain = Superimposer() + sup_chain.set_atoms( + chain_atoms_1[:min_chain], chain_atoms_2[:min_chain] + ) + per_chain_rmsd[chain_id] = sup_chain.rms + print(f"Chain {chain_id} RMSD: {sup_chain.rms:.3f} Å") + except Exception as e: + print(f"Could not calculate RMSD for chain {chain_id}: {e}") + + # Convert back to PDB strings + aligned_pdb_1 = structure_to_pdb_string(struct1) + aligned_pdb_2 = structure_to_pdb_string(struct2) + + # Add models to viewer + view.addModel(aligned_pdb_1, "pdb") + view.addModel(aligned_pdb_2, "pdb") + + else: + print( + "Could not find sufficient atoms for alignment, adding original models" + ) + view.addModel(model_1_data, "pdb") + view.addModel(model_2_data, "pdb") + + except Exception as e: + print(f"Alignment failed: {e}") + view.addModel(model_1_data, "pdb") + view.addModel(model_2_data, "pdb") + + # Apply styling + view.setStyle({"model": 0}, {"cartoon": {}}) + view.setStyle({"model": 1}, {"cartoon": {}}) + + for chain, color in model1_colors.items(): + if chain in chains: + view.addStyle( + {"model": 0, "chain": chain}, + {"cartoon": {"color": color, "opacity": 0.9}}, + ) + + for chain, color in model2_colors.items(): + if chain in chains: + view.addStyle( + {"model": 1, "chain": chain}, + {"cartoon": {"color": color, "opacity": 0.6}}, + ) + + # Add labels if requested + if show_labels: + view.addLabel( + "Model 1 (Reference)", + { + "position": {"x": -20, "y": 20, "z": 0}, + "backgroundColor": "darkred", + "fontColor": "white", + }, + ) + view.addLabel( + "Model 2 (Aligned)", + { + "position": {"x": 20, "y": 20, "z": 0}, + "backgroundColor": "darkgreen", + "fontColor": "white", + }, + ) + view.addLabel( + "Full Molecule Alignment", + { + "position": {"x": 0, "y": -20, "z": 0}, + "backgroundColor": "navy", + "fontColor": "white", + }, + ) + if overall_rmsd: + view.addLabel( + f"Overall RMSD: {overall_rmsd:.3f} Å", + { + "position": {"x": 0, "y": -30, "z": 0}, + "backgroundColor": "purple", + "fontColor": "white", + }, + ) + + # Add per-chain RMSD labels + y_offset = -40 + for chain_id, rmsd_val in per_chain_rmsd.items(): + view.addLabel( + f"Chain {chain_id}: {rmsd_val:.3f} Å", + { + "position": {"x": 0, "y": y_offset, "z": 0}, + "backgroundColor": "gray", + "fontColor": "white", + "fontSize": 10, + }, + ) + y_offset -= 8 + + view.zoomTo() + + return view diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libontology.py b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libontology.py new file mode 100644 index 0000000000000000000000000000000000000000..4646c9cc9607aa2b7a0e9c40491bb136f75071fb --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libontology.py @@ -0,0 +1,250 @@ +"""Describe the Haddock3 ontology used for communicating between modules.""" + +import datetime +import itertools +from enum import Enum +from os import linesep +from pathlib import Path + + +import jsonpickle + +from haddock.core.defaults import MODULE_IO_FILE +from haddock.core.typing import FilePath, Literal, Optional, TypeVar, Union +from typing import List, Any + + +NaN = float("nan") + + +class Format(Enum): + """Input and Output possible formats.""" + + PDB = "pdb" + PDB_ENSEMBLE = "pdb" + CNS_INPUT = "inp" + CNS_OUTPUT = "out" + TOPOLOGY = "psf" + MATRIX = "matrix" + + def __str__(self) -> str: + return str(self.value) + + +class Persistent: + """Any persistent file generated by this framework.""" + + def __init__( + self, + file_name: FilePath, + file_type: Format, + path: FilePath = ".", + md5: Optional[str] = None, + restr_fname: Optional[FilePath] = None, + ) -> None: + self.created = datetime.datetime.now().isoformat(" ", "seconds") + self.file_name = Path(file_name).name + self.file_type = file_type + self.path = str(Path(path).resolve()) + self.full_name = str(Path(path, self.file_name)) + self.rel_path = Path("..", Path(self.path).name, file_name) + self.md5 = md5 + self.restr_fname = restr_fname + + def __repr__(self) -> str: + rep = ( + f"[{self.file_type}|{self.created}] " f"{Path(self.path) / self.file_name}" + ) + return rep + + def is_present(self) -> bool: + """Check if the persisent file exists on disk.""" + return self.rel_path.resolve().exists() + + +class PDBFile(Persistent): + """Represent a PDB file.""" + + def __init__( + self, + file_name: Union[Path, str], + topology: Optional[Any] = None, + path: Union[Path, str] = ".", + score: float = NaN, + md5: Optional[str] = None, + restr_fname: Optional[Union[Path, str]] = None, + unw_energies: Optional[dict[str, float]] = None, + ) -> None: + super().__init__(file_name, Format.PDB, path, md5, restr_fname) + + self.topology = topology + self.score = score + self.ori_name: Optional[str] = None + self.clt_id: Union[str, int, None] = None + self.clt_rank: Optional[int] = None + self.clt_model_rank: Optional[int] = None + self.len = score + self.unw_energies = unw_energies + self.seed = None + + def __lt__(self, other: "PDBFile") -> bool: + return self.score < other.score + + def __gt__(self, other: "PDBFile") -> bool: + return self.score > other.score + + def __eq__(self, other: "PDBFile") -> bool: # type: ignore + return self.score == other.score + + def __hash__(self) -> int: + return id(self) + + +class RMSDFile(Persistent): + """Represents a RMSD matrix file.""" + + def __init__(self, file_name: FilePath, npairs: int, path: FilePath = ".") -> None: + super().__init__(file_name, Format.MATRIX, path) + self.npairs = npairs + + def __hash__(self) -> int: + return id(self) + + +class TopologyFile(Persistent): + """Represent a CNS-generated topology file.""" + + def __init__(self, file_name: FilePath, path: FilePath = ".") -> None: + super().__init__(file_name, Format.TOPOLOGY, path) + + +class ModuleIO: + """Intercommunicating modules and exchange input/output information.""" + + def __init__(self) -> None: + self.input: List[Any] = [] + self.output: List[Any] = [] + + def add(self, persistent, mode="i"): + """Add a given filename as input or output.""" + if mode == "i": + if isinstance(persistent, list): + self.input.extend(persistent) + else: + self.input.append(persistent) + else: + if isinstance(persistent, list): + self.output.extend(persistent) + else: + self.output.append(persistent) + + def save(self, path: FilePath = ".", filename: FilePath = MODULE_IO_FILE) -> Path: + """Save Input/Output needed files by this module to disk.""" + fpath = Path(path, filename) + with open(fpath, "w") as output_handler: + to_save = {"input": self.input, "output": self.output} + jsonpickle.set_encoder_options("json", sort_keys=True, indent=4) + output_handler.write(jsonpickle.encode(to_save)) # type: ignore + return fpath + + def load(self, filename: FilePath) -> None: + """Load the content of a given IO filename.""" + with open(filename) as json_file: + content = jsonpickle.decode(json_file.read()) + self.input = content["input"] # type: ignore + self.output = content["output"] # type: ignore + + def retrieve_models( + self, crossdock: bool = False, individualize: bool = False + ) -> list[Union[PDBFile, list[PDBFile]]]: + """Retrieve the PDBobjects to be used in the module.""" + # Get the models generated in previous step + model_list: list[PDBFile] = [] + input_dic: dict[int, list[PDBFile]] = {} + + for i, element in enumerate(self.output): + if isinstance(element, dict): + position_list: list[PDBFile] = input_dic.setdefault(i, []) + for key in element: + position_list.append(element[key]) # type: ignore + + elif element.file_type == Format.PDB: # type: ignore + model_list.append(element) # type: ignore + + if input_dic and not crossdock and not individualize: + # check if all ensembles contain the same number of models + sub_lists = iter(input_dic.values()) + _len = len(next(sub_lists)) + if not all(len(sub) == _len for sub in sub_lists): + _msg = ( + "Different number of models in molecules," + " cannot prepare pairwise complexes." + ) + raise Exception(_msg) + + # prepare pairwise combinations + model_list = [values for values in zip(*input_dic.values())] # type: ignore + elif input_dic and crossdock and not individualize: + model_list = [values for values in itertools.product(*input_dic.values())] # type: ignore + elif input_dic and individualize: + model_list = list(itertools.chain(*input_dic.values())) + + return model_list # type: ignore + + def check_faulty(self) -> float: + """Check how many of the output exists.""" + total = 0.0 + present = 0.0 + for element in self.output: + if isinstance(element, dict): + total += len(element) + present += sum(j.is_present() for j in element.values()) + else: + total += 1 + if element.is_present(): + present += 1 + + if total == 0: + _msg = "No expected output was passed to ModuleIO" + raise Exception(_msg) + + faulty_per = (1 - (present / total)) * 100 + + # added this method here to avoid modifying all calls in the + # modules' run method. We can think about restructure this part + # in the future. + self.remove_missing() + + return faulty_per + + def remove_missing(self) -> None: + """Remove missing structure from `output`.""" + # can't modify a list/dictionary within a loop + idxs: list[int] = [] + for idx, element in enumerate(self.output): + if isinstance(element, dict): + to_pop = [] + for key2 in element: + if not element[key2].is_present(): + to_pop.append(key2) + for pop_me in to_pop: + element.pop(pop_me) + else: + if not element.is_present(): + idxs.append(idx) + + self.output = [value for i, value in enumerate(self.output) if i not in idxs] + + def __repr__(self) -> str: + return f"Input: {self.input}{linesep}Output: {self.output}" + + +PDBPath = Union[PDBFile, Path] + +PDBPathT = TypeVar("PDBPathT", bound=Union[PDBFile, Path]) +""" +Generic type variable for PDBFile or Path. + +If the first annotated variable is PDBFile, +the second annotated variable will be PDBFile instead of Path,vice versa. +""" diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libparallel.py b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libparallel.py new file mode 100644 index 0000000000000000000000000000000000000000..0490453ab291e98a63a7ef3dc74bd13d75ab4c06 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libparallel.py @@ -0,0 +1,208 @@ +"""Module in charge of parallelizing the execution of tasks.""" + +import math +from multiprocessing import Process, Queue + +from haddock import log +from haddock.core.typing import ( + AnyT, + FilePath, + Generator, + Optional, + Sequence, + SupportsRunT, + Union, +) +from haddock.libs.libutil import parse_ncores + + +def split_tasks(lst: Sequence[AnyT], n: int) -> Generator[Sequence[AnyT], None, None]: + """Split tasks into N-sized chunks.""" + n = math.ceil(len(lst) / n) + for j in range(0, len(lst), n): + chunk = lst[j : n + j] + yield chunk + + +def get_index_list(nmodels, ncores): + """ + Optimal distribution of models among cores + + Parameters + ---------- + nmodels : int + Number of models to be distributed. + + ncores : int + Number of cores to be used. + + Returns + ------- + index_list : list + List of model indexes to be used for the parallel scanning. + """ + if nmodels < 1: + raise ValueError(f"nmodels ({nmodels})) must be greater than 0") + if ncores < 1: + raise ValueError(f"ncores ({ncores}) must be greater than 0") + spc = nmodels // ncores + # now the remainder + rem = nmodels % ncores + # now the list of indexes to be used for the SCAN calculation + index_list = [0] + for core in range(ncores): + if core < rem: + index_list.append(index_list[-1] + spc + 1) + else: + index_list.append(index_list[-1] + spc) + return index_list + + +class GenericTask: + """Generic task to be executed.""" + + def __init__(self, function, *args, **kwargs): + if not callable(function): + raise TypeError("The 'function' argument must be callable") + self.function = function + self.args = args + self.kwargs = kwargs + + def run(self): + return self.function(*self.args, **self.kwargs) + + +class Worker(Process): + """Work on tasks.""" + + def __init__(self, tasks: Sequence[SupportsRunT], results: Queue) -> None: + super(Worker, self).__init__() + self.tasks = tasks + self.result_queue = results + log.debug(f"Worker ready with {len(self.tasks)} tasks") + + def run(self) -> None: + """Execute tasks.""" + results = [] + for task in self.tasks: + r = None + try: + r = task.run() + except Exception as e: + log.warning(f"Exception in task execution: {e}") + + results.append(r) + + # Put results into the queue + self.result_queue.put(results) + + # Signal completion by putting a unique identifier into the queue + self.result_queue.put(f"{self.name}_done") + + # log.debug(f"{self.name} executed") + + +class Scheduler: + """Schedules tasks to run in multiprocessing.""" + + def __init__( + self, + tasks: list[SupportsRunT], + ncores: Optional[int] = None, + max_cpus: bool = False, + ) -> None: + """ + Schedule tasks to a defined number of processes. + + Parameters + ---------- + tasks : list + The list of tasks to execute. Tasks must have method `run()`. + + ncores : None or int + The number of cores to use. If `None` is given uses the + maximum number of CPUs allowed by + `libs.libututil.parse_ncores` function. + """ + self.max_cpus = max_cpus + self.num_tasks = len(tasks) + self.num_processes = ncores # first parses num_cores + self.queue: Queue = Queue() + self.results: list = [] + + # Sort the tasks by input_file name and its length, so we know that 2 comes before 10 + ### Q? Whys is this necessary? + # Only CNSJobs can be sorted like this + if all(hasattr(t, "input_file") for t in tasks): + task_name_dic: dict[int, tuple[FilePath, int]] = {} + for i, t in enumerate(tasks): + task_name_dic[i] = (t.input_file, len(str(t.input_file))) # type: ignore + + sorted_task_list: list[SupportsRunT] = [] + for e in sorted(task_name_dic.items(), key=lambda x: (x[0], x[1])): + idx = e[0] + sorted_task_list.append(tasks[idx]) + else: + sorted_task_list = tasks + + job_list = split_tasks(sorted_task_list, self.num_processes) + self.worker_list = [Worker(jobs, self.queue) for jobs in job_list] + + log.info(f"Using {self.num_processes} cores") + log.debug(f"{self.num_tasks} tasks ready.") + + @property + def num_processes(self) -> int: + """Number of processors to use.""" # noqa: D401 + return self._ncores + + @num_processes.setter + def num_processes(self, n: Union[str, int, None]) -> None: + self._ncores = parse_ncores( + n, + njobs=self.num_tasks, + max_cpus=self.max_cpus, + ) + log.debug(f"Scheduler configured for {self._ncores} cpu cores.") + + def run(self) -> None: + """Run tasks in parallel.""" + + try: + for w in self.worker_list: + w.start() + + # Collect results until all workers have signaled completion + all_results = [] + num_workers = len(self.worker_list) + completed_workers = 0 + + while completed_workers < num_workers: + result = self.queue.get() + if isinstance(result, str) and result.endswith("_done"): + completed_workers += 1 + else: + all_results.append(result) + + for w in self.worker_list: + w.join() + + self.results = [item for sublist in all_results for item in sublist] + + log.info(f"{self.num_tasks} tasks finished") + + except KeyboardInterrupt as err: + # Q: why have a keyboard interrupt here? + # A: To have a controlled break if the user Ctrl+c during CNS run + self.terminate() + # this raises sends the error to libs.libworkflow.Step + # if Scheduler is used independently the error will propagate to + # whichever has to catch it + raise err + + def terminate(self) -> None: + """Terminate tasks in a controlled way.""" + for worker in self.worker_list: + worker.terminate() + + log.info("The workers terminated in a controlled way") diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libpdb.py b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libpdb.py new file mode 100644 index 0000000000000000000000000000000000000000..ba926c48753c9410df864fe2fced301871264a33 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libpdb.py @@ -0,0 +1,508 @@ +"""Parse molecular structures in PDB format.""" + +import os +from copy import deepcopy +from functools import partial +from pathlib import Path + +from pdbtools.pdb_segxchain import run as place_seg_on_chain +from pdbtools.pdb_splitchain import run as split_chain +from pdbtools.pdb_splitmodel import run as split_model +from pdbtools.pdb_tidy import run as tidy_pdbfile + +from haddock.core.exceptions import SetupError +from haddock.core.supported_molecules import supported_residues +from haddock.core.typing import ( + Callable, + FilePath, + FilePathT, + Iterable, + Optional, + TypeVar, + Union, +) +from haddock.libs.libio import PDBFile, working_directory +from haddock.libs.libutil import get_result_or_same_in_list, sort_numbered_paths + +slc_record = slice(0, 6) +slc_serial = slice(6, 11) +slc_name = slice(12, 16) +slc_altloc = slice(16, 17) +slc_resname = slice(17, 20) +slc_chainid = slice(21, 22) +slc_resseq = slice(22, 26) +slc_icode = slice(26, 27) +slc_x = slice(30, 38) +slc_y = slice(38, 46) +slc_z = slice(46, 54) +slc_occ = slice(54, 60) +slc_temp = slice(60, 66) +slc_segid = slice(72, 76) +slc_element = slice(76, 78) +slc_charge = slice(78, 80) + + +def format_atom_name(atom: str, element: str) -> str: + """ + Format PDB atom name. + + Further Reading: + + * https://www.cgl.ucsf.edu/chimera/docs/UsersGuide/tutorials/pdbintro.html + + Parameters + ---------- + atom : str + The atom name. + + element : str + The atom element code. + + Returns + ------- + str + Formatted atom name. + """ + # string formats for atom name + _3 = " {:<3s}" + _4 = "{:<4s}" + # len of element, atom formatting string + # anything outside this is an error + _atom_format_dict = { + # len of element: {len of atom name} + 1: {1: _3, 2: _3, 3: _3, 4: _4}, + 2: {1: _4, 2: _4, 3: _4, 4: _4}, + } + + atm = atom.strip() + len_atm = len(atm) + len_ele = len(element.strip()) + + try: + return _atom_format_dict[len_ele][len_atm].format(atm) + except KeyError as err: + _ = f"Could not format this atom:type -> {atom}:{element}" + # raising KeyError assures that no context in IDPConfGen + # will handle it. @joaomcteixeira never handles pure Python + # exceptions, those are treated as bugs. + raise KeyError(_) from err + + +def get_supported_residues(haddock_topology: FilePath) -> list[str]: + """Read the topology file and identify which data is supported.""" + supported: list[str] = [] + with open(haddock_topology) as input_handler: + for line in input_handler: + if "resi" in line[:4].casefold(): + res = line.split()[1] + supported.append(res) + return supported + + +_to_remove = ["REMAR", "CTERB", "CTERA", "NTERA", "NTERB", "CONECT"] + +_to_rename = { + "HSD": "HIS", + "HSE": "HIS", + "HID": "HIS", + "HIE": "HIS", + "WAT ": "TIP3", + " 0.00969": " 0.00 ", +} + +# Get list of supported residues to keep when pre-processing +_to_keep = list(supported_residues) + + +def split_ensemble(pdb_file_path: Path, dest: Optional[FilePath] = None) -> list[Path]: + """ + Split a multimodel PDB file into different structures. + + Parameters + ---------- + dest : str or pathlib.Path + Destination folder. + """ + if dest is None: + dest = Path.cwd() + assert pdb_file_path.is_file(), pdb_file_path + with open(pdb_file_path) as input_handler: + with working_directory(dest): + # tidy pdb before splitting + tidied = tidy_pdbfile(input_handler) + split_model(tidied, outname=str(pdb_file_path.stem)) + + return sort_numbered_paths(*get_new_models(pdb_file_path)) + + +def split_by_chain(pdb_file_path: FilePath) -> list[Path]: + """Split a PDB file into multiple structures for each chain.""" + abs_path = Path(pdb_file_path).resolve().parent.absolute() + with open(pdb_file_path) as input_handler: + with working_directory(abs_path): + split_chain(input_handler) + + return get_new_models(pdb_file_path) + + +def tidy(pdb_file_path: FilePath, new_pdb_file_path: FilePath) -> None: + """Tidy PDB structure.""" + abs_path = Path(pdb_file_path).resolve().parent.absolute() + with open(pdb_file_path) as input_handler: + with working_directory(abs_path): + with open(new_pdb_file_path, "w") as output_handler: + for line in tidy_pdbfile(input_handler): + output_handler.write(line) + + +def swap_segid_chain(pdb_file_path: FilePath, new_pdb_file_path: FilePath) -> None: + """Add to the Chain ID column the found Segid.""" + abs_path = Path(pdb_file_path).resolve().parent.absolute() + with open(pdb_file_path) as input_handler: + with working_directory(abs_path): + with open(new_pdb_file_path, "w") as output_handler: + for line in place_seg_on_chain(input_handler): + output_handler.write(line) + + +def sanitize( + pdb_file_path: FilePathT, + overwrite: bool = True, + custom_topology: Optional[FilePath] = None, +) -> Union[FilePathT, Path]: + """Sanitize a PDB file.""" + to_keep = deepcopy(_to_keep) + if custom_topology: + custom_res_to_keep = get_supported_residues(custom_topology) + to_keep.extend(custom_res_to_keep) + + good_lines: list[str] = [] + with open(pdb_file_path) as input_handler: + for line in input_handler: + line = line.rstrip(os.linesep) + # Ignoring lines containing any tag from __to_remove + if not any([tag in line for tag in _to_remove]): + for tag, new_tag in _to_rename.items(): + line = line.replace(tag, new_tag) + # check if this residue is known + res = line[17:20].strip() + if res and res in to_keep: + good_lines.append(line) + # Terminate file with an END statement + if len(good_lines) > 0 and good_lines[-1] != "END": + good_lines.append("END") + + # Check if anything has been kept from this file + if len(good_lines) == 0: + raise SetupError(f"No coordinates kept after sanitzing {pdb_file_path.name}.") + + if overwrite: + with open(pdb_file_path, "w") as output_handler: + for line in good_lines: + output_handler.write(line + os.linesep) + return pdb_file_path + + basename = Path(pdb_file_path) + new_pdb_file = Path(f"{basename.stem}_cleaned{basename.suffix}") + new_pdb_file.write_text(os.linesep.join(good_lines) + os.linesep) + return new_pdb_file + + +def identify_chainseg( + pdb_file_path: FilePath, sort: bool = True +) -> tuple[list[str], list[str]]: + """Return segID OR chainID.""" + segids: list[str] = [] + chains: list[str] = [] + with open(pdb_file_path) as input_handler: + for line in input_handler: + if line.startswith(("ATOM ", "HETATM")): + try: + segid = line[72:76].strip()[:1] + except IndexError: + segid = "" + try: + chainid = line[21].strip() + except IndexError: + chainid = "" + + if segid: + segids.append(segid) + if chainid: + chains.append(chainid) + + if not segid and not chainid: + raise ValueError( + f"Could not identify chainID or segID in pdb {pdb_file_path}, line {line}" + ) + + if sort: + segids = sorted(list(set(segids))) + chains = sorted(list(set(chains))) + else: + segids = list(set(segids)) + chains = list(set(chains)) + return segids, chains + + +def get_new_models(pdb_file_path: FilePath) -> list[Path]: + """ + Get new PDB models if they exist. + + If no new models are found, return the original path within a list. + """ + new_models = get_result_or_same_in_list( + get_pdb_file_suffix_variations, + pdb_file_path, + ) + return new_models + + +def get_pdb_file_suffix_variations(file_name: FilePath, sep: str = "_") -> list[Path]: + """ + List suffix variations of a PDB file in the current path. + + If `file.pdb` is given, and files `file_1.pdb`, `file_2.pdb`, exist + in the folder, those will be listed. + + Parameters + ---------- + file_name : str or Path + The name of the file with extension. + + sep : str + The separation between the file base name and the suffix. + Defaults to "_". + + Returns + ------- + list + List of Paths with the identified PBD files. + If no files are found return an empty list. + """ + basename = Path(file_name) + return list(Path(".").glob(f"{basename.stem}{sep}*{basename.suffix}")) + + +def read_RECORD_section( + lines: Iterable[str], + section_slice: slice, + func: Callable[[Iterable[str]], Iterable[str]] = set, +) -> Iterable[str]: + """ + Create a set of observations from a section of the ATOM line. + + Returns + ------- + set + A set of the observations. + """ + # read the chain ID + chainids = func( + the_line + for line in lines + if line.startswith(("ATOM", "HETATM")) + and (the_line := line[section_slice].strip()) # noqa: E501 + ) + return chainids + + +read_chainids = partial(read_RECORD_section, section_slice=slc_chainid, func=list) +read_segids = partial(read_RECORD_section, section_slice=slc_segid, func=list) + + +def add_TER_on_chain_breaks( + input_pdb: FilePath, + output_pdb: FilePath, +) -> None: + """Detect chain breaks and add TER statements between them. + + Parameters + ---------- + input_pdb : FilePath + Input PDB filepath with potential chain breaks. + output_pdb : FilePath + Output PDB filepath with added TER statements between chain breaks. + """ + Residue = dict[str, Union[list[str], list[float], str]] + residueT = TypeVar("residueT", bound=Residue) + + def euclidean_dist(atm1: list[float], atm2: list[float]) -> float: + """Compute Euclidean distances between two points. + + Parameters + ---------- + atm1 : list[float] + Atom 1 coordinates. + atm2 : list[float] + Atom 2 coordinates. + + Returns + ------- + float + Distance between the two atoms. + """ + return sum([(c1 - c2) ** 2 for c1, c2 in zip(atm1, atm2)]) ** 0.5 + + def detected_chain_break(residue1: residueT, residue2: residueT) -> bool: + """Detect chain break between two consecutive residues. + + Currently limitted to DNA and protein chains. + + Parameters + ---------- + residue1 : residueT + Previous residue (N-1) + residue2 : residueT + Current residue (N) + + Returns + ------- + bool + True if chain break detected, else False + """ + # Expected backbone distances set + backbone_dists = { + "protein": 3.5, # very loose ! + "DNA": 4.5, + } + # Detect type of residues + # DNA case + try: + # Extract coordinates + atm1 = residue1["O3'"] + atm2 = residue2["O5'"] + except KeyError: + # Protein case + try: + # Extract coordinates + atm1 = residue1["C"] # C of -1 residue + atm2 = residue2["N"] # N of 0 residue + # Error in detection of any of the atoms + except KeyError: + # Must be a chain break + # FIXME : This assumes that it is NOT a DNA nor a protein. + # In the future, if future there is, it may cause an issue if + # lipids, glycans, other type of entities are added, + # as this will trigger a TER statement between them. + return True + else: + entity_type = "protein" + else: + entity_type = "DNA" + # Point distance + upper_dist = backbone_dists[entity_type] + # Check if distance is within acceptable peptide bond limit + return euclidean_dist(atm1, atm2) > upper_dist + + def write_residue(fhandler, residue_lines: list[str]) -> None: + """Writes residues line to file. + + Parameters + ---------- + fhandler : _type_ + File object on which to write the residue lines. + residue_lines : list[str] + Residue to write. + """ + for _ in residue_lines: + fhandler.write(_) + + def write_previous_residue( + fhandler, + previous: residueT, + current: residueT, + ) -> None: + """Write residue lines to file, possibly ending by TER. + + Parameters + ---------- + fhandler : _type_ + File object on which to write the residue lines. + previous : residueT + Previous residue (N-1) + current : residueT + Current residue (N) + """ + # Write previous residue + write_residue(fhandler, previous["lines"]) + # Check if bond observed between -2 and -1 + chain_break = detected_chain_break( + previous, + current, + ) + # If chain break detected or new chain in file + if chain_break or previous["chain"] != current["chain"]: + fhandler.write(f"TER{os.linesep}") + + # Initiate parsing variables + BB_atomnames: tuple[str, str, str, str] = ( + "C", + "N", # for peptide bonds + "O3'", + "O5'", # for DNA/RNA + ) + current_resid: tuple[str, str] = ("-", "-") + previous_residue: residueT = {"lines": []} + current_residue: residueT = {"lines": []} + # Read input file + with open(input_pdb, "r") as fin, open(output_pdb, "w") as fout: + for _ in fin: + if _.startswith( + ( + "ATOM", + "HETATM", + ) + ): + # Extract specific data from coordinates record + chainid = _[slc_chainid].strip() + resid = _[slc_resseq].strip() + atname = _[slc_name].strip() + + # Case when new residue + if current_resid != (chainid, resid): + # Make sure it is not first residue + if len(previous_residue["lines"]) > 0: + # Write previous residue + write_previous_residue(fout, previous_residue, current_residue) + # Reset previous residue to current residue + previous_residue = current_residue + # Initialize new current residue + current_resid = ( + chainid, + resid, + ) + current_residue = {"lines": [], "chain": chainid} + + # Hold residue line + current_residue["lines"].append(_) + + # If atom name is in the backbone atoms + if atname in BB_atomnames: + # Hold backbone atom coordinates in current residue + current_residue[atname] = [ + float(_[slc_x]), + float(_[slc_y]), + float(_[slc_z]), + ] + # Last previous residue + write_previous_residue(fout, previous_residue, current_residue) + # Last residue + write_residue(fout, current_residue["lines"]) + # Write final TER statement + fout.write(f"TER{os.linesep}") + # Write END statement + fout.write(f"END{os.linesep}") + + +def check_combination_chains(combination: list[PDBFile]) -> list[str]: + """Check if chain IDs are unique for each pdb in combination.""" + chainid_list: list[str] = [] + for pdb in combination: + segids, chains = identify_chainseg(pdb.rel_path, sort=False) + chainsegs = sorted(list(set(segids) | set(chains))) + # check if any of chainsegs is already in chainid_list + if any(chainseg in chainid_list for chainseg in chainsegs): + raise ValueError(f"Chain/seg IDs are not unique for pdbs {combination}.") + chainid_list.extend(chainsegs) + return chainid_list diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libplots.py b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libplots.py new file mode 100644 index 0000000000000000000000000000000000000000..43dfea1b27d47da2ca1c99c278543d3681ac9595 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libplots.py @@ -0,0 +1,1641 @@ +"""Plotting functionalities.""" + +import json +import shutil + +import numpy as np +import pandas as pd +import plotly.colors as px_colors +import plotly.express as px +import plotly.graph_objects as go +from plotly.io._utils import plotly_cdn_url +from plotly.offline.offline import get_plotlyjs +from plotly.subplots import make_subplots + +from pathlib import Path + +from haddock import log +from haddock.core.typing import ( + Any, + DataFrameGroupBy, + Figure, + FilePath, + ImgFormat, + NDFloat, + Optional, + Union, + ) +from haddock.libs.assets import haddock_ui_path + + +SCATTER_PAIRS = [ + ("irmsd", "score"), + ("irmsd", "desolv"), + ("irmsd", "vdw"), + ("irmsd", "elec"), + ("irmsd", "air"), + ("dockq", "score"), + ("dockq", "desolv"), + ("dockq", "vdw"), + ("dockq", "elec"), + ("dockq", "air"), + ("lrmsd", "score"), + ("lrmsd", "desolv"), + ("lrmsd", "vdw"), + ("lrmsd", "elec"), + ("lrmsd", "air"), + ("ilrmsd", "score"), + ("ilrmsd", "desolv"), + ("ilrmsd", "vdw"), + ("ilrmsd", "elec"), + ("ilrmsd", "air"), + ("fnat", "score"), + ("fnat", "desolv"), + ("fnat", "vdw"), + ("fnat", "elec"), + ("fnat", "air"), + ] + + +# if SCATTER_PAIRS changes, SCATTER_MATRIX_SIZE should change too! +SCATTER_MATRIX_SIZE = (5, 5) # (number of rows, number of columns) + +TITLE_NAMES = { + "score": "HADDOCK score", + "irmsd": "i-RMSD", + "lrmsd": "l-RMSD", + "ilrmsd": "il-RMSD", + "dockq": "DOCKQ", + "desolv": "Edesolv", + "vdw": "Evdw", + "elec": "Eelec", + "air": "Eair", + "fnat": "FCC", + "bsa": "BSA", + } + +AXIS_NAMES = { + "score": "HADDOCK score [a.u.]", + "vdw": "Van der Waals Energy", + "elec": "Electrostatic Energy", + "air": "Restraints Energy", + "desolv": "Desolvation Energy", + "irmsd": "interface RMSD [A]", + "lrmsd": "ligand RMSD [A]", + "ilrmsd": "interface-ligand RMSD [A]", + "fnat": "Fraction of Common Contacts", + "dockq": "DOCKQ", + "bsa": "Buried Surface Area [A^2]", + } + +ClRank = dict[int, int] +""" +A dict representing clusters' rank. + +key (int): cluster's id + +value(int): cluster's rank +""" + +HEATMAP_DEFAULT_PATH = Path('contacts.html') +SUPPORTED_OUTPUT_FORMATS = ('png', 'jpeg', 'webp', 'svg', 'pdf', 'eps', ) + +def create_html( + json_content: str, + plot_id: int = 1, + plotly_js_import: Optional[str] = None, + figure_height: int = 800, + figure_width: int = 1000, + ) -> str: + """Create html content given a plotly json. + + Parameters + ---------- + json_content : str + plotly json content + + plot_id : int + plot id to be used in the html content + + figure_height : int + figure height (in pixels) + + figure_width : int + figure width (in pixels) + + Returns + ------- + html_content : str + html content + """ + # Check if plotly javascript must be flushed in this file + if not plotly_js_import: + plotly_js_import = f'' + + # Write HTML content + html_content = f""" +
+ + {plotly_js_import} +
+
+ + +
+ """ # noqa : E501 + return html_content + + +def read_capri_table( + capri_filename: FilePath, + comment: str = "#", + ) -> pd.DataFrame: + """Read capri table with pandas. + + Parameters + ---------- + capri_filename : str or Path + capri single structure filename + comment : str + the string used to denote a commented line in capri tables + + Returns + ------- + capri_df : pandas DataFrame + dataframe of capri values + """ + capri_df = pd.read_csv(capri_filename, sep="\t", comment=comment) + return capri_df + + +def in_capri(column: str, df_columns: pd.Index) -> bool: + """ + Check if the selected column is in the set of available columns. + + Parameters + ---------- + column : str + column name + df_columns : pandas.DataFrame.columns + columns of a pandas.DataFrame + + Returns + ------- + resp : bool + if True, the column is present + """ + resp = True + if column not in df_columns: + log.warning(f"quantity {column} not present in capri table") + resp = False + return resp + + +def update_layout_plotly( + fig: Figure, + x_label: str, + y_label: str, + title: Optional[str] = None, + ) -> Figure: + """ + Update layout of plotly plot. + + Parameters + ---------- + fig : plotly Figure + figure + x_label : str + x axis name + y_label : str + y axis name + title : str or None + plot title + """ + px_dict = { + "title": title, + "xaxis": dict( + title=dict(text=x_label, font=dict(size=40)), + tickfont_size=14, + ), + "yaxis": dict( + title=dict(text=y_label, font=dict(size=40)), + tickfont_size=14, + ), + "legend": dict(x=1.01, y=1.0, font_family="Helvetica", font_size=16), + "hoverlabel": dict(font_size=16, font_family="Helvetica"), + } + fig.update_layout(px_dict) + return fig + + +def box_plot_plotly( + gb_full: pd.DataFrame, + y_ax: str, + cl_rank: dict[int, int], + format: Optional[ImgFormat], + scale: Optional[float], + offline: bool = False, + ) -> Figure: + """ + Create a scatter plot in plotly. + + Parameters + ---------- + gb_full : pandas DataFrame + data to box plot + y_ax : str + variable to plot + cl_rank : dict + {cluster_id : cluster_rank} dictionary + format : str + Produce images in the selected format. + scale : int + scale of image + + Returns + ------- + fig_list : list + a list of figures + """ + colors = px_colors.qualitative.Dark24 + color_map = {} + for cl_id in sorted(cl_rank.keys()): + color_idx = (cl_rank[cl_id] - 1) % len(colors) # color index + + # Note: the rank format (float/int) in "cl_rank" is different from + # gb_full["cluster_ranking"] + rns = gb_full[gb_full["cluster_id"] == cl_id]["cluster_ranking"] + rn = rns.unique()[0] + color_map[f"{rn}"] = colors[color_idx] + + # Choose a different color for "Other" like in scatter plots + color_map["Other"] = "#DDDBDA" + + # to use color_discrete_map, cluster_ranking column should be str not int + gb_full_string = gb_full.astype({"cluster_ranking": "string"}) + + # Rename for a better name in legend + gb_full_string.rename( + columns={"cluster_ranking": "Cluster Rank"}, + inplace=True, + ) + + # "Cluster Rank" is equivalent to "capri_rank"! + fig = px.box( + gb_full_string, + x="capri_rank", + y=f"{y_ax}", + color="Cluster Rank", + color_discrete_map=color_map, + boxmode="overlay", + points="outliers", + width=1000, + height=800, + hover_data=["caprieval_rank"], + ) + # layout + update_layout_plotly(fig, "Cluster Rank", AXIS_NAMES[y_ax]) + # save figure + px_fpath = Path(f"{y_ax}_clt.html") + json_content = fig.to_json() + html_content = create_html( + json_content, + plotly_js_import=offline_js_manager(px_fpath, offline), + ) + # write html_content to px_fname + px_fpath.write_text(html_content) + # create format boxplot if necessary + if format: + fig.write_image(f"{y_ax}_clt.{format}", scale=scale) + return fig + + +def box_plot_data(capri_df: pd.DataFrame, cl_rank: ClRank) -> pd.DataFrame: + """ + Retrieve box plot data. + + Parameters + ---------- + capri_df : pandas DataFrame + capri table dataframe + cl_rank : dict + {cluster_id : cluster_rank} dictionary + + Returns + ------- + gb_full : pandas DataFrame + DataFrame of all the clusters to be plotted + """ + gb_cluster = capri_df.groupby("cluster_id") + gb_other = pd.DataFrame([]) + gb_good = pd.DataFrame([]) + for cl_id, cl_df in gb_cluster: + if cl_id not in cl_rank.keys(): + gb_other = pd.concat([gb_other, cl_df]) + else: + cl_df["capri_rank"] = cl_rank[cl_id] # type: ignore + gb_good = pd.concat([gb_good, cl_df]) + + gb_other["cluster_id"] = "Other" + gb_other["capri_rank"] = len(cl_rank.keys()) + 1 + gb_other["cluster_ranking"] = "Other" + gb_full = pd.concat([gb_good, gb_other]) + + # Sort based on "capri_rank" + gb_full.sort_values(by=["capri_rank"], inplace=True) + return gb_full + + +def box_plot_handler( + capri_filename: FilePath, + cl_rank: ClRank, + format: Optional[ImgFormat], + scale: Optional[float], + offline: bool = False, + ) -> list[Figure]: + """Create box plots. + + The idea is that for each of the top X-ranked clusters we create a box plot + showing how the basic statistics are distributed within each model. + + Parameters + ---------- + capri_filename : str or Path + capri single structure filename + cl_rank : dict + {cluster_id : cluster_rank} dictionary + format : str + Produce images in the selected format. + scale : int + scale for images. + """ + # generating the correct dataframe + capri_df = read_capri_table(capri_filename, comment="#") + gb_full = box_plot_data(capri_df, cl_rank) + + # iterate over the variables + fig_list: list[Figure] = [] + for y_ax in AXIS_NAMES.keys(): + if not in_capri(y_ax, capri_df.columns): + continue + fig = box_plot_plotly( + gb_full, y_ax, cl_rank, format, scale, offline=offline, + ) + fig_list.append(fig) + return fig_list + + +def scatter_plot_plotly( + gb_cluster: DataFrameGroupBy, + gb_other: pd.DataFrame, + cl_rank: ClRank, + x_ax: str, + y_ax: str, + colors: list[str], + format: Optional[ImgFormat], + scale: Optional[float], + offline: bool = False, + ) -> Figure: + """Create a scatter plot in plotly. + + Parameters + ---------- + gb_cluster : pandas DataFrameGroupBy + capri DataFrame grouped by cluster_id + gb_other : pandas DataFrame + DataFrame of clusters not in the top cluster ranking + cl_rank : dict + {cluster_id : cluster_rank} dictionary + x_ax : str + name of the x column + y_ax : str + name of the y column + colors : list + list of colors to be used + format : str + Produce images in the selected format. + scale : int + scale for images. + + Returns + ------- + fig : + an instance of plotly.graph_objects.Figure + """ + + def _build_hover_text(df): + """Build a nice text for hover text.""" + text_list = [] + for _, row in df.iterrows(): + model_text = f"Model: {row['model'].split('/')[-1]}" + score_text = f"Score: {row['score']}" + caprieval_rank_text = f"Caprieval rank: {row['caprieval_rank']}" + text_list.append( + f"{model_text}
{score_text}" + f"
{caprieval_rank_text}" + ) + return text_list + + fig = go.Figure(layout={"width": 1000, "height": 800}) + traces: list[go.Scatter] = [] + n_colors = len(colors) + cl_rank_swap = {v: k for k, v in cl_rank.items()} + + for cl_rn in sorted(cl_rank_swap.keys()): + cl_id = cl_rank_swap[cl_rn] + cl_df = gb_cluster.get_group(cl_id) + if cl_id in cl_rank.keys(): + if cl_id == "-": + cl_name = "Unclustered" + else: + cl_name = f"Cluster {cl_rank[cl_id]}" # use rank + color_idx = (cl_rank[cl_id] - 1) % n_colors # color index + + traces.append( + go.Scatter( + x=cl_df[x_ax], + y=cl_df[y_ax], + name=cl_name, + mode="markers", + text=_build_hover_text(cl_df), + legendgroup=cl_name, + marker_color=colors[color_idx], + hoverlabel=dict( + bgcolor=colors[color_idx], + font_size=16, + font_family="Helvetica", + ), + ) + ) + clt_text = f"{cl_name}
" + + # mean and std deviations for the top 4 members + x_mean = np.mean(cl_df[x_ax].iloc[:4]) + y_mean = np.mean(cl_df[y_ax].iloc[:4]) + x_std = np.std(cl_df[x_ax].iloc[:4]) + y_std = np.std(cl_df[y_ax].iloc[:4]) + + if "score" not in [x_ax, y_ax]: + clt_text += f"Score: {np.mean(cl_df['score'].iloc[:4]):.3f}
" + clt_text += f"{x_ax}: {x_mean:.3f}
{y_ax}: {y_mean:.3f}" + + clt_text_list = [clt_text] + traces.append( + go.Scatter( + x=[x_mean], + y=[y_mean], + # error bars + error_x=dict( + type="data", array=[x_std], visible=True + ), + error_y=dict( + type="data", array=[y_std], visible=True + ), + # color and text + marker_color=colors[color_idx], + text=clt_text_list, + legendgroup=cl_name, + showlegend=False, + mode="markers", + marker=dict(size=10, symbol="square-dot"), + hovertemplate=f"{clt_text}", + hoverlabel=dict( + bgcolor=colors[color_idx], + font_size=16, + font_family="Helvetica", + ), + ) + ) + # append trace other + if not gb_other.empty: + traces.append( + go.Scatter( + x=gb_other[x_ax], + y=gb_other[y_ax], + name="Other", + mode="markers", + text=_build_hover_text(gb_other), + legendgroup="Other", + marker=dict( + color="white", + line=dict(width=2, color="DarkSlateGrey"), + ), + hoverlabel=dict( + bgcolor="white", + font_size=16, + font_family="Helvetica", + ), + ) + ) + for trace in traces: + fig.add_trace(trace) + px_fpath = Path(f"{x_ax}_{y_ax}.html") + update_layout_plotly( + fig, + TITLE_NAMES[x_ax], + TITLE_NAMES[y_ax], + title=f"{TITLE_NAMES[x_ax]} vs {TITLE_NAMES[y_ax]}", + ) + json_content = fig.to_json() + html_content = create_html( + json_content, + plotly_js_import=offline_js_manager(px_fpath, offline), + ) + # write html_content to px_fname + Path(px_fpath).write_text(html_content) + + # create format boxplot if necessary + if format: + fig.write_image(f"{x_ax}_{y_ax}.{format}", scale=scale) + return fig + + +def scatter_plot_data( + capri_df: pd.DataFrame, + cl_rank: ClRank, + ) -> tuple[DataFrameGroupBy, pd.DataFrame]: + """Retrieve scatter plot data. + + Parameters + ---------- + capri_df : pandas DataFrame + capri table dataframe + cl_rank : dict + {cluster_id : cluster_rank} dictionary + + Returns + ------- + gb_cluster : pandas DataFrameGroupBy + capri DataFrame grouped by cluster_id + gb_other : pandas DataFrame + DataFrame of clusters not in the top cluster ranking + """ + gb_cluster = capri_df.groupby("cluster_id") + gb_other = pd.DataFrame([]) + for cl_id, cl_df in gb_cluster: + if cl_id not in cl_rank.keys(): + gb_other = pd.concat([gb_other, cl_df]) + return gb_cluster, gb_other + + +def scatter_plot_handler( + capri_filename: FilePath, + cl_rank: ClRank, + format: Optional[ImgFormat], + scale: Optional[float], + offline: bool = False, + ) -> list[Figure]: + """Create scatter plots. + + The idea is that for each pair of variables of interest (SCATTER_PAIRS, + declared as global) we create a scatter plot. + If available, each scatter plot containts cluster information. + + Parameters + ---------- + capri_filename : str or Path + capri single structure filename + cl_rank : dict + {cluster_id : cluster_rank} dictionary + format : str + Produce images in the selected format. + scale : int + scale for images. + + Returns + ------- + fig_list : list + a list of figures + """ + capri_df = read_capri_table(capri_filename, comment="#") + gb_cluster, gb_other = scatter_plot_data(capri_df, cl_rank) + + # defining colors + colors = px_colors.qualitative.Dark24 + fig_list = [] + for x_ax, y_ax in SCATTER_PAIRS: + if not in_capri(x_ax, capri_df.columns): + continue + if not in_capri(y_ax, capri_df.columns): + continue + fig = scatter_plot_plotly( + gb_cluster, + gb_other, + cl_rank, + x_ax, + y_ax, + colors, + format, + scale, + offline=offline, + ) + fig_list.append(fig) + return fig_list + + +def _report_grid_size(plot_list: list[Figure]) -> tuple[int, int, int, int]: + """ + Calculate the size of the grid in the report. + + By size, it means the number of rows/columns, and the width/height + of an individual plot. In the report, some of the axes are shared. The + settings for sharing axes depends on the type (scatters or boxes). The + number of columns is set to the number of columns in SCATTER_MATRIX_SIZE. If + the number of clusters is more than 5, it increases the width which causes + horizontal scrolling in the report. + + Parameters + ---------- + plot_list : list + list of plots generated by analyse command + + Returns + ------- + number_of_rows : int + number of rows in the grid + number_of_cols : int + number of columns in the grid + width : int + the width of an individual plot + height: int + the height of an individual plot + """ + # Calculate grid size for subplots + number_of_plots = len(plot_list) + number_of_clusters = len({trace.legendgroup for trace in plot_list[0].data}) + # same number of cols for both boxes and scatters + number_of_cols = SCATTER_MATRIX_SIZE[1] + number_of_rows = int(np.ceil(number_of_plots / number_of_cols)) + # enable horizontal scroll + width = 600 if number_of_clusters > 5 else 350 + height = 600 if number_of_clusters > 5 else 350 + return number_of_rows, number_of_cols, width, height + + +def report_plots_handler(plots, shared_xaxes=False, shared_yaxes=False): + """ + Create a figure that holds subplots. + + The idea is that for each type (scatters or boxes), the individual plots are + considered subplots. In the report, some of the axes are shared. The + settings for sharing axes depends on the type (scatters or boxes). + + Parameters + ---------- + plots : list + list of plots generated by `analyse` command + shared_xaxes: boolean or str (default False) + a parameter of plotly.subplots.make_subplots + shared_yaxes: boolean or str (default False) + a parameter of plotly.subplots.make_subplots + + Returns + ------- + fig : + an instance of plotly.graph_objects.Figure + """ + number_of_rows, number_of_cols, width, height = _report_grid_size(plots) + fig = make_subplots( + rows=number_of_rows, + cols=number_of_cols, + shared_xaxes=shared_xaxes, + shared_yaxes=shared_yaxes, + vertical_spacing=(0.4 / number_of_rows), + horizontal_spacing=(0.3 / number_of_cols), + ) + for i, sub_fig in enumerate(plots): + col_index = int((i % number_of_cols) + 1) + row_index = int(np.floor(i / number_of_cols) + 1) + # hide legend of plots except one + if i != 0: + sub_fig.for_each_trace(lambda trace: trace.update(showlegend=False)) + fig.add_traces(sub_fig.data, rows=row_index, cols=col_index) + fig.update_yaxes( + title_text=sub_fig.layout.yaxis.title.text, + row=row_index, + col=col_index, + title_standoff=5, + automargin=True, + ) + # x title only on the last row + if shared_xaxes == "all": + row_index = number_of_rows + fig.update_xaxes( + title_text=sub_fig.layout.xaxis.title.text, + row=row_index, + col=col_index, + title_standoff=5, + automargin=True, + ) + legend_title_text = sub_fig.layout.legend.title.text + fig.update_layout( + legend_title_text=legend_title_text, + height=height * number_of_rows, + width=width * number_of_cols, + ) + return fig + + +def find_best_struct( + df: pd.DataFrame, + max_best_structs: int = 4, + ) -> pd.DataFrame: + """Find best structures for each cluster. + + Parameters + ---------- + df: pd.DataFrame + The loaded capri_ss.tsv dataframe + max_best_structs: int + The maximum number of best structures to return. + + Returns + ------- + best_df: pd.DataFrame + DataFrame of best structures with + `cluster_id` and `best` columns + and empty strings for missing values. + """ + df = df[["cluster_id", "model-cluster_ranking", "model"]] + df = df[df["model-cluster_ranking"] <= max_best_structs] + + best_df = df.pivot( + index="cluster_id", + columns="model-cluster_ranking", + values="model", + ) + + best_df = best_df.fillna('').reset_index() + best_df.columns = [ + f"best{col}" if col != "cluster_id" else col + for col in best_df.columns + ] + # Remove empty columns + best_df = best_df.loc[:, (best_df != '').any(axis=0)] + return best_df + + +def clean_capri_table(df: pd.DataFrame) -> pd.DataFrame: + """ + Create a tidy capri table for the report. + + It also combines mean and std values in one column. + Also it drops the columns that are not needed in the report. + + Makes inplace changes to the dataframe. + + Parameters + ---------- + df : pandas DataFrame + dataframe of capri values + + Returns + ------- + pandas DataFrame + DataFrame of capri table with new column names + """ + for col_name in AXIS_NAMES.keys(): + if not in_capri(col_name, df.columns): + continue + mean_value = df[col_name] + std_value = df[f"{col_name}_std"] + df[col_name] = [ + {'mean': mean_value, 'std': std_value} + for mean_value, std_value in zip(mean_value, std_value) + ] + + # Drop columns ending with '_std' + df = df.drop(df.filter(regex='_std$').columns, axis=1) + return df + + +def create_other_cluster( + clusters_df: pd.DataFrame, + structs_df: pd.DataFrame, + max_clusters: int, + ) -> tuple[pd.DataFrame, pd.DataFrame]: + """ + Combine all clusters with rank >= max_clusters into an "Other" cluster. + + Parameters + ---------- + clusters_df : pandas DataFrame + DataFrame of clusters + structs_df : pandas DataFrame + DataFrame of structures + max_clusters : int + From which cluster rank to consider as "Other" + + Returns + ------- + tuple with clusters_df and structs_df + """ + if len(clusters_df) <= max_clusters: + return clusters_df, structs_df + # other clusters + other_structs_df = structs_df[structs_df['cluster_ranking'] >= max_clusters].copy() + # drop other clusters from structs_df + structs_df = structs_df[structs_df['cluster_ranking'] < max_clusters].copy() + other_structs_df.loc[:,'cluster_id'] = 'Other' + other_structs_df.loc[:,'cluster_ranking'] = max_clusters + inner_rank = other_structs_df['caprieval_rank'].rank(method='first').astype(int) # noqa : E501 + other_structs_df['model-cluster_ranking'] = inner_rank + structs_df = pd.concat([structs_df, other_structs_df]) + + clusters_df = clusters_df[clusters_df['cluster_rank'] < max_clusters] + other_cluster = { + 'cluster_id': 'Other', + 'cluster_rank': max_clusters, + 'n': len(other_structs_df), + 'caprieval_rank': max_clusters, + } + for col in AXIS_NAMES.keys(): + if any([ + col not in other_structs_df.columns, + col not in clusters_df.columns, + ]): + continue + other_cluster[col] = other_structs_df[col].mean() + other_cluster[col + '_std'] = other_structs_df[col].std() + other_cluster_df = pd.DataFrame([other_cluster]) + clusters_df = pd.concat([clusters_df, other_cluster_df], ignore_index=True).round(2) + return clusters_df, structs_df + + +def clt_table_handler( + clt_file: FilePath, + ss_file: FilePath, + is_cleaned: bool = False, + topX_clusters: int = 10, + clustered_topX: int = 4, + unclustered_topX: int = 10, + top_ranked_mapping: Optional[dict[Path, Path]] = None, + ) -> pd.DataFrame: + """ + Create a dataframe including data for tables. + + The idea is to create tidy tables that report statistics available in + capri_clt.tsv and capri_ss.tsv files. + + Parameters + ---------- + clt_file : str or Path + path to capri_clt.tsv file + ss_file: str or Path + path to capri_ss.tsv file + is_cleaned: bool + is the run going to be cleaned? + + Returns + ------- + df_merged : pandas DataFrame + a data frame including data for tables + """ + # table of statistics + clusters_df = read_capri_table(clt_file) + structs_df = read_capri_table(ss_file) + + # Round all numbers to 2 decimal places + clusters_df = clusters_df.round(2) + structs_df = structs_df.round(2) + + # if the run will be cleaned, the structures are going to be gzipped + if not top_ranked_mapping: + if is_cleaned: + # substitute the values in the df by adding .gz at the end + structs_df['model'] = structs_df['model'].replace( + to_replace=r"(\.pdb)$", value=r".pdb.gz", regex=True, + ) + else: + # ss_file is in NN_caprieval/ while report is in + # analysis/NN_caprieval_analysis/ + # need to correct model paths by prepending ../ + def correct_relative_paths( + path: str, + top_ranked_mapping: Optional[dict[Path, Path]], + ) -> str: + """Prepend model paths in capri_ss files get their relative paths. + + Parameters + ---------- + path : str + Original path to a model file. + top_ranked_mapping : Optional[dict[Path, Path]] + Optional filepath mapping of top ranked models. + + Returns + ------- + new_path : str + New path to the file + """ + try: + # If top ranked is provided, use that information + new_path = top_ranked_mapping[path] + except (KeyError, TypeError, ): + # Otherwise just prepend by `../` + new_path = f"../{path}" + return new_path + + structs_df['model'] = structs_df['model'].apply( + lambda x: correct_relative_paths(x, top_ranked_mapping) + ) + + is_unclustered = clusters_df["cluster_rank"].unique().tolist() == ["-"] + # If unclustered, we only want to show the top 10 structures in a table. + if is_unclustered: + structs_df = structs_df[:unclustered_topX] + cols2keep = ['caprieval_rank', 'model'] + list(AXIS_NAMES.keys()) + structs_df = structs_df[cols2keep] + # model has ../../01_rigidbody/rigidbody_62.pdb.gz + # add id column with 62 as value + structs_df['id'] = structs_df['model'].str.extract(r'(\d+).pdb') + return structs_df + + clusters_df, structs_df = create_other_cluster( + clusters_df, + structs_df, + max_clusters=topX_clusters + 1, + ) + + clusters_df = clean_capri_table(clusters_df) + structs_df = find_best_struct(structs_df, max_best_structs=clustered_topX) + df_merged = pd.merge(clusters_df, structs_df, on="cluster_id") + return df_merged + + +def _css_styles_for_report(offline: bool) -> str: + """ + Generate custom CSS styles for an analysis report. + + Parameters + ---------- + offline : bool + If True, the HTML will be generated for offline use. + + Returns + ------- + The CSS styles as a string. + """ + custom_css = """ + .title { + font-family: Arial, sans-serif; + font-size: 32px; + font-weight: bold; + } + body { + margin-left: 1em; + } + table { + border-collapse: collapse; + } + th { + background-color: #f2f2f2; + padding: 8px; + border: 1px solid #ddd; + text-align: left; + } + th[scope="row"] { + position: sticky; + min-width: 16rem; + left: 0; + z-index: 1 + } + td { + border: 1px solid #ddd; + padding: 8px; + text-align: left; + } + tr:nth-child(even) { + background-color: #f2f2f2 + } + .js-plotly-plot .plotly .modebar svg { + display: inline; + } + """ + css_link = "https://cdn.jsdelivr.net/npm/@i-vresse/haddock3-ui@~0.3.0/dist/index.css" + if offline: + # copy the css file to the report directory + src = haddock_ui_path / 'index.css' + shutil.copyfile(str(src), "../data/ui/index.css") + css_link = "../../data/ui/index.css" + table_css = f' ' + return f"{table_css}" + + +def _generate_html_report( + step: str, + figures: list[Union[Figure, pd.DataFrame]], + report_path: FilePath, + offline: bool = False, + ) -> str: + """ + Generate an HTML report for a specific step of analysis, including figures. + + Parameters + ---------- + step : str + The step number. + figures : list + A list of figures to include in the HTML body. + Each figure can be either a string representing a table or a + plotly.graph_objects.Figure object. + offline : bool + If True, the HTML will be generated for offline use. + + Returns + ------- + html_report : str + The generated HTML report as a string. + """ + html_report = "" + html_report += _generate_html_head(step, offline) + html_report += _generate_html_body(figures, report_path, offline=offline) + html_report += "" + return html_report + + +def _generate_html_head(step, offline): + """ + Generate the HTML head section for an analysis report. + + Parameters + ---------- + step : str + The step number. + offline : bool + If True, the HTML will be generated for offline use. + + Returns + ------- + head : str + The HTML head section as a string. + """ + head = "" + head += f"Analysis report of step {step}" + head += f"

Analysis report of step {step}

" + head += _css_styles_for_report(offline) + head += "" + return head + + +def _generate_unclustered_table_html( + table_id: str, + df: pd.DataFrame, + bundle_url: str, + ) -> str: + data = df.to_json(orient='records') + headers = [ + {'key': "caprieval_rank", 'label': "Structure Rank", 'sorted': "asc"}, + {'key': "model", 'label': "Structure", + 'sortable': False, 'type': "structure" + }, + ] + [ + {'key': k, 'label': v, 'type': 'stats'} + for k, v in AXIS_NAMES.items() + if k in df.columns + ] + [ + {'key': "id", 'label': "Structure ID"}, + ] + return f""" +
+ + """ # noqa : E501 + + +def _generate_clustered_table_html( + table_id: str, + df: pd.DataFrame, + bundle_url: str, + ) -> str: + data = df.to_json(orient='records') + nr_best_columns = df.filter(like="best").shape[1] + headers = [ + {'key': "cluster_rank", 'label': "Cluster Rank", 'sorted': "asc"}, + {'key': "cluster_id", 'label': "Cluster ID"}, + {'key': "n", 'label': "Cluster size"}, + ] + [ + {'key': k, 'label': v, 'type': 'stats'} + for k, v in AXIS_NAMES.items() + if k in df.columns + ] + [ + {'key': f"best{i}", 'label': f"Nr {i} best structure", + 'sortable': False, 'type': "structure" + } + for i in range(1, nr_best_columns + 1) + ] + + caption = '' + if df['cluster_id'].isin(['Other']).any(): + caption = ( + 'The "Other" cluster is not a real cluster it contains' + 'all structures that are not in the top 10 clusters.' + ) + + return f""" +
+
{caption}
+ + """ # noqa : E501 + + +def _generate_html_body( + figures: list[Union[Figure, pd.DataFrame]], + report_path: FilePath, + offline: bool = False, + ) -> str: + """ + Generate an HTML body section containing figures for an analysis report. + + Parameters + ---------- + figures : list + A list of figures to include in the HTML body. + Each figure can be either a string representing a table or a + plotly.graph_objects.Figure object. + offline : bool + If True, the HTML will be generated for offline use. + + Returns + ------- + body : str + The generated HTML body as a string. + """ + body = "" + table_index: int = 1 + fig_index: int = 1 + for figure in figures: + if isinstance(figure, pd.DataFrame): # tables + table_index += 1 + table_id = f"table{table_index}" + + is_unclustered = 'cluster_rank' not in figure + bundle_url = "https://cdn.jsdelivr.net/npm/@i-vresse/haddock3-ui@~0.3.0/dist/report.bundle.js" + if offline: + # copy the bundle to the run_dir folder + src = haddock_ui_path / 'report.bundle.js' + shutil.copyfile(str(src), "../data/ui/report.bundle.js") + bundle_url = "../../data/ui/report.bundle.js" + if is_unclustered: + inner_html = _generate_unclustered_table_html(table_id, figure, bundle_url) + else: + inner_html = _generate_clustered_table_html(table_id, figure, bundle_url) + else: # plots + inner_json = figure.to_json() + inner_html = create_html( + inner_json, + fig_index, + plotly_js_import=offline_js_manager(report_path, offline), + figure_height=figure.layout.height, + figure_width=figure.layout.width, + ) + fig_index += 1 # type: ignore + body += "
" # add a break between tables and plots + body += inner_html + body += "" + return body + + +def report_generator( + boxes: list[Figure], + scatters: list[Figure], + tables: list, + step: str, + directory: FilePath = ".", + offline: bool = False + ) -> None: + """ + Create a figure include plots and tables. + + The idea is to create a report.html file that includes all the plots and + tables generated by the command `analyse`. + + Parameters + ---------- + boxes : list + list of box plots generated by box_plot_handler + scatters: list + list of scatter plots generated by scatter_plot_handler + table: list + a list including tables generated by clt_table_handler + directory : Path + path to the output folder + offline: bool + If True, the HTML will be generated for offline use. + """ + figures = [tables] + # Combine scatters + figures.append( + report_plots_handler( + scatters, + shared_xaxes="rows", + shared_yaxes="columns", + ) + ) + # Combine boxes" + figures.append(report_plots_handler(boxes)) + + if offline: + Path('../data/ui').mkdir(parents=True, exist_ok=True) + # Write everything to a html file + report_path = Path(directory, "report.html") + html_report = _generate_html_report(step, figures, report_path, offline) + with open(report_path, "w", encoding="utf-8") as report: + report.write(html_report) + + +def heatmap_plotly( + matrix: NDFloat, + labels: Optional[dict] = None, + xlabels: Optional[list] = None, + ylabels: Optional[list] = None, + color_scale: str = 'Greys_r', + title: Optional[str] = None, + output_fname: Path = HEATMAP_DEFAULT_PATH, + offline: bool = False, + hovertemplate: Optional[str] = None, + customdata: Optional[list[list[Any]]] = None, + delineation_traces: Optional[list[dict[str, float]]] = None, + ) -> Path: + """Generate a `plotly heatmap` based on matrix content. + + Parameters + ---------- + matrix : NDFloat + The 2D matrix containing data to be shown. + labels : dict + Labels of the horizontal (x), vertical (y) and colorscale (color) axis. + xlabels : list + List of columns names. + ylabels : list + List of row names. + color_scale : str + Color scale to use. + title : str + Title of the figure. + output_fname : Path + Path to the output filename to generate. + hovertemplate: Optional[str] + Custrom string used to format data for hover annotation in plotly. + customdata: Optional[list[list[list[int]]]] + A matrix of cluster ids, used for extra hover annotation in plotly. + delineation_traces: Optional[list[dict[str, float]]] + A list of dict enabling to draw lines separating cluster ids. + + Return + ------ + output_fname : Path + Path to the generated filename + """ + # Generate heatmap trace + fig = px.imshow( + matrix, + labels=labels, + x=xlabels, + y=ylabels, + color_continuous_scale=color_scale, + title=title, + ) + # Place X axis on top + fig.update_xaxes(side="top") + fig.update_traces( + hovertemplate=hovertemplate, + customdata=customdata, + ) + # Add delineation traces + if delineation_traces: + # Loop over lines + for trace in delineation_traces: + # Draw them + fig.add_shape( + type="line", + line={"dash": "5px"}, + x0=trace["x0"], + x1=trace["x1"], + y0=trace["y0"], + y1=trace["y1"], + ) + + # Compute pixels + nb_entries = matrix.shape[0] + scaled_log = int(np.log(nb_entries)) * 200 + lower_bound = max(scaled_log, 1000) + uppder_bound = min(lower_bound, 2000) + # Set hight and width + height = uppder_bound + # Increment width for legend space + width = height + 70 + + # Save figure as html file + export_plotly_figure( + fig, + output_fname, + offline=offline, + figure_height=height, + figure_width=width, + ) + + return output_fname + + +def export_plotly_figure( + fig: Figure, + output_fname: Union[str, Path], + figure_height: int = 1000, + figure_width: int = 1000, + offline: bool = False, + ) -> None: + """Write a plotly figure. + + Parameters + ---------- + fig : Figure + The plotly Figure object + output_fname : Union[str, Path] + Where to write it + figure_height : int, optional + Height of the figure (in pixels), by default 1000 + figure_width : int, optional + Width of the figure (in pixels), by default 1000 + offline : bool, optional + If True add the plotly js library to the file, by default False + """ + # Detect output file extension + _suffix = Path(output_fname).suffix + suffix = _suffix[1:] + # Check corresponding function + if suffix == "html": + fig_to_html( + fig, + output_fname, + figure_height=figure_height, + figure_width=figure_width, + offline=offline, + ) + elif suffix in SUPPORTED_OUTPUT_FORMATS: + fig.write_image(output_fname) + + +def make_alascan_plot( + df: pd.DataFrame, + clt_id: int, + scan_res: str = "ALA", + offline: bool = False, + ) -> str: + """ + Make a plotly interactive plot. + + Score components are here **weighted** by their respective + contribution to the total score. + + Parameters + ---------- + df : pandas.DataFrame + DataFrame containing the results of the alanine scan. + clt_id : int + Cluster ID. + scan_res : str, optional + Residue name used for the scan, by default "ALA" + + Returns + ------- + html_output_filename : str + Name of the plot generated + """ + plot_name = f"scan_clt_{clt_id}" + log.info(f"Generating {scan_res} scanning plot {plot_name}") + + # create figure + width, height = 2000, 1000 + fig = go.Figure(layout={"width": width, "height": height}) + # add traces + # Delta HADDOCK score + fig.add_trace( + go.Bar( + x=df["full_resname"], + y=df["delta_score"], + error_y={"type": "data", "array": df["delta_score_std"]}, + name="delta_score", + ) + ) + # Delta VdW + fig.add_trace( + go.Bar( + x=df["full_resname"], + y=df["delta_vdw"], + error_y={"type": "data", "array": df["delta_vdw_std"]}, + name="delta_vdw", + ) + ) + # delta_elec is given its weight in the emscoring module + fig.add_trace( + go.Bar( + x=df["full_resname"], + y=0.2 * df["delta_elec"], + error_y={"type": "data", "array": df["delta_elec_std"]}, + name="delta_elec", + ) + ) + # Delta desolvation score + fig.add_trace( + go.Bar( + x=df["full_resname"], + y=df["delta_desolv"], + error_y={"type": "data", "array": df["delta_desolv_std"]}, + name="delta_desolv", + ) + ) + # prettifying layout + fig.update_layout( + title=f"{scan_res} scanning cluster {clt_id}", + xaxis={ + "title": {"text": "Residue Name", "font": {"size": 16}}, + "tickfont_size": 14, + "tick0": df["full_resname"], + # in case we want to show less residues + # "dtick": 10, + }, + yaxis={ + "title": { + "text": "Average Delta (WT - mutant)", + "font": {"size": 16} + }, + "tickfont_size": 14, + }, + legend={ + "x": 1.01, "y": 1.0, + "font_family": "Helvetica", + "font_size": 16 + }, + barmode="group", + bargap=0.05, + bargroupgap=0.05, + hovermode="x unified", + hoverlabel={"font_size": 16, "font_family": "Helvetica"}, + ) + for n in range(df.shape[0] - 1): + fig.add_vline(x=0.5 + n, line_color="gray", opacity=0.2) + + # save html + html_output_filename = f"{plot_name}.html" + export_plotly_figure( + fig, + html_output_filename, + figure_height=height, + figure_width=width, + offline=offline, + ) + return html_output_filename + + +def fig_to_html( + fig: Figure, + fpath: Union[str, Path], + plot_id: int = 1, + figure_height: int = 800, + figure_width: int = 1000, + offline: bool = False, + ) -> None: + """Workaround plotly html file generation. + + Parameters + ---------- + fig : Figure + A Figure object created by Plotly + fpath : Union[str, Path] + Where to write the content + json_content : str + plotly json content + plot_id : int + plot id to be used in the html content + figure_height : int + figure height (in pixels) + figure_width : int + figure width (in pixels) + offline : bool + If set to False, use the cdn url to obtain the javascript content + for the rendering. + """ + # Convert to json + json_content = fig.to_json() + # Create custom html file + html_content = create_html( + json_content, + plot_id=plot_id, + plotly_js_import=offline_js_manager(fpath, offline), + figure_height=figure_height, + figure_width=figure_width, + ) + # Write it + Path(fpath).write_text(html_content) + + +def offline_js_manager(fpath: FilePath, offline: bool) -> str: + """Build string to access plotly javascript content. + + Parameters + ---------- + fpath : FilePath + Path to the figure about to be written. + offline : bool + if True use the offline approach. + + Returns + ------- + plotly_js_import : str + HTML solution for the importation of the plotly javascript content. + """ + # Case when offline is true + if offline: + # Obtain directory where the figure should be written + fig_dir = Path(fpath).parent + # Set plotly js filepath + plotly_js_fpath = Path(fig_dir, "plotly_bundle.js") + # Check that this file do not already exists + if not plotly_js_fpath.exists(): + # Write the plotly java script content + plotly_js_fpath.write_text(get_plotlyjs()) + # Build HTML string + plotly_js_import = f'' + else: + # Use CDN url to obtain the script + plotly_js_import = f'' + return plotly_js_import + + +def make_traceback_plot(tr_subset, plot_filename, offline=False): + """ + Create a traceback barplot with the 40 best ranked models. + + Parameters + ---------- + tr_subset : pandas.DataFrame + DataFrame containing the top traceback results + plot_filename : Path + Path to the output filename to generate + """ + rank_columns = tr_subset.columns[tr_subset.columns.str.endswith("rank")] + # for each row, plot a bar with the values of the rank columns + fig = px.bar(tr_subset, x="Model", y=rank_columns) + # vertical legend on the right with legend name 'Modules' + fig.update_layout(legend_orientation="v", legend_title="Modules") + # legend should have bigger font size + fig.update_layout( + legend=dict( + title_font_size=24, + font_size=24, + ), + ) + # y axis title 'Sum of Ranks' + fig.update_layout(yaxis_title="Sum of Ranks", xaxis_title="Models") + # bigger axis labels + fig.update_layout( + yaxis=dict(title_font_size=30, tickfont_size=16), + xaxis=dict(title_font_size=30, tickfont_size=16), + ) + # bigger title + fig.update_layout( + title_text=f"Top ranked {tr_subset.shape[0]} Models", + title_font_size=30 + ) + fig_to_html( + fig, + plot_filename, + figure_height=1200, + figure_width=2000, + offline=offline, + ) + return plot_filename diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libprodigy.py b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libprodigy.py new file mode 100644 index 0000000000000000000000000000000000000000..95d8e2756f46980c0fe5b719630fa9894c6d8817 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libprodigy.py @@ -0,0 +1,176 @@ +"""Set of functionalities to run prodigy.""" + +import logging +from abc import ABC, abstractmethod + +import numpy as np + +from haddock import log +from haddock.core.exceptions import ModuleError +from haddock.core.typing import FilePath, Optional, ParamDict +from haddock.libs.libontology import PDBFile + + +# Define conversion constants +R_GAS_CONST = 8.31446261815324 # (J x mol−1 x K−1) +CALS_TO_JOULES = 4.184 +KELVIN_TO_CELCIUS = 273.15 + + +class CheckInstall: + """Verify that installation of prodigy is ok.""" + + def __init__(self): + """Verify that installation of prodigy is ok. + + Raises + ------ + ModuleError + Raised when prodigy libraries could not be loaded. + """ + try: + self.import_prodigy_libs() + except ModuleNotFoundError: + raise ModuleError( + "Issue detected with the installation of Prodigy. " + "Consider installing it with: " + "pip install prodigy-prot prodigy-lig" + ) + + @staticmethod + def import_prodigy_libs() -> None: + """Import prodigy prot and lig libraries.""" + import prodigy_prot # noqa : F401 + import prodigy_lig # noqa : F401 + return None + + +class ProdigyWorker(ABC): + """Prodigy Worker class.""" + + def __init__(self, model: FilePath, params: ParamDict) -> None: + # Use by both prodigy -prot and -lig + self.model = model + self.topKd = params["to_pkd"] + self.temperature = params["temperature"] + self.dist_cutoff = params["distance_cutoff"] + # Output values + self.score: Optional[float] = None + self.error: Optional[Exception] = None + + def _run(self) -> None: + """Evaluate complex and compute score.""" + # Patching the logging to not print everything on screen + logging.getLogger("Prodigy").setLevel(logging.CRITICAL) + # Running the predictions + self.score = self.pkd_converter(self.evaluate_complex()) + + def run(self) -> None: + """Execute the _run method.""" + try: + self._run() + except ModuleError as error: + self.error = error + + def pkd_converter(self, deltaG: float) -> float: + """Decide if deltaG must be converted to pKd. + + Parameters + ---------- + deltaG : float + Input DeltaG value + + Returns + ------- + score : float + The converted DeltaG to pKd if self.topKd is true, + else the input DeltaG. + """ + if self.topKd: + score = self.deltaG_to_pKd( + deltaG, + kelvins=self.temperature + KELVIN_TO_CELCIUS, + ) + else: + score = deltaG + return round(score, 3) + + @staticmethod + def deltaG_to_pKd(deltaG: float, kelvins: float = 298.3) -> float: + """Convert a deltaG (in Kcal/mol) to pKd. + + Parameters + ---------- + deltaG : float + DeltaG value (in Kcal/mol) + kelvins : float, optional + Temperature at which to perform the conversion. + By default 298.3 (25 degrees Celcius) + + Returns + ------- + pKd : float + The corresponding pKd value at given temperature. + """ + # Convert Kcals to joules + deltaG_joules = deltaG * CALS_TO_JOULES * 1000 + # Use formula + Kd = np.exp(-deltaG_joules / (R_GAS_CONST * kelvins)) + # Convert to pKd + _pKd = np.log10(Kd) + # Reduce number of decimals + pKd = round(_pKd, 2) + return -pKd + + @abstractmethod + def evaluate_complex(self) -> float: + """Logic to evaluate a complex using prodigy.""" + pass + + +class ModelScore: + """Simple class for holding score for a model.""" + + def __init__(self, model_index: int) -> None: + """Initiate models scores.""" + self.index = model_index + self.score = None + self.error = None + + +class ProdigyBaseJob(ABC): + """Managing the computation of prodigy scores within haddock3.""" + + def __init__( + self, + model: PDBFile, + params: ParamDict, + index: int = 1, + ) -> None: + """Initiate a worker.""" + self.score = ModelScore(index) + worker = self.get_worker() + self.worker = worker(model.rel_path, params) + + def _run(self) -> ModelScore: + """Run the worker and retrieve output values.""" + try: + self.worker.run() + except Exception as e: + log.error(e) + self.worker.error = str(e) + self.score.error = str(e) + else: + self.score.score = self.worker.score + self.score.error = self.worker.error + return self.score + + def run(self) -> ModelScore: + """Execute the _run method.""" + return self._run() + + @staticmethod + @abstractmethod + def get_worker() -> object: + """Return the appropriate worker.""" + pass diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/libs/librestraints.py b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/librestraints.py new file mode 100644 index 0000000000000000000000000000000000000000..20cc6ef0f0b774266ea111bb84dd29e004849536 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/librestraints.py @@ -0,0 +1,856 @@ +from pathlib import Path +import logging +import itertools +import re +import random +import sys +import os +from typing import Generator + +from Bio.PDB import PDBParser, NeighborSearch +from freesasa import Classifier, structureFromBioPDB, calc + +# Scaling factors for relative ASA +# Calculated using extended ALA-X-ALA peptides +# Taken from NACCESS +REL_ASA = { + 'total': + { + 'ALA': 107.95, + 'CYS': 134.28, + 'ASP': 140.39, + 'GLU': 172.25, + 'PHE': 199.48, + 'GLY': 80.10, + 'HIS': 182.88, + 'ILE': 175.12, + 'LYS': 200.81, + 'LEU': 178.63, + 'MET': 194.15, + 'ASN': 143.94, + 'PRO': 136.13, + 'GLN': 178.50, + 'ARG': 238.76, + 'SER': 116.50, + 'THR': 139.27, + 'VAL': 151.44, + 'TRP': 249.36, + 'TYR': 212.76, + 'ASH': 140.39, + 'DDZ': 107.95, + 'GLH': 172.25, + 'CYM': 134.28, + 'CSP': 134.28, + 'CYF': 134.28, + 'CYC': 134.28, + 'CFE': 134.28, + 'NEP': 182.88, + 'ALY': 200.81, + 'MLZ': 200.81, + 'MLY': 200.81, + 'M3L': 200.81, + 'HYP': 136.13, + 'SEP': 116.50, + 'TOP': 139.27, + 'TYP': 212.76, + 'PTR': 212.76, + 'TYS': 212.76, + 'PNS': 116.50, + }, + 'bb': + { + 'ALA': 38.54, + 'CYS': 37.53, + 'ASP': 37.70, + 'GLU': 37.51, + 'PHE': 35.37, + 'GLY': 47.77, + 'HIS': 35.80, + 'ILE': 37.16, + 'LYS': 37.51, + 'LEU': 37.51, + 'MET': 37.51, + 'ASN': 37.70, + 'PRO': 16.23, + 'GLN': 37.51, + 'ARG': 37.51, + 'SER': 38.40, + 'THR': 37.57, + 'VAL': 37.16, + 'TRP': 38.10, + 'TYR': 35.38, + 'ASH': 37.70, + 'DDZ': 38.54, + 'GLH': 37.51, + 'CYM': 37.53, + 'CYC': 37.53, + 'CSP': 37.53, + 'CYF': 37.53, + 'CFE': 37.53, + 'NEP': 35.80, + 'ALY': 37.51, + 'MLZ': 37.51, + 'MLY': 37.51, + 'M3L': 37.51, + 'HYP': 16.23, + 'SEP': 38.40, + 'TOP': 37.57, + 'TYP': 35.38, + 'PTR': 35.38, + 'TYS': 35.38, + 'PNS': 38.40, + }, + 'sc': + { + 'ALA': 69.41, + 'CYS': 96.75, + 'ASP': 102.69, + 'GLU': 134.74, + 'PHE': 164.11, + 'GLY': 32.33, + 'HIS': 147.08, + 'ILE': 137.96, + 'LYS': 163.30, + 'LEU': 141.12, + 'MET': 156.64, + 'ASN': 106.24, + 'PRO': 119.90, + 'GLN': 140.99, + 'ARG': 201.25, + 'SER': 78.11, + 'THR': 101.70, + 'VAL': 114.28, + 'TRP': 211.26, + 'TYR': 177.38, + 'ASH': 102.69, + 'DDZ': 69.41, + 'GLH': 134.74, + 'CYM': 96.75, + 'CYC': 96.75, + 'CSP': 96.75, + 'CYF': 96.75, + 'CFE': 96.75, + 'NEP': 147.08, + 'ALY': 163.30, + 'MLZ': 163.30, + 'MLY': 163.30, + 'M3L': 163.30, + 'HYP': 119.90, + 'SEP': 78.11, + 'TOP': 101.70, + 'TYP': 177.38, + 'PTR': 177.38, + 'TYS': 177.38, + 'PNS': 78.11, + } + } +DEFAULT_PROBE_RADIUS = 1.4 + +def get_surface_resids(structure, cutoff=15): + """ + Calls freesasa using its Python API and returns + per-residue accessibilities. + """ + asa_data, rsa_data, rel_main_chain, rel_side_chain = {}, {}, {}, {} + _rsa = REL_ASA['total'] + _rsa_bb = REL_ASA['bb'] + _rsa_sc = REL_ASA['sc'] + + #classifier = Classifier(config_path) + classifier = Classifier() + + struct = structureFromBioPDB(structure, classifier, ) + result = calc(struct) + + # iterate over all atoms to get SASA and residue name + for idx in range(struct.nAtoms()): + atname = struct.atomName(idx).strip() + resname = struct.residueName(idx) + resid = int(struct.residueNumber(idx)) + chain = struct.chainLabel(idx) + at_uid = (chain, resname, resid, atname) + res_uid = (chain, resname, resid) + + asa = result.atomArea(idx) + asa_data[at_uid] = asa + # add asa to residue + rsa_data[res_uid] = rsa_data.get(res_uid, 0) + asa + + if atname in ('C', 'N', 'O'): + rel_main_chain[res_uid] = rel_main_chain.get(res_uid, 0) + asa + else: + rel_side_chain[res_uid] = rel_side_chain.get(res_uid, 0) + asa + + # convert total asa ro relative asa + rsa_data.update((res_uid, asa / _rsa[res_uid[1]]) for res_uid, asa in rsa_data.items()) + rel_main_chain.update((res_uid, asa / _rsa_bb[res_uid[1]] * 100) for res_uid, asa in rel_main_chain.items()) + rel_side_chain.update((res_uid, asa / _rsa_sc[res_uid[1]] * 100) for res_uid, asa in rel_side_chain.items()) + + # We format to fit the pipeline + resid_access = {} + for res_uid, access in rel_main_chain.items(): + resid_access[res_uid[2]] = {'side_chain_rel': rel_side_chain.get(res_uid), 'main_chain_rel': access} + surface_resids = [r for r, v in resid_access.items() if v['side_chain_rel'] >= cutoff or + v['main_chain_rel'] >= cutoff] + return surface_resids + + +def parse_actpass_file(actpass_file): + """Parse actpass file + + Parameters + ---------- + actpass_file: str or Path + path to actpass_file + + Returns + ------- + active: list + list of active residues + passive: list + list of passive residues + """ + + if Path(actpass_file).exists() is False: + raise Exception(f"actpass file {actpass_file} does not exist.") + + lines = open(actpass_file, "r").readlines() + nlines = len(lines) + if nlines != 2: + raise Exception(f"actpass file {actpass_file} does not have two lines (counted {nlines})") + active, passive = [[int(x) for x in line.split()] for line in lines] + return active, passive + + +def active_passive_to_ambig(active1, passive1, active2, passive2, segid1='A', segid2='B'): + """Convert active and passive residues to Ambiguous Interaction Restraints + + Parameters + ---------- + active1 : list + List of active residue numbers of the first segid + + passive1 : list + List of passive residue numbers of the first segid + + passive2 : list + List of passive residue numbers of the second segid + + active2 : list + List of active residue numbers of the second segid + + active2 : list + List of passive residue numbers of the second segid + + segid1 : string + Segid to use for the first model + + segid2 : string + Segid to use for the second model + + """ + + all1 = active1 + passive1 + all2 = active2 + passive2 + + for resi1 in active1: + print('assign (resi {:d} and segid {:s})'.format(resi1, segid1)) + print('(') + c = 0 + for resi2 in all2: + print(' (resi {:d} and segid {:s})'.format(resi2, segid2)) + c += 1 + if c != len(all2): + print(' or') + + print(') 2.0 2.0 0.0\n') + + for resi2 in active2: + print('assign (resi {:d} and segid {:s})'.format(resi2, segid2)) + print('(') + c = 0 + for resi1 in all1: + print(' (resi {:d} and segid {:s})'.format(resi1, segid1)) + c += 1 + if c != len(all1): + print(' or') + + print(') 2.0 2.0 0.0\n') + + +# Functions/Methods + +def calc_euclidean(i, j): + return ((j[0]-i[0])**2 + (j[1]-i[1])**2 + (j[2]-i[2])**2)**0.5 + + +def read_structure(pdbf, exclude=None): + """ + Reads a PDB file and returns a list of parsed atoms + """ + _atoms = {'CA', 'P'} # Alpha-Carbon (Prot), Backbone Phosphorous (DNA) + _altloc = {' ', 'A'} + + if not exclude: + exclude = set() + else: + exclude = set(exclude) + + res_list = [] + with open(pdbf, 'r') as pdb_handle: + for line in pdb_handle: + field = line[0:4] + if field != 'ATOM': + continue + + aname = line[12:16].strip() + chain = line[21] if line[21].strip() else line[72:76].strip() # chain ID or segID + if chain not in exclude and aname in _atoms and line[16] in _altloc: + resi = int(line[22:26]) + coords = (float(line[30:38]), float(line[38:46]), float(line[46:54])) + res_list.append((chain, resi, aname, coords)) + + if not res_list: + logging.critical('[!] PDB File seems empty or no CA/P atoms found: {0}'.format(pdbf)) + sys.exit(1) + + return res_list + + +def get_bodies(atom_lst, prot_threshold=4.0, dna_threshold=7.5): + """ + Determines gaps in an atom list following simple distance based criteria. + Returns continuous fragments. + """ + + bodies = [] + + threshold = {'CA': prot_threshold, 'P': dna_threshold} + + body_start = 0 + i = None + for i, atom in enumerate(atom_lst[1:], start=1): + p_atom = atom_lst[i-1] + + chain, resi, aname, xyz = atom + p_chain, p_resi, p_aname, p_xyz = p_atom + + if (chain == p_chain) and (aname == p_aname): # Internal Gap + d_xyz = calc_euclidean(xyz, p_xyz) + if d_xyz >= threshold[aname]: + logging.debug('[+++] (Internal) Body: {0}:{1}'.format(body_start, i-1)) + bodies.append((body_start, i-1)) + body_start = i # Set new beginning + + elif (chain != p_chain) or (aname != p_aname): # Different molecules/types + logging.debug('[+++] Body: {0}:{1}'.format(body_start, i-1)) + bodies.append((body_start, i-1)) + body_start = i # Set new beginning + + if not bodies: # Single continuous molecule + bodies.append((0, len(atom_lst))) + else: + logging.debug('[+++] Body: {0}:{1}'.format(body_start, i)) + bodies.append((body_start, i)) # Last body + + logging.info('[++] Found {0} bodies'.format(len(bodies))) + + return bodies + + +def build_restraints(bodies): + """ + Generates distance restraints to maintain the relative + orientation of the different bodies during the simulations. + + Generates two unique restraints per pair of bodies. + + Each restraint is created using two random atoms on each body + and using their exact euclidean distance as target distance. + """ + + def pick_residues(body, max_trials=10): + # Pick two random residues in each body + # Make sure they are far apart from each other + n_trials = 0 + while 1: + try: + res_i, res_ii = random.sample(body, 2) + except ValueError: + # Likely, sample size is 1 + logging.warning('[!] One-sized body found. This may lead to problems..') + return body[0], body[0] + + logging.debug('[+++] Trial {0}: {1} & {2}'.format(n_trials, res_i, res_ii)) + if abs(res_i - res_ii) > 3: + logging.info('[++] Picked residues {0} & {1}'.format(res_i, res_ii)) + return res_i, res_ii + n_trials += 1 + if n_trials == max_trials: + msg = '[!] Could not pick two unique distant residues in body after {0} tries' + logging.info(msg.format(max_trials)) + return res_i, res_ii + + restraints = [] + + n_bodies = range(len(bodies)) + combinations = itertools.combinations(n_bodies, 2) + + for pair_bodies in combinations: + body_i, body_j = pair_bodies + logging.debug('[+++] Restraining body {0} to body {1}'.format(body_i, body_j)) + + st_body_i, en_body_i = bodies[body_i] + st_body_j, en_body_j = bodies[body_j] + res_i, res_ii = pick_residues(range(st_body_i, en_body_i+1)) + res_j, res_jj = pick_residues(range(st_body_j, en_body_j+1)) + + logging.info('[++] Created restraint: {0}:{1} <--> {2}:{3}'.format(body_i, res_i, body_j, res_j)) + restraints.append((res_i, res_j)) + logging.info('[++] Created restraint: {0}:{1} <--> {2}:{3}'.format(body_i, res_ii, body_j, res_jj)) + restraints.append((res_ii, res_jj)) + + return restraints + + +def generate_tbl(atom_lst, restraints): + """ + Makes a list of TBL-formatted restraints. + + Parameters + ---------- + atom_lst : list + List of atoms in the form (chain, resi, aname, coords) + + restraints : list + List of restraints in the form (res_i, res_j) + """ + + for r in restraints: + i, j = r + atom_i, atom_j = atom_lst[i], atom_lst[j] + dist_ij = calc_euclidean(atom_i[3], atom_j[3]) + + tbl = "assign (segid {0[0]} and resi {0[1]} and name {0[2]}) ".format(atom_i) + tbl += "(segid {0[0]} and resi {0[1]} and name {0[2]}) ".format(atom_j) + tbl += "{0:3.3f} 0.0 0.0".format(dist_ij) + print(tbl) + + +def check_parenthesis(file): + open_parenthesis = re.compile('[(]') + close_parenthesis = re.compile('[)]') + quotation_marks = re.compile('[\"]') + opened = 0 + closed = 0 + quote = 0 + for _match in open_parenthesis.finditer(file): + opened += 1 + for _match in close_parenthesis.finditer(file): + closed += 1 + for _match in quotation_marks.finditer(file): + quote += 1 + if opened != closed: + raise Exception("Problem with TBL file parentheses ({:d} opening for {:d} " + "closing parentheses)".format(opened, closed)) + if quote % 2 != 0: + raise Exception("Problem with TBL file, odd number of quotation marks " + "({:d} quotation marks)".format(quote)) + + +def validate_tbldata(restraints, pcs=False): + # List of selection keywords + selectors = ('name', 'resn', 'atom', 'resi', 'attr', 'segi', 'chem', 'id', + 'byres', 'not') + connectors = ('and', 'or', 'not', 'byres') + output = "" + parentmatch = re.compile('[()]') + # Global mode is activated outside any assign statement + mode = "global" + # Remove any carriage return/new line caracters + lines = restraints.replace('\r', '').split("\n") + # Line number + lnr = 0 + # Temporary line storage for future output + tmp_output = None + tmp = None + level = None + s = None + selections = None + postselections = None + numbers = None + types = None + lastassign = None + for line in lines: + lnr += 1 + # Take everything which is before putative "!" (comment) caracter + if line.find("!") > -1: + line = line[:line.find("!")] + # Remove whitespaces and merge with previous line if in OR statement + # for AIR restraints + if mode != "format": + line = line.strip() + else: + line = tmp + line.strip() + mode = "postassign" + # End of line + if not len(line): + continue + # Check if all "" are closed + if line.count('"') % 2 > 0: + raise Exception('Unclosed " at line {:d} for line: {}'.format(lnr, line)) + if mode in ("global", "postglobal"): + # Start of an assign statement + if line.lower().startswith("assi"): + if mode == "postglobal": + output += "\n!\n" + output += tmp_output + mode = "assign" + selections = [] + # assign is the only character of the line,check following lines + if line.find("(") == -1: + continue + # Reset temporary buffer + tmp_output = None + # Check for "OR" restraint + elif mode == "postglobal" and line.lower().startswith("or"): + mode = "postassign" + selections = [] + line = line[len("or"):] + # Case where "OR" statement is the only one on the line + # (rest of selection at the next line) + if line == "": + continue + # We are not treating an assign params (postglobal) or at the + # end (global) and no "OR" restraint is present -> ERROR + else: + raise Exception("Invalid TBL file: Unknown statement (line {:d}): {}".format(lnr, line)) + # We check if the selection is made over two lines + # (thanks to "segid" keyword) + if mode == "postassign": + if line.count("segid") == 1: + mode = "format" + tmp = line + continue + + matched = True + while matched: + matched = False + # We are looking for parenthesis as start of the selections + if mode in ("assign", "postassign"): + # Ambiguous restraint for two different pairs of atoms + # (ex: THR 1 B <-> ALA 2 A OR GLY 2 B <-> ASP 10 A ) + pos = line.find("(") + if pos != -1: + matched = True + line = line[pos + 1:] + # We look for an "OR" selection + if mode == "postassign": + mode = "postsel" + else: + mode = "sel" + lastassign = lnr + s = "" + level = 1 + # Get the structural selections + if mode in ("sel", "postsel"): + # Detect opening and closing parenthesis + for match in parentmatch.finditer(line): + if match.group() == "(": + level += 1 + else: + level -= 1 + # End of the parenthesis content + if level == 0: + if mode == "postsel": + mode = "postassign" + else: + mode = "assign" + matched = True + # print l[:match.start()] + # Get back the parentheses content and check + # for selection keywords + idx_connectors = [] + sel = line[:match.start()] + # We can directly check for the 1st keyword presence + if len(sel) > 0: + syntax_ok = False + for s in selectors: + if sel.strip().startswith(s): + syntax_ok = True + if not syntax_ok and not \ + sel.strip().startswith('byres') and not \ + sel.strip().startswith('not'): + raise Exception("1) Missing or wrong keyword in-term {} (stopped at line {:d})". + format(sel, lnr)) + # Get indexes of connectors (AND, OR, etc.) + for c in connectors: + idx_connectors.append([m.start()+len(c) for m in + re.finditer(c, sel)]) + # Flatten the list + tmp_list = [item for sublist in idx_connectors for + item in sublist] + idx_connectors = tmp_list + # Check that each connector is followed by a keyword + for i in idx_connectors: + new_sel = sel[i:].strip().strip("(").strip() + if len(new_sel) > 0: + syntax_ok = False + for s in selectors: + if new_sel.startswith(s): + syntax_ok = True + break + if not syntax_ok: + raise Exception("Missing or wrong keyword in-term {} (stopped at line {:d})". + format(sel, lnr)) + s += sel + selections.append(s) + s = None + # Get the rest of the line + line = line[match.end():] + # Go to the process of the selection + break + # No parenthesis, we get the whole line + if level > 0: + if line != "": + s += line + "\n\t" + else: + # To avoid multiple blank lines + if repr(s) == "''": + # print repr(l), repr(s), selections + s += "\n\t" + # TBD + if mode in ("sel", "postsel"): + continue + # Selection parsed for "OR" line + if mode == "postassign": + if len(selections) != postselections: + raise Exception("Invalid TBL file: wrong number of selections: in-term {:d}, cross-term {:d} " + "(stopped at line {:d})".format(postselections, len(selections), lnr)) + tmp_output += " or" + for s in selections: + tmp_output += "\t({})\n".format(s) + # We let the possibility for other "OR" + mode = "postglobal" + if len(line) == 0: + continue + # Define the distance restraints type to adapt the parsing + if mode == "assign": + mode = "numbers" + if pcs: + if len(selections) == 5: + types = (" {:.3f}", " {:.3f}") + else: + raise Exception("Invalid TBL file: wrong number of selections (must be 5 in PCS mode)") + else: + if len(selections) == 2: + types = (" {:.3f}", " {:.3f}", " {:.3f}") + elif len(selections) == 4: + types = (" {:.3f}", " {:.3f}", " {:.3f}", " {:d}") + elif len(selections) == 5: + raise Exception("Invalid TBL file: wrong number of selections (can be 5 only in PCS mode)") + elif len(selections) == 6: + types = (" {:.3f}", " {:.3f}") + else: + check_parenthesis(restraints) + raise Exception("Invalid TBL file: wrong number of selections (must be 2, 4 or 6)") + postselections = len(selections) + numbers = [] + # Distance restraints parsing + if mode == "numbers": + ll = line.split() + for num in ll: + if len(numbers) == len(types): + break + numbers.append(float(num)) + if len(numbers) == len(types): + tmp_output = "assign " + for s in selections: + tmp_output += "\t({})\n".format(s) + tmp_output = tmp_output[:-len("\n")] + for n, t in zip(numbers, types): + tmp_output += t.format(n) + tmp_output += "\n" + mode = "postglobal" + # "OR" lines have been parsed, we store the selections + if mode == "postglobal": + output += "!\n" + output += tmp_output + mode = "global" + # If mode is not back to global, something has not been processed properly + if mode != "global": + raise Exception("Invalid TBL file: Malformed ASSIGN statement (line {:d}), use --quick to check for " + "putative syntax issues".format(lastassign)) + if not len(output.strip()): + raise Exception("Invalid or empty TBL file") + + # Remove extra lines before each assign statement + output = output.replace("\n\n", "\n") + # Remove extra line at the beginning of the file + if output.startswith("\n"): + output = output.replace("\n", "", 1) + return output + +def passive_from_active_raw(structure, active, chain_id=None, surface=None, radius=6.5): + """Get the passive residues. + + Parameters + ---------- + + structure : str + path to the PDB file + + active : list + List of active residues + + chain_id : str + Chain ID + + surface : list + List of surface residues. + + radius : float + Radius from active residues + """ + + # Parse the PDB file + if Path(structure).exists(): + p = PDBParser(QUIET=True) + s = p.get_structure('pdb', structure) + else: + raise FileNotFoundError('File not found: {0}'.format(structure)) + + try: + if chain_id: + atom_list = [a for a in s[0][chain_id].get_atoms()] + else: + atom_list = [a for a in s[0].get_atoms()] + except KeyError as e: + raise KeyError('Chain {0} does not exist in the PDB file {1}, please enter a proper chain id'. + format(chain_id, structure)) from e + + act_atoms = [a.get_coord() for a in atom_list if a.parent.id[1] in active] + + try: + if not surface: + surface = get_surface_resids(s) + except Exception as e: + raise Exception("There was an error while calculating surface residues: {}".format(e)) from e + + ns = NeighborSearch(atom_list) + neighbors = [] + for a in act_atoms: + neighbors.append(ns.search(a, radius, "R")) # HADDOCK used 6.5A as default + + passive_list = set() + for n in neighbors: + for r in n: + passive_list.add(r.id[1]) + tmp = passive_list & set(surface) + passive_list = tmp - set(active) + return sorted(passive_list) + + +def get_restraint_subset( + tblfile: str, + rd_removed_ratio: float, + seed: int = 917, + ) -> Generator[list[str], None, None]: + """Generator of restraints subsets. + + Parameters + ---------- + tblfile : str + Path to a AIR.tbl file containing restraints. + rd_removed_ratio : float + Ratio of the number of restraints to remove. + seed : int, optional + Pseudo-random seed, by default 917 + + Yields + ------ + subset_restraints: list[str] + A subset of the input restraints. + + Raises + ------ + ValueError + When random removal ratio is too high and no restraints a kept. + ValueError + When random removal ratio is too low and all restraints a kept. + """ + # Extract all restraints + input_restraints = extract_restraint_entries(tblfile) + # Compute number of restraints to be placed in each file + _nb_rest_per_file = (1 - rd_removed_ratio) * len(input_restraints) + nb_rest_per_file = int(round(_nb_rest_per_file, 0)) + # Indicies + rest_indices = list(range(len(input_restraints))) + # Validate that it should result in something OK + if nb_rest_per_file == len(input_restraints): + raise ValueError(f"Error: Subset of restraints equal to number of restraints") + elif nb_rest_per_file == 0: + raise ValueError(f"Error: Subset of restraints equal to 0") + + try: + # Forever loop + while True: + # Reset seed + random.seed(seed) + # Obtain a subset of restraints indices + subset_restraints_ids = random.sample( + rest_indices, + nb_rest_per_file, + ) + # Get subset of restraints + subset_restraints = [ + f"! restraint id {i + 1}{os.linesep}{input_restraints[i]}" + for i in subset_restraints_ids + ] + # Return / Yield them + yield subset_restraints + # Increase seed + seed += 1 + finally: + pass + + +def extract_restraint_entries(tbl_filepath: str) -> list[str]: + """Read and extract restraints in a AIR.tbl file. + + Parameters + ---------- + tbl_filepath : str + Path to a AIR.tbl file containing restraints. + + Returns + ------- + restraints: list[str] + Loaded restraints as a list. + """ + restraints: list[str] = [] + assi: str = "" + # Open the file + with open(tbl_filepath, "r") as fin: + # Loop over lines + for _ in fin: + # Chekf if the line is starting with `assi` == new restraint def + if _.strip().lower().startswith("assi"): + # See if previous assign statement is not empty + if assi != "": + # Hold this one + restraints.append(assi) + # Reset the assign statement with current line + assi = _ + # Skip lines with comments + elif _.strip().startswith("!"): + continue + else: + # Add line to current assign statement + if assi != "": + assi += _ + # Hold last assign statement + if assi != "": + restraints.append(assi) + # Return loaded restraints as a list of string + return restraints diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libstructure.py b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libstructure.py new file mode 100644 index 0000000000000000000000000000000000000000..9f816443671bc82cc50854d0f145281b8b283f90 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libstructure.py @@ -0,0 +1,44 @@ +"""Molecular data structures.""" +from functools import partial +from pathlib import Path +from typing import Any, Iterable, Optional + + +class Molecule: + """ + Input molecule, usually a PDB file. + + Parameters + ---------- + file_name : :external:py:class:`pathlib.Path` + The path to the molecule file. + + segid : int, optional + The ID of the segment. Defaults to ``None``. + + no_parent : boolean + Whether to add the parent path ``..`` to the + :py:attr:`haddock.libs.libstructure.Molecule.with_parent`. + When set to true, the ``with_parent`` attribute returns the same + as ``file_name``. + """ + + def __init__(self, + file_name: Path, + segid: Optional[int] = None, + no_parent: bool = False) -> None: + # the rest of the code is too dependent on the Path API + assert isinstance(file_name, Path), \ + f"`file_name` must be pathlib.Path: {type(file_name)} given" + + self.file_name = file_name + self.segid = segid + if no_parent: + self.with_parent = file_name + else: + self.with_parent = Path('..', file_name) + + +def make_molecules(paths: Iterable[Path], **kwargs: Any) -> list[Molecule]: + """Get input molecules from the data stream.""" + return list(map(partial(Molecule, **kwargs), paths)) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libsubprocess.py b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libsubprocess.py new file mode 100644 index 0000000000000000000000000000000000000000..d66fc0022eedd88e9dfb5af63de4b2f71642acb0 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libsubprocess.py @@ -0,0 +1,275 @@ +"""Run subprocess jobs.""" + +import os +import shlex +import subprocess +from contextlib import suppress +from pathlib import Path + +from haddock.core.defaults import cns_exec as global_cns_exec +from haddock.core.exceptions import ( + CNSRunningError, + JobRunningError, + KnownCNSError, + ) +from haddock.core.typing import Any, FilePath, Optional, ParamDict +from haddock.gear.known_cns_errors import KNOWN_ERRORS as KNOWN_CNS_ERRORS +from haddock.libs.libio import gzip_files + + +class BaseJob: + """Base class for a subprocess job.""" + + def __init__( + self, input_: Path, output: Path, executable: Path, *args: Any + ) -> None: + self.input = input_ + self.output = output + self.executable = executable + self.args = args + self.cmd: str + + def run(self) -> bytes: + """Execute job in subprocess.""" + self.make_cmd() + + with open(self.output, "w") as outf: + p = subprocess.Popen( + shlex.split(self.cmd), + stdout=outf, + close_fds=True, + ) + out, error = p.communicate() + + p.kill() + + if error: + raise JobRunningError(error) + + return out + + def make_cmd(self) -> None: + """Execute subprocess job.""" + raise NotImplementedError() + + +class Job(BaseJob): + """ + Instantiate a standard job. + + Runs with the following scheme: + + $ cmd ARGS INPUT + """ + + def make_cmd(self) -> None: + """Execute subprocess job.""" + self.cmd = " ".join( + [ + os.fspath(self.executable), + "".join(map(str, self.args)), # empty string if no args + os.fspath(self.input), + ] + ) + return + + +class JobInputFirst(BaseJob): + """ + Instantiate a subprocess job with inverted args and input. + + Runs with the following scheme, INPUT comes first: + + $ cmd INPUT ARGS + """ + + def make_cmd(self) -> None: + """Execute job in subprocess.""" + self.cmd = " ".join( + [ + os.fspath(self.executable), + os.fspath(self.input), + "".join(map(str, self.args)), # empty string if no args + ] + ) + return + + +class CNSJob: + """A CNS job script.""" + + def __init__( + self, + input_file: FilePath, + output_file: Optional[FilePath] = None, + error_file: Optional[FilePath] = None, + envvars: Optional[ParamDict] = None, + cns_exec: Optional[FilePath] = None, + ) -> None: + """ + CNS subprocess. + + To execute the job, call the `.run()` method. + + Parameters + ---------- + input_file : str or pathlib.Path + The path to the .inp CNS file. + + output_file : str or pathlib.Path + The path to the .out CNS file, where the standard output + will be saved. + + envvars : dict + A dictionary containing the environment variables needed for + the CNSJob. These will be passed to subprocess.Popen.env + argument. + """ + self.input_file = input_file + self.output_file = output_file + self.error_file = error_file + self.envvars = envvars + self.cns_exec = cns_exec + + def __repr__(self) -> str: + _input_file = self.input_file + if isinstance(self.input_file, str): + _input_file = "IO Stream" + return ( + f"CNSJob({_input_file}, {self.output_file}, " + f"envvars={self.envvars}, cns_exec={self.cns_exec})" + ) + + def __str__(self) -> str: + return repr(self) + + @property + def envvars(self) -> ParamDict: + """CNS environment vars.""" + return self._envvars + + @envvars.setter + def envvars(self, envvars: Optional[ParamDict]) -> None: + """CNS environment vars.""" + self._envvars = envvars or {} + if not isinstance(self._envvars, dict): + raise ValueError("`envvars` must be a dictionary.") + + for k, v in self._envvars.items(): + if isinstance(v, Path): + self._envvars[k] = str(v) + + @property + def cns_exec(self) -> FilePath: + """CNS executable path.""" + return self._cns_exec + + @cns_exec.setter + def cns_exec(self, cns_exec_path: Optional[FilePath]) -> None: + if not cns_exec_path: + cns_exec_path = global_cns_exec # global cns_exec + + if not os.access(cns_exec_path, mode=os.X_OK): + raise ValueError( + f"{str(cns_exec_path)!r} binary file not found, " + "or is not executable." + ) + + self._cns_exec = cns_exec_path + + def run( + self, + compress_inp: bool = False, + compress_out: bool = True, + compress_seed: bool = False, + compress_err: bool = True, + ) -> bytes: + """ + Run this CNS job script. + + Parameters + ---------- + compress_inp : bool + Compress the *.inp file to '.gz' after the run. Defaults to + ``False``. + + compress_out : bool + Compress the *.out file to '.gz' after the run. Defaults to + ``True``. + + compress_seed : bool + Compress the *.seed file to '.gz' after the run. Defaults to + ``False``. + """ + + if isinstance(self.input_file, str): + p = subprocess.Popen( + self.cns_exec, + stdin=subprocess.PIPE, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + close_fds=True, + env=self.envvars, + ) + out, error = p.communicate(input=self.input_file.encode()) + p.kill() + + elif isinstance(self.input_file, Path) and self.output_file is not None: + with open(self.input_file) as inp: + p = subprocess.Popen( + self.cns_exec, + stdin=inp, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + close_fds=True, + env=self.envvars, + ) + out, error = p.communicate() + p.kill() + # Write out file + with open(self.output_file, "wb+") as outf: + outf.write(out) + + if compress_inp: + gzip_files(self.input_file, remove_original=True) + + if compress_out: + gzip_files(self.output_file, remove_original=True) + + if compress_seed: + with suppress(FileNotFoundError): + gzip_files( + Path(Path(self.output_file).stem).with_suffix(".seed"), + remove_original=True, + ) + + # If undetected error or detect an error in the STDOUT + if error or self.contains_cns_stdout_error(out): + # Write .err file + with open(self.error_file, "wb+") as errf: + errf.write(out) + # Compress it + if compress_err: + gzip_files(self.error_file, remove_original=True) + if error: + raise CNSRunningError(error) + + # Return STDOUT + return out + + @staticmethod + def contains_cns_stdout_error(out: bytes) -> bool: + # Decode end of STDOUT + # Search in last 24000 characters (300 lines * 80 characters) + sout = out[-24000:].split(bytes(os.linesep, "utf-8")) + # Reverse loop on lines (read backward) + for bytes_line in reversed(sout): + line = bytes_line.decode("utf-8") + # This checks for an unknown CNS error + # triggered when CNS is about to crash due to internal error + if "^^^^^" in line: + return True + # Check if a known error is found + elif any([error in line for error in KNOWN_CNS_ERRORS.keys()]): + return True + return False diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libtimer.py b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libtimer.py new file mode 100644 index 0000000000000000000000000000000000000000..30b8ccb069e2542697ac46fb9389baa6abe9fca5 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libtimer.py @@ -0,0 +1,75 @@ +"""Tools related to timing functions.""" +from contextlib import contextmanager +from time import time +from typing import Generator + +from haddock import log + + +@contextmanager +def log_time(pre_msg: str) -> Generator[None, None, None]: + """ + Log the time taken to execute the code under the context. + + Examples + -------- + >>> with log_time("function took"): + do_something() + do_more() + + logged: "function tooked 10 minutes" + + Parameters + ---------- + pre_msg : str + String to log with appended time. + + See Also + -------- + :py:func:`convert_seconds_to_min_sec` + """ + start = time() + yield + end = time() + elapsed = convert_seconds_to_min_sec(end - start) + log.info(f"{pre_msg} {elapsed}") + + +def convert_seconds_to_min_sec(seconds: float) -> str: + """ + Convert seconds to min&sec. + + Examples + -------- + >>> convert_seconds_to_min_sec(60) + 1 minute + + >>> convert_seconds_to_min_sec(120) + 2 minutes and 0 seconds + + >>> convert_seconds_to_min_sec(179) + 2 minutes and 59 seconds + + Parameters + ---------- + seconds : int + The elapsed time in seconds. Seconds are round to integers. + + Returns + ------- + str + """ + seconds = int(round(seconds, 0)) + hours = seconds // 3600 + minutes = (seconds) // 60 % 60 + seconds = (seconds) % 60 + + if hours: + return f"{hours}h{minutes}m{seconds}s" + + if minutes: + s = "" if minutes == 1 else "s" + return f"{minutes} minute{s} and {seconds} seconds" + + s = "" if seconds == 1 else "s" + return f"{seconds} seconds" diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libutil.py b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libutil.py new file mode 100644 index 0000000000000000000000000000000000000000..410cf89b0227b6abb43e68e54c7a26ec7ffff438 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libutil.py @@ -0,0 +1,526 @@ +"""General utilities.""" + +import collections.abc +import contextlib +import os +import platform +import re +import shutil +import subprocess +import sys +from copy import deepcopy +from functools import partial +from importlib.resources import files +from pathlib import Path + +import haddock +from haddock import EmptyPath, log +from haddock.core.exceptions import SetupError +from haddock.core.typing import ( + PT, + Any, + AnyT, + Callable, + Container, + FilePath, + FilePathT, + Generator, + Iterable, + Optional, + ParamDict, + ParamMap, + ParamMapT, + Union, +) +from haddock.gear.greetings import get_goodbye_help + +check_subprocess = partial( + subprocess.run, + shell=True, + check=True, + stdout=subprocess.DEVNULL, +) + + +def get_result_or_same_in_list( + function: Callable[[PT], AnyT], value: PT +) -> Union[AnyT, list[PT]]: + """ + Return the result if True or the value within a list. + + Applies `function` to `value` and returns its result if it evaluates + to True. Otherwise, return the value within a list. + + `function` should receive a single argument, the `value`. + """ + result = function(value) + return result if result else [value] + + +def make_list_if_string(item: Union[str, list[str]]) -> list[str]: + """Put `item` into a list.""" + if isinstance(item, str): + return [item] + return item + + +def transform_to_list( + item: Union[Iterable[AnyT], AnyT], +) -> Union[list[AnyT], tuple[AnyT, ...]]: + """ + Put `item` into a list if not a list already. + + If it is set, transforms the set into a list. + + If it is a dict, returns a list of the keys. + + If it is tuple, returns the tuple. + + If a list, returns the same. + + Everything else returns `item` inside a one element list. + """ + if isinstance(item, (set, dict)): + return list(item) + + if isinstance(item, (list, tuple)): + return item + + return [item] + + +def copy_files_to_dir(paths: Iterable[FilePath], directory: FilePath) -> None: + """ + Copy files to directory. + + Parameters + ---------- + paths : iterable of paths + Source files. + + directory : path + Where to copy files to. + """ + for path in paths: + shutil.copy(path, directory) + + +def remove_folder(folder: FilePath) -> None: + """ + Remove a folder if it exists. + + Parameters + ---------- + folder : str or Path + Path to folder to remove. + """ + if Path(folder).exists(): + log.warning(f"{folder} exists and it will be REMOVED!") + shutil.rmtree(folder) + + +def remove_dict_keys(d: ParamMap, keys: Container[str]) -> ParamDict: + """ + Remove `keys` from dictionary (`d`). + + Return + ------ + dict + A copy of `d` dictionary without the `keys`. + """ + return {k: deepcopy(v) for k, v in d.items() if k not in keys} + + +def cpu_count() -> int: + """Count number of available CPU for the process. + + User suggestion, by https://github.com/EricDeveaud + + Note: pid 0 == current process + + FIXME: from python3.13, better to use os.process_cpu_count() + + Returns + ------- + process_ncores : int + Number of cores allocated to the process pid. + """ + + def _cpu_count() -> int: + """Detect number of cores available. + + Returns + ------- + ncores : int + Maximum number of cores that can be used. + """ + try: + # Try to obtain the number of cpu allocated to the process + _process_ncores = os.sched_getaffinity(0) + if isinstance(_process_ncores, set): + ncores = len(_process_ncores) + else: + ncores = int(_process_ncores) + except AttributeError: + # If unsucessful, return the number cores detected in the machine + # Note: this can happen on MacOS, where the os.sched_getaffinity + # may not be defined/exist. + ncores = int(os.cpu_count()) + return ncores + + try: + process_ncores = int(os.process_cpu_count()) + except AttributeError: + process_ncores = _cpu_count() + return process_ncores + + +def parse_ncores( + n: Optional[Union[int, str]] = None, + njobs: Optional[int] = None, + max_cpus: Optional[bool] = None, +) -> int: + """ + Check the number of cores according to HADDOCK3 architecture. + + Parameters + ---------- + n : int or str + The desired number of cores. If `None` is given, returns the + maximum number of cores allowed, see `max_cpus`. + + njobs : int + The number of jobs to execute. Optional. The number of cores + will be compared to `njobs`. + + max_cpus : int + The maximum number of CPUs allowed. If not specified, defaults + to the available CPUs minus one. + + Raises + ------ + SetupError + If `n` is not positive or not convertable to `int`. + + Returns + ------- + int + A correct number of cores according to specifications. + """ + if max_cpus is None or max_cpus is False: + max_cpus = max(cpu_count() - 1, 1) # type: ignore + if max_cpus is True: + max_cpus = cpu_count() # type: ignore + elif not isinstance(max_cpus, int): + raise TypeError(f"`max_cpus` not of valid type: {type(max_cpus)}") + + if n is None: + return max_cpus + + try: + n = int(n) + except (TypeError, ValueError) as err: + _msg = f"`n` must be `int` or `int`-convertable `str`: {n!r} given." + raise SetupError(_msg) from err + + if n < 1: + _msg = f"`n` is not positive, this is not possible: {n!r}" + raise SetupError(_msg) + + if njobs is not None: + ncores = min(n, njobs, max_cpus) + log.info( + f"Selected {ncores} cores to process {njobs} jobs, with {max_cpus} " + "maximum available cores." + ) + return ncores + + log.debug(f"`njobs` not specified, evaluating initial value {n}...") + ncores = min(n, max_cpus) + log.debug(f"Selected {ncores} for a maximum of {max_cpus} CPUs") + return ncores + + +def non_negative_int( + n: Any, + exception: type[Exception] = ValueError, + emsg: str = "`n` do not satisfies", +) -> int: + """ + Transform `n` in int and returns if `compare` evaluates to True. + + Parameters + ---------- + n : int-convertable + Something that can be converted to int. + + exception : Exception + The Exception to raise in case `n` is not a positive integer. + + emsg : str + The error message to give to `exception`. May accept formatting + to pass `n`. + + Raises + ------ + ValueError, TypeError + If `n` cannot be converted to `int` + """ + try: + n1 = int(n) + if n1 >= 0: + return n1 + except Exception as e: + raise e + else: + # don't change to f-strings, .format has a purpose + raise exception(emsg.format(n)) + + +def recursive_dict_update(d: ParamMapT, u: ParamMap) -> ParamMapT: + """ + Update dictionary `d` according to `u` recursively. + + https://stackoverflow.com/questions/3232943 + + Returns + ------- + dict + A new dict object with updated key: values. The original dictionaries + are not modified. + """ + + def _recurse(d_: ParamMapT, u_: ParamMap) -> ParamMapT: + for k, v in u_.items(): + if isinstance(v, collections.abc.Mapping): + d_[k] = _recurse(d_.get(k, {}), v) + else: + d_[k] = deepcopy(v) # in case these are also lists + + return d_ + + new = deepcopy(d) + _recurse(new, u) + + return new + + +def get_number_from_path_stem(path: FilePath) -> int: + """ + Extract tail number from path. + + Examples + -------- + + >>> get_number_from_path_stem('src/file_1.pdb') + >>> 1 + + >>> get_number_from_path_stem('src/file_3.pdb') + >>> 3 + + >>> get_number_from_path_stem('file_1231.pdb') + >>> 1231 + + >>> get_number_from_path_stem('src/file11') + >>> 11 + + >>> get_number_from_path_stem('src/file_1234_1.pdb') + >>> 1 + + Parameters + ---------- + path : str or Path obj + The path to evaluate. + + Returns + ------- + int + The tail integer of the path. + """ + stem = Path(path).stem + number = re.findall(r"\d+", stem)[-1] + return int(number) + + +def sort_numbered_paths(*paths: FilePathT) -> list[FilePathT]: + """ + Sort input paths to tail number. + + If possible, sort criteria is provided by + :py:func:`get_number_from_path_stem`. + If paths do not have a numbered tag, sort paths alphabetically. + + Parameters + ---------- + *inputs : str or pathlib.Path + Paths to files. + + Returns + ------- + list + The sorted pathlist. The original types are not modified. If + strings are given, strings are returns, if Paths are given + paths are returned. + """ + try: + return sorted(paths, key=get_number_from_path_stem) + except TypeError as err: + log.exception(err) + emsg = ( + "Mind the packing *argument, input should be strings or Paths, not a list." + ) + raise TypeError(emsg) + except IndexError: + return sorted(paths, key=lambda x: Path(x).stem) + + +@contextlib.contextmanager +def log_error_and_exit() -> Generator[None, None, None]: + """Exit with exception.""" + try: + yield + except Exception as err: + log.exception(err) + log.error(err) + log.error( + "An error has occurred, see log file. And contact the developers if needed." + ) + log.info(get_goodbye_help()) + sys.exit(1) + + +def extract_keys_recursive(config: ParamMap) -> Generator[str, None, None]: + """Extract keys recursively for the needed modules.""" + for param_name, value in config.items(): + if isinstance(value, collections.abc.Mapping): + yield from extract_keys_recursive(value) + else: + yield param_name + + +def recursive_convert_paths_to_strings(params: ParamMapT) -> ParamMapT: + """ + Convert paths to strings recursively over a dictionary. + + Parameters + ---------- + params : dictionary + + Returns + ------- + dictionary + A copy of the original dictionary with paths converted to strings. + """ + params = deepcopy(params) + for param, value in params.items(): + if isinstance(value, (Path, EmptyPath)): + params[param] = str(value) + elif isinstance(value, collections.abc.Mapping): + params[param] = recursive_convert_paths_to_strings(value) + elif isinstance(value, (tuple, list)): + for i, v in enumerate(value): + if isinstance(v, (Path, EmptyPath)): + value[i] = str(v) + params[param] = value + + return params + + +def get_arch(): + """Helper function to figure out the architetchure""" + system = platform.system().lower() + machine = platform.machine().lower() + + return f"{machine}-{system}" + + +def get_cns_executable() -> tuple[Path, Path]: + """ + Locate CNS executable and its Linux variant for grid execution. + + Returns: + Tuple of (cns_exec, cns_exec_linux) paths + + Raises: + SystemExit: If CNS executable cannot be found + """ + cns_exec_dir = Path(files(haddock).joinpath("cns/bin")) # type: ignore + arch = get_arch() + cns_exec = Path(cns_exec_dir, f"{arch}.bin") + if not cns_exec.exists(): + log.error("CNS executable not found at %s", cns_exec) + + # Fall back to environment variable + cns_exec_env = os.environ.get("CNS_EXEC") + if cns_exec_env is None: + log.error( + "Please define the CNS binary location by setting the CNS_EXEC " + "environment variable" + ) + sys.exit(1) + + cns_exec = Path(cns_exec_env) + if not cns_exec.exists(): + log.error("CNS executable not found at %s", cns_exec) + sys.exit(1) + + # Determine Linux-specific executable for grid usage + cns_exec_linux = Path(cns_exec_dir, "x86_64-linux.bin") + + if not cns_exec_linux.exists(): + log.warning( + "Current architecture is %s, but grid execution requires " + "an x86_64-linux binary", + arch, + ) + log.warning("Linux CNS binary not found at %s", cns_exec_linux) + log.warning("GRID mode will not be available") + + return cns_exec, cns_exec_linux + + +def get_prodrg_exec() -> tuple[Optional[Path], Optional[Path]]: + """ + Locate the prodrg binary and its parameter file. + + Returns ``(None, None)`` with a warning if the binary cannot be found, + allowing the application to start normally. The error will surface later + if ``run_prodrg`` is actually called. + + Returns: + Tuple of (prodrg_exec, prodrg_param) paths, or (None, None) if not found + """ + prodrg_dir = Path(files(haddock).joinpath("prodrg")) # type: ignore + arch = get_arch() + prodrg_exec = prodrg_dir / f"prodrg_{arch}" + + if not prodrg_exec.exists(): + prodrg_exec_env = os.environ.get("PRODRG_EXEC") + if prodrg_exec_env is not None: + prodrg_exec = Path(prodrg_exec_env) + else: + log.warning( + "prodrg binary not found for arch %s and PRODRG_EXEC is not set. " + "Automated ligand topology generation will not be available.", + arch, + ) + return None, None + + if not prodrg_exec.exists(): + log.warning( + "prodrg executable not found at %s. " + "Automated ligand topology generation will not be available.", + prodrg_exec, + ) + return None, None + + prodrg_param = prodrg_dir / "prodrg.param" + if not prodrg_param.exists(): + log.warning( + "prodrg.param not found at %s. " + "Automated ligand topology generation will not be available.", + prodrg_param, + ) + return None, None + + return prodrg_exec, prodrg_param diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libworkflow.py b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libworkflow.py new file mode 100644 index 0000000000000000000000000000000000000000..38254fb845729fc9a65e3702b0d68cdb0fb6d6b4 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/libs/libworkflow.py @@ -0,0 +1,202 @@ +"""HADDOCK3 workflow logic.""" + +import importlib +import sys +from pathlib import Path +from time import time + +from haddock import log +from haddock.clis.cli_analyse import main as cli_analyse +from haddock.clis.cli_traceback import main as cli_traceback +from haddock.core.exceptions import HaddockError, HaddockTermination, StepError +from haddock.core.typing import Any, ModuleParams, Optional +from haddock.gear.clean_steps import clean_output +from haddock.gear.config import get_module_name +from haddock.gear.zerofill import zero_fill +from haddock.libs.libtimer import convert_seconds_to_min_sec, log_time +from haddock.libs.libutil import recursive_dict_update +from haddock.modules import ( + modules_category, + non_mandatory_general_parameters_defaults, +) + + +class WorkflowManager: + """Read and execute workflows.""" + + def __init__( + self, + workflow_params: ModuleParams, + start: Optional[int] = 0, + **other_params: Any, + ) -> None: + self.start = 0 if start is None else start + self.recipe = Workflow(workflow_params, start=0, **other_params) + # terminate is used to synchronize the `clean` option with the + # `exit` module. If the `exit` module is removed in the future, + # you can also remove and clean the `terminate` part here. + self._terminated = None + + def run(self) -> None: + """High level workflow composer.""" + for i, step in enumerate(self.recipe.steps[self.start :], start=self.start): + try: + step.execute() + except HaddockTermination: + self._terminated = i # type: ignore + break + + # Forward any params generated at runtime by some module, for example + # auto-generated ligand topology/parameter files to every subsequent + # step that exposes the same key in its config, + # Do this ONLY when the user has not already set a value for that key. + output_params = getattr(step.module, "_output_params", {}) + if output_params: + for future_step in self.recipe.steps[i + 1 :]: + for key, value in output_params.items(): + if future_step.config.get(key) in (None, ""): + future_step.config[key] = value + + def clean(self, terminated: Optional[int] = None) -> None: + """ + Clean steps. + + Parameters + ---------- + terminated : int, None + At which index of the workflow to stop the cleaning. If ``None``, + uses the internal class configuration. + """ + terminated = self._terminated if terminated is None else terminated + for step in self.recipe.steps[:terminated]: + step.clean() + + def postprocess(self, self_contained: bool = False) -> None: + """Postprocess the workflow.""" + # is the workflow going to be cleaned? + is_cleaned = self.recipe.steps[0].config["clean"] + # Is the workflow supposed to run offline + offline = self.recipe.steps[0].config["offline"] + # running mode + mode = self.recipe.steps[0].config["mode"] + # ncores + ncores = self.recipe.steps[0].config["ncores"] + + capri_steps: list[int] = [] + for step in self.recipe.steps: + if step.module_name == "caprieval": + capri_steps.append(step.order) # type: ignore + # call cli_analyse (no need for capri_dicts, it's all precalculated) + cli_analyse( + "./", + capri_steps, + top_clusters=10, + format=None, + scale=None, + inter=False, + is_cleaned=is_cleaned, + offline=offline, + mode=mode, + ncores=ncores, + self_contained=self_contained, + ) + # call cli_traceback. If it fails, it's not a big deal + try: + cli_traceback("./", offline=offline) + except Exception as e: + log.warning(f"Error running traceback: {e}") + + +class Workflow: + """Represent a set of stages to be executed by HADDOCK.""" + + def __init__( + self, + modules_parameters: ModuleParams, + start: Optional[int] = 0, + **other_params: Any, + ) -> None: + if start is None: + start = 0 + + # filter out those parameters not belonging to the modules + general_modules = { + k: v + for k, v in other_params.items() + if k in non_mandatory_general_parameters_defaults + } + + # Create the list of steps contained in this workflow + self.steps: list[Step] = [] + _items = enumerate(modules_parameters.items(), start=start) + for num_stage, (stage_name, params) in _items: + stage_name = get_module_name(stage_name) + log.info(f"Reading instructions step {num_stage}_{stage_name}") + + # updates the module's specific parameter with global parameters + # that are applicable to the modules. But keep priority to the local + # level + params_up = recursive_dict_update(general_modules, params) + + try: + _ = Step( + stage_name, + order=num_stage, + **params_up, + ) + self.steps.append(_) + + except StepError as re: + log.error(f"Error found while parsing course {stage_name}") + raise HaddockError from re + + +class Step: + """Represents a Step of the Workflow.""" + + def __init__( + self, + module_name: str, + order: Optional[int] = None, + **config_params: Any, + ) -> None: + self.config = config_params + self.module_name = module_name + self.order = order + self.working_path = Path(zero_fill.fill(self.module_name, self.order)) # type: ignore + self.module = None + + def execute(self) -> None: + """Execute simulation step.""" + self.working_path.resolve().mkdir(parents=False, exist_ok=False) + + # Import the module given by the mode or default + module_name = ".".join( + ["haddock", "modules", modules_category[self.module_name], self.module_name] + ) + module_lib = importlib.import_module(module_name) + self.module = module_lib.HaddockModule(order=self.order, path=self.working_path) + + # Run module + start = time() + try: + self.module.update_params(**self.config) # type: ignore + self.module.save_config(Path(self.working_path, "params.cfg")) # type: ignore + self.module.run() # type: ignore + except KeyboardInterrupt: + log.info("You have halted subprocess execution by hitting Ctrl+c") + log.info("Exiting...") + sys.exit(1) + + end = time() + elapsed = convert_seconds_to_min_sec(end - start) + self.module.log(f"took {elapsed}") # type: ignore + + def clean(self) -> None: + """Clean step output.""" + if self.module is None and self.config["clean"]: + with log_time("cleaning output files took"): + clean_output(self.working_path, self.config["ncores"]) + + elif self.module is not None and self.module.params["clean"]: + self.module.clean_output() diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..692112783467e9f09f00564d04fa621e4b6ac10a --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/__init__.py @@ -0,0 +1,537 @@ +"""HADDOCK3 modules.""" + +import re + +from abc import ABC, abstractmethod +from contextlib import contextmanager, suppress +from copy import deepcopy +from functools import partial +from os import linesep +from pathlib import Path + +from haddock import EmptyPath, log, modules_defaults_path +from haddock.core.defaults import MODULE_IO_FILE, INTERACTIVE_RE_SUFFIX +from haddock.core.exceptions import ConfigurationError +from haddock.core.typing import ( + Any, + Container, + FilePath, + Generator, + Literal, + Optional, + ParamDict, + Union, +) +from haddock.gear import config +from haddock.gear.clean_steps import clean_output +from haddock.gear.known_cns_errors import find_all_cns_errors +from haddock.gear.parameters import config_mandatory_general_parameters +from haddock.gear.yaml2cfg import read_from_yaml_config, find_incompatible_parameters +from haddock.libs.libhpc import HPCScheduler +from haddock.libs.libgrid import GRIDScheduler, ping_dirac +from haddock.libs.libio import folder_exists, working_directory +from haddock.libs.libmpi import MPIScheduler +from haddock.libs.libontology import ModuleIO, PDBFile +from haddock.libs.libparallel import Scheduler +from haddock.libs.libtimer import log_time +from haddock.libs.libutil import recursive_dict_update + + +modules_folder = Path(__file__).resolve().parent + +_folder_match_regex = "[a-zA-Z]*/" +modules_category = { + module.name: category.name + for category in modules_folder.glob(_folder_match_regex) + for module in category.glob(_folder_match_regex) +} +"""Indexes each module in its specific category. Keys are Paths to the module, +values are their categories. Categories are the modules parent folders.""" + +modules_names = set(modules_category.keys()) + +category_hierarchy = [ + "topology", + "sampling", + "refinement", + "scoring", + "analysis", + "extras", +] + +# this dictionary defines non-mandatory general parameters that can be defined +# as global parameters thus affect all modules, or, instead, can be defined per +# module where the module definition overwrites global definition. Not all +# modules will use these parameters. It is the responsibility of the module to +# extract the parameters it needs. +# the config file is in modules/defaults.cfg +non_mandatory_general_parameters_defaults = read_from_yaml_config(modules_defaults_path) # noqa : E501 + +incompatible_defaults_params = find_incompatible_parameters(modules_defaults_path) + +config_readers = { + ".yaml": read_from_yaml_config, + ".cfg": config.load, +} + +_step_folder_regex = tuple( + r"[0-9]+_" + mod_name for mod_name in modules_category.keys() +) +step_folder_regex = "(" + "|".join(_step_folder_regex) + ")" +""" +String for regular expression to match module folders in a run directory. + +It will match folders with a numeric prefix followed by underscore ("_") +followed by the name of a module. + +Example: https://regex101.com/r/roHls9/1 +""" + +step_folder_regex_re = re.compile(step_folder_regex) +""" +Compiled regular expression from :py:const:`step_folder_regex`. + +It will match folders with a numeric prefix followed by underscore ("_") +followed by the name of a module. + +Example: https://regex101.com/r/roHls9/1 +""" + + +@contextmanager +def _not_valid_config() -> Generator[None, None, None]: + try: + yield + except KeyError as err: + emsg = ( + "The configuration file extension is not supported. " + f"Supported types are {', '.join(config_readers.keys())}." + ) + raise ConfigurationError(emsg) from err + + +class BaseHaddockModule(ABC): + """HADDOCK3 module's base class.""" + + name: str + + def __init__(self, order: int, path: Path, params_fname: FilePath) -> None: + """ + HADDOCK3 modules base class. + + Parameters + ---------- + params : dict or path to HADDOCK3 configuration file + A dictionary or a path to a HADDOCK3 configuration file + containing the initial module parameters. Usually this is + defined by the default params. + """ + self.order = order + self.path = path + self.previous_io = self._load_previous_io() + + # instantiate module's parameters + self._origignal_config_file = params_fname + with _not_valid_config(): + extension = Path(params_fname).suffix + self._original_params = config_readers[extension](params_fname) + + self._params: ParamDict = {} + self.update_params(update_from_cfg_file=params_fname) + + # Some modules might need to overwrite parameters defined by the user + # This can be done via `_output_params` - whatever the module adds to this + # variable, will be propagated down to other modules. + # For example: `topoaa` needs to pass `ligand_param_fname` to `rigidbody` module + # so somewhere in the `topoaa` module we need to set: `self._output_params[VALUE] = VAR` + # IMPORANT: This will be propagated to ALL modules and can have unexpected effects + self._output_params: dict = {} + + @property + def params(self) -> ParamDict: + """Configuration parameters.""" # noqa: D401 + return self._params + + def reset_params(self) -> None: + """Reset parameters to the ones used to instantiate the class.""" + self._params.clear() + self.update_params(**self._original_params) + + def update_params( + self, + update_from_cfg_file: Optional[FilePath] = None, + **params: Any, + ) -> None: + """ + Update the modules parameters. + + Add/update to the current modules parameters the ones given in + the function call. If you want to enterily replace the modules + parameters to their default values use the `reset_params()` + method. + + Update takes places recursively, that is, nested dictionaries + will be updated accordingly. + + To update the current config with the parameters defined in an + HADDOCK3 configuration file use the `update_from_cfg_file` + parameter. + + To update from a JSON file, first load the JSON into a + dictionary and unpack the dictionary to the function call. + + Examples + -------- + >>> m.update_params(param1=value1, param2=value2) + + >>> m.update_params(**param_dict) + + >>> m.update_params(update_from_cfg_file=path_to_file) + + # if you wish to start from scratch + >>> m.reset_params() + >>> m.update_params(...) + """ + if update_from_cfg_file and params: + _msg = "You can not provide both `update_from_cfg_file` and key arguments." + raise TypeError(_msg) + + if update_from_cfg_file: + with _not_valid_config(): + extension = Path(update_from_cfg_file).suffix + params = config_readers[extension](update_from_cfg_file) + + # the updating order is relevant + _n = recursive_dict_update( + non_mandatory_general_parameters_defaults, self._params + ) + self._params = recursive_dict_update(_n, params) + self._fill_emptypaths() + self._confirm_fnames_exist() + + def save_config(self, path: FilePath) -> None: + """Save current parameters to a HADDOCK3 config file.""" + # creates this dictionary for the config to have the module name + # key in brackets, for example: + # + # [topoaa] + # ... + ignore = config_mandatory_general_parameters.union( + non_mandatory_general_parameters_defaults + ) # noqa: 501 + params = deepcopy(self.params) + + with suppress(KeyError): + for key in list(ignore): + params.pop(key) + + config.save({self.name: params}, path) + + def add_parent_to_paths(self) -> None: + """Add parent path to paths.""" + # convert paths to relative by appending parent + for key, value in self.params.items(): + if value and key.endswith("_fname"): + if not Path(value).is_absolute(): + self.params[key] = Path("..", value) + return + + @abstractmethod + def _run(self) -> None: ... + + def run(self, **params: Any) -> None: + """Execute the module.""" + log.info(f"Running [{self.name}] module") + + self.update_params(**params) + self.add_parent_to_paths() + + with working_directory(self.path): + self._run() + + log.info(f"Module [{self.name}] finished.") + + def clean_output(self) -> None: + """ + Clean module output folder. + + See Also + -------- + :py:func:`haddock.gear.clean_steps.clean_output` + """ + with log_time("cleaning output files took"): + clean_output(self.path, self.params["ncores"]) + + @classmethod + @abstractmethod + def confirm_installation(cls) -> None: + """ + Confirm the third-party software needed for the module is installed. + + HADDOCK3's own modules should just return. + """ + return + + def export_io_models(self, faulty_tolerance: float = 0.0) -> None: + """ + Export input/output to the ModuleIO interface. + + Modules that do not perform any operation on PDB files should have + input = output. + + This function implements a common interface for all modules. + + Parameters + ---------- + faulty_tolerance : int, default 0 + The percentage of missing output allowed. If 20 is given, + raises an error if 20% of the expected output is missing (not + saved to disk). + """ + self.output_models: Union[list[PDBFile], dict[int, PDBFile]] + assert self.output_models, "`self.output_models` cannot be empty." + io = ModuleIO() + # add the input models + io.add(self.previous_io.output, "i") + # add the output models + io.add(self.output_models, "o") + # Removes un-generated outputs and compute percentage of ungenerated + faulty = io.check_faulty() + # Save outputs + io.save() + # Check if number of generated outputs is under the tolerance threshold + if faulty > faulty_tolerance: + _msg = ( + f"{faulty:.2f}% of output was not generated for this module " + f"and tolerance was set to {faulty_tolerance:.2f}%." + ) + # Try to detect CNS errors + if detected_errors := find_all_cns_errors(self.path): + _msg += linesep + for error in detected_errors.values(): + _msg += f"{str(error['error'])}{linesep}" + # Show final error message + self.finish_with_error(_msg) + + def finish_with_error(self, reason: object = "Module has failed.") -> None: + """Finish with error message.""" + if isinstance(reason, Exception): + raise RuntimeError("Module has failed.") from reason + + else: + raise RuntimeError(reason) + + def _load_previous_io( + self, + filename: FilePath = MODULE_IO_FILE, + ) -> ModuleIO: + if self.order == 0: + self._num_of_input_molecules = 0 + return ModuleIO() + + io = ModuleIO() + previous_io = Path(self.previous_path(), filename) + + if previous_io.is_file(): + io.load(previous_io) + + self._num_of_input_molecules = len(io.output) + + return io + + def previous_path(self) -> Path: + """Give the path from the previous calculation.""" + previous = get_module_steps_folders(self.path.resolve().parent) + + try: + # return Path(previous[self.order - 1]) + return self.last_step_folder(previous, self.order - 1) + except IndexError: + return self.path + + @staticmethod + def last_step_folder(folders, index): + """Retrieve last step folder.""" + with_ind = [folder for folder in folders if int(folder.split("_")[0]) == index] + nb_with_ind = len(with_ind) + # No matching index + if nb_with_ind == 0: + raise IndexError + # Only one matching index + elif nb_with_ind == 1: + return with_ind[0] + # Case of multiple matching index + else: + for folder in with_ind: + if folder.split("_")[-1] != INTERACTIVE_RE_SUFFIX: + return folder + return with_ind[0] + + def log(self, msg: str, level: str = "info") -> None: + """ + Log a message with a common header. + + Currently the header is the [MODULE NAME] in square brackets. + + Parameters + ---------- + msg : str + The log message. + + level : str + The level log: 'debug', 'info', ... + Defaults to 'info'. + """ + getattr(log, level)(f"[{self.name}] {msg}") + + def _confirm_fnames_exist(self) -> None: + for param, value in self._params.items(): + if param.endswith("_fname") and value: + if not Path(value).exists(): + raise FileNotFoundError(f"File not found: {str(value)!r}") + + def _fill_emptypaths(self) -> None: + """Fill empty paths.""" + for param, value in list(self._params.items()): + if param.endswith("_fname") and not value: + self._params[param] = EmptyPath() + + +EngineMode = Literal["batch", "local", "mpi"] + + +def get_engine( + mode: str, + params: dict[Any, Any], +) -> partial[Union[HPCScheduler, Scheduler, MPIScheduler, GRIDScheduler]]: + """ + Create an engine to run the jobs. + + Parameters + ---------- + mode : str + The type of engine to create + + params : dict + A dictionary containing parameters for the engine. + `get_engine` will retrieve from `params` only those parameters + needed and ignore the others. + """ + # a bit of a factory pattern here + # this might end up in another module but for now its fine here + if mode == "batch": + return partial( # type: ignore + HPCScheduler, + target_queue=params["queue"], + queue_limit=params["queue_limit"], + concat=params["concat"], + ) + + elif mode == "local": + return partial( # type: ignore + Scheduler, + ncores=params["ncores"], + max_cpus=params["max_cpus"], + ) + elif mode == "mpi": + return partial(MPIScheduler, ncores=params["ncores"]) # type: ignore + + elif mode == "grid": + # `grid` mode should only be used IF the grid is reachable, + # if not it should fallback to `local` + grid_available = ping_dirac() + + if grid_available: + return partial(GRIDScheduler, params=params) # type: ignore + else: + log.warning("GRID is not available, activating fallback using `mode=local`") + return partial( # type: ignore + Scheduler, + ncores=params["ncores"], + max_cpus=params["max_cpus"], + ) + + else: + available_engines = ("batch", "local", "mpi", "grid") + raise ValueError( + f"Scheduler `mode` {mode!r} not recognized. " + f"Available options are {', '.join(available_engines)}" + ) + + +def get_module_steps_folders( + folder: FilePath, + modules: Optional[Container[int]] = None, +) -> list[str]: + """ + Return a sorted list of the step folders in a running directory. + + Example + ------- + Consider the folder structure: + + run_dir/ + 0_topoaa/ + 1_rigidbody/ + 2_caprieval/ + 3_bad_module_name/ + data/ + + >>> get_module_steps_folders("run_dir") + >>> ["0_topoaa", "1_rigidbody", "2_caprieval"] + + Parameters + ---------- + folder : str or Path + Path to the run directory, or to the folder containing the step + folders. + + Returns + ------- + list of str + List containing strings with the names of the step folders. + """ + folders = (p.name for p in Path(folder).iterdir() if p.is_dir()) + steps = sorted( + (f for f in folders if step_folder_regex_re.search(f)), + key=lambda x: int(x.split("_")[0]), + ) + if modules: + steps = [ + st + for st in steps + if all( + [ + int(st.split("_")[0]) in modules, + st.split("_")[1] in modules_names, + ] + ) + ] + return steps + + +def is_step_folder(path: FilePath) -> bool: + """ + Assess whether a folder is a possible step folder. + + The folder is considered a step folder if has a zero or positive + integer index followed by a name of a module. + + Parameters + ---------- + path : str or pathlib.Path + The path to the folder. + + Returns + ------- + bool + Whether the folder is a step folder or not. + """ + path = Path(path) + folder_exists(path) + main_folder_name = path.name + parts = main_folder_name.split("_") + if len(parts) == 2 and parts[0].isdigit() and parts[1] in modules_category: + return True + else: + return False diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ee2a8f2729f27289c865c73afb57b5c0fdb56082 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/__pycache__/base_cns_module.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/__pycache__/base_cns_module.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..960d8023f626b21c0c84708faf22d0ecf3ba72e7 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/__pycache__/base_cns_module.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/_template_cat/README.md b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/_template_cat/README.md new file mode 100644 index 0000000000000000000000000000000000000000..ed5ec452d1f6b189dfad37da83bd226aefba3d80 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/_template_cat/README.md @@ -0,0 +1,30 @@ +Welcome! + +To develop your own HADDOCK3 module follow the patterns used in other modules. + +1. If your module belongs to a new category, create a folder for that category + under the `modules` folder. +1. Else, create a folder for your module inside its relevant category. + The name of that folder is the name of the module, i.e., the name used to call + the module in the haddock3 configuration files and used throughout the code base. +1. Copy the `__init__.py` file here to the new module's folder and edit it accordingly + to the instructions there. +1. Do the same for the `defaults.yaml` file. +1. You can then add any extra files needed inside your module's folder in order to + develop your module fully. +1. If your module requires any extra libraries, describe how to install those libraries + in the `docs/INSTALL.md` file. Unless approved by the Haddock Team, do not add + those dependencies to the `requirements.*` files. +1. HADDOCK3 has already many features related to IO, subprocess run, sending jobs, + etc. Please, look around the `libs` folder for pertinent functions, but, above all, + feel welcomed to reach out to us with any doubts. +1. Please write also tests for your module. Our testing machinery already + tests for the common patterns, for example, inspecting the `defaults.yaml` file. + But you should write any additional tests to ensure that your module works properly. + See other examples in the `tests/` folder. +1. Finally, add an example of how to use your module in the `examples/` folder. + The example should have a short sampling scheme. Name the config file ending with + `-test.cfg`. + +Thanks, and we are happy to help you! :-) +@ The Haddock Team diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/_template_cat/_template_mod/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/_template_cat/_template_mod/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8fe31b4f76dc1868dbc8fd3619681f75e3361f07 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/_template_cat/_template_mod/__init__.py @@ -0,0 +1,142 @@ +""" +Template module +=============== + +Use this template to implement your own HADDOCK3 module. + +In this docstring, please write the documentation explaining what the module +does technically, scientifically, and its purpose. + +Anything you want to write to describe the module, also do it here. +You should use restructureText syntax: + + https://docutils.sourceforge.io/docs/user/rst/quickstart.html +""" +# Import here what you need +from pathlib import Path +from haddock.core.typing import FilePath, Any +from haddock.core.defaults import MODULE_DEFAULT_YAML + +# In case you need to import a Python library that is a run-time dependency, +# you should import it inside the `_run` method to avoid import errors for those +# users not using the new module, thus not having its dependencies installed. + +# If your module does not use CNS, import the following +from haddock.modules import BaseHaddockModule + +# If your module uses CNS import +from haddock.modules.base_cns_module import BaseCNSModule + + +# this is mandatory, don't erase nor edit these lines +RECIPE_PATH = Path(__file__).resolve().parent +DEFAULT_CONFIG = Path(RECIPE_PATH, MODULE_DEFAULT_YAML) + + +# this is the main class of the module. It should be named exactly as this. +class HaddockModule(BaseHaddockModule): + # inherit from BaseCNSModule in case the module uses CNS + """ + Here you can write any extra documentation you wish about the class. + + Use numpydoc syntax: + + https://numpydoc.readthedocs.io/en/latest/format.html + """ + + # this is mandatory + name = RECIPE_PATH.name + + # this __init__ structure is mandatory, but you can extend it to the + # module's needs as long as you keep the main structure. Surely, + # *ignore and **everything can be edited to fit your needs. + def __init__( + self, + order: int, + path: Path, + *ignore: Any, + init_params: FilePath = DEFAULT_CONFIG, + **everything: Any, + ) -> None: + + # if your module uses CNS you might need to define where the main CNS + # script is localted. See examples in `topoaa`, `emref`. + # else leave it out. + # cns_script = Path(RECIPE_PATH, "cns", "main.cns") + + # use one of the following: + # if the module does not use CNS: + super().__init__(order, path, init_params) + + # if the module uses CNS: + super().__init__(order, path, initial_params, cns_script=cns_script) + + @classmethod + def confirm_installation(cls) -> None: + """Confirm if the module is ready to use.""" + # here, you should write any code needed to confirm that all the + # dependencies required by your module are installed. + # this class method will be executed when HADDOCK3 starts. + + # if you module does not import any run-time dependency, just leave + # this method blank + return + + # here is where the module magic will happen + def _run(self) -> None: + # Import here any Python run-time dependencies that your module needs. + + # you can refer to other modules as examples to see how they perform. + # Likely, the new module will need to load the output from the previous + # module. For example: + models_to_use = self.previous_io.retrieve_models() + + # once the module loads, you can access its parameters in + # `self.params`. See more in the BaseHaddockModule class. + # `self.params` is a dictionary that contains both the general + # parameters such as the number of processors + # `self.params['ncores']` parameters as well as those + # defined in your `defaults.yml` + + # Add here all the magic that your module does. You can split this part + # into many functions, classes, or add any extra files or subfolders to + # the module's folder as you may need. You can even import other modules + # if needed. + + # If you module creates models, the line below is almost mandatory. + # see other modules, such as topoaa or mdref, emref to see how they + # handle `output_models`. + # the PDB references in `list_of_created_models` below must be instances + # of the `libs.libontology.PDBFile` class. + + output_model_list = your_function(models_to_use, self.params) + # output_model_list = [(pdb, psf, score), ...] + + list_of_created_models = [] + for element in output_model_list: + pdb, psf, score = element + # IMPORTANT: pass `file_name=Path.name` + + # alternatively to the strategy below, you can use the + # `libs.libcns.prepare_expected_pdb` function if it better fits + # your case. See `emref` and `mdref` for examples. + pdb_object = PDBFile( + Path(pdb).name, + topology=TopologyFile(Path(psf).name, path="."), + path=".") + + pdb_object.score = score + list_of_created_models.append(pdb_object) + + # final section + self.output_models = list_of_created_models + self.export_io_models() + # in case your module considers possible tolerance for generated models, + # you can use: + # self.export_io_models(faulty_tolerance=self.params["tolerance"]) + + +# Finally, the haddock module's class inherit from BaseHaddockModule. It is +# important that you go through the BaseHaddockModule interface to understand +# it's functionalities. If you find any spots of missing documentation, let us +# know. Thanks! @ The Haddock Team diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/_template_cat/_template_mod/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/_template_cat/_template_mod/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4258c1313dac450fc942a2bdca2c1cc6f70aff67 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/_template_cat/_template_mod/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/_template_cat/_template_mod/defaults.yaml b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/_template_cat/_template_mod/defaults.yaml new file mode 100644 index 0000000000000000000000000000000000000000..cf7713327796250684798caa81873420399c3420 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/_template_cat/_template_mod/defaults.yaml @@ -0,0 +1,106 @@ +# this is an example of the default parameters +# add here the parameters of your module. You can follow examples +# in other default config files. Each parameter type has it's own specific extra +# fields. Below an example of parameters of different types: +# explevel can only be easy, expert, guru + +# You may wish to read our functionalities in "extended parameters": +# https://github.com/haddocking/haddock3/blob/main/src/haddock/gear/expandable_parameters.py#L1-L73 + +# INTEGER parameter +random_seed: + default: 42 + type: integer + min: 0 + max: 999 + title: + short: + long: + group: "" + explevel: easy + +# FLOAT parameter +indpb: + default: 0.2 + type: float + min: 0 + max: 1 + precision: 2 + title: + short: + long: + group: "" + explevel: expert + +# LIST parameter +region: + default: [] + type: list + minitems: 0 + maxitems: 1000 + title: + short: + long: + group: "" + explevel: guru + +# STRING parameter with CHOICES +initial_mutation: + default: keep + type: string + minchars: 0 + maxchars: 7 + choices: + - alanine + - random + - keep + title: + short: + long: + group: "" + explevel: guru + +# STRING parameter without CHOICES +target_chain: + default: "A" + type: string + minchars: 1 + maxchars: 1 + title: + short: + long: + group: "" + explevel: hidden + +# a DICTIONARY parameter +# these parameter are tricky to maintain, use them only if strickly needed. +dict_like_par: + explevel: easy + title: Example of a dictionary mdule + short: Some short explanation on dick_like_par + long: Some long explanationon dick_like_par + group: "the group it belongs" + type: dict + # here are the parameters belonging to the `dict_like_par` key + somepar: + default: 0.2 + type: float + min: 0 + max: 1 + precision: 2 + title: + short: + long: + group: "" + explevel: expert + + otherpar: + default: [] + type: list + minitems: 0 + maxitems: 1000 + title: + short: + long: + group: "" + explevel: guru diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..bf8035011d2e2947bc0e27f1c9cb6743aa78f34f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/__init__.py @@ -0,0 +1,61 @@ +"""HADDOCK3 modules related to model analysis.""" + +from typing import Iterable + + +modules_using_resdic = ("caprieval", "rmsdmatrix", "alascan", "sasascore") + + +def confirm_resdic_chainid_length(params: Iterable[str]) -> None: + """ + Confirm resdic params have chain IDs of length one. + + Parameters + ---------- + params : dict, or list of keys + The parameters. + + Raises + ------ + ValueError + If a `resdic_*` parameter has chain IDs with more than one letter. + For example, `resdic_AB`. + """ + resdic_params = (p for p in params if p.startswith("resdic_")) + for param in resdic_params: + chainid = param.split("_")[-1] + if len(chainid) > 1: + raise ValueError( + f"We found the parameter {param!r} which has " + "more than one character in the chain " + "identifier. Chain IDs should have only one character." + ) + + +def get_analysis_exec_mode(mode: str) -> str: + """ + Get the execution mode for analysis modules. + + Parameters + ---------- + exec_mode : str + The execution mode to use. + + Returns + ------- + str + The execution mode to use for the analysis modules. + If it's "batch", it will be changed to "local". + """ + # =====================================================================# + # EXPLANATION # + # =====================================================================# + # This function is called in the analysis-based modules to OVERWRITE + # the mode selected by the user. + # This must be done because the analysis modules do not support being + # executed over the HPC system or the GRID + # + # The function below returns "local" if the user selected either + # `batch` or `grid` as execution mode. Thus effectively forcing the + # execution to be local. + return "local" if mode in ("batch", "grid") else mode diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ccf3cd8b0db9ac8b1a1db16a6c6b92ed413948e4 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/alascan/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/alascan/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7c73aabb5fb3aa07db2be3a6dd0c50de1dbbdae3 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/alascan/__init__.py @@ -0,0 +1,205 @@ +""" +HADDOCK3 module for alanine scan. + +This module is responsible for the alanine (or any other residue) scan analysis +of the model(s) generated in the previous step of the workflow. +For each model, this module will mutate the interface residues and calculate +the differences in the haddock score and its individual components between the +wild type and the mutant, thus providing a measure of the impact of such mutation. +Such difference (delta_score) is always calculated as: + + delta_score = score_wildtype - score_mutant + +Therefore, a _positive_ delta_score indicates that the mutation is destabilizing +while a _negative_ delta_score indicates that the mutation is stabilizing. + +If cluster information is available, the module will also calculate the +average haddock score difference for each cluster of models. For each amino acid, +a Z score is calculated as: + + Z = (delta_score - mean) / std + +where mean and std are the mean and standard deviation of the delta_score over +all the amino acids. + +The module will also generate plots of the alanine scan data, showing the +distribution of the delta_score (and every component) for each amino acid at the +interface. + +You can use the parameters below to customize the behavior of the module: + + * `chains`: list of chains to be considered for the alanine scan. In some + cases you may want to limit the analysis to a single chain. + * `output_mutants`: if True, the module will output the models with the + mutations applied (only possible if there is only one model) + * `output_bfactor`: if True, the module will output the non-mutated models + with the rescaled delta_score in the B-factor column + * `plot`: if True, the module will generate plots of the alanine scan data + * `scan_residue`: the residue to scan (default is 'ALA') + * `resdic`: list of residues to be used for the scanning. An example is: + + >>> resdic_A = [1,2,3,4] + >>> resdic_B = [2,3,4] +""" + +from pathlib import Path + +from haddock import log +from haddock.core.defaults import MODULE_DEFAULT_YAML +from haddock.libs.libparallel import GenericTask +from haddock.modules import BaseHaddockModule, get_engine +from haddock.modules.analysis import get_analysis_exec_mode +from haddock.modules.analysis.alascan.scan import ( + AddDeltaBFactor, + ClusterOutputer, + group_scan_by_cluster, + InterfaceScanner, + write_scan_out, +) + + +RECIPE_PATH = Path(__file__).resolve().parent +DEFAULT_CONFIG = Path(RECIPE_PATH, MODULE_DEFAULT_YAML) + + +class HaddockModule(BaseHaddockModule): + """HADDOCK3 module for alanine scan.""" + + name = RECIPE_PATH.name + + def __init__(self, order, path, *ignore, init_params=DEFAULT_CONFIG, + **everything): + super().__init__(order, path, init_params) + + @classmethod + def confirm_installation(cls): + """Confirm if module is installed.""" + return + + def validate_ouput_mutant_parameter(self, nmodels: int) -> None: + """Validate the output mutant parameter. + + This parameter can be set to True if only one input model is provided, + otherewise we risk to generate too many PDB files. + + Parameters + ---------- + nmodels: int + Number of input models. + """ + if self.params["output_mutants"]: + # output mutants is only possible if there is only one model + if nmodels > 1: + log.warning( + "'output_mutants' parameter is set to True, " + "but more than one model was found. " + "Setting 'output_mutant' parameter to False." + ) + self.params["output_mutants"] = False + + def _run(self): + """Execute module.""" + # Get the models generated in previous step + try: + models = self.previous_io.retrieve_models(individualize=True) + except Exception as e: + self.finish_with_error(e) + + # Compute number of input model + nmodels = len(models) + + # Validate `output_mutant` parameter + self.validate_ouput_mutant_parameter(nmodels) + + # Step1: "get mutations" i.e. get target interface residues per input model + # 1 scan_obj per input model, merged into scan_objects to give to Engine + scan_objects = [ + InterfaceScanner( + mutation_res=self.params["scan_residue"], + model=model, + params=self.params, + library_mode=False, + ) + for model in models + ] + + log.info(f"Scanning {nmodels} models for possible mutations") + exec_mode = get_analysis_exec_mode(self.params["mode"]) + Engine = get_engine(exec_mode, self.params) + engine = Engine(scan_objects) + engine.run() + + # Step2: perform mutations + # Collect all point mutations to be performed + mutation_objects = [] + for mutations_to_perform in engine.results: + if mutations_to_perform: + mutation_objects.extend(mutations_to_perform) + + total_mutations = len(mutation_objects) + log.info(f"Found {total_mutations} mutations") + + if mutation_objects: + # let engine take care of parallelization + engine = Engine(mutation_objects) + engine.run() + + # Organize engine output by model + results_by_model = {} + for result in engine.results: + if result and result.success: + if result.model_id not in results_by_model: + results_by_model[result.model_id] = [] + results_by_model[result.model_id].append(result) + + # Save to .tsv + scan_writter_jobs = [ + GenericTask(write_scan_out, results, model_id) + for model_id, results in results_by_model.items() + ] + engine = Engine(scan_writter_jobs) + engine.run() + + # Generate output models with bfactors if requested + if self.params["output_bfactor"]: + update_with_bfactor_jobs = [] + for model in models: + model_id = model.file_name.removesuffix(".pdb") + try: + model_results = results_by_model[model_id] + except KeyError: + # Case when no data computed for this model + model_results = [] + update_with_bfactor_jobs.append( + AddDeltaBFactor(model, self.path, model_results) + ) + engine = Engine(update_with_bfactor_jobs) + engine.run() + models_to_export = engine.results + self.output_models = models_to_export + else: + # Send models to the next step, no operation is done on them + self.output_models = models + + # Cluster-based analysis + clt_scan, clt_pops = group_scan_by_cluster(models, results_by_model) + alascan_cluster_jobs = [ + ClusterOutputer( + clt_data, + clt_id, + clt_pops[clt_id], + scan_residue=self.params["scan_residue"], + generate_plot=self.params["plot"], + offline=self.params["offline"], + ) + for clt_id, clt_data in clt_scan.items() + ] + engine = Engine(alascan_cluster_jobs) + engine.run() + + else: + log.info("No interface residues found - skipping mutation analysis") + # Send models to the next step, no operation is done on them + self.output_models = models + + self.export_io_models() diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/alascan/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/alascan/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e70a358f0d5c1807718cb7f952fbab2dba03c06e Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/alascan/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/alascan/__pycache__/scan.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/alascan/__pycache__/scan.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bbe9fdc77b493cccc8a0ce888e64a31f26752a51 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/alascan/__pycache__/scan.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/alascan/defaults.yaml b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/alascan/defaults.yaml new file mode 100644 index 0000000000000000000000000000000000000000..649a7ffc5eb6938b1511b579ec0294fa3b17c80a --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/alascan/defaults.yaml @@ -0,0 +1,87 @@ +resdic_: + default: [] + type: list + minitems: 0 + maxitems: 100 + title: List of residues to be mutated + short: List of residues to be mutated. By default all the interface residues are + mutated. + long: List of residues to be mutated. By default all the interface residues are + mutated. resdic_* is an expandable parameter. You can provide resdic_A, + resdic_B, resdic_C, etc, where the last capital letter is the chain + identifier. + group: analysis + explevel: expert +int_cutoff: + default: 5.0 + type: float + min: 1.0 + max: 20. + precision: 3 + title: Distance cutoff (Å) used to define interface contacts. + short: Distance cutoff (Å) used to define interface contacts between two interacting molecules. + long: Distance cutoff (Å) used to define interface contacts between two interacting molecules. + group: analysis + explevel: easy +output_bfactor: + default: false + type: boolean + title: Dump the input models with the rescaled delta_score written in the b-factor column. + short: Dump the input models with the rescaled delta_score written in the b-factor column. + long: Dump the input models with the rescaled delta_score written in the b-factor column. Those files do not contain the mutations, but rather will display the normalized (between 0 and 100) delta HADDOCK score (100 * (delta_score - min_score) / (max_score - min_score)) in the b-factor column. The higher the b-factor, the more favourable (or less unfavourable) the mutation. You can color the PDB files according to this attribute (in pymol, type "spectrum b") + group: analysis + explevel: easy +scan_residue: + default: "ALA" + type: string + minchars: 3 + maxchars: 3 + choices: [ALA, ARG, ASN, ASP, CYS, GLN, GLU, GLY, HIS, ILE, LEU, LYS, MET, PHE, PRO, SER, THR, TRP, TYR, VAL, ALY, ASH, CFE, CSP, CYC, CYF, CYM, DDZ, GLH, HLY, HY3, HYP, M3L, MLY, MLZ, MSE, NEP, PNS, PTR, SEP, TOP, TYP, TYS, CIR] + title: Residue to be used for the scanning + short: Residue to be used for the scanning. The default is alanine. + long: Residue to be used for the scanning. The default is alanine. Use bigger residues at your own risk. + group: analysis + explevel: easy +plot: + default: false + type: boolean + title: Plot scanning data. + short: Plot scanning data. + long: Plot scanning data. + group: analysis + explevel: easy +chains: + default: [] + type: list + minitems: 0 + maxitems: 10 + title: ChainIDs to be considered for the scanning. + short: ChainIDs to be considered for the scanning. + long: ChainIDs to be considered for the scanning. If empty, all the chains will be considered. If not empty, only residues part of the specified chains will be mutated. Do not use this parameter if you are using the resdic_* parameter. + group: analysis + explevel: easy +output_mutants: + default: false + type: boolean + title: Dump the mutated, energy-minimized PDB files. + short: Dump the mutated, energy-minimized PDB files. + long: Dump the mutated, energy-minimized PDB files. As the number of mutants can be very large, this option is allowed only when a single model is provided in input. + group: analysis + explevel: easy +ligand_param_fname: + default: '' + type: file + title: Custom ligand parameter file + short: Ligand parameter file in CNS format + long: Ligand parameter file in CNS format, for any ligand/residues/molecules not supported by default by HADDOCK. + group: 'force field' + explevel: easy +ligand_top_fname: + default: '' + type: file + title: Custom ligand topology file + short: Ligand topology file in CNS format + long: Ligand topology file in CNS format containing the ligand topologies + (atoms, masses, charges, bond definitions...) for any ligand not supported by default by HADDOCK + group: 'force field' + explevel: easy diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/alascan/scan.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/alascan/scan.py new file mode 100644 index 0000000000000000000000000000000000000000..dc7ae060f88bbac148371082df1a382eaaac2ae9 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/alascan/scan.py @@ -0,0 +1,954 @@ +"""alascan module.""" +import os +import io +import shutil +from pathlib import Path +from contextlib import redirect_stdout +from dataclasses import dataclass +from typing import List, Tuple, Dict + +import numpy as np +import pandas as pd + + +from haddock import log +from haddock.core.typing import Any, Optional, Union +from haddock.libs.libalign import get_atoms, load_coords +from haddock.libs.libontology import PDBFile +from haddock.libs.libplots import make_alascan_plot +from haddock.modules.analysis.caprieval.capri import CAPRI +from haddock.clis import cli_score + +ATOMS_TO_BE_MUTATED = ['C', 'N', 'CA', 'O', 'CB'] + +RES_CODES = dict([ + ("CYS", "C"), + ("ASP", "D"), + ("SER", "S"), + ("GLN", "Q"), + ("LYS", "K"), + ("ILE", "I"), + ("PRO", "P"), + ("THR", "T"), + ("PHE", "F"), + ("ASN", "N"), + ("GLY", "G"), + ("HIS", "H"), + ("LEU", "L"), + ("ARG", "R"), + ("TRP", "W"), + ("ALA", "A"), + ("VAL", "V"), + ("GLU", "E"), + ("TYR", "Y"), + ("MET", "M"), + ("ALY", "K"), + ("ASH", "D"), + ("CFE", "C"), + ("CSP", "C"), + ("CYC", "C"), + ("CYF", "C"), + ("CYM", "C"), + ("DDZ", "A"), + ("GLH", "E"), + ("HLY", "P"), + ("HY3", "P"), + ("HYP", "P"), + ("M3L", "K"), + ("MLY", "K"), + ("MLZ", "K"), + ("MSE", "M"), + ("NEP", "H"), + ("PNS", "S"), + ("PTR", "Y"), + ("SEP", "S"), + ("TOP", "T"), + ("TYP", "Y"), + ("TYS", "Y"), + ("CIR", "R"), + ]) + + +@dataclass +class MutationResult: + """Result from a single mutation.""" + model_id: str + chain: str + resid: int + ori_resname: str + target_resname: str + # components of "mutant_scores": score, vdw, elec, desolv, bsa + mutant_scores: Tuple[float, float, float, float, float] + delta_scores: Tuple[float, float, float, float, float] + success: bool + error_msg: Optional[str] = None + + +def mutate(pdb_f, target_chain, target_resid, mut_resname): + """ + Mutate a residue in a PDB file into a different residue. + + Parameters + ---------- + pdb_f : str + Path to the pdb file. + + target_chain : str + Chain of the residue to be mutated. + + target_resid : int + Residue number of the residue to be mutated. + + mut_resname : str + Residue name of the residue to be mutated. + + Returns + ------- + mut_pdb_fname : str + Path to the mutated pdb file. + """ + mut_pdb_l = [] + resname = "" + with open(pdb_f, "r") as fh: + for line in fh.readlines(): + if line.startswith("ATOM"): + chain = line[21] + resid = int(line[22:26]) + atom_name = line[12:16].strip() + if target_chain == chain and target_resid == resid: + if not resname: + resname = line[17:20].strip() + if atom_name in ATOMS_TO_BE_MUTATED: + # mutate + line = line[:17] + mut_resname + line[20:] + mut_pdb_l.append(line) + else: + mut_pdb_l.append(line) + try: + mut_id = f"{RES_CODES[resname]}{target_resid}{RES_CODES[mut_resname]}" + except KeyError: + raise KeyError(f"Could not mutate {resname} into {mut_resname}.") + mut_pdb_fname = Path( + pdb_f.name.replace(".pdb", f"-{target_chain}_{mut_id}.pdb")) + with open(mut_pdb_fname, "w") as fh: + fh.write("".join(mut_pdb_l)) + return mut_pdb_fname + + +def get_score_string( + pdb_f: str, + run_dir: str, + outputpdb: bool = False, + ligand_param_fname: Union[Path, str] = "", + ligand_top_fname: Union[Path, str] = "", + ) -> List[str]: + """Get score output from cli_score.main. + + Parameters + ---------- + pdb_f : str + Path to the pdb file. + run_dir : str + Path to the run directory. + outputpdb : bool, optional + If True, the output, energy-minimized pdb file will be written. + Default is False. + ligand_param_fname : Union[Path, str] + Path to additional parameter file used by CNS. + ligand_top_fname : Union[Path, str] + Path to additional topology file used by CNS. + + Returns + ------- + out : list[str] + List of strings with the score output. + """ + stdout = io.StringIO() + with redirect_stdout(stdout): + cli_score.main( + pdb_f, + run_dir, + full=True, + outputpdb=outputpdb, + ligand_param_fname=ligand_param_fname, + ligand_top_fname=ligand_top_fname, + ) + out = stdout.getvalue().split(os.linesep) + return out + + +def calc_score( + pdb_f: str, + run_dir: str, + outputpdb: bool = False, + ligand_param_fname: Union[Path, str] = "", + ligand_top_fname: Union[Path, str] = "", + ) -> Tuple[float, float, float, float, float]: + """Calculate the score of a model. + + Parameters + ---------- + pdb_f : str + Path to the pdb file. + run_dir : str + Path to the run directory. + outputpdb : bool, optional + If True, the output, energy-minimized pdb file will be written. + Default is False. + ligand_param_fname : Union[Path, str] + Path to additional parameter file used by CNS + ligand_top_fname : Union[Path, str] + Path to additional topology file used by CNS + + Returns + ------- + Tuple[float, float, float, float, float] + All the scores + score : float + Haddock score. + vdw : float + Van der Waals energy. + elec : float + Electrostatic energy. + desolv : float + Desolvation energy. + bsa : float + Buried surface area. + + Raises + ------ + FileNotFoundError + Error when the file could not be located. + """ + scores_strings = get_score_string( + pdb_f, run_dir, + outputpdb=outputpdb, + ligand_param_fname=ligand_param_fname, + ligand_top_fname=ligand_top_fname, + ) + # Loop over lines to search for the score and components + for ln in scores_strings: + if ln.startswith("> HADDOCK-score (emscoring)"): + score = float(ln.split()[-1]) + if ln.startswith("> vdw"): + vdw = float(ln.split("vdw=")[1].split(",")[0]) + elec = float(ln.split("elec=")[1].split(",")[0]) + desolv = float(ln.split("desolv=")[1].split(",")[0]) + bsa = float(ln.split("bsa=")[1].split(",")[0]) + if ln.startswith("> writing") and outputpdb: + outpdb = ln.split()[-1] + # check if the output pdb file exists + if not os.path.exists(outpdb): + raise FileNotFoundError(f"Could not find output pdb file {outpdb}") + return score, vdw, elec, desolv, bsa + + +def add_zscores(df_scan_clt, column='delta_score'): + """Add z-scores to the dataframe. + + Parameters + ---------- + df_scan : pandas.DataFrame + Dataframe with the scan results for the model. + + colunm : str + Column to calculate the z-score. + + Returns + ------- + df_scan : pandas.DataFrame + Dataframe with the z-scores added. + """ + mean_delta = np.mean(df_scan_clt[column]) + std_delta = np.std(df_scan_clt[column]) + if std_delta > 0.0: + df_scan_clt['z_score'] = (df_scan_clt[column] - mean_delta) / std_delta + else: + df_scan_clt['z_score'] = 0.0 + return df_scan_clt + + +class ClusterOutputer(): + """Manage the generation of alascan outputs for cluster-based analysis.""" + def __init__( + self, + cluster_scan_data: Dict[str, Dict[str, Union[float, int]]], + clt_id: str, + clt_population: int, + scan_residue: str = "ALA", + generate_plot: bool = False, + offline: bool = False, + ): + """Initialization function + + Parameters + ---------- + cluster_scan_data : Dict[str, Dict[str, Union[float, int]]] + Dictionary containing alascan data per residue identifier. + clt_id : str + Cluster identifier + clt_population : int + Number of entries in this cluster. + scan_residue : str, optional + Residue scanned, by default "ALA" + generate_plot : bool, optional + Defines if a plot must be generated, by default False + offline : bool, optional + Defines if the plot should be functional offline, by default False + """ + self.cluster_scan_data = cluster_scan_data + self.clt_id = clt_id + self.clt_population = clt_population + self.scanned_residue = scan_residue + self.generate_plot = generate_plot + self.offline = offline + + def run(self) -> str: + """Wrtie cluster alascan output to scan_clt_X.tsv file, + including average and stdard deviation data per residue + and optionally save cluster alascan plots (if generate_plot == True) + + Return + ------ + scan_clt_filename : str + Name of the tsv file written + """ + # Gather all data in a list + clt_data = [] + # Loop over residues + for ident, clt_res_dt in self.cluster_scan_data.items(): + # Split identifier to retrieve residue data + chain = ident.split("-")[0] + resid = int(ident.split("-")[1]) + resname = ident.split("-")[2] + # Compute averages and stddev and hold data. + clt_data.append([ + chain, + resid, + resname, + ident, + np.mean(clt_res_dt['delta_score']), + np.std(clt_res_dt['delta_score']), + np.mean(clt_res_dt['delta_vdw']), + np.std(clt_res_dt['delta_vdw']), + np.mean(clt_res_dt['delta_elec']), + np.std(clt_res_dt['delta_elec']), + np.mean(clt_res_dt['delta_desolv']), + np.std(clt_res_dt['delta_desolv']), + np.mean(clt_res_dt['delta_bsa']), + np.std(clt_res_dt['delta_bsa']), + clt_res_dt['frac_pr'] / self.clt_population, + ]) + df_cols = [ + 'chain', 'resid', 'resname', 'full_resname', + 'delta_score', 'delta_score_std', 'delta_vdw', 'delta_vdw_std', + 'delta_elec', 'delta_elec_std', 'delta_desolv', 'delta_desolv_std', + 'delta_bsa', 'delta_bsa_std', 'frac_pres', + ] + df_scan_clt = pd.DataFrame(clt_data, columns=df_cols) + # adding clt-based Z score + df_scan_clt = add_zscores(df_scan_clt, 'delta_score') + # Sort rows + df_scan_clt.sort_values(by=['chain', 'resid'], inplace=True) + # Generate output CSV data + csv_data = io.StringIO() + df_scan_clt.to_csv( + csv_data, + index=False, + float_format='%.2f', + sep="\t") + csv_data.seek(0) + # Define output csv filepath + scan_clt_filename = f"scan_clt_{self.clt_id}.tsv" + # Write the file + with open(scan_clt_filename, "w") as fout: + # add comment to the file + fout.write(f"{'#' * 80}{os.linesep}") + fout.write(f"# `alascan` cluster results for cluster {self.clt_id}{os.linesep}") # noqa E501 + fout.write(f"# reported values are the average for the cluster{os.linesep}") # noqa E501 + fout.write(f"#{os.linesep}") + fout.write(f"# z_score is calculated with respect to the mean values of all residues{os.linesep}") # noqa E501 + fout.write(f"{'#' * 80}{os.linesep}") + # Write csv data content + fout.write(csv_data.read()) + + # Generate plot + self.gen_alascan_plot(df_scan_clt) + + return scan_clt_filename + + def gen_alascan_plot(self, df_scan_clt: pd.DataFrame) -> None: + """Generate the alascan plot based on provided data. + + Parameters + ---------- + df_scan_clt : pd.DataFrame + The data frame containing the data to be plotted. + """ + # Check if the plot must be generated + if not self.generate_plot: + return + + # Try to plot the data + try: + make_alascan_plot( + df_scan_clt, + self.clt_id, + self.scanned_residue, + offline=self.offline, + ) + except Exception as e: + log.warning( + "Could not create interactive plot. The following error" + f" occurred {e}" + ) + + +class AddDeltaBFactor(): + """Add delta score in bfactor column of a PDB.""" + def __init__( + self, + model: PDBFile, + path: Path, + model_results: List[MutationResult], + ): + """Initialisation function + + Parameters + ---------- + model : PDBFile + PDBfile model to be modified + path : Path + Where to write the new file + """ + self.model = model + self.path = path + self.input_results = model_results + + def run(self) -> PDBFile: + """Perform the addition of delta scores as bfactor in pdb file.""" + self.reorder_results() + # Define new pdb filename + model_fname = self.model.file_name.removesuffix(".pdb") + output_fname = f"{model_fname}_alascan.pdb" + # Add delta_score as a bfactor to the model + self.write_delta_score_to_pdb(output_fname) + # Update attributes of the model + self.model.ori_name = self.model.file_name + self.model.file_name = output_fname + self.model.full_name = output_fname + self.model.rel_path = Path("..", Path(self.path).name, output_fname) + self.model.path = str(Path(".").resolve()) + return self.model + + def write_delta_score_to_pdb(self, output_path: Path) -> Path: + """Add delta scores as b-factors in PDB file. + + Parameters + ---------- + output_path : Path + Path to the pdb file. + + Returns + ------- + output_path : Path + Path to the pdb file with the b-factors added. + """ + # Input pdb file path + input_pdbfile = Path(self.model.path, self.model.file_name) + # Start writting file containing bfactor + with open(input_pdbfile, "r") as fin, open(output_path, "w") as fout: + for line in fin: + if line.startswith("ATOM"): + chain = line[21] + resid = int(line[22:26]) + chain_res_key = f"{chain}-{resid}" + try: + delta_score = self.model_results[chain_res_key] + norm_delta = self.normalize_score(delta_score) + except KeyError: + norm_delta = 0.0 + # Generate the bfactor string + delta_str = f"{norm_delta:.2f}".rjust(6, " ") + # Modify the PDB line + line = line[:60] + delta_str + line[66:] + fout.write(line) + return output_path + + def reorder_results(self) -> None: + """Perform initial data manuputation to simply downstream access. + + Organise mutation results into dictionary, with chain-resid keys + and values delta score (e.g.: {"A-115": 5}), + and determine min and max score within the model to normalize data. + """ + self.model_results: Dict[str, float] = {} + all_delta_scores: List[float] = [] + # Loop over mutation results + for mut_result in self.input_results: + # Create key + chain_res_key = f"{mut_result.chain}-{mut_result.resid}" + # Point delta score value + delta_score = mut_result.delta_scores[0] + # Hold data + self.model_results[chain_res_key] = delta_score + all_delta_scores.append(delta_score) + # Obtain min and max delta score to be able to normalize later + if len(all_delta_scores) >= 1: + self.min_score = min(all_delta_scores) + self.max_score = max(all_delta_scores) + else: + self.min_score = -1 + self.max_score = 1 + + def normalize_score(self, score: float) -> float: + """Normalise the input score based on observed scores for this model + + In case normalisation cannot be performed, returns 50.0 + + Parameters + ---------- + score : float + Input score to be normalized + + Returns + ------- + norm100 : float + Normalized score between 0 and 100 + """ + try: + norm = (score - self.min_score) / (self.max_score - self.min_score) + except ZeroDivisionError: + norm = 0.5 + norm100 = 100 * norm + return norm100 + + +def write_scan_out(results: List[MutationResult], model_id: str) -> None: + """ + Save mutation results per model to tsv file. + + Parameters + ---------- + results : List[MutationResult] + List of mutation results from scanning (comes from MutationResult) + model_id : str + Identifier for the model used in filename. + + Returns + ------- + None + Function saves results to file `scan_{model_id}.tsv`. + + Notes + ----- + If results list is empty, no file is created. + """ + if not results: + print(f"No scan results for model {model_id}") + return + + # Convert scan output to dataframe + scan_data = [] + native_score = None + for result in results: + if result.success: + m_score, m_vdw, m_elec, m_des, m_bsa = result.mutant_scores + d_score, d_vdw, d_elec, d_des, d_bsa = result.delta_scores + + scan_data.append([ + result.chain, result.resid, result.ori_resname, + result.target_resname, m_score, m_vdw, m_elec, m_des, m_bsa, + d_score, d_vdw, d_elec, d_des, d_bsa + ]) + + # Get native score from first result (mutant + delta = native) + if native_score is None: + native_score = result.mutant_scores[0] + result.delta_scores[0] + + if scan_data: + df_columns = ['chain', 'res', 'ori_resname', 'end_resname', + 'score', 'vdw', 'elec', 'desolv', 'bsa', + 'delta_score', 'delta_vdw', 'delta_elec', + 'delta_desolv', 'delta_bsa'] + + df_scan = pd.DataFrame(scan_data, columns=df_columns) + # Compute z-scores + df_scan = add_zscores(df_scan, 'delta_score') + + # Sort by chain id, then by residue id + df_scan.sort_values(by=['chain', 'res'], inplace=True) + + # Get csv data as string + csv_io = io.StringIO() + df_scan.to_csv(csv_io, index=False, float_format="%.2f", sep="\t") + csv_io.seek(0) + # Save to tsv + output_file = f"scan_{model_id}.tsv" + with open(output_file, "w") as fout: + # Write comments at start of the file + fout.write(f"{'#' * 80}{os.linesep}") + fout.write(f"# `alascan` results for {model_id}{os.linesep}") + fout.write(f"#{os.linesep}") + fout.write(f"# native score = {native_score}{os.linesep}") + fout.write(f"#{os.linesep}") + fout.write(f"# z_score is calculated with respect to the other residues{os.linesep}") + fout.write(f"{'#' * 80}{os.linesep}") + # Write csv content + fout.write(csv_io.read()) + + +def group_scan_by_cluster( + models: List[PDBFile], + results_by_model: Dict[str, MutationResult] + ) -> Tuple[ + Dict[str, Dict[str, Dict[str, Union[float, int]]]], + Dict[str, int] + ]: + """Group models alascan data per cluster. + + Parameters + ---------- + models : List[PDBFile] + List of input models + + Returns + ------- + clt_scan : Dict[str, Dict[str, Dict[str, Union[float, int]]]] + Dictionary containing alascan data for each cluster, grouped by + residue identifyer. + clt_pops: Dict[str, int] + Dictionary containing number of entries for each cluster. + """ + # Define holders + clt_scan: Dict[str, Dict[str, Dict[str, Union[float, int]]]] = {} + clt_pops: Dict[str, int] = {} + # Loop over models + for model in models: + # Point cluster id + cl_id = model.clt_id + # unclustered models have cl_id = None + if cl_id is None: + cl_id = "unclustered" + # Initiate key if this cluster id is encountered for the first time + if cl_id not in clt_scan: + clt_scan[cl_id] = {} + clt_pops[cl_id] = 0 + # Increase the population of that cluster + clt_pops[cl_id] += 1 + # Point scan results for this model + model_id = model.file_name.removesuffix(".pdb") + try: + model_scan_dt = results_by_model[model_id] + except KeyError: + pass + # Loop over the mutation results + for mut_result in model_scan_dt: + # Extract data related to residue information + chain = mut_result.chain + res = mut_result.resid + ori_resname = mut_result.ori_resname + # Define unique string identifying this residue + ident = f"{chain}-{res}-{ori_resname}" + # Create variable with appropriate key + if ident not in clt_scan[cl_id].keys(): + clt_scan[cl_id][ident] = { + "delta_score": [], + "delta_vdw": [], + "delta_elec": [], + "delta_desolv": [], + "delta_bsa": [], + "frac_pr": 0, + } + # Add data + delta_scores = mut_result.delta_scores + clt_scan[cl_id][ident]["delta_score"].append(delta_scores[0]) + clt_scan[cl_id][ident]["delta_vdw"].append(delta_scores[1]) + clt_scan[cl_id][ident]["delta_elec"].append(delta_scores[2]) + clt_scan[cl_id][ident]["delta_desolv"].append(delta_scores[3]) + clt_scan[cl_id][ident]["delta_bsa"].append(delta_scores[4]) + clt_scan[cl_id][ident]["frac_pr"] += 1 + return clt_scan, clt_pops + + +class InterfaceScanner: + """Scan interface of a model to get tartget residues and create + corresponding mutation jobs. + """ + + def __init__( + self, + model: Union[str, Path, Any], + mutation_res: str = "ALA", + params: Optional[Dict[str, Any]] = None, + library_mode: bool = True + ) -> None: + """ + Initialize InterfaceScanner for a single model. + + Parameters + ---------- + model : str, Path, or model object + HADDOCK model object (if library_mode = False) or + Path to PDB file (if library mode = True) + mutation_res : str + Target residue for mutation (default: "ALA") + params : dict, optional + Additional parameters for interface detection + (list on top of alascan/__inint__.py) + library_mode : bool + If True, execute mutations sequentially inside InterfaceScanner.run() + If False, just prepare jobs - execution will be taken care of in init.py + of alascan module by haddock Engine + """ + self.model = model + self.mutation_res = mutation_res + self.library_mode = library_mode + self.params = params or {} + self.point_mutations_jobs = [] + self.ligand_param_fname = self.params.get("ligand_param_fname", "") + self.ligand_top_fname = self.params.get("ligand_top_fname", "") + self.filter_resdic = { + key[-1]: value for key, value + in self.params.items() + if key.startswith("resdic") + } + if isinstance(model, PDBFile): + self.model_path = model.rel_path + self.model_id = model.file_name.removesuffix(".pdb") + else: + # for library mode + self.model_path = Path(model) + self.model_id = self.model_path.stem + + def run(self): + """ + Get interface residues and create mutation jobs. + If library_mode=True, also execute the mutations sequentially. + + Returns + ------- + Optional[List[ModelPointMutation]] + List of mutation jobs if library_mode=False, None if library_mode=True + """ + try: + # Calculate native scores + sc_dir = f"haddock3-score-{self.model_id}-{os.getpid()}" + try: + native_scores = calc_score( + self.model_path, + run_dir=sc_dir, + outputpdb=False, + ligand_param_fname=self.ligand_param_fname, + ligand_top_fname=self.ligand_top_fname, + ) + finally: + if os.path.exists(sc_dir): + shutil.rmtree(sc_dir) + + # Load coordinates + atoms = get_atoms(self.model_path) + coords, _chain_ranges = load_coords( + self.model_path, + atoms, + add_resname=True, + ) + + # Determine target residues: get interface, then apply user filers, if given + # Get all interface residues + cutoff = self.params.get("int_cutoff", 5.0) + interface = CAPRI.identify_interface(self.model_path, cutoff=cutoff) + + # get user_chains for the check down the line + user_chains = self.params.get("chains", []) + + # if user defined target residues, check they are in the interface + if self.filter_resdic != {'_': []}: + filtered_interface = {} + for chain in self.filter_resdic: + if chain in interface: + # Search for the intersection of user queried residues and interface residues + user_res_valid = list(set(self.filter_resdic[chain]).intersection(set(interface[chain]))) + # If at least one residue must be analyzed, add it to residues to be scanned + if user_res_valid: + filtered_interface[chain] = user_res_valid + interface = filtered_interface + + # if (user defined target chains) & (no user target residues) - do use user chains + elif user_chains: + interface = { + chain: res + for chain, res in interface.items() + if chain in user_chains + } + + # get all atoms of the model to verifiy residue type down the line + resname_dict = {} + for chain, resid, _atom, resname in coords.keys(): + key = f"{chain}-{resid}" + if key not in resname_dict: + resname_dict[key] = resname + + # Create mutation + output_mutants = self.params.get("output_mutants", False) + for chain in interface: + for res in interface[chain]: + ori_resname = resname_dict[f"{chain}-{res}"] + end_resname = self.mutation_res + # Skip if scan_residue is the same as original + # (e.g. skip ALA->ALA) + if ori_resname != end_resname: + job = ModelPointMutation( + model_path=self.model_path, + model_id=self.model_id, + chain=chain, + resid=res, + ori_resname=ori_resname, + target_resname=end_resname, + native_scores=native_scores, + output_mutants=output_mutants, + ligand_param_fname=self.ligand_param_fname, + ligand_top_fname=self.ligand_top_fname, + ) + self.point_mutations_jobs.append(job) + + # Execute jobs if in library mode + if self.library_mode: + log.info( + f"Executing {len(self.point_mutations_jobs)} " + f"mutations for {self.model_id}" + ) + results = [] + total = len(self.point_mutations_jobs) + + for i, job in enumerate(self.point_mutations_jobs, 1): + log.info( + f"Processing mutation {i}/{total}: " + f"{job.chain}:{job.resid} {job.ori_resname}" + f"->{job.target_resname}" + ) + result = job.run() + results.append(result) + if result.success: + log.info(f"Delta score: {result.delta_scores[0]:.2f}") + else: + log.warning(f"Failed: {result.error_msg}") + + write_scan_out(results, self.model_id) + else: + # return point_mutations_jobs back to alascan/__init__.py + return self.point_mutations_jobs + + except Exception as e: + log.error(f"Failed to scan model {self.model_id}: {e}") + raise + + +class ModelPointMutation: + """Executes a single point mutation.""" + def __init__( + self, + model_path: Path, + model_id: str, + chain: str, + resid: int, + ori_resname: str, + target_resname: str, + native_scores: Tuple[float, float, float, float, float], + output_mutants: bool = False, + ligand_param_fname: Union[Path, str] = "", + ligand_top_fname: Union[Path, str] = "", + ) -> None: + """ + Initialize a single point mutation job. + + Parameters + ---------- + model_path : Path + Path to the PDB file + model_id : str + Identifier for the model + chain : str + Chain identifier + resid : int + Residue number + ori_resname : str + Original residue name + target_resname : str + Target residue name for mutation + native_scores : tuple + Native model scores (score, vdw, elec, desolv, bsa) + output_mutants : bool + Whether to keep mutant PDB files + ligand_param_fname : Union[Path, str] + Path to additional parameter file used by CNS + ligand_top_fname : Union[Path, str] + Path to additional topology file used by CNS + """ + self.model_path = Path(model_path) + self.model_id = model_id + self.chain = chain + self.resid = resid + self.ori_resname = ori_resname + self.target_resname = target_resname + self.native_scores = native_scores + self.output_mutants = output_mutants + self.ligand_param_fname = ligand_param_fname + self.ligand_top_fname = ligand_top_fname + + def run(self): + """Execute the point mutation.""" + mutation_id = f"{self.model_id}_{self.chain}{self.resid}{self.target_resname}" + + try: + # Setup working directory + sc_dir = f"haddock3-score-{mutation_id}" + os.makedirs(sc_dir, exist_ok=True) + + # Perform point mutation on pdb file + mut_pdb = mutate(self.model_path, self.chain, self.resid, self.target_resname) + + # Calculate mutant scores + mutant_scores = calc_score( + mut_pdb, + run_dir=sc_dir, + outputpdb=self.output_mutants, + ligand_param_fname=self.ligand_param_fname, + ligand_top_fname=self.ligand_top_fname, + ) + + # Calculate deltas (native - mutant) + n_score, n_vdw, n_elec, n_des, n_bsa = self.native_scores + m_score, m_vdw, m_elec, m_des, m_bsa = mutant_scores + delta_scores = (n_score - m_score, n_vdw - m_vdw, n_elec - m_elec, + n_des - m_des, n_bsa - m_bsa) + + # Handle output files + em_mut_pdb = Path(f"{mut_pdb.stem}_hs.pdb") + if not self.output_mutants: + # if output_mutants = False, then remove both files + if os.path.exists(mut_pdb): + os.remove(mut_pdb) + if em_mut_pdb.exists(): + os.remove(em_mut_pdb) + else: + # othervise keep energy-minimized pdb + if os.path.exists(em_mut_pdb): + shutil.move(em_mut_pdb, mut_pdb) + # clean up scoring dir + if os.path.exists(sc_dir): + shutil.rmtree(sc_dir) + + return MutationResult( + model_id=self.model_id, chain=self.chain, resid=self.resid, + ori_resname=self.ori_resname, target_resname=self.target_resname, + mutant_scores=mutant_scores, delta_scores=delta_scores, success=True + ) + + except Exception as e: + return MutationResult( + model_id=self.model_id, chain=self.chain, resid=self.resid, + ori_resname=self.ori_resname, target_resname=self.target_resname, + mutant_scores=(0, 0, 0, 0, 0), delta_scores=(0, 0, 0, 0, 0), + success=False, error_msg=str(e) + ) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/caprieval/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/caprieval/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..69e4bcd297543c338b4ca0b482305bd45fb43c25 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/caprieval/__init__.py @@ -0,0 +1,262 @@ +"""Calculate CAPRI metrics for the input models. + +By default the following metrics are calculated: + +- FNAT (fraction of native contacts), namely the fraction of + intermolecular contacts in the docked complex that are also + present in the reference complex. +- IRMSD (interface root mean square deviation), namely the RMSD + of the interface of the docked complex with respect + to the reference complex. +- LRMSD (ligand root mean square deviation), namely the RMSD of the + ligand of the docked complex with respect to the + reference complex upon superposition of the receptor. +- DOCKQ, a measure of the quality of the docked model obtained + by combining FNAT, IRMSD and LRMSD (see + Basu and Wallner 2016, 11 (8), e0161879). +- ILRMSD (interface ligand root mean square deviation), the RMSD of the + ligand of the docked complex with respect to the reference complex + upon superposition of the interface of the receptor. +- GLOBAL_RMSD, the full RMSD between the reference and the model. + +The following files are generated: + +- **capri_ss.tsv**: a table with the CAPRI metrics for each model. +- **capri_clt.tsv**: a table with the CAPRI metrics for each cluster of models (if clustering information is available). +""" + + +from pathlib import Path + +from haddock.core.defaults import MODULE_DEFAULT_YAML +from haddock.core.typing import FilePath, Union +from haddock.libs.libontology import PDBFile +from haddock.libs.libparallel import Scheduler +from haddock.modules import BaseHaddockModule +from haddock.modules.analysis.caprieval.capri import ( + CAPRI, + capri_cluster_analysis, + dump_weights, + extract_data_from_capri_class, + extract_models_best_references, + ) +from pdbtools.pdb_wc import run as pdb_wc +from pdbtools.pdb_splitmodel import run as pdb_splitmodel + + +RECIPE_PATH = Path(__file__).resolve().parent +DEFAULT_CONFIG = Path(RECIPE_PATH, MODULE_DEFAULT_YAML) + + +class HaddockModule(BaseHaddockModule): + """HADDOCK3 module to calculate the CAPRI metrics.""" + + name = RECIPE_PATH.name + + def __init__( + self, + order: int, + path: Path, + init_params: FilePath = DEFAULT_CONFIG, + ) -> None: + super().__init__(order, path, init_params) + + @classmethod + def confirm_installation(cls) -> None: + """Confirm if contact executable is compiled.""" + return + + @staticmethod + def is_nested(models: list[Union[PDBFile, list[PDBFile]]]) -> bool: + for model in models: + if isinstance(model, list): + return True + return False + + def handle_input_reference(self, reference: Path) -> list[Path]: + """Validate the reference file by returning only one model. + + Parameters + ---------- + reference : Path + Path to the input reference structure, possibly containing + an ensemble. + + Returns + ------- + reference or first_model_path : Path + Path to the reference structure to be used downstream. + """ + # Extremly complicated stuff to manage the gathering of the sys.stdout, + # as the pdb_tools.pdb_wc is basically writing on it. + import sys + from io import TextIOWrapper, BytesIO + # Memorize previous sys.stdout + original_stdout = sys.stdout + # setup the new stdout environment + sys.stdout = TextIOWrapper(BytesIO(), sys.stdout.encoding) + + # Count number of models + with open(reference, "r") as fh: + pdb_wc(fh, "m") + # Get output + sys.stdout.seek(0) # Jump to the start + wc_return = sys.stdout.read() # Read output + # Restore original stdout + sys.stdout.close() + sys.stdout = original_stdout + # Parse output + # using here `\n` (and not os.linesep) as it is the output for pdb_wc + for line in wc_return.split("\n"): + if "No. models" in line: + sline = line.strip().split() + nb_models = int(sline[-1]) + break + # Return reference as only one structure present + if nb_models == 1: + return [reference] + + self.log( + f"Multiple structures ({nb_models}) found in reference file. " + "Using all conformations as reference." + ) + # Split models + with open(reference, "r") as ref_in: + pdb_splitmodel(ref_in, "reference_model") + # Gather individual references and sort them + references = sorted( + list(Path(".").glob("reference_model_*.pdb")), + key=lambda k: int(k.stem.split("_")[-1]), + ) + assert len(references) == nb_models, ( + "Issue while splitting references conformation: " + f"{nb_models} detected, {len(references)} generated" + ) + return references + + def get_reference(self, models: list[PDBFile]) -> list[Path]: + """Manage to obtain the reference structure to be used downstream. + + Parameters + ---------- + models : list[PDBFile] + List of input model to be evaluated, among which the best + can serve as reference structure if none provided. + + Returns + ------- + references : list[Path] + List of paths to the reference(s) structure to be used downstream. + """ + if self.params["reference_fname"]: + _reference = Path(self.params["reference_fname"]) + references = self.handle_input_reference(_reference) + else: + self.log( + "No reference structure provided. " + "Using the structure with the lowest score from previous step" + ) + # Sort by score to find the "best" + models.sort() + best_model = models[0] + assert isinstance(best_model, PDBFile), "Best model is not a PDBFile" + best_model_fname = best_model.rel_path + references = [best_model_fname] + return references + + def _run(self) -> None: + """Execute module.""" + # Get the models generated in previous step + if type(self.previous_io) == iter: + _e = "This module cannot come after one that produced an iterable." + self.finish_with_error(_e) + + models = self.previous_io.retrieve_models(individualize=True) + if self.is_nested(models): + raise ValueError( + "CAPRI module cannot be executed after " + "modules that produce a nested list of models." + ) + + # dump previously used weights + dump_weights(self.order) + + # Get reference file + references = self.get_reference(models) + + # Each model is a job; this is not the most efficient way + # but by assigning each model to an individual job + # we can handle scenarios in which the models are hetergoneous + # for example during CAPRI scoring + jobs: list[CAPRI] = [] + # Loop over models + for i, model_to_be_evaluated in enumerate(models, start=1): + # `models_to_be_evaluated` cannot be a list, + # `CAPRI` class is expecting a single model + if isinstance(model_to_be_evaluated, list): + raise ValueError( + "CAPRI module cannot handle a list " + "of `model_to_be_evaluated`" + ) + # Loop over references + for ref_id, reference in enumerate(references, start=1): + jobs.append( + CAPRI( + identificator=i, + model=model_to_be_evaluated, + path=Path("."), + reference=reference, + params=self.params, + ref_id=ref_id, + ) + ) + + engine = Scheduler( + tasks=jobs, + ncores=self.params["ncores"], + max_cpus=self.params["max_cpus"], + ) + engine.run() + + jobs = engine.results + jobs = sorted(jobs, key=lambda capri: capri.identificator) + + # Extract best references per input model + best_ref_jobs = extract_models_best_references(jobs) + + # Write standard capri_ss file + extract_data_from_capri_class( + capri_objects=best_ref_jobs, + output_fname=Path(".", "capri_ss.tsv"), + sort_key=self.params["sortby"], + sort_ascending=self.params["sort_ascending"], + add_reference_id=len(references) > 1, + ) + + # Perform cluster analysis + capri_cluster_analysis( + capri_list=best_ref_jobs, + model_list=models, # type: ignore # ignore this here only if we are checking the return type of `retrieve_models` is not nested!! + output_fname="capri_clt.tsv", + clt_threshold=self.params["clt_threshold"], + # output_count=len(capri_jobs), + sort_key=self.params["sortby"], + sort_ascending=self.params["sort_ascending"], + path=Path("."), + ) + + # In case multiple references are provided, generate an additional file + # containing the information to traceback metrics related to each ref + if len(references) > 1: + extract_data_from_capri_class( + capri_objects=jobs, + output_fname=Path(".", "capri_ss_multiref.tsv"), + sort_key=self.params["sortby"], + sort_ascending=self.params["sort_ascending"], + add_reference_id=True, + ) + + # Send models to the next step, + # no operation is done on them + self.output_models = models # type: ignore # ignore this here only if we are checking the return type of `retrieve_models` is not nested!! + self.export_io_models() diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/caprieval/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/caprieval/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..205c9e2b7f29cf7ce113bf6122fa23f6dd72c398 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/caprieval/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/caprieval/__pycache__/capri.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/caprieval/__pycache__/capri.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9e594d73a966a9e34736f49a34de916702fc0393 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/caprieval/__pycache__/capri.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/caprieval/capri.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/caprieval/capri.py new file mode 100644 index 0000000000000000000000000000000000000000..863e6cf643463eeeac9de54f4a2778bc816e05c1 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/caprieval/capri.py @@ -0,0 +1,1150 @@ +"""CAPRI module.""" + +import copy +import json +import os +import shutil +import tempfile +from itertools import combinations +from math import isnan +from pathlib import Path + + +os.environ["OPENBLAS_NUM_THREADS"] = "1" + +import numpy as np +from pdbtools import pdb_segxchain +from scipy.spatial.distance import cdist + +from haddock import log +from haddock.core.defaults import CNS_MODULES +from haddock.core.typing import ( + Any, + AtomsDict, + FilePath, + Iterable, + NDFloat, + Optional, + ParamDict, + ParamMap, + Union, + ) +from haddock.gear.config import load as read_config +from haddock.libs.libalign import ( + ALIGNError, + calc_rmsd, + centroid, + check_chains, + get_align, + get_atoms, + kabsch, + load_coords, + make_range, + ) +from haddock.libs.libio import write_dic_to_file, write_nested_dic_to_file +from haddock.libs.libontology import PDBFile, PDBPath +from haddock.modules import get_module_steps_folders + + +WEIGHTS = ["w_elec", "w_vdw", "w_desolv", "w_bsa", "w_air"] + + +def get_previous_cns_step(sel_steps: list, st_order: int) -> Union[str, None]: + """ + Get the previous CNS step. + + Parameters + ---------- + run_path : Path + Path to the run folder. + + Returns + ------- + cns_step : str + Name of the CNS step. + """ + # get the previous CNS step + cns_step = None + # just to be careful, remove steps with more than one underscore + sel_steps = [step for step in sel_steps if step.count("_") == 1] + mod = min(st_order - 1, len(sel_steps) - 1) + # loop + while mod > -1: + st_name = sel_steps[mod].split("_")[1] + if st_name in CNS_MODULES: + cns_step = sel_steps[mod] + break + mod -= 1 + + return cns_step + + +def save_scoring_weights(cns_step: str) -> Path: + """Save the scoring weights in a json file. + + Parameters + ---------- + cns_step : str + Name of the CNS step. + + Returns + ------- + scoring_params_fname : Path + Path to the json file. + """ + cns_params = read_config(Path("..", cns_step, "params.cfg")) + key = list(cns_params["final_cfg"].keys())[0] + scoring_pars = {kv: cns_params["final_cfg"][key][kv] for kv in WEIGHTS} + + scoring_params_fname = Path("weights_params.json") + # write json file + with open(scoring_params_fname, "w", encoding="utf-8") as jsonf: + json.dump( + scoring_pars, + jsonf, + indent=4, + ) + return scoring_params_fname + + +def load_contacts( + pdb_f: Union[Path, PDBFile], + cutoff: float = 5.0, + numbering_dic: Optional[dict[str, dict[int, int]]] = None, + model2ref_chain_dict: Optional[dict[str, str]] = None, + keep_hetatm: bool = False, +) -> set[tuple]: + """Load residue-based contacts. + + Parameters + ---------- + pdb_f : PosixPath or :py:class:`haddock.libs.libontology.PDBFile` + PDB file of the model to have its atoms identified + cutoff : float, optional + Cutoff distance for the interface identification. + keep_hetatm : bool + Should HETATM coordinates be considered ? (default False) + + Returns + ------- + set(con_list) : set + set of unique contacts + """ + if isinstance(pdb_f, PDBFile): + pdb_f = pdb_f.rel_path + # get also side chains atoms + atoms = get_atoms(pdb_f, full=True) + ref_coord_dic, _ = load_coords( + pdb_f, + atoms, + numbering_dic=numbering_dic, + model2ref_chain_dict=model2ref_chain_dict, + keep_hetatm=keep_hetatm, + ) + # create coordinate arrays + coord_arrays: dict[str, NDFloat] = {} + coord_ids: dict[str, list[int]] = {} + for atom in ref_coord_dic.keys(): + chain = atom[0] + if chain not in coord_arrays.keys(): # initialize lists + coord_arrays[chain], coord_ids[chain] = [], [] # type: ignore + coord_arrays[chain].append(ref_coord_dic[atom]) # type: ignore + coord_ids[chain].append(atom[1]) # only the resid is appended + for chain in coord_arrays.keys(): + coord_arrays[chain] = np.array(coord_arrays[chain]) + + # combinations of chains + unique_chain_combs = list(combinations(sorted(coord_arrays.keys()), 2)) + + # calculating contacts + con_list: list[tuple] = [] + for pair in unique_chain_combs: + # cycling over each coordinate of the first chain + for s in range(coord_arrays[pair[0]].shape[0]): + s_xyz = coord_arrays[pair[0]][s].reshape(1, 3) + s_cid = coord_ids[pair[0]][s] + dist = cdist(s_xyz, coord_arrays[pair[1]]) + npw = np.where(dist < cutoff) + del dist + for k in range(npw[0].shape[0]): + con = (pair[0], s_cid, pair[1], coord_ids[pair[1]][npw[1][k]]) + con_list.append(con) + return set(con_list) + + +class CAPRI: + """CAPRI class.""" + + def __init__( + self, + identificator: int, + model: PDBPath, + path: Path, + reference: PDBPath, + params: ParamMap, + ref_id: int = 1, + ) -> None: + """ + Initialize the class. + + Parameters + ---------- + identificator : int + The identificator of the object. + model : PosixPath or :py:class:`haddock.libs.libontology.PDBFile` + The model to be evaluated. + path : Path + Reference that defines where output should be saved. + reference : PosixPath or :py:class:`haddock.libs.libontology.PDBFile` + The reference structure. + params : dict + The parameters for the CAPRI evaluation. + """ + self.reference = reference + if not isinstance(model, PDBFile): + self.model = PDBFile(model) + self.md5 = "" + self.score = float("nan") + else: + self.model = model + self.md5 = model.md5 + self.score = model.score + self.path = path + self.params = params + self.irmsd = float("nan") + self.lrmsd = float("nan") + self.ilrmsd = float("nan") + self.fnat = float("nan") + self.dockq = float("nan") + self.rmsd = float("nan") + self.allatoms = params["allatoms"] + self.atoms = self._load_atoms(model, reference, full=self.allatoms) + self.r_chain = params["receptor_chain"] + self.l_chains = params["ligand_chains"] + self.keep_hetatm = params["keep_hetatm"] + self.model2ref_numbering = None + self.model2ref_chain_dict = None + self.output_ss_fname = Path(f"capri_ss_{identificator}.tsv") + self.output_clt_fname = Path(f"capri_clt_{identificator}.tsv") + self.output = self.output_ss_fname + self.identificator = identificator + self.core_model_idx = identificator + self.ref_id = ref_id + + def calc_irmsd(self, cutoff: float = 5.0) -> None: + """Calculate the I-RMSD. + + Parameters + ---------- + cutoff : float + The cutoff distance for the intermolecular contacts. + """ + # Identify reference interface + ref_interface_resdic = self.identify_interface( + self.reference, + cutoff, + keep_hetatm=self.keep_hetatm, + ) + + if len(ref_interface_resdic) == 0: + log.warning("No reference interface found") + else: + # Load interface coordinates + ref_coord_dic, _ = load_coords( + self.reference, + self.atoms, + ref_interface_resdic, + keep_hetatm=self.keep_hetatm, + ) + try: + mod_coord_dic, _ = load_coords( + self.model, + self.atoms, + ref_interface_resdic, + numbering_dic=self.model2ref_numbering, + model2ref_chain_dict=self.model2ref_chain_dict, + keep_hetatm=self.keep_hetatm, + ) + except ALIGNError as alignerror: + log.warning(alignerror) + return + + # Here _coord_dic keys are matched + # and formatted as (chain, resnum, atom) + # we will use atoms that are present in both + P = [] + Q = [] + + for k in ref_coord_dic.keys() & mod_coord_dic.keys(): + ref_xyz = ref_coord_dic[k] + mod_xyz = mod_coord_dic[k] + + Q.append(ref_xyz) + P.append(mod_xyz) + + Q = np.asarray(Q) + P = np.asarray(P) + # write_coords("model.pdb", P) + # write_coords("ref.pdb", Q) + + Q = Q - centroid(Q) + P = P - centroid(P) + U = kabsch(P, Q) + P = np.dot(P, U) + + self.irmsd = calc_rmsd(P, Q) + # write_coords("model_aln.pdb", P) + # write_coords("ref_aln.pdb", Q) + + def calc_lrmsd(self) -> None: + """Calculate the L-RMSD.""" + ref_coord_dic, _ = load_coords( + self.reference, + self.atoms, + keep_hetatm=self.keep_hetatm, + ) + try: + mod_coord_dic, _ = load_coords( + self.model, + self.atoms, + numbering_dic=self.model2ref_numbering, + model2ref_chain_dict=self.model2ref_chain_dict, + keep_hetatm=self.keep_hetatm, + ) + except ALIGNError as alignerror: + log.warning(alignerror) + return + + Q = [] + P = [] + # Note: this MUST be sorted since we will use the indexes to + # separate between receptor and ligand coordinates + intersection = sorted(ref_coord_dic.keys() & mod_coord_dic.keys()) + + chain_ranges: dict[Any, Any] = {} + for i, segment in enumerate(intersection): + chain, _, _ = segment + if chain not in chain_ranges: + chain_ranges[chain] = [] + chain_ranges[chain].append(i) + + chain_ranges = make_range(chain_ranges) + obs_chains = list(chain_ranges.keys()) # observed chains + if len(obs_chains) < 2: + log.warning("Not enough chains for calculating lrmsd") + else: + r_chain, l_chains = check_chains(obs_chains, self.r_chain, self.l_chains) + r_start, r_end = chain_ranges[r_chain] + l_starts = [chain_ranges[_l][0] for _l in l_chains] + l_ends = [chain_ranges[_l][1] for _l in l_chains] + + for k in intersection: + ref_xyz = ref_coord_dic[k] + mod_xyz = mod_coord_dic[k] + + Q.append(ref_xyz) + P.append(mod_xyz) + + Q = np.asarray(Q) + P = np.asarray(P) + + # write_coords("ref_first.pdb", Q) + # write_coords("model_first.pdb", P) + + # get receptor and ligand coordinates + Q_r_first = Q[r_start : r_end + 1] + P_r_first = P[r_start : r_end + 1] + # write_coords("ref_r_first.pdb", Q_r_first) + # write_coords("model_r_first.pdb", P_r_first) + # Q_l_first = Q[l_start: l_end + 1] + # P_l_first = P[l_start: l_end + 1] + # write_coords("ref_l_first.pdb", Q_l_first) + # write_coords("model_l_first.pdb", P_l_first) + + # move to the origin of the receptor + + Q = Q - centroid(Q_r_first) + P = P - centroid(P_r_first) + + # get receptor coordinates + Q_r = Q[r_start : r_end + 1] + P_r = P[r_start : r_end + 1] + # Center receptors and get rotation matrix + # Q_r = Q_r - centroid(Q_r) + # P_r = P_r - centroid(P_r) + # write_coords("ref_r_centr.pdb", Q_r) + # write_coords("model_r_centr.pdb", P_r) + + U_r = kabsch(P_r, Q_r) + + # Apply rotation to complex + # - complex are now aligned by the receptor + P = np.dot(P, U_r) + + # write_coords("ref.pdb", Q) + # write_coords("model.pdb", P) + + # Identify ligand coordinates concatenating all the ligand chains + Q_l = np.empty((0, 3)) + P_l = np.empty((0, 3)) + for l_start, l_end in zip(l_starts, l_ends): + Q_l = np.concatenate((Q_l, Q[l_start : l_end + 1])) + P_l = np.concatenate((P_l, P[l_start : l_end + 1])) + # Q_l = Q[l_start: l_end + 1] + # P_l = P[l_start: l_end + 1] + + # write_coords("ref_l.pdb", Q_l) + # write_coords("model_l.pdb", P_l) + + # Calculate the RMSD of the ligands + self.lrmsd = calc_rmsd(P_l, Q_l) + + def calc_ilrmsd(self, cutoff: float = 10.0) -> None: + """Calculate the Interface Ligand RMSD. + + Parameters + ---------- + cutoff : float + The cutoff distance for the intermolecular contacts. + """ + # Identify interface + ref_interface_resdic = self.identify_interface( + self.reference, + cutoff, + keep_hetatm=self.keep_hetatm, + ) + # Load interface coordinates + + ref_int_coord_dic, _ = load_coords( + self.reference, + self.atoms, + ref_interface_resdic, + keep_hetatm=self.keep_hetatm, + ) + try: + mod_int_coord_dic, _ = load_coords( + self.model, + self.atoms, + ref_interface_resdic, + numbering_dic=self.model2ref_numbering, + model2ref_chain_dict=self.model2ref_chain_dict, + keep_hetatm=self.keep_hetatm, + ) + except ALIGNError as alignerror: + log.warning(alignerror) + return + + # write_coord_dic("ref.pdb", ref_int_coord_dic) + # write_coord_dic("model.pdb", mod_int_coord_dic) + + # find atoms present in both interfaces + Q_int = [] + P_int = [] + common_keys = ref_int_coord_dic.keys() & mod_int_coord_dic.keys() + for k in sorted(common_keys): + ref_xyz = ref_int_coord_dic[k] + mod_xyz = mod_int_coord_dic[k] + + Q_int.append(ref_xyz) + P_int.append(mod_xyz) + + Q_int = np.asarray(Q_int) + P_int = np.asarray(P_int) + + # write_coords("ref.pdb", Q_int) + # write_coords("model.pdb", P_int) + + chain_ranges: dict[Any, Any] = {} + for i, segment in enumerate(sorted(common_keys)): + chain, _, _ = segment + if chain not in chain_ranges: + chain_ranges[chain] = [] + chain_ranges[chain].append(i) + + chain_ranges = make_range(chain_ranges) + obs_chains = list(chain_ranges.keys()) # observed chains + if len(obs_chains) < 2: + log.warning("Not enough chains for calculating ilrmsd") + else: + r_chain, l_chains = check_chains(obs_chains, self.r_chain, self.l_chains) + r_start, r_end = chain_ranges[r_chain] + l_starts = [chain_ranges[l_chain][0] for l_chain in l_chains] + l_ends = [chain_ranges[l_chain][1] for l_chain in l_chains] + + # write_coords("ref.pdb", Q) + # write_coords("model.pdb", P) + + # put system at origin of the receptor interface + Q_r_int = Q_int[r_start : r_end + 1] + P_r_int = P_int[r_start : r_end + 1] + + Q_int = Q_int - centroid(Q_r_int) + P_int = P_int - centroid(P_r_int) + # put interfaces at the origin + + # find the rotation that minimizes the receptor interface rmsd + Q_r_int = Q_int[r_start : r_end + 1] + P_r_int = P_int[r_start : r_end + 1] + + U_int = kabsch(P_r_int, Q_r_int) + P_int = np.dot(P_int, U_int) + # just for checks. + # the interface rmsd for the rec interface should be almost zero + # Q_r_int = Q_int[r_start: r_end + 1] + # P_r_int = P_int[r_start: r_end + 1] + # r_rmsd = calc_rmsd(Q_r_int, P_int[r_start: r_end + 1]) + # print(r_rmsd) + # Identify ligand coordinates concatenating all the ligand chains + Q_l_int = np.empty((0, 3)) + P_l_int = np.empty((0, 3)) + for l_start, l_end in zip(l_starts, l_ends): + Q_l_int = np.concatenate((Q_l_int, Q_int[l_start : l_end + 1])) + P_l_int = np.concatenate((P_l_int, P_int[l_start : l_end + 1])) + # prior to multibody: + # Q_l_int = Q_int[l_start: l_end + 1] + # P_l_int = P_int[l_start: l_end + 1] + # write_coords("ref_l_int_fin.pdb", Q_l_int) + # write_coords("mod_l_int_fin.pdb", P_l_int) + + # # this will be the interface-ligand-rmsd + self.ilrmsd = calc_rmsd(P_l_int, Q_l_int) + + def calc_fnat(self, cutoff: float = 5.0) -> None: + """Calculate the frequency of native contacts. + + Parameters + ---------- + cutoff : float + The cutoff distance for the intermolecular contacts. + """ + ref_contacts = load_contacts( + self.reference, + cutoff, + keep_hetatm=self.keep_hetatm, + ) + if len(ref_contacts) != 0: + try: + model_contacts = load_contacts( + self.model, + cutoff, + numbering_dic=self.model2ref_numbering, # type: ignore + model2ref_chain_dict=self.model2ref_chain_dict, # type: ignore + keep_hetatm=self.keep_hetatm, + ) + except ALIGNError as alignerror: + log.warning(alignerror) + else: + intersection = ref_contacts & model_contacts + self.fnat = len(intersection) / float(len(ref_contacts)) + else: + log.warning("No reference contacts found") + + def calc_global_rmsd(self) -> None: + """Calculate the full structure RMSD.""" + # Load reference atomic coordinates + ref_coord_dic, _ = load_coords( + self.reference, + self.atoms, + keep_hetatm=self.keep_hetatm, + ) + # Load model atomic coordinates + try: + model_coord_dic, _ = load_coords( + self.model, + self.atoms, + numbering_dic=self.model2ref_numbering, + model2ref_chain_dict=self.model2ref_chain_dict, + keep_hetatm=self.keep_hetatm, + ) + except ALIGNError as alignerror: + log.warning(alignerror) + return + # Obtain list of coordinates + Q = [] + P = [] + for k in ref_coord_dic.keys() & model_coord_dic.keys(): + ref_xyz = ref_coord_dic[k] + mod_xyz = model_coord_dic[k] + Q.append(ref_xyz) + P.append(mod_xyz) + # Cast indo array + Q = np.asarray(Q) + P = np.asarray(P) + # Center to 0 + Q = Q - centroid(Q) + P = P - centroid(P) + # Obtain rotation matrix + U = kabsch(P, Q) + # Rotate model (the actual superimposition) + P = np.dot(P, U) + # Compute full RMSD + self.rmsd = calc_rmsd(P, Q) + + def calc_dockq(self) -> None: + """Calculate the DockQ metric.""" + self.dockq = 0.0 + if self.fnat: + self.dockq += float(self.fnat) / 3 + if self.irmsd: + irmsd_denom = 1 + (self.irmsd / 1.5) * (self.irmsd / 1.5) + self.dockq += (1 / irmsd_denom) / 3 + if self.lrmsd: + lrmsd_denom = 1 + (self.lrmsd / 8.5) * (self.lrmsd / 8.5) + self.dockq += (1 / lrmsd_denom) / 3 + + def has_cluster_info(self) -> bool: + """ + Check wether this object contains cluster information. + + Returns + ------- + bool + True if this object contains cluster information. + """ + has_cluster_info = False + if self.model.clt_id: + has_cluster_info = True + return has_cluster_info + + def run(self) -> Union[None, "CAPRI"]: + """Get the CAPRI metrics.""" + try: + align_func = get_align( + method=self.params["alignment_method"], + lovoalign_exec=self.params["lovoalign_exec"], + keep_hetatm=self.keep_hetatm, + ) + self.model2ref_numbering, self.model2ref_chain_dict = align_func( + self.reference, self.model, self.path + ) + except ALIGNError: + log.warning( + f"Alignment failed between {self.reference} " + f"and {self.model}, skipping..." + ) + return + # print(f"model2ref_numbering {self.model2ref_numbering}") + # print(f"model2ref_chain_dict {self.model2ref_chain_dict}") + if self.params["fnat"]: + fnat_cutoff = self.params["fnat_cutoff"] + self.calc_fnat(cutoff=fnat_cutoff) + + if self.params["irmsd"]: + irmsd_cutoff = self.params["irmsd_cutoff"] + self.calc_irmsd(cutoff=irmsd_cutoff) + + if self.params["lrmsd"]: + self.calc_lrmsd() + + if self.params["ilrmsd"]: + ilrmsd_cutoff = self.params["irmsd_cutoff"] + self.calc_ilrmsd(cutoff=ilrmsd_cutoff) + + if self.params["dockq"]: + self.calc_dockq() + + if self.params["global_rmsd"]: + self.calc_global_rmsd() + + # The scheduler will use the return of the `run` method as the output of the tasks + return copy.deepcopy(self) + + def __eq__(self, other): + if self.params["dockq"] and \ + not (isnan(self.dockq) or isnan(other.dockq)): + return self.dockq == other.dockq + elif self.params["fnat"] and \ + not (isnan(self.fnat) or isnan(other.fnat)): + return self.fnat == other.fnat + elif self.params["ilrmsd"] and \ + not (isnan(self.ilrmsd) or isnan(other.ilrmsd)): + return self.ilrmsd == other.ilrmsd + elif self.params["lrmsd"] and \ + not (isnan(self.lrmsd) or isnan(other.lrmsd)): + return self.lrmsd == other.lrmsd + elif self.params["irmsd"] and \ + not (isnan(self.irmsd) or isnan(other.irmsd)): + return self.irmsd == other.irmsd + elif self.params["global_rmsd"] and \ + not (isnan(self.rmsd) or isnan(other.rmsd)): + return self.rmsd == other.rmsd + return True + + def __lt__(self, other): + if self.params["dockq"] and \ + not (isnan(self.dockq) or isnan(other.dockq)): + return self.dockq > other.dockq + elif self.params["fnat"] and \ + not (isnan(self.fnat) or isnan(other.fnat)): + return self.fnat > other.fnat + elif self.params["ilrmsd"] and \ + not (isnan(self.ilrmsd) or isnan(other.ilrmsd)): + return self.ilrmsd < other.ilrmsd + elif self.params["lrmsd"] and \ + not (isnan(self.lrmsd) or isnan(other.lrmsd)): + return self.lrmsd < other.lrmsd + elif self.params["irmsd"] and \ + not (isnan(self.irmsd) or isnan(other.irmsd)): + return self.irmsd < other.irmsd + elif self.params["global_rmsd"] and \ + not (isnan(self.rmsd) or isnan(other.rmsd)): + return self.rmsd < other.rmsd + return False + + @staticmethod + def _load_atoms( + model: PDBPath, + reference: PDBPath, + full: bool = False, + ) -> AtomsDict: + """ + Load atoms from a model and reference. + + Parameters + ---------- + model : PosixPath or :py:class:`haddock.libs.libontology.PDBFile` + PDB file of the model to have its atoms identified + reference : PosixPath or :py:class:`haddock.libs.libontology.PDBFile` + PDB file of the model to have its atoms identified + full : bool + If False, only backbone atoms will be retrieved, otherwise all atoms + + Returns + ------- + atom_dic : dict + Dictionary containing atoms observed in model and reference + """ + model_atoms = get_atoms(model, full=full) + reference_atoms = get_atoms(reference, full=full) + atoms_dict: AtomsDict = {} + atoms_dict.update(model_atoms) + atoms_dict.update(reference_atoms) + return atoms_dict + + @staticmethod + def identify_interface( + pdb_f: PDBPath, + cutoff: float = 5.0, + keep_hetatm: bool = False, + ) -> dict[str, list[int]]: + """Identify the interface. + + Parameters + ---------- + pdb_f : PosixPath or :py:class:`haddock.libs.libontology.PDBFile` + PDB file of the model to have its atoms identified + cutoff : float, optional + Cutoff distance for the interface identification. + keep_hetatm : bool + Should HETATM coordinates be considered ? (default False) + + Returns + ------- + interface_resdic : dict[str, list[int]] + Dictionary holding list of interface residues ids for each chains. + """ + if isinstance(pdb_f, PDBFile): + pdb_f = pdb_f.rel_path + + interface_resdic: dict[str, list[int]] = {} + contacts = load_contacts(pdb_f, cutoff, keep_hetatm=keep_hetatm) + + for contact in contacts: + first_chain, first_resid, sec_chain, sec_resid = contact + + if first_chain not in interface_resdic: + interface_resdic[first_chain] = [] + if sec_chain not in interface_resdic: + interface_resdic[sec_chain] = [] + + if first_resid not in interface_resdic[first_chain]: + interface_resdic[first_chain].append(first_resid) + if sec_resid not in interface_resdic[sec_chain]: + interface_resdic[sec_chain].append(sec_resid) + + return interface_resdic + + @staticmethod + def add_chain_from_segid(pdb_path: PDBPath) -> Path: + """ + Replace the chainID with the segID. + + Parameters + ---------- + pdb_path : PosixPath or :py:class:`haddock.libs.libontology.PDBFile` + PDB file to be replaced + """ + if isinstance(pdb_path, PDBFile): + pdb_path = pdb_path.rel_path + temp_f = tempfile.NamedTemporaryFile(delete=False, mode="w+t") + with open(pdb_path) as fh: + for line in list(pdb_segxchain.run(fh)): + temp_f.writelines(line) + temp_f.close() + # REPLACE! + new_pdb_path = shutil.move(temp_f.name, pdb_path) + return new_pdb_path + + +def rank_according_to_score( + data: dict[int, ParamDict], sort_key: str, sort_ascending: bool +) -> dict[int, ParamDict]: + """ + Ranks a dictionary of data based on a specified sort key and sort order, + and assigns a rank to each entry based on its 'score' attribute. + + Args: + data (dict[int, ParamDict]): Dictionary where each key is an index and each + value is a ParamDict containing data attributes. + sort_key (str): Key by which to sort the data within the ParamDict. + Must correspond to a valid attribute in ParamDict. + sort_ascending (bool): If True, sorts the data in ascending order based on + the sort_key; if False, sorts in descending order. + + Returns: + dict[int, ParamDict]: A new dictionary where entries are sorted according + to the sort_key and optionally sorted order. Each entry + also includes a 'caprieval_rank' attribute indicating + its rank based on the 'score'. + """ + score_rankkey_values = [(k, v["score"]) for k, v in data.items()] + score_rankkey_values.sort(key=lambda x: x[1]) + + for i, k in enumerate(score_rankkey_values): + data_idx, _ = k + data[data_idx]["caprieval_rank"] = i + 1 + + # Sort according to the sort key + rankkey_values = [(k, v[sort_key]) for k, v in data.items()] + rankkey_values.sort( + key=lambda x: x[1], + reverse=True if not sort_ascending else False, + ) + + _data = {} + for i, (data_idx, _) in enumerate(rankkey_values): + _data[i + 1] = data[data_idx] + data = _data + + return _data + + +def extract_models_best_references(capri_objects: list[CAPRI]) -> list[CAPRI]: + """Extract best reference for each input model. + + Same input models are combined and best reference is later found by + sorting the CAPRI objects. Only the best performing CAPRI object is + kept and returned. + This step was implemented to handle comparisons against multiple refs. + + Parameters + ---------- + capri_objects : list[CAPRI] + List of CAPRI object. + + Returns + ------- + selected_capri_objects : list[CAPRI] + List of selected best CAPIR object for each model. + """ + # Group results by models + by_model_data: dict[int, dict[Path, CAPRI]] = {} + for capri in capri_objects: + model_data = by_model_data.setdefault(capri.identificator, []) + model_data.append(capri) + # Finds best performances for each model + selected_capri_objects: list[CAPRI] = [] + # Loop over model referneces performances + for references_perfs in by_model_data.values(): + # Sort them using built in __eq__ and __lt__ CAPRI methods + sorted_perfs = sorted(references_perfs) + # Select first on (best) + best_perf = sorted_perfs[0] + # Hold that guy + selected_capri_objects.append(best_perf) + return selected_capri_objects + + +def extract_data_from_capri_class( + capri_objects: list[CAPRI], + sort_key: str, + sort_ascending: bool, + output_fname: Path, + add_reference_id: bool = False, +) -> Union[dict[int, ParamDict], None]: + """Extracts data attributes from a list of CAPRI objects into a structured + dictionary, optionally sorts the data based on a specified key, and writes + the sorted data to a file. + + Parameters + ---------- + capri_objects : list[CAPRI] + List of CAPRI objects containing data attributes to be extracted. + sort_key : str + Key by which to sort the extracted data. Must correspond to a valid + attribute in the CAPRI object (e.g., 'score', 'irmsd'). + sort_ascending : bool + If True, sorts the data in ascending order based on the sort_key; + if False, sorts in descending order. + output_fname : Path + Path to the output file where the sorted data will be written. + add_reference_id : bool, optional + Should the reference id be added to the capri table?, by default False + + Returns + ------- + ranked_data : Union[dict[int, ParamDict], None] + The sorted and structured data dictionary if successful, + None if no data was processed. + """ + # Retrieve data for each model + data: dict[int, ParamDict] = {} + for i, c in enumerate(capri_objects, start=1): + data[i] = { + "model": c.model, + "md5": c.md5, + "caprieval_rank": None, + "score": c.score, + "irmsd": c.irmsd, + "fnat": c.fnat, + "lrmsd": c.lrmsd, + "ilrmsd": c.ilrmsd, + "dockq": c.dockq, + "rmsd": c.rmsd, + "cluster_id": c.model.clt_id if c.model.clt_id else None, + "cluster_ranking": c.model.clt_rank if c.model.clt_rank else None, + "model-cluster_ranking": ( + c.model.clt_model_rank if c.model.clt_model_rank else None + ), + } + if c.model.unw_energies is not None: + data[i].update(c.model.unw_energies) + if add_reference_id: + data[i]["ref_id"] = c.ref_id + # Sort models + ranked_data = rank_according_to_score( + data, sort_key=sort_key, sort_ascending=sort_ascending + ) + if not ranked_data: + # This means no files have been collected + return + else: + write_nested_dic_to_file(data_dict=ranked_data, output_fname=output_fname) + return ranked_data + + +def calc_stats(data: list) -> tuple[float, float]: + """ + Calculate the mean and stdev. + + Parameters + ---------- + data : list + List of values. + + Returns + ------- + mean : float + Mean of the values. + stdev : float + Standard deviation of the values. + """ + mean = np.mean(data) + stdev = np.std(data) + return mean, stdev + + +# Define dict types +CltData = dict[tuple[Optional[int], Union[int, str, None]], list[tuple[CAPRI, PDBFile]]] + + +def capri_cluster_analysis( + capri_list: Iterable[CAPRI], + model_list: Iterable[PDBFile], + output_fname: FilePath, + clt_threshold: int, + sort_key: str, + sort_ascending: bool, + path: FilePath, +) -> None: + """Consider the cluster results for the CAPRI evaluation.""" + capri_keys = ["irmsd", "fnat", "lrmsd", "dockq", "ilrmsd", "rmsd"] + model_keys = ["air", "bsa", "desolv", "elec", "total", "vdw"] + log.info(f"Rearranging cluster information into {output_fname}") + # get the cluster data + clt_data: CltData = dict(((m.clt_rank, m.clt_id), []) for m in model_list) + + # add models to each cluster + for capri, model in zip(capri_list, model_list): + clt_data[(model.clt_rank, model.clt_id)].append((capri, model)) + + output_dic: dict[int, ParamDict] = {} + + for i, element in enumerate(clt_data): + data: ParamDict = {} + number_of_models_in_cluster = len(clt_data[element]) + # rank, cluster id, number of models in cluster + data["cluster_rank"] = element[0] + data["cluster_id"] = element[1] + data["n"] = number_of_models_in_cluster + if number_of_models_in_cluster < clt_threshold: + # under-evaluated, the mean was divided by a value + # larger than the total number of models in the cluster + data["under_eval"] = "yes" + else: + data["under_eval"] = "-" + # score + try: + score_array = [e[1].score for e in clt_data[element][:clt_threshold]] + data["score"], data["score_std"] = calc_stats(score_array) + except KeyError: + data["score"] = float("nan") + data["score_std"] = float("nan") + + # capri keys + for key in capri_keys: + std_key = f"{key}_std" + try: + key_array = [vars(e[0])[key] for e in clt_data[element][:clt_threshold]] + data[key], data[std_key] = calc_stats(key_array) + except KeyError: + data[key] = float("nan") + data[std_key] = float("nan") + + # model keys + for key in model_keys: + std_key = f"{key}_std" + if clt_data[element][0][1].unw_energies: + try: + key_array = [ + vars(e[1])["unw_energies"][key] + for e in clt_data[element][:clt_threshold] + ] + data[key], data[std_key] = calc_stats(key_array) + except KeyError: + data[key] = float("nan") + data[std_key] = float("nan") + + output_dic[i] = data + + # Rank according to the score + score_rankkey_values = [(key, v["score"]) for key, v in output_dic.items()] + score_rankkey_values.sort(key=lambda x: x[1]) + for i, k in enumerate(score_rankkey_values): + idx, _ = k + output_dic[idx]["caprieval_rank"] = i + 1 + + # Rank according to the sorting key + rankkey_values = [(key, v[sort_key]) for key, v in output_dic.items()] + rankkey_values.sort( + key=lambda x: x[1], + reverse=True if not sort_ascending else False, + ) + + _output_dic = {} + for i, k in enumerate(rankkey_values): + idx, _ = k + _output_dic[i + 1] = output_dic[idx] + output_dic = _output_dic + + output_fname = Path(path, output_fname) + + info_header = "#" * 40 + os.linesep + info_header += "# `caprieval` cluster-based analysis" + os.linesep + info_header += "#" + os.linesep + info_header += f"# > sortby_key={sort_key}" + os.linesep + info_header += f"# > sort_ascending={sort_ascending}" + os.linesep + info_header += f"# > clt_threshold={clt_threshold}" + os.linesep + info_header += "#" + os.linesep + info_header += ( + "# NOTE: if under_eval=yes, it means that there were less models in" + " a cluster than" + os.linesep + ) + info_header += ( + "# clt_threshold, thus these values were under " "evaluated." + os.linesep + ) + info_header += ( + "# You might need to tweak the value of clt_threshold or change" + " some parameters" + os.linesep + ) + info_header += "# in `clustfcc` depending on your " "analysis." + os.linesep + info_header += "#" + os.linesep + info_header += "#" * 40 + + if not data: + # This means there were only "dummy" values + return + else: + write_nested_dic_to_file( + output_dic, + output_fname, + info_header=info_header, + ) + + +class CAPRIError(Exception): + """Raised when something goes wrong with the CAPRI class.""" + + def __init__(self, msg: str = "") -> None: + self.msg = msg + super().__init__(self.msg) + + +def dump_weights(order: int) -> None: + sel_steps = get_module_steps_folders(Path("..")) + cns_step = get_previous_cns_step(sel_steps=sel_steps, st_order=order) + if cns_step: + log.info(f"Found previous CNS step: {cns_step}") + scoring_params_fname = save_scoring_weights(cns_step) + log.info(f"Saved scoring weights to: {scoring_params_fname}") + else: + log.info("No previous CNS step found. Cannot save scoring weights.") + + +# # debug only +# def write_coord_dic(output_name, coord_dic): +# """Add a dummy atom to a PDB file according to a list of coordinates.""" +# with open(output_name, "w") as fh: +# for i, k in enumerate(coord_dic): +# atom_num = f"{i+1}".rjust(4, " ") +# chain, resnum, atom = k +# resnum = int(resnum) +# resnum = f"{resnum}".rjust(3, " ") +# atom_name = f"{atom}".rjust(3, " ") +# x, y, z = coord_dic[k] +# dum_x = f"{x:.3f}".rjust(7, " ") +# dum_y = f"{y:.3f}".rjust(7, " ") +# dum_z = f"{z:.3f}".rjust(7, " ") +# dummy_line = ( +# f"ATOM {atom_num} {atom_name} DUM {chain} {resnum} " +# f" {dum_x} {dum_y} {dum_z} 1.00 1.00 " +# " H " + os.linesep +# ) +# fh.write(dummy_line) + + +# # debug only +# def write_coords(output_name, coor_list): +# """Add a dummy atom to a PDB file according to a list of coordinates.""" +# with open(output_name, "w") as fh: +# for i, dummy_coord in enumerate(coor_list): +# atom_num = f"{i}".rjust(4, " ") +# resnum = f"{i}".rjust(3, " ") +# dum_x = f"{dummy_coord[0]:.3f}".rjust(7, " ") +# dum_y = f"{dummy_coord[1]:.3f}".rjust(7, " ") +# dum_z = f"{dummy_coord[2]:.3f}".rjust(7, " ") +# dummy_line = ( +# f"ATOM {atom_num} H DUM X {resnum} " +# f" {dum_x} {dum_y} {dum_z} 1.00 1.00 " +# " H " + os.linesep +# ) +# fh.write(dummy_line) + + +# # debug only +# def write_pymol_viz(resdic): +# """Write PyMol vizualitation.""" +# for k in resdic: +# reslist = "+".join(map(str, resdic[k])) +# cmd = f"sele {k}, chain {k} and resid {reslist}" +# print(cmd) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/caprieval/defaults.yaml b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/caprieval/defaults.yaml new file mode 100644 index 0000000000000000000000000000000000000000..62821a00e2d48631ff6abf652cc4dfa8bd9f71b3 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/caprieval/defaults.yaml @@ -0,0 +1,209 @@ +reference_fname: + default: '' + type: file + title: Reference structure + short: Structure to be used when calculating the CAPRI metrics. + long: Reference tructure to be used when calculating the CAPRI metrics. + If none is defined then the lowest scoring model is selected by default. + group: analysis + explevel: easy + +irmsd: + default: true + type: boolean + title: Calculate I-RMSD + short: Performs Interface RMSD calculations. + long: Calculates the Interface Root Mean Square Deviation. + This calculate the RMSD of interface backbone atoms after fitting on the interface backbone atoms. + The interface is idenfied based on intermolecular contacts shorter than the defined irmsd_cutoff. + group: analysis + explevel: easy + +fnat: + default: true + type: boolean + title: Calculate FNAT + short: Performs FNAT calculations. + long: Calculates the Fraction of Native Contacts. This evaluates how many contacts observed + in the reference are present in the model. The distance cutoff used to define intermolecular contacts is + defined by the fnat_cutoff parameter. + group: analysis + explevel: easy + +lrmsd: + default: true + type: boolean + title: Calculate L-RMSD + short: Performs Ligand RMSD calculations. + long: Calculates the Ligand Root Mean Square Deviation. This calculation is done by superimposing + the receptors (defined by the receptor_chain parameter) and then evaluating the RMSD on the ligands (defined by the ligand_chains parameter). + Superposition and RMSD calculations are done on backbone heavy atoms. + group: analysis + explevel: easy + +ilrmsd: + default: true + type: boolean + title: Calculate I-L-RMSD + short: Performs Interface Ligand RMSD calculations. + long: Calculates the Interface Ligand Root Mean Square Deviation. This calculation is done by superimposing the model and the target + on the interface backbone atoms of the receptor (defined by the receptor_chain parameter) and calculating the RMSD on all heavy atoms + of the ligand (defined by the ligand_chains parameter). + group: analysis + explevel: easy + +dockq: + default: true + type: boolean + title: Calculate DockQ + short: Evaluate DockQ. + long: Evaluate DockQ. A single continuous quality measure for protein docked models based on the CAPRI criteria, + a combination of i-RMSD, l-RMSD and FNAT value. For details check the DockQ publication `DOI:10.1371/journal.pone.0161879` + group: analysis + explevel: easy + +global_rmsd: + default: true + type: boolean + title: Calculate global RMSD + short: Calculate full structure RMSD. + long: Compute full structure RMSD between reference structure and the model + after superimposition. Note that a sequence alignment is performed to + obtain the mapping between the reference and the model. If the one of + the structure contain a 'small-molecule', we assume that the compared + structure atoms are in the same order. With default parameters `allatoms = false`, only + backbone RMSD will be computed. + group: analysis + explevel: easy + +irmsd_cutoff: + default: 10.0 + type: float + min: 3.0 + max: 20.0 + precision: 3 + title: Distance cutoff (Å) used to define interface residues. + short: Distance cutoff (Å) used to define interface residues based on intermolecular contacts. + long: Distance cutoff (Å) used to define interface residues based on intermolecular contacts. + group: analysis + explevel: easy + +fnat_cutoff: + default: 5.0 + type: float + min: 3.0 + max: 20. + precision: 3 + title: Distance cutoff (Å) used to define interface contacts. + short: Distance cutoff (Å) used to define interface contacts between two interacting molecules. + long: Distance cutoff (Å) used to define interface contacts between two interacting molecules. + group: analysis + explevel: easy + +receptor_chain: + default: A + type: string + minchars: 1 + maxchars: 1 + title: Receptor ChainID + short: Receptor ChainID to be considered for the RMSD calculations. + long: Receptor ChainID to be considered for the RMSD calculations. This determines which chain will be + treated as the receptor for the L-RMSD and for I-L-RMSD. + group: analysis + explevel: easy + +ligand_chains: + default: [] + type: list + minitems: 0 + maxitems: 100 + title: Ligand ChainIDs + short: Ligand ChainIDs to be considered for the RMSD calculations. + long: Ligand ChainIDs to be considered for the RMSD calculations. This determines which chains will be + treated as the ligand for the L-RMSD and for I-L-RMSD. + group: analysis + explevel: easy + +sortby: + default: score + type: string + minchars: 0 + maxchars: 20 + choices: + - score + - irmsd + - lrmsd + - ilrmsd + - fnat + - dockq + title: Sort the structures/clusters in the output file by this value + short: Which value should be used to sort the output. + long: Which value should be used to sort the output, the output table will be sorted accordingly. + group: analysis + explevel: easy + +sort_ascending: + default: true + type: boolean + title: Sort in ascending order + short: Sort in ascending order. + long: Sort in ascending order. + group: analysis + explevel: easy + +alignment_method: + default: sequence + type: string + minchars: 0 + maxchars: 100 + choices: + - structure + - sequence + title: Alignment method used to match the numbering. + short: Which alignment method should be used to match the numbering. + long: Alignment method used to match the numbering. Sequence alignment is haddock3-friendly but might not produce best results + for structures that are too different, for that use + group: analysis + explevel: easy + +lovoalign_exec: + default: '' + type: string + minchars: 0 + maxchars: 200 + title: Location (path) of the LovoAlign executable + short: Location (path) of the LovoAlign executable. + long: Location (path) of the LovoAlign executable. + group: analysis + explevel: easy + +clt_threshold: + default: 4 + type: integer + min: 1 + max: 1000 + title: Threshold (n) used for the average evaluation in the cluster-based output + short: Threshold (n) used for the average evaluation in the cluster-based output. + long: Threshold (n) used for the average evaluation in the cluster-based output. + group: analysis + explevel: easy + +allatoms: + default: false + type: boolean + title: Atoms to be considered during the analysis. + short: Atoms to be considered during the analysis. + long: Atoms to be considered during the analysis. If false (default), only + backbone atoms will be considered, otherwise all the heavy-atoms. + group: analysis + explevel: easy + +keep_hetatm: + default: false + type: boolean + title: HETATM to be considered during the analysis. + short: HETATM to be considered during the analysis. + long: HETATM to be considered during the analysis. If false (default), only + ATOM coordinates lines will be used, otherwise the HETATM from reference will also be used. + group: analysis + explevel: easy \ No newline at end of file diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustfcc/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustfcc/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..fca46cb8644b3bd7b63344a6f38df69020e49f96 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustfcc/__init__.py @@ -0,0 +1,220 @@ +"""Fraction of Common Contacts (FCC) clustering module. + +The module takes the models generated in the previous step and calculates the +contacts between them. Then, the module calculates the FCC matrix and clusters +the models based on their contact similarities. + +For more details please check +*Rodrigues, J. P. et al. +Proteins: Struct. Funct. Bioinform. +80, 1810–1817 (2012)* +""" + +import os +from pathlib import Path + +from haddock import log +from haddock.core.defaults import CONTACT_FCC_EXEC, MODULE_DEFAULT_YAML +from haddock.core.exceptions import ModuleError +from haddock.core.typing import Union +from haddock.libs.libclust import ( + add_cluster_info, + get_cluster_matrix_plot_clt_dt, + plot_cluster_matrix, + rank_clusters, + write_structure_list, + ) +from haddock.libs.libfcc import ( + calculate_pairwise_matrix, + Cluster, + Element, + parse_contact_file, + create_elements, + ) +from haddock.libs.libsubprocess import JobInputFirst +from haddock.modules import BaseHaddockModule, get_engine +from haddock.modules.analysis import get_analysis_exec_mode +from haddock.modules.analysis.clustfcc.clustfcc import ( + get_cluster_centers, + iterate_clustering, + write_clusters, + write_clustfcc_file, + ) + + +RECIPE_PATH = Path(__file__).resolve().parent +DEFAULT_CONFIG = Path(RECIPE_PATH, MODULE_DEFAULT_YAML) + + +class HaddockModule(BaseHaddockModule): + """HADDOCK3 module for clustering with FCC.""" + + name = RECIPE_PATH.name + + def __init__( + self, + order: int, + path: Path, + initial_params: Union[Path, str] = DEFAULT_CONFIG, + ) -> None: + super().__init__(order, path, initial_params) + + @classmethod + def confirm_installation(cls) -> None: + """Confirm if FCC is installed and available.""" + # The FCC binary can be either in the default binary path or in the + if not CONTACT_FCC_EXEC.exists(): + raise ModuleError( + f"CONTACT FCC execultable not found at: {CONTACT_FCC_EXEC}" + ) + + def _run(self) -> None: + """Execute module.""" + # Get the models generated in previous step + models_to_clust = self.previous_io.retrieve_models(individualize=True) + + # Calculate the contacts for each model + log.info("Calculating contacts") + contact_jobs: list[JobInputFirst] = [] + for model in models_to_clust: + pdb_f = Path(model.rel_path) # type: ignore + contact_f = Path(model.file_name.replace(".pdb", ".con")) # type: ignore # noqa : E501 + job = JobInputFirst( + pdb_f, + contact_f, + CONTACT_FCC_EXEC, + self.params["contact_distance_cutoff"], + ) + contact_jobs.append(job) + + exec_mode = get_analysis_exec_mode(self.params["mode"]) + + Engine = get_engine(exec_mode, self.params) + engine = Engine(contact_jobs) + engine.run() + + contact_file_l: list[str] = [] + not_found: list[str] = [] + for job in contact_jobs: + if not job.output.exists(): + # NOTE: If there is no output, most likely the models are not in + # contact there is no way of knowing how many models are not in + # contact, it can be only one, or could be all of them. + not_found.append(job.input.name) + log.warning(f"Contact was not calculated for {job.input.name}") + else: + contact_file_l.append(str(job.output)) + + # Check if any contact file could not be retrieved + if not_found: + # No contacts were calculated, we cannot cluster + self.finish_with_error( + f"Several files were not generated: {not_found}" + ) + + log.info("Calculating the FCC matrix") + parsed_contacts = parse_contact_file( + contact_file_l, + False, + ) + + # Imporant: matrix is a generator object, be careful with it + matrix_gen = calculate_pairwise_matrix( + parsed_contacts, + False, + ) + + # write the matrix to a file, so we can read it afterwards and don't + # need to reinvent the wheel handling this + fcc_matrix_f = Path("fcc.matrix") + matrix = list(matrix_gen) + with open(fcc_matrix_f, "w") as fh: + for data in matrix: + data_str = f"{data[0]} {data[1]} {data[2]:.2f} {data[3]:.3f}" + fh.write(f"{data_str}{os.linesep}") + + # Cluster + log.info("Clustering...") + pool = create_elements( + matrix, + self.params["clust_cutoff"], + self.params["strictness"], + ) + + if not pool: + self.params["min_population"] = 1 + clusters = [Cluster(1, Element(1))] + else: + # iterate clustering until at least one cluster is found + clusters, min_population = iterate_clustering( + pool, + self.params["min_population"], + ) + self.params["min_population"] = min_population + + # Prepare output and read the elements + if clusters: + # Write the clusters + write_clusters(clusters) + + # Get the cluster centers + clt_dic, clt_centers = get_cluster_centers( + clusters, + models_to_clust, + ) + + # ranking clusters + _scores, sorted_score_dic = rank_clusters( + clt_dic, self.params["min_population"], + ) + + # Add this info to the models + self.output_models = add_cluster_info(sorted_score_dic, clt_dic) + + # Write unclustered structures + write_structure_list( + models_to_clust, + self.output_models, + out_fname="clustfcc.tsv", + ) + + write_clustfcc_file( + clusters, clt_centers, clt_dic, self.params, sorted_score_dic + ) + else: + log.warning("No clusters were found") + self.output_models = models_to_clust # type: ignore + + # Draw the matrix + if self.params["plot_matrix"]: + # Obtain final models indices + final_order_idx, labels, cluster_ids = [], [], [] + for pdb in self.output_models: + final_order_idx.append(models_to_clust.index(pdb)) + labels.append(pdb.file_name.replace(".pdb", "")) + cluster_ids.append(pdb.clt_id) + # Get custom cluster data + matrix_cluster_dt, cluster_limits = get_cluster_matrix_plot_clt_dt( + cluster_ids + ) + + # Define output filename + html_matrix_basepath = "fcc_matrix" + # Plot matrix + html_matrixpath = plot_cluster_matrix( + fcc_matrix_f, + final_order_idx, + labels, + dttype="FCC", + diag_fill=1, + output_fname=html_matrix_basepath, + matrix_cluster_dt=matrix_cluster_dt, + cluster_limits=cluster_limits, + ) + if html_matrixpath: + log.info(f"Plotting matrix in {html_matrixpath}") + else: + log.warning("Cluster matrix was not generated") + + # Export models for next module + self.export_io_models() diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustfcc/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustfcc/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fe018d41cd9eae1247444007ba2f02487e7a2683 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustfcc/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustfcc/__pycache__/clustfcc.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustfcc/__pycache__/clustfcc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ed9e5fb1c4b519dfa650024f1dd25a6cbc14e9ae Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustfcc/__pycache__/clustfcc.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustfcc/clustfcc.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustfcc/clustfcc.py new file mode 100644 index 0000000000000000000000000000000000000000..a50e28bed8af3e0f2f4f2527245d3ef3250145b7 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustfcc/clustfcc.py @@ -0,0 +1,209 @@ +"""FCC clustering.""" + +import os +from pathlib import Path + +import numpy as np + +from haddock import log +from haddock.libs.libfcc import ( + Cluster, + cluster_elements, + Element, + output_clusters, + ) + + +def iterate_clustering( + pool: dict[int, Element], + min_population_param: int, + ) -> tuple[list[Cluster], int]: + """ + Iterate over the clustering process until a cluster is found. + + Parameters + ---------- + pool : fcc.Pool + The pool object containing the fcc matrix. + + min_population_param : int + The min_population parameter to start the clustering process. + + Returns + ------- + clusters : list[Cluster] + A list of clusters. + + min_population : int + The min_population used to obtain the clusters. + """ + # Loop from min_population to population == 1 + for min_population in range(min_population_param, 0, -1): + log.info(f"Clustering with min_population={min_population}") + _, clusters = cluster_elements( + pool, + threshold=min_population, + ) + # No clusters found + if not clusters: + log.info("[WARNING] No cluster was found, decreasing min_population!") + # Clusters were generated + else: + break + return clusters, min_population + + +def write_clusters(clusters, out_filename="cluster.out"): + """ + Write the clusters to the cluster.out file. + + Parameters + ---------- + clusters : list + A list of clusters. + + out_filename : str, optional + The name of the output file. The default is "cluster.out". + + Returns + ------- + None + """ + # write the classic output file for compatibility reasons + log.info(f"Saving output to {out_filename}") + cluster_out = Path(out_filename) + with open(cluster_out, "w") as fh: + output_clusters(fh, clusters) + fh.close() + + +def get_cluster_centers(clusters, models_to_cluster): + """ + Get the cluster centers and the cluster dictionary. + + Parameters + ---------- + clusters : list + A list of clusters. + + models_to_cluster : list + A list of models to cluster. + + Returns + ------- + clt_dic : dict + A dictionary containing the clusters. + + clt_centers : dict + A dictionary containing the cluster centers. + """ + clt_dic = {} + clt_centers = {} + # iterate over the clusters + for clt in clusters: + cluster_id = clt.name + cluster_center_id = clt.center.name - 1 + cluster_center_pdb = models_to_cluster[cluster_center_id] + + clt_dic[cluster_id] = [] + clt_centers[cluster_id] = cluster_center_pdb + clt_dic[cluster_id].append(cluster_center_pdb) + # iterate over the models in the cluster + for model in clt.members: + model_id = model.name + model_pdb = models_to_cluster[model_id - 1] + clt_dic[cluster_id].append(model_pdb) + return clt_dic, clt_centers + + +def write_clustfcc_file( + clusters, + clt_centers, + clt_dic, + params, + sorted_score_dic, + output_fname="clustfcc.txt", +): # noqa: E501 + """ + Write the clustfcc.txt file. + + Parameters + ---------- + clusters : list + A list of clusters. + + clt_centers : dict + A dictionary containing the cluster centers. + + clt_dic : dict + A dictionary containing the clusters. + + params : dict + A dictionary containing the clustering parameters. + + sorted_score_dic : list + A list of sorted scores. + + Returns + ------- + None + """ + # Prepare clustfcc.txt + output_str = f"### clustfcc output ###{os.linesep}" + output_str += os.linesep + output_str += f"Clustering parameters {os.linesep}" + output_str += ( + "> contact_distance_cutoff=" + f"{params['contact_distance_cutoff']}A" + f"{os.linesep}" + ) + output_str += f"> clust_cutoff={params['clust_cutoff']}" f"{os.linesep}" + output_str += f"> min_population={params['min_population']}{os.linesep}" + output_str += f"> strictness={params['strictness']}{os.linesep}" + output_str += os.linesep + output_str += ( + "Note: Models marked with * represent the center of the cluster" f"{os.linesep}" + ) + output_str += f"-----------------------------------------------{os.linesep}" + output_str += os.linesep + output_str += f"Total # of clusters: {len(clusters)}{os.linesep}" + + for cluster_rank, _e in enumerate(sorted_score_dic, start=1): + cluster_id, _ = _e + center_pdb = clt_centers[cluster_id] + model_score_l = [(e.score, e) for e in clt_dic[cluster_id]] + model_score_l.sort() + # subset_score_l = [e[0] for e in model_score_l][:min_population] + subset_score_l = [e[0] for e in model_score_l] + subset_score_l = subset_score_l[: params["min_population"]] + top_mean_score = np.mean(subset_score_l) + top_std = np.std(subset_score_l) + output_str += ( + f"{os.linesep}" + "-----------------------------------------------" + f"{os.linesep}" + f"Cluster {cluster_rank} (#{cluster_id}, " + f"n={len(model_score_l)}, " + f"top{params['min_population']}_avg_score = {top_mean_score:.2f} " + f"+-{top_std:.2f})" + f"{os.linesep}" + ) + output_str += os.linesep + output_str += f"clt_rank\tmodel_name\tscore{os.linesep}" + for model_ranking, element in enumerate(model_score_l, start=1): + score, pdb = element + if pdb.file_name == center_pdb.file_name: + output_str += ( + f"{model_ranking}\t{pdb.file_name}\t{score:.2f}\t*" f"{os.linesep}" + ) + else: + output_str += ( + f"{model_ranking}\t{pdb.file_name}\t{score:.2f}" f"{os.linesep}" + ) + output_str += "-----------------------------------------------" f"{os.linesep}" + + log.info("Saving detailed output to clustfcc.txt") + with open(output_fname, "w") as out_fh: + out_fh.write(output_str) + + return diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustfcc/defaults.yaml b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustfcc/defaults.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f5c48a8283caf9b066ca699de482afb87350e771 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustfcc/defaults.yaml @@ -0,0 +1,59 @@ +executable: + default: src/contact_fcc + type: file + title: Relative path to contact_fcc executable. + short: Relative path to contact_fcc executable. + long: As contact_fcc is an external tool, its path must be provided. Basically, this parameter should not be changed, as the tool is downloaded at the same time as haddock3. Nevertheless, one could try to have the contact_fcc tool written in another programming language or whatever. + group: executable + explevel: expert +contact_distance_cutoff: + default: 5.00 + type: float + min: 2.00 + max: 999.99 + precision: 2 + title: Cutoff distance (A) for contact detection. + short: Cutoff distance (A) for contact detection. By default 5.0 Angstroms. + long: Cutoff distance between two atoms for contact detection. By default 5.0 Angstroms. + group: analysis + explevel: easy +clust_cutoff: + default: 0.60 + type: float + min: 0.00 + max: 1.00 + precision: 2 + title: Minimum fraction of common contacts to be considered in a cluster. + short: Minimum fraction of common contacts to be considered in a cluster. By default 0.6. + long: Minimum fraction of common contacts (fcc) to cluster complexes together. Complexes not sharing fraction of common contacts above the `fraction_cutoff` parameter cannot belong to the same cluster. + group: analysis + explevel: easy +min_population: + default: 4 + type: integer + min: 1 + max: 9999 + title: Clustering population threshold. + short: Threshold employed to exclude clusters with less than this number of members. By default 4. + long: Minimum set of grouped complexes to define a cluster. If a potential cluster is composed of less than this number of members, it will be considered as `singleton` and discarded from final clusters. If set to 1, all complexes will be part of a cluster. By default 4. + group: analysis + explevel: easy +strictness: + default: 0.75 + type: float + min: 0.00 + max: 1.00 + precision: 2 + title: Strictness factor. + short: Strictness factor. It's multiplied by the fraction_cutoff to obtain a new cutoff for the second half of the matrix. By default 0.75. + long: Strictness factor. It's multiplied by the fraction_cutoff to obtain a new cutoff for the second half of the matrix. Used to allow for some variability. By default 0.75. + group: analysis + explevel: easy +plot_matrix: + default: false + type: boolean + title: Plot matrix of members + short: Plot matrix of members. By default is false. + long: Plot matrix of members. By default is false. + group: analysis + explevel: easy \ No newline at end of file diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustrmsd/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustrmsd/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8ff94fe3720be21b3bbc4552f3e9208ed21d25fe --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustrmsd/__init__.py @@ -0,0 +1,191 @@ +""" +RMSD clustering module. + +This module takes in input the RMSD matrix calculated in the previous step and +performs a hierarchical clustering procedure on it, leveraging `scipy routines`_ +for this purpose. + +Essentially, the procedure amounts at lumping the input models in a +progressively coarser hierarchy of clusters, called the dendrogram. + +Four parameters can be defined in this context: + +* `linkage`: governs the way clusters are merged together in the creation of + the dendrogram +* `criterion`: defines the prescription to cut the dendrogram and obtain the + desired clusters +* `n_clusters`: number of desired clusters (if `criterion` is `maxclust`). +* `clust_cutoff`: value of distance that separates distinct clusters (if `criterion` is + ``distance``) +* `min_population` : analogously to the `clustfcc` module, it is the minimum number + of models that should be present in a cluster to consider it. If criterion is + `maxclust`, the value is ignored. + +This module passes the path to the RMSD matrix is to the next step of the +workflow through the `rmsd_matrix.json` file, thus allowing to execute several +`clustrmsd` modules (possibly with different parameters) on the same RMSD +matrix. + +.. _scipy routines: https://docs.scipy.org/doc/scipy/reference/cluster.hierarchy.html +""" # noqa: E501 +from pathlib import Path + +from haddock import log +from haddock.core.defaults import MODULE_DEFAULT_YAML +from haddock.core.typing import Union +from haddock.libs.libclust import ( + add_cluster_info, + clustrmsd_tolerance_params, + get_cluster_matrix_plot_clt_dt, + plot_cluster_matrix, + rank_clusters, + write_structure_list, + ) +from haddock.libs.libontology import ModuleIO +from haddock.modules import BaseHaddockModule +from haddock.modules.analysis.clustrmsd.clustrmsd import ( + get_clusters, + get_dendrogram, + get_matrix_path, + iterate_min_population, + order_clusters, + read_matrix, + write_clusters, + write_clustrmsd_file, + ) + +RECIPE_PATH = Path(__file__).resolve().parent +DEFAULT_CONFIG = Path(RECIPE_PATH, MODULE_DEFAULT_YAML) + + +class HaddockModule(BaseHaddockModule): + """HADDOCK3 module for clustering with RMSD.""" + + name = RECIPE_PATH.name + + def __init__( + self, + order: int, + path: Path, + initial_params: Union[Path, str] = DEFAULT_CONFIG, + ) -> None: + super().__init__(order, path, initial_params) + + self.matrix_json = self._load_previous_io("rmsd_matrix.json") + + @classmethod + def confirm_installation(cls) -> None: + """Confirm if contact executable is compiled.""" + return + + def _run(self) -> None: + """Execute module.""" + # Get the models generated in previous step + models = self.previous_io.retrieve_models() + + # Cluster + rmsd_matrix = read_matrix(self.matrix_json.input[0]) + # loading parameters + min_population = self.params["min_population"] + + # getting clusters_list + dendrogram = get_dendrogram(rmsd_matrix, self.params["linkage"]) + + # adjust the parameters + tolerance_param_name, tolerance = clustrmsd_tolerance_params( + self.params, + ) + + log.info( + f"Clustering with {tolerance_param_name} = {tolerance}, " + f"and criterion {self.params['criterion']}" + ) + + cluster_arr = get_clusters( + dendrogram, + tolerance, + self.params["criterion"], + ) + + # when crit == distance, apply clustering min_population + if self.params['criterion'] == "distance": + cluster_arr, min_population = iterate_min_population( + cluster_arr, + self.params['min_population'], + ) + self.params['min_population'] = min_population + + clusters, cluster_arr = order_clusters(cluster_arr) + log.info(f"clusters = {clusters}") + + out_filename = Path('cluster.out') + clt_dic, cluster_centers = write_clusters( + clusters, + cluster_arr, + models, + rmsd_matrix, + out_filename, + centers=True, + ) + + # ranking clusters + score_dic, sorted_score_dic = rank_clusters( + clt_dic, + self.params['min_population'], + ) + + self.output_models = add_cluster_info(sorted_score_dic, clt_dic) + + # Write unclustered structures + write_structure_list( + models, + self.output_models, + out_fname="clustrmsd.tsv", + ) # type: ignore + + write_clustrmsd_file( + clusters, + clt_dic, + cluster_centers, + score_dic, + sorted_score_dic, + self.params, + ) + + # Draw the matrix + if self.params['plot_matrix']: + # Obtain final models indices + final_order_idx, labels, cluster_ids = [], [], [] + for pdb in self.output_models: + final_order_idx.append(models.index(pdb)) + labels.append(pdb.file_name.replace('.pdb', '')) + cluster_ids.append(pdb.clt_id) + # Get custom cluster data + matrix_cluster_dt, cluster_limits = get_cluster_matrix_plot_clt_dt( + cluster_ids + ) + + # Define output filename + html_matrix_basepath = 'rmsd_matrix' + # Plot matrix + html_matrixpath = plot_cluster_matrix( + get_matrix_path(self.matrix_json.input[0]), + final_order_idx, + labels, + dttype='RMSD(Å)', + reverse=True, + diag_fill=0, + output_fname=html_matrix_basepath, + matrix_cluster_dt=matrix_cluster_dt, + cluster_limits=cluster_limits, + ) + if html_matrixpath: + log.info(f"Plotting matrix in {html_matrixpath}") + else: + log.warning("Cluster matrix was not generated") + + self.export_io_models() + # sending matrix to next step of the workflow + matrix_io = ModuleIO() + matrix_io.add(self.matrix_json.input[0]) + matrix_io.save(filename="rmsd_matrix.json") diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustrmsd/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustrmsd/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a0acf3e80165d783dd215e1e02712850ceeb69e2 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustrmsd/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustrmsd/__pycache__/clustrmsd.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustrmsd/__pycache__/clustrmsd.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d46a3147c98624b6fa5b60d3f14a97c11030144c Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustrmsd/__pycache__/clustrmsd.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustrmsd/clustrmsd.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustrmsd/clustrmsd.py new file mode 100644 index 0000000000000000000000000000000000000000..5bd2647937cb94d3d7bca6bcd3732de146c54cd8 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustrmsd/clustrmsd.py @@ -0,0 +1,400 @@ +"""RMSD clustering.""" +import os +from pathlib import Path + +import numpy as np +from scipy.cluster.hierarchy import fcluster, linkage + +from haddock import log +from haddock.libs.libontology import RMSDFile + + +def get_matrix_path(rmsd_matrix: RMSDFile) -> Path: + """From an RMSDFile object returns the rmsd matrix path. + + Parameters + ---------- + rmsd_matrix : :obj:`RMSDFile` + RMSDFile object with the path to the RMSD matrix. + + Returns + ------- + matrix_fpath : Path + Path to the RMSD matrix + + Raises + ------ + TypeError + If input rmsd_matrix is not of type RMSDFile + """ + if not isinstance(rmsd_matrix, RMSDFile): + err = f"{type(rmsd_matrix)} is not a RMSDFile object." + raise TypeError(err) + matrix_fpath = Path(rmsd_matrix.path, rmsd_matrix.file_name) + return matrix_fpath + + +def write_clusters(clusters, cluster_arr, models, rmsd_matrix, out_filename="cluster.out", centers=False): # noqa: E501 + """ + Write the clusters to a file. + + Parameters + ---------- + clusters : list + List of clusters to write. + cluster_arr : np.array + Array with the cluster assignment for each model. + models : list + List of models. + rmsd_matrix : np.array + RMSD matrix. + out_filename : str, optional + Output filename. The default is "cluster.out". + centers : bool, optional + Whether to calculate the cluster centers. The default is False. + + Returns + ------- + clt_dic : :obj:`dict` + Dictionary with the clusters. + + cluster_centers : :obj:`dict` + Dictionary with the cluster ID as key and the cluster center as value. + """ + n_obs = len(cluster_arr) + cluster_centers = {} + # preparing output + clt_dic = {} + log.info(f'Saving output to {out_filename}') + cluster_out = Path(out_filename) + with open(cluster_out, 'w') as fh: + for cl_id in clusters: + if cl_id != -1: + npw = np.where(cluster_arr == cl_id)[0] + clt_dic[cl_id] = [models[n] for n in npw] + fh.write(f"Cluster {cl_id} -> ") + + # find the cluster center + if centers: + clt_center = get_cluster_center(npw, n_obs, rmsd_matrix) + cluster_centers[cl_id] = models[clt_center].file_name + + # write the cluster + for el in npw[:-1]: + fh.write(f"{el + 1} ") + fh.write(f"{npw[-1] + 1}") + fh.write(os.linesep) + + return clt_dic, cluster_centers + + +def read_matrix(rmsd_matrix: RMSDFile) -> np.ndarray: + """ + Read the RMSD matrix. + + Parameters + ---------- + rmsd_matrix : :obj:`RMSDFile` + RMSDFile object with the path to the RMSD matrix. + + Returns + ------- + matrix : :obj:`numpy.ndarray` + Numpy array with the RMSD matrix. + """ + filename = get_matrix_path(rmsd_matrix) + # count lines + nlines = sum(1 for line in open(filename)) + log.info(f"input rmsd matrix has {nlines} entries") + # must be a 1D condensed distance matrix + d = int(np.ceil(np.sqrt(nlines * 2))) + if (d * (d - 1) / 2) != nlines: + err = f"{nlines} is not a valid binomial coefficient" + raise ValueError(err) + if nlines != rmsd_matrix.npairs: + err = f"number of pairs {nlines} != expected ({rmsd_matrix.npairs})" + raise ValueError(err) + # creating and filling matrix obj + matrix = np.zeros((nlines)) + c = 0 + with open(filename, "r") as mf: + for line in mf: + data = line.split() + if len(data) != 3: + raise ValueError(f"line {line} malformed") + else: + matrix[[c]] = float(data[2]) + c += 1 + return np.array(matrix) + + +def get_dendrogram(rmsd_matrix, linkage_type): + """Get and save the dendrogram. + + Parameters + ---------- + rmsd_matrix : :obj:`numpy.ndarray` + Numpy array with the RMSD matrix. + + linkage_type : str + Linkage type for the clustering. + + Returns + ------- + Z : :obj:`numpy.ndarray` + Numpy array with the dendrogram. + """ + Z = linkage(rmsd_matrix, linkage_type) + np.savetxt("dendrogram.txt", Z, fmt='%.5f') + return Z + + +def get_clusters(dendrogram, tolerance, criterion): + """Obtain the clusters.""" + log.info("Clustering dendrogram...") + cluster_arr = fcluster(dendrogram, t=tolerance, criterion=criterion) + return cluster_arr + + +def apply_min_population( + cluster_arr: np.ndarray, + min_population: int, + ) -> np.ndarray: + """ + Apply min_population to cluster list. + + Parameters + ---------- + cluster_arr : np.ndarray + Array of clusters. + min_population : int + min_population value on cluster population. + + Returns + ------- + cluster_arr : np.ndarray + Array of clusters (unclustered structures are labelled with -1) + """ + new_cluster_arr = cluster_arr.copy() + log.info(f"Applying min_population {min_population} to cluster list") + cluster_pops = np.unique(cluster_arr, return_counts=True) + uncl_idx = np.where(cluster_pops[1] < min_population)[0] + invalid_clusters = cluster_pops[0][uncl_idx] + log.info(f"Invalid clusters: {invalid_clusters}") + # replacing invalid clusters with -1 + uncl_models = 0 + for cl_idx, cl_id in enumerate(new_cluster_arr): + if cl_id in invalid_clusters: + new_cluster_arr[cl_idx] = -1 + uncl_models += 1 + log.info(f"min_population applied, {uncl_models} models left unclustered") + return new_cluster_arr + + +def iterate_min_population( + cluster_arr: np.ndarray, + min_population: int, + ) -> np.ndarray: + """ + Find one valid valuster satisfying the min_population parameter. + + Logic: Iterate over the min_population values until we find + at least one valid cluster. + + Parameters + ---------- + cluster_arr : np.ndarray + Array of clusters. + min_population : int + min_population value on cluster population. + + Returns + ------- + new_cluster_arr : np.ndarray + Array of clusters (unclustered structures are labelled with -1) + """ + new_cluster_arr: np.ndarray = np.ndarray([]) + for curr_thr in range(min_population, 0, -1): + log.info(f"Clustering with min_population={curr_thr}") + new_cluster_arr = apply_min_population(cluster_arr, curr_thr) + ncl = len(np.unique(new_cluster_arr)) + if -1 in new_cluster_arr: # contains -1 (unclustered) + ncl -= 1 + # if no clusters found, try with a lower min_population + if ncl == 0: + log.warning(f'No clusters found with min_population={curr_thr}') + else: + break + return new_cluster_arr, curr_thr + + +def cond_index(i: int, j: int, n: int) -> float: + """ + Get the condensed index from two matrix indexes. + + Parameters + ---------- + i : int + Index of the first element. + j : int + Index of the second element. + n : int + Number of observations. + """ + return n * (n - 1) / 2 - (n - i) * (n - i - 1) / 2 + j - i - 1 + + +def get_cluster_center( + npw: np.ndarray, + n_obs: int, + rmsd_matrix: np.ndarray, + ) -> int: + """ + Get the cluster centers. + + Parameters + ---------- + npw: np.ndarray + Indexes of the cluster over cluster_list array + n_obs : int + Number of overall observations (models). + rmsd_matrix : np.ndarray + RMSD matrix. + + Returns + ------- + cluster_center : int + Index of cluster center + """ + intra_cl_distances = {el: 0.0 for el in npw} + + # iterating over the elements of the cluster + for m_idx in range(len(npw)): + npws = npw[m_idx + 1:] + pairs = [int(cond_index(npw[m_idx], npw_el, n_obs)) for npw_el in npws] + for pair_idx in range(len(pairs)): + intra_cl_distances[npw[m_idx]] += rmsd_matrix[pairs[pair_idx]] + intra_cl_distances[npws[pair_idx]] += rmsd_matrix[pairs[pair_idx]] + cluster_center = min(intra_cl_distances, key=intra_cl_distances.get) # type: ignore # noqa : E501 + return cluster_center + + +def write_clustrmsd_file(clusters, clt_dic, cluster_centers, score_dic, sorted_score_dic, params, output_fname='clustrmsd.txt'): # noqa E501 + """ + Write the clustrmsd.txt file. + + Parameters + ---------- + clusters : np.ndarray + Array of clusters. + + clt_dic : dict + Dictionary with the clusters. + + cluster_centers : dict + Dictionary with the cluster centers. + + score_dic : dict + Dictionary with the scores. + + sorted_score_dic : dict + Dictionary with the sorted scores. + + params : dict + Dictionary with the clustering parameters. + + output_fname : str + Output filename. + """ + # Prepare clustrmsd.txt + output_str = f'### clustrmsd output ###{os.linesep}' + output_str += os.linesep + output_str += f'Clustering parameters {os.linesep}' + output_str += f"> linkage_type={params['linkage']}{os.linesep}" + output_str += f"> criterion={params['criterion']}{os.linesep}" + if params['criterion'] == "distance": + output_str += f"> clust_cutoff={params['clust_cutoff']:.2f}{os.linesep}" + else: + output_str += f"> n_clusters={params['n_clusters']}{os.linesep}" + output_str += f"> min_population={params['min_population']}{os.linesep}" + output_str += os.linesep + + output_str += ( + f"-----------------------------------------------{os.linesep}") + output_str += os.linesep + output_str += f'Total # of clusters: {len(clusters)}{os.linesep}' + for cluster_rank, _e in enumerate(sorted_score_dic, start=1): + cluster_id, _ = _e + + model_score_l = [(e.score, e) for e in clt_dic[cluster_id]] + model_score_l.sort() + top_score = score_dic[cluster_id] + + output_str += ( + f"{os.linesep}" + "-----------------------------------------------" + f"{os.linesep}" + f"Cluster {cluster_rank} (#{cluster_id}, " + f"n={len(model_score_l)}, " + f"top{params['min_population']}_avg_score = {top_score:.2f})" + f"{os.linesep}") + output_str += os.linesep + output_str += f'clt_rank\tmodel_name\tscore{os.linesep}' + for model_ranking, element in enumerate(model_score_l, start=1): + score, pdb = element + output_str += ( + f"{model_ranking}\t{pdb.file_name}\t{score:.2f}" + ) + if cluster_centers: + # is the model the cluster center? + if pdb.file_name == cluster_centers[cluster_id]: + output_str += "\t*" + output_str += (f"{os.linesep}") + output_str += ( + "-----------------------------------------------" + f"{os.linesep}") + log.info('Saving detailed output to clustrmsd.txt') + with open(output_fname, 'w') as out_fh: + out_fh.write(output_str) + + +def order_clusters(cluster_arr): + """ + Order the clusters by population. + + The most populated cluster will be assigned the ID 1, the second most + populated the ID 2, and so on. + + Parameters + ---------- + cluster_arr : np.ndarray + Array of clusters. + + Returns + ------- + clusters : list + List of clusters. + + cluster_arr : np.ndarray + Array of clusters. + """ + unique_clusters, cluster_counts = np.unique(cluster_arr, return_counts=True) + + sorted_indices = np.argsort(-cluster_counts) # must use negative to sort ascending + sorted_clusters = unique_clusters[sorted_indices] + + # delete -1 from sorted_clusters if present + sorted_clusters = sorted_clusters[sorted_clusters != -1] + clusters = [] + # for every element of sorted_clusters I want to assign a new ID + # to the elements of cluster_arr that match the order of sorted_clusters + index_dict = {} + for c in sorted_clusters: + # index of cluster_arr where the cluster is equal to c + idx = np.where(cluster_arr == c) + index_dict[c] = idx + # now the assignment + for i, c in enumerate(sorted_clusters): + clusters.append(i + 1) + cluster_arr[index_dict[c]] = i + 1 + return clusters, cluster_arr diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustrmsd/defaults.yaml b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustrmsd/defaults.yaml new file mode 100644 index 0000000000000000000000000000000000000000..c354211cc8ab112cb7dfb9afc682e85ec8cc573b --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/clustrmsd/defaults.yaml @@ -0,0 +1,70 @@ +criterion: + default: "distance" + type: "string" + minchars: 0 + maxchars: 100 + title: Criterion for fcluster + short: Criterion to be used to cut the dendrogram + long: if criterion is maxclust, the dendrogram is cut when a certain number of clusters is formed. If criterion is distance, the dendrogram will be cut based on the value of the cophenetic distance + group: analysis + explevel: expert + choices: + - distance + - maxclust +linkage: + default: "average" + type: "string" + minchars: 0 + maxchars: 100 + title: Linkage type + short: How to lump together clusters in hierarchical clustering + long: check out the full description at https://docs.scipy.org/doc/scipy/reference/generated/scipy.cluster.hierarchy.linkage.html + group: analysis + explevel: expert + choices: + - average + - centroid + - complete + - median + - single + - ward + - weighted +min_population: + default: 4 + type: integer + min: 1 + max: 9999 + title: Clustering population threshold + short: Threshold employed to exclude clusters with less than this number of members. By default 4. + long: Threshold employed to exclude clusters with less than this number of members. By default 4. When criterion is maxclust, this value is ignored. + group: analysis + explevel: easy +clust_cutoff: + default: 7.5 + type: float + min: 0.1 + max: 100 + precision: 3 + title: Clustering cutoff distance + short: Value of cutoff cophenetic distance. + long: Value of cutoff cophenetic distance. When criterion is maxclust, this value is ignored. + group: analysis + explevel: easy +plot_matrix: + default: false + type: boolean + title: Plot matrix of members + short: Plot matrix of members. By default is false. + long: Plot matrix of members. By default is false. + explevel: easy + group: analysis +n_clusters: + default: 4 + type: integer + min: 1 + max: 9999 + title: Number of clusters + short: Number of clusters to be formed + long: Number of clusters to be formed. When criterion is distance, this value is ignored. + group: analysis + explevel: easy \ No newline at end of file diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/contactmap/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/contactmap/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..df328d0df412fa41d17dee8ea1f05056d39e2bed --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/contactmap/__init__.py @@ -0,0 +1,123 @@ +"""Compute contacts between chains in complexes. + +The ``[contactmap]`` module aims at generating heatmaps and chordcharts of +the contacts observed in the input complexes. + +If complexes are clustered, the analysis of contacts will be performed +based on all structures from each cluster. + +**Heatmaps** are describing the probability of contacts (<5A) between two +residues (both intramolecular and intermolecular). + +**Chordcharts** are describing only intermolecular contacts in circles, +connecting with *chords* the two residues that are contacting. +""" + +from copy import deepcopy +from pathlib import Path + +from haddock.core.defaults import MODULE_DEFAULT_YAML +from haddock.core.typing import Any, FilePath, SupportsRunT +from haddock.modules import BaseHaddockModule +from haddock.modules import get_engine +from haddock.modules.analysis import get_analysis_exec_mode +from haddock.modules.analysis.contactmap.contmap import ( + ContactsMap, + ClusteredContactMap, + get_clusters_sets, + make_contactmap_report, + topX_models, + ) + + +RECIPE_PATH = Path(__file__).resolve().parent +DEFAULT_CONFIG = Path(RECIPE_PATH, MODULE_DEFAULT_YAML) + + +class HaddockModule(BaseHaddockModule): + """HADDOCK3 module to compute complexes contacts and generate heatmap.""" + + name = RECIPE_PATH.name + + def __init__( + self, + order: int, + path: Path, + *ignore: Any, + init_params: FilePath = DEFAULT_CONFIG, + **everything: Any, + ) -> None: + """Initialize class.""" + super().__init__(order, path, init_params) + + @classmethod + def confirm_installation(cls) -> None: + """Confirm if contact executable is compiled.""" + return + + def _run(self) -> None: + """Execute module.""" + # Get the models generated in previous step + if type(self.previous_io) == iter: + _e = "This module cannot come after one that produced an iterable." + self.finish_with_error(_e) + try: + models = self.previous_io.retrieve_models(individualize=True) + except AttributeError as e: + self.finish_with_error(e) + + # Obtain clusters + clusters_sets = get_clusters_sets(models) + + # Initiate holder of all jobs to be run by the `Scheduler` + contact_jobs: list[SupportsRunT] = [] + # Loop over clusters + for (clust_id, clust_rank), clt_models in clusters_sets.items(): + # In case of unclustered models + if clust_id is None: + # Obtain subset of top models + top_models = topX_models(clt_models, topX=self.params["topX"]) + + # Create single model analysis params + single_models_params = deepcopy(self.params) + single_models_params["single_model_analysis"] = True + + # Loop over models to analyse + for model in top_models: + # Set names + modelfname = Path(model.file_name).stem + jobname = f"Unclustered_{modelfname}" + # Create a contact map object + contmap_job = ContactsMap( + Path(model.rel_path), + Path(jobname), + single_models_params, + ) + contact_jobs.append(contmap_job) + + # For clustered models + else: + # Handles case where clustered models were not scored before + rank_id = "Unranked" if clust_rank is None else clust_rank + # Building basename for the job + name = f"cluster{rank_id}" + # Create a contact map object + contmap_job = ClusteredContactMap( + [Path(model.rel_path) for model in clt_models], + Path(name), + self.params, + ) + contact_jobs.append(contmap_job) + + # Find execution engine + exec_mode = get_analysis_exec_mode(self.params["mode"]) + Engine = get_engine(exec_mode, self.params) + engine = Engine(contact_jobs) + engine.run() + + # Generate report + make_contactmap_report(contact_jobs, "ContactMapReport.html") + + # Send models to the next step, no operation is done on them + self.output_models = models + self.export_io_models() diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/contactmap/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/contactmap/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..33de9f0dd871c4850713a7e0cf07d5f5562833bb Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/contactmap/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/contactmap/__pycache__/contmap.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/contactmap/__pycache__/contmap.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4558c949bb9130e511ca5c2511a7bf869896d6da Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/contactmap/__pycache__/contmap.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/contactmap/contmap.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/contactmap/contmap.py new file mode 100644 index 0000000000000000000000000000000000000000..bf76a924f534b04a311ae3dff13bd73b7ef50055 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/contactmap/contmap.py @@ -0,0 +1,2377 @@ +"""Module computing contact maps of complexes, alone or grouped by cluster. + +Chord diagram functions were adapted from: +https://plotly.com/python/v3/filled-chord-diagram/ +""" + + +import os +import glob +from pathlib import Path + +import numpy as np +import plotly.graph_objs as go +from scipy.spatial.distance import pdist, squareform + +from haddock import log +from haddock.libs.libontology import PDBFile +from haddock.libs.libpdb import ( + slc_name, + slc_resname, + slc_chainid, + slc_resseq, + slc_x, + slc_y, + slc_z, + ) +from haddock.core.typing import ( + Any, + NDFloat, + NDArray, + Optional, + Union, + SupportsRun, + ) +from haddock.libs.libplots import heatmap_plotly, fig_to_html + + +############################### +# Global variable definitions # +############################### +RESIDUE_POLARITY = { + "CYS": "polar", + "HIS": "polar", + "ASN": "polar", + "GLN": "polar", + "SER": "polar", + "THR": "polar", + "TYR": "polar", + "TRP": "polar", + "ALA": "apolar", + "PHE": "apolar", + "GLY": "apolar", + "ILE": "apolar", + "VAL": "apolar", + "MET": "apolar", + "PRO": "apolar", + "LEU": "apolar", + "GLU": "negative", + "ASP": "negative", + "LYS": "positive", + "ARG": "positive", + } +DNA_RNA_POLARITY = { + "A": "negative", + "DA": "negative", + "T": "negative", + "DT": "negative", + "U": "negative", + "DU": "negative", + "C": "negative", + "DC": "negative", + "G": "negative", + "DG": "negative", + } +RESIDUE_POLARITY.update(DNA_RNA_POLARITY) + +PI = np.pi + +# Define interaction types colors +CONNECT_COLORS = { + "polar-polar": (153, 255, 153), + "polar-apolar": (255, 204, 204), + "polar-negative": (255, 204, 153), + "polar-positive": (153, 204, 255), + "apolar-apolar": (255, 255, 0), + "apolar-negative": (255, 229, 204), + "apolar-positive": (204, 229, 255), + "negative-negative": (255, 127, 0), + "negative-positive": (0, 204, 0), + "positive-positive": (255, 127, 0), + } +# Also add reversed keys order +REVERSED_CONNECT_COLORS_KEYS = { + '-'.join(k.split('-')[::-1]): v + for k, v in CONNECT_COLORS.items() + } +CONNECT_COLORS.update(REVERSED_CONNECT_COLORS_KEYS) + +# Colors for each amino-acids +RESIDUES_COLORS = { + "CYS": "rgba(229, 255, 204, 0.80)", + "MET": "rgba(229, 255, 204, 0.80)", + "ASN": "rgba(128, 255, 0, 0.80)", + "GLN": "rgba(128, 255, 0, 0.80)", + "SER": "rgba(153, 255, 51, 0.80)", + "THR": "rgba(153, 255, 51, 0.80)", + "TYR": "rgba(204, 155, 53, 0.80)", + "TRP": "rgba(204, 155, 53, 0.80)", + "HIS": "rgba(204, 155, 53, 0.80)", + "PHE": "rgba(255, 255, 51, 0.80)", + "ALA": "rgba(255, 255, 0, 0.80)", + "ILE": "rgba(255, 255, 0, 0.80)", + "VAL": "rgba(255, 255, 0, 0.80)", + "PRO": "rgba(255, 255, 0 0.80)", + "LEU": "rgba(255, 255, 0, 0.80)", + "GLY": "rgba(255, 255, 255, 0.80)", + "GLU": "rgba(255, 0, 0, 0.80)", + "ASP": "rgba(255, 0, 0, 0.80)", + "LYS": "rgba(0, 0, 255, 0.80)", + "ARG": "rgba(0, 0, 255, 0.80)", + } + +# Colors for DNA / RNA +# Note: Based on WebLogo color scheme +DNARNA_COLORS = { + "A": "rgba(51, 204, 51, 0.80)", + "T": "rgba(204, 0, 0, 0.80)", + "U": "rgba(204, 0, 0, 0.80)", + "C": "rgba(51, 102, 255, 0.80)", + "G": "rgba(255, 163, 26, 0.80)", + } +FULL_DNARNA_COLORS = {f"D{k}": rgba for k, rgba in DNARNA_COLORS.items()} + +# Combine all of them +AA_DNA_RNA_COLORS = {} +AA_DNA_RNA_COLORS.update(RESIDUES_COLORS) +AA_DNA_RNA_COLORS.update(DNARNA_COLORS) +AA_DNA_RNA_COLORS.update(FULL_DNARNA_COLORS) + +# Chain colors +CHAIN_COLORS = [ + 'rgba(51, 255, 51, 0.85)', + 'rgba(51, 153, 255, 0.85)', + 'rgba(255, 153, 51, 0.85)', + 'rgba(255, 255, 51, 0.85)', + 'rgba(255, 0, 0, 0.85)', + 'rgba(255, 0, 127, 0.85)', + 'rgba(0, 255, 0, 0.85)', + 'rgba(0, 0, 255, 0.85)', + 'rgba(0, 153, 0, 0.85)', + ] +CHAIN_COLORS = CHAIN_COLORS[::-1] + + +################## +# Define classes # +################## +class ContactsMap(SupportsRun): + """ContactMap analysis for single structure.""" + + def __init__( + self, + model: Path, + output: Path, + params: dict, + ) -> None: + self.model = model + self.output = output + self.params = params + self.files: dict[str, Union[str, Path]] = {} + + def run(self): + """Process analysis of contacts of a PDB structure.""" + # Load pdb + pdb_dt = extract_pdb_dt(self.model) + # Extract all cordinates + all_coords, resid_keys, resid_dt = get_ordered_coords(pdb_dt) + # Compute distance matrix + full_dist_matrix = compute_distance_matrix(all_coords) + + res_res_contacts = [] + all_heavy_interchain_contacts = [] + # First loop over residues + for ri, reskey_1 in enumerate(resid_keys): + # Second loop over residues (half matrix only) + for _rj, reskey_2 in enumerate(resid_keys[ri + 1:], start=ri + 1): + # Extract data + contact_dt = gen_contact_dt( + full_dist_matrix, + resid_dt, + reskey_1, + reskey_2, + ) + res_res_contacts.append(contact_dt) + + # Extract interchain heavy atoms data + if reskey_2.split('-')[0] == reskey_1.split('-')[0]: + continue + heavy_atoms_contacts = extract_heavyatom_contacts( + full_dist_matrix, + resid_dt, + reskey_1, + reskey_2, + contact_distance=self.params['shortest_dist_threshold'], + ) + all_heavy_interchain_contacts += heavy_atoms_contacts + + # generate outputs for single models + if self.params['single_model_analysis']: + self.generate_output( + res_res_contacts, all_heavy_interchain_contacts, + ) + + return res_res_contacts, all_heavy_interchain_contacts + + def generate_output( + self, + res_res_contacts: list[dict], + all_heavy_interchain_contacts: list[dict], + ) -> None: + """Generate several outputs based on contacts. + + Parameters + ---------- + res_res_contacts : list[dict] + List of residue-residue contacts + all_heavy_interchain_contacts : list[dict] + List of heavy atoms interchain contacts + """ + # write contacts tsv files + header = ['res1', 'res2'] + header += [ + v for v in sorted(res_res_contacts[0]) + if v not in header + ] + fpath = write_res_contacts( + res_res_contacts, + header, + f'{self.output}_contacts.tsv', + interchain_data={ + 'path': f'{self.output}_interchain_contacts.tsv', + 'data_key': 'ca-ca-dist', + 'contact_threshold': self.params['ca_ca_dist_threshold'], + } + ) + log.info(f'Generated contacts file: {fpath}') + self.files['res-res-contacts'] = fpath + + # Genreate corresponding heatmap + if self.params['generate_heatmap']: + heatmap = tsv_to_heatmap( + fpath, + data_key='ca-ca-dist', + contact_threshold=self.params['ca_ca_dist_threshold'], + colorscale=self.params['color_ramp'], + output_fname=f'{self.output}_heatmap.html', + offline=self.params["offline"], + ) + log.info(f'Generated single model heatmap file: {heatmap}') + self.files['res-res-contactmap'] = heatmap + + # Generate corresponding chord chart + if self.params['generate_chordchart']: + # find theshold type + if self.params['chordchart_datatype'] == 'ca-ca-dist': + threshold = self.params['ca_ca_dist_threshold'] + else: + threshold = self.params['shortest_dist_threshold'] + chordp = tsv_to_chordchart( + fpath, + data_key=self.params['chordchart_datatype'], + contact_threshold=threshold, + output_fname=f'{self.output}_chordchart.html', + filter_intermolecular_contacts=True, + title=Path(self.output).stem.replace('_', ' '), + offline=self.params["offline"], + ) + log.info(f'Generated single model chordchart file: {chordp}') + self.files['res-res-chordchart'] = chordp + + # Write interchain heavy atoms contacts tsv file + header2 = ['atom1', 'atom2', 'dist'] + fpath2 = write_res_contacts( + all_heavy_interchain_contacts, + header2, + f'{self.output}_heavyatoms_interchain_contacts.tsv', + ) + log.info(f'Generated contacts file: {fpath2}') + self.files['atom-atom-interchain-contacts'] = fpath2 + + +class ClusteredContactMap(SupportsRun): + """ContactMap analysis for set of clustered structures.""" + + def __init__( + self, + models: list[Path], + output: Path, + params: dict, + ) -> None: + self.models = models + self.output = output + self.params = params + self.files: dict[str, Union[str, Path]] = {} + self.terminated = False + + @staticmethod + def aggregate_contacts( + contacts_holder: dict, + contact_keys: list[str], + contacts: list[dict], + key1: str, + key2: str, + ) -> None: + """Aggregate single models data belonging to a cluster. + + Parameters + ---------- + contacts_holder : dict + Dictionnary holding list of contact data + contact_keys : list[str] + Order of the keys to access the dictionnary + contacts : list[dict] + Singel model contact data. + key1 : str + Name of the key to access first entry in data. + key2 : str + Name of the key to access second entry in data. + """ + # Parse outputs to aggregate contacts in `clusters_contacts` + for cont in contacts: + # Check key + combined_key = f'{cont[key2]}/{cont[key1]}' # resversed + if combined_key not in contacts_holder.keys(): + combined_key = f'{cont[key1]}/{cont[key2]}' # normal + if combined_key not in contacts_holder.keys(): + # Add key order + contact_keys.append(combined_key) + # Initiate key + contacts_holder[combined_key] = { + k: [] + for k in cont.keys() + if k not in [key1, key2] + } + # Add data + for dtk in contacts_holder[combined_key].keys(): + contacts_holder[combined_key][dtk].append(cont[dtk]) + + def run(self): + """Process analysis of contacts of a set of PDB structures.""" + # initiate holding variables + clusters_contacts = {} # Residue-residue contacts + resres_keys_list = [] # Ordered residue-residue contacts keys + clusters_heavyatm_contacts = {} # Interchain atom-atom contacts + atat_keys_list = [] # Ordered interchain atom-atom contacts keys + + # loop over models/structures + for pdb_path in self.models: + # initiate object + contact_map_obj = ContactsMap( + pdb_path, + f'{self.output}_{pdb_path.stem}', + self.params, + ) + # Run it + pdb_contacts, interchain_heavy_contacts = contact_map_obj.run() + + # Parse outputs to aggregate contacts in `clusters_contacts` + self.aggregate_contacts( + clusters_contacts, resres_keys_list, + pdb_contacts, + "res1", "res2", + ) + + # Parse outputs for heavy atoms contacts + self.aggregate_contacts( + clusters_heavyatm_contacts, atat_keys_list, + interchain_heavy_contacts, + "atom1", "atom2", + ) + + # Initiate heavy atoms contact cluster aggrated data + heavy_atm_clust_list = [] + for atatk in atat_keys_list: + at1, at2 = atatk.split('/') + # point corresponding list of distances + h_dists = clusters_heavyatm_contacts[atatk]['dist'] + # Summerize it + heavy_atm_clust_list.append({ + "atom1": at1, + "atom2": at2, + "nb_dists": len(h_dists), + "avg_dist": round(np.mean(h_dists), 2), + "std_dist": round(np.std(h_dists), 2), + }) + # write contacts + header = ['atom1', 'atom2'] + header += [ + v for v in sorted(heavy_atm_clust_list[0]) + if v not in header + ] + hfpath = write_res_contacts( + heavy_atm_clust_list, + header, + f'{self.output}_heavyatoms_interchain_contacts.tsv', + ) + log.info(f'Generated heavy atoms interchain contacts file: {hfpath}') + + # Initiate cluster aggregated data holder + combined_clusters_list = [] + # Loop over ordered keys + for combined_key in resres_keys_list: + # point data + dt = clusters_contacts[combined_key] + + # Compute averages Ca-Ca distances + avg_ca_ca_dist = np.mean(dt['ca-ca-dist']) + # Compute nb. times cluster members holds a value under threshold + ca_ca_under_thresh = [ + v for v in dt['ca-ca-dist'] + if v <= self.params['ca_ca_dist_threshold'] + ] + nb_under = len(ca_ca_under_thresh) + # Compute probability + ca_ca_cont_probability = nb_under / len(dt['ca-ca-dist']) + + # Compute averages for shortest distances + avg_shortest = np.mean(dt['shortest-dist']) + # Generate list of shortest distances observed between two residues + short_under_threshold = [ + v for v in dt['shortest-dist'] + if v <= self.params['shortest_dist_threshold'] + ] + short_nb_und = len(short_under_threshold) + # Compute nb. time the cluster members holds a value under threshold + short_cont_proba = short_nb_und / len(dt['shortest-dist']) + + # Find most representative contact type + cont_ts = list(set(dt['contact-type'])) + # Decreasing sorting of cluster contact types and pick highest one + cont_t = sorted( + cont_ts, + key=lambda k: cont_ts.count(k), + reverse=True, + )[0] + + # Split key to recover resiudes names + res1, res2 = combined_key.split('/') + + # Hold summary data for cluster + combined_clusters_list.append({ + 'res1': res1, + 'res2': res2, + 'ca-ca-dist': round(avg_ca_ca_dist, 1), + 'ca-ca-cont-probability': round(ca_ca_cont_probability, 2), + 'shortest-dist': round(avg_shortest, 1), + 'shortest-cont-probability': round(short_cont_proba, 2), + 'contact-type': cont_t, + }) + + # write contacts + header = ['res1', 'res2'] + header += [ + v for v in sorted(combined_clusters_list[0]) + if v not in header + ] + fpath = write_res_contacts( + combined_clusters_list, + header, + f'{self.output}_contacts.tsv', + interchain_data={ + 'path': f'{self.output}_interchain_contacts.tsv', + 'data_key': 'ca-ca-dist', + 'contact_threshold': self.params['ca_ca_dist_threshold'], + } + ) + log.info(f'Generated contacts file: {fpath}') + self.files['res-res-contacts'] = fpath + self.files['atom-atom-interchain-contacts'] = f'{self.output}_interchain_contacts.tsv' # noqa : E501 + + # Generate corresponding heatmap + if self.params['generate_heatmap']: + heatmap_path = tsv_to_heatmap( + fpath, + data_key=self.params['cluster_heatmap_datatype'], + contact_threshold=1, + colorscale=self.params['color_ramp'], + output_fname=f'{self.output}_heatmap.html', + offline=self.params["offline"], + ) + log.info(f'Generated cluster contacts heatmap: {heatmap_path}') + self.files['res-res-contactmap'] = heatmap_path + + # Generate corresponding chord chart + if self.params['generate_chordchart']: + # find theshold type + if self.params['chordchart_datatype'] == 'ca-ca-dist': + threshold = self.params['ca_ca_dist_threshold'] + else: + threshold = self.params['shortest_dist_threshold'] + chordp = tsv_to_chordchart( + fpath, + data_key=self.params['chordchart_datatype'], + contact_threshold=threshold, + output_fname=f'{self.output}_chordchart.html', + filter_intermolecular_contacts=True, + title=Path(self.output).stem.replace('_', ' '), + offline=self.params["offline"], + ) + log.info(f'Generated cluster contacts chordchart file: {chordp}') + self.files['res-res-chordchart'] = chordp + + self.terminated = True + + +def make_contactmap_report( + contactmap_jobs: list[Union[ContactsMap, ClusteredContactMap]], + outputpath: Union[str, Path], + ) -> Union[str, Path]: + """Generate a HTML navigation page holding all generated files. + + Parameters + ---------- + contact_jobs : list[Union[ClusteredContactMap, ContactsMap]] + All the terminated jobs + outputpath : Union[str, Path] + Output filepath where to write the report. + + Returns + ------- + outputpath: Union[str, Path] + Path to the generated report. + """ + ordered_files = [] + # Loop over terminated jobs + for job in contactmap_jobs: + basepath = f"{job.output}_" + # Gather all files generated by this job + job_files = glob.glob(f"{basepath}*") + + # Sort them by file extension + ext_names: dict[str, Union[str, Path]] = {} + for fpath in job_files: + _fname, ext = os.path.splitext(fpath) + if ext not in ext_names.keys(): + ext_names[ext] = [] + ext_names[ext].append(fpath) + # Sort each keys filepaths + for ext in ext_names.keys(): + ext_names[ext] = sorted( + ext_names[ext], + key=lambda k: k.replace(basepath, ""), + ) + # Get final list order + sorted_jobfiles = [ + fpath + for ext in sorted(ext_names) + for fpath in ext_names[ext] + ] + + # Initiate html links holding list + job_list: list[str] = [] + # Loop over generated files + for fpath in sorted_jobfiles: + # Generate html link + shortname = fpath.replace(basepath, "") + html_string = f'{shortname}' + job_list.append(html_string) + # Combine all links in one string + job_list_combined = ', '.join(job_list) + # Create final string + job_access = f"{job.output}: {job_list_combined}" + # Hold that guy + ordered_files.append(job_access) + + # Combine all jobs outputs as a list + all_access = '\n
  • '.join(ordered_files) + # Generate small html file + htmldt = f""" +
    +
      +
    • + {all_access} +
      • +
    +
    +""" + + # Write it + with open(outputpath, 'w') as reportout: + reportout.write(htmldt) + log.info(f'Generated report file: {outputpath}') + # Return generate outputfilepath + return outputpath + + +def get_clusters_sets( + models: list[PDBFile], + ) -> dict[tuple[Optional[int], Optional[int]], list[PDBFile]]: + """Split models by clusters ids. + + Parameters + ---------- + models : list + List of pdb models/complexes. + + Return + ------ + clust_sets : dict[tuple[Optional[int], Optional[int]], list[PDBFile]] + Dictionary of (cluster ids, cluster rank) keys containing their + respective models as list of PDBFiles. + """ + clust_sets: dict[tuple[Optional[int], Optional[int]], list[PDBFile]] = {} + # Loop over models + for model in models: + # Set key + cluster_key = (model.clt_id, model.clt_rank) + # Create/Gather the corresponding list + cluster_list = clust_sets.setdefault(cluster_key, []) + # Add model + cluster_list.append(model) + return clust_sets + + +def topX_models(models: list[PDBFile], topX: int = 10) -> list[Any]: + """Sort and return subset of top X best models. + + Parameters + ---------- + models : list + List of pdb models/complexes. + topX : int + Number of models to return after sorting. + + Return + ------ + subset_bests : list + List of top `X` best models. + """ + try: + sorted_models = sorted(models, key=lambda m: m.score) + except AttributeError: + sorted_models = models + finally: + subset_bests = sorted_models[:topX] + return subset_bests + + +#################### +# Define functions # +#################### +def extract_pdb_dt(path: Path) -> dict: + """Read and extract ATOM/HETATM records from a pdb file. + + Parameters + ---------- + path : Path + Path to a pdb file. + + Return + ------ + pdb_chains : dict + A dictionary of the pdb file accesible using chains as keys. + """ + pdb_chains: dict = {'chain_order': []} + # Read file + with open(path, 'r') as f: + # Loop over lines + for _ in f: + # Skip non ATOM / HETATM lines + if not any([ + _.startswith('ATOM'), + _.startswith('HETATM'), + ]): + continue + + # Extract residue name + resname = _[slc_resname] + # Extract chain id + chainid = _[slc_chainid] + # Extract resid + resid = _[slc_resseq].strip() + + # Check if chain already parsed + if chainid not in pdb_chains.keys(): + # Add to ordered chains + pdb_chains['chain_order'].append(chainid) + # Initiate new chain holder + pdb_chains[chainid] = {'order': []} + + # Check if new resid id + if resid not in pdb_chains[chainid].keys(): + # Add to oredered resids + pdb_chains[chainid]['order'].append(resid) + # Initiate new residue holder + pdb_chains[chainid][resid] = { + 'index': len(pdb_chains[chainid]['order']) - 1, + 'resname': resname, + 'chainid': chainid, + 'resid': resid, + 'position': len(pdb_chains[chainid]['order']), + 'atoms_order': [], + 'atoms': {}, + } + # extract atome name + atname = _[slc_name].strip() + # check if not an hydrogen + if atname[0] == 'H': + continue + + # extact atome coordinates + coords = extract_pdb_coords(_) + pdb_chains[chainid][resid]['atoms_order'].append(atname) + pdb_chains[chainid][resid]['atoms'][atname] = coords + + return pdb_chains + + +def extract_pdb_coords(line: str) -> list[float]: + """Extract coordinated from a PDB line. + + Parameters + ---------- + line : str + A strandard ATOM/HETATM pdb record. + + Return + ------ + coords : list[float] + List of the X, Y and Z coordinate of this atom. + """ + x = float(line[slc_x].strip()) + y = float(line[slc_y].strip()) + z = float(line[slc_z].strip()) + coords = [x, y, z] + return coords + + +def get_ordered_coords( + pdb_chains: dict, + ) -> tuple[list[list[float]], list[str], dict]: + """Generate list of all atom coordinates. + + Parameters + ---------- + pdb_chains : dict + A dictionary of the pdb file accesible using chains as keys, + as provided by the `extract_pdb_dt()` function. + + Return + ------ + all_coords : list[list[float]] + All atomic coordinates in a single list. + resid_keys : list[str] + Ordered list of residues keys. + resid_dt : dict + Dictionary of coordinates indices for each residue. + """ + # Define holders + all_coords = [] + resid_keys = [] + resid_dt = {} + i = 0 + # Loop over chains + for chainid in pdb_chains['chain_order']: + # Loop over residues of this chain + for resid in pdb_chains[chainid]['order']: + # create a resdiue key + resname = pdb_chains[chainid][resid]['resname'] + reskey = f'{chainid}-{resid}-{resname}' + resdt = { + 'atoms_indices': [], + 'resname': resname, + 'atoms_order': pdb_chains[chainid][resid]['atoms_order'], + } + # Loop over atoms of this residue + for atname in pdb_chains[chainid][resid]['atoms_order']: + # list of internal indices + resdt['atoms_indices'].append(i) + # index of a CA + if atname == 'CA': + resdt['CA'] = i + # Point atome submatrix coordinates index + all_coords.append(pdb_chains[chainid][resid]['atoms'][atname]) + # increment atom index + i += 1 + resid_dt[reskey] = resdt + resid_keys.append(reskey) + return (all_coords, resid_keys, resid_dt) + + +def compute_distance_matrix(all_atm_coords: list[list[float]]) -> NDFloat: + """Compute all vs all distance matrix. + + Paramaters + ---------- + all_atm_coords : list[list[float]] + List of atomic coordinates. + + Return + ------ + dist_matrix : NDFloat + N*N distance matrix between all coordinates. + """ + dist_matrix = squareform(pdist(all_atm_coords)) + return dist_matrix + + +def extract_submatrix( + matrix: NDFloat, + indices: list[int], + indices2: Optional[list[int]] = None, + ) -> NDFloat: + """Extract submatrix based on desired indices. + + Paramaters + ---------- + matrix : NDFloat + A N*N matrix. + indices : list[int] + List of `row` indices to extract from this matrix + indices2 : list[int] + List of `columns` indices to extract from this matrix. + if unspecified, indices2 == indices and symetric matrix + is extracted. + + Return + ------ + submat : NDFloat + The extracted submatrix. + """ + # Set second set of indices (columns) to first if not defined + if not indices2: + indices2 = indices + # extract submatrix + submat = matrix[np.ix_(indices, indices2)] + return submat + + +def gen_contact_dt( + matrix: NDFloat, + resdt: dict, + res1_key: str, + res2_key: str, + ) -> dict: + """Generate contacts data. + + Parameters + ---------- + matrix : NDFloat + The distance matrix. + resdt : dict + Residues data with atom indices as returned by `get_ordered_coords()`. + res1_key : str + First residue of interest. + res2_key : str + Second residue of interest + + Return + ------ + cont_dt : dict + Dictionary holding contact data + """ + # point residues data + res1_dt = resdt[res1_key] + res2_dt = resdt[res2_key] + # point ca-ca dist + try: + ca_ca_dist = matrix[res1_dt['CA'], res2_dt['CA']] + except KeyError: + ca_ca_dist = 9999 + # obtain submatrix + res1_res2_atm_submat = extract_submatrix( + matrix, + res1_dt['atoms_indices'], + res2_dt['atoms_indices'], + ) + # obtain clostest contact + clostest_contact = min_dist(res1_res2_atm_submat) + # contact type + cont_type = get_cont_type(res1_dt['resname'], res2_dt['resname']) + # set return variable + cont_dt = { + 'res1': res1_key, + 'res2': res2_key, + 'ca-ca-dist': round(ca_ca_dist, 1), + 'shortest-dist': round(clostest_contact, 1), + 'contact-type': cont_type, + } + return cont_dt + + +def extract_heavyatom_contacts( + matrix: NDFloat, + resdt: dict, + res1_key: str, + res2_key: str, + contact_distance: float = 4.5, + ) -> list[dict[str, Union[float, str]]]: + """Generate contacts data. + + Parameters + ---------- + matrix : NDFloat + The distance matrix. + resdt : dict + Residues data with atom indices as returned by `get_ordered_coords()`. + res1_key : str + First residue of interest. + res2_key : str + Second residue of interest. + contact_distance : float + Distance defining a contact. + + Return + ------ + all_contacts : list[dict[str, Union[float, str]]] + List holding contact data + """ + all_contacts: list[dict[str, Union[float, str]]] = [] + # point data for first residue + res1_indices = resdt[res1_key]['atoms_indices'] + res1_atnames = resdt[res1_key]['atoms_order'] + # point data for second residue + res2_indices = resdt[res2_key]['atoms_indices'] + res2_atnames = resdt[res2_key]['atoms_order'] + # Loop over res1 atoms / indices + for r1_atname, r1_atindex in zip(res1_atnames, res1_indices): + # Loop over res2 atoms / indices + for r2_atname, r2_atindex in zip(res2_atnames, res2_indices): + # Point corresponding distance in matrix + r1_r2_dist = matrix[r1_atindex, r2_atindex] + # Check if distance <= threshold + if r1_r2_dist <= contact_distance: + # Hold data + contactdt = { + 'atom1': f'{res1_key}-{r1_atname}', + 'atom2': f'{res2_key}-{r2_atname}', + 'dist': r1_r2_dist, + } + all_contacts.append(contactdt) + return all_contacts + + +def get_cont_type(resn1: str, resn2: str) -> str: + """Generate polarity key between two residues. + + Parameters + ---------- + resn1 : str + 3 letters code of fist residue. + resn2 : str + 3 letters code of second residue. + + Return + ------ + pol_key : str + Combined residues polarities + """ + pol_keys: list[str] = [] + for resn in [resn1, resn2]: + if resn.strip() in RESIDUE_POLARITY.keys(): + pol_keys.append(RESIDUE_POLARITY[resn.strip()]) + else: + pol_keys.append('unknow') + pol_key = '-'.join(pol_keys) + return pol_key + + +def min_dist(matrix: NDFloat) -> float: + """Find minimum value in a matrix.""" + return np.min(matrix) + + +def write_res_contacts( + res_res_contacts: list[dict], + header: list[str], + path: Union[Path, str], + sep: str = '\t', + interchain_data: Union[bool, dict] = None, + ) -> Path: + """Write a tsv file based on residues-residues contacts data. + + Parameters + ---------- + res_res_contacts : list[dict] + List of dict holding data for each residue-residue contacts. + header : list[str] + Ordered list of keys to access in the dicts. + path : Path + Path to the output file to generate. + sep : str + Character used to separate data within a line. + + Return + ------ + path : Path + Path to the generated file. + """ + # define README data type content + dttype_info = { + 'res1': 'Chain-Resname-ResID key identifying first residue', + 'res2': 'Chain-Resname-ResID key identifying second residue', + 'ca-ca-dist': 'Observed distances between the two carbon alpha (Ca) atoms', + 'ca-ca-cont-probability': 'Fraction of times a contact is observed under the ca-ca-dist threshold over all analysed models of the same cluster', # noqa : E501 + 'shortest-dist': 'Observed shortest distance between the two residues', + 'shortest-cont-probability': 'Fraction of times a contact is observed under the shortest-dist threshold over all analysed models of the same cluster', # noqa : E501 + 'contact-type': 'ResidueType - ResidueType contact name', + 'atom1': 'Chain-Resname-ResID-Atome key identifying first atom', + 'atom2': 'Chain-Resname-ResID-Atome key identifying second atom', + 'dist': 'Observed distance between two atoms', + 'nb_dists': 'Total number of observed distances', + 'avg_dist': 'Cluster average distance', + 'std_dist': 'Cluster distance standard deviation', + } + + # Check for inter chain contacts + gen_interchain_tsv: bool = False + if interchain_data and type(interchain_data) == dict: + expected_keys = ('path', 'contact_threshold', 'data_key', ) + if all([k in interchain_data.keys() for k in expected_keys]): + gen_interchain_tsv = True + interchain_tsvdt: list[list[str]] = [header] + else: + raise KeyError + + # initiate file content + tsvdt: list[list[str]] = [header] + for res_res_cont in res_res_contacts: + tsvdt.append([str(res_res_cont[h]) for h in header]) + if gen_interchain_tsv: + chain1 = res_res_cont['res1'].split('-')[0] + chain2 = res_res_cont['res2'].split('-')[0] + if chain1 != chain2: + dist = res_res_cont[interchain_data['data_key']] + if dist < interchain_data['contact_threshold']: + interchain_tsvdt.append(tsvdt[-1]) + tsv_str = '\n'.join([sep.join(_) for _ in tsvdt]) + + # generate commented lines to be placed on top of file + readme = [ + '#' * 80, + '# This file contains extracted contacts half-matrix information', + '#' * 80, + '', + ] + for head in header[::-1]: + readme.insert(2, f'# {head}: {dttype_info[head]}') + + # Write file + with open(path, 'w') as tsvout: + tsvout.write('\n'.join(readme)) + tsvout.write(tsv_str) + + # Write inter chain file + if gen_interchain_tsv: + # Modify readme + readme[1] = readme[1].replace( + 'contacts half-matrix', + 'interchain contacts', + ) + # Write file + with open(interchain_data['path'], 'w') as f: + f.write('\n'.join(readme)) + # Write data string + f.write('\n'.join([sep.join(_) for _ in interchain_tsvdt])) + + return path + + +def tsv_to_heatmap( + tsv_path: Path, + sep: str = '\t', + data_key: str = 'ca-ca-dist', + contact_threshold: float = 7.5, + colorscale: str = 'Greys', + output_fname: Union[Path, str] = 'contacts.html', + offline: bool = False, + ) -> Union[Path, str]: + """Read a tsv file and generate a heatmap from it. + + Paramters + --------- + tsv_path : Path + Path a the .tsv file containing contact data. + sep : str + Separator character used to split data in each line. + data_key : str + Data key used to draw the plot. + contact_threshold : float + Upper boundary of maximum value to be plotted. + any value above it will be set to this value. + output_fname : Path + Path to the generated graph. + + Return + ------ + output_filepath : Union[Path, str] + Path to the generated file. + """ + half_matrix: list[float] = [] + labels: list[str] = [] + header: Union[bool, list[str]] = None + with open(tsv_path, 'r') as f: + for line in f: + # skip commented lines + if line.startswith('#'): + continue + # split line + s_ = line.strip().split(sep) + # gather header + if not header: + header = s_ + continue + # point labels + label1 = s_[header.index('res1')] + label2 = s_[header.index('res2')] + # Add them to set of labels + if label1 not in labels: + labels.append(label1) + if label2 not in labels: + labels.append(label2) + + # point data + value = float(s_[header.index(data_key)]) + # bound data to contact_threshold + bounded_value = min(value, contact_threshold) + # add it to matrix + half_matrix.append(bounded_value) + + # Genereate full matrix + matrix = squareform(half_matrix) + + # set data label + color_scale = datakey_to_colorscale(data_key, color_scale=colorscale) + if 'probability' in data_key: + data_label = 'probability' + np.fill_diagonal(matrix, 1) + else: + data_label = 'distance' + + # Compute chains length + chains_length: dict[str, int] = {} + ordered_chains: list[str] = [] + for label in labels: + chainid = label.split('-')[0] + if chainid not in chains_length.keys(): + chains_length[chainid] = 0 + ordered_chains.append(chainid) + chains_length[chainid] += 1 + # Compute chains delineations positions + del_posi = [0] + for chainid in ordered_chains: + del_posi.append(del_posi[-1] + chains_length[chainid]) + # Compute chains delineations lines + chains_limits: list[dict[str, float]] = [] + for delpos in del_posi: + # Vertical lines + chains_limits.append({ + "x0": delpos - 0.5, + "x1": delpos - 0.5, + "y0": -0.5, + "y1": len(labels) - 0.5, + }) + # Horizontal lines + chains_limits.append({ + "y0": delpos - 0.5, + "y1": delpos - 0.5, + "x0": -0.5, + "x1": len(labels) - 0.5, + }) + # Generate hover template + hovertemplate = ( + ' %{y} ↭ %{x}
    ' + f' Contact {data_label}: %{{z}}' + '' + ) + + # Generate heatmap + output_filepath = heatmap_plotly( + matrix, + labels={'color': data_label}, + xlabels=labels, + ylabels=labels, + color_scale=color_scale, + output_fname=output_fname, + offline=offline, + delineation_traces=chains_limits, + hovertemplate=hovertemplate, + ) + + return output_filepath + + +def datakey_to_colorscale(data_key: str, color_scale: str = 'Greys') -> str: + """Convert color scale into reverse if data implies to do it. + + data_key : str + A dictionary key pointing to data type. + color_scale : str + Name of a base plotpy color_scale. + + Return + ------ + color_scale : str + Possibly the reverse name of the color_scale. + """ + return f'{color_scale}_r' if 'probability' not in data_key else color_scale + + +###################################### +# Start of the chord chart functions # +###################################### +def moduloAB(val: float, lb: float, ub: float) -> float: + """Map a real number onto the unit circle. + + The unit circle is identified with the interval [lb, ub), ub-lb=2*PI. + + Parameters + ---------- + val : float + The value to be mapped into the unit circle. + lb : float + The lower boundary. + ub : float + The upper boundary + + Return + ------ + moduloab : float + The modulo of val between lb and ub + """ + if lb >= ub: + raise ValueError('Incorrect interval ends') + y = (val - lb) % (ub - lb) + moduloab = y + ub if y < 0 else y + lb + return moduloab + + +def within_2PI(val: float) -> bool: + """Check if float value is within unit circle value range. + + Parameters + ---------- + val : float + The value to be tested. + """ + return 0 <= val < 2 * PI + + +def check_square_matrix(data_matrix: NDArray) -> int: + """Check if the matrix is a square one. + + Parameters + ---------- + data_matrix : NDArray (2DArray) + The matrix to be checked. + + Return + ------ + nb_rows : int + Number of rows in this matrix. + """ + matrixshape = data_matrix.shape + nb_rows = matrixshape[0] + if len(matrixshape) > 2: + raise ValueError('Data array must have only two dimensions') + if nb_rows != matrixshape[1]: + raise ValueError('Data array must have (n,n) shape') + return nb_rows + + +def get_ideogram_ends( + ideogram_len: NDFloat, + gap: float, + ) -> list[tuple[float, float]]: + """Generate ideogram ends. + + Paramaters + ---------- + ideogram_len : NDArray + Length of each ideograms. + gap : float + Gap to add in between each ideogram. + + Return + ------ + ideo_ends : list[tuple[float]] + List of start and end position for each ideograms. + """ + ideo_ends: list[tuple[float, float]] = [] + start = 0.0 + for k in range(len(ideogram_len)): + end = float(start + ideogram_len[k]) + ideo_ends.append((start, end)) + # Increment new start by gap for next origin + start = end + gap + return ideo_ends + + +def make_ideogram_arc( + radius: float, + _phi: tuple[float, float], + nb_points: float = 50, + ) -> NDFloat: + """Generate ideogran arc. + + Parameters + ---------- + radius : float + The circle radius. + phi : tuple[float, float] + Tuple of ends angle coordinates of an arc. + nb_points : float + Parameter that controls the number of points to be evaluated on an arc + + Return + ------ + arc_positions : NDArray + Array of 2D coorinates defining an arc. + """ + if not within_2PI(_phi[0]) or not within_2PI(_phi[1]): + phi = [moduloAB(t, 0, 2 * PI) for t in _phi] + else: + phi = [t for t in _phi] + length = (phi[1] - phi[0]) % (2 * PI) + nr = 5 if length <= (PI / 4) else int((nb_points * length) / PI) + if phi[0] < phi[1]: + theta = np.linspace(phi[0], phi[1], nr) + else: + theta = np.linspace( + moduloAB(phi[0], -PI, PI), + moduloAB(phi[1], -PI, PI), + nr, + ) + arc_positions = radius * np.exp(1j * theta) + return arc_positions + + +def make_ribbon_ends( + matrix: NDArray, + row_sum: list[int], + ideo_ends: list[tuple[float, float]], + L: int, + ) -> list[list[tuple[float, float]]]: + """Generate all connecting ribbons coordinates. + + Parameters + ---------- + matrix : NDArray + The data matrix. + row_sum : list[int] + Number of connexions in each row. + ideo_ends : list[tuple[float, float]] + List of start and end position for each ideograms. + + Returns + ------- + ribbon_boundary : list[list[tuple[float, float]]] + Matrix of per residue ribbons start and end positions. + """ + ribbon_boundary: list[list[tuple[float, float]]] = [] + for k, ideo_end in enumerate(ideo_ends): + # Point stating coordinates of this residue ideo + start = float(ideo_end[0]) + # No ribbon to be formed + if row_sum[k] == 0: + # Add empty set of ribbons + ribbon_boundary.append([(0., 0.) for i in range(len(ideo_ends))]) + continue + # Initiate row ribbons + row_ribbon_ends: list[tuple[float, float]] = [] + # Compute increment + increment = (ideo_end[1] - start) / row_sum[k] + # Loop over positions + for j in range(1, L + 1): + # Skip if no ribbon to add for this k, j pair + if matrix[k][j - 1] == 0: + row_ribbon_ends.append((0., 0.)) + continue + # Define end + end = float(start + increment) + # Hold data + row_ribbon_ends.append((start, end)) + # Set next start to current end + start = end + # Add full row + ribbon_boundary.append(row_ribbon_ends) + return ribbon_boundary + + +def control_pts( + angle: list[float], + radius: float, + ) -> list[tuple[float, float]]: + """Generate control points to draw a SVGpath. + + Parameters + ---------- + angle : list[float] + A list containing angular coordinates of the control points b0, b1, b2. + radius : float + The distance from b1 to the origin O(0,0) + + Returns + ------- + control_points : list[tuple[float, float]] + The set of control points. + + Raises + ------ + ValueError + Raised if the number of angular coordinates is not equal to 3. + """ + # Check number of angular coordinates + if len(angle) != 3: + raise ValueError('angle must have len = 3') + b_cplx = np.array([np.exp(1j * angle[k]) for k in range(3)]) + # Give it its size + b_cplx[1] = radius * b_cplx[1] + # Generate control points as a list for two values + control_points = list(zip(b_cplx.real, b_cplx.imag)) + return control_points + + +def ctrl_rib_chords( + side1: tuple[float, float], + side2: tuple[float, float], + radius: float, + ) -> list[list[tuple[float, float]]]: + """Generate poligons points aiming at drawing ribbons. + + Parameters + ---------- + side1 : tuple[float, float] + List of angular variables of the ribbon arc ends defining + the ribbon starting (ending) arc + side2 : tuple[float, float] + List of angular variables of the ribbon arc ends defining + the ribbon starting (ending) arc + radius : float, optional + Circle radius size + + Returns + ------- + list[list[tuple[float, float]]] + _description_ + """ + if len(side1) != 2 or len(side2) != 2: + raise ValueError('the arc ends must be elements in a list of len 2') + poligons = [ + control_pts( + [side1[j], (side1[j] + side2[j]) / 2, side2[j]], + radius, + ) + for j in range(2) + ] + return poligons + + +def make_q_bezier(control_points: list[tuple[float, float]]) -> str: + """Define the Plotly SVG path for a quadratic Bezier curve. + + defined by the list of its control points. + + Parameters + ---------- + control_points : list[tuple[float, float]] + List of control points + + Return + ------ + svgpath : str + An SVG path + """ + if len(control_points) != 3: + raise ValueError('control poligon must have 3 points') + _a, _b, _c = control_points + svgpath = 'M ' + str(_a[0]) + ',' + str(_a[1]) + ' Q ' +\ + str(_b[0]) + ', ' + str(_b[1]) + ' ' +\ + str(_c[0]) + ', ' + str(_c[1]) + return svgpath + + +def make_ribbon_arc(theta0: float, theta1: float) -> str: + """Generate a SVGpath to draw a ribbon arc. + + Parameters + ---------- + theta0 : float + Starting angle value + theta1 : float + Ending angle value + + Returns + ------- + string_arc : str + A string representing the SVGpath of the ribbon arc. + + Raises + ------ + ValueError + If provided theta0 and theta1 angles are incorrect for a ribbon. + ValueError + If the angle coordinates for an arc side of a ribbon are not + in the appropriate range [0, 2*pi] + """ + if within_2PI(theta0) and within_2PI(theta1): + if theta0 < theta1: + theta0 = moduloAB(theta0, -PI, PI) + theta1 = moduloAB(theta1, -PI, PI) + if theta0 * theta1 > 0: + raise ValueError('incorrect angle coordinates for ribbon') + + nr = int(40 * (theta0 - theta1) / PI) + if nr <= 2: + nr = 3 + theta = np.linspace(theta0, theta1, nr) + pts = np.exp(1j * theta) # points on arc in polar complex form + + string_arc: str = '' + for k in range(len(theta)): + string_arc += f'L {str(pts.real[k])}, {str(pts.imag[k])} ' + return string_arc + else: + raise ValueError('the angle coordinates for an arc side of a ribbon ' + 'must be in [0, 2*pi]') + + +def make_layout( + title: str, + plot_size: float, + layout_shapes: list[dict], + ) -> go.Layout: + """Generate the chart layout. + + Parameters + ---------- + title : str + Title to be given to the chart. + plot_size : float + Size of the chart. + layout_shapes : list[dict] + Shapes to be drawn. + + Returns + ------- + layout : go.Layout + The plotly layout. + """ + # Set axis parameters to hide axis line, grid, ticklabels and title + axis = { + 'showline': False, + 'zeroline': False, + 'showgrid': False, + 'showticklabels': False, + 'title': '', + } + # Getenate the layout + layout = go.Layout( + title=title, + xaxis=axis, + yaxis=axis, + showlegend=True, # Important to show legend + # legend={'font': {'size': 10}}, # Lower font size + width=plot_size + 150, # +150 to accomodate legend / keep circle round + height=plot_size, + margin={"t": 25, "b": 25, "l": 25, "r": 25}, + hovermode='closest', + shapes=layout_shapes, + ) + return layout + + +def make_ideo_shape( + path: str, + line_color: str, + fill_color: str, + ) -> dict: + """Generate data to draw a ideogram shape. + + Parameters + ---------- + path : str + A SVGPath to be drawn. + line_color : str + Color of the shape boundary. + fill_color : str + Shape filling color fr the ribbon shape. + + Returns + ------- + dict + Data enabling to draw a ideogram shape in layout. + """ + return { + "line": {"color": line_color, "width": 0.45}, + "path": path, + "type": 'path', + "fillcolor": fill_color, + "layer": 'below', + } + + +def make_ribbon( + side1: tuple[float, float], + side2: tuple[float, float], + line_color: str, + fill_color: str, + radius: float = 0.2, + ) -> dict: + """Generate data to draw a ribbon. + + Parameters + ---------- + side1 : list[float] + List of angular variables of first ribbon arc ends defining + the ribbon starting (ending) arc. + side2 : list[float] + List of angular variables of the other ribbon arc ends defining + the ribbon starting (ending) arc. + line_color : str + Color of the shape boundary. + fill_color : str + Shape filling color fr the ribbon shape. + radius : float, optional + Circle radius size, by default 0.2. + + Returns + ------- + dict + Data enabling to draw a ribbon in layout. + """ + poligon = ctrl_rib_chords(side1, side2, radius) + _b, _c = poligon + # Generate the SVGpath + path = make_q_bezier(_b) + path += make_ribbon_arc(side2[0], side2[1]) + path += make_q_bezier(_c[::-1]) + path += make_ribbon_arc(side1[1], side1[0]) + + return { + 'line': {'color': line_color, 'width': 0.5}, + 'path': path, + 'type': 'path', + 'fillcolor': fill_color, + 'layer': 'below', + } + + +def invPerm(perm: list[int]) -> list[int]: + """Generate the inverse of a permutation. + + Parameters + ---------- + perm : _type_ + A permutation. + + Returns + ------- + inv : list[int] + Inverse of a permutation. + """ + # Fill with zeros + inv = [0] * len(perm) + for i, s in enumerate(perm): + inv[s] = i + return inv + + +def get_chains_ideograms_ends( + chains: dict[str, list[str]], + gap: float = 2 * PI * 0.005, + ) -> tuple[list[tuple[float, float]], NDFloat]: + """Build ideogram ends to represent protein chains. + + Parameters + ---------- + chains : dict[str, list[str]] + Dictionary mapping chains with their respective set of residues labels. + gap : float, optional + Gap between two ideograms, by default 2*PI*0.005 + + Returns + ------- + chain_ideo_ends : list[tuple[float, float]] + Ideogram ends to represent protein chains. + chain_ideogram_length : NDFloat + + """ + chain_row_sum = [len(chains[chain]) + for chain in sorted(chains, reverse=True)] + chain_ideogram_length = 2 * PI * np.asarray(chain_row_sum) + chain_ideogram_length /= sum(chain_row_sum) + chain_ideogram_length -= gap * np.ones(len(chain_row_sum)) + chain_ideo_ends = get_ideogram_ends(chain_ideogram_length, gap) + return chain_ideo_ends, chain_ideogram_length + + +def get_all_ideograms_ends( + chains: dict, + gap: float = 2 * PI * 0.005, + ) -> tuple[list[tuple[float, float]], list[tuple[float, float]]]: + """Generate both chain and residues ideograms ends. + + Parameters + ---------- + chains : dict + Dictionary mapping to list of residues labels. + gap : float, optional + Gap distance used to separate two ideograms, by default 2*PI*0.005 + + Returns + ------- + tuple[ideo_ends, chain_ideo_ends] + A tuple containing residues ideo ends and chains ideo ends. + + ideo_ends : list[tuple[float, float]] + List of residues ideograms start and ending positions. + chain_ideo_ends : list[tuple[float, float]] + List of chain ideograms start and ending positions. + """ + chain_ideo_ends, chain_ideogram_length = get_chains_ideograms_ends( + chains, + gap=gap, + ) + + ideo_ends: list[tuple[float, float]] = [] + left = 0 + for ind, chain in enumerate(sorted(chains, reverse=True)): + chain_labels = chains[chain] + for _label in chain_labels: + right = left + (chain_ideogram_length[ind] / len(chain_labels)) + ideo_ends.append((left, right)) + left = right + left = right + gap + return ideo_ends, chain_ideo_ends + + +def split_labels_by_chains(labels: list[str]) -> dict[str, list[str]]: + """Map each label to its chain. + + Parameters + ---------- + labels : list[str] + List of residues keys. e.g.: A-SER-123 (chain A, serine 123) + + Returns + ------- + chains : dict[str, list[str]] + Dictionary mapping chains with their respective set of residues labels. + """ + chains: dict[str, list] = {} + for lab in labels: + chain, resname, resid = lab.split('-') + if chain not in chains.keys(): + chains[chain] = [] + chains[chain].append(lab) + return chains + + +def contacts_to_connect_matrix( + matrix: NDFloat, + labels: list[str], + ) -> list[list[int]]: + """. + + Parameters + ---------- + matrix : NDFloat + A square contact matrix. + labels : list[str] + List of labels corresponding row & columns entries. + + Returns + ------- + connect_matrix : list[list[Union[str, int]]] + The connectivity matrix without self contacts. + """ + connect_matrix: list[list[int]] = [] + for ri, label_i in enumerate(labels): + # Point label chain name + chain1 = label_i.split('-')[0] + new_contact_mat_row: list[int] = [] + # Loop over columns + for ci, label_j in enumerate(labels): + # Point label chain name + chain2 = label_j.split('-')[0] + if chain1 != chain2 and matrix[ri, ci] == 1: + interaction = 1 + else: + interaction = 0 + new_contact_mat_row.append(interaction) + # Hold row + connect_matrix.append(new_contact_mat_row) + return connect_matrix + + +def to_nice_label(label: str) -> str: + """Convert a label into a user friendly label. + + Parameters + ---------- + label : str + Label name as found in csv + + Returns + ------- + nicelabel : str + User friendly description of the label. + """ + slabel = label.split('-') + nicelabel = f"Chain {slabel[0]}, residue {slabel[2]} {slabel[1]}" + return nicelabel + + +def to_color_weight( + distance: float, + max_dist: float, + min_dist: float = 2., + min_weight: float = 0.2, + max_weight: float = 0.90, + ) -> float: + """Compute color weight based on distance. + + Parameters + ---------- + distance : float + The distance to weight. + max_dist : float + The max distance observed in the dataset. + min_dist : float, optional + The minumu, distance observed in the dataset, by default 2. + min_weight : float, optional + Color wight for the maximum distance, by default 0.2 + max_weight : float, optional + Color wight for the minimum distance, by default 0.90 + + Returns + ------- + weight : float + The color weight. in range [min_weight, max_weight] + """ + # Scale dist into minimum + dist = max(distance, min_dist) + # Compute probability + probability_dist = (dist - min_dist) / (max_dist - min_dist) + # Obtain corresponding weight + weight = ((min_weight - max_weight) * probability_dist) + max_weight + # Return rounded value of weight + return round(weight, 2) + + +def to_rgba_color_string( + connect_color: tuple[int, int, int], + alpha: float, + ) -> str: + """Generate a rgba string from list of colors and alpha. + + Parameters + ---------- + connect_color : list[int] + A 3-values list of integers defining the red, green and blue colors. + alpha : float + color_weight + + Returns + ------- + rgba_color : str + The html like rgba colors. e.g.: 'rgba(123, 123, 123, 0.5)' + """ + colors_str = ",".join([str(v) for v in connect_color]) + rgba_color = f'rgba({colors_str},{alpha})' + return rgba_color + + +def to_full_matrix( + half_matrix: list[Union[int, float, str]], + diag_val: Union[int, float, str], + ) -> NDArray: + """Generate a full matrix from a half matrix. + + Parameters + ---------- + half_matrix : list[Any] + Values of the N*(N-1)/2 half matrix. + diag_val : Any + Value to be placed in diagonal of the full matrix. + + Returns + ------- + matrix : NDArry + The reconstituted full matrix. + """ + # Genereate full matrix from N*(N-1)/2 vector + matrix = squareform(half_matrix) + # Update diagonal with data + np.fill_diagonal(matrix, diag_val) + return matrix + + +def make_chordchart( + _contact_matrix: list[list[int]], + _dist_matrix: list[list[float]], + _interttype_matrix: list[list[str]], + _labels: list[str], + gap: float = 2 * PI * 0.005, + output_fpath: Union[str, Path] = 'chordchart.html', + title: str = 'Chord diagram', + offline: bool = False, + ) -> Union[str, Path]: + """Generate a plotly chordchart graph. + + Parameters + ---------- + _contact_matrix : list[list[int]] + The contact matrix + _dist_matrix : list[list[float]] + The distance matrix + _interttype_matrix : list[list[str]] + The interaction type matrix + _labels : list[str] + Labels of each matrix rows (and columns as supposed to be symetric) + gap : float, optional + Gap between two ideograms, by default 2*PI*0.005 + output_fpath : Union[str, Path], optional + Path to the output file, by default 'chordchart.html' + title : str, optional + Title to give to the diagram, by default 'Chord diagram' + + Returns + ------- + output_fpath : Union[str, Path] + Path to the genereated output file. + """ + # Unpack matrices + contact_matrix = contacts_to_connect_matrix(_contact_matrix, _labels) + + # Reverse data order so later graph displayed clockwise + matrix = np.array([ri[::-1] for ri in contact_matrix[::-1]]) + dist_matrix = [ri[::-1] for ri in _dist_matrix[::-1]] + interttype_matrix = [ri[::-1] for ri in _interttype_matrix[::-1]] + labels = _labels[::-1] + + # Check matrix shape + L = check_square_matrix(matrix) + + # Map labels into respective chains + chains = split_labels_by_chains(labels) + # Set matrix of indices + idx_sort = [list(range(L)) for i in range(L)] + + # Compute residues and chain ideograms positions + ideo_ends, chain_ideo_ends = get_all_ideograms_ends(chains, gap=gap) + + # Compute number of connexion per residues + row_sum = [np.sum(matrix[k, :]) for k in range(L)] + + # Compute connexion ribbons positions + ribbon_ends = make_ribbon_ends(matrix, row_sum, ideo_ends, L) + + # Initiate shape holder + layout_shapes: list[dict] = [] + # Initiate ribbon info holder + ribbon_info: list[go.Scatter] = [] + # Loop over entries + for k, label1 in enumerate(labels): + sigma = idx_sort[k] + sigma_inv = invPerm(sigma) + # Half matrix loop to avoid duplicates + for j in range(k, L): + # No data to draw + if matrix[k][j] == 0 and matrix[j][k] == 0: + continue + + # Obtain ribbon color for this interaction type + try: + connect_color = CONNECT_COLORS[interttype_matrix[k][j]] + except KeyError: + connect_color = (123, 123, 123) + color_weight = to_color_weight(dist_matrix[k][j], 9.5) + rgba_color = to_rgba_color_string(connect_color, color_weight) + + # Point ribbons data + side1 = ribbon_ends[k][sigma_inv[j]] + eta = idx_sort[j] + eta_inv = invPerm(eta) + side2 = ribbon_ends[j][eta_inv[k]] + zi = 0.9 * np.exp(1j * (side1[0] + side1[1]) / 2) + zf = 0.9 * np.exp(1j * (side2[0] + side2[1]) / 2) + + # reverse interaction type for second label + s_intertype = interttype_matrix[k][j].split('-') + rev_s_intertype = s_intertype[::-1] + rev_interttype = '-'.join(rev_s_intertype) + # Obtain nice labels + nicelabel1 = to_nice_label(label1) + nicelabel2 = to_nice_label(labels[j]) + # texti and textf are the strings that will be displayed when + # hovering the mouse over the two ribbon ends + texti = f'{nicelabel1} {rev_interttype} with {nicelabel2}' + textf = f'{nicelabel2} {interttype_matrix[j][k]} with {nicelabel1}' # noqa : E501 + # Generate interactive labels + for zv, text in zip([zi, zf], [texti, textf]): + # Generate ribbon info + ribbon_info.append( + go.Scatter( + x=[zv.real], + y=[zv.imag], + mode='markers', + marker={"size": 0.5, "color": rgba_color}, + text=text, + hoverinfo='text', + showlegend=False, + ) + ) + # Note: must reverse these arc ends to avoid twisted ribbon + side2_rev = (side2[1], side2[0]) + # Append the ribbon shape + layout_shapes.append( + make_ribbon( + side1, + side2_rev, + 'rgba(175,175,175)', + rgba_color, + ) + ) + + ideograms: list[go.Scatter] = [] + # Draw ideograms for residues + for k, label in enumerate(labels): + z = make_ideogram_arc(1.1, ideo_ends[k]) + zi = make_ideogram_arc(1.0, ideo_ends[k]) + + # Point residue name + resname = label.split('-')[2] + + # Point corresponding color + try: + rescolor = AA_DNA_RNA_COLORS[resname.strip()] + except KeyError: + rescolor = 'rgba(123, 123, 123, 0.7)' + + # Build textual info + text_info = f'{to_nice_label(label)}
    ' + if row_sum[k] == 0: + text_info += 'No interaction' + else: + text_info += f'Total of {row_sum[k]:d} interaction' + if row_sum[k] >= 2: + text_info += 's' + # Add info + ideograms.append( + go.Scatter( + x=z.real, + y=z.imag, + mode='lines', + line={ + "color": rescolor, + "shape": 'spline', + "width": 0.25, + }, + text=text_info, + hoverinfo='text', + showlegend=False, + ) + ) + + # Build corresponding SVG path + m = len(z) + svgpath = 'M ' + for s in range(m): + svgpath += f'{str(z.real[s])}, {str(z.imag[s])} L ' + + Zi = np.array(zi.tolist()[::-1]) + for s in range(m): + svgpath += f'{str(Zi.real[s])}, {str(Zi.imag[s])} L ' + svgpath += f'{str(z.real[0])}, {str(z.imag[0])}' + # Hold it + layout_shapes.append( + make_ideo_shape( + svgpath, + 'rgba(150,150,150)', + rescolor, + ) + ) + + # Draw ideograms for chains + for k, chainid in enumerate(sorted(chains, reverse=True)): + z = make_ideogram_arc(1.2, chain_ideo_ends[k]) + zi = make_ideogram_arc(1.11, chain_ideo_ends[k]) + m = len(z) + ideograms.append( + go.Scatter( + x=z.real, + y=z.imag, + mode='lines', + line={ + "color": CHAIN_COLORS[k], + "shape": 'spline', + "width": 0.25, + }, + text=f'Chain {chainid}', + hoverinfo='text', + showlegend=False, + ) + ) + + # Build corresponding SVG path + svgpath = 'M ' + for s in range(m): + svgpath += f'{str(z.real[s])}, {str(z.imag[s])} L ' + Zi = np.array(zi.tolist()[::-1]) + for s in range(m): + svgpath += f'{str(Zi.real[s])}, {str(Zi.imag[s])} L ' + svgpath += f'{str(z.real[0])}, {str(z.imag[0])}' + + layout_shapes.append( + make_ideo_shape( + svgpath, + 'rgba(150,150,150)', + CHAIN_COLORS[k], + ) + ) + + # Compute figure size + fig_size = 100 * np.log(L * L) + # Create plotly layout + layout = make_layout(title, fig_size, layout_shapes) + # combine all data info + data = ideograms + ribbon_info + # Generate the figure + fig = go.Figure(data=data, layout=layout) + # Fine tune figure + fig.update_layout( + plot_bgcolor='white', + ) + # Add legend(s) + add_chordchart_legends(fig) + # Write it as html file + fig_to_html( + fig, + output_fpath, + figure_height=fig_size, + figure_width=fig_size, + offline=offline, + ) + return output_fpath + + +def add_chordchart_legends(fig: go.Figure) -> None: + """Add custom legend to chordchart. + + Parameters + ---------- + fig : go.Figure + A plotly figure. + """ + # Add connection types legends + for key_key, color in REVERSED_CONNECT_COLORS_KEYS.items(): + # Create dummy traces + fig.add_trace( + go.Scatter( + x=[None], + y=[None], + legendgroup="connect_color", + legendgrouptitle_text="Interaction types", + showlegend=True, + name=key_key.replace('-', '↭'), + mode="lines", + marker={ + "color": to_rgba_color_string(color, 0.75), + "size": 10, + "symbol": "line-ew-open", + }, + ) + ) + # Add unknown interaction type + fig.add_trace( + go.Scatter( + x=[None], + y=[None], + legendgroup="connect_color", + legendgrouptitle_text="Interaction types", + showlegend=True, + name="Unknown", + mode="lines", + marker={ + "color": to_rgba_color_string((111, 111, 111), 0.75), + "size": 10, + "symbol": "line-ew-open", + }, + ) + ) + + # Add aa types legend + for aa, rgba_color in RESIDUES_COLORS.items(): + # Create dummy traces + fig.add_trace( + go.Scatter( + x=[None], + y=[None], + legendgroup="aa_color", + legendgrouptitle_text="Residues/Bases", + showlegend=True, + name=aa, + mode="lines", + marker={ + "color": rgba_color, + "size": 10, + "symbol": "line-ew-open", + }, + ) + ) + # Add nucleobases legend + for na, rgba_color in DNARNA_COLORS.items(): + # Create dummy traces + fig.add_trace( + go.Scatter( + x=[None], + y=[None], + legendgroup="aa_color", + legendgrouptitle_text="Residues/Bases", + showlegend=True, + name=na, + mode="lines", + marker={ + "color": rgba_color, + "size": 10, + "symbol": "line-ew-open", + }, + ) + ) + # Add unknown type + fig.add_trace( + go.Scatter( + x=[None], + y=[None], + legendgroup="aa_color", + legendgrouptitle_text="Residues/Bases", + showlegend=True, + name="Unknown", + mode="lines", + marker={ + "color": to_rgba_color_string((111, 111, 111), 0.75), + "size": 10, + "symbol": "line-ew-open", + }, + ) + ) + + +def tsv_to_chordchart( + tsv_path: Path, + sep: str = '\t', + data_key: str = 'ca-ca-dist', + contact_threshold: float = 7.5, + filter_intermolecular_contacts: bool = True, + output_fname: Union[Path, str] = 'contacts_chordchart.html', + title: str = 'Chord diagram', + offline: bool = False, + ) -> Union[Path, str]: + """Read a tsv file and generate a chord diagram from it. + + Paramters + --------- + tsv_path : Path + Path a the .tsv file containing contact data. + sep : str + Separator character used to split data in each line. + data_key : str + Data key used to draw the plot. + contact_threshold : float + Upper boundary of maximum value to be plotted. + any value above it will be set to this value. + output_fname : Union[Path, str] + Path where to generate the graph. + title : str + Title to give to the Chord diagram + + Return + ------ + chord_chart_fpath : Union[Path, str] + Path to the generated graph + """ + # Initiate holders + half_contact_matrix: list[int] = [] + half_value_matrix: list[float] = [] + half_intertype_matrix: list[str] = [] + labels: list[str] = [] + header: Union[bool, list[str]] = None + # Read tsv file + with open(tsv_path, 'r') as f: + for line in f: + # skip commented lines + if line.startswith('#'): + continue + # split line + s_ = line.strip().split(sep) + # gather header + if not header: + header = s_ + continue + # point labels + label1 = s_[header.index('res1')] + label2 = s_[header.index('res2')] + # Add them to set of labels + if label1 not in labels: + labels.append(label1) + if label2 not in labels: + labels.append(label2) + + # point data + value = float(s_[header.index(data_key)]) + # check if in contact + contact = 1 if value <= contact_threshold else 0 + # Point interaction type + inter_type = s_[header.index('contact-type')] + # add it to matrix + half_contact_matrix.append(contact) + half_value_matrix.append(value) + half_intertype_matrix.append(inter_type) + + # Genereate full matrices + contact_matrix = to_full_matrix(half_contact_matrix, 1) + dist_matrix = to_full_matrix(half_value_matrix, 0.) + intertype_matrix = to_full_matrix(half_intertype_matrix, 'self-self') + + # Check if must get only the intermolecular contacts submatrix + if filter_intermolecular_contacts: + # Filter positions where: intermolecular contacts + dist <= threshold + intmol_cont_labels: list[str] = [] + for ri, label1 in enumerate(labels): + label1_chain = label1.split('-')[0] + for ci, label2 in enumerate(labels): + label2_chain = label2.split('-')[0] + # Skip same chains + if label1_chain == label2_chain: + continue + # Check contacts + if contact_matrix[ri, ci] == 1: + intmol_cont_labels += [label1, label2] + + # Obtain sorted subset + nodoubles_intmol_cont_labels = list(set(intmol_cont_labels)) + sorted_intmol_cont_labels = sorted( + nodoubles_intmol_cont_labels, + key=lambda k: labels.index(k), + ) + + # Get indices to be extracted + sorted_indices = [labels.index(k) for k in sorted_intmol_cont_labels] + + # Get submatrix + contact_submatrix = extract_submatrix(contact_matrix, sorted_indices) + dist_submatrix = extract_submatrix(dist_matrix, sorted_indices) + intert_submatrix = extract_submatrix(intertype_matrix, sorted_indices) + sublabels = sorted_intmol_cont_labels + + else: + contact_submatrix = contact_matrix + dist_submatrix = dist_matrix + intert_submatrix = intertype_matrix + sublabels = labels + + # Generate chord chart + chord_chart_fpath = make_chordchart( + contact_submatrix, + dist_submatrix, + intert_submatrix, + sublabels, + output_fpath=output_fname, + title=title, + offline=offline, + ) + + return chord_chart_fpath diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/contactmap/defaults.yaml b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/contactmap/defaults.yaml new file mode 100644 index 0000000000000000000000000000000000000000..a022c9a21d3c5ff9e0a8a2ab0e534e44b4d754cc --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/contactmap/defaults.yaml @@ -0,0 +1,120 @@ +ca_ca_dist_threshold: + default: 9.0 + min: 4.0 + max: 1000.0 + type: float + precision: 1 + title: Ca-Ca distance defining a contact. + short: Distance between Ca atoms of two residues defining a contact. + long: Distance between Ca atoms of two residues defining a contact. + group: analysis + explevel: easy + +shortest_dist_threshold: + default: 4.5 + type: float + min: 2.0 + max: 1000.0 + precision: 1 + title: Distance defining a contact between two residues. + short: Shortest distance between any atom of two residues defining a contact. + long: Shortest distance between any atom of two residues defining a contact. + group: analysis + explevel: easy + +color_ramp: + default: 'Greys' + type: string + minchars: 3 + maxchars: 10 + choices: + - Greys + - Purples + - BuPu + - Blues + - BuGn + - Greens + - deep + - tempo + - algae + - dense + - amp + title: Color ramp used to color heatmap. + short: Color ramp used to color heatmap. + long: Color ramp used to color heatmap. Please refer to `plotly builtin-colorscales` for more information + group: analysis + explevel: easy + +single_model_analysis: + default: false + type: boolean + title: Analyse contacts at single model level. + short: Analyse contacts at single model level. + long: In addition to cluster analysis, also perform single model analyses. + group: analysis + explevel: easy + +generate_heatmap: + default: true + type: boolean + title: Generate contact heatmap. + short: Generate plotly heatmap matrix representation of the contacts. + long: Uses generated contact matrices files to generate heatmap. + group: analysis + explevel: easy + +generate_chordchart: + default: true + type: boolean + title: Generate chordchart. + short: Generate plotly chordchart representation of the contacts. + long: Uses generated contact matrices files to generate chord chart. + group: analysis + explevel: easy + +topX: + default: 10 + type: integer + min: 1 + max: 100 + title: Number of unclustered models to analyse. + short: Number of unclustered models to analyse. + long: Top `X` unclustered models to analyse. Models are sorted based on + their score (if accessible) and only a subset defined + by this variable are analysed. If no score available, a random set of + `topX` models are analysed. + group: analysis + explevel: expert + +cluster_heatmap_datatype: + default: 'shortest-cont-probability' + type: string + minchars: 5 + maxchars: 30 + choices: + - ca-ca-dist + - ca-ca-cont-probability + - shortest-dist + - shortest-cont-probability + title: Type of data to be used in the heatmap. + short: Type of data to be used in the heatmap. + long: ca-ca-dist & shortest-dist are averages distances observed in cluster. + ca-ca-cont-probability & shortest-cont-probability are probability of + the distances to be observed under their respective thresholds. + group: analysis + explevel: easy + +chordchart_datatype: + default: 'shortest-dist' + type: string + minchars: 5 + maxchars: 30 + choices: + - ca-ca-dist + - shortest-dist + title: Type of data to be used in the chordchart. + short: Type of data to be used in the chordchart. + long: ca-ca-dist and shortest-dist are averages distances observed in + cluster. + group: analysis + explevel: easy diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/filter/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/filter/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6dadcbfb9a336cae1c98b1f303ccf6f71dc54200 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/filter/__init__.py @@ -0,0 +1,104 @@ +"""Filter models based on their score. + +This module filters the input models based on their score using a threshold +value. Models having higher score than the threshold value are filtered out. + +The number of models to be selected is unknown, and is the set of models that +have a score below the defined threshold. +For this module to be functional, a score must be first computed. This can be +performed by running a CNS module or a scoring module. If scores are not +accessible, the workflow will terminate with an error message. + +If the threshold value is too stringent, resulting in no models passed to the +next module, the workflow will stop with an error message. +""" + +from pathlib import Path + +from haddock.core.defaults import MODULE_DEFAULT_YAML +from haddock.core.typing import Any, FilePath +from haddock.libs.libontology import Format, PDBFile +from haddock.modules import BaseHaddockModule + + +RECIPE_PATH = Path(__file__).resolve().parent +DEFAULT_CONFIG = Path(RECIPE_PATH, MODULE_DEFAULT_YAML) + + +class HaddockModule(BaseHaddockModule): + """HADDOCK3 module to select top cluster/model.""" + + name = RECIPE_PATH.name + + def __init__(self, + order: int, + path: Path, + *ignore: Any, + init_params: FilePath = DEFAULT_CONFIG, + **everything: Any) -> None: + super().__init__(order, path, init_params) + + @classmethod + def confirm_installation(cls) -> None: + """Confirm if module is installed.""" + return + + def _run(self) -> None: + """Execute module.""" + # Make sure we have access to complexes + if type(self.previous_io) == iter: + self.finish_with_error( + "[filter] This module cannot come after one" + " that produced an iterable." + ) + # Get the models generated in previous step + models: list[PDBFile] = [ + p + for p in self.previous_io.output + if p.file_type == Format.PDB + ] + + # Get the filter by parameter + filter_by = "score" + threshold = self.params["threshold"] + + # Make sure we can access this attribute on models + models_with_attributes: list[PDBFile] = [ + m for m in models + if getattr(m, filter_by, None) != None + ] + + # Check how many of them are available + ratio_models_with_attr = len(models_with_attributes) / len(models) + self.log( + f"{100 * (1 - ratio_models_with_attr):6.2f} % " + "of the input models have accessible scores." + ) + if len(models_with_attributes) == 0: + self.finish_with_error( + "Input models do not have scores. " + "Please consider running a scoring module before!" + ) + + # Process to the actual filtering step + filtered_models: list[PDBFile] = [ + m for m in models_with_attributes + if getattr(m, filter_by) <= threshold + ] + + # Final evaluation of the outcome of the filtering + percent_filtered = (1 - (len(filtered_models) / len(models))) * 100 + if len(filtered_models) == 0: + self.finish_with_error( + f"With the currently set 'threshold' value of {threshold}, " + "ALL models were filtered out." + ) + else: + self.log( + f"With currently set 'threshold' value of {threshold}, " + f"{percent_filtered:6.2f}% of the models were filtered out." + ) + + # select the models based on the parameter + self.output_models = filtered_models + self.export_io_models() diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/filter/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/filter/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..031d201e82fd08d58e3bb68c4a5cbc4a3c572bcc Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/filter/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/filter/defaults.yaml b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/filter/defaults.yaml new file mode 100644 index 0000000000000000000000000000000000000000..abdf4ef5116b0afc9a0ca67dfaf08d56cc954780 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/filter/defaults.yaml @@ -0,0 +1,12 @@ +threshold: + default: 0.00 + type: float + min: -99999.99 + max: 99999.99 + precision: 2 + title: Threshold value to filter models. + short: Threshold value to filter models based on their score. + long: Threshold value to filter models based on their score. + Models having higher score than the threshold value will be filtered out. + group: analysis + explevel: easy \ No newline at end of file diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/ilrmsdmatrix/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/ilrmsdmatrix/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ce1e64595645abd636667eed3d6eb783d5501349 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/ilrmsdmatrix/__init__.py @@ -0,0 +1,371 @@ +""" +ilRMSD matrix module. + +This module calculates of the interface-ligand RMSD (ilRMSD) matrix between all +the models generated in the previous step. + +As all the pairwise ilRMSD calculations are independent, the module distributes +them over all the available cores in an optimal way. + +Once created, the ilRMSD matrix is saved in text form in the current +`ilrmsdmatrix` folder. The path to this file is then shared with the following +step of the workflow by means of the json file `rmsd_matrix.json`. + +IMPORTANT: the module assumes coherent numbering for all the receptor and ligand +chains, as no alignment is performed. The user must ensure that the numbering +is coherent. +""" + +import os +from pathlib import Path + +import numpy as np + +from haddock import RMSD_path, log +from haddock.core.defaults import FAST_RMSDMATRIX_EXEC, MODULE_DEFAULT_YAML +from haddock.libs.libalign import ( + check_chains, + check_common_atoms, + get_atoms, + load_coords, + rearrange_xyz_files, + ) +from haddock.libs.libontology import ModuleIO, RMSDFile +from haddock.libs.libparallel import get_index_list +from haddock.libs.libutil import parse_ncores +from haddock.modules import BaseHaddockModule, get_engine +from haddock.modules.analysis import get_analysis_exec_mode +from haddock.modules.analysis.ilrmsdmatrix.ilrmsd import Contact, ContactJob +from haddock.modules.analysis.rmsdmatrix import RMSDJob, rmsd_dispatcher +from haddock.modules.analysis.rmsdmatrix.rmsd import XYZWriter, XYZWriterJob + + +RECIPE_PATH = Path(__file__).resolve().parent +DEFAULT_CONFIG = Path(RECIPE_PATH, MODULE_DEFAULT_YAML) +EXEC_PATH = FAST_RMSDMATRIX_EXEC + + +class HaddockModule(BaseHaddockModule): + """HADDOCK3 module for clustering with RMSD.""" + + name = RECIPE_PATH.name + + def __init__(self, order, path, *ignore, init_params=DEFAULT_CONFIG, **everything): + super().__init__(order, path, init_params) + + @classmethod + def confirm_installation(cls) -> None: + """Confirm if fast-rmsdmatrix is installed and available.""" + if not os.access(EXEC_PATH, mode=os.F_OK): + raise Exception( + f"Required {str(EXEC_PATH)} file does not exist.{os.linesep}" + "Old HADDOCK3 installation? Please follow the new installation instructions at https://github.com/haddocking/haddock3/blob/main/docs/INSTALL.md" # noqa : E501 + ) + + if not os.access(EXEC_PATH, mode=os.X_OK): + raise Exception(f"Required {str(EXEC_PATH)} file is not executable") + + return + + @staticmethod + def _rearrange_output(output_name, path, ncores): + """Combine different ilrmsd outputs in a single file.""" + output_fname = Path(path, output_name) + log.info(f"rearranging output files into {output_fname}") + # Combine files + with open(output_fname, "w") as out_file: + for core in range(ncores): + tmp_file = Path(path, "ilrmsd_" + str(core) + ".matrix") + with open(tmp_file) as infile: + out_file.write(infile.read()) + log.debug(f"File number {core} written") + tmp_file.unlink() + log.info("Completed reconstruction of rmsd files.") + log.info(f"{output_fname} created.") + + @staticmethod + def _rearrange_contact_output(output_name, path, ncores): + """Combine different contact outputs in a single file. + + Parameters + ---------- + output_name : str + Name of the output file. + path : str + Path to the output file. + ncores : int + Number of cores used in the calculation. + + Returns + ------- + res_resdic_npu : dict + Dictionary of the unique residues in the interfaces. + """ + output_fname = Path(path, output_name) + log.info(f"rearranging contact files into {output_fname}") + # Combine residues + res_resdic = {} + for core in range(ncores): + tmp_file = Path(path, "interface_contacts_" + str(core) + ".con") + for ln in tmp_file.read_text().split(os.linesep)[:-1]: + ch = ln.split()[0] + resids = [int(el) for el in ln.split()[1:]] + if ch not in res_resdic: + res_resdic[ch] = [resids] + else: + res_resdic[ch].append(resids) + tmp_file.unlink() + + # Unique residues + npu_resdic = {} + for ch in res_resdic.keys(): + resids = np.concatenate(res_resdic[ch]) + resids_npu = np.unique(resids) + npu_resdic[ch] = resids_npu + log.info(f"Overall interface residues: {npu_resdic}") + + # Write to file + with open(output_fname, "w") as out_file: + for chain in npu_resdic.keys(): + out_file.write(f"{chain} ") + out_file.write(" ".join([str(el) for el in npu_resdic[chain]])) + out_file.write(os.linesep) + + log.info("Completed reconstruction of contact files.") + log.info(f"{output_fname} created.") + return npu_resdic + + def _run(self) -> None: + """Execute module.""" + # Get the models generated in previous step + if type(self.previous_io) == iter: + _e = "This module cannot come after one that produced an iterable." + self.finish_with_error(_e) + + # Get the models generated in previous step + models = self.previous_io.retrieve_models(individualize=True) + + # Parallelisation : optimal dispatching of models + nmodels = len(models) + ncores = parse_ncores(n=self.params["ncores"], njobs=nmodels) + + if nmodels > self.params["max_models"]: + # too many input models : ilRMSD matrix would be too big => Abort! + raise Exception( + f"Too many models ({nmodels} > {self.params['max_models']}) " + "for ilRMSD matrix calculation" + ) + + # find the existing chains + model_atoms = get_atoms(models[0]) + mod_coord_dic, _ = load_coords( + models[0], + model_atoms, + ) + obs_chains = np.unique([el[0] for el in mod_coord_dic.keys()]) + obs_chains = list(obs_chains) + log.info(f"Observed chains: {obs_chains}") + # assigning the chains to the receptor and ligand + r_chain, l_chains = check_chains( + obs_chains, self.params["receptor_chain"], self.params["ligand_chains"] + ) + log.info(f"Receptor chain: {r_chain}") + log.info(f"Ligand chains: {l_chains}") + self.params["receptor_chain"] = r_chain + self.params["ligand_chains"] = l_chains + + # Find the common residues making contacts for the receptor and ligand. + index_list = get_index_list(nmodels, ncores) + # contact jobs + contact_jobs = [] + for core in range(ncores): + output_name = "interface_contacts_" + str(core) + ".con" + contact_obj = Contact( + model_list=models[index_list[core] : index_list[core + 1]], + output_name=output_name, + core=core, + path=Path("."), + contact_distance_cutoff=self.params["contact_distance_cutoff"], + params=self.params, + ) + # running now the ContactJob + job_f = Path(output_name) + # init RMSDJob + job = ContactJob( + job_f, + self.params, + contact_obj, + ) + contact_jobs.append(job) + + exec_mode = get_analysis_exec_mode(self.params["mode"]) + Engine = get_engine(exec_mode, self.params) + contact_engine = Engine(contact_jobs) + contact_engine.run() + + # check if all the jobs have been completed + contact_file_l = [] + not_found = [] + for job in contact_jobs: + if not job.output.exists(): + not_found.append(job.output.name) + wrn = f"Contacts were not calculated for {job.output.name}" + log.warning(wrn) + else: + contact_file_l.append(str(job.output)) + + if not_found: + # Not all contacts were calculated, cannot proceed + self.finish_with_error( + "Several contact files were not generated:" f" {not_found}" + ) + + # Post-processing : single file + output_name = "receptor_contacts.con" + res_resdic = self._rearrange_contact_output( + output_name, path=contact_obj.path, ncores=ncores + ) + + # if the receptor chain in res_resdic is empty, then the receptor has made no contacts and + # the ilrmsd matrix cannot be calculated. This probably means that single chains structures + # reached this step or that something went (very) wrong in the docking process. + if res_resdic[r_chain].size == 0: + _msg = f"No contacts found for receptor chain {r_chain}. Impossible to calculate ilRMSD matrix." + _msg += " Please check your input and make sure that there are at least two chains in contact." + self.finish_with_error(_msg) + + rec_traj_filename = Path("traj_rec.xyz") + lig_traj_filename = Path("traj_lig.xyz") + + res_resdic_rec = {k: res_resdic[k] for k in res_resdic if k[0] == r_chain} + # ligand_chains is a list of chains + res_resdic_lig = {k: res_resdic[k] for k in l_chains} + + log.info( + f"Check common atoms for receptor (chain {list(res_resdic_rec.keys())})" + ) + n_atoms_rec, common_keys_rec = check_common_atoms( + models, + res_resdic_rec, + self.params["allatoms"], + self.params["atom_similarity"], + ) + + log.info( + f"Check common atoms for ligand (chains {list(res_resdic_lig.keys())})" + ) + n_atoms_lig, common_keys_lig = check_common_atoms( + models, + res_resdic_lig, + self.params["allatoms"], + self.params["atom_similarity"], + ) + + xyzwriter_jobs: list[XYZWriterJob] = [] + for core in range(ncores): + output_name_rec = Path("traj_rec_" + str(core) + ".xyz") + # init XYZWriter + xyzwriter_obj_rec = XYZWriter( + model_list=models[index_list[core] : index_list[core + 1]], + output_name=output_name_rec, + core=core, + n_atoms=n_atoms_rec, + common_keys=common_keys_rec, + filter_resdic=res_resdic_rec, + allatoms=self.params["allatoms"], + ) + # job_rec + job_rec = XYZWriterJob( + xyzwriter_obj_rec, + ) + + xyzwriter_jobs.append(job_rec) + + output_name_lig = Path("traj_lig_" + str(core) + ".xyz") + # init XYZWriter + xyzwriter_obj_lig = XYZWriter( + model_list=models[index_list[core] : index_list[core + 1]], + output_name=output_name_lig, + core=core, + n_atoms=n_atoms_lig, + common_keys=common_keys_lig, + filter_resdic=res_resdic_lig, + allatoms=self.params["allatoms"], + ) + # job_lig + job_lig = XYZWriterJob( + xyzwriter_obj_lig, + ) + xyzwriter_jobs.append(job_lig) + + # run jobs + engine = Engine(xyzwriter_jobs) + engine.run() + + rearrange_xyz_files(rec_traj_filename, path=Path("."), ncores=ncores) + rearrange_xyz_files(lig_traj_filename, path=Path("."), ncores=ncores) + + # Parallelisation : optimal dispatching of models + tot_npairs = nmodels * (nmodels - 1) // 2 + ncores = parse_ncores(n=self.params["ncores"], njobs=tot_npairs) + log.info(f"total number of pairs {tot_npairs}") + npairs, ref_structs, mod_structs = rmsd_dispatcher(nmodels, tot_npairs, ncores) + + # Calculate the rmsd for each set of models + ilrmsd_jobs: list[RMSDJob] = [] + self.log(f"running RmsdFast Jobs with {ncores} cores") + for core in range(ncores): + output_name = f"ilrmsd_{core:d}.out" + job_f = Path(output_name) + # init RMSDJob + job = RMSDJob( + rec_traj_filename, + job_f, + EXEC_PATH, + core, + npairs[core], + ref_structs[core], + mod_structs[core], + len(models), + n_atoms_rec, + lig_traj_filename, + n_atoms_lig, + ) + ilrmsd_jobs.append(job) + + ilrmsd_engine = Engine(ilrmsd_jobs) + ilrmsd_engine.run() + + ilrmsd_file_l = [] + not_found = [] + for j in ilrmsd_jobs: + if not j.output.exists(): + # NOTE: If there is no output, most likely the RMSD calculation + # timed out + not_found.append(j.output.name) + wrn = f"ilRMSD results were not calculated for {j.output.name}" + log.warning(wrn) + else: + ilrmsd_file_l.append(str(j.output)) + + if not_found: + # Not all distances were calculated, cannot create the full matrix + self.finish_with_error("Several files were not generated:" f" {not_found}") + + # Post-processing : single file + output_name = "ilrmsd.matrix" + self._rearrange_output(output_name, path=Path("."), ncores=ncores) + # Delete the trajectory files + if rec_traj_filename.exists(): + os.unlink(rec_traj_filename) + if lig_traj_filename.exists(): + os.unlink(lig_traj_filename) + + # Sending models to the next step of the workflow + self.output_models = models + self.export_io_models() + # Sending matrix path to the next step of the workflow + matrix_io = ModuleIO() + ilrmsd_matrix_file = RMSDFile(output_name, npairs=tot_npairs) + matrix_io.add(ilrmsd_matrix_file) + matrix_io.save(filename="rmsd_matrix.json") diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/ilrmsdmatrix/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/ilrmsdmatrix/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..690b42d2b924611795dbb66090a6302cb76b7302 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/ilrmsdmatrix/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/ilrmsdmatrix/__pycache__/ilrmsd.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/ilrmsdmatrix/__pycache__/ilrmsd.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ab5cf6d86489561546e6e13511319cce267d3716 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/ilrmsdmatrix/__pycache__/ilrmsd.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/ilrmsdmatrix/defaults.yaml b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/ilrmsdmatrix/defaults.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ac5113d2f4e25a27f1c30692b1f8598d01457e65 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/ilrmsdmatrix/defaults.yaml @@ -0,0 +1,71 @@ +receptor_chain: + default: A + type: string + minchars: 1 + maxchars: 1 + title: Receptor ChainID + short: Receptor ChainID to be considered for the RMSD calculations. + long: Receptor ChainID to be considered for the RMSD calculations. This determines which chain will be + treated as the receptor for the L-RMSD and for I-L-RMSD. + group: analysis + explevel: easy + +ligand_chains: + default: [] + type: list + minitems: 0 + maxitems: 100 + title: Ligand ChainIDs + short: Ligand ChainIDs to be considered for the IL-RMSD calculations. + long: Ligand ChainIDs to be considered for the IL-RMSD calculations. This determines which chains will be + treated as the ligand for the IL-RMSD. By default, all chains are considered with the exception of the receptor chain. + group: analysis + explevel: easy + +max_models: + default: 10000 + type: integer + min: 1 + max: 20000 + title: Maximum number of models + short: Maximum number of models to be considered when calculating the matrix. + long: Maximum number of models to be considered when calculating the matrix. If the number of models in the input file is larger than + this number, the execution will be aborted. + group: analysis + explevel: guru + +atom_similarity: + default: 90.0 + type: float + min: 10.0 + max: 100.0 + precision: 3 + title: Required atom similarity + short: Required similarity (in %) between the number of atoms in the input models. + long: Required similarity (in %) between the number of atoms in the input models. If the similarity is higher than this value, the RMSD calculation is performed on the common atoms. Otherwise, the calculation is stopped. The lower the value the looser the checks. + group: analysis + explevel: easy + +allatoms: + default: false + type: boolean + title: Atoms to be considered during the analysis. + short: Atoms to be considered during the analysis. + long: Atoms to be considered during the analysis. If false (default), only + backbone atoms will be considered, otherwise all the heavy-atoms. + group: analysis + explevel: easy + +contact_distance_cutoff: + default: 5.0 + type: float + min: 0.1 + max: 30.0 + precision: 3 + title: Distance cutoff defining a contact. + short: Cutoff distance (in Angstrom) defining a contact. + long: Distance (in Angstrom) cutoff defining a contact. Any atoms within this + cutoff range will be used to define the interface. Standard values are + usually 3.9 A or 5.0 A. + group: analysis + explevel: easy diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/ilrmsdmatrix/ilrmsd.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/ilrmsdmatrix/ilrmsd.py new file mode 100644 index 0000000000000000000000000000000000000000..62002a6e084111d6c04d1f274f5ff2c4165a9d98 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/ilrmsdmatrix/ilrmsd.py @@ -0,0 +1,110 @@ +"""ilRMSD calculations.""" +import os +from pathlib import Path + +import numpy as np + +from haddock import log +from haddock.core.typing import NDFloat, Any +from haddock.libs.libalign import ( + get_atoms, + ) +from haddock.libs.libontology import PDBFile +from haddock.modules.analysis.caprieval.capri import load_contacts + + +class ContactJob: + """A Job dedicated to the fast retrieval of receptor contacts.""" + + def __init__( + self, + output, + params, + contact_obj): + + log.info(f"core {contact_obj.core}, initialising Contact...") + self.params = params + self.output = output + self.contact_obj = contact_obj + log.info(f"core {contact_obj.core}, Contact initialised") + + def run(self): + """Run this ContactJob.""" + log.info(f"core {self.contact_obj.core}, running Contact...") + self.contact_obj.run() + self.contact_obj.output() + return + + +class Contact: + """Contact class.""" + + def __init__( + self, + model_list: list[PDBFile], + output_name: str, + core: int, + path: Path, + contact_distance_cutoff: float = 5.0, + **params: dict[str, Any], + ): + """Initialise Contact class.""" + self.model_list = model_list + self.output_name = output_name + self.core = core + self.path = path + self.contact_distance_cutoff = contact_distance_cutoff + self.atoms = {} + self.receptor_chain = params["params"]["receptor_chain"] + self.ligand_chains = params["params"]["ligand_chains"] + self.unique_rec_res: NDFloat = [] + self.unique_lig_res: NDFloat = [] + for m in model_list: + self.atoms.update(get_atoms(m)) + + def run(self): + """Run contact calculations.""" + nmodels = len(self.model_list) + # create empty set of receptor interface residues + receptor_interface_residues = [] + ligand_interface_residues = [] + for n in range(nmodels): + contacts = load_contacts( + self.model_list[n], + cutoff=self.contact_distance_cutoff, + ) + rec_resids = [ + con[1] if con[0] == self.receptor_chain + else con[3] for con in contacts + ] + lig_resids = [ + con[1] if con[0] in self.ligand_chains + else con[3] for con in contacts + ] + if rec_resids != []: + receptor_interface_residues.append(np.unique(rec_resids)) + if lig_resids != []: + ligand_interface_residues.append(np.unique(lig_resids)) + # concatenate all the receptor residues + if receptor_interface_residues != []: + rec_np_arr = np.concatenate(receptor_interface_residues) + self.unique_rec_res = np.unique(rec_np_arr) + # now the ligand residues + if ligand_interface_residues != []: + lig_np_arr = np.concatenate(ligand_interface_residues) + self.unique_lig_res = np.unique(lig_np_arr) + + def output(self): + """Write down unique contacts to file.""" + output_fname = Path(self.path, self.output_name) + with open(output_fname, "w") as out_fh: + # first the receptor + out_fh.write(f"{self.receptor_chain} ") + out_fh.write(" ".join([str(res) for res in self.unique_rec_res])) + out_fh.write(f"{os.linesep}") + # now the ligand + for chain in self.ligand_chains: + out_fh.write(f"{chain} ") + res_str = " ".join([str(res) for res in self.unique_lig_res]) + out_fh.write(res_str) + out_fh.write(f"{os.linesep}") diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/rmsdmatrix/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/rmsdmatrix/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..07e4047ac2b3992816dd1c85b46d6a5052dd1dee --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/rmsdmatrix/__init__.py @@ -0,0 +1,228 @@ +""" +RMSD matrix module. + +This module calculates of the RMSD matrix between all the models +generated in the previous step. + +As all the pairwise RMSD calculations are independent, the module distributes +them over all the available cores in an optimal way. + +Once created, the RMSD matrix is saved in text form in the current `rmsdmatrix` +folder. The path to this file is then shared with the following step of the +workflow by means of the json file `rmsd_matrix.json`. + +The module accepts two parameters in input, namely: + +* `max_models` (default = 10000) +* `resdic_` : an expandable parameter to specify which residues must be + considered for the alignment and the RMSD calculation. If there are + two proteins denoted by chain IDs A and B, then the user can operate + such selection in the following way inside the configuration file + +>>> resdic_A = [1,2,3,4] +>>> resdic_B = [2,3,4] + +thus telling the module to consider residues from 1 to 4 of chain A and from 2 +to 4 of chain B for the alignment and RMSD calculation. +""" + +import contextlib +import os +from pathlib import Path + +from haddock import RMSD_path, log +from haddock.core.defaults import FAST_RMSDMATRIX_EXEC, MODULE_DEFAULT_YAML +from haddock.core.typing import Any, AtomsDict, FilePath +from haddock.libs.libalign import check_common_atoms, rearrange_xyz_files +from haddock.libs.libontology import ModuleIO, RMSDFile +from haddock.libs.libparallel import get_index_list +from haddock.libs.libutil import parse_ncores +from haddock.modules import BaseHaddockModule, get_engine +from haddock.modules.analysis import ( + confirm_resdic_chainid_length, + get_analysis_exec_mode, + ) +from haddock.modules.analysis.rmsdmatrix.rmsd import ( + RMSDJob, + XYZWriter, + XYZWriterJob, + rmsd_dispatcher, + ) + + +RECIPE_PATH = Path(__file__).resolve().parent +DEFAULT_CONFIG = Path(RECIPE_PATH, MODULE_DEFAULT_YAML) +EXEC_PATH = FAST_RMSDMATRIX_EXEC + + +class HaddockModule(BaseHaddockModule): + """HADDOCK3 module for clustering with RMSD.""" + + name = RECIPE_PATH.name + + def __init__( + self, order: int, path: Path, initial_params: FilePath = DEFAULT_CONFIG + ) -> None: + super().__init__(order, path, initial_params) + + @classmethod + def confirm_installation(cls) -> None: + """Confirm if fast-rmsdmatrix is installed and available.""" + + if not os.access(EXEC_PATH, mode=os.F_OK): + raise Exception( + f"Required {str(EXEC_PATH)} file does not exist.{os.linesep}" + "Old HADDOCK3 installation? Please follow the new installation instructions at https://github.com/haddocking/haddock3/blob/main/docs/INSTALL.md" + ) + + if not os.access(EXEC_PATH, mode=os.X_OK): + raise Exception(f"Required {str(EXEC_PATH)} file is not executable") + + return + + def _rearrange_output( + self, output_name: FilePath, path: FilePath, ncores: int + ) -> None: + """Combine different rmsd outputs in a single file.""" + output_fname = Path(path, output_name) + self.log(f"rearranging output files into {output_fname}") + # Combine files + with open(output_fname, "w") as out_file: + for core in range(ncores): + tmp_file = Path(path, "rmsd_" + str(core) + ".matrix") + with open(tmp_file) as infile: + out_file.write(infile.read()) + log.debug(f"File number {core} written") + tmp_file.unlink() + log.info("Completed reconstruction of rmsd files.") + log.info(f"{output_fname} created.") + + def update_params(self, *args: Any, **kwargs: Any) -> None: + """Update parameters.""" + super().update_params(*args, **kwargs) + with contextlib.suppress(KeyError): + self.params.pop("resdic_") + + confirm_resdic_chainid_length(self._params) + + def _run(self) -> None: + """Execute module.""" + # Get the models generated in previous step + if type(self.previous_io) == iter: + _e = "This module cannot come after one that produced an iterable." + self.finish_with_error(_e) + + # Get the models generated in previous step + models = self.previous_io.retrieve_models(individualize=True) + + nmodels = len(models) + if nmodels > self.params["max_models"]: + # too many input models : RMSD matrix would be too big => Abort! + raise Exception("Too many models for RMSD matrix calculation") + + # index_list for the jobs with linear scaling + ncores = parse_ncores(n=self.params["ncores"], njobs=len(models)) + index_list = get_index_list(nmodels, ncores) + + traj_filename = Path("traj.xyz") + + filter_resdic = { + key[-1]: value + for key, value in self.params.items() + if key.startswith("resdic") + } + + # check common atoms + n_atoms, common_keys = check_common_atoms( + models, + filter_resdic, + self.params["allatoms"], + self.params["atom_similarity"], + ) + + xyzwriter_jobs: list[XYZWriterJob] = [] + for core in range(ncores): + output_name = Path("traj_" + str(core) + ".xyz") + # init RMSDJobFast + xyzwriter_obj = XYZWriter( + model_list=models[index_list[core] : index_list[core + 1]], + output_name=output_name, + core=core, + n_atoms=n_atoms, + common_keys=common_keys, + filter_resdic=filter_resdic, + allatoms=self.params["allatoms"], + ) + # job_f = output_name + job = XYZWriterJob( + xyzwriter_obj, + ) + xyzwriter_jobs.append(job) + + # run jobs + exec_mode = get_analysis_exec_mode(self.params["mode"]) + Engine = get_engine(exec_mode, self.params) + engine = Engine(xyzwriter_jobs) + engine.run() + + rearrange_xyz_files(traj_filename, path=Path("."), ncores=ncores) + + # Parallelisation : optimal dispatching of models + tot_npairs = nmodels * (nmodels - 1) // 2 + log.info(f"total number of pairs {tot_npairs}") + ncores = parse_ncores(n=self.params["ncores"], njobs=tot_npairs) + npairs, ref_structs, mod_structs = rmsd_dispatcher(nmodels, tot_npairs, ncores) + + # Calculate the rmsd for each set of models + rmsd_jobs: list[RMSDJob] = [] + self.log(f"running RmsdFast Jobs with {ncores} cores") + for core in range(ncores): + output_name = Path("rmsd_" + str(core) + ".out") + # init RMSDJobFast + job = RMSDJob( + traj_filename, + output_name, + EXEC_PATH, + core, + npairs[core], + ref_structs[core], + mod_structs[core], + len(models), + n_atoms, + ) + rmsd_jobs.append(job) + + engine = Engine(rmsd_jobs) + engine.run() + + rmsd_file_l: list[str] = [] + not_found: list[str] = [] + for job in rmsd_jobs: + if not job.output.exists(): + # NOTE: If there is no output, most likely the RMSD calculation + # timed out + not_found.append(job.output.name) + wrn = f"Rmsd results were not calculated for {job.output.name}" + log.warning(wrn) + else: + rmsd_file_l.append(str(job.output)) + + if not_found: + # Not all distances were calculated, cannot create the full matrix + self.finish_with_error("Several files were not generated:" f" {not_found}") + + # Post-processing : single file + final_output_name = "rmsd.matrix" + self._rearrange_output(final_output_name, path=Path("."), ncores=ncores) + # Delete the trajectory file + if traj_filename.exists(): + os.unlink(traj_filename) + + # Sending models to the next step of the workflow + self.output_models = models + self.export_io_models() + # Sending matrix path to the next step of the workflow + matrix_io = ModuleIO() + rmsd_matrix_file = RMSDFile(final_output_name, npairs=tot_npairs) + matrix_io.add(rmsd_matrix_file) + matrix_io.save(filename="rmsd_matrix.json") diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/rmsdmatrix/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/rmsdmatrix/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..667e655c958a28a9c811501f04f4e248a6de7afa Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/rmsdmatrix/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/rmsdmatrix/__pycache__/rmsd.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/rmsdmatrix/__pycache__/rmsd.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1c265ea2cddbbd6e90edba2e82dbba0cf995fd64 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/rmsdmatrix/__pycache__/rmsd.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/rmsdmatrix/defaults.yaml b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/rmsdmatrix/defaults.yaml new file mode 100644 index 0000000000000000000000000000000000000000..2d4d43231060b9e0c2dc3b9bdea4fa323f476776 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/rmsdmatrix/defaults.yaml @@ -0,0 +1,45 @@ +max_models: + default: 10000 + type: integer + min: 1 + max: 20000 + title: Maximum number of models to calculate RMSD matrix + short: If the number of models exceeds max_models the execution is blocked + long: If the number of models exceeds the few thousands, the calculation of + the RMSD matrix is computationally demanding, especially in terms of CPU + and disk space. + group: analysis + explevel: easy +resdic_: + default: [] + type: list + minitems: 0 + maxitems: 100 + title: List of residues + short: The residue numbers that should be used in the alignment and in the + RMSD calculation. + long: resdic_* is an expandable parameter. You can provide resdic_A, + resdic_B, resdic_C, etc, where the last capital letter is the chain + identifier. + group: analysis + explevel: easy +atom_similarity: + default: 90.0 + type: float + min: 10.0 + max: 100.0 + precision: 3 + title: Required atom similarity + short: Required similarity (in %) between the number of atoms in the input models. + long: Required similarity (in %) between the number of atoms in the input models. If the similarity is higher than this value, the RMSD calculation is performed on the common atoms. Otherwise, the calculation is stopped. The lower the value the looser the checks. + group: analysis + explevel: easy +allatoms: + default: false + type: boolean + title: Atoms to be considered during the analysis. + short: Atoms to be considered during the analysis. + long: Atoms to be considered during the analysis. If false (default), only + backbone atoms will be considered, otherwise all the heavy-atoms. + group: analysis + explevel: easy \ No newline at end of file diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/rmsdmatrix/rmsd.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/rmsdmatrix/rmsd.py new file mode 100644 index 0000000000000000000000000000000000000000..45adf7d772c188e2545923c97d02d3a8bef9dece --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/rmsdmatrix/rmsd.py @@ -0,0 +1,124 @@ +"""RMSD calculations.""" +import os +import numpy as np +from pathlib import Path + +from haddock import log +from haddock.core.typing import AtomsDict +from haddock.libs.libalign import get_atoms, load_coords +from haddock.libs.libsubprocess import BaseJob + + +class RMSDJob(BaseJob): + """ + Instantiate a subprocess job with inverted args and input. + + Runs with the following scheme, INPUT comes first: + + $ cmd INPUT ARGS + """ + + def make_cmd(self) -> None: + """Execute job in subprocess.""" + self.cmd = " ".join([ + os.fspath(self.executable), + os.fspath(self.input), + ' '.join(map(str, self.args)), # empty string if no args + ]) + return + + +def get_pair(nmodels: int, idx: int) -> tuple[int, int]: + """Get the pair of structures given the 1D matrix index.""" + if (nmodels < 0 or idx < 0): + err = "get_pair cannot accept negative numbers" + err += f"Input is {nmodels} , {idx}" + raise ValueError(err) + # solve the second degree equation + b = 1 - (2 * nmodels) + i = (-b - np.sqrt(b ** 2 - 8 * idx)) // 2 + j = idx + i * (b + i + 2) // 2 + 1 + return (int(i), int(j)) + + +def rmsd_dispatcher(nmodels: int, tot_npairs: int, + ncores: int) -> tuple[list[int], list[int], list[int]]: + """Optimal dispatching of rmsd jobs.""" + base_pairs = tot_npairs // ncores + modulo = tot_npairs % ncores + npairs: list[int] = [] + for core in range(ncores): + if core < modulo: + npairs.append(base_pairs + 1) + else: + npairs.append(base_pairs) + # each core must know how many pairs and where to start + index = 0 + start_structures = [0] + end_structures = [1] + for el in npairs[:-1]: + index += el + pair = get_pair(nmodels, index) + start_structures.append(pair[0]) + end_structures.append(pair[1]) + return npairs, start_structures, end_structures + + +class XYZWriterJob: + """A Job dedicated to the parallel writing of xyz files.""" + + def __init__( + self, + xyzwriter_obj): + """Initialise XYZWriterJob.""" + self.xyzwriter_obj = xyzwriter_obj + self.output = xyzwriter_obj.output_name + + def run(self): + """Run this XYZWriterJob.""" + log.info(f"core {self.xyzwriter_obj.core}, running XYZWriter...") + self.xyzwriter_obj.run() + return + + +class XYZWriter: + """XYZWriter class.""" + + def __init__( + self, + model_list, + output_name, + core, + n_atoms, + common_keys, + filter_resdic, + allatoms=False, + ): + """Initialise Contact class.""" + self.model_list = model_list + self.output_name = output_name + self.core = core + self.n_atoms = n_atoms + self.common_keys = common_keys + self.filter_resdic = filter_resdic + self.allatoms = allatoms + + def run(self) -> None: + """write xyz coordinates.""" + with open(self.output_name, "w") as traj_xyz: + for mod in self.model_list: + atoms: AtomsDict = get_atoms(mod, self.allatoms) + + ref_coord_dic, _ = load_coords( + mod, atoms, self.filter_resdic + ) + # now we filter the dictionary with the common keys + common_coord_dic = {k: v for k, v in ref_coord_dic.items() if k in self.common_keys} + # write header + traj_xyz.write(f"{self.n_atoms}{os.linesep}{os.linesep}") + # write the coordinates + for k in self.common_keys: + v = common_coord_dic[k] + at_string = ''.join([str(el) for el in k]) + traj_xyz.write(f"{at_string} {v[0]} {v[1]} {v[2]}{os.linesep}") + return diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/seletop/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/seletop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..43393e95b382973f95e0f15e14f4072aee72fbda --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/seletop/__init__.py @@ -0,0 +1,65 @@ +"""Select a number of models. + +This module selects a number of models from the input models. By default, the +selection is based on the HADDOCK score of the models. + +The number of models to be selected is defined by the parameter `select`. +In the standard HADDOCK protocol, this number is 200, which can be increased +if more models should be refined. +""" +from pathlib import Path + +from haddock.core.defaults import MODULE_DEFAULT_YAML +from haddock.core.typing import Any, FilePath +from haddock.libs.libontology import Format, PDBFile +from haddock.modules import BaseHaddockModule + + +RECIPE_PATH = Path(__file__).resolve().parent +DEFAULT_CONFIG = Path(RECIPE_PATH, MODULE_DEFAULT_YAML) + + +class HaddockModule(BaseHaddockModule): + """HADDOCK3 module to select top cluster/model.""" + + name = RECIPE_PATH.name + + def __init__(self, + order: int, + path: Path, + *ignore: Any, + init_params: FilePath = DEFAULT_CONFIG, + **everything: Any) -> None: + super().__init__(order, path, init_params) + + @classmethod + def confirm_installation(cls) -> None: + """Confirm if module is installed.""" + return + + def _run(self) -> None: + """Execute module.""" + # Get the models generated in previous step + if type(self.previous_io) == iter: + self.finish_with_error('[seletop] This module cannot come after one' + ' that produced an iterable') + + models_to_select: list[PDBFile] = [ + p + for p in self.previous_io.output + if p.file_type == Format.PDB + ] + + # sort the models based on their score + models_to_select.sort(key=lambda x: x.score) + + if len(models_to_select) < self.params['select']: + self.log(( + 'Number of models to be selected is larger' + ' than generated models, selecting ALL'), + level='warning', + ) + + # select the models based on the parameter + self.output_models = models_to_select[:self.params['select']] + self.export_io_models() diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/seletop/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/seletop/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b10ceb5d08197f961fe525edfc85d9520d0f910f Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/seletop/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/seletop/defaults.yaml b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/seletop/defaults.yaml new file mode 100644 index 0000000000000000000000000000000000000000..a96700476b64c9408362d77bf1fc446e13a0a3c0 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/seletop/defaults.yaml @@ -0,0 +1,10 @@ +select: + default: 200 + type: integer + min: 1 + max: 50000 + title: Number of best-ranked models to select + short: Number of best-ranked models to select for further steps of the workflow + long: Number of best-ranked models to select for further steps of the workflow. Typically only 200 models produced at the rigid-body docking stage are selected for further refinement. + group: analysis + explevel: easy diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/seletopclusts/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/seletopclusts/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..af3f9eccc2a5aa3cae766127b5daf748e09b35a9 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/seletopclusts/__init__.py @@ -0,0 +1,89 @@ +"""Select models from the top clusters. + +This module selects a number of models from a number of clusters. The +selection is based on the score of the models within the clusters. + +In the standard HADDOCK analysis, the top 4 models of the top 10 clusters +are shown. In case seletopclusts is run after a sampling module, we can +keep a few models from all the clusters to have more diversity at the +refinement stage(s). +""" + +from pathlib import Path + +from haddock import log +from haddock.core.defaults import MODULE_DEFAULT_YAML +from haddock.core.typing import Any, FilePath +from haddock.modules import BaseHaddockModule +from haddock.modules.analysis.seletopclusts.seletopclusts import ( + select_top_clusts_models, + write_selected_models, + ) + + +RECIPE_PATH = Path(__file__).resolve().parent +DEFAULT_CONFIG = Path(RECIPE_PATH, MODULE_DEFAULT_YAML) + + +class HaddockModule(BaseHaddockModule): + """Haddock Module for 'seletopclusts'.""" + + name = RECIPE_PATH.name + + def __init__(self, + order: int, + path: Path, + *ignore: Any, + init_params: FilePath = DEFAULT_CONFIG, + **everything: Any) -> None: + super().__init__(order, path, init_params) + + @classmethod + def confirm_installation(cls) -> None: + """Confirm if module is installed.""" + return + + def _run(self) -> None: + """Execute the module's protocol.""" + # Check parameters validity + if self.params["top_models"] <= 0: + _msg = "top_models must be either > 0 or nan." + self.finish_with_error(_msg) + + if not isinstance(self.params["top_clusters"], int): + _msg = "top_clusters must be an integer." + self.finish_with_error(_msg) + + # Retrieve list of previous models + models_to_select = self.previous_io.retrieve_models() + + # Check if cluster info is accessible + if any([mdl.clt_rank is None for mdl in models_to_select]): + _msg = ( + "Impossible to obtain cluster information. Please consider " + "running a clustering method prior to this module." + ) + self.finish_with_error(_msg) + + # Make model selection + selected_models, _notes = select_top_clusts_models( + self.params["sortby"], + models_to_select, + self.params["top_clusters"], + self.params["top_models"], + ) + # Log notes + for note in _notes: + log.info(note) + + # dump the models to disk and change their attributes + renamed_models = write_selected_models( + "seletopclusts.txt", + selected_models, + self.path, + ) + + # Make these new models the output of this module + self.output_models = renamed_models + # Export outputs + self.export_io_models() diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/seletopclusts/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/seletopclusts/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9d4c588a173fb2f7e23ab4f4e1920c3dea125f88 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/seletopclusts/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/seletopclusts/__pycache__/seletopclusts.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/seletopclusts/__pycache__/seletopclusts.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..86a1db3dc57962d6426f83b5611f7901ed9d379c Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/seletopclusts/__pycache__/seletopclusts.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/seletopclusts/defaults.yaml b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/seletopclusts/defaults.yaml new file mode 100644 index 0000000000000000000000000000000000000000..6f6ece8b70ddb824c76aacf92edbe54cdfcea6c9 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/seletopclusts/defaults.yaml @@ -0,0 +1,33 @@ +top_clusters: + type: integer + default: 1000 + min : 1 + max : 99999 + title: Number of clusters to consider + short: Number of clusters to consider (ranked by score) + long: Number of clusters to consider (ranked by score) + group: analysis + explevel: easy +top_models: + default: 10 + type: integer + min: 1 + max: 99999 + title: Number of best-ranked models to select per cluster + short: Number of best-ranked models to select per cluster. By default, 10 models are selected. + long: Number of best-ranked models to select per cluster. By default, 10 models are selected. If one expects to find many clusters (e.g., in the case of vague restraints), this number can be reduced to speed up the protocol. Instead, if few clusters are expected (very specific and localized restraints) this number can be increased. + group: analysis + explevel: easy +sortby: + default: score + type: string + minchars: 2 + maxchars: 15 + choice: + - score + - size + title: Method used to define `best cluster`. + short: Best cluster can be defined based either on cluster models scores, or on cluster size. By default, 'score' is selected. + long: if the selection is done by 'score' the average score of the top (4) models of each cluster is used to define the cluster rank. When clustering by 'size', a bigger cluster size corresponds to a higher rank. By default, 'score' is selected. + group: analysis + explevel: easy diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/seletopclusts/seletopclusts.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/seletopclusts/seletopclusts.py new file mode 100644 index 0000000000000000000000000000000000000000..ffde8259e1c65c9ea91860450588704c8921e1f0 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/analysis/seletopclusts/seletopclusts.py @@ -0,0 +1,236 @@ +"""Set of functions related to the selection of top clusters.""" + +import os +import math +from pathlib import Path +from haddock.core.typing import Union +from haddock.libs.libontology import PDBFile + + +def select_top_clusts_models( + sortby: str, + models_to_select: list[PDBFile], + top_clusters: int, + top_models: Union[int, float], + ) -> tuple[list[PDBFile], list[str]]: + """Select best clusters based on structures scores. + + Parameters + ---------- + sortby : str + How to order clusters: by `score` or by `size`. + models_to_select : list[PDBFile] + List of input models on which selection must be performed. + top_clusters : int + Number of best clusters to take into account. + top_models : int + Number of best models in each cluster to take into account. + + Returns + ------- + models_to_export : list[PDBFile] + List of PDBfiles to export. + notes : list[str] + List of notes to be printed. + """ + notes: list[str] = [] + by_clusters = map_clusters_models(models_to_select) + + # Get cluster order + if sortby == "size": + cluster_rankings = size_clust_order(by_clusters) + else: + cluster_rankings = rank_clust_order(by_clusters) + + # Check if number of clusters >= set of rank + if top_clusters >= len(cluster_rankings): + # select all clusters + cluster_rankins_str = ",".join(map(str, cluster_rankings)) + notes.append(f"Selecting all clusters: {cluster_rankins_str}") + else: + # select top_clusters clusters + cluster_rankings = cluster_rankings[:top_clusters] + cluster_rankins_str = ",".join(map(str, cluster_rankings)) + notes.append( + f"Selecting top {top_clusters} clusters: " + f"{cluster_rankins_str}" + ) + + # Initiate set of selected models to export + models_to_export: list[PDBFile] = [] + # Loop over cluster ranks + for clt_rank in cluster_rankings: + # Sort models by model rank + clt_mdls, note = sort_models(by_clusters[clt_rank]) + if note: + notes.append(note) + + # Set new ranks to models + for mdl_rank, pdb in enumerate(clt_mdls, start=1): + pdb.clt_rank = clt_rank + pdb.clt_model_rank = mdl_rank + # In case number of models is not set (nan.) + if math.isnan(top_models): + for pdb in clt_mdls: + models_to_export.append(pdb) + # In case number of models is a integer + else: + # Loop over first `top_models` models + for pdb in clt_mdls[:top_models]: + models_to_export.append(pdb) + return models_to_export, notes + + +def sort_models( + models: list[PDBFile] + ) -> tuple[list[PDBFile], Union[None, str]]: + """Sort models based on their rank in cluster. + + Parameters + ---------- + models : list[PDBFile] + List of input models on which ordering must be performed. + + Returns + ------- + sorted_mdls : list[PDBFile] + List of sorted models. + """ + note: Union[None, str] = None + try: + sorted_mdls = sorted( + models, + key=lambda k: k.clt_model_rank, + ) + except TypeError: + note = 'model rank unavailable, falling back to input order' + sorted_mdls = models + return sorted_mdls, note + + +def rank_clust_order( + by_clusters: dict[int, list[PDBFile]], + ) -> list[int]: + """Select best clusters based on structures scores. + + Parameters + ---------- + models_to_select : list[PDBFile] + List of input models on which selection must be performed. + top_clusters : int + Number of best clusters to take into account. + top_models : int + Number of best models in each cluster to take into account. + + Returns + ------- + models_to_export : list[PDBFile] + List of PDBfiles to export. + notes : list[str] + List of notes to be printed. + """ + # Generate set of all cluster rank available + cluster_rankings = sorted(by_clusters) + return cluster_rankings + + +def size_clust_order( + by_clusters: dict[int, list[PDBFile]], + ) -> list[int]: + """Select best clusters based on structures scores. + + Parameters + ---------- + models_to_select : list[PDBFile] + List of input models on which selection must be performed. + top_clusters : int + Number of best clusters to take into account. + top_models : int + Number of best models in each cluster to take into account. + + Returns + ------- + models_to_export : list[PDBFile] + List of PDBfiles to export. + notes : list[str] + List of notes to be printed. + """ + # Generate set of all cluster rank available + cluster_rankings = sorted( + by_clusters, + key=lambda k: len(by_clusters[k]), + reverse=True, + ) + return cluster_rankings + + +def map_clusters_models(models: list[PDBFile]) -> dict[int, list[PDBFile]]: + """Group models by clusters. + + Parameters + ---------- + models : list[PDBFile] + List of PDBfiles models to be grouped. + + Returns + ------- + by_clusters : dict[int, list[PDBFile]] + _description_ + """ + # Preset dictionary keys + by_clusters: dict[int, list[PDBFile]] = { + clrank: [] + for clrank in list(set([pdb.clt_rank for pdb in models])) + } + # Loop over models + for pdb in models: + # Add model to cluster + by_clusters[pdb.clt_rank].append(pdb) + return by_clusters + + +def write_selected_models( + output_path: Union[str, Path], + models: list[PDBFile], + module_path: Union[str, Path], + ) -> list[PDBFile]: + """Dump selected models and new names in a file. + + Parameters + ---------- + output_path : Union[str, Path] + Name of tne file to create. + models : list[PDBFile] + List of PDBfiles of selected models. + module_path : Union[str, Path] + Path of the module. + + Returns + ------- + models : list[PDBFile] + Updated list of selected models. + """ + # dump the models to disk and change their attributes + with open(output_path, 'w') as fh: + fh.write("rel_path\tori_name\tcluster_name\tmd5" + os.linesep) + for model in models: + name = ( + f"cluster_{model.clt_rank}_model" + f"_{model.clt_model_rank}.pdb" + ) + # writing name + fh.write( + f"{model.rel_path}\t" + f"{model.ori_name}\t" + f"{name}\t" + f"{model.md5}" + os.linesep + ) + # changing attributes + name_path = Path(name) + name_path.write_text(model.rel_path.read_text()) + model.ori_name = model.file_name + model.file_name = name + model.full_name = name + model.rel_path = Path('..', Path(module_path).name, name) + model.path = str(Path(".").resolve()) + return models diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/base_cns_module.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/base_cns_module.py new file mode 100644 index 0000000000000000000000000000000000000000..01af52d2fd39920bad72e483ccef3614a72d51d2 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/base_cns_module.py @@ -0,0 +1,170 @@ +"""Functionalities related to CNS modules.""" +import os +import shutil +import tarfile +from pathlib import Path + +from haddock import log +from haddock import toppar_path as global_toppar +from haddock.core.defaults import cns_exec as global_cns_exec +from haddock.core.typing import Any, FilePath, Optional, Union +from haddock.gear.expandable_parameters import populate_mol_parameters_in_module +from haddock.libs.libio import working_directory +from haddock.modules import BaseHaddockModule + + +class BaseCNSModule(BaseHaddockModule): + """ + Operation module for CNS. + + Contains additional functionalities excusive for CNS modules. + """ + + def __init__(self, order: int, path: Path, initial_params: FilePath, + cns_script: FilePath) -> None: + """ + Instantitate CNSModule. + + Parameters + ---------- + cns_script : str or pathlib.Path + Path to the main module's cns script. + """ + super().__init__(order, path, initial_params) + + self.cns_folder_path = Path(Path(cns_script).resolve().parent) + self.cns_protocol_path = Path(cns_script) + self.toppar_path = global_toppar + self.recipe_str = self.cns_protocol_path.read_text() + + def run(self, **params: Any) -> None: + """Execute the module.""" + log.info(f'Running [{self.name}] module') + + self.update_params(**params) + + # the `mol_*` parameters exist only for CNS jobs. + if self._num_of_input_molecules: + populate_mol_parameters_in_module( + self._params, + self._num_of_input_molecules, + self._original_params, + ) + + self.add_parent_to_paths() + self.envvars = self.default_envvars() + + if self.params['self_contained']: + self.make_self_contained() + + with working_directory(self.path): + self._run() + + log.info(f'Module [{self.name}] finished.') + + def default_envvars(self) -> dict[str, str]: + """Return default env vars updated to `envvars` (if given).""" + default_envvars = { + "MODULE": str(self.cns_folder_path), + "MODDIR": ".", + "TOPPAR": str(self.toppar_path), + } + + return default_envvars + + def save_envvars(self, filename: FilePath = "envvars") -> None: + """Save envvars needed for CNS to a file in the module's folder.""" + # there are so few variables, best to handle them by hand + lines = ( + "#!/bin/bash", + "# for debugging purposes source this file from within the ", + "# module folder for example, from within '00_topoaa'", + "export MODULE=cns", + "export MODDIR=.", + "export TOPPAR=../toppar", + ) + + fstr = os.linesep.join(lines) + Path(self.path, filename).write_text(fstr) + return + + def make_self_contained(self) -> None: + """Create folders to make run self-contained.""" + _ = Path(self.path, "cns") + shutil.copytree(self.cns_folder_path, _) + self.cns_folder_path = Path(".", "cns") + + self.cns_protocol_path = Path( + self.cns_folder_path, + self.cns_protocol_path.name, + ) + + if not Path(self.toppar_path.name).exists(): + shutil.copytree(self.toppar_path, self.toppar_path.name) + self.toppar_path = Path("..", self.toppar_path.name) + + self.envvars = self.default_envvars() + self.save_envvars() + + _cns_exec = self.params["cns_exec"] or global_cns_exec + new_cns = Path(".", Path(_cns_exec).name) + if not new_cns.exists(): + self.params["cns_exec"] = shutil.copyfile(_cns_exec, new_cns) + shutil.copystat(_cns_exec, new_cns) + self.params["cns_exec"] = Path("..", Path(_cns_exec).name) + + def get_ambig_fnames( + self, prev_ambig_fnames: list[Union[None, FilePath]] + ) -> Union[list[FilePath], None]: + """Get the correct ambiguous restraint names. + + Parameters + ---------- + prev_ambig_fnames : list + list of ambig_fname files encoded in previous models + + Returns + ------- + ambig_fnames : list or None + list of ambig_fname files to be used by the CNS module + """ + ambig_fname: Optional[Path] = self.params["ambig_fname"] + ambig_fnames: Union[list[FilePath], None] = None + if ambig_fname: + if ambig_fname.name.endswith("tgz"): + self.log(f"Searching for tbl files in {ambig_fname}") + basepath = ambig_fname.parent + # Open archive to retrieve members + with tarfile.open(ambig_fname, mode="r:gz") as targz: + # Get filenames + tbl_files = targz.getmembers() + # At that stage, they should be already extracted + # and we simply need to generate the full paths + ambig_fnames = [] + for tbl in tbl_files: + fname = tbl.name + # Filter non-".tbl" and hidden files + if fname.startswith("."): + continue + # Build path + tbl_fpath = Path(basepath, fname) + # Make sure it exists + if tbl_fpath.exists() and tbl_fpath.suffix == ".tbl": + ambig_fnames.append(tbl_fpath) + # abort execution if no files are found + if len(ambig_fnames) == 0: + raise Exception(f"No tbl files found in {ambig_fname} !") + self.log(f"Found {len(ambig_fnames)} tbl files") + # Sort them to make sure we get the same order every time + ambig_fnames.sort() + else: + if self.params["previous_ambig"]: + # check if there is restraint information in all models + if None in prev_ambig_fnames: + raise Exception( + "'previous_ambig' option selected but no available " + "restraint information in models" + ) + self.log("Using previously defined restraints") + ambig_fnames = prev_ambig_fnames.copy() + return ambig_fnames diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/defaults.yaml b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/defaults.yaml new file mode 100644 index 0000000000000000000000000000000000000000..9571db2b07f619610476669767d277e707b27b16 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/defaults.yaml @@ -0,0 +1,154 @@ +cns_exec: + default: "" + type: file + title: "Path to the CNS executable" + short: If not provided, HADDOCK3 will use the cns path configured + during the installation. + long: CNS is a required component to run HADDOCK. Ideally it should have been + configured during installation. If not you can specify with the cns_exec parameter + its path. + group: "execution" + explevel: easy +ncores: + default: 4 + type: integer + min: 1 + max: 500 + title: Number of CPU cores + short: Number of CPU cores to use for the CNS calculations. + It is truncated to max available CPUs minus 1. + long: Number of CPU cores to use for the CNS calculations. + This will define the number of concurrent jobs being executed. + Note that is truncated to the total number of available CPUs minus 1. + group: "execution" + explevel: easy +max_cpus: + default: true + type: boolean + title: The max number of CPUs allowed. + short: By default the max number of CPUs allowed is the max available on the system. + long: + If you want to spare a minimum amount of resources for daily tasks, set max_cpus + to false; in that case the maximum number of CPUs allowed will be the total available + in the machine minus 1. This calculation is done automatically. + group: "execution" + explevel: expert +mode: + default: local + type: string + minchars: 0 + maxchars: 20 + choices: + - local + - batch + title: Mode of execution + short: Mode of execution of the jobs, either local or using a batch system. + long: Mode of execution of the jobs, either local or using a batch system. + Currently slurm and torque are supported. For the batch mode the queue command must be + specified in the queue parameter. + group: "execution" + explevel: easy +batch_type: + default: "slurm" + type: string + minchars: 0 + maxchars: 100 + choices: + - slurm + - torque + title: Batch system + short: Type of batch system running on your server + long: Type of batch system running on your server. Only slurm and torque are supported at this time + group: "execution" + explevel: "easy" +queue: + default: "" + type: string + minchars: 0 + maxchars: 100 + title: Queue name + short: Name of the batch queue to which jobs will be submitted + long: Name of the batch queue to which jobs will be submitted. If not defined the batch system default will be used. + group: "execution" + explevel: easy +queue_limit: + default: 100 + type: integer + min: 1 + max: 9999 + title: Number of jobs to submit to the batch system + short: Number of jobs to submit to the batch system + long: This parameter controls the number of jobs that will be submitted to the batch system. In combination with the concat parameter this allow to limit the load on the queueing system and also make sure jobs remain in the queue for some time (if concat > 1) to avoid high system loads on the batch system. + group: "execution" + explevel: easy +concat: + default: 1 + type: integer + min: 1 + max: 9999 + precision: 0 + title: Number of models to produce per job. + short: Multiple models can be calculated within one job + long: + This defines the number of models that will be generated within on job script. + This allows to concatenate the generation of models into one script. + In that way jobs might run longer in the batch system and reduce the load on the scheduler. + group: "execution" + explevel: easy +self_contained: + default: false + type: boolean + title: Create a self-contained run + short: This option will copy the CNS scripts and executable to the run folder. + long: + This option will copy the CNS scripts and executable to the run folder to ensure that all scripts are available within the run dir. + This can be useful for for example remote execution of a job or for debugging purpose to allow to edit the scripts without touching the + main installation. + group: "execution" + explevel: guru +clean: + default: true + type: boolean + title: Clean the module output files. + short: Clean the module if run succeeds by compressing or removing output files. + long: + When running haddock through the command-line, the 'clean' parameter will + instruct the workflow to clean the output files of the module if the whole + run succeeds. In this process, PDB and PSF files are compressed to gzip, + with the extension `.gz`. While files with extension `.seed`, `.inp`, and + `.out` files are archived, and the original files deleted. The time to + perform a cleaning operation depends on the number of files in the folders + and the size of the files. However, it should not represent a limit step in + the workflow. For example, a rigidbody sampling 10,000 structures takes + about 4 minutes in our servers. This operation uses as many cores as allowed + by the user in the 'ncores' parameter. SSD disks will perform faster by + definition. See also the 'haddock3-clean' and 'haddock3-unpack' command-line + clients. + group: "clean" + explevel: easy +offline: + default: false + type: boolean + title: Isolate haddock3 from internet. + short: Completely isolate the haddock3 run & results from internet. + long: For interactive plots, we are using the plotly library. It can be + embedded as a link to the plotly.js library and fetched from the web, + or directly copied on the html files AT THE COST OF ~3Mb per file. + Setting this parameter to `true` will add the javascript library in + generated files, therefore completely isolating haddock3 from any web call. + group: "execution" + explevel: easy +debug: + default: false + type: boolean + title: Write intermediate and stdout files. + short: Write intermediate and stdout files. + long: When set to true, this option will increase the amount of I/O + operations by writing intermediate input, output and error files on disk. + Turning it to false can be useful for example when running on a network + file system where I/O operations are slow. + group: "execution" + explevel: easy + incompatible: + false: + mode: batch diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/extras/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/extras/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..10d3d334736334f4676159de3e9a2fd2e4bb69ff --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/extras/__init__.py @@ -0,0 +1,6 @@ +""" +HADDOCK3 extra modules. + +The extra modules are modules that do not belong to any of the standard +simulation categories but that help further configuring the workflow. +""" diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/extras/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/extras/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e6ab68d0c680be2ca7417645a0da55abe5946e1c Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/extras/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/extras/exit/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/extras/exit/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1cb6993c8ebc6e274adf7e7bb6b0c06a03b70c2b --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/extras/exit/__init__.py @@ -0,0 +1,68 @@ +""" +Exit module +=========== + +Stop the workflow when this module is reached. This allows users to execute +only a certain initial part of the workflow without having to comment/uncomment +the unwanted lines. + +Examples +-------- + +Consider the following config file example:: + + [topoaa] + (...) + + [rigidbody] + (...) + + [exit] # <- workflow will stop here + + [flexref] + (...) + +The workflow will stop at ``[exit]`` and ``[flexref]`` will not be performed. + +You can also use this option combined with ``--restart`` and ``--extend-run``. +See examples in ``examples/docking-protein-protein/*-exit-test.cfg`` files. +""" +import shutil +from pathlib import Path + +from haddock.core.defaults import MODULE_DEFAULT_YAML +from haddock.core.exceptions import HaddockTermination +from haddock.core.typing import Any, FilePath +from haddock.modules import BaseHaddockModule + + +RECIPE_PATH = Path(__file__).resolve().parent +DEFAULT_CONFIG = Path(RECIPE_PATH, MODULE_DEFAULT_YAML) + + +class HaddockModule(BaseHaddockModule): + """Stop the workflow when this module is reached.""" + + name = RECIPE_PATH.name + + def __init__( + self, + order: int, + path: Path, + *ignore: Any, + init_params: FilePath = DEFAULT_CONFIG, + **everything: Any, + ) -> None: + super().__init__(order, path, init_params) + + @classmethod + def confirm_installation(cls) -> None: + """Confirm if contact executable is compiled.""" + return + + def _run(self) -> None: + # removes the `exit` step folder + self.log(self.params["message"]) + shutil.rmtree(Path.cwd()) + error = HaddockTermination() + raise error diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/extras/exit/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/extras/exit/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..da960093009bec1552bf6ec32c174d8e733b78f3 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/extras/exit/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/extras/exit/defaults.yaml b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/extras/exit/defaults.yaml new file mode 100644 index 0000000000000000000000000000000000000000..58d787ab9969904edfa30b0f5e73d1f8870d6636 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/extras/exit/defaults.yaml @@ -0,0 +1,10 @@ +message: + default: Stopping the workflow. + type: string + minchars: 0 + maxchars: 1000 + title: Exiting message. + short: The message to print when exiting. + long: The message to print when exiting. + group: execution + explevel: easy diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2b70baccf55be6e2654f043d3824835616918745 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/__init__.py @@ -0,0 +1 @@ +"""HADDOCK3 actions referring to refinement.""" diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d544dba7a45e3b2d8e5d2921d4b160e9af0c0919 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/emref/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/emref/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..acdefc58989568ed6983629f6605671e71634745 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/emref/__init__.py @@ -0,0 +1,142 @@ +"""Energy minimization refinement with CNS. + +The ``[emref]`` module refine the input complexes by energy minimization using +conjugate gradient method implemented in CNS. + +Coordinates of the energy minimized structures are saved, and each +complex is then evaluated using the HADDOCK scoring function. +""" + +from pathlib import Path + +from haddock.core.defaults import MODULE_DEFAULT_YAML +from haddock.core.typing import FilePath +from haddock.gear.haddockmodel import HaddockModel +from haddock.libs.libcns import prepare_cns_input, prepare_expected_pdb +from haddock.libs.libontology import PDBFile +from haddock.libs.libsubprocess import CNSJob +from haddock.modules import get_engine +from haddock.modules.base_cns_module import BaseCNSModule + + +RECIPE_PATH = Path(__file__).resolve().parent +DEFAULT_CONFIG = Path(RECIPE_PATH, MODULE_DEFAULT_YAML) + + +class HaddockModule(BaseCNSModule): + """HADDOCK3 module energy minimization refinement.""" + + name = RECIPE_PATH.name + + def __init__( + self, order: int, path: Path, initial_params: FilePath = DEFAULT_CONFIG + ) -> None: + """.""" + cns_script = Path(RECIPE_PATH, "cns", "emref.cns") + super().__init__(order, path, initial_params, cns_script=cns_script) + + @classmethod + def confirm_installation(cls) -> None: + """Confirm module is installed.""" + return + + def _run(self) -> None: + """Execute module.""" + # Pool of jobs to be executed by the CNS engine + jobs: list[CNSJob] = [] + + # Get the models generated in previous step + try: + models_to_refine = self.previous_io.retrieve_models() + except Exception as e: + self.finish_with_error(e) + + self.output_models = [] + sampling_factor = self.params["sampling_factor"] + if sampling_factor > 1: + self.log(f"sampling_factor={sampling_factor}") + if sampling_factor == 0: + self.log("[Warning] sampling_factor cannot be 0, setting it to 1") + sampling_factor = 1 + if sampling_factor > 100: + self.log("[Warning] sampling_factor is larger than 100") + + max_nmodels = self.params["max_nmodels"] + nmodels = len(models_to_refine) * sampling_factor + if nmodels > max_nmodels: + self.finish_with_error( + f"Too many models ({nmodels}) to refine, max_nmodels =" + f" {max_nmodels}. Please reduce the number of models or" + " decrease the sampling_factor." + ) + + # checking the ambig_fname: + try: + prev_ambig_fnames = [mod.restr_fname for mod in models_to_refine] + except Exception as e: # noqa:F841 + # cannot extract restr_fname info from tuples + prev_ambig_fnames = [None for model in models_to_refine] + + ambig_fnames = self.get_ambig_fnames(prev_ambig_fnames) + + model_idx = 0 + idx = 1 + for model in models_to_refine: + # assign ambig_fname + if ambig_fnames: + ambig_fname = ambig_fnames[model_idx] + else: + ambig_fname = self.params["ambig_fname"] + model_idx += 1 + + for _ in range(self.params["sampling_factor"]): + emref_input = prepare_cns_input( + idx, + model, + self.path, + self.recipe_str, + self.params, + "emref", + ambig_fname=ambig_fname, + native_segid=True, + debug=self.params["debug"], + seed=model.seed if isinstance(model, PDBFile) else None, + ) + out_file = f"emref_{idx}.out" + err_fname = f"emref_{idx}.cnserr" + + # create the expected PDBobject + expected_pdb = prepare_expected_pdb(model, idx, ".", "emref") + expected_pdb.restr_fname = ambig_fname + try: + expected_pdb.ori_name = model.file_name + except AttributeError: + expected_pdb.ori_name = None + self.output_models.append(expected_pdb) + + job = CNSJob(emref_input, out_file, err_fname, envvars=self.envvars) + + jobs.append(job) + + idx += 1 + + # Run CNS Jobs + self.log(f"Running CNS Jobs n={len(jobs)}") + Engine = get_engine(self.params["mode"], self.params) + engine = Engine(jobs) + engine.run() + self.log("CNS jobs have finished") + + # Get the weights needed for the CNS module + _weight_keys = ("w_vdw", "w_elec", "w_desolv", "w_air", "w_bsa") + weights = {e: self.params[e] for e in _weight_keys} + + for pdb in self.output_models: + if pdb.is_present(): + haddock_model = HaddockModel(pdb.file_name) + pdb.unw_energies = haddock_model.energies + + haddock_score = haddock_model.calc_haddock_score(**weights) + pdb.score = haddock_score + + self.export_io_models(faulty_tolerance=self.params["tolerance"]) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/emref/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/emref/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e91b1c0f156b8f1b38cc6a3284357a0fd67b7e15 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/emref/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/emref/cns/setflags.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/emref/cns/setflags.cns new file mode 100644 index 0000000000000000000000000000000000000000..fd3e181f3cc822ca390f8d3f0ec6368c7305498b --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/emref/cns/setflags.cns @@ -0,0 +1,21 @@ +! setflags.cns +! Defines energy flags +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +if ($Data.flags.noe = TRUE) then + flags include noe end +end if +if ($Data.flags.cdih = TRUE) then + flags include cdih end +end if +if ($Data.flags.ncs = TRUE) then + flags include ncs end +end if diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/emref/defaults.yaml b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/emref/defaults.yaml new file mode 100644 index 0000000000000000000000000000000000000000..1d7fc880e06e040a41c2519abe74ddd11a97a2fa --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/emref/defaults.yaml @@ -0,0 +1,4652 @@ +# +# Group molecule +# +mol_fix_origin_1: + default: false + type: boolean + title: Fix molecule + short: Fixes the molecule in its original position. + long: Fixes the molecule in its original position. + group: 'molecule' + explevel: expert +mol_shape_1: + default: false + type: boolean + title: Is the molecule a shape? + short: Defines a molecule as a shape. + long: Defines a molecule as a shape, which is a collection of beads. + group: 'molecule' + explevel: easy +# +# Group distance restraints +# +ambig_fname: + default: '' + type: file + title: Ambiguous distance restraints filename + short: Filename of the ambiguous distance restraints file + long: Filename of the ambiguous distance restraints file. By default 50% of those restraints will be randomly discared. + This can be changed/turned off and is controlled by the randremoval and npart parameters. + Note that this file can contain both ambiguous and unambiguous restraints. + group: 'distance restraints' + explevel: easy +previous_ambig: + default: false + type: boolean + title: Boolean condition on the previous ambiguous distance restraints file + short: Boolean condition on the previous ambiguous distance restraints file. + If true, use the the restraint information coming from the previous CNS module. If false, don't use previous information. + long: Boolean condition on the ambiguous distance restraints file. + If true, use the restraint information coming from the previous CNS module, as long as an ambig_fname is not defined for the current module. + If false, don't use previous information. + group: 'distance restraints' + explevel: expert +unambig_fname: + default: '' + type: file + title: Unambiguous restraints filename + short: Filename of the unambiguous distance restraints file + long: Filename of the unambiguous distance restraints file. All restraints in that file will be used. + Note that this file can contain both ambiguous and unambiguous restraints. + group: 'distance restraints' + explevel: easy +hbond_fname: + default: '' + type: file + title: H-bond restraints filename + short: Filename of the hydrogen bond distance restraints file + long: Filename of the hydrogen bond distance restraints file. Note that this file can contain any type of distance restraints. + group: 'distance restraints' + explevel: easy +ambig_scale: + default: 50 + type: integer + min: 0 + max: 1000 + title: Force constant for ambiguous distance restraints + short: Force constant applied to the distance restraints defined in ambig_fname. + long: Force constant applied to the distance restraints defined in ambig_fname. + group: 'distance restraints' + explevel: expert +unambig_scale: + default: 50 + type: integer + min: 0 + max: 1000 + title: Force constant for unambiguous distance restraints + short: Force constant applied to the distance restraints defined in unambig_fname. + long: Force constant applied to the distance restraints defined in unambig_fname. + group: 'distance restraints' + explevel: expert +hbond_scale: + default: 50 + type: integer + min: 0 + max: 1000 + title: Force constant for hbonds distance restraints + short: Force constant applied to the distance restraints defined in hbond_fname. + long: Force constant applied to the distance restraints defined in hbond_fname. + group: 'distance restraints' + explevel: expert +randremoval: + default: true + type: boolean + title: Random removal of ambiguous restraints + short: If set to true (default) this will cause the random removal of ambiguous restraints for each model generated. + long: If set to true (default) this will cause the random removal of ambiguous restraints for each model generated. + The fraction of restraints randomly removed depends on the npart parameter which defines in how many sets the restraints should be randomly split. + The first set will be removed. The fraction of randomly removed ambiguous restraints is thus 1/npart. + group: 'distance restraints' + explevel: expert +npart: + default: 2 + type: integer + min: 1 + max: 20 + title: Number partitions for ambiguous restraints + short: Number of sets into which to randomly partition the ambiguous restraints. + long: Number of sets into which to randomly partition the ambiguous restraints. + The fraction of restraints randomly removed depends on the npart parameter which defines in how many sets the restraints should be randomly split. + The first set will be removed. The fraction of randomly removed ambiguous restraints is thus 1/npart. + group: 'distance restraints' + explevel: expert +contactairs: + default: false + type: boolean + title: Contact restraints + short: Contact restraints between molecules + long: Contact restraints between molecules. These are defined as ambiguous distance restraint + between each residue of a molecule and all residues of the other molecules with 5A from that residue. + This can be used to restraint the contacts between the interfaces. Note that this can generate a large number of ambiguous restraints + and slow down the computations + group: 'distance restraints' + explevel: expert +kcont: + default: 1.0 + type: float + min: 0 + max: 1000 + precision: 1 + title: Contact restraints force constant + short: Force constant applied to the contact restraints. + long: Force constant applied to the contact restraints. + group: 'distance restraints' + explevel: expert +# +# Group dihedral restraints +# +dihe_fname: + default: '' + type: file + title: Dihedral angle restraints filename + short: Filename of the Dihedral angle restraints file + long: Filename of the Dihedral angle restraints file. + group: 'dihedral restraints' + explevel: easy +dihedrals_on: + default: false + type: boolean + title: Use dihedral angle restraints + short: Turns on dihedral angle restraints. + long: Turns on dihedral angle restraints. Those should be defined in the dihe_fname file. + group: 'dihedral restraints' + explevel: easy +dihedrals_scale: + default: 200 + type: integer + min: 0 + max: 9999 + title: Force constant for dihedral angle restraints + short: Force constant applied to the dihedral angle restraints read from dihe_fname. + long: Force constant applied to the dihedral angle restraints read from dihe_fname. + group: 'dihedral restraints' + explevel: easy +ssdihed: + default: none + type: string + minchars: 0 + maxchars: 100 + choices: + - none + - all + - alpha + - alphabeta + title: Define automatically backbone dihedral angle restraints + short: If turned on, this option will automatically defined backbone dihedral angle restraints for the selected regions. + long: This option allows to utomatically defined backbone dihedral angle restraints for the selected regions. + The restraints will be defined for the phi and psi backbone dihedral angles of amino acids, with the target value taken from + the measured angle in the input structure, and the error bound defined by the error_dih parameter. + Those restraints can be applied to the entire structure (all), the alpha/beta secondary structure elements (alphabeta) or + only to the alpha helical regions (alpha). Those are automatically detected based on the measured dihedral angle combinations. + group: 'dihedral restraints' + explevel: easy +error_dih: + default: 10 + type: integer + min: 0 + max: 180 + title: Force constant for backbone dihedral angle restraints + short: Force constant for backbone dihedral angle restraints (ssdihed option) + long: Force constant for backbone dihedral angle restraints (ssdihed option) + group: 'dihedral restraints' + explevel: easy +# +# Group other restraints +# +dnarest_on: + default: false + type: boolean + title: Restrain the DNA conformation + short: Automatically creates restraints to maintain the conformation of DNA/RNA + long: "This option allows to restraint the conformation of nucleic acids based on the values from the input structures. + The following restraints will be automatically defined: + - single base planarity + - sugar pucker + - phosphate backbone diherdral angle restraints + - Watson-Crick base pairing" + group: 'other restraints' + explevel: easy +# +# Group symmetry +# +sym_on: + default: false + type: boolean + title: Symmetry restraints + short: Enables symmetry restraints + long: Enables symmetry restraints. The symmetry type (C2,C3,C4,C5,C6,S3 supported) + and the segments to which those apply must be defined. In addition a custom symmetry restraint file can be supplied (symrest_fname). + group: 'symmetry' + explevel: expert +ksym: + default: 10.0 + type: float + min: 0 + max: 1000 + precision: 1 + title: Force constant for symmetry restraints + short: Force constant for symmetry restraints + long: Force constant for symmetry restraints + group: 'symmetry' + explevel: expert +symtbl_fname: + default: '' + type: file + title: Custom symmetry restraints filename + short: Filename of the custom symmetry restraints file + long: Filename of the custom symmetry restraints file. + group: 'symmetry' + explevel: expert +nc2sym: + default: 0 + type: integer + min: 0 + max: 40 + title: Number of C2 symmetry restraints + short: Defines the number of C2 symmetry restraints. + long: Defines the number of C2 symmetry restraints. + For each, a pair of segments on which the symmetry restraint is applied will have to be defined. + Those must all have the same length. + group: 'symmetry' + explevel: hidden +c2sym_sta1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the first C2 symmetry segment + long: Residue number of first residue in the first C2 symmetry segment + group: 'symmetry' + explevel: expert +c2sym_end1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the first C2 symmetry segment + long: Residue number of last residue in the first C2 symmetry segment + group: 'symmetry' + explevel: expert +c2sym_seg1_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of first C2 segment + short: Segment ID of first C2 segment + long: Segment ID of first C2 segment + group: 'symmetry' + explevel: expert +c2sym_sta2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the second C2 symmetry segment + long: Residue number of first residue in the second C2 symmetry segment + group: 'symmetry' + explevel: expert +c2sym_end2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the second C2 symmetry segment + long: Residue number of last residue in the second C2 symmetry segment + group: 'symmetry' + explevel: expert +c2sym_seg2_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of second C2 segment + short: Segment ID of second C2 segment + long: Segment ID of second C2 segment + group: 'symmetry' + explevel: expert +nc3sym: + default: 0 + type: integer + min: 0 + max: 10 + title: Number of C3 symmetry restraints + short: Defines the number of C3 symmetry restraints. + long: Defines the number of C3 symmetry restraints. + For each, three segments on which the symmetry restraint is applied will have to be defined. + Those must all have the same length. + group: 'symmetry' + explevel: hidden +c3sym_sta1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the first C3 symmetry segment + long: Residue number of first residue in the first C3 symmetry segment + group: 'symmetry' + explevel: expert +c3sym_end1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the first C3 symmetry segment + long: Residue number of last residue in the first C3 symmetry segment + group: 'symmetry' + explevel: expert +c3sym_seg1_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of first C3 segment + short: Segment ID of first C3 segment + long: Segment ID of first C3 segment + group: 'symmetry' + explevel: expert +c3sym_sta2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the second C3 symmetry segment + long: Residue number of first residue in the second C3 symmetry segment + group: 'symmetry' + explevel: expert +c3sym_end2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the second C3 symmetry segment + long: Residue number of last residue in the second C3 symmetry segment + group: 'symmetry' + explevel: expert +c3sym_seg2_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of second C3 segment + short: Segment ID of second C3 segment + long: Segment ID of second C3 segment + group: 'symmetry' + explevel: expert +c3sym_sta3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the third C3 symmetry segment + long: Residue number of first residue in the third C3 symmetry segment + group: 'symmetry' + explevel: expert +c3sym_end3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the third C3 symmetry segment + long: Residue number of last residue in the third C3 symmetry segment + group: 'symmetry' + explevel: expert +c3sym_seg3_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of third C3 segment + short: Segment ID of third C3 segment + long: Segment ID of third C3 segment + group: 'symmetry' + explevel: expert +nc4sym: + default: 0 + type: integer + min: 0 + max: 10 + title: Number of C4 symmetry restraints + short: Defines the number of C4 symmetry restraints. + long: Defines the number of C4 symmetry restraints. + For each, four segments on which the symmetry restraint is applied will have to be defined. + Those must all have the same length. + group: 'symmetry' + explevel: hidden +c4sym_sta1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the first C4 symmetry segment + long: Residue number of first residue in the first C4 symmetry segment + group: 'symmetry' + explevel: expert +c4sym_end1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the first C4 symmetry segment + long: Residue number of last residue in the first C4 symmetry segment + group: 'symmetry' + explevel: expert +c4sym_seg1_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of first C4 segment + short: Segment ID of first C4 segment + long: Segment ID of first C4 segment + group: 'symmetry' + explevel: expert +c4sym_sta2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the second C4 symmetry segment + long: Residue number of first residue in the second C4 symmetry segment + group: 'symmetry' + explevel: expert +c4sym_end2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the second C4 symmetry segment + long: Residue number of last residue in the second C4 symmetry segment + group: 'symmetry' + explevel: expert +c4sym_seg2_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of second C4 segment + short: Segment ID of second C4 segment + long: Segment ID of second C4 segment + group: 'symmetry' + explevel: expert +c4sym_sta3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the third C4 symmetry segment + long: Residue number of first residue in the third C4 symmetry segment + group: 'symmetry' + explevel: expert +c4sym_end3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the third C4 symmetry segment + long: Residue number of last residue in the third C4 symmetry segment + group: 'symmetry' + explevel: expert +c4sym_seg3_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of third C4 segment + short: Segment ID of third C4 segment + long: Segment ID of third C4 segment + group: 'symmetry' + explevel: expert +c4sym_sta4_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the fourth C4 symmetry segment + long: Residue number of first residue in the fourth C4 symmetry segment + group: 'symmetry' + explevel: expert +c4sym_end4_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the fourth C4 symmetry segment + long: Residue number of last residue in the fourth C4 symmetry segment + group: 'symmetry' + explevel: expert +c4sym_seg4_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of fourth C4 segment + short: Segment ID of fourth C4 segment + long: Segment ID of fourth C4 segment + group: 'symmetry' + explevel: expert +nc5sym: + default: 0 + type: integer + min: 0 + max: 10 + title: Number of C5 symmetry restraints + short: Defines the number of C5 symmetry restraints. + long: Defines the number of C5 symmetry restraints. + For each, five segments on which the symmetry restraint is applied will have to be defined. + Those must all have the same length. + group: 'symmetry' + explevel: hidden +c5sym_sta1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the first C5 symmetry segment + long: Residue number of first residue in the first C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_end1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the first C5 symmetry segment + long: Residue number of last residue in the first C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_seg1_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of first C5 segment + short: Segment ID of first C5 segment + long: Segment ID of first C5 segment + group: 'symmetry' + explevel: expert +c5sym_sta2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the second C5 symmetry segment + long: Residue number of first residue in the second C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_end2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the second C5 symmetry segment + long: Residue number of last residue in the second C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_seg2_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of second C5 segment + short: Segment ID of second C5 segment + long: Segment ID of second C5 segment + group: 'symmetry' + explevel: expert +c5sym_sta3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the third C5 symmetry segment + long: Residue number of first residue in the third C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_end3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the third C5 symmetry segment + long: Residue number of last residue in the third C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_seg3_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of third C5 segment + short: Segment ID of third C5 segment + long: Segment ID of third C5 segment + group: 'symmetry' + explevel: expert +c5sym_sta4_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the fourth C5 symmetry segment + long: Residue number of first residue in the fourth C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_end4_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the fourth C5 symmetry segment + long: Residue number of last residue in the fourth C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_seg4_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of fourth C5 segment + short: Segment ID of fourth C5 segment + long: Segment ID of fourth C5 segment + group: 'symmetry' + explevel: expert +c5sym_sta5_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the fifth C5 symmetry segment + long: Residue number of first residue in the fifth C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_end5_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the fifth C5 symmetry segment + long: Residue number of last residue in the fifth C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_seg5_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of fifth C5 segment + short: Segment ID of fifth C5 segment + long: Segment ID of fifth C5 segment + group: 'symmetry' + explevel: expert +nc6sym: + default: 0 + type: integer + min: 0 + max: 10 + title: Number of C6 symmetry restraints + short: Defines the number of C6 symmetry restraints. + long: Defines the number of C6 symmetry restraints. + For each, six segments on which the symmetry restraint is applied will have to be defined. + Those must all have the same length. + group: 'symmetry' + explevel: hidden +c6sym_sta1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the first C6 symmetry segment + long: Residue number of first residue in the first C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_end1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the first C6 symmetry segment + long: Residue number of last residue in the first C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_seg1_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of first C6 segment + short: Segment ID of first C6 segment + long: Segment ID of first C6 segment + group: 'symmetry' + explevel: expert +c6sym_sta2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the second C6 symmetry segment + long: Residue number of first residue in the second C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_end2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the second C6 symmetry segment + long: Residue number of last residue in the second C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_seg2_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of second C6 segment + short: Segment ID of second C6 segment + long: Segment ID of second C6 segment + group: 'symmetry' + explevel: expert +c6sym_sta3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the third C6 symmetry segment + long: Residue number of first residue in the third C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_end3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the third C6 symmetry segment + long: Residue number of last residue in the third C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_seg3_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of third C6 segment + short: Segment ID of third C6 segment + long: Segment ID of third C6 segment + group: 'symmetry' + explevel: expert +c6sym_sta4_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the fourth C6 symmetry segment + long: Residue number of first residue in the fourth C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_end4_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the fourth C6 symmetry segment + long: Residue number of last residue in the fourth C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_seg4_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of fourth C6 segment + short: Segment ID of fourth C6 segment + long: Segment ID of fourth C6 segment + group: 'symmetry' + explevel: expert +c6sym_sta5_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the fifth C6 symmetry segment + long: Residue number of first residue in the fifth C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_end5_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the fifth C6 symmetry segment + long: Residue number of last residue in the fifth C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_seg5_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of fifth C6 segment + short: Segment ID of fifth C6 segment + long: Segment ID of fifth C6 segment + group: 'symmetry' + explevel: expert +c6sym_sta6_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the sixth C6 symmetry segment + long: Residue number of first residue in the sixth C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_end6_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the sixth C6 symmetry segment + long: Residue number of last residue in the sixth C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_seg6_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of sixth C6 segment + short: Segment ID of sixth C6 segment + long: Segment ID of sixth C6 segment + group: 'symmetry' + explevel: expert +ns3sym: + default: 0 + type: integer + min: 0 + max: 10 + title: Number of S3 symmetry restraints + short: Defines the number of S3 symmetry restraints. + long: Defines the number of S3 symmetry restraints. + For each, three segments on which the symmetry restraint is applied will have to be defined. + Those must all have the same length. + group: 'symmetry' + explevel: hidden +s3sym_sta1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the first S3 symmetry segment + long: Residue number of first residue in the first S3 symmetry segment + group: 'symmetry' + explevel: expert +s3sym_end1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the first S3 symmetry segment + long: Residue number of last residue in the first S3 symmetry segment + group: 'symmetry' + explevel: expert +s3sym_seg1_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of first S3 segment + short: Segment ID of first S3 segment + long: Segment ID of first S3 segment + group: 'symmetry' + explevel: expert +s3sym_sta2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the second S3 symmetry segment + long: Residue number of first residue in the second S3 symmetry segment + group: 'symmetry' + explevel: expert +s3sym_end2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the second S3 symmetry segment + long: Residue number of last residue in the second S3 symmetry segment + group: 'symmetry' + explevel: expert +s3sym_seg2_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of second S3 segment + short: Segment ID of second S3 segment + long: Segment ID of second S3 segment + group: 'symmetry' + explevel: expert +s3sym_sta3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the third S3 symmetry segment + long: Residue number of first residue in the third S3 symmetry segment + group: 'symmetry' + explevel: expert +s3sym_end3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the third S3 symmetry segment + long: Residue number of last residue in the third S3 symmetry segment + group: 'symmetry' + explevel: expert +s3sym_seg3_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of third S3 segment + short: Segment ID of third S3 segment + long: Segment ID of third S3 segment + group: 'symmetry' + explevel: expert +ncs_on: + default: false + type: boolean + title: Non-crystallographic symmetry restraints + short: Non-crystallographic symmetry restraints to ensure two molecules will have the same conformation. + long: Non-crystallographic symmetry restraints to ensure two molecules will have the same conformation. + This does not apply any symmetry between the two molecules but rather defines restraints such as the RMSD between those is 0. + group: 'symmetry' + explevel: expert +kncs: + default: 1.0 + type: float + min: 0 + max: 1000 + precision: 1 + title: Force constant for non-crystallographic restraints + short: Force constant for non-crystallographic restraints + long: Force constant for non-crystallographic restraints + group: 'symmetry' + explevel: expert +nncs: + default: 0 + type: integer + min: 0 + max: 100 + title: Number of non-crystallographic symmetry restraints + short: Number of non-crystallographic symmetry restraints (NCS). + long: Number of non-crystallographic symmetry restraints. For each pairs of segments will have to be defined. + Note that those must contain exactly the same residues/atom combinations. + group: 'symmetry' + explevel: hidden +ncs_sta1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the first NCS segment + long: Residue number of first residue in the first NCS segment + group: 'symmetry' + explevel: expert +ncs_end1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the first NCS segment + long: Residue number of last residue in the first NCS segment + group: 'symmetry' + explevel: expert +ncs_seg1_1: + default: '' + type: string + minchars: 0 + maxchars: 100 + title: Segment ID of first NCS segment + short: Segment ID of first NCS segment + long: Segment ID of first NCS segment + group: 'symmetry' + explevel: expert +ncs_sta2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the second NCS segment + long: Residue number of first residue in the second NCS segment + group: 'symmetry' + explevel: expert +ncs_end2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the second NCS segment + long: Residue number of last residue in the second NCS segment + group: 'symmetry' + explevel: expert +ncs_seg2_1: + default: '' + type: string + minchars: 0 + maxchars: 100 + title: Segment ID of second NCS segment + short: Segment ID of second NCS segment + long: Segment ID of second NCS segment + group: 'symmetry' + explevel: expert +# +# Group scoring +# +w_air: + default: 0.1 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the distance restraint energy + short: Weight of the distance restraints energy in the scoring function + long: Weight of the distance restraints energy in the scoring function. + Note that this is different from the force constants used during the calculations. + group: 'scoring' + explevel: expert +w_bsa: + default: 0.0 + type: float + min: -9999 + max: 9999 + precision: 3 + title: Weight of the buried surface area term + short: Weight of the buried surface area term in the scoring function + long: Weight of the buried surface area (BSA) term in the scoring function. + Note that the BSA is only used for scoring. + group: 'scoring' + explevel: expert +w_cdih: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the dihedral angle restraint energy + short: Weight of the dihedral angle restraints energy in the scoring function + long: Weight of the dihedral angle restraints energy in the scoring function. + Note that this is different from the force constant used during the calculations. + group: 'scoring' + explevel: expert +w_dani: + default: 0.1 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the relaxation anisotropy (DANI) restraint energy + short: Weight of the relaxation anisotropy (DANI) restraint energy + long: Weight of the relaxation anisotropy (DANI) restraint energy + group: 'scoring' + explevel: hidden +w_deint: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the interaction energy term + short: Weight of the interaction energy term + long: Weight of the interaction energy term calculated as the difference in total energy of the complex and of the separate components + group: 'scoring' + explevel: hidden +w_desolv: + default: 1.0 + type: float + min: -9999 + max: 9999 + precision: 3 + title: Weight of the desolvation energy term + short: Weight of the desolvation energy term in the scoring function + long: Weight of the desolvation energy term in the scoring function. + Note that the desolvation energy is only used for scoring. + group: 'scoring' + explevel: expert +w_elec: + default: 0.2 + type: float + min: -9999 + max: 9999 + precision: 3 + title: Weight of the intermolecular electrostatic energy + short: Weight of the intermolecular electrostatic energy in the scoring function + long: Weight of the intermolecular electrostatic energy in the scoring function. + Note that this does not affect the electostatic energy during the EM minimization. + group: 'scoring' + explevel: expert +w_lcc: + default: -10000.0 + type: float + min: -10000.0 + max: 0 + precision: 3 + title: Weight of the EM local correlation coefficient + short: Weight of the EM local correlation coefficient + long: Weight of the EM local correlation coefficient + group: 'scoring' + explevel: hidden +w_rg: + default: 1.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the radius of gyration restraint energy + short: Weight of the radius of gyration restraint energy + long: Weight of the radius of gyration restraint energy + group: 'scoring' + explevel: hidden +w_sani: + default: 0.1 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the residual dipolar coupling (SANI) restraint energy + short: Weight of the residual dipolar coupling (SANI) restraint energy + long: Weight of the residual dipolar coupling (SANI) restraint energy + group: 'scoring' + explevel: hidden +w_sym: + default: 0.1 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the symmetry restraint energy + short: Weight of the symmetry restraints energy in the scoring function + long: Weight of the symmetry restraints energy in the scoring function. + Note that this is different from the force constant used during the calculations. + group: 'scoring' + explevel: expert +w_vdw: + default: 1.0 + type: float + min: -9999 + max: 9999 + precision: 3 + title: Weight of the intermolecular van der Waals energy + short: Weight of the intermolecular van der Waals energy in the scoring function + long: Weight of the intermolecular van der Waals energy in the scoring function. + Note that this does not affect the van der Waals energy during the EM minimization. + group: 'scoring' + explevel: expert +w_vean: + default: 0.1 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the residual dipolar coupling (VEAN) restraint energy + short: Weight of the residual dipolar coupling (VEAN) restraint energy + long: Weight of the residual dipolar coupling (VEAN) restraint energy + group: 'scoring' + explevel: hidden +w_xpcs: + default: 0.1 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the pseudo contact shifts (XPCS) restraint energy + short: Weight of the pseudo contact shifts (XPCS) restraint energy + long: Weight of the pseudo contact shifts (XPCS) restraint energy + group: 'scoring' + explevel: hidden +w_xrdc: + default: 0.1 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the residual dipolar coupling (XRDC) restraint energy + short: Weight of the residual dipolar coupling (XRDC) restraint energy + long: Weight of the residual dipolar coupling (XRDC) restraint energy + group: 'scoring' + explevel: hidden +w_zres: + default: 0.1 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the Z-restraining potential energy + short: Weight of the Z-restraining potential energy + long: Weight of the Z-restraining potential energy + group: 'scoring' + explevel: hidden +# +# Group force field +# +ligand_param_fname: + default: '' + type: file + title: Custom ligand parameter file + short: Ligand parameter file in CNS format + long: Ligand parameter file in CNS format containing all force field parameters + (bond, angles, dihedrals, impropers, van der waals) for any ligand not supported by default by HADDOCK + group: 'force field' + explevel: easy +ligand_top_fname: + default: '' + type: file + title: Custom ligand topology file + short: Ligand topology file in CNS format + long: Ligand topology file in CNS format containing the ligand topologies + (atoms, masses, charges, bond definitions...) for any ligand not supported by default by HADDOCK + group: 'force field' + explevel: easy +elecflag: + default: true + type: boolean + title: Include electrostatics energy + short: Include electrostatics energy during the calculations. + long: Include electrostatics energy during the calculations. If set to false electrostatics will not be considered. + group: 'force field' + explevel: easy +dielec: + default: cdie + type: string + minchars: 0 + maxchars: 4 + choices: + - cdie + - rdie + title: Constant (cdie) or distance-dependent dielectric (rdie) constant. + short: Use a constant (cdie option) or a distance-dependent dielectric (rdie) constant in the Coulomb potential. + long: Use a constant (cdie option) or a distance-dependent dielectric (rdie) constant in the Coulomb potential. + A distance dependent dielectric constant will effectively scale down the electrostatic energy + by having a 1/r**2 dependency instead of 1/r + group: 'force field' + explevel: expert +epsilon: + default: 1.0 + type: float + min: 1 + max: 78 + precision: 1 + title: Dielectric constant + short: Dielectric constant for the electrostatic Coulomb energy term. + long: Dielectric constant for the electrostatic Coulomb energy term. + group: 'force field' + explevel: expert +dihedflag: + default: true + type: boolean + title: Use torsion angle dihedral energy term + short: Turns on the torsion angle dihedral energy terms of the force field. + long: Turns on the torsion angle dihedral energy terms of the force field. + group: 'force field' + explevel: expert +# +# Group sampling +# +sampling_factor: + default: 1 + type: integer + min: 1 + max: 500 + title: Sampling factor for each starting model + short: This parameter control how many times a model will be refined. + long: This parameter control how many times a model will be refined. For EM refinement only it does not make sense to increase it unless random removal of restraints is turned on. If not then the energy minimisation will lead to the same final conformation. + group: 'sampling' + explevel: expert +max_nmodels: + default: 50000 + type: integer + min: 1 + max: 100000 + title: Maximum number of models to refine + short: This parameter controls the maximum number of models to refine. + long: This parameter controls the maximum number of models to refine. + group: 'sampling' + explevel: expert +nemsteps: + default: 200 + type: integer + min: 0 + max: 10000 + title: Number of EM steps + short: Number of energy minimisation steps to perform. + long: Number of energy minimisation steps to perform. Note that the effective number might be smaller if the minimisation converges earlier. + group: 'sampling' + explevel: expert +iniseed: + default: 917 + type: integer + min: 0 + max: 9999999999999999 + title: Random seed + short: Random seed used in CNS to initialize the random seed function + long: Random seed used in CNS to initialize the random seed function + group: 'sampling' + explevel: guru +keepwater: + default: false + type: boolean + title: Write water molecules to output file + short: Write water molecules if present to the output file. + long: Write water molecules if present to the output file. + group: 'sampling' + explevel: guru +tolerance: + default: 5 + type: integer + min: 0 + max: 99 + precision: 3 + title: Failure tolerance percentage + short: Percentage of allowed failures for a module to successfully complete + long: Percentage of allowed failures for a module to successfully complete + group: 'module' + explevel: expert +log_level: + default: quiet + type: string + minchars: 0 + maxchars: 100 + choices: + - verbose + - normal + - quiet + title: Log level verbosity for CNS + short: Set the log level verbosity for CNS + long: CNS, the computational engine used by HADDOCK can generate a lot of output + messages. This parameter controls the verbosity of CNS (verbose, normal or quiet). + group: module + explevel: guru +# +# Group flexibility +# +# +# Semi-flexible segments +# +nseg1: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg2: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg3: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg4: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_4_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_4_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg5: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_5_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_5_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg6: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_6_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_6_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg7: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_7_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_7_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg8: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_8_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_8_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg9: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_9_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_9_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg10: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_10_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_10_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg11: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_11_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_11_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg12: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_12_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_12_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg13: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_13_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_13_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg14: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_14_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_14_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg15: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_15_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_15_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg16: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_16_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_16_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg17: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_17_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_17_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg18: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_18_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_18_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg19: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_19_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_19_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg20: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_20_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_20_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +# +# Fully flexible segments +# +nfle: + default: 0 + type: integer + min: 0 + max: 1000 + title: Number of fully flexible segments + short: This defines the number of fully flexible segments. + long: This parameter defines the number of fully flexible segments for all molecules. + If >=1 then those must be defined manually with segment ID (segid) in the fle_seg_* variable, + followed by the starting and ending residue numbers in the fle_sta_* and fle_end_* variables. + group: 'flexibility' + explevel: hidden +fle_sta_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the fully flexible segment. + long: Residue number defining the start of this (1st) fully flexible segment. + group: 'flexibility' + explevel: expert +fle_end_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: End residue number + short: Residue number defining the end of the fully flexible segment. + long: Residue number defining the end of this (1st) fully flexible segment. + group: 'flexibility' + explevel: expert +fle_seg_1: + default: none + type: string + minchars: 1 + maxchars: 4 + title: Segment ID (segid) + short: Segment ID of the molecule for which this flexible segment is defined. + long: Segment ID of the molecule for which this (1st) flexible segment is defined. + group: 'flexibility' + explevel: expert +# +# Group interaction matrix +# +int_1_1: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_2: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_3: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_4: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_5: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_6: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_7: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_8: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_9: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_2: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_3: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_4: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_5: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_6: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_7: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_8: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_9: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_3: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_4: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_5: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_6: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_7: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_8: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_9: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_4: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_5: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_6: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_7: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_8: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_9: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_5: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_6: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_7: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_8: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_9: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_6: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_7: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_8: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_9: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_7: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_8: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_9: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_8: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_9: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_9: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_12_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_12_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_12_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_12_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_12_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_12_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_12_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_12_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_12_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_13_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_13_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_13_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_13_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_13_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_13_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_13_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_13_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_14_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_14_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_14_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_14_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_14_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_14_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_14_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_15_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_15_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_15_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_15_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_15_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_15_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_16_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_16_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_16_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_16_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_16_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_17_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_17_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_17_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_17_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_18_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_18_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_18_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_19_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_19_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_20_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..bdbea226eb0275756c2c83b6ac20872ae876586f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/__init__.py @@ -0,0 +1,159 @@ +"""Flexible refinement with CNS. + +The ``[flexref]`` module (also known as ``it1`` stage in HADDOCK2.X series), +is a semi-flexible simulated annealing (SA) protocol based on molecular +dynamics in torsion angle space. + + +This semi-flexible SA consists of several stages: + +* High temperature rigid body molecular dynamics +* Rigid body SA +* Semi-flexible SA with flexible side-chains at the interface +* Semi-flexible SA with fully flexible interface (both backbone and side-chains) + +By default, only the interface regions is treated as flexible. It is automatically +defined based on the intermolecular contacts made. It is also possible to manually +define the semi-flexible regions, and also define fully flexible regions that are +allowed to move throughout the entire protocol from the high temperature rigid +body molecular dynamics on. + +The temperature and number of steps for the various stages can be tuned. +""" + +from pathlib import Path + +from haddock.core.defaults import MODULE_DEFAULT_YAML +from haddock.core.typing import FilePath +from haddock.gear.haddockmodel import HaddockModel +from haddock.libs.libcns import prepare_cns_input, prepare_expected_pdb +from haddock.libs.libontology import PDBFile +from haddock.libs.libsubprocess import CNSJob +from haddock.modules import get_engine +from haddock.modules.base_cns_module import BaseCNSModule + + +RECIPE_PATH = Path(__file__).resolve().parent +DEFAULT_CONFIG = Path(RECIPE_PATH, MODULE_DEFAULT_YAML) + + +class HaddockModule(BaseCNSModule): + """HADDOCK3 module for flexible refinement.""" + + name = RECIPE_PATH.name + + def __init__( + self, order: int, path: Path, initial_params: FilePath = DEFAULT_CONFIG + ) -> None: + cns_script = Path(RECIPE_PATH, "cns", "flexref.cns") + super().__init__(order, path, initial_params, cns_script=cns_script) + + @classmethod + def confirm_installation(cls) -> None: + """Confirm module is installed.""" + return + + def _run(self) -> None: + """Execute module.""" + # Pool of jobs to be executed by the CNS engine + jobs: list[CNSJob] = [] + + # Get the models generated in previous step + try: + models_to_refine = self.previous_io.retrieve_models() + except Exception as e: + self.finish_with_error(e) + + self.output_models: list[PDBFile] = [] + idx = 1 + sampling_factor = self.params["sampling_factor"] + if sampling_factor > 1: + self.log(f"sampling_factor={sampling_factor}") + if sampling_factor == 0: + self.log("[Warning] sampling_factor cannot be 0, setting it to 1") + sampling_factor = 1 + if sampling_factor > 100: + self.log("[Warning] sampling_factor is larger than 100") + + max_nmodels = self.params["max_nmodels"] + nmodels = len(models_to_refine) * sampling_factor + if nmodels > max_nmodels: + self.finish_with_error( + f"Too many models ({nmodels}) to refine, max_nmodels =" + f" {max_nmodels}. Please reduce the number of models or" + " decrease the sampling_factor." + ) + + # checking the ambig_fname: + try: + prev_ambig_fnames = [mod.restr_fname for mod in models_to_refine] + except Exception as e: # noqa:F841 + # cannot extract restr_fname info from tuples + prev_ambig_fnames = [None for model in models_to_refine] + + ambig_fnames = self.get_ambig_fnames(prev_ambig_fnames) + + model_idx = 0 + idx = 1 + for model in models_to_refine: + # assign ambig_fname + if ambig_fnames: + ambig_fname = ambig_fnames[model_idx] + else: + ambig_fname = self.params["ambig_fname"] + model_idx += 1 + + for _ in range(self.params["sampling_factor"]): + # prepare cns input + flexref_input = prepare_cns_input( + idx, + model, + self.path, + self.recipe_str, + self.params, + "flexref", + ambig_fname=ambig_fname, + native_segid=True, + debug=self.params["debug"], + seed=model.seed if isinstance(model, PDBFile) else None, + ) + + out_file = f"flexref_{idx}.out" + err_fname = f"flexref_{idx}.cnserr" + + # create the expected PDBobject + expected_pdb = prepare_expected_pdb(model, idx, ".", "flexref") + expected_pdb.restr_fname = ambig_fname + try: + expected_pdb.ori_name = model.file_name + except AttributeError: + expected_pdb.ori_name = None + self.output_models.append(expected_pdb) + + job = CNSJob(flexref_input, out_file, err_fname, envvars=self.envvars) + + jobs.append(job) + + idx += 1 + + # Run CNS Jobs + self.log(f"Running CNS Jobs n={len(jobs)}") + Engine = get_engine(self.params["mode"], self.params) + engine = Engine(jobs) + engine.run() + self.log("CNS jobs have finished") + + # Get the weights from the defaults + _weight_keys = ("w_vdw", "w_elec", "w_desolv", "w_air", "w_bsa") + weights = {e: self.params[e] for e in _weight_keys} + + for pdb in self.output_models: + if pdb.is_present(): + haddock_model = HaddockModel(pdb.file_name) + pdb.unw_energies = haddock_model.energies + + haddock_score = haddock_model.calc_haddock_score(**weights) + pdb.score = haddock_score + + # Save module information + self.export_io_models(faulty_tolerance=self.params["tolerance"]) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f60547a4d2ce5c9642179f62df52ff672586edcf Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/calc_free-ene.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/calc_free-ene.cns new file mode 100644 index 0000000000000000000000000000000000000000..0466f939be3a1b65c698e77621e36fbcd68e0174 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/calc_free-ene.cns @@ -0,0 +1,24 @@ +! calc_free-ene.cns +! Calculate the total energy of the separated components +! +! Script uses the store1 and store2 atom object, and COMP, REF and RMSD object +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +@MODULE:scale_intra_only.cns + +evaluate ($eintfree = 0.0) +@MODULE:flex_segment_back.cns +fix sele=(((attr store5 = 0) or resn ANI or resn DAN or resn XAN or resn SHA) and not name H* and not (resn WAT or resn HOH or resn TIP*)) end + +minimize powell nstep=100 drop=10.0 nprint=25 end +fix sele=(not all) end +energy end +evaluate ($eintfree = $bond + $angl + $impr + $dihe + $vdw + $elec) + +display FREE MOLECULES INTERNAL ENERGY = $eintfree diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/check-homomers.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/check-homomers.cns new file mode 100644 index 0000000000000000000000000000000000000000..7faf7a4c90f49812724e0a5e217f380cba1b712f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/check-homomers.cns @@ -0,0 +1,56 @@ +! check-homomers.cns +! check for homomeric complexes +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +evaluate ($homosymmetry = false) + +evaluate($n_moving_mol = 0) +evaluate ($ncount = 0) +while ($ncount < $data.ncomponents) loop checkmol + evaluate ($ncount = $ncount + 1) + if ($mol_shape_$ncount eq false) then + evaluate($n_moving_mol = $n_moving_mol + 1) + end if +end loop checkmol + +if ($data.flags.sym eq true) then + if ($data.nc2sym > 0) then + if ($n_moving_mol = 2) then + evaluate ($homosymmetry = true) + end if + end if + if ($data.nc2sym = 6) then + if ($n_moving_mol = 4) then + evaluate ($homosymmetry = true) + end if + end if + if ($data.nc3sym > 0) then + if ($n_moving_mol = 3) then + evaluate ($homosymmetry = true) + end if + end if + if ($data.nc4sym > 0) then + if ($n_moving_mol = 4) then + evaluate ($homosymmetry = true) + end if + end if + if ($data.nc5sym > 0) then + if ($n_moving_mol = 5) then + evaluate ($homosymmetry = true) + end if + end if + if ($data.nc6sym > 0) then + if ($n_moving_mol = 6) then + evaluate ($homosymmetry = true) + end if + end if +end if + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/check_coordinates.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/check_coordinates.cns new file mode 100644 index 0000000000000000000000000000000000000000..d23c8e64804060c61ff6aeea38925dc8e61dc8d6 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/check_coordinates.cns @@ -0,0 +1,100 @@ +! check_coordinates.cns +! Check max/min coordinates for compatibility with PDB format +! +! *********************************************************************** +! * Copyright 2025 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +evaluate ($failure = false) + +!check for coordinates >9999.999 (max writable in PDB format) + +show max (x) (all) +evaluate ($maxcoor = $result) +show max (y) (all) +if ($result gt $maxcoor) then + evaluate ($maxcoor = $result) +end if +show max (z) (all) +if ($result gt $maxcoor) then + evaluate ($maxcoor = $result) +end if +if ($maxcoor gt 9999.999) then + evaluate ($failure = true) +end if + +!check for coordinates <-999.999 (min writable in PDB format) + +show min (x) (all) +evaluate ($mincoor = $result) +show min (y) (all) +if ($result lt $mincoor) then + evaluate ($maxcoor = $result) +end if +show min (z) (all) +if ($result lt $mincoor) then + evaluate ($mincoor = $result) +end if +if ($mincoor lt -999.999) then + evaluate ($failure = true) +end if + +!if problem detected try correcting it by centering the system around 4500,4500,4500 +!but only if no EM restraints are used + +if ($failure eq true) then + if ($data.flags.em eq false) then + + evaluate ($xc = 0.0) + evaluate ($yc = 0.0) + evaluate ($zc = 0.0) + show ave (x) (all) + evaluate ($xc = 4500 - $result) + show ave (y) (all) + evaluate ($yc = 4500 - $result) + show ave (z) (all) + evaluate ($zc = 4500 -$result) + + do (x = x + $xc) (all) + do (y = y + $yc) (all) + do (z = z + $zc) (all) + + evaluate ($failure = false) + evaluate ($maxcoor = -999) + evaluate ($mincoor = 9999) + !check again for coordinates >9999.999 (max writable in PDB format) + show max (x) (all) + evaluate ($maxcoor = $result) + show max (y) (all) + if ($result gt $maxcoor) then + evaluate ($maxcoor = $result) + end if + show max (z) (all) + if ($result gt $maxcoor) then + evaluate ($maxcoor = $result) + end if + if ($maxcoor gt 9999.999) then + evaluate ($failure = true) + end if + + !check for coordinates <-999.999 (min writable in PDB format) + show min (x) (all) + evaluate ($mincoor = $result) + show min (y) (all) + if ($result lt $mincoor) then + evaluate ($maxcoor = $result) + end if + show min (z) (all) + if ($result lt $mincoor) then + evaluate ($mincoor = $result) + end if + if ($mincoor lt -999.999) then + evaluate ($failure = true) + end if + end if +end if + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/cm-restraints.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/cm-restraints.cns new file mode 100644 index 0000000000000000000000000000000000000000..51a4b9e4a4ed699653e4e65c1ddaa729202f3628 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/cm-restraints.cns @@ -0,0 +1,131 @@ +! cm-restraints.cns +! Define center-of-mass restraints between molecules +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +!define center of mass restraints between all molecules +!using distance restraints between CA, BB or N1 atoms with center averaging + +evaluate ($ncount = 0) + +! store original coordinates +do (refx = x) (all) +do (refy = y) (all) +do (refz = z) (all) + +while ($ncount < $data.ncomponents) loop nloop1 + evaluate ($ncount = $ncount +1) + evaluate ($dim_$ncount = 0.0) + + !orient molecule + coor orient sele=(segid $prot_segid_$ncount) end + + ! find dimensions + show max (x) (segid $prot_segid_$ncount and (name CA or name BB or name N1)) + evaluate ($xdim = $result) + show max (y) (segid $prot_segid_$ncount and (name CA or name BB or name N1)) + evaluate ($ydim = $result) + show max (z) (segid $prot_segid_$ncount and (name CA or name BB or name N1)) + evaluate ($zdim = $result) + show min (x) (segid $prot_segid_$ncount and (name CA or name BB or name N1)) + evaluate ($xdim = $xdim - $result) + show min (y) (segid $prot_segid_$ncount and (name CA or name BB or name N1)) + evaluate ($ydim = $ydim - $result) + show min (z) (segid $prot_segid_$ncount and (name CA or name BB or name N1)) + evaluate ($zdim = $zdim - $result) + + evaluate ($corr = max($xdim,$ydim)) + evaluate ($corr = max($corr,$zdim)) + + if ($data.cmtight eq false) then + ! use average of all three dimensions + evaluate ($dim_$ncount = ($xdim + $ydim + $zdim)/6.0) + else + ! use only the average of the smallest two dimensions + evaluate ($dim_$ncount = ($xdim + $ydim + $zdim - $corr)/4.0) + end if + + ! check for anything not protein + do (store6 = 0) (all) + do (store6 = 1) (segid $prot_segid_$ncount and (name CA or name BB)) + show sum (store6) (all) + if ($result eq 0) then + ! we are dealing with a ligand, nucleic acid or glycan -> set dimension to 0 + evaluate ($dim_$ncount = 0.0) + end if + +end loop nloop1 + +! restore original coordinates +do (x = refx) (all) +do (y = refy) (all) +do (z = refz) (all) + +eval($nchain = 0) +do (store9 = 0) (all) +do (store9 = 1) (name CA or name BB or name N1) +while ($nchain < $data.ncomponents) loop nloop0 + eval($nchain = $nchain + 1) + show sum (store9) (segid $prot_segid_$nchain) + if ($result < 3) then + evaluate ($selat$nchain = 0 ) + else + evaluate ($selat$nchain = 1 ) + end if +end loop nloop0 + +eval($nchain1 = 0) +noe + class contact + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + eval($nchain2 = $nchain1 ) + if ($mol_shape_$nchain1 eq false) then + while ($nchain2 < $data.ncomponents) loop nloop2 + eval($nchain2 = $nchain2 + 1) + if ($mol_shape_$nchain2 eq false) then + if ($data.cmtight eq false) then + eval($cm_dist = $dim_$nchain1 + $dim_$nchain2) + else + eval($cm_dist = ($dim_$nchain1 + $dim_$nchain2)/2 ) + end if + if ($selat$nchain1 = 1) then + if ($selat$nchain2 = 1) then + assign (segid $prot_segid_$nchain1 and ( name CA or name BB or name N1 )) + (segid $prot_segid_$nchain2 and ( name CA or name BB or name N1 )) $cm_dist $cm_dist 1.0 + else + assign (segid $prot_segid_$nchain1 and ( name CA or name BB or name N1 )) + (segid $prot_segid_$nchain2) $cm_dist $cm_dist 1.0 + end if + else + if ($selat$nchain2 = 1) then + assign (segid $prot_segid_$nchain1) + (segid $prot_segid_$nchain2 and ( name CA or name BB or name N1 )) $cm_dist $cm_dist 1.0 + else + assign (segid $prot_segid_$nchain1) + (segid $prot_segid_$nchain2) $cm_dist $cm_dist 1.0 + end if + end if + end if + end loop nloop2 + end if + end loop nloop1 + + averaging contact center + scale contact $data.kcm + sqconstant contact 1.0 + sqexponent contact 2 + soexponent contact 1 + rswitch contact 1.0 + sqoffset contact 0.0 + asymptote contact 2.0 + msoexponent contact 1 + masymptote contact -0.1 + mrswitch contact 1.0 +end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/contactairs.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/contactairs.cns new file mode 100644 index 0000000000000000000000000000000000000000..aa8028ab7d3b40e56df692afec9eda66b1a45c68 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/contactairs.cns @@ -0,0 +1,27 @@ +! contactairs.cns +! Define ambiguous distance restraints between residues at interfaces +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +eval($nchain1 = 0) +while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + for $id in id (tag and segid $prot_segid_$nchain1 + and (not (segid $prot_segid_$nchain1 or resn ANI or resn DAN or resn XAN + or resn SHA or resn WAT or resn HOH or resn TIP* or resn DUM) around 5.0)) loop defnoe1 + show (resid) (id $id) + evaluate ($inres = $result) + noe + assign (resid $inres and segid $prot_segid_$nchain1) + (byres (not (segid $prot_segid_$nchain1 or resn ANI or resn DAN or resn XAN + or resn SHA or resn WAT or resn HOH or resn TIP* or resn DUM) + and (segid $prot_segid_$nchain1) around 5.0)) 2.0 2.0 0.0 + end + end loop defnoe1 +end loop nloop1 diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/covalions.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/covalions.cns new file mode 100644 index 0000000000000000000000000000000000000000..85d6417f7c77bc719af19199aa24d2b197c4cd71 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/covalions.cns @@ -0,0 +1,83 @@ +! covalions.cns +! Add a covalent bond between an ion and its closest coordinating atom +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +evaluate ($pcount = 0) +for $id1 in id ( name "LI+1" or name "F-1" or name "NA+1" or name "MG+2" or name "AL+3" + or name "CL-1" or name "K+1" or name "CA+2" or name "V+2" or name "V+3" + or name "CR+2" or name "CR+3" or name "MN+2" or name "MN+3" or name "FE+2" + or name "FE+3" or name "NI+2" or name "CO+2" or name "CO+3" or name "CU+1" + or name "CU+2" or name "ZN+2" or name "BR-1" or name "SR+2" or name "MO+3" + or name "AG+1" or name "CD+2" or name "I-1" or name "CS+2" or name "HO+3" + or name "YB+2" or name "YB+3" or name "OS+4" or name "IR+3" or name "PT+2" + or name "AU+1" or name "AU+2" or name "HG+1" or name "HG+2" or name "PB+2" + or name "U+3" or name "U+4" or name "ZN+1" or name "ZN" ) loop ions + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + show (resname) (id $id1) + evaluate ($resname1=$result) + show (name) (id $id1) + evaluate ($name1=$result) + show (chem) (id $id1) + evaluate ($chem1=$result) + + evaluate ($mindis = 7.5) + evaluate ($minid = 0) + for $id2 in id ( (name O* or name S* or name N*) and (id $id1) around $mindis and + (resn ACE or resn ALA or resn ALY or resn ARG or resn ASN or resn ASH or resn ASP or + resn CSP or resn CTN or resn CYC or resn CYF or resn CYM or resn CYS or resn DDZ or + resn GLN or resn GLH or resn GLU or resn GLY or resn HIS or resn HY3 or resn HYP or + resn ILE or resn LEU or resn LYS or resn M3L or resn MLY or resn MLZ or resn MET or + resn MSE or resn NEP or resn NME or resn PHE or resn PNS or resn PRO or resn PTR or + resn QSR or resn SEP or resn SER or resn SEC or resn THR or resn TOP or resn TRP or + resn TYP or resn TYR or resn TYS or resn VAL or resn A or resn C or resn G or + resn T or resn DA or resn DC or resn DG or resn DT or resn DJ )) loop search + + pick bond (id $id1) (id $id2) geometry + + if ( $result < $mindis) then + evaluate ($mindis = $result) + evaluate ($minid = $id2) + end if + + end loop search + + if ($minid> 0) then + show (segid) (id $minid) + evaluate ($segid2=$result) + show (resid) (id $minid) + evaluate ($resid2=$result) + show (resname) (id $minid) + evaluate ($resname2=$result) + show (name) (id $minid) + evaluate ($name2=$result) + show (chem) (id $minid) + evaluate ($chem2=$result) + + evaluate ($pat1 = "1"+$name1) + evaluate ($pat2 = "2"+$name2) + evaluate ($pcount = $pcount + 1) + evaluate ($pname = "cb" + encode($pcount)) + topology + presidue $pname ! Patch to add a covalent bond between two atoms + add bond $pat1 $pat2 + end + end + patch $pname refe=1=(resid $resid1 and segid $segid1) refe=2=(resid $resid2 and segid $segid2) end + display COVALION: ADDED ONE COVALENT BOND BETWEEN $name1 $resid1 AND $name2 $resname2 $resid2 + end if + + param bond $chem1 $chem2 0.0 $mindis end + +end loop ions + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/def_solv_param.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/def_solv_param.cns new file mode 100644 index 0000000000000000000000000000000000000000..5a9e07a042e08d15d5b98d859fa199151e7b4a43 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/def_solv_param.cns @@ -0,0 +1,105 @@ +! def_solv_param.cns +! Define atomic solvation parameters +! Original valus taken from Fernandez-Recio et al. JMB 335:843 (2004) +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +evaluate ($arofac = 6.26) +evaluate ($alifac = 1.27) +evaluate ($polfac = 2.30) + + +do (store1 = 0.0000) (all) +do (store1 = 0.0151 * $alifac) (name C*) +do (store1 = 0.0176 * $arofac) ((name CG* or name CD* or name CE* or name CH* or name CZ*) and (resn PHE or resn TYR or resn HIS or resn TRP)) +do (store1 = -0.0170 * $polfac) (name N*) +do (store1 = -0.0548 * $polfac) (name NT* or (name NZ* and resn LYS)) +do (store1 = -0.0273 * $polfac) (name NH* and resn ARG) +do (store1 = -0.0136 * $polfac) (name O*) +do (store1 = -0.0185 * $polfac) (name OG* or name OH) +do (store1 = -0.0299 * $polfac) ((name OD* and resn ASP) or (name OE* and resn GLU)) +do (store1 = 0.0112 * $polfac) (name S*) +do (store1 = 0.0022 * $polfac) ((name S* and attr charge = -0.3) or (name SD and resn MET)) +do (store1 = 0.0000) (name SHA) + +! +! CG parameters matched from the original terms +! +! Edesolv_aa +! ASP_cg = _________________________ +! ASA_cg +! +! ASA_cg and Edesol_aa calculated on a GGXGG peptide +! accuracy=0.0025, rh2o=1.4, delete H, sele=(resn X) +! +! e.g. BB bead alanine +! +! BB = CA + C + N + O +! ASA_cg = 176.4940 +! Edesolv_aa = -1.8889 +! +! ASP_cg = -0.0107 +! +! Charleen Don (2012), JR (2014), Jorge Roel (2017) +! +! + +do (store1 = 0.0000) (name BB or name SC*) +! Backbone beads +do (store1 = -0.0107) (name BB and resn ALA) +do (store1 = -0.0089) (name BB and resn GLY) +do (store1 = -0.0153) (name BB and resn ILE) +do (store1 = -0.0158) (name BB and resn VAL) +do (store1 = -0.0046) (name BB and resn PRO) +do (store1 = -0.0137) (name BB and resn ASN) +do (store1 = -0.0147) (name BB and resn GLN) +do (store1 = -0.0165) (name BB and resn THR) +do (store1 = -0.0154) (name BB and resn SER) +do (store1 = -0.0130) (name BB and resn MET) +do (store1 = -0.0167) (name BB and resn CYS) +do (store1 = -0.0126) (name BB and resn PHE) +do (store1 = -0.0134) (name BB and resn TYR) +do (store1 = -0.0134) (name BB and resn TRP) +do (store1 = -0.0169) (name BB and resn ASP) +do (store1 = -0.0150) (name BB and resn GLU) +do (store1 = -0.0155) (name BB and resn HIS) +do (store1 = -0.0163) (name BB and resn LYS) +do (store1 = -0.0162) (name BB and resn ARG) + +! Side-chain beads +!do (store1 = 0.0000) (name SC* and resn ALA) +!do (store1 = 0.0000) (name SC* and resn GLY) +do (store1 = 0.0255) (name SC* and resn ILE) +do (store1 = 0.0222) (name SC* and resn VAL) +do (store1 = 0.0230) (name SC* and resn PRO) +do (store1 = -0.0192) (name SC* and resn ASN) +do (store1 = -0.0135) (name SC* and resn GLN) +do (store1 = -0.0009) (name SC* and resn THR) +do (store1 = -0.0056) (name SC* and resn SER) +do (store1 = 0.0202) (name SC* and resn MET) +do (store1 = 0.0201) (name SC* and resn CYS) +do (store1 = 0.1005) (name SC* and resn PHE) +do (store1 = 0.0669) (name SC* and resn TYR) +do (store1 = 0.0872) (name SC* and resn TRP) +do (store1 = -0.0360) (name SC* and resn ASP) +do (store1 = -0.0301) (name SC* and resn GLU) +do (store1 = 0.0501) (name SC* and resn HIS) +do (store1 = -0.0210) (name SC* and resn LYS) +do (store1 = -0.0229) (name SC* and resn ARG) + +! Fake beads +do (store1 = 0.0) (name SCD* and resn ASN) +do (store1 = 0.0) (name SCD* and resn GLN) +do (store1 = 0.0) (name SCD* and resn SER) +do (store1 = 0.0) (name SCD* and resn THR) +do (store1 = 0.0) (name SCD* and resn ARG) +do (store1 = 0.0) (name SCD* and resn LYS) +do (store1 = 0.0) (name SCD* and resn GLU) +do (store1 = 0.0) (name SCD* and resn ASP) + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/dna-rna_restraints.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/dna-rna_restraints.cns new file mode 100644 index 0000000000000000000000000000000000000000..feb27b3999cec077b4e20abd921dac061b7ded1f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/dna-rna_restraints.cns @@ -0,0 +1,424 @@ +! dna-rna_restraints.def +! Define backbone dihedral angles, hbonds and planarity restraints +! for nucleic acids +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +{+ file: dna-rna_restraints.def +} +{+ description: Creates restraints to maintain conformation of DNA/RNA +} +{+ Additions and changes were made to allow for flexibility during docking +} +{+ comment:This file is to be read by refinement files that modify atom coordinates +} +{+ authors: Axel T. Brunger, and Paul D. Adams +} +{+ modified by Alexandre Bonvin and Marc van Dijk for HADDOCK use +} + +{============================================== base planarity =============================================} + +{* Restrain base planarity. This selection must only include nucleotide residues *} +evaluate ($dna_bases_planar=true) + +{=================================== sugar-pucker dihedral angle restraints ================================} + +{* Pick the dihedral angles of the sugar pucker from the input structure + and restrain them within the given error range *} +evaluate ($dna_pick_pucdih=true) + +{* dihedral C1'-C2'-C3'-C4' error range *} +evaluate ($error_nu2=0.0) +{* dihedral C5'-C4'-C3'-C2' error range *} +evaluate ($error_nu3=0.0) +{* dihedral C1'-O4'-C4'-C5' error range *} +evaluate ($error_nu4=0.0) + +{================================ phosphate backbone dihedral angle restraints =============================} + +{* Pick the dihedral angles of the phosphate backbone from the input structure and + restrain them within the given error range *} +evaluate ($dna_pick_bacdih=true) + +{* Error range for phosphate backbone dihedrals *} +{* alpha dihedral O3'-P-O5'-C5' error range *} +evaluate ($error_alpha=10.0) +{* beta dihedral P-O5'-C5'-C4' error range *} +evaluate ($error_beta=40.0) +{* gamma dihedral O5'-C5'-C4'-C3' error range *} +evaluate ($error_gamma=20.0) +{* delta dihedral C5'-C4'-C3'-O3' error range *} +evaluate ($error_delta=50.0) +{* epsilon dihedral C4'-C3'-O3'-P error range *} +evaluate ($error_eps=10.0) +{* zeta dihedral C3'-O3'-P-O5' error range *} +evaluate ($error_zeta=50.0) + + +{=========================================== Watson-Crick base pairs =======================================} + +{* automatically pick Watson-Crick restraint values from structure *} +evaluate ($dna_pick_wc=true) + +{* error range used for dna_pick_wc defined Watson-Crick restraints *} +evaluate ($wc_low=0.05) +evaluate ($wc_up=0.05) + + +{=========================================== Coarse-Grained ===========================================================} +{* Is the DNA/RNA molecule CG? *} +evaluate ($dna_cg=false) + +{=========================================================================================================} +{ things below this line do not normally need to be changed } +{=========================================================================================================} + + +{- find max and min residue numbers -} +evaluate ($min_resid = 99999) +evaluate ($max_resid = -99999) +show sum(1) ( (resn DA or resn A or resn DG or resn G or resn DT or resn T or resn DC or resn C or resn U) and tag ) +if ( $result > 0 ) then + for $id in id ( (resn DA or resn A or resn DG or resn G or resn DT or resn T or resn DC or resn C or resn U) and tag ) loop resid + show (resid) ( id $id ) + evaluate ($resid=decode($result)) + evaluate ($min_resid = max($min_resid,$resid)) + evaluate ($max_resid = max($max_resid,$resid)) + end loop resid +end if + +{- the planarity restraints single bases -} +if ($dna_bases_planar=true) then + for $id in id ( tag and (resn DA or resn A or resn DG or resn G or resn DT or resn T or resn DC or resn C or resn U) ) loop plan + show (segid) (id $id) + evaluate ($segid=$result) + show (resid) (id $id) + evaluate ($resid=decode($result)) + evaluate ($plweight = 20) + + restraints plane + group + selection=( segid $segid and resid $resid and + (resn T or resn C or resn G or resn A or resn U or + resn DT or resn DC or resn DG or resn DA) and + not (name c#' or name h#' or name h#'' or name o#p or + name h7# or name o#' or name p or name h#t or name o#t)) + weight=$plweight + end + end + end loop plan +end if + +{- Dihedral restraints for the sugar pucker -} + +if ($dna_pick_pucdih=true) then + show sum(1) ( (resn DA or resn A or resn DG or resn G or resn DT or resn T or resn DC or resn C or resn U) and tag ) + if ( $result > 0 ) then + for $id in id ( (resn DA or resn A or resn DG or resn G or resn DT or resn T or resn DC or resn C or resn U) and tag ) loop resid + show (segid) (id $id) + evaluate ($segid=$result) + show (resid) ( id $id ) + evaluate ($resid=decode($result)) + pick dihedral + ( segid $segid and resid $resid and name c1' ) + ( segid $segid and resid $resid and name c2' ) + ( segid $segid and resid $resid and name c3' ) + ( segid $segid and resid $resid and name c4' ) + geometry + evaluatate ($dihedral_nu2=$result) + pick dihedral + ( segid $segid and resid $resid and name c5' ) + ( segid $segid and resid $resid and name c4' ) + ( segid $segid and resid $resid and name c3' ) + ( segid $segid and resid $resid and name c2' ) + geometry + evaluatate ($dihedral_nu3=$result) + pick dihedral + ( segid $segid and resid $resid and name c1' ) + ( segid $segid and resid $resid and name o4' ) + ( segid $segid and resid $resid and name c4' ) + ( segid $segid and resid $resid and name c5' ) + geometry + evaluatate ($dihedral_nu4=$result) + restraints dihedral + assign ( segid $segid and resid $resid and name c1' ) + ( segid $segid and resid $resid and name c2' ) + ( segid $segid and resid $resid and name c3' ) + ( segid $segid and resid $resid and name c4' ) + 20.0 $dihedral_nu2 $error_nu2 2 + assign ( segid $segid and resid $resid and name c5' ) + ( segid $segid and resid $resid and name c4' ) + ( segid $segid and resid $resid and name c3' ) + ( segid $segid and resid $resid and name c2' ) + 20.0 $dihedral_nu3 $error_nu3 2 + assign ( segid $segid and resid $resid and name c1' ) + ( segid $segid and resid $resid and name o4' ) + ( segid $segid and resid $resid and name c4' ) + ( segid $segid and resid $resid and name c5' ) + 20.0 $dihedral_nu4 $error_nu4 2 + scale=20.0 + end + end loop resid + flags include cdih end + end if +end if + +{- Dihedral restraints for the phosphate backbone -} + +if ($dna_pick_bacdih=true) then + show sum(1) ( (resn DA or resn A or resn DG or resn G or resn DT or resn T or resn DC or resn C or resn U) and tag ) + if ( $result > 0 ) then + evaluate ($resid=$min_resid) + evaluate ($nres=$max_resid - $min_resid + 1) + evaluate ($error_alpha=$error_alpha) + evaluate ($error_beta=$error_beta) + evaluate ($error_gamma=$error_gamma) + evaluate ($error_zeta=$error_zeta) + evaluate ($error_epsilon=$error_eps) + evaluate ($error_delta=$error_delta) + for $id in id ( (resn DA or resn A or resn DG or resn G or resn DT or resn T or resn DC or resn C or resn U) and tag ) loop resid + show (segid) (id $id) + evaluate ($segid=$result) + show (resid) ( id $id ) + evaluate ($resid=decode($result)) + if ($resid > $min_resid) then + evaluate ($rprec = $resid - 1) + ! check if previous residue exists + show sum(1) ( resid $rprec and tag ) + if ( $result > 0 ) then + pick dihedral + ( segid $segid and resid $rprec and name O3' ) + ( segid $segid and resid $resid and name P ) + ( segid $segid and resid $resid and name O5' ) + ( segid $segid and resid $resid and name C5' ) + geometry + evaluatate ($dihedral_alpha=$result) + pick dihedral + ( segid $segid and resid $resid and name P ) + ( segid $segid and resid $resid and name O5' ) + ( segid $segid and resid $resid and name C5' ) + ( segid $segid and resid $resid and name C4' ) + geometry + evaluatate ($dihedral_beta=$result) + restraint dihedral + ! alpha + assign ( segid $segid and resid $rprec and name O3' ) + ( segid $segid and resid $resid and name P ) + ( segid $segid and resid $resid and name O5' ) + ( segid $segid and resid $resid and name C5' ) + 1.0 $dihedral_alpha $error_alpha 2 + ! beta + assign ( segid $segid and resid $resid and name P ) + ( segid $segid and resid $resid and name O5' ) + ( segid $segid and resid $resid and name C5' ) + ( segid $segid and resid $resid and name C4' ) + 1.0 $dihedral_beta $error_beta 2 + scale 200.0 + end + end if + end if + + pick dihedral + ( segid $segid and resid $resid and name O5' ) + ( segid $segid and resid $resid and name C5' ) + ( segid $segid and resid $resid and name C4' ) + ( segid $segid and resid $resid and name C3' ) + geometry + evaluatate ($dihedral_gamma=$result) + pick dihedral + ( segid $segid and resid $resid and name C5' ) + ( segid $segid and resid $resid and name C4' ) + ( segid $segid and resid $resid and name C3' ) + ( segid $segid and resid $resid and name O3' ) + geometry + evaluatate ($dihedral_delta=$result) + + restraints dihedral + ! gamma + assign ( segid $segid and resid $resid and name O5' ) + ( segid $segid and resid $resid and name C5' ) + ( segid $segid and resid $resid and name C4' ) + ( segid $segid and resid $resid and name C3' ) + 1.0 $dihedral_gamma $error_gamma 2 + ! delta + assign ( segid $segid and resid $resid and name C5' ) + ( segid $segid and resid $resid and name C4' ) + ( segid $segid and resid $resid and name C3' ) + ( segid $segid and resid $resid and name O3' ) + 1.0 $dihedral_delta $error_delta 2 + scale=200.0 + end + + if ($resid < $max_resid) then + evaluate ($rfoll = $resid + 1) + ! check if next residue exists + show sum(1) ( resid $rfoll and segid $segid and tag ) + if ( $result > 0 ) then + pick dihedral + ( segid $segid and resid $resid and name C4' ) + ( segid $segid and resid $resid and name C3' ) + ( segid $segid and resid $resid and name O3' ) + ( segid $segid and resid $rfoll and name P ) + geometry + evaluatate ($dihedral_epsilon=$result) + pick dihedral + ( segid $segid and resid $resid and name C3' ) + ( segid $segid and resid $resid and name O3' ) + ( segid $segid and resid $rfoll and name P ) + ( segid $segid and resid $rfoll and name O5' ) + geometry + evaluatate ($dihedral_zeta=$result) + restraint dihedral + ! epsilon + assign ( segid $segid and resid $resid and name C4' ) + ( segid $segid and resid $resid and name C3' ) + ( segid $segid and resid $resid and name O3' ) + ( segid $segid and resid $rfoll and name P ) + 1.0 $dihedral_epsilon $error_epsilon 2 + ! zeta + assign ( segid $segid and resid $resid and name C3' ) + ( segid $segid and resid $resid and name O3' ) + ( segid $segid and resid $rfoll and name P ) + ( segid $segid and resid $rfoll and name O5' ) + 1.0 $dihedral_zeta $error_zeta 2 + scale 200.0 + end + end if + end if + end loop resid + flags include cdih end + end if +end if + +{- Watson-Crick base pairing -} + +if ($dna_pick_wc = true) then + evaluate ($hbcut = 3.5) + ! We only to check for ADE and CYT + show sum(1) ( (resn DA or resn A or resn DC or resn C) and tag ) + if ( $result > 0 ) then + noe + class hres + averaging hres cent + potential hres square + sqconstant hres 1. + sqexponent hres 2 + scale hres 70. + end + for $id in id ( (resn DA or resn A or resn DC or resn C) and tag ) loop resid + show (segid) (id $id) + evaluate ($segid=$result) + show (resid) ( id $id ) + evaluate ($resid=decode($result)) + evaluate ($presid=$resid-1) + evaluate ($fresid=$resid+1) + evaluate ($ares_name = none) + show ( resn ) (id $id) + evaluate ($ares=$result) + + if ( $ares = DA ) then + eval ($ares_name = ADE) + elseif ( $ares = A ) then + eval ($ares_name = ADE) + end if + + if ( $ares = DC ) then + eval ($ares_name = CYT) + elseif ( $ares = C ) then + eval ($ares_name = CYT) + end if + + if ($ares_name = ADE) then + show sum(1) ( ((resn DT or resn T or resn U) and not (resid $presid or resid $fresid) and name N3) + and (resid $resid and name N1) around $hbcut) + if ($result = 1) then + show (resid) ( ((resn DT or resn T or resn U) and not (resid $presid or resid $fresid) and name N3) + and (resid $resid and name N1) around $hbcut) + evaluate ($rpair = $result) + pick bond + (resid $resid and name N6) + (resid $rpair and name O4) + geometry + evaluate ($n6o4=$result) + pick bond + (resid $resid and name N1) + (resid $rpair and name N3) + geometry + evaluate ($n1n3=$result) + pick bond + (resid $resid and name N1) + (resid $rpair and name O4) + geometry + evaluate ($n1o4=$result) + pick bond + (resid $resid and name N1) + (resid $rpair and name O2) + geometry + evaluate ($n1o2=$result) + noe + assign (resid $resid and name N6) + (resid $rpair and name O4) + $n6o4 $wc_low $wc_up + assign (resid $resid and name N1) + (resid $rpair and name N3) + $n1n3 $wc_low $wc_up + assign (resid $resid and name N1) + (resid $rpair and name O4) + $n1o4 $wc_low $wc_up + assign (resid $resid and name N1) + (resid $rpair and name O2) + $n1o2 $wc_low $wc_up + end + end if + end if + + !find possible pairing for DC/C with DG/G + if ($ares_name = CYT) then + show sum(1) ( ((resn DG or resn G) and not (resid $presid or resid $fresid) and name N1) + and (resid $resid and name N3) around $hbcut) + if ($result = 1) then + show (resid) ( ((resn DG or resn G) and not (resid $presid or resid $fresid) and name N1) + and (resid $resid and name N3) around $hbcut) + evaluate ($rpair = $result) + pick bond + (resid $resid and name N3) + (resid $rpair and name N1) + geometry + evaluate ($n3n1=$result) + pick bond + (resid $resid and name N4) + (resid $rpair and name O6) + geometry + evaluate ($n4o6=$result) + pick bond + (resid $resid and name O2) + (resid $rpair and name N2) + geometry + evaluate ($o2n2=$result) + pick bond + (resid $resid and name N3) + (resid $rpair and name O6) + geometry + evaluate ($n3o6=$result) + pick bond + (resid $resid and name N3) + (resid $rpair and name N2) + geometry + evaluate ($n3n2=$result) + noe + assign (resid $resid and name N3) + (resid $rpair and name N1) $n3n1 $wc_low $wc_up + assign (resid $resid and name N4) + (resid $rpair and name O6) $n4o6 $wc_low $wc_up + assign (resid $resid and name O2) + (resid $rpair and name N2) $o2n2 $wc_low $wc_up + assign (resid $resid and name N3) + (resid $rpair and name O6) $n3o6 $wc_low $wc_up + assign (resid $resid and name N3) + (resid $rpair and name N2) $n3n2 $wc_low $wc_up + end + end if + end if + end loop resid + end if +end if diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/flex_segment.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/flex_segment.cns new file mode 100644 index 0000000000000000000000000000000000000000..6902f602e00b8280aa423711db2c34ef8dd5df0a --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/flex_segment.cns @@ -0,0 +1,32 @@ +! flex_segment.cns +! Define fully flexible segments for docking +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +do (store5 = 0) (all) + +display NO FLEXIBLE SEGMENTS for all molecule at this stage +if ($nfle = 0) then + display NO FULLY FLEXIBLE SEGMENTS +else + evaluate($nf=0) + while ($nf < $nfle) loop Xfflex + evaluate($nf=$nf + 1) + do (store5 = 1) ( resid $fle_sta_$nf : $fle_end_$nf and segid $fle_seg_$nf ) + display FULLY FLEXIBLE SEGMENT NR $nf FROM $fle_sta_$nf TO $fle_end_$nf FOR CHAIN $fle_seg_$nf + end loop Xfflex +end if + +do (store5 = 21) (resn WAT or resn HOH or resn TIP*) + +do (store1 = 0) (all) +do (store1 = 1) ((resn WAT or resn HOH or resn TIP*) and name OH2) +show sum (store1) ((resn WAT or resn HOH or resn TIP*)) + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/flex_segment_back.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/flex_segment_back.cns new file mode 100644 index 0000000000000000000000000000000000000000..7baf1c9ad9a7e857e14e08c816806b9ff285f010 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/flex_segment_back.cns @@ -0,0 +1,58 @@ +! flex_segment_back.cns +! Define the semi-flexible segments (both side-chains and backbone) +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +do (store5 = 0) (all) +do (store6 = 0) (all) + +!first flexible segments for docking +evaluate($nchain1 = 0) +while ($nchain1 < $data.ncomponents) loop nloop1 + evaluate($nchain1 = $nchain1 + 1) + evaluate($nf=0) + + if ($nseg$nchain1 = 0) then + display NO FLEXIBLE SEGMENTS for molecule $nchain1 + else + if ($nseg$nchain1 < 0) then + display AUTOMATIC DEFINITION OF FLEXIBLE SEGMENTS BASED ON INTERMOLECULAR PROXIMITY FOR MOLECULE $nchain1 + inline @MODULE:flexauto-neighbors.cns + else + display FLEXIBLE SIDE-CHAINS SEGMENTS for molecule $nchain1 + while ($nf < $nseg$nchain1) loop Xflex + evaluate($nf=$nf + 1) + do (store5 = $nchain1) ( resid $seg_sta_$nchain1_$nf : $seg_end_$nchain1_$nf + and segid $prot_segid_$nchain1) + display FLEXIBLE SEGMENT NR $nf FROM $seg_sta_$nchain1_$nf TO $seg_end_$nchain1_$nf + end loop Xflex + end if + end if +end loop nloop1 + +!then fully flexible segments for all stages +display NO FLEXIBLE SEGMENTS for all molecule at this stage +if ($nfle = 0) then + display NO FULLY FLEXIBLE SEGMENTS +else + evaluate($nf=0) + while ($nf < $nfle) loop Xfflex + evaluate($nf=$nf + 1) + do (store5 = 1) ( resid $fle_sta_$nf : $fle_end_$nf and segid $fle_seg_$nf ) + display FULLY FLEXIBLE SEGMENT NR $nf FROM $fle_sta_$nf TO $fle_end_$nf FOR CHAIN $fle_seg_$nf + end loop Xfflex +end if + +do (store5 = 21) (resn WAT or resn HOH or resn TIP*) + +do (store1 = 0) (all) +do (store1 = 1) ((resn WAT or resn HOH or resn TIP*) and name OH2) +show sum (store1) ((resn WAT or resn HOH or resn TIP*)) + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/flex_segment_side.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/flex_segment_side.cns new file mode 100644 index 0000000000000000000000000000000000000000..ac5276c3225b214778fdd02b4db81408857eaea9 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/flex_segment_side.cns @@ -0,0 +1,61 @@ +! flex_segment_side.cns +! Define semi-flexible segments (side-chains only) +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +do (store5 = 0) (all) +do (store6 = 0) (all) + +!first flexible segments for docking +evaluate($nchain1 = 0) +while ($nchain1 < $data.ncomponents) loop nloop1 + evaluate($nchain1 = $nchain1 + 1) + evaluate($nf=0) + if ($nseg$nchain1 = 0) then + display NO FLEXIBLE SIDE-CHAINS SEGMENTS for molecule $nchain1 + else + if ($nseg$nchain1 < 0) then + display AUTOMATIC DEFINITION OF FLEXIBLE SEGMENTS BASED ON INTERMOLECULAR PROXIMITY FOR MOLECULE $nchain1 + inline @MODULE:flexauto-neighbors.cns + do (store5 = 0) (name CA or name BB or name C or name N or name O) + else + display FLEXIBLE SIDE-CHAINS SEGMENTS for molecule $nchain1 + while ($nf < $nseg$nchain1) loop Xflex + evaluate($nf=$nf + 1) + do (store5 = $nchain1) ( resid $seg_sta_$nchain1_$nf : $seg_end_$nchain1_$nf + and segid $prot_segid_$nchain1 + and not(name CA or name BB or name C or name N or name O) ) + display FLEXIBLE SIDE-CHAINS SEGMENT NR $nf FROM $seg_sta_$nchain1_$nf TO $seg_end_$nchain1_$nf + end loop Xflex + end if + end if +end loop nloop1 + +!then fully flexible segments for all stages + +!then fully flexible segments for all stages +display NO FLEXIBLE SEGMENTS for all molecule at this stage +if ($nfle = 0) then + display NO FULLY FLEXIBLE SEGMENTS +else + evaluate($nf=0) + while ($nf < $nfle) loop Xfflex + evaluate($nf=$nf + 1) + do (store5 = 1) ( resid $fle_sta_$nf : $fle_end_$nf and segid $fle_seg_$nf ) + display FULLY FLEXIBLE SEGMENT NR $nf FROM $fle_sta_$nf TO $fle_end_$nf FOR CHAIN $fle_seg_$nf + end loop Xfflex +end if + +do (store5 = 21) (resn WAT or resn HOH or resn TIP*) + +do (store1 = 0) (all) +do (store1 = 1) ((resn WAT or resn HOH or resn TIP*) and name OH2) +show sum (store1) ((resn WAT or resn HOH or resn TIP*)) + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/flexauto-neighbors.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/flexauto-neighbors.cns new file mode 100644 index 0000000000000000000000000000000000000000..f3fe74b83b0aa2a99d80a117239d87e052648b11 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/flexauto-neighbors.cns @@ -0,0 +1,42 @@ +! flexauto-neighbors.cns +! Automatic definition of flexible segments for docking for contacting residues +! including neighboring residues of residues making contacts +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +evaluate ($flcut = 5.0) + +do (store5 = $nchain1) (byres (segid $prot_segid_$nchain1 + and (not (segid $prot_segid_$nchain1 or resn SHA)) around $flcut)) + +do (store6 = 0) (segid $prot_segid_$nchain1) +for $id in id (tag and attr store5 >0 and not ((resn WAT or resn HOH or resn TIP*) or resn DMSO) and segid $prot_segid_$nchain1) loop flexres1 + show (resid) (id $id) + evaluate ($inres = decode($result)) + evaluate ($preres = $inres) + evaluate ($nexres = $inres) + evaluate ($preres = $preres - 1) + do (store6 = $nchain1) (resid $preres and segid $prot_segid_$nchain1) + do (store6 = $nchain1) (resid $nexres and segid $prot_segid_$nchain1) +end loop flexres1 + +do (store5 = store6) (segid $prot_segid_$nchain1) + +display THE FOLLOWING RESIDUES HAVE BEEN DEFINED AS FLEXIBLE for molecule $nchain1 +for $id in id (tag and attr store5 >0 and not ((resn WAT or resn HOH or resn TIP*) or resn DMSO) and segid $prot_segid_$nchain1) loop flexres2 + show (resid) (id $id) + evaluate ($inres = $result) + show (resn) (id $id) + evaluate ($nares = $result) + show (segid) (id $id) + evaluate ($seres = $result) + display AUTOMATICALLY SELECTED SEGMENT: $nares,$inres,$seres +end loop flexres2 + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/flexref.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/flexref.cns new file mode 100644 index 0000000000000000000000000000000000000000..54d07b35feae7a8addc154b6621cb904564139df --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/flexref.cns @@ -0,0 +1,621 @@ +! flexref.cns +! The HADDOCK semi-flexible refinement in torsion angle space +! This version supports only distance and symmetry/ncs restraints +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** + +if ( $log_level = "verbose" ) then + set message=all echo=on end +elseif ( $log_level = "normal" ) then + set message=normal echo=off end +else + set message=off echo=off end +end if + +!==================================================================! +! Initialisation of variables +!==================================================================! + +evaluate ($saprotocol.randorien=$randorien) +evaluate ($saprotocol.tadhigh_t=$temp_high) +evaluate ($saprotocol.t1_init=$temp_cool1_init) +evaluate ($saprotocol.t2_init=$temp_cool2_init) +evaluate ($saprotocol.t3_init=$temp_cool3_init) +evaluate ($saprotocol.t1_final=$temp_cool1_final) +evaluate ($saprotocol.t2_final=$temp_cool2_final) +evaluate ($saprotocol.t3_final=$temp_cool3_final) +evaluate ($saprotocol.inter_init_rigid=$sinter_rigid_init) +evaluate ($saprotocol.inter_fin_rigid=$sinter_rigid_final) +evaluate ($saprotocol.inter_init_cool2=$sinter_cool2_init) +evaluate ($saprotocol.inter_fin_cool2=$sinter_cool2_final) +evaluate ($saprotocol.inter_init_cool3=$sinter_cool3_init) +evaluate ($saprotocol.inter_fin_cool3=$sinter_cool3_final) +evaluate ($saprotocol.tempstep=50) +evaluate ($saprotocol.timestep=$timestep) +evaluate ($saprotocol.tadfactor=$tadfactor) +evaluate ($saprotocol.initiosteps=$mdsteps_rigid) +evaluate ($saprotocol.cool1_steps=$mdsteps_cool1) +evaluate ($saprotocol.cool2_steps=$mdsteps_cool2) +evaluate ($saprotocol.cool3_steps=$mdsteps_cool3) +evaluate ($saprotocol.fbeta=100) +evaluate ($saprotocol.mass=100) + +evaluate ($data.ncomponents=$ncomponents) + + +! non-bonded parameter set to use +evaluate ($toppar.par_nonbonded = "OPLSX") + +! dihedrals, DNA and distance restraints +evaluate ($Data.dnarest =$dnarest_on) +evaluate ($Data.flags.cdih =$dihedrals_on) +evaluate ($Data.cdih.on =$dihedrals_on) +evaluate ($Data.ssdihed =$ssdihed) +evaluate ($Data.error_dih =$error_dih) +evaluate ($data.dihedrals.on=$dihedrals_on) +evaluate ($data.dihedrals_hot=$dihedrals_hot) +evaluate ($data.dihedrals_cool1=$dihedrals_cool1) +evaluate ($data.dihedrals_cool2=$dihedrals_cool2) +evaluate ($data.dihedrals_cool3=$dihedrals_cool3) + +! planarity restraints +evaluate ($Data.flags.plan = false) + +! distance restraints +evaluate ($Data.flags.noe = true) +evaluate ($data.unambig_hot=$unambig_hot) +evaluate ($data.unambig_cool1=$unambig_cool1) +evaluate ($data.unambig_cool2=$unambig_cool2) +evaluate ($data.unambig_cool3=$unambig_cool3) +evaluate ($data.randremoval=$randremoval) +evaluate ($data.npart=$npart) + +evaluate ($data.ambig_hot=$ambig_hot) +evaluate ($data.ambig_cool1=$ambig_cool1) +evaluate ($data.ambig_cool2=$ambig_cool2) +evaluate ($data.ambig_cool3=$ambig_cool3) + +evaluate ($data.hbond_hot=$hbond_hot) +evaluate ($data.hbond_cool1=$hbond_cool1) +evaluate ($data.hbond_cool2=$hbond_cool2) +evaluate ($data.hbond_cool3=$hbond_cool3) + +evaluate ($data.mrswi_hot=$mrswi_hot) +evaluate ($data.mrswi_cool1=$mrswi_cool1) +evaluate ($data.mrswi_cool2=$mrswi_cool2) +evaluate ($data.mrswi_cool3=$mrswi_cool3) + +evaluate ($data.rswi_hot=$rswi_hot) +evaluate ($data.rswi_cool1=$rswi_cool1) +evaluate ($data.rswi_cool2=$rswi_cool2) +evaluate ($data.rswi_cool3=$rswi_cool3) + +evaluate ($data.masy_hot=$masy_hot) +evaluate ($data.masy_cool1=$masy_cool1) +evaluate ($data.masy_cool2=$masy_cool2) +evaluate ($data.masy_cool3=$masy_cool3) + +evaluate ($data.asy_hot=$asy_hot) +evaluate ($data.asy_cool1=$asy_cool1) +evaluate ($data.asy_cool2=$asy_cool2) +evaluate ($data.asy_cool3=$asy_cool3) + +evaluate ($data.cmrest=$cmrest) +evaluate ($data.cmtight=$cmtight) +evaluate ($data.kcm=$kcm) +evaluate ($data.kcont=$kcont) +evaluate ($data.contactairs=$contactairs) +if ($data.contactairs eq true) then + evaluate ($data.randremoval = false) +end if + +! NCS restraints +evaluate ($data.kncs = $kncs) +evaluate ($Data.flags.ncs = $ncs_on) +evaluate ($data.nncs = $nncs) + +! Symmetry restraints +evaluate ($data.ksym = $ksym) +evaluate ($Data.flags.sym = $sym_on) +evaluate ($data.nc2sym = $nc2sym) +evaluate ($data.nc3sym = $nc3sym) +evaluate ($data.ns3sym = $ns3sym) +evaluate ($data.nc4sym = $nc4sym) +evaluate ($data.nc5sym = $nc5sym) +evaluate ($data.nc6sym = $nc6sym) + +!Electrostatics: +evaluate ($Data.flags.dihed =$dihedflag) +evaluate ($Data.flags.elec =$elecflag) +evaluate ($Data.epsilon =$epsilon) +evaluate ($Data.dielec =$dielec) + +!Interaction matrix: +evaluate ($nmol1=1) +while ($nmol1 <=$data.ncomponents) loop mol1 + evaluate ($nmol2=$nmol1 + 1) + evaluate ($scale.int_$nmol1_$nmol1 =$int_$nmol1_$nmol1) + while ($nmol2 <=$data.ncomponents) loop mol2 + evaluate ($scale.int_$nmol1_$nmol2 =$int_$nmol1_$nmol2) + evaluate ($scale.int_$nmol2_$nmol1 =$int_$nmol1_$nmol2) + evaluate ($nmol2=$nmol2 + 1) + end loop mol2 + evaluate ($nmol1 = $nmol1 + 1) +end loop mol1 + + +! Unsupported restraints +evaluate ($Data.flags.em = false) +evaluate ($Data.flags.rg = false) +evaluate ($Data.flags.zres = false) +evaluate ($Data.flags.sani = false) +evaluate ($Data.flags.xrdc = false) +evaluate ($Data.flags.xpcs = false) +evaluate ($Data.flags.dani = false) +evaluate ($Data.flags.vean = false) + +! Other parameters +evaluate ($refine.keepwater = false) + +!==================================================================! + +evaluate ($whichMD="torsion") + +{* Read paramters and set various force field related variables *} + +@MODULE:read_param.cns + +parameter + bond (resn WAT ) (resn WAT ) 1000 TOKEN + angle (resn WAT ) (resn WAT ) (resn WAT ) 500 TOKEN + bond (resn HOH ) (resn HOH ) 1000 TOKEN + angle (resn HOH ) (resn HOH ) (resn HOH ) 500 TOKEN + bond (resn TIP*) (resn TIP*) 1000 TOKEN + angle (resn TIP*) (resn TIP*) (resn TIP*) 500 TOKEN +end + +{* Check for the presence of ions and add distance restraints / covalent bond == *} + +@MODULE:restrain-ions.cns +@MODULE:covalions.cns + + +{* Define various interaction and energetics settings *} + +igroup + interaction (not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) + (not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) weight * 1 end + interaction (resn ANI or resn DAN or resn XAN or resn DUM or resn DUM) + (resn ANI or resn DAN or resn XAN or resn DUM or resn DUM) weight * 1 vdw 0.0 elec 0.0 end + interaction (resn SHA) (not resn SHA) weight * 0 end +end + +flag include bond angle impr vdw end + +if ($Data.flags.dihed eq true) then + flag include dihed end +end if + +if ($Data.flags.elec eq true) then + flag include elec end + if ($Data.dielec eq "rdie") then + parameter nbonds eps=$Data.epsilon rdie shift switch end end + ! shift statement needed first to activate switch (CNS bug?) + else + parameter nbonds eps=$Data.epsilon cdie end end + end if + parameter nbonds ? end end +else + evaluate ($elec=0.0) + flag exclude elec end +end if + +do (fbeta=$Saprotocol.fbeta) (all) +do (mass=$Saprotocol.mass) (all) + +!catch possible bound water and set high T steps to 0 +coor select ((resn WAT or resn HOH or resn TIP*)) end +if ($select gt 0) then + evaluate ($SaProtocol.initiosteps = 0) + evaluate ($SaProtocol.cool1_steps = 0) + evaluate ($refine.keepwater = true) +end if + +! random placement of molecules +if ($SaProtocol.randorien eq true) then + @MODULE:separate.cns + @MODULE:random_rotations.cns +end if + +{* Read the distance restraints ================================ *} +set seed $seed end +set message=normal echo=on end +inline @MODULE:read_data.cns + +! random removal of restaints +if ($Data.randremoval eq true) then + noe cv $npart ? end +end if + +if ( $log_level = "verbose" ) then + set message=all echo=on end +elseif ( $log_level = "normal" ) then + set message=normal echo=off end +else + set message=off echo=off end +end if + +evaluate ($numnoe = 0) + +!Make sure that at least as many distance restraints are successfully +!read as the number of partitions for cross-validation +evaluate ($numnoe = 999) +noe ? end +if ($NUMNOE = 0) then + if ($Data.ncomponents > 1) then + if ($Data.contactairs eq FALSE) then + if ($Data.cmrest eq FALSE) then + evaluate ($errfile = "MODDIR:WARNING") + fileexist $errfile end + if ($result eq false) then + set display=$errfile end + display TOTAL NUMBER OF DISTANCE RESTRAINTS FOR FLEXIBLE REFINEMENT IS ZERO! + display CONTROL YOUR PARAMETER SETTINGS AND RESTRAINT DEFINITIONS + close $errfile end + end if + end if + end if + end if + evaluate ($Data.npart = 1) + evaluate ($Data.randremoval = FALSE) +end if + +if ($NUMNOE lt $Data.npart) then + noe part=1 end + evaluate ($Data.npart = 1) + evaluate ($Data.randremoval = FALSE) +end if + + +{* set the energy flags ======================================================== *} + +inline @MODULE:setflags.cns + +{* Check for other restraints ================================================== *} + +@MODULE:symmultimer.cns + +if ($Data.cmrest eq true ) then + @MODULE:cm-restraints.cns +end if + +if ($Data.contactairs eq true ) then + @MODULE:contactairs.cns +end if + +if ($Data.dnarest eq true ) then + @MODULE:dna-rna_restraints.cns +end if + +if ($Data.ssdihed eq "all" ) then + inline @MODULE:protein-ss-restraints-all.cns +end if +if ($Data.ssdihed eq "alpha" ) then + inline @MODULE:protein-ss-restraints-alpha.cns +end if +if ($Data.ssdihed eq "alphabeta" ) then + inline @MODULE:protein-ss-restraints-alpha-beta.cns +end if + + +{* Check first for failed structures =========================================== *} +evaluate ($failure = false) +evaluate ($filefail=$output_pdb_filename - ".pdb" + ".fail") +fileexist $filefail end +evaluate ($failure = $result) + + +{* Define initial weights for distance restraints ============================== *} +evaluate ($unambig_scale = $Data.unambig_hot) +evaluate ($ambig_scale = $Data.ambig_hot) +evaluate ($hbond_scale = $Data.hbond_hot) + +noe + scale dist $unambig_scale + scale ambi $ambig_scale + scale hbon $hbond_scale +end + +{* Stage 0 ================================== initial EM for flexible parts only *} + +! get initial energy +energy end + +! fix the residues describing the shape +fix sele=(resn SHA) end + +! define flexible interface +@MODULE:flex_segment_back.cns +fix sele=((attr store5 = 0 or name OO or resn SHA) and not name H* and not (resn WAT or resn HOH or resn TIP*)) end + +! energy minimization +if ($nemsteps > 0) then + minimize powell nstep=$nemsteps drop=10.0 nprint=25 end +end if + +fix sele=(not all) end + +! get initial energy +energy end + +! fix the residues describing the shape +fix sele=(resn SHA) end + +! the following is added to avoid the generation of the torsion angle topology if not needed +! in cases where the number of steps is set to 0 (avoid issues with isolated atoms) +eval ($torsiondone = false) + +! start SA in torsion angle unless a failure was detected +if ($failure eq false) then + + {* Stage 1 ======================================= rigid body high temperature search*} + + if ($nfle > 0) then + ! reduce timestep in case of fully flexible segments + evaluate ($SaProtocol.tadfactor = min(4,$SaProtocol.tadfactor)) + end if + if ($SaProtocol.initiosteps > 0) then + inline @MODULE:flex_segment.cns + @MODULE:torsiontop.cns + eval ($torsiondone = true) + @MODULE:sa_ltad_hightemp.cns + end if + + {* Stage 2 ======================================= rigid body first slow cooling *} + + if ($SaProtocol.cool1_steps > 0) then + if ($torsiondone ne true) then + inline @MODULE:flex_segment.cns + @MODULE:torsiontop.cns + eval ($torsiondone = true) + end if + if ($nfle > 0) then + ! reduce timestep in case of fully flexible segments + evaluate ($SaProtocol.tadfactor = min(4,$SaProtocol.tadfactor)) + end if + @MODULE:sa_ltad_cool1.cns + end if + + {* Stage 3 ======================================= second slow cooling *} + {* flexible side-chains and reduced time step *} + + if ($SaProtocol.cool2_steps > 0) then + if ($torsiondone eq true) then + dyna tors topo reset end end + end if + inline @MODULE:flex_segment_side.cns + @MODULE:torsiontop.cns + eval ($torsiondone = true) + evaluate ($SaProtocol.tadfactor = 1) + @MODULE:sa_ltad_cool2.cns + end if + + {* Stage 4 ============================================ third slow cooling *} + {* flexible side-chains and backbone at interface and reduced time step *} + + if ($SaProtocol.cool3_steps > 0) then + if ($torsiondone eq true) then + dyna tors topo reset end end + end if + inline @MODULE:flex_segment_back.cns + @MODULE:torsiontop.cns + eval ($torsiondone = true) + evaluate ($SaProtocol.tadfactor = 1) + @MODULE:sa_ltad_cool3.cns + end if + +end if + +{* Stage 5 =========================== final minimization *} + +! define flexible segments and fix the remaining of the structure +@MODULE:flex_segment_back.cns +fix sele=((attr store5 = 0 or name OO or resn SHA) and not name H* and not (resn WAT or resn HOH or resn TIP* or resn XAN)) end + +! energy minimization +if ($nemsteps > 0) then + minimize powell nstep=$nemsteps drop=10.0 nprint=25 end +end if + +! final energy +fix sele=(not all) end + +{* ======================= calculate free molecules internal energy *} + +igroup + interaction (not (resn ANI or resn DAN or resn XAN or resn SHA or resn WAT or resn HOH or resn TIP* or resn DUM)) + (not (resn ANI or resn DAN or resn XAN or resn SHA or resn WAT or resn HOH or resn TIP* or resn DUM)) weight * 1 end +end + +do (refx=x) (all) +do (refy=y) (all) +do (refz=z) (all) + +fix sele=(resn ANI or resn DAN or resn XAN or resn SHA or resn WAT or resn HOH or resn TIP* or resn DMS) end + +flag excl noe dani sani vean xrdc xpcs coll cdih zhar end +flag include bond angle dihe impr vdw end + +evaluate ($elec = 0.0) +evaluate ($eintfree = 0.0) +if ($Data.flags.elec eq true) then + flag include elec end +end if + +if ($Data.dielec eq "rdie") then + parameter nbonds eps=$Data.epsilon rdie shift switch end end + ! shift statement needed first to activate switch (CNS bug?) +else + parameter nbonds eps=$Data.epsilon cdie end end +end if +parameter nbonds ? end end +inline @MODULE:calc_free-ene.cns + +fix sele=(not all) end + +do (x = refx) (all) +do (y = refy) (all) +do (z = refz) (all) + + +{* ===================== calculate complex internal energy *} + +evaluate ($kinter = 1.0) +flag include bond angle dihe impr vdw end +energy end + +@MODULE:scale_intra_only.cns + +evaluate ($elec = 0.0) +evaluate ($eintcplx = 0.0) +if ($Data.flags.elec eq true) then + flag include elec end +end if + +energy end + +evaluate ($eintcplx = $bond + $angl + $impr + $dihe + $vdw + $elec) +evaluate ($ebond = $bond) +evaluate ($eangl= $angl) +evaluate ($eimpr= $impr) +evaluate ($edihe= $dihe) + +evaluate ($result=0) +print thres=0.05 bonds +evaluate ($rms_bonds=$result) +evaluate ($result=0) +print thres=5. angles +evaluate ($rms_angles=$result) +evaluate ($result=0) +print thres=5. impropers +evaluate ($rms_impropers=$result) +evaluate ($result=0) +print thres=30. dihedrals +evaluate ($rms_dihedrals=$result) + + +{* ===================== calculate final energies and write structure *} +evaluate ($cdih=0.0) +flag incl noe cdih end +if ($Data.ncomponents > 1) then + evaluate ($kinter = 1.0) + @MODULE:scale_inter_final.cns +else + @MODULE:scale_intra_only.cns +end if + +noe + scale dist $Data.unambig_cool3 + scale ambi $Data.ambig_cool3 + scale hbon $Data.hbond_cool3 + scale symm 0.0 + scale cont 0.0 +end +energy end +evaluate ($eair= $noe) + +evaluate ($esym = 0.0) +evaluate ($ncs = 0.0) +evaluate ($zhar = 0.0) +evaluate ($rms_test_noe = 0.0) +evaluate ($violations_test_noe = 0) +if ($Data.flags.sym eq true) then + ! calculatee first the symmetry energy + noe reset nres= 1200000 end + @MODULE:symmultimer.cns + noe + scale symm $Data.ksym + end + energy end + evaluate ($esym = $noe) + noe reset end + set seed=$seed end + !read back all the distance restraints: + @@MODULE:read_noes.cns + ! random removal of restaints + if ($Data.randremoval eq true) then + noe cv $npart ? end + end if + noe + scale dist $Data.unambig_cool3 + scale ambi $Data.ambig_cool3 + scale hbon $Data.hbond_cool3 + end + evaluate ($result = 0) + print threshold=0.3 noe + evaluate ($rms_noe=$result) + evaluate ($violations_noe=$violations) + if ($Data.randremoval eq true) then + evaluate ($rms_test_noe=$test_rms) + evaluate ($violations_test_noe=$test_violations) + end if +else + evaluate ($result = 0) + print threshold=0.3 noe + evaluate ($rms_noe=$result) + evaluate ($violations_noe=$violations) + if ($Data.randremoval eq true) then + evaluate ($rms_test_noe=$test_rms) + evaluate ($violations_test_noe=$test_violations) + end if +end if + +if ($Data.dnarest eq true ) then + @MODULE:dna-rna_restraints.cns +end if + +energy end +evaluate ($etot = $ener - $noe) +evaluate ($noe = $eair) +evaluate ($etot = $etot + $noe) + +inline @MODULE:print_coorheader.cns + + +{* determine whether the final models should be reoriented along their principal *} +{* axes before writing to file ================================================= *} +eval($reorient = true) +evaluate ($ncount = 0) +while ($ncount < $data.ncomponents) loop orientmol + evaluate ($ncount = $ncount + 1) + eval($watersegname_$ncount="WA" + encode($ncount)) + if ($mol_fix_origin_$ncount eq true) then + eval($reorient = false) + end if +end loop orientmol + +if ($reorient = true) then + coor sele= (not name H* and not resn ANI and not resn XAN and not resn DAN) orient end +end if + +inline @MODULE:check_coordinates.cns + +if ($failure eq true) then + evaluate ($failfile = $output_pdb_filename - ".pdb" + ".fail") + set display=$failfile end + display "MAX/MIN possible coordinates exceeded - stopping" + close $failfile end + stop +else + write coordinates format=pdbo output=$output_pdb_filename end +end if + +display OUTPUT: $output_pdb_filename + +stop diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/numtrees.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/numtrees.cns new file mode 100644 index 0000000000000000000000000000000000000000..4157f2121a9852ebb623fac1dd426e2fff02384d --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/numtrees.cns @@ -0,0 +1,83 @@ +! numtrees.cns +! Define the number of trees for torsion angle MD +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * Originally adapted from Aria 1.2 from Nilges and Linge, EMBL. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +evaluate ($numtrees = 1) +evaluate ($ncount = 0) +evaluate ($break=$data.ncomponents) + +while ($ncount < $data.ncomponents) loop nsloop + + evaluate ($ncount = $ncount + 1) + + for $id1 in id ( name C and bondedto(name CA) and segid $prot_segid_$ncount) loop break + show (resid) (id $id1) + evaluate ($resid1=$result) + evaluate ($resid2=encode(decode($resid1)+1)) + show sum(1) (id $id1 and known) + if ( $result ne 0 ) then + identity (store1) ( name N and bondedto(name CA) and segid $prot_segid_$ncount and resid $resid2 ) + show element (store1) (attribute store1 > 0) + if ( $result ne 0) then + evaluate ($id2=$result) + show sum(1) (id $id2 and known) + if ( $result ne 0 ) then + pick bond + (name c and segid $prot_segid_$ncount and resid $resid1) + (name n and segid $prot_segid_$ncount and resid $resid2) + geometry + if ( $result > 2.5 ) then + evaluate ($break=$break+1) + end if + else + evaluate ($break=$break+1) + end if + end if + end if + end loop break + + for $id1 in id ( name BB ) loop bbbreak + show (resid) (id $id1) + evaluate ($resid1=$result) + evaluate ($resid2=encode(decode($resid1)+1)) + show sum(1) (id $id1 and known) + if ( $result ne 0 ) then + identity (store1) ( name BB and segid $prot_segid_$ncount and resid $resid2 ) + show element (store1) (attribute store1 > 0) + if ( $result ne 0) then + evaluate ($id2=$result) + show sum(1) (id $id2 and known) + if ( $result ne 0 ) then + pick bond + (name BB and segid $prot_segid_$ncount and resid $resid1) + (name BB and segid $prot_segid_$ncount and resid $resid2) + geometry + if ( $result > 8.0 ) then + evaluate ($break=$break+1) + end if + else + evaluate ($break=$break+1) + end if + end if + end if + end loop bbbreak + +end loop nsloop + +! check for water molecules + +do (store1 = 0) (all) +do (store1 = 1) ((resn WAT or resn HOH or resn TIP*) and name OH2) +show sum (store1) ((resn WAT or resn HOH or resn TIP*)) +evaluate ($numtrees = $numtrees + $break + $result) + +evaluate ($numtrees = $numtrees + 300) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/print_coorheader.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/print_coorheader.cns new file mode 100644 index 0000000000000000000000000000000000000000..1a06f68f63b409e44be920b6dada5a05ff1e762f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/print_coorheader.cns @@ -0,0 +1,308 @@ +! print_coorheader.cns +! Generate the coordinate header (REMARKS) +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * Originally adapted from Aria 1.2 from Nilges and Linge, EMBL. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +if ($Data.flags.dihed eq false) then evaluate ($dihe = 0) end if +if ($Data.flags.sani eq false) then evaluate ($sani = 0) end if +if ($Data.flags.xrdc eq false) then evaluate ($xrdc = 0) end if +if ($Data.flags.xpcs eq false) then evaluate ($xpcs = 0) end if +if ($Data.flags.dani eq false) then evaluate ($dani = 0) end if +if ($Data.flags.vean eq false) then evaluate ($vean = 0) end if +if ($Data.flags.cdih eq false) then evaluate ($cdih = 0) end if +if ($Data.flags.noe eq false) then evaluate ($noe = 0) end if +if ($Data.flags.rg eq false) then evaluate ($coll = 0) end if +if ($Data.flags.zres eq false) then evaluate ($zhar = 0) end if +if ($Data.flags.em eq false) then evaluate ($lcc = 0) end if + +evaluate($enerall=$etot) +evaluate($bondall=$ebond) +evaluate($anglall=$eangl) +evaluate($imprall=$eimpr) +evaluate($diheall=$edihe) +evaluate($vdwall=$vdw) +evaluate($elecall=$elec) +evaluate($noeall=$noe) +evaluate($rgall=$coll) +evaluate($zresall=$zhar) +evaluate($cdihall=$cdih) +evaluate($coupall=0) +evaluate($saniall=$sani+$xrdc) +evaluate($veanall=$vean) +evaluate($xpcsall=$xpcs) +evaluate($daniall=$dani) + +if ($Data.flags.sym eq true) then + evaluate ($result=0) + evaluate ($violations=0) + print threshold=0.3 noe + evaluate ($rms_noe=$result) + evaluate ($violations_noe=$violations) +end if + +if ($Data.randremoval eq false) then + evaluate ($violations_test_noe= 0) + evaluate ($rms_test_noe = 0) + evaluate ($npart = 0) +end if + +evaluate ($result=0) +evaluate ($violations=0) +print threshold=5. cdih +evaluate ($rms_cdih=$result) +evaluate ($violations_cdih=$violations) +evaluate ($result=0) +evaluate ($violations=0) +evaluate ($rms_coup = 0) +evaluate ($violations_coup = 0) + +evaluate( $rms_sani = 0) +evaluate( $violations_sani = 0) +if ($Data.flags.sani eq TRUE) then + sani print threshold = 0.20 class rd* end + evaluate( $rms_sani = $result) + evaluate( $violations_sani = $violations) +end if + +evaluate( $rms_xrdc = 0) +evaluate( $violations_xrdc = 0) +if ($Data.flags.xrdc eq TRUE) then + xrdc print threshold = 0.2 class xr* end + evaluate( $rms_xrdc = $result) + evaluate( $violations_xrdc = $violations) +end if + +evaluate( $violations_sani = $violations_sani + $violations_xrdc) +evaluate( $rms_sani = $rms_sani + $rms_xrdc) + +evaluate( $rms_xpcs = 0) +evaluate( $violations_xpcs = 0) +if ($Data.flags.xpcs eq TRUE) then + xpcs print threshold = 0.2 class pc* end + evaluate( $rms_xpcs = $result) + evaluate( $violations_xpcs = $violations) +end if + +evaluate( $rms_vean = 0) +evaluate( $violations_vean = 0) +if ($Data.flags.vean eq TRUE) then + vean print threshold = 5.00 class ve* end + evaluate( $rms_vean = $result) + evaluate( $violations_vean = $violations) +end if + +evaluate( $rms_dani = 0) +evaluate( $violations_dani = 0) +if ($Data.flags.dani eq TRUE) then + dani print threshold = 0.20 class da* end + evaluate( $rms_dani = $result) + evaluate( $violations_dani = $violations) +end if + +{====>} {* define ASA-based solvation parameters *} +inline @MODULE:def_solv_param.cns + +{====>} {* buried surface area and desolvation*} +evaluate ($nchain1 = 0) +evaluate ($saafree = 0) +evaluate ($esolfree = 0) +while ($nchain1 < $data.ncomponents) loop nloop1 + evaluate ($nchain1 = $nchain1 + 1) + {====>} {* buried surface area and desolvation*} + do (rmsd = 0) (all) + surface mode=access accu=0.075 rh2o=1.4 sele=(segid $prot_segid_$nchain1 and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) end + show sum (rmsd) (segid $prot_segid_$nchain1 and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) + evaluate ($saafree = $saafree + $result) + do (store2 = rmsd * store1) (segid $prot_segid_$nchain1 and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) + show sum (store2) (segid $prot_segid_$nchain1 and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) + evaluate ($esolfree = $esolfree + $result) +end loop nloop1 + +do (rmsd = 0) (all) +do (store2 = 0) (all) +surface mode=access accu=0.075 rh2o=1.4 sele=(not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) end +show sum (rmsd) (not ((resn WAT or resn HOH or resn TIP*) or resn DMS or resn SHA)) +evaluate ($satot = $result) +do (store2 = rmsd * store1) (not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) +show sum (store2) (not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) +evaluate ($esolcplx = $result) +evaluate ($saburied = $saafree - $satot) +if ($saburied < 0) then + evaluate ($saburied = -999999) +end if + +evaluate ($edesolv = $esolcplx - $esolfree) + +evaluate ($dhbinding = $edesolv + $eintcplx - $eintfree + $elecall + $vdwall) + +evaluate ($nshape = 0) +evaluate ($ncount = 0) +while ($ncount < $data.ncomponents) loop shape + evaluate ($ncount = $ncount + 1) + if ($mol_shape_$ncount eq true) then + evaluate ($nshape = $nshape + 1) + end if +end loop shape + +evaluate ($nonshape = $Data.ncomponents - $nshape) + +if ($nonshape = 1) then + evaluate ($saburied = 0) + evaluate ($edesolv = 0) + evaluate ($dhbinding = 0) + evaluate ($eintfree = $eintcplx) +end if + +if ($Data.flags.sym eq true) then + evaluate ($enerall = $enerall + $esym) +end if +if ($Data.flags.ncs eq true) then + evaluate ($enerall = $enerall + $ncs) +end if + +evaluate ($procwat = false) +if ($refine.keepwater eq true) then + evaluate ($procwat = true) +end if + +if ($procwat eq true) then + ident (store3) (not all) + flag exclude * include vdw elec end + + eval($nchain1 = 0) + + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + + igroup + interaction (segid $prot_segid_$nchain1) ((resn WAT or resn HOH or resn TIP* or resn DMS) and not store3) weight * 1.0 end + interaction (not segid $prot_segid_$nchain1) (resn WAT or resn HOH or resn TIP* or resn DMS) weight * 0.0 end + interaction (segid $prot_segid_$nchain1) (not ((resn WAT or resn HOH or resn TIP* or resn DMS) and store3)) weight * 0.0 end + end + energy end + evaluate ($ener_water_$nchain1 = $ener) + evaluate ($enerall = $enerall + $ener) + evaluate ($vdw_water_$nchain1 = $vdw) + evaluate ($elec_water_$nchain1 = $elec) + + end loop nloop1 + if ($data.ncomponents > 1) then + eval($nchain1 = $data.ncomponents) + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + evaluate ($ener_water_$nchain1 = 0.0) + evaluate ($vdw_water_$nchain1 = 0.0) + evaluate ($elec_water_$nchain1 = 0.0) + end loop nloop1 + end if + + eval($nchain1 = 0) + + igroup + while ($nchain1 < $data.ncomponents) loop nloop2 + eval($nchain1 = $nchain1 + 1) + interaction (segid $prot_segid_$nchain1) (all) weight * 0.0 end + end loop nloop2 + interaction ((resn WAT or resn HOH or resn TIP* or resn DMS) and not store3) + ((resn WAT or resn HOH or resn TIP* or resn DMS) and not store3) weight * 1.0 end + interaction (store3) (store3) weight * 0.0 end + interaction (resn SHA) (not resn SHA) weight * 0.0 end + interaction (resn SHA) (resn SHA) weight * 0.0 end + end + energy end + evaluate ($ener_water_water = $ener) + evaluate ($enerall = $enerall + $ener) + evaluate ($vdw_water_water = $vdw) + evaluate ($elec_water_water = $elec) +else + eval($nchain1 = 0) + + while ($nchain1 < $data.ncomponents ) loop nloop1 + eval($nchain1 = $nchain1 + 1) + evaluate ($ener_water_$nchain1 = 0.0) + evaluate ($vdw_water_$nchain1 = 0.0) + evaluate ($elec_water_$nchain1 = 0.0) + end loop nloop1 + evaluate ($ener_water_water = 0.0) + evaluate ($vdw_water_water = 0.0) + evaluate ($elec_water_water = 0.0) +end if + +! calculate the HADDOCK score +evaluate ($hscore = $w_vdw * $vdwall) +evaluate ($hscore = $hscore + $w_elec * $elecall) +evaluate ($hscore = $hscore + $w_air * $noeall) +evaluate ($hscore = $hscore + $w_rg * $rgall) +evaluate ($hscore = $hscore + $w_cdih * $cdihall) +evaluate ($hscore = $hscore + $w_sani * $saniall) +evaluate ($hscore = $hscore + $w_xpcs * $xpcsall) +evaluate ($hscore = $hscore + $w_dani * $daniall) +evaluate ($hscore = $hscore + $w_vean * $veanall) +evaluate ($hscore = $hscore + $w_sym * $esym) +evaluate ($hscore = $hscore + $w_bsa * $saburied) +evaluate ($hscore = $hscore + $w_desolv * $edesolv) +evaluate ($hscore = $hscore + $w_lcc * $lcc) + +set message=on echo=on end +set remarks=reset end +set remarks=accumulate end +remarks =============================================================== +remarks HADDOCK stats for $output_pdb_filename +remarks =============================================================== +remarks HADDOCK score: $hscore +remarks =============================================================== + +!list input molecules +evaluate ($nmol=1) +while ($nmol <=$data.ncomponents) loop mol + if ( $exist_input_pdb_filename_$nmol = true) then + remarks initial structure $nmol - $input_pdb_filename_$nmol + end if + evaluate ($nmol = $nmol + 1) +end loop mol + +remarks =============================================================== +remarks total,bonds,angles,improper,dihe,vdw,elec,air,cdih,coup,rdcs,vean,dani,xpcs,rg +remarks energies: $enerall, $bondall, $anglall, $imprall, $diheall, $vdwall, $elecall, $noeall, $cdihall, $coupall, $saniall, $veanall, $daniall, $xpcsall, $rgall +remarks =============================================================== +remarks bonds,angles,impropers,dihe,air,cdih,coup,rdcs,vean,dani,xpcs +remarks rms-dev.: $rms_bonds,$rms_angles,$rms_impropers,$rms_dihedrals,$rms_noe,$rms_cdih,$rms_coup, $rms_sani, $rms_vean, $rms_dani, $rms_xpcs +remarks =============================================================== +remarks air,cdih,coup,rdcs,vean,dani,xpcs +remarks >0.3,>5,>1,>0,>5,>0.2,>0.2 +remarks violations.: $violations_noe, $violations_cdih, $violations_coup, $violations_sani, $violations_vean, $violations_dani, $violations_xpcs +remarks =============================================================== +remarks CVpartition#,violations,rms +remarks AIRs cross-validation: $npart, $violations_test_noe, $rms_test_noe +remarks =============================================================== +remarks NCS energy: $ncs +remarks =============================================================== +remarks Symmetry energy: $esym +remarks =============================================================== +remarks Membrane restraining energy: $zresall +remarks =============================================================== +remarks Local cross-correlation: $lcc[f7.4] +remarks =============================================================== +remarks Desolvation energy: $edesolv +remarks Internal energy free molecules: $eintfree +remarks Internal energy complex: $eintcplx +remarks Binding energy: $dhbinding +remarks =============================================================== +remarks buried surface area: $saburied +remarks =============================================================== +set remark accumulate end +evaluate($ncount = 0) +while ($ncount < $data.ncomponents) loop waterremark + evaluate ($ncount = $ncount +1) + remarks water - chain_$ncount: $ener_water_$ncount $vdw_water_$ncount $elec_water_$ncount +end loop waterremark +remarks =============================================================== +remarks water - water: $ener_water_water $vdw_water_water $elec_water_water +remarks =============================================================== diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/protein-ss-restraints-all.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/protein-ss-restraints-all.cns new file mode 100644 index 0000000000000000000000000000000000000000..ce6537b77378451041f63bb9fb07cb9fce35b4d7 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/protein-ss-restraints-all.cns @@ -0,0 +1,88 @@ +! protein-ss-restraints-all.def +! Define automatically secondary stucture dihedral angle restraints for all residues +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +{+ file: protein-ss-restraints.def +} +{+ description: Creates dihedral angle restraints to maintain conformation of the protein backbone +} +{+ authors: Axel T. Brunger, and Paul D. Adams, +} +{+ modified by Alexandre Bonvin for HADDOCK use +} + +{=========================================================================================================} +{ things below this line do not normally need to be changed } +{=========================================================================================================} + +{- Dihedral restraints for the protein backbone -} +restraint dihedral + nass = 50000 +end +do (store1 = 1) (all) +evaluate ($group=1) +evaluate ($done=false) +while ( $done = false ) loop bdihe + if ( $exist_prot_segid_$group = true ) then + show sum(1) ( segid $prot_segid_$group ) + if ( $result > 0 ) then + evaluate ($error_phi=$Data.error_dih) + evaluate ($error_psi=$Data.error_dih) + for $id in id ( segid $prot_segid_$group and tag and not resn TIP3 ) loop resid + show (segid) (id $id) + evaluate ($segid=$result) + show (resid) ( id $id ) + evaluate ($resid=decode($result)) + evaluate ($rprec = $resid - 1) + show sum (store1) (resid $rprec and name C) + if ($result ne 0) then + evaluate ($rprec = $resid - 1) + pick dihedral + ( segid $segid and resid $rprec and name C ) + ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + geometry + evaluatate ($dihedral_phi=$result) + restraint dihedral + ! phi + assign ( segid $segid and resid $rprec and name C ) + ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + 1.0 $dihedral_phi $error_phi 2 + scale 200.0 + end + end if + evaluate ($rnext = $resid + 1) + show sum (store1) (resid $rnext and name N) + if ($result ne 0) then + pick dihedral + ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + ( segid $segid and resid $rnext and name N ) + geometry + evaluatate ($dihedral_psi=$result) + restraint dihedral + ! psi + assign ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + ( segid $segid and resid $rnext and name N ) + 1.0 $dihedral_psi $error_psi 2 + scale 200.0 + end + end if + end loop resid + end if + else + evaluate ($done=true) + end if + evaluate ($group=$group+1) +end loop bdihe + +flags include cdih end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/protein-ss-restraints-alpha-beta.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/protein-ss-restraints-alpha-beta.cns new file mode 100644 index 0000000000000000000000000000000000000000..0d6d8e4aa9b00b11bd201f8f9917a4628821978b --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/protein-ss-restraints-alpha-beta.cns @@ -0,0 +1,128 @@ +! protein-ss-restraints-alpha-beta.cns +! Define automatically secondary structure dihedral angle restraints +! for helical and beta-sheet segments +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +{+ file: protein-ss-restraints.def +} +{+ description: Creates dihedral angle restraints to maintain conformation of the protein backbone +} +{+ comment:This file is to be read by refinement files that modify atom coordinates +} +{+ authors: Axel T. Brunger, and Paul D. Adams +} +{+ modified by Alexandre Bonvin for HADDOCK use +} + +{=========================================================================================================} +{ things below this line do not normally need to be changed } +{=========================================================================================================} + +{- Dihedral restraints for the protein backbone in alpha-beta regions -} + +do (store1 = 1) (all) +restraint dihedral + nass = 50000 +end +evaluate ($group=1) +evaluate ($done=false) +while ( $done = false ) loop bdihe + if ( $exist_prot_segid_$group = true ) then + show sum(1) ( segid $prot_segid_$group ) + if ( $result > 0 ) then + evaluate ($error_phi=$Data.error_dih) + evaluate ($error_psi=$Data.error_dih) + for $id in id ( segid $prot_segid_$group and tag and not resn TIP* ) loop resid + show (segid) (id $id) + evaluate ($segid=$result) + show (resid) ( id $id ) + evaluate ($resid=decode($result)) + evaluate ($alphaphi = 0) + evaluate ($alphapsi = 0) + evaluate ($alpha_check = 0) + evaluate ($betaphi = 0) + evaluate ($betapsi = 0) + evaluate ($beta_check = 0) + evaluate ($rprec = $resid - 1) + show sum (store1) (resid $rprec and name C) + if ($result ne 0) then + pick dihedral + ( segid $segid and resid $rprec and name C ) + ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + geometry + evaluate ($dihedral_phi=$result) + evaluate ($alphaphi=max($dihedral_phi,-77)) + evaluate ($alphaphi=max($dihedral_phi,-37)) + if ($alphaphi eq -37) then + evaluate ($alpha_check = 1) + else + evaluate ($alpha_check = 0) + end if + evaluate ($betaphi=max($dihedral_phi,-145)) + evaluate ($betaphi=max($dihedral_phi,-105)) + if ($betaphi eq -105) then + evaluate ($beta_check = 1) + else + evaluate ($beta_check = 0) + end if + end if + evaluate ($rnext = $resid + 1) + show sum (store1) (resid $rnext and name N) + if ($result ne 0) then + pick dihedral + ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + ( segid $segid and resid $rnext and name N ) + geometry + evaluate ($dihedral_psi=$result) + evaluate ($alphapsi=max($dihedral_psi,-67)) + evaluate ($alphapsi=max($dihedral_psi,-27)) + if ($alphapsi eq -27) then + evaluate ($alpha_check = $alpha_check + 1) + end if + evaluate ($betapsi=max($dihedral_psi,105)) + evaluate ($betapsi=max($dihedral_psi,145)) + if ($betapsi eq 145) then + evaluate ($beta_check = $beta_check + 1) + end if + end if + evaluate ($defrest = 0) + if ($alpha_check eq 2) then + evaluate ($defrest = 1) + end if + if ($beta_check eq 2) then + evaluate ($defrest = 1) + end if + if ($defrest = 1) then + restraint dihedral + ! phi + assign ( segid $segid and resid $rprec and name C ) + ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + 1.0 $dihedral_phi $error_phi 2 + ! psi + assign ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + ( segid $segid and resid $rnext and name N ) + 1.0 $dihedral_psi $error_psi 2 + scale 200.0 + end + end if + end loop resid + end if + else + evaluate ($done=true) + end if + evaluate ($group=$group+1) +end loop bdihe + +flags include cdih end + + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/protein-ss-restraints-alpha.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/protein-ss-restraints-alpha.cns new file mode 100644 index 0000000000000000000000000000000000000000..38416657fc086d88a8288b50371b1f3e697103a8 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/protein-ss-restraints-alpha.cns @@ -0,0 +1,109 @@ +! protein-ss-restraints-alpha.cns +! Define automatically secondary structure dihedral angle restraints +! for helical segments +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +{+ file: protein-ss-restraints.def +} +{+ description: Creates dihedral angle restraints to maintain conformation of the protein backbone +} +{+ comment:This file is to be read by refinement files that modify atom coordinates +} +{+ authors: Axel T. Brunger, and Paul D. Adams +} +{+ modified by Alexandre Bonvin for HADDOCK use +} + +{=========================================================================================================} +{ things below this line do not normally need to be changed } +{=========================================================================================================} + +{- Dihedral restraints for the protein backbone in alpha-helical regions -} +restraint dihedral + nass = 50000 +end +do (store1 = 1) (all) +evaluate ($group=1) +evaluate ($done=false) +while ( $done = false ) loop bdihe + if ( $exist_prot_segid_$group = true ) then + show sum(1) ( segid $prot_segid_$group ) + if ( $result > 0 ) then + evaluate ($error_phi=$Data.error_dih) + evaluate ($error_psi=$Data.error_dih) + for $id in id (segid $prot_segid_$group and tag and not resn TIP3 ) loop resid + show (segid) (id $id) + evaluate ($segid=$result) + show (resid) ( id $id ) + evaluate ($resid=decode($result)) + evaluate ($alphaphi = 0) + evaluate ($alphapsi = 0) + evaluate ($alpha_check = 0) + evaluate ($rprec = $resid - 1) + show sum (store1) (resid $rprec and name C) + if ($result ne 0) then + pick dihedral + ( segid $segid and resid $rprec and name C ) + ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + geometry + evaluate ($dihedral_phi=$result) + evaluate ($alphaphi=max($dihedral_phi,-77)) + evaluate ($alphaphi=max($dihedral_phi,-37)) + if ($alphaphi eq -37) then + evaluate ($alpha_check = 1) + else + evaluate ($alpha_check = 0) + end if + end if + evaluate ($rnext = $resid + 1) + show sum (store1) (resid $rnext and name N) + if ($result ne 0) then + pick dihedral + ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + ( segid $segid and resid $rnext and name N ) + geometry + evaluate ($dihedral_psi=$result) + evaluate ($alphapsi=max($dihedral_psi,-67)) + evaluate ($alphapsi=max($dihedral_psi,-27)) + if ($alphapsi eq -27) then + evaluate ($alpha_check = $alpha_check + 1) + end if + end if + evaluate ($defrest = 0) + if ($alpha_check eq 2) then + evaluate ($defrest = 1) + end if + if ($defrest = 1) then + restraint dihedral + ! phi + assign ( segid $segid and resid $rprec and name C ) + ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + 1.0 $dihedral_phi $error_phi 2 + ! psi + assign ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + ( segid $segid and resid $rnext and name N ) + 1.0 $dihedral_psi $error_psi 2 + scale 200.0 + end + end if + end loop resid + end if + else + evaluate ($done=true) + end if + evaluate ($group=$group+1) +end loop bdihe + +flags include cdih end + + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/random_rotations.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/random_rotations.cns new file mode 100644 index 0000000000000000000000000000000000000000..a50e9f5624abb6405affc6a2d38b29187ea5c9bc --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/random_rotations.cns @@ -0,0 +1,180 @@ +! random_rotations.cns +! Perform a random rotation +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +! check if homomer + +inline @MODULE:check-homomers.cns + +do (store4 = 0) (all) +evaluate ($ncount = 0) +while ($ncount < $data.ncomponents) loop fixed + evaluate ($ncount = $ncount + 1) + eval($watersegname_$ncount="WA" + encode($ncount)) + if ($mol_fix_origin_$ncount eq true) then + do (store4 = 1) (segid $prot_segid_$ncount) + end if +end loop fixed + +if ($homosymmetry eq false) then + ! Random translation within a 10A cube + evaluate ($ncount = 0) + while ($ncount < $data.ncomponents) loop randtrans + evaluate ($ncount = $ncount +1) + if ($mol_fix_origin_$ncount eq false) then + evaluate ($xd = 10.0 * (0.5 - ran())) + evaluate ($yd = 10.0 * (0.5 - ran())) + evaluate ($zd = 10.0 * (0.5 - ran())) + coor trans sele=(segid $prot_segid_$ncount or segid $watersegname_$ncount) vector=($xd,$yd,$zd) end + end if + end loop randtrans +end if + +! Random rotation of molecules +evaluate ($ncount = 0) +evaluate ($nrotset = 0) +while ($ncount < $data.ncomponents) loop randrot + evaluate ($ncount = $ncount +1) + if ($mol_fix_origin_$ncount eq false) then + show ave (x) (segid $prot_segid_$ncount or segid $watersegname_$ncount) + evaluate ($xc = $result) + show ave (y) (segid $prot_segid_$ncount or segid $watersegname_$ncount) + evaluate ($yc = $result) + show ave (z) (segid $prot_segid_$ncount or segid $watersegname_$ncount) + evaluate ($zc = $result) + + ! Random rotation for each molecule except for symmtrical homomers for which + ! the same rotation is applied to all molecules to keep the symmetry + if ($nrotset = 0) then + !1. Generate random e1 e2 e3 and e4 in [-1, 1] so that e1^2 + e2^2 < 1 and e3^2+e4^2 < 1 + evaluate ($RRM_e1 = ran () * 2 - 1) + evaluate ($RRM_e2 = ran () * 2 - 1) + evaluate ($RRM_s1 = ($RRM_e1)*($RRM_e1) + ($RRM_e2)*($RRM_e2)) + + while ( $RRM_s1 >= 1) loop s1loop + evaluate ($RRM_e1 = ran () * 2 - 1) + evaluate ($RRM_e2 = ran () * 2 - 1) + evaluate ($RRM_s1 = ($RRM_e1)*($RRM_e1) + ($RRM_e2)*($RRM_e2)) + end loop s1loop + + evaluate ($RRM_e3 = ran () * 2 - 1) + evaluate ($RRM_e4 = ran () * 2 - 1) + evaluate ($RRM_s2 = ($RRM_e3)*($RRM_e3) + ($RRM_e4)*($RRM_e4)) + while ( $RRM_s2 >= 1) loop s2loop + evaluate ($RRM_e3 = ran () * 2 - 1) + evaluate ($RRM_e4 = ran () * 2 - 1) + evaluate ($RRM_s2 = ($RRM_e3)*($RRM_e3) + ($RRM_e4)*($RRM_e4)) + end loop s2loop + + !2. the quaternion q0 q1 q2 q3 + evaluate($RRM_q0 = $RRM_e1) + evaluate($RRM_q1 = $RRM_e2) + evaluate($RRM_q2 = $RRM_e3 * sqrt((1 - $RRM_s1)/$RRM_s2) ) + evaluate($RRM_q3 = $RRM_e4 * sqrt((1 - $RRM_s1)/$RRM_s2) ) + + !3. The rotation matrix from the quaternion + evaluate ($x1 = $RRM_q0 * $RRM_q0 + $RRM_q1 * $RRM_q1 - $RRM_q2 * $RRM_q2 - $RRM_q3 * $RRM_q3) + evaluate ($x2 = 2 * ($RRM_q1 * $RRM_q2 - $RRM_q0 * $RRM_q3) ) + evaluate ($x3 = 2 * ($RRM_q1 * $RRM_q3 + $RRM_q0 * $RRM_q2) ) + evaluate ($y1 = 2 * ($RRM_q1 * $RRM_q2 + $RRM_q0 * $RRM_q3) ) + evaluate ($y2 = $RRM_q0 * $RRM_q0 - $RRM_q1 * $RRM_q1 + $RRM_q2 * $RRM_q2 - $RRM_q3 * $RRM_q3) + evaluate ($y3 = 2 * ($RRM_q2 * $RRM_q3 - $RRM_q0 * $RRM_q1) ) + evaluate ($z1 = 2 * ($RRM_q1 * $RRM_q3 - $RRM_q0 * $RRM_q2) ) + evaluate ($z2 = 2 * ($RRM_q2 * $RRM_q3 + $RRM_q0 * $RRM_q1) ) + evaluate ($z3 = $RRM_q0 * $RRM_q0 - $RRM_q1 * $RRM_q1 - $RRM_q2 * $RRM_q2 + $RRM_q3 * $RRM_q3) + + if ($homosymmetry eq true) then + evaluate ($nrotset = 1) + end if + end if + + !4. The rotation + coor + center=($xc $yc $zc) + rotate matrix=($x1 $x2 $x3) ($y1 $y2 $y3) ($z1 $z2 $z3) + sele=(segid $prot_segid_$ncount or segid $watersegname_$ncount) + end + end if +end loop randrot + + +! If there are fixed molecules, randomly rotate as one unit all non-fixed ones +! around the geometric center of the fixed ones + +show sum (store4) (all) + +if ($result > 0) then + + show ave (x) (attribute store4 = 1) + evaluate ($xc = $result) + show ave (y) (attribute store4 = 1) + evaluate ($yc = $result) + show ave (z) (attribute store4 = 1) + evaluate ($zc = $result) + + ! Random rotation for each molecule except for symmtrical homomers for which + ! the same rotation is applied to all molecules to keep the symmetry + if ($nrotset = 0) then + !1. Generate random e1 e2 e3 and e4 in [-1, 1] so that e1^2 + e2^2 < 1 and e3^2+e4^2 < 1 + evaluate ($RRM_e1 = ran () * 2 - 1) + evaluate ($RRM_e2 = ran () * 2 - 1) + evaluate ($RRM_s1 = ($RRM_e1)*($RRM_e1) + ($RRM_e2)*($RRM_e2)) + + while ( $RRM_s1 >= 1) loop s1loop + evaluate ($RRM_e1 = ran () * 2 - 1) + evaluate ($RRM_e2 = ran () * 2 - 1) + evaluate ($RRM_s1 = ($RRM_e1)*($RRM_e1) + ($RRM_e2)*($RRM_e2)) + end loop s1loop + + evaluate ($RRM_e3 = ran () * 2 - 1) + evaluate ($RRM_e4 = ran () * 2 - 1) + evaluate ($RRM_s2 = ($RRM_e3)*($RRM_e3) + ($RRM_e4)*($RRM_e4)) + while ( $RRM_s2 >= 1) loop s2loop + evaluate ($RRM_e3 = ran () * 2 - 1) + evaluate ($RRM_e4 = ran () * 2 - 1) + evaluate ($RRM_s2 = ($RRM_e3)*($RRM_e3) + ($RRM_e4)*($RRM_e4)) + end loop s2loop + + !2. the quaternion q0 q1 q2 q3 + evaluate($RRM_q0 = $RRM_e1) + evaluate($RRM_q1 = $RRM_e2) + evaluate($RRM_q2 = $RRM_e3 * sqrt((1 - $RRM_s1)/$RRM_s2) ) + evaluate($RRM_q3 = $RRM_e4 * sqrt((1 - $RRM_s1)/$RRM_s2) ) + + !3. The rotation matrix from the quaternion + evaluate ($x1 = $RRM_q0 * $RRM_q0 + $RRM_q1 * $RRM_q1 - $RRM_q2 * $RRM_q2 - $RRM_q3 * $RRM_q3) + evaluate ($x2 = 2 * ($RRM_q1 * $RRM_q2 - $RRM_q0 * $RRM_q3) ) + evaluate ($x3 = 2 * ($RRM_q1 * $RRM_q3 + $RRM_q0 * $RRM_q2) ) + evaluate ($y1 = 2 * ($RRM_q1 * $RRM_q2 + $RRM_q0 * $RRM_q3) ) + evaluate ($y2 = $RRM_q0 * $RRM_q0 - $RRM_q1 * $RRM_q1 + $RRM_q2 * $RRM_q2 - $RRM_q3 * $RRM_q3) + evaluate ($y3 = 2 * ($RRM_q2 * $RRM_q3 - $RRM_q0 * $RRM_q1) ) + evaluate ($z1 = 2 * ($RRM_q1 * $RRM_q3 - $RRM_q0 * $RRM_q2) ) + evaluate ($z2 = 2 * ($RRM_q2 * $RRM_q3 + $RRM_q0 * $RRM_q1) ) + evaluate ($z3 = $RRM_q0 * $RRM_q0 - $RRM_q1 * $RRM_q1 - $RRM_q2 * $RRM_q2 + $RRM_q3 * $RRM_q3) + + if ($homosymmetry eq true) then + evaluate ($nrotset = 1) + end if + end if + + !4. The rotation + coor + center=($xc $yc $zc) + rotate matrix=($x1 $x2 $x3) ($y1 $y2 $y3) ($z1 $z2 $z3) + sele=(attribute store4 = 0) + end +end if + +do (x = refx) (resn ANI or resn DAN or resn XAN or resn SHA) +do (y = refy) (resn ANI or resn DAN or resn XAN or resn SHA) +do (z = refz) (resn ANI or resn DAN or resn XAN or resn SHA) + +!evaluate ($outname = "MODULE:" + "begin/" + $Filenames.fileroot + "_init_" + encode($count) + ".pdb") +!write coor format=pdbo output=$outname end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/read_data.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/read_data.cns new file mode 100644 index 0000000000000000000000000000000000000000..0499183803224fbed8de2940b8499c9eb8f29d50 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/read_data.cns @@ -0,0 +1,81 @@ +! read_data.cns +! Read the various restraints data +! (distances and dihedral angles only in this version) +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +! Ambiguous and unambiguous distance restraints, hbonds +noe + reset + nrestraints = 12000000 ! allocate space for NOEs + ceiling 1000 +end + +evaluate ($filenam0 = $ambig_fname + "_" + encode($count)) +fileexist $filenam0 end +if ($result eq false) then + evaluate ($filenam0 = $ambig_fname) +end if + +if ($filenam0 # "") then + fileexist $filenam0 end + if ($result eq true) then + noe class ambi @@$filenam0 end + end if +end if + +if ($Data.randremoval eq true) then + noe part $Data.npart end +end if + +if ($unambig_fname # "") then + fileexist $unambig_fname end + if ($result eq true) then + noe class dist @@$unambig_fname end + end if +end if + +if ($hbond_fname # "") then + fileexist $hbond_fname end + if ($result eq true) then + noe class hbon @@$hbond_fname end + end if +end if + +noe + averaging * sum + potential * soft + scale * 1.0 + sqconstant * 1.0 + sqexponent * 2 + soexponent * 1 + rswitch * 1.0 + sqoffset * 0.0 + asymptote * 2.0 + msoexponent * 1 + masymptote * -0.1 + mrswitch * 1.0 +end + + +!dihedral restraints: +restraints dihedral + reset + nassign 50000 +end +if ($dihe_fname # "") then + fileexist $dihe_fname end + if ($result eq true) then + restraints dihedral + @@$dihe_fname + end + end if +end if + +restraints dihedral ? end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/read_noes.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/read_noes.cns new file mode 100644 index 0000000000000000000000000000000000000000..be5c0b8c55dbbd984e82a3fceb10553d0ee60281 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/read_noes.cns @@ -0,0 +1,65 @@ +! read_noes.cns +! Read the various restraints data +! In this version only distance-based restraints +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * Originally adapted from Aria 1.2 from Nilges and Linge, EMBL. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +! Ambiguous and unambiguous distance restraints, hbonds +noe + reset + nrestraints = 12000000 ! allocate space for NOEs + ceiling 1000 +end + +evaluate ($filenam0 = $ambig_fname + "_" + encode($count)) +fileexist $filenam0 end +if ($result eq false) then + evaluate ($filenam0 = $ambig_fname) +end if + +if ($filenam0 # "") then + fileexist $filenam0 end + if ($result eq true) then + noe class ambi @@$filenam0 end + end if +end if + +if ($Data.randremoval eq true) then + noe part $Data.npart end +end if + +if ($unambig_fname # "") then + fileexist $unambig_fname end + if ($result eq true) then + noe class dist @@$unambig_fname end + end if +end if + +if ($hbond_fname # "") then + fileexist $hbond_fname end + if ($result eq true) then + noe class hbon @@$hbond_fname end + end if +end if + +noe + averaging * sum + potential * soft + scale * 1.0 + sqconstant * 1.0 + sqexponent * 2 + soexponent * 1 + rswitch * 1.0 + sqoffset * 0.0 + asymptote * 2.0 + msoexponent * 1 + masymptote * -0.1 + mrswitch * 1.0 +end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/read_param.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/read_param.cns new file mode 100644 index 0000000000000000000000000000000000000000..6f549a453e49c118de295658c1294a8a429b9365 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/read_param.cns @@ -0,0 +1,64 @@ +! read_param.cns +! Reads parameter files. +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +!! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** + +{* protein parameter file *} +eval ($prot_parameter_infile="TOPPAR:protein-allhdg5-4.param") + +{* nucleic acid parameter file *} +eval ($nucl_parameter_infile="TOPPAR:dna-rna-allatom-hj-opls-1.3.param") + +{* carbohydrate parameter file *} +eval ($carbo_parameter_infile="TOPPAR:carbohydrate.param") + +{* solvent parameter file *} +eval ($solv_parameter_infile="TOPPAR:solvent-allhdg5-4.param") + +{* fragment probes parameter file *} +eval ($ligands_parameter_infile="TOPPAR:fragment_probes.param") + +{* ion parameter file *} +eval ($ion_parameter_infile="TOPPAR:ion.param") + +{* heme parameter file *} +eval ($heme_parameter_infile="TOPPAR:hemes-allhdg.param") + +{* shape parameter file *} +eval ($shape_parameter_infile="TOPPAR:shape.param") + +{* cofactors parameter file *} +eval ($cofactors_parameter_infile="TOPPAR:cofactors.param") + +parameter + @@$prot_parameter_infile + @@$ion_parameter_infile + @@$nucl_parameter_infile + @@$carbo_parameter_infile + @@$solv_parameter_infile + @@$ligands_parameter_infile + @@$heme_parameter_infile + @@$shape_parameter_infile + @@$cofactors_parameter_infile + if ($ligand_param_fname # "") then + fileexist $ligand_param_fname end + if ($result eq true) then + @@$ligand_param_fname + end if + end if +end + +parameter + nbonds + nbxmod=5 atom cdie shift + cutnb=9.5 ctofnb=8.5 ctonnb=6.5 eps=1.0 e14fac=0.4 inhibit 0.25 + wmin=0.5 tolerance 0.5 + end +end + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/restrain-ions.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/restrain-ions.cns new file mode 100644 index 0000000000000000000000000000000000000000..52a5b3d2024ac21f44456d9ed204d455d8380ac2 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/restrain-ions.cns @@ -0,0 +1,109 @@ +! restrain-ions.cns +! distance restraints between an ion and any coordinating atom within 5A +! to maintain the coordination topologu +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +noe class dist end + +! first deal with monoatomic ions +evaluate ($pcount = 0) +for $id1 in id ( name "LI+1" or name "F-1" or name "NA+1" or name "MG+2" or name "AL+3" + or name "CL-1" or name "K+1" or name "CA+2" or name "V+2" or name "V+3" + or name "CR+2" or name "CR+3" or name "MN+2" or name "MN+3" or name "FE+2" + or name "FE+3" or name "NI+2" or name "CO+2" or name "CO+3" or name "CU+1" + or name "CU+2" or name "ZN+2" or name "BR-1" or name "SR+2" or name "MO+3" + or name "AG+1" or name "CD+2" or name "I-1" or name "CS+2" or name "HO+3" + or name "YB+2" or name "YB+3" or name "OS+4" or name "IR+3" or name "PT+2" + or name "AU+1" or name "AU+2" or name "HG+1" or name "HG+2" or name "PB+2" + or name "U+3" or name "U+4" or name "ZN+1" or name "ZN" ) loop sions + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + show (resname) (id $id1) + evaluate ($resname1=$result) + show (name) (id $id1) + evaluate ($name1=$result) + + evaluate ($mindis = 4.0) + for $id2 in id ( (name O* or name S* or name N*) and (id $id1) around $mindis and + (resn ACE or resn ALA or resn ALY or resn ARG or resn ASN or resn ASH or resn ASP or + resn CSP or resn CTN or resn CYC or resn CYF or resn CYM or resn CYS or resn DDZ or + resn GLN or resn GLH or resn GLU or resn GLY or resn HIS or resn HY3 or resn HYP or + resn ILE or resn LEU or resn LYS or resn M3L or resn MLY or resn MLZ or resn MET or + resn MSE or resn NEP or resn NME or resn PHE or resn PNS or resn PRO or resn PTR or + resn QSR or resn SEP or resn SER or resn SEC or resn THR or resn TOP or resn TRP or + resn TYP or resn TYR or resn TYS or resn VAL or resn A or resn C or resn G or + resn T or resn DA or resn DC or resn DG or resn DT or resn DJ )) loop search + + pick bond (id $id1) (id $id2) geometry + evaluate ($upper = $result) + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + show (name) (id $id2) + evaluate ($name2=$result) + + if ($segid1 eq $segid2) then + noe + assign (resid $resid1 and segid $segid1 and name $name1) + (resid $resid2 and segid $segid2 and name $name2) $upper 0.1 0.1 + end + end if + + end loop search + +end loop sions + +! then deal with multiatomic mions +evaluate ($pcount = 0) +for $id1 in id ( (resn SO4 or resn PO4 or resn WO4) and name O* ) loop mions + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + show (resname) (id $id1) + evaluate ($resname1=$result) + show (name) (id $id1) + evaluate ($name1=$result) + + evaluate ($mindis = 4.0) + for $id2 in id ( (name O* or name S* or name N*) and (id $id1) around $mindis and + (resn ACE or resn ALA or resn ALY or resn ARG or resn ASN or resn ASH or resn ASP or + resn CSP or resn CTN or resn CYC or resn CYF or resn CYM or resn CYS or resn DDZ or + resn GLN or resn GLH or resn GLU or resn GLY or resn HIS or resn HY3 or resn HYP or + resn ILE or resn LEU or resn LYS or resn M3L or resn MLY or resn MLZ or resn MET or + resn MSE or resn NEP or resn NME or resn PHE or resn PNS or resn PRO or resn PTR or + resn QSR or resn SEP or resn SER or resn SEC or resn THR or resn TOP or resn TRP or + resn TYP or resn TYR or resn TYS or resn VAL or resn A or resn C or resn G or + resn T or resn DA or resn DC or resn DG or resn DT or resn DJ )) loop search + + pick bond (id $id1) (id $id2) geometry + evaluate ($upper = $result) + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + show (name) (id $id2) + evaluate ($name2=$result) + + if ($segid1 eq $segid2) then + noe + assign (resid $resid1 and segid $segid1 and name $name1) + (resid $resid2 and segid $segid2 and name $name2) $upper 0.1 0.1 + end + end if + + end loop search + +end loop mions diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/sa_ltad_cool1.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/sa_ltad_cool1.cns new file mode 100644 index 0000000000000000000000000000000000000000..50f5c12224d2bb294a7de5b33b6a586ca1e7dd75 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/sa_ltad_cool1.cns @@ -0,0 +1,130 @@ +! sa_ltad_cool1.cns +! Perform the first simulated annealing stage of it1 +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * Originally adapted from Aria 1.2 from Nilges and Linge, EMBL. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +evaluate ($ncycle = 10) + +evaluate ($interstep = ($SaProtocol.inter_fin_rigid - $SaProtocol.inter_init_rigid)/($ncycle-1)) +evaluate ($kinter = $SaProtocol.inter_init_rigid) + +evaluate ($asy_add = ($Data.asy_cool1-$Data.asy_hot)/$ncycle) +evaluate ($masy_add = ($Data.masy_cool1-$Data.masy_hot)/$ncycle) + +evaluate ($asy=$Data.asy_hot) +evaluate ($masy=$Data.masy_hot) +noe + rswitch ambi $Data.Rswi_hot + rswitch dist $Data.Rswi_hot + rswitch hbon $Data.Rswi_hot + + mrswitch ambi $Data.mRswi_hot + mrswitch dist $Data.mRswi_hot + mrswitch hbon $Data.mRswi_hot + + asym ambi $Data.asy_hot + asym dist $Data.asy_hot + asym hbon $Data.asy_hot + + masym ambi $Data.masy_hot + masym dist $Data.masy_hot + masym hbon $Data.masy_hot +end + +restraints dihedral scale=$Data.dihedrals_cool1 end + + +evaluate ($tempstep = ($SaProtocol.t1_init - $SaProtocol.t1_final)/$ncycle) +evaluate ($calcsteps = int($SaProtocol.cool1_steps/$ncycle)) +evaluate ($printsteps = int($calcsteps / 4)) +evaluate ($timestep = $SaProtocol.timestep*$SaProtocol.tadfactor) + +if ($Data.unambig_hot = 0) then + evaluate ($Data.unambig_hot = 0.000001) +end if +if ($Data.unambig_cool1 = 0) then + evaluate ($Data.unambig_cool1 = 0.000001) +end if +if ($Data.ambig_hot = 0)then + evaluate ($Data.ambig_hot = 0.000001) +end if +if ($Data.ambig_cool1 = 0) then + evaluate ($Data.ambig_cool1 = 0.000001) +end if +if ($Data.hbond_hot = 0) then + evaluate ($Data.hbond_hot = 0.000001) +end if +if ($Data.hbond_cool1 = 0) then + evaluate ($Data.hbond_cool1 = 0.000001) +end if + +evaluate ($k_unamb= $Data.unambig_hot) +evaluate ($unambig_fac = ($Data.unambig_cool1/$Data.unambig_hot)^(1/$ncycle)) +evaluate ($k_amb= $Data.ambig_hot) +evaluate ($ambig_fac = ($Data.ambig_cool1/$Data.ambig_hot)^(1/$ncycle)) +evaluate ($k_hbond= $Data.hbond_hot) +evaluate ($hbond_fac = ($Data.hbond_cool1/$Data.hbond_hot)^(1/$ncycle)) + + +evaluate ($bath = $SaProtocol.t1_init) +do (vx=maxwell($bath)) ( all ) +do (vy=maxwell($bath)) ( all ) +do (vz=maxwell($bath)) ( all ) + + + +evaluate ($reassign = TRUE) +evaluate ($i_cool = 0) +while ($i_cool < $ncycle) loop cool + + evaluate ($i_cool=$i_cool+1) + + evaluate ($bath = $bath - $tempstep) + evaluate ($k_unamb = $k_unamb*$unambig_fac) + evaluate ($k_amb = $k_amb*$ambig_fac) + evaluate ($k_hbond = $k_hbond*$hbond_fac) + evaluate ($asy=$asy+$asy_add) + evaluate ($masy=$masy+$masy_add) + + noe + scale dist $k_unamb + scale ambi $k_amb + scale hbon $k_hbond + asym ambi $asy + asym dist $asy + asym hbon $asy + masym ambi $masy + masym dist $masy + masym hbon $masy + end + + !scale intermolecular interactions + inline @MODULE:scale_inter.cns + evaluate ($kinter = $kinter + $interstep) + + dyna tors + reassign $reassign + timestep=$timestep + nstep=$calcsteps + nprint=$printsteps + ntrfrq=0 + tcoupling = true temperature = $bath + end + + energy end + if ($ener > 99999999) then + display ENERGY PROBLEM, THE SYSTEM IS BLOWING UP: ==> STOPPING + stop + end if + evaluate ($reassign = FALSE) + +end loop cool + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/sa_ltad_cool2.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/sa_ltad_cool2.cns new file mode 100644 index 0000000000000000000000000000000000000000..eac233612324c1350e4513e2996a029f27b34dab --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/sa_ltad_cool2.cns @@ -0,0 +1,130 @@ +! sa_ltad_cool2.cns +! Perform the second simulation annealing stage of it1 +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * Originally adapted from Aria 1.2 from Nilges and Linge, EMBL. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +evaluate ($ncycle = 10) + +evaluate ($asy_add = ($Data.asy_cool2-$Data.asy_cool1)/$ncycle) +evaluate ($masy_add = ($Data.masy_cool2-$Data.masy_cool1)/$ncycle) + +evaluate ($asy=$Data.asy_cool1) +evaluate ($masy=$Data.masy_cool1) + +noe + rswitch ambi $Data.Rswi_cool1 + rswitch dist $Data.Rswi_cool1 + rswitch hbon $Data.Rswi_cool1 + + mrswitch ambi $Data.mRswi_cool1 + mrswitch dist $Data.mRswi_cool1 + mrswitch hbon $Data.mRswi_cool1 + + asym ambi $Data.asy_cool1 + asym dist $Data.asy_cool1 + asym hbon $Data.asy_cool1 + + masym ambi $Data.masy_cool1 + masym dist $Data.masy_cool1 + masym hbon $Data.masy_cool1 +end + +restraints dihedral scale=$Data.dihedrals_cool2 end + + +evaluate ($interstep = ($SaProtocol.inter_fin_cool2 - $SaProtocol.inter_init_cool2)/($ncycle-1)) +evaluate ($kinter = $SaProtocol.inter_init_cool2) + +evaluate ($tempstep = ($SaProtocol.t2_init - $SaProtocol.t2_final)/$ncycle) +evaluate ($calcsteps = int($SaProtocol.cool2_steps/$ncycle)) +evaluate ($printsteps = int($calcsteps / 4)) +evaluate ($timestep = $SaProtocol.timestep*$SaProtocol.tadfactor) + +if ($Data.unambig_cool1 = 0) then + evaluate ($Data.unambig_cool1 = 0.000001) +end if +if ($Data.unambig_cool2 = 0) then + evaluate ($Data.unambig_cool2 = 0.000001) +end if +if ($Data.ambig_cool1 = 0) then + evaluate ($Data.ambig_cool1 = 0.000001) +end if +if ($Data.ambig_cool2 = 0) then + evaluate ($Data.ambig_cool2 = 0.000001) +end if +if ($Data.hbond_cool1 = 0) then + evaluate ($Data.hbond_cool1 = 0.000001) +end if +if ($Data.hbond_cool2 = 0) then + evaluate ($Data.hbond_cool2 = 0.000001) +end if + +evaluate ($k_unamb= $Data.unambig_cool1) +evaluate ($unambig_fac = ($Data.unambig_cool2/$Data.unambig_cool1)^(1/$ncycle)) +evaluate ($k_amb= $Data.ambig_cool1) +evaluate ($ambig_fac = ($Data.ambig_cool2/$Data.ambig_cool1)^(1/$ncycle)) +evaluate ($k_hbond= $Data.hbond_cool1) +evaluate ($hbond_fac = ($Data.hbond_cool2/$Data.hbond_cool1)^(1/$ncycle)) + + +evaluate ($bath = $SaProtocol.t2_init) +do (vx=maxwell($bath)) ( all ) +do (vy=maxwell($bath)) ( all ) +do (vz=maxwell($bath)) ( all ) + +evaluate ($reassign = TRUE) +evaluate ($i_cool = 0) +while ($i_cool < $ncycle) loop cool + + evaluate ($i_cool=$i_cool+1) + + evaluate ($bath = $bath - $tempstep) + evaluate ($k_unamb = $k_unamb*$unambig_fac) + evaluate ($k_amb = $k_amb*$ambig_fac) + evaluate ($k_hbond = $k_hbond*$hbond_fac) + evaluate ($asy=$asy+$asy_add) + evaluate ($masy=$masy+$masy_add) + + + noe + scale dist $k_unamb + scale ambi $k_amb + scale hbon $k_hbond + asym ambi $asy + asym dist $asy + asym hbon $asy + masym ambi $masy + masym dist $masy + masym hbon $masy + end + + !scale intermolecular interactions: + inline @MODULE:scale_inter.cns + evaluate ($kinter = $kinter + $interstep) + + dyna tors + reassign $reassign + timestep=$timestep + nstep=$calcsteps + nprint=$printsteps + ntrfrq=0 + tcoupling = true temperature = $bath + end + evaluate ($reassign = FALSE) + + energy end + if ($ener > 99999999) then + display ENERGY PROBLEM, THE SYSTEM IS BLOWING UP: ==> STOPPING + stop + end if + +end loop cool + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/sa_ltad_cool3.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/sa_ltad_cool3.cns new file mode 100644 index 0000000000000000000000000000000000000000..892a824572ffe8c839b07d655cd8b47f21882f43 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/sa_ltad_cool3.cns @@ -0,0 +1,128 @@ +! sa_ltad_cool3.cns +! Perfrom the third simulated annealing stage of it1 +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * Originally adapted from Aria 1.2 from Nilges and Linge, EMBL. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +evaluate ($ncycle = 20) + +evaluate ($asy_add = ($Data.asy_cool3-$Data.asy_cool2)/$ncycle) +evaluate ($masy_add = ($Data.masy_cool3-$Data.masy_cool2)/$ncycle) + +evaluate ($asy=$Data.asy_cool2) +evaluate ($masy=$Data.masy_cool2) + +noe + rswitch ambi $Data.Rswi_cool2 + rswitch dist $Data.Rswi_cool2 + rswitch hbon $Data.Rswi_cool2 + + mrswitch ambi $Data.mRswi_cool2 + mrswitch dist $Data.mRswi_cool2 + mrswitch hbon $Data.mRswi_cool2 + + asym ambi $Data.asy_cool2 + asym dist $Data.asy_cool2 + asym hbon $Data.asy_cool2 + + masym ambi $Data.masy_cool2 + masym dist $Data.masy_cool2 + masym hbon $Data.masy_cool2 +end + +restraints dihedral scale=$Data.dihedrals_cool3 end + + +evaluate ($interstep = ($SaProtocol.inter_fin_cool3 - $SaProtocol.inter_init_cool3)/($ncycle-1)) +evaluate ($kinter = $SaProtocol.inter_init_cool3) + +evaluate ($tempstep = ($SaProtocol.t3_init - $SaProtocol.t3_final)/$ncycle) +evaluate ($calcsteps = int($SaProtocol.cool3_steps/$ncycle)) +evaluate ($printsteps = int($calcsteps / 4)) +evaluate ($timestep = $SaProtocol.timestep*$SaProtocol.tadfactor) + +if ($Data.unambig_cool2 = 0) then + evaluate ($Data.unambig_cool2 = 0.000001) +end if +if ($Data.unambig_cool3 = 0) then + evaluate ($Data.unambig_cool3 = 0.000001) +end if +if ($Data.ambig_cool2 = 0) then + evaluate ($Data.ambig_cool2 = 0.000001) +end if +if ($Data.ambig_cool3 = 0) then + evaluate ($Data.ambig_cool3 = 0.000001) +end if +if ($Data.hbond_cool2 = 0) then + evaluate ($Data.hbond_cool2 = 0.000001) +end if +if ($Data.hbond_cool3 = 0) then + evaluate ($Data.hbond_cool3 = 0.000001) +end if + +evaluate ($k_unamb= $Data.unambig_cool2) +evaluate ($unambig_fac = ($Data.unambig_cool3/$Data.unambig_cool2)^(1/$ncycle)) +evaluate ($k_amb= $Data.ambig_cool2) +evaluate ($ambig_fac = ($Data.ambig_cool3/$Data.ambig_cool2)^(1/$ncycle)) +evaluate ($k_hbond= $Data.hbond_cool2) +evaluate ($hbond_fac = ($Data.hbond_cool3/$Data.hbond_cool2)^(1/$ncycle)) + +evaluate ($bath = $SaProtocol.t3_init) +do (vx=maxwell($bath)) ( all ) +do (vy=maxwell($bath)) ( all ) +do (vz=maxwell($bath)) ( all ) + +evaluate ($reassign = TRUE) +evaluate ($i_cool = 0) +while ($i_cool < $ncycle) loop cool + + evaluate ($i_cool=$i_cool+1) + + evaluate ($bath = $bath - $tempstep) + evaluate ($k_unamb = $k_unamb*$unambig_fac) + evaluate ($k_amb = $k_amb*$ambig_fac) + evaluate ($k_hbond = $k_hbond*$hbond_fac) + evaluate ($asy=$asy+$asy_add) + evaluate ($masy=$masy+$masy_add) + + noe + scale dist $k_unamb + scale ambi $k_amb + scale hbon $k_hbond + asym ambi $asy + asym dist $asy + asym hbon $asy + masym ambi $masy + masym dist $masy + masym hbon $masy + end + + !scale intermolecular interactions: + inline @MODULE:scale_inter.cns + evaluate ($kinter = $kinter + $interstep) + + dyna tors + reassign $reassign + timestep=$timestep + nstep=$calcsteps + nprint=$printsteps + ntrfrq=0 + tcoupling = true temperature = $bath + end + evaluate ($reassign = FALSE) + + energy end + if ($ener > 99999999) then + display ENERGY PROBLEM, THE SYSTEM IS BLOWING UP: ==> STOPPING + stop + end if + +end loop cool + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/sa_ltad_hightemp.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/sa_ltad_hightemp.cns new file mode 100644 index 0000000000000000000000000000000000000000..8b346d4ab71650e35d1a527508d745457fcd8b19 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/sa_ltad_hightemp.cns @@ -0,0 +1,65 @@ +! sa_ltad_hightemp.cns +! Perform the high-temperature rigid-body MD of it1 +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * Originally adapted from Aria 1.2 from Nilges and Linge, EMBL. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +evaluate ($calcsteps= $SaProtocol.initiosteps) +evaluate ($printsteps= max(int($calcsteps/10),1)) + +noe + rswitch ambi $Data.Rswi_hot + rswitch dist $Data.Rswi_hot + rswitch hbon $Data.Rswi_hot + + mrswitch ambi $Data.mRswi_hot + mrswitch dist $Data.mRswi_hot + mrswitch hbon $Data.mRswi_hot + + asym ambi $Data.asy_hot + asym dist $Data.asy_hot + asym hbon $Data.asy_hot + + masym ambi $Data.masy_hot + masym dist $Data.masy_hot + masym hbon $Data.masy_hot +end + +evaluate ($bath = $SaPRotocol.tadhigh_t) +evaluate ($timestep = $SaProtocol.timestep*$SaProtocol.tadfactor) + +do (vx = maxwell($bath)) (all) +do (vy = maxwell($bath)) (all) +do (vz = maxwell($bath)) (all) + + +restraints dihedral scale $Data.dihedrals_hot end + +evaluate ($reassign = TRUE) + +noe + scale dist $Data.unambig_hot + scale ambi $Data.ambig_hot + scale hbon $Data.hbond_hot +end + +evaluate ($kinter = $SaProtocol.inter_init_rigid) +inline @MODULE:scale_inter.cns + +dyna tors + reassign $reassign + timestep=$timestep + nstep=$calcsteps + nprint=$printsteps + ntrfrq=0 + tcoupling = true temperature = $bath +end + +evaluate ($reassign = FALSE) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/scale_inter.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/scale_inter.cns new file mode 100644 index 0000000000000000000000000000000000000000..7088087a65b71bcdb213cce29d86ab6c043225e8 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/scale_inter.cns @@ -0,0 +1,45 @@ +! scale_inter.cns +! Scaling of intermolecular interactions +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +igroup interaction (not all) (not all) end + +igroup + + eval($nchain1 = 0) + + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + + interaction (segid $prot_segid_$nchain1 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) + (segid $prot_segid_$nchain1 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) weight * $scale.int_$nchain1_$nchain1 end + interaction (segid $prot_segid_$nchain1 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) + ((resn WAT or resn HOH or resn TIP* or resn DMS)) weight * 1.0 vdw $kinter elec $kinter end + + eval($nchain2 = $nchain1 ) + while ($nchain2 < $data.ncomponents) loop nloop2 + eval($nchain2 = $nchain2 + 1) + eval($scalfac = $kinter * $scale.int_$nchain1_$nchain2) + interaction (segid $prot_segid_$nchain1 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) + (segid $prot_segid_$nchain2 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) weight * 1.0 vdw $scalfac elec $scalfac end + end loop nloop2 + + end loop nloop1 + + interaction (resn ANI) (resn ANI) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DAN) (resn DAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn XAN) (resn XAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DUM) (resn DUM) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (resn SHA) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (not resn SHA) weight * 0.0 end + + interaction ((resn WAT or resn HOH or resn TIP* or resn DMS)) ((resn WAT or resn HOH or resn TIP* or resn DMS)) weight * 1.0 end + +end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/scale_inter_final.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/scale_inter_final.cns new file mode 100644 index 0000000000000000000000000000000000000000..efae5ce10a1fdafe1ef2f1d47a0ff9ebe57a1c8f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/scale_inter_final.cns @@ -0,0 +1,39 @@ +! scale_inter_final.cns +! Scaling of intermolecular interactions +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +igroup interaction (not all) (not all) end + +igroup + + eval($nchain1 = 0) + + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + eval($nchain2 = $nchain1 ) + while ($nchain2 < $data.ncomponents) loop nloop2 + eval($nchain2 = $nchain2 + 1) + eval($scalfac = $kinter * $scale.int_$nchain1_$nchain2) + interaction (segid $prot_segid_$nchain1 and not + (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA or resn DPP or resn PCW or resn PEE)) + (segid $prot_segid_$nchain2 and not + (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA or resn DPP or resn PCW or resn PEE)) weight * 1.0 vdw $scalfac elec $scalfac end + end loop nloop2 + + end loop nloop1 + + interaction (resn ANI) (resn ANI) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DAN) (resn DAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn XAN) (resn XAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DUM) (resn DUM) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (resn SHA) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (not resn SHA) weight * 0.0 end + +end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/scale_inter_only.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/scale_inter_only.cns new file mode 100644 index 0000000000000000000000000000000000000000..7abf15e4f42ad05aaeaf8c654c01ad1ea178d2c5 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/scale_inter_only.cns @@ -0,0 +1,41 @@ +! scale_inter_only.cns +! Scaling of intermolecular interaction (not internal energies) +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +igroup interaction (not all) (not all) end + +igroup + + eval($nchain1 = 0) + + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + eval($nchain2 = $nchain1 ) + while ($nchain2 < $data.ncomponents) loop nloop2 + eval($nchain2 = $nchain2 + 1) + eval($scalfac = $kinter * $mol_int_$nchain1_$nchain2) + interaction (segid $prot_segid_$nchain1 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) + (segid $prot_segid_$nchain2 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) weight * 1.0 vdw $scalfac elec $scalfac end + end loop nloop2 + interaction (segid $prot_segid_$nchain1 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) + ((resn WAT or resn HOH or resn TIP* or resn DMS)) weight * 1.0 vdw $kinter elec $kinter end + + end loop nloop1 + + interaction ((resn WAT or resn HOH or resn TIP*)) ((resn WAT or resn HOH or resn TIP*)) weight * 1.0 end + + interaction (resn ANI) (resn ANI) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DAN) (resn DAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn XAN) (resn XAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DUM) (resn DUM) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (resn SHA) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (not resn SHA) weight * 0.0 end + +end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/scale_intra_only.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/scale_intra_only.cns new file mode 100644 index 0000000000000000000000000000000000000000..15b0adfbb562862214f161c494c14a17dbf6beb7 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/scale_intra_only.cns @@ -0,0 +1,36 @@ +! scale_intra_only.cns +! Scaling of intramolecular energies (no intermolecular energies) +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +igroup interaction (not all) (not all) end + +igroup + + eval($nchain1 = 0) + + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + + interaction (segid $prot_segid_$nchain1 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) + (segid $prot_segid_$nchain1 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) weight * 1.0 end + + end loop nloop1 + + interaction (resn ANI) (resn ANI) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DAN) (resn DAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn XAN) (resn XAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DUM) (resn DUM) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (resn SHA) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (not resn SHA) weight * 0.0 end + +end + + + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/separate.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/separate.cns new file mode 100644 index 0000000000000000000000000000000000000000..b25ebaee28aca28e90322a5466a5700a2f100538 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/separate.cns @@ -0,0 +1,236 @@ +! separate.cns +! Distribute molecules in 3D space +! Orient each molecule according to its principal axes +! and restore them all at the end (after the while loop) +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +! first flag all fixed molecules +do (store4 = 0) (all) +evaluate ($ncount = 0) +evaluate ($nfixed = 0) +while ($ncount < $data.ncomponents) loop orientmol + evaluate ($ncount = $ncount + 1) + if ($mol_fix_origin_$ncount eq true) then + evaluate ($nfixed = $nfixed + 1) + do (store4 = 1) (segid $prot_segid_$ncount) + end if +end loop orientmol + +if ($nfixed < $data.ncomponents) then + + evaluate ($xc = 0.0) + evaluate ($yc = 0.0) + evaluate ($zc = 0.0) + ! then define the geometrical center of the fixed molecules if present + show sum (store4) (all) + if ($result > 0) then + show ave (x) (attribute store4 = 1) + evaluate ($xc = $result) + show ave (y) (attribute store4 = 1) + evaluate ($yc = $result) + show ave (z) (attribute store4 = 1) + evaluatee ($zc = $result) + end if + + do (xcomp = x) (all) + do (ycomp = y) (all) + do (zcomp = z) (all) + + ! then orient each moving molecule separately at the origin + ! and translate it to the geometric center of the fixed molecules + evaluate ($ncount = 0) + while ($ncount < $data.ncomponents) loop orientmol + evaluate ($ncount = $ncount +1) + eval($watersegname_$ncount="WA" + encode($ncount)) + if ($mol_fix_origin_$ncount eq false) then + coor orient sele=(segid $prot_segid_$ncount or segid $watersegname_$ncount) end + coor sele=(segid $prot_segid_$ncount or segid $watersegname_$ncount) translate vector = ($xc $yc $zc) end + do (xcomp = x) (segid $prot_segid_$ncount or segid $watersegname_$ncount) + do (ycomp = y) (segid $prot_segid_$ncount or segid $watersegname_$ncount) + do (zcomp = z) (segid $prot_segid_$ncount or segid $watersegname_$ncount) + end if + end loop orientmol + + do (x = xcomp) (not (resn ANI or resn XAN or resn DAN)) + do (y = ycomp) (not (resn ANI or resn XAN or resn DAN)) + do (z = zcomp) (not (resn ANI or resn XAN or resn DAN)) + + ! Find the largest axis of all molecules + evaluate ($minispacing = 25.0) + evaluate ($mxdim = 0) + evaluate ($ncount = 0) + + while ($ncount < $data.ncomponents) loop findmax + evaluate ($ncount = $ncount +1) + + show max (x) (segid $prot_segid_$ncount or segid $watersegname_$ncount) + evaluate ($xdim = $result) + show min (x) (segid $prot_segid_$ncount or segid $watersegname_$ncount) + evaluate ($xdim = $xdim - $result) + + show max (y) (segid $prot_segid_$ncount or segid $watersegname_$ncount) + evaluate ($ydim = $result) + show min (y) (segid $prot_segid_$ncount or segid $watersegname_$ncount) + evaluate ($ydim = $ydim - $result) + + show max (z) (segid $prot_segid_$ncount or segid $watersegname_$ncount) + evaluate ($zdim = $result) + show min (z) (segid $prot_segid_$ncount or segid $watersegname_$ncount) + evaluate ($zdim = $zdim - $result) + + ! Check which dimension (x,y,z) is the largest = mxdim + evaluate ($mxdim = max($mxdim, $xdim, $ydim, $zdim)) + + end loop findmax + + evaluate ($spacing = $minispacing + $mxdim ) + display SPACING SET TO $spacing ANGSTROM + + ! This has to be manually coded because of the variable name + ! Should be fine since we support only a few types of symmetry + ! Maybe change the variable name later if these are expanded + ! to have the number at the end? + + inline @MODULE:check-homomers.cns + + if ($homosymmetry eq true) then + ! In case of homosymmetry, place molecules in a plane + do (store4 = 0) (all) + evaluate ($ncount = 0) + while ($ncount < $data.ncomponents) loop orientmol + evaluate ($ncount = $ncount + 1) + if ($mol_fix_origin_$ncount eq false) then + do (store4 = 1) (segid $prot_segid_$ncount) + end if + end loop orientmol + + {* translate and generate symmetric positions by rotation around z *} + coor trans sele=(attr store4=1) vector=($spacing,0,0) end + + ! if one molecule is fixed (e.g. plane), move all others along z-axis + !if ($data.ncomponents > $n_moving_mol) then + ! coor trans sele=(attr store4=1) vector=(0,0,$spacing) end + !end if + + evaluate ($ncount = 2) + evaluate ($increment = 360/$n_moving_mol) + while ($ncount le $data.ncomponents) loop orientsym + + if ($mol_fix_origin_$ncount eq false) then + {* rotate around z axis *} + evaluate ($xr = $increment) + evaluate ($x1 = cos($xr)) + evaluate ($x2 = -sin($xr)) + evaluate ($x3 = 0 ) + evaluate ($y1 = sin($xr)) + evaluate ($y2 = cos($xr)) + evaluate ($y3 = 0 ) + evaluate ($z1 = 0 ) + evaluate ($z2 = 0 ) + evaluate ($z3 = 1 ) + coor + center=($xc $yc $zc) + rotate matrix=($x1 $x2 $x3) ($y1 $y2 $y3) ($z1 $z2 $z3) + sele=(segid $prot_segid_$ncount or segid $watersegname_$ncount) + end + evaluate ($increment = $xr + 360/$n_moving_mol) + + end if + evaluate ($ncount = $ncount + 1) + + end loop orientsym + + else + ! Do we need fix any molecule? + evaluate($n_moving_mol = 0) + evaluate ($ncount = 0) + while ($ncount < $data.ncomponents) loop centermol + evaluate ($ncount = $ncount + 1) + if ($mol_fix_origin_$ncount eq false) then + evaluate($n_moving_mol = $n_moving_mol + 1) + end if + end loop centermol + + ! Translate molecules to positions calculated using an algorithm + ! based on minimization of electrostatic potential of N equally charged particles. + ! See Thomson problem: http://en.wikipedia.org/wiki/Thomson_problem + evaluate ($filename = "TOPPAR:initial_positions/trans_vector_" + encode($n_moving_mol) ) + inline @@$filename + + ! Logic: + ! Assign a random number larger than 0 to every molecule + ! Assign 0.0 to fixed molecules + ! For every i up to the number of molecules + ! pick the mol with the largest number and displace it + ! then zero its number. + ! This will place molecules in space sort of randomly + ! Stop when the sum of all numbers is zero + + ! Generate as many random numbers as the # of mols + evaluate ($ncount = 0) + while ($ncount < $data.ncomponents) loop genrandom + evaluate ($ncount = $ncount + 1) + if ($mol_fix_origin_$ncount eq true) then + evaluate ($random_$ncount = 0.0) + else + evaluate ($random_$ncount = random()) + end if + end loop genrandom + + ! Randomly pick a molecule and place it + ! on the pre-defined position - iterate + evaluate ($sum_random = 999) + evaluate ($molcounter = 1) + + while ($sum_random > 0) loop placemol + evaluate ($maximum = 0) + evaluate ($maxid = 0) + evaluate ($ncount = 0) + + ! Select molecule with largest random number + while ($ncount < $data.ncomponents) loop selectmol + evaluate ($ncount = $ncount + 1) + if ($random_$ncount > $maximum) then + evaluate ($maximum = $random_$ncount) + evaluate ($maxid = $ncount) + end if + end loop selectmol + + if ($mol_fix_origin_$maxid eq false) then + coor trans + sele=(segid $prot_segid_$maxid or segid $watersegname_$maxid) + vector=($x_$molcounter, $y_$molcounter, $z_$molcounter) + end + + ! Reset random_ncount to 0 to avoid re-selecting + evaluate ($random_$maxid = 0) + + ! Increment molcounter to update new + evaluate ($molcounter = $molcounter + 1) + + ! Update sum_random + evaluate ($ncount = 0) + evaluate ($sum_random = 0) + + while ($ncount < $data.ncomponents) loop resetsumrandom + evaluate ($ncount = $ncount + 1) + evaluate( $sum_random = $sum_random + $random_$ncount) + end loop resetsumrandom + + end if + end loop placemol + end if + + do (x = refx) (resn ANI or resn DAN or resn XAN) + do (y = refy) (resn ANI or resn DAN or resn XAN) + do (z = refz) (resn ANI or resn DAN or resn XAN) + +end if diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/setflags.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/setflags.cns new file mode 100644 index 0000000000000000000000000000000000000000..754df3959432795dadf9f62a136995689f23ef0d --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/setflags.cns @@ -0,0 +1,24 @@ +! setflags.cns +! Defines energy flags +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +if ($Data.cdih.on eq true) then + evaluate ($Data.flags.cdih = true) +end if +if ($Data.flags.noe = TRUE) then + flags include noe end +end if +if ($Data.flags.cdih = TRUE) then + flags include cdih end +end if +if ($Data.flags.ncs = TRUE) then + flags include ncs end +end if diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/symmultimer.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/symmultimer.cns new file mode 100644 index 0000000000000000000000000000000000000000..3b4f731e948bf1d58eab0f71f457da6e52afc3e9 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/symmultimer.cns @@ -0,0 +1,677 @@ +! symmultimer.cns +! Define symmetry restraints +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * Originally adapted from Aria 1.2 from Nilges and Linge, EMBL. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +if ($Data.flags.sym eq true) then + + noe class symm end + + ! Define C2 symmetry restraints for symmetrical multimers + ! + eval ($ncount = 0) + while ($ncount < $data.nc2sym) loop c2symloop + + eval ($ncount = $ncount + 1) + evaluate ($i1start = $c2sym_sta1_$ncount) + evaluate ($i1end = $c2sym_end1_$ncount) + evaluate ($chain1 = $c2sym_seg1_$ncount) + evaluate ($i2start = $c2sym_sta2_$ncount) + evaluate ($i2end = $c2sym_end2_$ncount) + evaluate ($chain2 = $c2sym_seg2_$ncount) + + !first check that the chain lengths are equal for the two defined molecules + evaluate ($diff1 = $i1end - $i1start) + evaluate ($diff2 = $i2end - $i2start) + if ($diff1 ne $diff2) then + display CHAIN LENGTH FOR SYMMETRY RESTRAINTS DOES NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + + eval ($icount = 0) + while ($i1start < $i1end) loop genc2sym + + evaluate ($resid1 = $i1start) + evaluate ($resid2 = $i2end - $icount) + evaluate ($resid3 = $i2start) + evaluate ($resid4 = $i1end - $icount) + + noe + assign (resid $resid1 and (name CA or name P or name BB) and segid $chain1) + (resid $resid2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resid3 and (name CA or name P or name BB) and segid $chain2) + (resid $resid4 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + end + + evaluate ($icount = $icount + 1) + evaluate ($i1start = $i1start + 1) + evaluate ($i2start = $i2start + 1) + + end loop genc2sym + + end loop c2symloop + + + ! Define C3 symmetry restraints for symmetrical multimers + ! + eval ($ncount = 0) + while ($ncount < $data.nc3sym) loop c3symloop + + eval ($ncount = $ncount + 1) + evaluate ($i1start = $c3sym_sta1_$ncount) + evaluate ($i1end = $c3sym_end1_$ncount) + evaluate ($chain1 = $c3sym_seg1_$ncount) + evaluate ($i2start = $c3sym_sta2_$ncount) + evaluate ($i2end = $c3sym_end2_$ncount) + evaluate ($chain2 = $c3sym_seg2_$ncount) + evaluate ($i3start = $c3sym_sta3_$ncount) + evaluate ($i3end = $c3sym_end3_$ncount) + evaluate ($chain3 = $c3sym_seg3_$ncount) + + !first check that the chain lengths are equal for the two defined molecules + evaluate ($diff1 = $i1end - $i1start) + evaluate ($diff2 = $i2end - $i2start) + evaluate ($diff3 = $i3end - $i3start) + if ($diff1 ne $diff2) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff1 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff2 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + + eval ($icount = 0) + while ($i1start < $i1end) loop genc3sym + + evaluate ($resst1 = $i1start) + evaluate ($resst2 = $i2start) + evaluate ($resst3 = $i3start) + evaluate ($resen1 = $i1end - $icount) + evaluate ($resen2 = $i2end - $icount) + evaluate ($resen3 = $i3end - $icount) + + noe + + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resen2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resen3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resen3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resen1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resen1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resen2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + + end + + evaluate ($icount = $icount + 2) + evaluate ($i1start = $i1start + 2) + evaluate ($i2start = $i2start + 2) + evaluate ($i3start = $i3start + 2) + + end loop genc3sym + + end loop c3symloop + + ! Define S3 symmetry restraints for symmetrical multimers + ! + eval ($ncount = 0) + while ($ncount < $data.ns3sym) loop s3symloop + + eval ($ncount = $ncount + 1) + evaluate ($i1start = $s3sym_sta1_$ncount) + evaluate ($i1end = $s3sym_end1_$ncount) + evaluate ($chain1 = $s3sym_seg1_$ncount) + evaluate ($i2start = $s3sym_sta2_$ncount) + evaluate ($i2end = $s3sym_end2_$ncount) + evaluate ($chain2 = $s3sym_seg2_$ncount) + evaluate ($i3start = $s3sym_sta3_$ncount) + evaluate ($i3end = $s3sym_end3_$ncount) + evaluate ($chain3 = $s3sym_seg3_$ncount) + + !first check that the chain lengths are equal for the two defined molecules + evaluate ($diff1 = $i1end - $i1start) + evaluate ($diff2 = $i2end - $i2start) + evaluate ($diff3 = $i3end - $i3start) + if ($diff1 ne $diff2) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff1 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff2 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + + eval ($icount = 0) + eval ($istep = 4) + eval ($istop = $i1end - $istep) + while ($i1start < $istop) loop gens3sym + + evaluate ($resst11 = $i1start) + evaluate ($resst21 = $i1start+1) + evaluate ($resst12 = $i2start) + evaluate ($resst22 = $i2start+1) + evaluate ($resst13 = $i3start) + evaluate ($resst23 = $i3start+1) + + + noe + + assign (resid $resst11 and (name CA or name P or name BB) and segid $chain1) + (resid $resst12 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resst12 and (name CA or name P or name BB) and segid $chain2) + (resid $resst13 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + + assign (resid $resst21 and (name CA or name P or name BB) and segid $chain1) + (resid $resst22 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resst22 and (name CA or name P or name BB) and segid $chain2) + (resid $resst23 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + + end + + evaluate ($icount = $icount + $istep) + evaluate ($i1start = $i1start + $istep) + evaluate ($i2start = $i2start + $istep) + evaluate ($i3start = $i3start + $istep) + + end loop gens3sym + + end loop s3symloop + + ! Define C4 symmetry restraints for symmetrical multimers + ! + eval ($istep = 10) + eval ($ncount = 0) + while ($ncount < $data.nc4sym) loop c4symloop + + eval ($ncount = $ncount + 1) + evaluate ($i1start = $c4sym_sta1_$ncount) + evaluate ($i1end = $c4sym_end1_$ncount) + evaluate ($chain1 = $c4sym_seg1_$ncount) + evaluate ($i2start = $c4sym_sta2_$ncount) + evaluate ($i2end = $c4sym_end2_$ncount) + evaluate ($chain2 = $c4sym_seg2_$ncount) + evaluate ($i3start = $c4sym_sta3_$ncount) + evaluate ($i3end = $c4sym_end3_$ncount) + evaluate ($chain3 = $c4sym_seg3_$ncount) + evaluate ($i4start = $c4sym_sta4_$ncount) + evaluate ($i4end = $c4sym_end4_$ncount) + evaluate ($chain4 = $c4sym_seg4_$ncount) + + !first check that the chain lengths are equal for the four defined molecules + evaluate ($diff1 = $i1end - $i1start) + evaluate ($diff2 = $i2end - $i2start) + evaluate ($diff3 = $i3end - $i3start) + evaluate ($diff4 = $i4end - $i4start) + if ($diff1 ne $diff2) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff1 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff1 ne $diff4) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff2 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff2 ne $diff4) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff3 ne $diff4) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + + eval ($icount = 0) + while ($i1start < $i1end) loop genc4sym + + evaluate ($resst1 = $i1start) + evaluate ($resst2 = $i2start) + evaluate ($resst3 = $i3start) + evaluate ($resst4 = $i4start) + evaluate ($resen1 = $i1end - $icount) + evaluate ($resen2 = $i2end - $icount) + evaluate ($resen3 = $i3end - $icount) + evaluate ($resen4 = $i4end - $icount) + + noe + + ! N to N sequential restraints to prevent anti-parallel arrangements + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resst2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resst3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resst3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resst4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resst4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resst1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resst1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resst2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + + ! N to C sequential restraints to assure planarity + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resen2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resen3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resen3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resen4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resen4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resen1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resen1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resen2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + + assign (resid $resen1 and (name CA or name P or name BB) and segid $chain1) + (resid $resst2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resen2 and (name CA or name P or name BB) and segid $chain2) + (resid $resst3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + + assign (resid $resen2 and (name CA or name P or name BB) and segid $chain2) + (resid $resst3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + assign (resid $resen3 and (name CA or name P or name BB) and segid $chain3) + (resid $resst4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + + assign (resid $resen3 and (name CA or name P or name BB) and segid $chain3) + (resid $resst4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + assign (resid $resen4 and (name CA or name P or name BB) and segid $chain4) + (resid $resst1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + + assign (resid $resen4 and (name CA or name P or name BB) and segid $chain4) + (resid $resst1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + assign (resid $resen1 and (name CA or name P or name BB) and segid $chain1) + (resid $resst2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + + end + + evaluate ($icount = $icount + $istep) + evaluate ($i1start = $i1start + $istep) + evaluate ($i2start = $i2start + $istep) + evaluate ($i3start = $i3start + $istep) + evaluate ($i4start = $i4start + $istep) + + end loop genc4sym + + end loop c4symloop + + + ! Define C5 symmetry restraints for symmetrical multimers + ! + eval ($istep = 4) + eval ($ncount = 0) + while ($ncount < $data.nc5sym) loop c5symloop + + eval ($ncount = $ncount + 1) + evaluate ($i1start = $c5sym_sta1_$ncount) + evaluate ($i1end = $c5sym_end1_$ncount) + evaluate ($chain1 = $c5sym_seg1_$ncount) + evaluate ($i2start = $c5sym_sta2_$ncount) + evaluate ($i2end = $c5sym_end2_$ncount) + evaluate ($chain2 = $c5sym_seg2_$ncount) + evaluate ($i3start = $c5sym_sta3_$ncount) + evaluate ($i3end = $c5sym_end3_$ncount) + evaluate ($chain3 = $c5sym_seg3_$ncount) + evaluate ($i4start = $c5sym_sta4_$ncount) + evaluate ($i4end = $c5sym_end4_$ncount) + evaluate ($chain4 = $c5sym_seg4_$ncount) + evaluate ($i5start = $c5sym_sta5_$ncount) + evaluate ($i5end = $c5sym_end5_$ncount) + evaluate ($chain5 = $c5sym_seg5_$ncount) + + !first check that the chain lengths are equal for the two defined molecules + evaluate ($diff1 = $i1end - $i1start) + evaluate ($diff2 = $i2end - $i2start) + evaluate ($diff3 = $i3end - $i3start) + evaluate ($diff4 = $i4end - $i4start) + evaluate ($diff5 = $i5end - $i5start) + if ($diff1 ne $diff2) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff1 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff2 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff3 ne $diff4) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff4 ne $diff5) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + + eval ($icount = 0) + while ($i1start < $i1end) loop genc5sym + + evaluate ($resst1 = $i1start) + evaluate ($resst2 = $i2start) + evaluate ($resst3 = $i3start) + evaluate ($resst4 = $i4start) + evaluate ($resst5 = $i5start) + evaluate ($resen1 = $i1end - $icount) + evaluate ($resen2 = $i2end - $icount) + evaluate ($resen3 = $i3end - $icount) + evaluate ($resen4 = $i4end - $icount) + evaluate ($resen5 = $i5end - $icount) + + noe + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resst3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resst4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resst4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resst5 and (name CA or name P or name BB) and segid $chain5) 0 0 0 + + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resst5 and (name CA or name P or name BB) and segid $chain5) 0 0 0 + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resst1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resst1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resst2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + + assign (resid $resst5 and (name CA or name P or name BB) and segid $chain5) + (resid $resst2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resst5 and (name CA or name P or name BB) and segid $chain5) + (resid $resst3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + + end + + evaluate ($icount = $icount + $istep) + evaluate ($i1start = $i1start + $istep) + evaluate ($i2start = $i2start + $istep) + evaluate ($i3start = $i3start + $istep) + evaluate ($i4start = $i4start + $istep) + evaluate ($i5start = $i5start + $istep) + + end loop genc5sym + + end loop c5symloop + + ! Define C6 symmetry restraints for symmetrical multimers + ! + eval ($istep = 10) + eval ($ncount = 0) + while ($ncount < $data.nc6sym) loop c6symloop + + eval ($ncount = $ncount + 1) + evaluate ($i1start = $c6sym_sta1_$ncount) + evaluate ($i1end = $c6sym_end1_$ncount) + evaluate ($chain1 = $c6sym_seg1_$ncount) + evaluate ($i2start = $c6sym_sta2_$ncount) + evaluate ($i2end = $c6sym_end2_$ncount) + evaluate ($chain2 = $c6sym_seg2_$ncount) + evaluate ($i3start = $c6sym_sta3_$ncount) + evaluate ($i3end = $c6sym_end3_$ncount) + evaluate ($chain3 = $c6sym_seg3_$ncount) + evaluate ($i4start = $c6sym_sta4_$ncount) + evaluate ($i4end = $c6sym_end4_$ncount) + evaluate ($chain4 = $c6sym_seg4_$ncount) + evaluate ($i5start = $c6sym_sta5_$ncount) + evaluate ($i5end = $c6sym_end5_$ncount) + evaluate ($chain5 = $c6sym_seg5_$ncount) + evaluate ($i6start = $c6sym_sta6_$ncount) + evaluate ($i6end = $c6sym_end6_$ncount) + evaluate ($chain6 = $c6sym_seg6_$ncount) + + !first check that the chain lengths are equal for the two defined molecules + evaluate ($diff1 = $i1end - $i1start) + evaluate ($diff2 = $i2end - $i2start) + evaluate ($diff3 = $i3end - $i3start) + evaluate ($diff4 = $i4end - $i4start) + evaluate ($diff5 = $i5end - $i5start) + evaluate ($diff6 = $i6end - $i6start) + if ($diff1 ne $diff2) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff1 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff2 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff3 ne $diff4) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff4 ne $diff5) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff5 ne $diff6) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + + eval ($icount = 0) + while ($i1start < $i1end) loop genc6sym + + evaluate ($resst1 = $i1start) + evaluate ($resst2 = $i2start) + evaluate ($resst3 = $i3start) + evaluate ($resst4 = $i4start) + evaluate ($resst5 = $i5start) + evaluate ($resst6 = $i6start) + evaluate ($resen1 = $i1end - $icount) + evaluate ($resen2 = $i2end - $icount) + evaluate ($resen3 = $i3end - $icount) + evaluate ($resen4 = $i4end - $icount) + evaluate ($resen5 = $i5end - $icount) + evaluate ($resen6 = $i6end - $icount) + + noe + + ! Around the C6 ring + ! N to N sequential restraints to prevent anti-parallel arrangements + + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resst2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resst3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resst3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resst4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resst4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resst5 and (name CA or name P or name BB) and segid $chain5) 0 0 0 + + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resst5 and (name CA or name P or name BB) and segid $chain5) 0 0 0 + assign (resid $resst5 and (name CA or name P or name BB) and segid $chain5) + (resid $resst6 and (name CA or name P or name BB) and segid $chain6) 0 0 0 + + assign (resid $resst5 and (name CA or name P or name BB) and segid $chain5) + (resid $resst6 and (name CA or name P or name BB) and segid $chain6) 0 0 0 + assign (resid $resst6 and (name CA or name P or name BB) and segid $chain6) + (resid $resst1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + + assign (resid $resst6 and (name CA or name P or name BB) and segid $chain6) + (resid $resst1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resst2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + + ! N to C sequential restraints to assure planarity + + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resen2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resen3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resen3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resen4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resen4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resen5 and (name CA or name P or name BB) and segid $chain5) 0 0 0 + + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resen5 and (name CA or name P or name BB) and segid $chain5) 0 0 0 + assign (resid $resst5 and (name CA or name P or name BB) and segid $chain5) + (resid $resen6 and (name CA or name P or name BB) and segid $chain6) 0 0 0 + + assign (resid $resst5 and (name CA or name P or name BB) and segid $chain5) + (resid $resen6 and (name CA or name P or name BB) and segid $chain6) 0 0 0 + assign (resid $resst6 and (name CA or name P or name BB) and segid $chain6) + (resid $resen1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + + ! Triples + + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resen3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resen5 and (name CA or name P or name BB) and segid $chain5) 0 0 0 + + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resen5 and (name CA or name P or name BB) and segid $chain5) 0 0 0 + assign (resid $resst5 and (name CA or name P or name BB) and segid $chain5) + (resid $resen1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resen4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resen6 and (name CA or name P or name BB) and segid $chain6) 0 0 0 + + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resen6 and (name CA or name P or name BB) and segid $chain6) 0 0 0 + assign (resid $resst6 and (name CA or name P or name BB) and segid $chain6) + (resid $resen2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + + end + + evaluate ($icount = $icount + $istep) + evaluate ($i1start = $i1start + $istep) + evaluate ($i2start = $i2start + $istep) + evaluate ($i3start = $i3start + $istep) + evaluate ($i4start = $i4start + $istep) + evaluate ($i5start = $i5start + $istep) + evaluate ($i6start = $i6start + $istep) + + end loop genc6sym + + end loop c6symloop + + + noe + potential symm symmetry + scale symm $Data.ksym + sqconstant symm 1.0 + sqexponent symm 2 + soexponent symm 1 + rswitch symm 0.5 + sqoffset symm 0.0 + asymptote symm 1.0 + end + +end if diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/torsiontop.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/torsiontop.cns new file mode 100644 index 0000000000000000000000000000000000000000..020935d984922bfa9297a80ed3df38b7732548c5 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/cns/torsiontop.cns @@ -0,0 +1,108 @@ +! torsiontop.cns +! Create the topology for torsion angle MD first stage +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * Originally adapted from Aria 1.2 from Nilges and Linge, EMBL. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +evaluate ($numtrees=$data.ncomponents) +inline @MODULE:numtrees.cns + +DISPLAY NUMTREES set to $numtrees + +dyna tors + topology + maxtree $numtrees + kdihmax = 23. + + evaluate ($N_atom_id = 0) + evaluate ($atom_id = 0) + + for $atom_id in id ( name CA ) loop main + if ( $N_atom_id > 0 ) then + fix group ( ( byresidue ( id $N_atom_id ) and (name C or name O) ) + or ( byresidue ( id $atom_id ) and (name N or name HN ) ) + ) + end if + evaluate ($N_atom_id = $atom_id) + end loop main + + if ( $atom_id > 0 ) then + fix group ( byresidue ( id $atom_id ) and (name C or name OT1 or name OT2 or name OXT) ) + end if + + for $atom_id in id ( name BB and not (resn PHE or resn TYR or resn TRP or resn HIS or resn ARG or resn LYS)) loop main + if ( $atom_id > 0 ) then + fix group ( byresidue ( id $atom_id )) + end if + end loop main + + for $atom_id in id ( (name CA or name BB) and + (resn PHE or resn TRP or resn HIS or resn ASP or resn ASN or resn NEP)) + loop main + fix group ( byresidue ( id $atom_id ) and (name CG or name %D* or name %Z* or name %E* or name %H* or name SC# )) + end loop main + + for $atom_id in id ( (name CA or name BB) and (resn TYR)) loop main + fix group + ( byresidue ( id $atom_id ) + and (name CG or name %D* or name %Z* or name %E* or name OH or name SC# )) + end loop main + + for $atom_id in id ( (name CA or name BB) and (resn gln or resn glu)) loop main + fix group ( byresidue ( id $atom_id ) and (name %D* or name %E*)) + end loop main + + for $atom_id in id ( (name CA or name BB) and (resn ARG)) loop main + fix group ( byresidue ( id $atom_id ) and ( name %E* or name %Z* or name %H* or name SC# )) + + end loop main + fix group ( resn PRO and not (name C or name O) ) + + !next loop is for all sugars defined in glycans-uu.top + for $atom_id in id + ( name c1 and + (resn GCP or resn GCF or resn GTP or resn GTF or resn MNP + or resn MNF or resn ALP or resn ALF or resn ARP or resn ARF or resn GLP + or resn GLF or resn IDP or resn IDF or resn TLP or resn TLF or resn PCP + or resn PCF or resn FTP or resn FTF or resn SBP or resn SBF or resn TTP + or resn TTF or resn NAA or resn RBP or resn RBF or resn ANF or resn XLF + or resn LXF or resn RLF or resn LLF) + ) loop main + fix group ( byresidue ( id $atom_id ) + and (name %1 or name %2 or name %3 or name %4 or name %5 or name O5)) + end loop main + + for $id in id (name C1') loop freeribose + free bond (id $id) (byresid (id $id) and name C2') + end loop freeribose + + fix group ( resn HEC and (name C1* or name C2* or name C3* or name C4* or name N* or name CH*)) + + fix group ( resn CYM and not (name CA or name BB or name C or name O or name OXT or + name N or name HN or name HA or name CB or name HB1 or name HB2 or + name SG or name SAL or name CAJ)) + + fix group ( byresidue (resn WAT)) + fix group ( byresidue (resn HOH)) + fix group ( byresidue (resn TIP*)) + fix group ( byresidue (resn ANI)) + fix group ( byresidue (resn DAN)) + fix group ( byresidue (resn XAN)) + fix group (resn SHA) + + eval($nchain1 = 0) + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + fix group (segid $prot_segid_$nchain1 + and not (attribute store5 > 0) + and not ((resn WAT or resn HOH or resn TIP*))) + end loop nloop1 + end +end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/defaults.yaml b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/defaults.yaml new file mode 100644 index 0000000000000000000000000000000000000000..1f716e5cd6efee5c54c7e69b2f9873752f80f6d2 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/flexref/defaults.yaml @@ -0,0 +1,5195 @@ +# +# Group molecule +# +mol_fix_origin_1: + default: false + type: boolean + title: Fix molecule + short: Fixes the molecule in its original position. + long: Fixes the molecule in its original position. + group: 'molecule' + explevel: expert +mol_shape_1: + default: false + type: boolean + title: Is the molecule a shape? + short: Defines a molecule as a shape. + long: Defines a molecule as a shape, which is a collection of beads. + group: 'molecule' + explevel: easy +# +# Group distance restraints +# +ambig_fname: + default: '' + type: file + title: Ambiguous distance restraints filename + short: Filename of the ambiguous distance restraints file + long: Filename of the ambiguous distance restraints file. By default 50% of those restraints will be randomly discared. + This can be changed/turned off and is controlled by the randremoval and npart parameters. + Note that this file can contain both ambiguous and unambiguous restraints. + group: 'distance restraints' + explevel: easy +previous_ambig: + default: false + type: boolean + title: Boolean condition on the previous ambiguous distance restraints file + short: Boolean condition on the previous ambiguous distance restraints file. + If true, use the the restraint information coming from the previous CNS module. If false, don't use previous information. + long: Boolean condition on the ambiguous distance restraints file. + If true, use the restraint information coming from the previous CNS module, as long as an ambig_fname is not defined for the current module. + If false, don't use previous information. + group: 'distance restraints' + explevel: expert +unambig_fname: + default: '' + type: file + title: Unambiguous restraints filename + short: Filename of the unambiguous distance restraints file + long: Filename of the unambiguous distance restraints file. All restraints in that file will be used. + Note that this file can contain both ambiguous and unambiguous restraints. + group: 'distance restraints' + explevel: easy +hbond_fname: + default: '' + type: file + title: H-bond restraints filename + short: Filename of the hydrogen bond distance restraints file + long: Filename of the hydrogen bond distance restraints file. Note that this file can contain any type of distance restraints. + group: 'distance restraints' + explevel: easy +ambig_hot: + default: 10 + type: integer + min: 0 + max: 1000 + title: Hot phase SA force constant for ambiguous distance restraints + short: Force constant applied to the distance restraints defined in ambig_fname during the hot phase of the SA. + long: Force constant applied to the distance restraints defined in ambig_fname during the initial hot phase of the simulatd annealing protocol. Molecules are treated as rigid bodies unless fully flexible segments are defined (see nfle parameter). + group: 'distance restraints' + explevel: expert +ambig_cool1: + default: 10 + type: integer + min: 0 + max: 1000 + title: First cooling SA force constant for ambiguous distance restraints + short: Force constant applied to the distance restraints defined in ambig_fname during the first cooling phase of the SA. + long: Force constant applied to the distance restraints defined in ambig_fname during the first cooling phase of the simulatd annealing protocol. Molecules are treated as rigid bodies unless fully flexible segments are defined (see nfle parameter). + group: 'distance restraints' + explevel: expert +ambig_cool2: + default: 50 + type: integer + min: 0 + max: 1000 + title: Second cooling SA force constant for ambiguous distance restraints + short: Force constant applied to the distance restraints defined in ambig_fname during the second cooling phase of the SA. + long: Force constant applied to the distance restraints defined in ambig_fname during the second cooling phase of the simulatd annealing protocol. Side-chains at the interface are treated as flexible and any region defined in fully flexible segments as fully flexible (see nfle parameter). + group: 'distance restraints' + explevel: expert +ambig_cool3: + default: 50 + type: integer + min: 0 + max: 1000 + title: Third cooling SA force constant for ambiguous distance restraints + short: Force constant applied to the distance restraints defined in ambig_fname during the third cooling phase of the SA. + long: Force constant applied to the distance restraints defined in ambig_fname during the third cooling phase of the simulatd annealing protocol. Side-chains and backbone at the interface are treated as flexible and any region defined in fully flexible segments as fully flexible (see nfle parameter). + group: 'distance restraints' + explevel: expert +unambig_hot: + default: 10 + type: integer + min: 0 + max: 1000 + title: Hot phase SA force constant for unambiguous distance restraints + short: Force constant applied to the distance restraints defined in unambig_fname during the hot phase of the SA. + long: Force constant applied to the distance restraints defined in unambig_fname during the initial hot phase of the simulatd annealing protocol. Molecules are treated as rigid bodies unless fully flexible segments are defined (see nfle parameter). + group: 'distance restraints' + explevel: expert +unambig_cool1: + default: 10 + type: integer + min: 0 + max: 1000 + title: Hot phase SA force constant for unambiguous distance restraints + short: Force constant applied to the distance restraints defined in unambig_fname during the hot phase of the SA. + long: Force constant applied to the distance restraints defined in unambig_fname during the initial hot phase of the simulatd annealing protocol. Molecules are treated as rigid bodies unless fully flexible segments are defined (see nfle parameter). + group: 'distance restraints' + explevel: expert +unambig_cool2: + default: 50 + type: integer + min: 0 + max: 1000 + title: Hot phase SA force constant for unambiguous distance restraints + short: Force constant applied to the distance restraints defined in ambig_fname during the hot phase of the SA. + long: Force constant applied to the distance restraints defined in unambig_fname during the initial hot phase of the simulatd annealing protocol. Molecules are treated as rigid bodies unless fully flexible segments are defined (see nfle parameter). + group: 'distance restraints' + explevel: expert +unambig_cool3: + default: 50 + type: integer + min: 0 + max: 1000 + title: Hot phase SA force constant for unambiguous distance restraints + short: Force constant applied to the distance restraints defined in unambig_fname during the hot phase of the SA. + long: Force constant applied to the distance restraints defined in unambig_fname during the initial hot phase of the simulatd annealing protocol. Molecules are treated as rigid bodies unless fully flexible segments are defined (see nfle parameter). + group: 'distance restraints' + explevel: expert +hbond_hot: + default: 10 + type: integer + min: 0 + max: 1000 + title: Hot phase SA force constant for hbond distance restraints + short: Force constant applied to the hydrogen bond restraints defined in hbond_fname during the hot phase of the SA. + long: Force constant applied to the hydrogen bond restraints defined in hbond_fname during the initial hot phase of the simulatd annealing protocol. Molecules are treated as rigid bodies unless fully flexible segments are defined (see nfle parameter). + group: 'distance restraints' + explevel: expert +hbond_cool1: + default: 10 + type: integer + min: 0 + max: 1000 + title: Hot phase SA force constant for hydrogen bond restraints + short: Force constant applied to the hydrogen bond restraints defined in hbond_fname during the hot phase of the SA. + long: Force constant applied to the hydrogen bond restraints defined in hbond_fname during the initial hot phase of the simulatd annealing protocol. Molecules are treated as rigid bodies unless fully flexible segments are defined (see nfle parameter). + group: 'distance restraints' + explevel: expert +hbond_cool2: + default: 50 + type: integer + min: 0 + max: 1000 + title: Hot phase SA force constant for hydrogen bond restraints + short: Force constant applied to the hydrogen bond restraints defined in hbond_fname during the hot phase of the SA. + long: Force constant applied to the hydrogen bond restraints defined in hbond_fname during the initial hot phase of the simulatd annealing protocol. Molecules are treated as rigid bodies unless fully flexible segments are defined (see nfle parameter). + group: 'distance restraints' + explevel: expert +hbond_cool3: + default: 50 + type: integer + min: 0 + max: 1000 + title: Hot phase SA force constant for hydrogen bond restraints + short: Force constant applied to the hydrogen bond restraints defined in hbond_fname during the hot phase of the SA. + long: Force constant applied to the hydrogen bond restraints defined in hbond_fname during the initial hot phase of the simulatd annealing protocol. Molecules are treated as rigid bodies unless fully flexible segments are defined (see nfle parameter). + group: 'distance restraints' + explevel: expert +randremoval: + default: true + type: boolean + title: Random removal of ambiguous restraints + short: If set to true (default) this will cause the random removal of ambiguous restraints for each model generated. + long: If set to true (default) this will cause the random removal of ambiguous restraints for each model generated. + The fraction of restraints randomly removed depends on the npart parameter which defines in how many sets the restraints should be randomly split. + The first set will be removed. The fraction of randomly removed ambiguous restraints is thus 1/npart. + group: 'distance restraints' + explevel: expert +npart: + default: 2 + type: integer + min: 1 + max: 20 + title: Number partitions for ambiguous restraints + short: Number of sets into which to randomly partition the ambiguous restraints. + long: Number of sets into which to randomly partition the ambiguous restraints. + The fraction of restraints randomly removed depends on the npart parameter which defines in how many sets the restraints should be randomly split. + The first set will be removed. The fraction of randomly removed ambiguous restraints is thus 1/npart. + group: 'distance restraints' + explevel: expert +contactairs: + default: false + type: boolean + title: Contact restraints + short: Contact restraints between molecules + long: Contact restraints between molecules. These are defined as ambiguous distance restraint + between each residue of a molecule and all residues of the other molecules with 5A from that residue. + This can be used to restraint the contacts between the interfaces. Note that this can generate a large number of ambiguous restraints + and slow down the computations + group: 'distance restraints' + explevel: expert +kcont: + default: 1.0 + type: float + min: 0 + max: 1000 + precision: 1 + title: Contact restraints force constant + short: Force constant applied to the contact restraints. + long: Force constant applied to the contact restraints. + group: 'distance restraints' + explevel: expert +cmrest: + default: false + type: boolean + title: Center of mass restraints + short: Automatically defines distance restraints between the geometric center of the various molecules. + long: When turned on, this option will automatically define center of mass restraints between the various molecules. + This allows HADDOCK to operate in ab-initio mode in the absence of any other restraints. But those restraints can also + be combined with other restraints to ensure more compact solutions. The distance restraints are defined between the + geometrical centers of the various molecules (calculated on CA atoms for proteins (BB in case of Martini coarse-grained + molecules) and N1 atoms for nucleic acids. For small ligands, all atoms will be used to define the geometric center. + The upper limit distance is automatically calculated based on the dimension of the molecules (see cmtight description). + group: 'distance restraints' + explevel: expert +cmtight: + default: true + type: boolean + title: Center of mass restraint tightness + short: Defines the upper distance limit based on the sum of the average dimension of the two molecule, + if cmtight=false all three dimensions are used, if set to true the shortest two only are used, + resulting in tighter distance restraints. + long: This parameter controls how the upper limit distance is defined for the center of mass restraints between molecules. + Each molecule is oriented along its principle components and the x,y and z dimensions are calculated. + If cmtight=true, the molecule distance (size) is set to the average of its smallest two half dimensions. + If cmtight=false, the molecule distance (size) is set to the average of its three half dimensions.. + In case of DNA or small ligands the molecule distance (size) is set to 0. + The effective upper distance limit for the center or mass distance restraint is the sum of the two molecule distances. + group: 'distance restraints' + explevel: expert +kcm: + default: 1.0 + type: float + min: 0 + max: 1000 + precision: 1 + title: Center of mass restraints force constant + short: Force constant applied to the center of mass restraints + long: Force constant applied to the center of mass restraints + group: 'distance restraints' + explevel: expert +# +# Group dihedral restraints +# +dihe_fname: + default: '' + type: file + title: Dihedral angle restraints filename + short: Filename of the Dihedral angle restraints file + long: Filename of the Dihedral angle restraints file. + group: 'dihedral restraints' + explevel: easy +dihedrals_on: + default: false + type: boolean + title: Use dihedral angle restraints + short: Turns on dihedral angle restraints. + long: Turns on dihedral angle restraints. Those should be defined in the dihe_fname file. + group: 'dihedral restraints' + explevel: easy +dihedrals_hot: + default: 5 + type: integer + min: 0 + max: 1000 + title: Hot phase SA force constant for dihedral angle restraints + short: Hot phase SA force constant for dihedral angle restraints read from dihe_fname. + long: Force constant applied to the dihedral angle restraints read from dihe_fname during the initial hot phase of the simulatd annealing protocol. + group: 'dihedral restraints' + explevel: expert +dihedrals_cool1: + default: 5 + type: integer + min: 0 + max: 1000 + title: First cooling SA force constant for dihedral angle restraints + short: First cooling SA force constant for dihedral angle restraints read from dihe_fname. + long: Force constant applied to the dihedral angle restraints read from dihe_fname during the first cooling phase of the simulatd annealing protocol. + group: 'dihedral restraints' + explevel: expert +dihedrals_cool2: + default: 50 + type: integer + min: 0 + max: 1000 + title: Second cooling SA force constant for dihedral angle restraints + short: Second cooling SA force constant for dihedral angle restraints read from dihe_fname. + long: Force constant applied to the dihedral angle restraints read from dihe_fname during the second cooling phase of the simulatd annealing protocol. + group: 'dihedral restraints' + explevel: expert +dihedrals_cool3: + default: 200 + type: integer + min: 0 + max: 1000 + title: Third cooling SA force constant for dihedral angle restraints + short: Third cooling SA force constant for dihedral angle restraints read from dihe_fname. + long: Force constant applied to the dihedral angle restraints read from dihe_fname during the third cooling phase of the simulatd annealing protocol. + group: 'dihedral restraints' + explevel: expert +ssdihed: + default: none + type: string + minchars: 0 + maxchars: 100 + choices: + - none + - all + - alpha + - alphabeta + title: Define automatically backbone dihedral angle restraints + short: If turned on, this option will automatically defined backbone dihedral angle restraints for the selected regions. + long: This option allows to utomatically defined backbone dihedral angle restraints for the selected regions. + The restraints will be defined for the phi and psi backbone dihedral angles of amino acids, with the target value taken from + the measured angle in the input structure, and the error bound defined by the error_dih parameter. + Those restraints can be applied to the entire structure (all), the alpha/beta secondary structure elements (alphabeta) or + only to the alpha helical regions (alpha). Those are automatically detected based on the measured dihedral angle combinations. + group: 'dihedral restraints' + explevel: easy +error_dih: + default: 10 + type: integer + min: 0 + max: 180 + title: Force constant for backbone dihedral angle restraints + short: Force constant for backbone dihedral angle restraints (ssdihed option) + long: Force constant for backbone dihedral angle restraints (ssdihed option) + group: 'dihedral restraints' + explevel: easy +# +# Group other restraints +# +dnarest_on: + default: false + type: boolean + title: Restrain the DNA conformation + short: Automatically creates restraints to maintain the conformation of DNA/RNA + long: "This option allows to restraint the conformation of nucleic acids based on the values from the input structures. + The following restraints will be automatically defined: + - single base planarity + - sugar pucker + - phosphate backbone diherdral angle restraints + - Watson-Crick base pairing" + group: 'other restraints' + explevel: easy + + +mrswi_hot: + default: 0.5 + type: float + min: 0 + max: 9999 + precision: 3 + title: No title yet + short: No short description yet + long: No long description yet + group: 'hidden' + explevel: hidden +mrswi_cool1: + default: 0.5 + type: float + min: 0 + max: 9999 + precision: 3 + title: No title yet + short: No short description yet + long: No long description yet + group: 'hidden' + explevel: hidden +mrswi_cool2: + default: 0.5 + type: float + min: 0 + max: 9999 + precision: 3 + title: No title yet + short: No short description yet + long: No long description yet + group: 'hidden' + explevel: hidden +mrswi_cool3: + default: 0.5 + type: float + min: 0 + max: 9999 + precision: 3 + title: No title yet + short: No short description yet + long: No long description yet + group: 'hidden' + explevel: hidden +rswi_hot: + default: 0.5 + type: float + min: 0 + max: 9999 + precision: 3 + title: No title yet + short: No short description yet + long: No long description yet + group: 'hidden' + explevel: hidden +rswi_cool1: + default: 0.5 + type: float + min: 0 + max: 9999 + precision: 3 + title: No title yet + short: No short description yet + long: No long description yet + group: 'hidden' + explevel: hidden +rswi_cool2: + default: 0.5 + type: float + min: 0 + max: 9999 + precision: 3 + title: No title yet + short: No short description yet + long: No long description yet + group: 'hidden' + explevel: hidden +rswi_cool3: + default: 0.5 + type: float + min: 0 + max: 9999 + precision: 3 + title: No title yet + short: No short description yet + long: No long description yet + group: 'hidden' + explevel: hidden +masy_hot: + default: -1.0 + type: float + min: -9999 + max: 9999 + precision: 3 + title: No title yet + short: No short description yet + long: No long description yet + group: 'hidden' + explevel: hidden +masy_cool1: + default: -1.0 + type: float + min: -9999 + max: 9999 + precision: 3 + title: No title yet + short: No short description yet + long: No long description yet + group: 'hidden' + explevel: hidden +masy_cool2: + default: -0.1 + type: float + min: -9999 + max: 9999 + precision: 3 + title: No title yet + short: No short description yet + long: No long description yet + group: 'hidden' + explevel: hidden +masy_cool3: + default: -0.1 + type: float + min: -9999 + max: 9999 + precision: 3 + title: No title yet + short: No short description yet + long: No long description yet + group: 'hidden' + explevel: hidden +asy_hot: + default: 1.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: No title yet + short: No short description yet + long: No long description yet + group: 'hidden' + explevel: hidden +asy_cool1: + default: 1.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: No title yet + short: No short description yet + long: No long description yet + group: 'hidden' + explevel: hidden +asy_cool2: + default: 0.1 + type: float + min: 0 + max: 9999 + precision: 3 + title: No title yet + short: No short description yet + long: No long description yet + group: 'hidden' + explevel: hidden +asy_cool3: + default: 0.1 + type: float + min: 0 + max: 9999 + precision: 3 + title: No title yet + short: No short description yet + long: No long description yet + group: 'hidden' + explevel: hidden +# +# Group symmetry +# +sym_on: + default: false + type: boolean + title: Symmetry restraints + short: Enables symmetry restraints + long: Enables symmetry restraints. The symmetry type (C2,C3,C4,C5,C6,S3 supported) + and the segments to which those apply must be defined. In addition a custom symmetry restraint file can be supplied (symrest_fname). + group: 'symmetry' + explevel: expert +ksym: + default: 10.0 + type: float + min: 0 + max: 1000 + precision: 1 + title: Force constant for symmetry restraints + short: Force constant for symmetry restraints + long: Force constant for symmetry restraints + group: 'symmetry' + explevel: expert +symtbl_fname: + default: '' + type: file + title: Custom symmetry restraints filename + short: Filename of the custom symmetry restraints file + long: Filename of the custom symmetry restraints file. + group: 'symmetry' + explevel: expert +nc2sym: + default: 0 + type: integer + min: 0 + max: 40 + title: Number of C2 symmetry restraints + short: Defines the number of C2 symmetry restraints. + long: Defines the number of C2 symmetry restraints. + For each, a pair of segments on which the symmetry restraint is applied will have to be defined. + Those must all have the same length. + group: 'symmetry' + explevel: hidden +c2sym_sta1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the first C2 symmetry segment + long: Residue number of first residue in the first C2 symmetry segment + group: 'symmetry' + explevel: expert +c2sym_end1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the first C2 symmetry segment + long: Residue number of last residue in the first C2 symmetry segment + group: 'symmetry' + explevel: expert +c2sym_seg1_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of first C2 segment + short: Segment ID of first C2 segment + long: Segment ID of first C2 segment + group: 'symmetry' + explevel: expert +c2sym_sta2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the second C2 symmetry segment + long: Residue number of first residue in the second C2 symmetry segment + group: 'symmetry' + explevel: expert +c2sym_end2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the second C2 symmetry segment + long: Residue number of last residue in the second C2 symmetry segment + group: 'symmetry' + explevel: expert +c2sym_seg2_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of second C2 segment + short: Segment ID of second C2 segment + long: Segment ID of second C2 segment + group: 'symmetry' + explevel: expert +nc3sym: + default: 0 + type: integer + min: 0 + max: 10 + title: Number of C3 symmetry restraints + short: Defines the number of C3 symmetry restraints. + long: Defines the number of C3 symmetry restraints. + For each, three segments on which the symmetry restraint is applied will have to be defined. + Those must all have the same length. + group: 'symmetry' + explevel: hidden +c3sym_sta1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the first C3 symmetry segment + long: Residue number of first residue in the first C3 symmetry segment + group: 'symmetry' + explevel: expert +c3sym_end1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the first C3 symmetry segment + long: Residue number of last residue in the first C3 symmetry segment + group: 'symmetry' + explevel: expert +c3sym_seg1_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of first C3 segment + short: Segment ID of first C3 segment + long: Segment ID of first C3 segment + group: 'symmetry' + explevel: expert +c3sym_sta2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the second C3 symmetry segment + long: Residue number of first residue in the second C3 symmetry segment + group: 'symmetry' + explevel: expert +c3sym_end2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the second C3 symmetry segment + long: Residue number of last residue in the second C3 symmetry segment + group: 'symmetry' + explevel: expert +c3sym_seg2_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of second C3 segment + short: Segment ID of second C3 segment + long: Segment ID of second C3 segment + group: 'symmetry' + explevel: expert +c3sym_sta3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the third C3 symmetry segment + long: Residue number of first residue in the third C3 symmetry segment + group: 'symmetry' + explevel: expert +c3sym_end3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the third C3 symmetry segment + long: Residue number of last residue in the third C3 symmetry segment + group: 'symmetry' + explevel: expert +c3sym_seg3_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of third C3 segment + short: Segment ID of third C3 segment + long: Segment ID of third C3 segment + group: 'symmetry' + explevel: expert +nc4sym: + default: 0 + type: integer + min: 0 + max: 10 + title: Number of C4 symmetry restraints + short: Defines the number of C4 symmetry restraints. + long: Defines the number of C4 symmetry restraints. + For each, four segments on which the symmetry restraint is applied will have to be defined. + Those must all have the same length. + group: 'symmetry' + explevel: hidden +c4sym_sta1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the first C4 symmetry segment + long: Residue number of first residue in the first C4 symmetry segment + group: 'symmetry' + explevel: expert +c4sym_end1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the first C4 symmetry segment + long: Residue number of last residue in the first C4 symmetry segment + group: 'symmetry' + explevel: expert +c4sym_seg1_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of first C4 segment + short: Segment ID of first C4 segment + long: Segment ID of first C4 segment + group: 'symmetry' + explevel: expert +c4sym_sta2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the second C4 symmetry segment + long: Residue number of first residue in the second C4 symmetry segment + group: 'symmetry' + explevel: expert +c4sym_end2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the second C4 symmetry segment + long: Residue number of last residue in the second C4 symmetry segment + group: 'symmetry' + explevel: expert +c4sym_seg2_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of second C4 segment + short: Segment ID of second C4 segment + long: Segment ID of second C4 segment + group: 'symmetry' + explevel: expert +c4sym_sta3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the third C4 symmetry segment + long: Residue number of first residue in the third C4 symmetry segment + group: 'symmetry' + explevel: expert +c4sym_end3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the third C4 symmetry segment + long: Residue number of last residue in the third C4 symmetry segment + group: 'symmetry' + explevel: expert +c4sym_seg3_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of third C4 segment + short: Segment ID of third C4 segment + long: Segment ID of third C4 segment + group: 'symmetry' + explevel: expert +c4sym_sta4_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the fourth C4 symmetry segment + long: Residue number of first residue in the fourth C4 symmetry segment + group: 'symmetry' + explevel: expert +c4sym_end4_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the fourth C4 symmetry segment + long: Residue number of last residue in the fourth C4 symmetry segment + group: 'symmetry' + explevel: expert +c4sym_seg4_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of fourth C4 segment + short: Segment ID of fourth C4 segment + long: Segment ID of fourth C4 segment + group: 'symmetry' + explevel: expert +nc5sym: + default: 0 + type: integer + min: 0 + max: 10 + title: Number of C5 symmetry restraints + short: Defines the number of C5 symmetry restraints. + long: Defines the number of C5 symmetry restraints. + For each, five segments on which the symmetry restraint is applied will have to be defined. + Those must all have the same length. + group: 'symmetry' + explevel: hidden +c5sym_sta1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the first C5 symmetry segment + long: Residue number of first residue in the first C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_end1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the first C5 symmetry segment + long: Residue number of last residue in the first C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_seg1_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of first C5 segment + short: Segment ID of first C5 segment + long: Segment ID of first C5 segment + group: 'symmetry' + explevel: expert +c5sym_sta2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the second C5 symmetry segment + long: Residue number of first residue in the second C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_end2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the second C5 symmetry segment + long: Residue number of last residue in the second C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_seg2_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of second C5 segment + short: Segment ID of second C5 segment + long: Segment ID of second C5 segment + group: 'symmetry' + explevel: expert +c5sym_sta3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the third C5 symmetry segment + long: Residue number of first residue in the third C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_end3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the third C5 symmetry segment + long: Residue number of last residue in the third C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_seg3_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of third C5 segment + short: Segment ID of third C5 segment + long: Segment ID of third C5 segment + group: 'symmetry' + explevel: expert +c5sym_sta4_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the fourth C5 symmetry segment + long: Residue number of first residue in the fourth C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_end4_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the fourth C5 symmetry segment + long: Residue number of last residue in the fourth C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_seg4_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of fourth C5 segment + short: Segment ID of fourth C5 segment + long: Segment ID of fourth C5 segment + group: 'symmetry' + explevel: expert +c5sym_sta5_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the fifth C5 symmetry segment + long: Residue number of first residue in the fifth C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_end5_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the fifth C5 symmetry segment + long: Residue number of last residue in the fifth C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_seg5_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of fifth C5 segment + short: Segment ID of fifth C5 segment + long: Segment ID of fifth C5 segment + group: 'symmetry' + explevel: expert +nc6sym: + default: 0 + type: integer + min: 0 + max: 10 + title: Number of C6 symmetry restraints + short: Defines the number of C6 symmetry restraints. + long: Defines the number of C6 symmetry restraints. + For each, six segments on which the symmetry restraint is applied will have to be defined. + Those must all have the same length. + group: 'symmetry' + explevel: hidden +c6sym_sta1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the first C6 symmetry segment + long: Residue number of first residue in the first C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_end1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the first C6 symmetry segment + long: Residue number of last residue in the first C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_seg1_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of first C6 segment + short: Segment ID of first C6 segment + long: Segment ID of first C6 segment + group: 'symmetry' + explevel: expert +c6sym_sta2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the second C6 symmetry segment + long: Residue number of first residue in the second C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_end2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the second C6 symmetry segment + long: Residue number of last residue in the second C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_seg2_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of second C6 segment + short: Segment ID of second C6 segment + long: Segment ID of second C6 segment + group: 'symmetry' + explevel: expert +c6sym_sta3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the third C6 symmetry segment + long: Residue number of first residue in the third C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_end3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the third C6 symmetry segment + long: Residue number of last residue in the third C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_seg3_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of third C6 segment + short: Segment ID of third C6 segment + long: Segment ID of third C6 segment + group: 'symmetry' + explevel: expert +c6sym_sta4_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the fourth C6 symmetry segment + long: Residue number of first residue in the fourth C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_end4_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the fourth C6 symmetry segment + long: Residue number of last residue in the fourth C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_seg4_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of fourth C6 segment + short: Segment ID of fourth C6 segment + long: Segment ID of fourth C6 segment + group: 'symmetry' + explevel: expert +c6sym_sta5_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the fifth C6 symmetry segment + long: Residue number of first residue in the fifth C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_end5_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the fifth C6 symmetry segment + long: Residue number of last residue in the fifth C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_seg5_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of fifth C6 segment + short: Segment ID of fifth C6 segment + long: Segment ID of fifth C6 segment + group: 'symmetry' + explevel: expert +c6sym_sta6_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the sixth C6 symmetry segment + long: Residue number of first residue in the sixth C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_end6_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the sixth C6 symmetry segment + long: Residue number of last residue in the sixth C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_seg6_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of sixth C6 segment + short: Segment ID of sixth C6 segment + long: Segment ID of sixth C6 segment + group: 'symmetry' + explevel: expert +ns3sym: + default: 0 + type: integer + min: 0 + max: 10 + title: Number of S3 symmetry restraints + short: Defines the number of S3 symmetry restraints. + long: Defines the number of S3 symmetry restraints. + For each, three segments on which the symmetry restraint is applied will have to be defined. + Those must all have the same length. + group: 'symmetry' + explevel: hidden +s3sym_sta1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the first S3 symmetry segment + long: Residue number of first residue in the first S3 symmetry segment + group: 'symmetry' + explevel: expert +s3sym_end1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the first S3 symmetry segment + long: Residue number of last residue in the first S3 symmetry segment + group: 'symmetry' + explevel: expert +s3sym_seg1_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of first S3 segment + short: Segment ID of first S3 segment + long: Segment ID of first S3 segment + group: 'symmetry' + explevel: expert +s3sym_sta2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the second S3 symmetry segment + long: Residue number of first residue in the second S3 symmetry segment + group: 'symmetry' + explevel: expert +s3sym_end2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the second S3 symmetry segment + long: Residue number of last residue in the second S3 symmetry segment + group: 'symmetry' + explevel: expert +s3sym_seg2_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of second S3 segment + short: Segment ID of second S3 segment + long: Segment ID of second S3 segment + group: 'symmetry' + explevel: expert +s3sym_sta3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the third S3 symmetry segment + long: Residue number of first residue in the third S3 symmetry segment + group: 'symmetry' + explevel: expert +s3sym_end3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the third S3 symmetry segment + long: Residue number of last residue in the third S3 symmetry segment + group: 'symmetry' + explevel: expert +s3sym_seg3_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of third S3 segment + short: Segment ID of third S3 segment + long: Segment ID of third S3 segment + group: 'symmetry' + explevel: expert +ncs_on: + default: false + type: boolean + title: Non-crystallographic symmetry restraints + short: Non-crystallographic symmetry restraints to ensure two molecules will have the same conformation. + long: Non-crystallographic symmetry restraints to ensure two molecules will have the same conformation. + This does not apply any symmetry between the two molecules but rather defines restraints such as the RMSD between those is 0. + group: 'symmetry' + explevel: expert +kncs: + default: 1.0 + type: float + min: 0 + max: 1000 + precision: 1 + title: Force constant for non-crystallographic restraints + short: Force constant for non-crystallographic restraints + long: Force constant for non-crystallographic restraints + group: 'symmetry' + explevel: expert +nncs: + default: 0 + type: integer + min: 0 + max: 100 + title: Number of non-crystallographic symmetry restraints + short: Number of non-crystallographic symmetry restraints (NCS). + long: Number of non-crystallographic symmetry restraints. For each pairs of segments will have to be defined. + Note that those must contain exactly the same residues/atom combinations. + group: 'symmetry' + explevel: hidden +ncs_sta1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the first NCS segment + long: Residue number of first residue in the first NCS segment + group: 'symmetry' + explevel: expert +ncs_end1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the first NCS segment + long: Residue number of last residue in the first NCS segment + group: 'symmetry' + explevel: expert +ncs_seg1_1: + default: '' + type: string + minchars: 0 + maxchars: 100 + title: Segment ID of first NCS segment + short: Segment ID of first NCS segment + long: Segment ID of first NCS segment + group: 'symmetry' + explevel: expert +ncs_sta2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the second NCS segment + long: Residue number of first residue in the second NCS segment + group: 'symmetry' + explevel: expert +ncs_end2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the second NCS segment + long: Residue number of last residue in the second NCS segment + group: 'symmetry' + explevel: expert +ncs_seg2_1: + default: '' + type: string + minchars: 0 + maxchars: 100 + title: Segment ID of second NCS segment + short: Segment ID of second NCS segment + long: Segment ID of second NCS segment + group: 'symmetry' + explevel: expert +# +# Group scoring +# +w_air: + default: 0.1 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the distance restraint energy + short: Weight of the distance restraints energy in the scoring function + long: Weight of the distance restraints energy in the scoring function. + Note that this is different from the force constants used during the calculations. + group: 'scoring' + explevel: expert +w_bsa: + default: -0.01 + type: float + min: -9999 + max: 9999 + precision: 3 + title: Weight of the buried surface area term + short: Weight of the buried surface area term in the scoring function + long: Weight of the buried surface area (BSA) term in the scoring function. + Note that the BSA is only used for scoring. + group: 'scoring' + explevel: expert +w_cdih: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the dihedral angle restraint energy + short: Weight of the dihedral angle restraints energy in the scoring function + long: Weight of the dihedral angle restraints energy in the scoring function. + Note that this is different from the force constant used during the calculations. + group: 'scoring' + explevel: expert +w_dani: + default: 0.1 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the relaxation anisotropy (DANI) restraint energy + short: Weight of the relaxation anisotropy (DANI) restraint energy + long: Weight of the relaxation anisotropy (DANI) restraint energy + group: 'scoring' + explevel: hidden +w_deint: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the interaction energy term + short: Weight of the interaction energy term + long: Weight of the interaction energy term calculated as the difference in total energy of the complex and of the separate components + group: 'scoring' + explevel: hidden +w_desolv: + default: 1.0 + type: float + min: -9999 + max: 9999 + precision: 3 + title: Weight of the desolvation energy term + short: Weight of the desolvation energy term in the scoring function + long: Weight of the desolvation energy term in the scoring function. + Note that the desolvation energy is only used for scoring. + group: 'scoring' + explevel: expert +w_elec: + default: 1.0 + type: float + min: -9999 + max: 9999 + precision: 3 + title: Weight of the intermolecular electrostatic energy + short: Weight of the intermolecular electrostatic energy in the scoring function + long: Weight of the intermolecular electrostatic energy in the scoring function. + Note that this does not affect the electostatic energy during the MD refinement. + group: 'scoring' + explevel: expert +w_lcc: + default: -10000.0 + type: float + min: -10000.0 + max: 0 + precision: 3 + title: Weight of the EM local correlation coefficient + short: Weight of the EM local correlation coefficient + long: Weight of the EM local correlation coefficient + group: 'scoring' + explevel: hidden +w_rg: + default: 1.000 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the radius of gyration restraint energy + short: Weight of the radius of gyration restraint energy + long: Weight of the radius of gyration restraint energy + group: 'scoring' + explevel: hidden +w_sani: + default: 0.1 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the residual dipolar coupling (SANI) restraint energy + short: Weight of the residual dipolar coupling (SANI) restraint energy + long: Weight of the residual dipolar coupling (SANI) restraint energy + group: 'scoring' + explevel: hidden +w_sym: + default: 0.1 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the symmetry restraint energy + short: Weight of the symmetry restraints energy in the scoring function + long: Weight of the symmetry restraints energy in the scoring function. + Note that this is different from the force constant used during the calculations. + group: 'scoring' + explevel: expert +w_vdw: + default: 1.0 + type: float + min: -9999 + max: 9999 + precision: 3 + title: Weight of the intermolecular van der Waals energy + short: Weight of the intermolecular van der Waals energy in the scoring function + long: Weight of the intermolecular van der Waals energy in the scoring function. + Note that this does not affect the van der Waals energy during the MD refinement. + group: 'scoring' + explevel: expert +w_vean: + default: 0.1 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the residual dipolar coupling (VEAN) restraint energy + short: Weight of the residual dipolar coupling (VEAN) restraint energy + long: Weight of the residual dipolar coupling (VEAN) restraint energy + group: 'scoring' + explevel: hidden +w_xpcs: + default: 0.1 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the pseudo contact shifts (XPCS) restraint energy + short: Weight of the pseudo contact shifts (XPCS) restraint energy + long: Weight of the pseudo contact shifts (XPCS) restraint energy + group: 'scoring' + explevel: hidden +w_xrdc: + default: 0.1 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the residual dipolar coupling (XRDC) restraint energy + short: Weight of the residual dipolar coupling (XRDC) restraint energy + long: Weight of the residual dipolar coupling (XRDC) restraint energy + group: 'scoring' + explevel: hidden +w_zres: + default: 0.1 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the Z-restraining potential energy + short: Weight of the Z-restraining potential energy + long: Weight of the Z-restraining potential energy + group: 'scoring' + explevel: hidden +# +# Group force field +# +ligand_param_fname: + default: '' + type: file + title: Custom ligand parameter file + short: Ligand parameter file in CNS format + long: Ligand parameter file in CNS format containing all force field parameters + (bond, angles, dihedrals, impropers, van der waals) for any ligand not supported by default by HADDOCK + group: 'force field' + explevel: easy +ligand_top_fname: + default: '' + type: file + title: Custom ligand topology file + short: Ligand topology file in CNS format + long: Ligand topology file in CNS format containing the ligand topologies + (atoms, masses, charges, bond definitions...) for any ligand not supported by default by HADDOCK + group: 'force field' + explevel: easy +elecflag: + default: true + type: boolean + title: Include electrostatics energy + short: Include electrostatics energy during the calculations. + long: Include electrostatics energy during the calculations. If set to false electrostatics will not be considered. + group: 'force field' + explevel: easy +dielec: + default: rdie + type: string + minchars: 0 + maxchars: 4 + choices: + - cdie + - rdie + title: Constant (cdie) or distance-dependent dielectric (rdie) constant. + short: Use a constant (cdie option) or a distance-dependent dielectric (rdie) constant in the Coulomb potential. + long: Use a constant (cdie option) or a distance-dependent dielectric (rdie) constant in the Coulomb potential. + A distance dependent dielectric constant will effectively scale down the electrostatic energy + by having a 1/r**2 dependency instead of 1/r + group: 'force field' + explevel: expert +epsilon: + default: 1.0 + type: float + min: 1 + max: 78 + precision: 1 + title: Dielectric constant + short: Dielectric constant for the electrostatic Coulomb energy term. + long: Dielectric constant for the electrostatic Coulomb energy term. + group: 'force field' + explevel: expert +dihedflag: + default: true + type: boolean + title: Use torsion angle dihedral energy term + short: Turns on the torsion angle dihedral energy terms of the force field. + long: Turns on the torsion angle dihedral energy terms of the force field. + group: 'force field' + explevel: expert +# +# Group sampling +# +sampling_factor: + default: 1 + type: integer + min: 1 + max: 500 + title: Sampling factor for each starting model + short: This paramater controls how many times a model will be refined. + long: This paramater controls how many times a model will be refined. + group: 'sampling' + explevel: expert +max_nmodels: + default: 10000 + type: integer + min: 1 + max: 50000 + title: Maximum number of models to refine + short: This paramater controls the maximum number of models to refine. + long: This paramater controls the maximum number of models to refine. + group: 'sampling' + explevel: expert +nemsteps: + default: 200 + type: integer + min: 0 + max: 10000 + title: Number of EM steps + short: Number of energy minimisation steps to perform. + long: Number of energy minimisation steps to perform in the various EM stages of this refinement protocol. + Note that the effective number might be smaller if the minimisation converges earlier. + group: 'sampling' + explevel: expert +mdsteps_rigid: + default: 500 + type: integer + min: 0 + max: 10000 + title: Hot phase SA MD steps + short: Number of MD steps for the hot phase of the SA. + long: Number of MD steps for the hot phase rigid body dynamics of the simulated annealing protocol. + group: 'sampling' + explevel: expert +mdsteps_cool1: + default: 500 + type: integer + min: 0 + max: 10000 + title: First cooling phase SA MD steps + short: Number of MD steps for the first cooling phase of the SA. + long: Number of MD steps for the first cooling phase of rigid body dynamics of the simulated annealing protocol. + group: 'sampling' + explevel: expert +mdsteps_cool2: + default: 1000 + type: integer + min: 0 + max: 10000 + title: Second cooling phase SA MD steps + short: Number of MD steps for the second cooling phase of the SA. + long: Number of MD steps for the second cooling phase of torsion angle dynamics of the simulated annealing protocol with flexible side-chains at the interface. Full flexibility is applied to the segments defined as fully flexible (see nfle and related parameters). + group: 'sampling' + explevel: expert +mdsteps_cool3: + default: 1000 + type: integer + min: 0 + max: 10000 + title: Third cooling phase SA MD steps + short: Number of MD steps for the third cooling phase of the SA. + long: Number of MD steps for the third cooling phase of torsion angle dynamics of the simulated annealing protocol with flexible side-chains and backbone at the interface. Full flexibility is applied to the segments defined as fully flexible (see nfle and related parameters). + group: 'sampling' + explevel: expert +randorien: + default: false + type: boolean + title: Randomize starting orientations + short: Randomize starting orientations + long: Randomize starting orientations by separating the molecules in space and randomly rotating those + group: 'sampling' + explevel: guru +timestep: + default: 0.002 + type: float + min: 0.0005 + max: 0.004 + precision: 4 + title: MD integrating time step + short: Integration time step for the torsion angle molecular dynamics. + long: Integration time step for the torsion angle molecular dynamics. + group: 'sampling' + explevel: guru +tadfactor: + default: 8 + type: integer + min: 1 + max: 10 + title: Scaling factor for the integration time step. + short: Initial scaling factor for the integration time step of the hot phase SA. + long: Scaling factor applied at the start of the simulated annealing protocol to the timestep using during torsion angle molecular dynamics. This factor is automatically reduced during the SA protocol. + group: 'sampling' + explevel: guru +temp_high: + default: 2000 + type: integer + min: 1 + max: 5000 + title: Initial rigid-body MD temperature + short: Temperature for the initial rigid-body MD phase in Kelvin. + long: Temperature in Kelvin for the initial rigid-body molecular dynamic phase of the simulated annealing protocol. + group: 'sampling' + explevel: guru +temp_cool1_init: + default: 2000 + type: integer + min: 1 + max: 5000 + title: Start temperature for the 1st cooling phase + short: Starting temperature for the first rigid-body MD cooling phase in Kelvin. + long: Starting temperature in Kelvin for the first rigid-body molecular dynamic cooling phase of the simulated annealing protocol. + group: 'sampling' + explevel: guru +temp_cool1_final: + default: 500 + type: integer + min: 1 + max: 1000 + title: End temperature for the 1st cooling phase + short: End temperature for the first rigid-body MD cooling phase in Kelvin. + long: End temperature in Kelvin for the first rigid-body molecular dynamic cooling phase of the simulated annealing protocol. + group: 'sampling' + explevel: guru +temp_cool2_init: + default: 1000 + type: integer + min: 1 + max: 2000 + title: Start temperature for the 2nd cooling phase + short: Starting temperature for the second MD cooling phase in Kelvin. + long: Starting temperature in Kelvin for the second torsion angle molecular dynamic cooling phase of the simulated annealing protocol in which side-chains at the interface are treated as flexible. + group: 'sampling' + explevel: guru +temp_cool2_final: + default: 50 + type: integer + min: 1 + max: 1000 + title: End temperature for the 2nd cooling phase + short: End temperature for the second MD cooling phase in Kelvin. + long: End temperature in Kelvin for the second torsion angle molecular dynamic cooling phase of the simulated annealing protocol in which side-chains at the interface are treated as flexible. + group: 'sampling' + explevel: guru +temp_cool3_init: + default: 1000 + type: integer + min: 1 + max: 1000 + title: Start temperature for the 3rd cooling phase + short: Starting temperature for the third MD cooling phase in Kelvin. + long: Starting temperature in Kelvin for the third and final torsion angle molecular dynamic cooling phase of the simulated annealing protocol in which side-chains and backbone at the interface are treated as flexible. + group: 'sampling' + explevel: guru +temp_cool3_final: + default: 50 + type: integer + min: 1 + max: 1000 + title: End temperature for the 3rd cooling phase + short: End temperature for the third MD cooling phase in Kelvin. + long: End temperature in Kelvin for the third and final torsion angle molecular dynamic cooling phase of the simulated annealing protocol in which side-chains and backbone at the interface are treated as flexible. + group: 'sampling' + explevel: guru +sinter_rigid_init: + default: 0.001 + type: float + min: 0.00001 + max: 1 + precision: 5 + title: Initial rigid-body MD intermolecular interactions scaling factor. + short: Initial scaling factor for intermolecular interactions in the first two SA stages + long: Initial scaling factor applied to intermolecular interactions during the first rigid-body molecular dynamics stage and at the start of the first cooling stage of the of the simulated annealing protocol. + group: 'sampling' + explevel: guru +sinter_rigid_final: + default: 0.001 + type: float + min: 0.00001 + max: 1 + precision: 5 + title: End rigid-body MD intermolecular interactions scaling factor. + short: End scaling factor for intermolecular interactions in the first cooling stage. + long: End scaling factor applied to intermolecular interactions during the first cooling stage of the simulated annealing protocol. + group: 'sampling' + explevel: easy +sinter_cool2_init: + default: 0.001 + type: float + min: 0.00001 + max: 1 + precision: 5 + title: Initial intermolecular interactions scaling factor for the 2nd cooling phase. + short: Initial scaling factor for intermolecular interactions in the second MD cooling SA stage. + long: Initial scaling factor applied to intermolecular interactions during the second torsion angle molecular dynamics cooling stage of the simulated annealing protocol during which side-chains at the interface are treated as flexible. + group: 'sampling' + explevel: guru +sinter_cool2_final: + default: 1.0 + type: float + min: 0.00001 + max: 1 + precision: 5 + title: End intermolecular interactions scaling factor for the 2nd cooling phase. + short: End scaling factor for intermolecular interactions in the second MD cooling SA stage. + long: End scaling factor applied to intermolecular interactions during the second torsion angle molecular dynamics cooling stage of the simulated annealing protocol during which side-chains at the interface are treated as flexible. + group: 'sampling' + explevel: guru +sinter_cool3_init: + default: 0.05 + type: float + min: 0.00001 + max: 1 + precision: 5 + title: Initial intermolecular interactions scaling factor for the 3rd cooling phase. + short: Initial scaling factor for intermolecular interactions in the third MD cooling SA stage. + long: Initial scaling factor applied to intermolecular interactions during the third and final torsion angle molecular dynamics cooling stage of the simulated annealing protocol during which both side-chains and backbone at the interface are treated as flexible. + group: 'sampling' + explevel: guru +sinter_cool3_final: + default: 1.0 + type: float + min: 0.00001 + max: 1 + precision: 5 + title: End intermolecular interactions scaling factor for the 3rd cooling phase. + short: End scaling factor for intermolecular interactions in the third MD cooling SA stage. + long: End scaling factor applied to intermolecular interactions during the third and final torsion angle molecular dynamics cooling stage of the simulated annealing protocol during which both side-chains and backbone at the interface are treated as flexible. + group: 'sampling' + explevel: guru +iniseed: + default: 917 + type: integer + min: 0 + max: 9999999999999999 + title: Random seed + short: Random seed used in CNS to initialize the random seed function + long: Random seed used in CNS to initialize the random seed function + group: 'sampling' + explevel: guru +keepwater: + default: false + type: boolean + title: Write water molecules to output file + short: Write water molecules if present to the output file. + long: Write water molecules if present to the output file. + group: 'sampling' + explevel: guru +tolerance: + default: 5 + type: integer + min: 0 + max: 99 + precision: 3 + title: Failure tolerance percentage + short: Percentage of allowed failures for a module to successfully complete + long: Percentage of allowed failures for a module to successfully complete + group: 'module' + explevel: expert +log_level: + default: quiet + type: string + minchars: 0 + maxchars: 100 + choices: + - verbose + - normal + - quiet + title: Log level verbosity for CNS + short: Set the log level verbosity for CNS + long: CNS, the computational engine used by HADDOCK can generate a lot of output + messages. This parameter controls the verbosity of CNS (verbose, normal or quiet). + group: module + explevel: guru +# +# Group flexibility +# +# +# Semi-flexible segments +# +nseg1: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg2: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg3: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg4: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_4_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_4_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg5: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_5_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_5_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg6: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_6_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_6_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg7: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_7_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_7_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg8: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_8_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_8_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg9: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_9_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_9_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg10: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_10_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_10_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg11: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_11_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_11_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg12: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_12_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_12_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg13: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_13_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_13_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg14: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_14_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_14_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg15: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_15_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_15_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg16: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_16_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_16_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg17: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_17_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_17_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg18: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_18_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_18_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg19: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_19_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_19_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg20: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_20_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_20_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +# +# Fully flexible segments +# +nfle: + default: 0 + type: integer + min: 0 + max: 1000 + title: Number of fully flexible segments + short: This defines the number of fully flexible segments. + long: This parameter defines the number of fully flexible segments for all molecules. + If >=1 then those must be defined manually with segment ID (segid) in the fle_seg_* variable, + followed by the starting and ending residue numbers in the fle_sta_* and fle_end_* variables. + group: 'flexibility' + explevel: hidden +fle_sta_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the fully flexible segment. + long: Residue number defining the start of this (1st) fully flexible segment. + group: 'flexibility' + explevel: expert +fle_end_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: End residue number + short: Residue number defining the end of the fully flexible segment. + long: Residue number defining the end of this (1st) fully flexible segment. + group: 'flexibility' + explevel: expert +fle_seg_1: + default: none + type: string + minchars: 1 + maxchars: 4 + title: Segment ID (segid) + short: Segment ID of the molecule for which this flexible segment is defined. + long: Segment ID of the molecule for which this (1st) flexible segment is defined. + group: 'flexibility' + explevel: expert +# +# Group interaction matrix +# +int_1_1: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_2: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_3: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_4: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_5: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_6: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_7: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_8: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_9: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_2: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_3: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_4: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_5: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_6: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_7: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_8: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_9: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_3: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_4: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_5: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_6: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_7: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_8: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_9: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_4: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_5: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_6: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_7: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_8: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_9: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_5: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_6: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_7: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_8: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_9: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_6: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_7: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_8: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_9: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_7: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_8: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_9: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_8: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_9: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_9: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_12_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_12_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_12_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_12_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_12_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_12_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_12_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_12_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_12_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_13_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_13_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_13_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_13_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_13_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_13_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_13_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_13_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_14_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_14_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_14_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_14_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_14_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_14_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_14_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_15_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_15_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_15_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_15_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_15_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_15_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_16_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_16_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_16_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_16_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_16_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_17_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_17_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_17_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_17_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_18_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_18_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_18_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_19_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_19_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_20_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3d651f585d911d18d0afee7d22b30d2ea4458711 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/__init__.py @@ -0,0 +1,156 @@ +"""Explicit solvent MD refinement with CNS. + +The ``[mdref]`` module (also known as ``itw`` in HADDOCK2.X series), is a small +molecular dynamics simulation, in cartesian space, using explicit solvent. + +A layer of solvent (8A for water, 12.5A for DMSO) is generated around +surface residues. + +The `mdref` protocol is composed of 4 sequential steps: +- Short energy minimization +- 3 stages of molecular dynamics to reach 300K (at 100, 200 and 300K) +- Molecular dynamics at 300K. +- 3 stages of molecular dynamics, to reach 100K (at 300, 200 and 100K) + +Using this protocol, with default parameters, no spectacular changes are +expected, however, the scoring of the various structures might be improved. + + +Number of MD steps can be modified using the ``waterheatsteps``, ``watersteps`` +and ``watercoolsteps``. +""" + +from pathlib import Path + +from haddock.core.defaults import MODULE_DEFAULT_YAML +from haddock.core.typing import FilePath +from haddock.gear.haddockmodel import HaddockModel +from haddock.libs.libcns import prepare_cns_input, prepare_expected_pdb +from haddock.libs.libontology import PDBFile +from haddock.libs.libsubprocess import CNSJob +from haddock.modules import get_engine +from haddock.modules.base_cns_module import BaseCNSModule + + +RECIPE_PATH = Path(__file__).resolve().parent +DEFAULT_CONFIG = Path(RECIPE_PATH, MODULE_DEFAULT_YAML) + + +class HaddockModule(BaseCNSModule): + """HADDOCK3 module for water refinement.""" + + name = RECIPE_PATH.name + + def __init__( + self, order: int, path: Path, initial_params: FilePath = DEFAULT_CONFIG + ) -> None: + cns_script = Path(RECIPE_PATH, "cns", "mdref.cns") + super().__init__(order, path, initial_params, cns_script=cns_script) + + @classmethod + def confirm_installation(cls) -> None: + """Confirm if module is installed.""" + return + + def _run(self) -> None: + """Execute module.""" + # Pool of jobs to be executed by the CNS engine + jobs: list[CNSJob] = [] + + # Get the models generated in previous step + try: + models_to_refine = self.previous_io.retrieve_models() + except Exception as e: + self.finish_with_error(e) + + self.output_models: list[PDBFile] = [] + + sampling_factor = self.params["sampling_factor"] + if sampling_factor > 1: + self.log(f"sampling_factor={sampling_factor}") + if sampling_factor == 0: + self.log("[Warning] sampling_factor cannot be 0, setting it to 1") + sampling_factor = 1 + if sampling_factor > 100: + self.log("[Warning] sampling_factor is larger than 100") + + max_nmodels = self.params["max_nmodels"] + nmodels = len(models_to_refine) * sampling_factor + if nmodels > max_nmodels: + self.finish_with_error( + f"Too many models ({nmodels}) to refine, max_nmodels =" + f" {max_nmodels}. Please reduce the number of models or" + " decrease the sampling_factor." + ) + + # checking the ambig_fname: + try: + prev_ambig_fnames = [mod.restr_fname for mod in models_to_refine] + except Exception as e: # noqa:F841 + # cannot extract restr_fname info from tuples + prev_ambig_fnames = [None for mod in models_to_refine] + + ambig_fnames = self.get_ambig_fnames(prev_ambig_fnames) + + model_idx = 0 + idx = 1 + for model in models_to_refine: + # assign ambig_fname + if ambig_fnames: + ambig_fname = ambig_fnames[model_idx] + else: + ambig_fname = self.params["ambig_fname"] + model_idx += 1 + + for _ in range(self.params["sampling_factor"]): + mdref_input = prepare_cns_input( + idx, + model, + self.path, + self.recipe_str, + self.params, + "mdref", + ambig_fname=ambig_fname, + native_segid=True, + debug=self.params["debug"], + seed=model.seed if isinstance(model, PDBFile) else None, + ) + out_file = f"mdref_{idx}.out" + err_fname = f"mdref_{idx}.cnserr" + + # create the expected PDBobject + expected_pdb = prepare_expected_pdb(model, idx, ".", "mdref") + expected_pdb.restr_fname = ambig_fname + try: + expected_pdb.ori_name = model.file_name + except AttributeError: + expected_pdb.ori_name = None + self.output_models.append(expected_pdb) + + job = CNSJob(mdref_input, out_file, err_fname, envvars=self.envvars) + + jobs.append(job) + + idx += 1 + + # Run CNS Jobs + self.log(f"Running CNS Jobs n={len(jobs)}") + Engine = get_engine(self.params["mode"], self.params) + engine = Engine(jobs) + engine.run() + self.log("CNS jobs have finished") + + # Get the weights from the defaults + _weight_keys = ("w_vdw", "w_elec", "w_desolv", "w_air", "w_bsa") + weights = {e: self.params[e] for e in _weight_keys} + + for pdb in self.output_models: + if pdb.is_present(): + haddock_model = HaddockModel(pdb.file_name) + pdb.unw_energies = haddock_model.energies + + haddock_score = haddock_model.calc_haddock_score(**weights) + pdb.score = haddock_score + + # Save module information + self.export_io_models(faulty_tolerance=self.params["tolerance"]) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d093d8f76c686d5d0c609364abc2e671205b98e6 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/calc_free-ene.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/calc_free-ene.cns new file mode 100644 index 0000000000000000000000000000000000000000..0466f939be3a1b65c698e77621e36fbcd68e0174 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/calc_free-ene.cns @@ -0,0 +1,24 @@ +! calc_free-ene.cns +! Calculate the total energy of the separated components +! +! Script uses the store1 and store2 atom object, and COMP, REF and RMSD object +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +@MODULE:scale_intra_only.cns + +evaluate ($eintfree = 0.0) +@MODULE:flex_segment_back.cns +fix sele=(((attr store5 = 0) or resn ANI or resn DAN or resn XAN or resn SHA) and not name H* and not (resn WAT or resn HOH or resn TIP*)) end + +minimize powell nstep=100 drop=10.0 nprint=25 end +fix sele=(not all) end +energy end +evaluate ($eintfree = $bond + $angl + $impr + $dihe + $vdw + $elec) + +display FREE MOLECULES INTERNAL ENERGY = $eintfree diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/check_coordinates.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/check_coordinates.cns new file mode 100644 index 0000000000000000000000000000000000000000..d23c8e64804060c61ff6aeea38925dc8e61dc8d6 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/check_coordinates.cns @@ -0,0 +1,100 @@ +! check_coordinates.cns +! Check max/min coordinates for compatibility with PDB format +! +! *********************************************************************** +! * Copyright 2025 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +evaluate ($failure = false) + +!check for coordinates >9999.999 (max writable in PDB format) + +show max (x) (all) +evaluate ($maxcoor = $result) +show max (y) (all) +if ($result gt $maxcoor) then + evaluate ($maxcoor = $result) +end if +show max (z) (all) +if ($result gt $maxcoor) then + evaluate ($maxcoor = $result) +end if +if ($maxcoor gt 9999.999) then + evaluate ($failure = true) +end if + +!check for coordinates <-999.999 (min writable in PDB format) + +show min (x) (all) +evaluate ($mincoor = $result) +show min (y) (all) +if ($result lt $mincoor) then + evaluate ($maxcoor = $result) +end if +show min (z) (all) +if ($result lt $mincoor) then + evaluate ($mincoor = $result) +end if +if ($mincoor lt -999.999) then + evaluate ($failure = true) +end if + +!if problem detected try correcting it by centering the system around 4500,4500,4500 +!but only if no EM restraints are used + +if ($failure eq true) then + if ($data.flags.em eq false) then + + evaluate ($xc = 0.0) + evaluate ($yc = 0.0) + evaluate ($zc = 0.0) + show ave (x) (all) + evaluate ($xc = 4500 - $result) + show ave (y) (all) + evaluate ($yc = 4500 - $result) + show ave (z) (all) + evaluate ($zc = 4500 -$result) + + do (x = x + $xc) (all) + do (y = y + $yc) (all) + do (z = z + $zc) (all) + + evaluate ($failure = false) + evaluate ($maxcoor = -999) + evaluate ($mincoor = 9999) + !check again for coordinates >9999.999 (max writable in PDB format) + show max (x) (all) + evaluate ($maxcoor = $result) + show max (y) (all) + if ($result gt $maxcoor) then + evaluate ($maxcoor = $result) + end if + show max (z) (all) + if ($result gt $maxcoor) then + evaluate ($maxcoor = $result) + end if + if ($maxcoor gt 9999.999) then + evaluate ($failure = true) + end if + + !check for coordinates <-999.999 (min writable in PDB format) + show min (x) (all) + evaluate ($mincoor = $result) + show min (y) (all) + if ($result lt $mincoor) then + evaluate ($maxcoor = $result) + end if + show min (z) (all) + if ($result lt $mincoor) then + evaluate ($mincoor = $result) + end if + if ($mincoor lt -999.999) then + evaluate ($failure = true) + end if + end if +end if + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/cm-restraints.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/cm-restraints.cns new file mode 100644 index 0000000000000000000000000000000000000000..7d10870287525ba4db37de66ab8ca7115ac9148f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/cm-restraints.cns @@ -0,0 +1,144 @@ +! cm-restraints.cns +! Define center-of-mass restraints between molecules +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +!define center of mass restraints between all molecules +!using distance restraints between CA, BB or N1 atoms with center averaging + +evaluate ($ncount = 0) + +! store original coordinates +do (refx = x) (all) +do (refy = y) (all) +do (refz = z) (all) + +while ($ncount < $data.ncomponents) loop nloop1 + evaluate ($ncount = $ncount +1) + evaluate ($dim_$ncount = 0.0) + + !orient molecule + coor orient sele=(segid $prot_segid_$ncount) end + + ! find dimensions + show max (x) (segid $prot_segid_$ncount and (name CA or name BB or name N1)) + evaluate ($xdim = $result) + show max (y) (segid $prot_segid_$ncount and (name CA or name BB or name N1)) + evaluate ($ydim = $result) + show max (z) (segid $prot_segid_$ncount and (name CA or name BB or name N1)) + evaluate ($zdim = $result) + show min (x) (segid $prot_segid_$ncount and (name CA or name BB or name N1)) + evaluate ($xdim = $xdim - $result) + show min (y) (segid $prot_segid_$ncount and (name CA or name BB or name N1)) + evaluate ($ydim = $ydim - $result) + show min (z) (segid $prot_segid_$ncount and (name CA or name BB or name N1)) + evaluate ($zdim = $zdim - $result) + + evaluate ($corr = max($xdim,$ydim)) + evaluate ($corr = max($corr,$zdim)) + + if ($data.cmtight eq false) then + ! use average of all three dimensions + evaluate ($dim_$ncount = ($xdim + $ydim + $zdim)/6.0) + else + ! use only the average of the smallest two dimensions + evaluate ($dim_$ncount = ($xdim + $ydim + $zdim - $corr)/4.0) + end if + + ! check if the molecule is a DNA + do (store6 = 0) (all) + do (store6 = 1) (segid $prot_segid_$ncount and tag) + show sum (store6) (all) + evaluate ($nresmol = $result) + do (store6 = 0) (all) + do (store6 = 1) (segid $prot_segid_$ncount and (resn DA or resn DC or resn DG or resn DT) and tag) + show sum (store6) (all) + if ($result eq $nresmol) then + ! we are dealing with DNA set dimension to 0 + evaluate ($dim_$ncount = 0.0) + end if + + ! check if the molecule is a small ligand + do (store6 = 0) (all) + do (store6 = 1) (segid $prot_segid_$ncount and (name CA or name BB or name N1)) + show sum (store6) (all) + if ($result eq 0) then + ! we are dealing with a ligand set dimension to 0 + evaluate ($dim_$ncount = 0.0) + end if + +end loop nloop1 + +! restore original coordinates +do (x = refx) (all) +do (y = refy) (all) +do (z = refz) (all) + +eval($nchain = 0) +do (store9 = 0) (all) +do (store9 = 1) (name CA or name BB or name N1) +while ($nchain < $data.ncomponents) loop nloop0 + eval($nchain = $nchain + 1) + show sum (store9) (segid $prot_segid_$nchain) + if ($result < 3) then + evaluate ($selat$nchain = 0 ) + else + evaluate ($selat$nchain = 1 ) + end if +end loop nloop0 + +eval($nchain1 = 0) +noe + class contact + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + eval($nchain2 = $nchain1 ) + if ($mol_shape_$nchain1 eq false) then + while ($nchain2 < $data.ncomponents) loop nloop2 + eval($nchain2 = $nchain2 + 1) + if ($mol_shape_$nchain2 eq false) then + if ($data.cmtight eq false) then + eval($cm_dist = $dim_$nchain1 + $dim_$nchain2) + else + eval($cm_dist = ($dim_$nchain1 + $dim_$nchain2)/2 ) + end if + if ($selat$nchain1 = 1) then + if ($selat$nchain2 = 1) then + assign (segid $prot_segid_$nchain1 and ( name CA or name BB or name N1 )) + (segid $prot_segid_$nchain2 and ( name CA or name BB or name N1 )) $cm_dist $cm_dist 1.0 + else + assign (segid $prot_segid_$nchain1 and ( name CA or name BB or name N1 )) + (segid $prot_segid_$nchain2) $cm_dist $cm_dist 1.0 + end if + else + if ($selat$nchain2 = 1) then + assign (segid $prot_segid_$nchain1) + (segid $prot_segid_$nchain2 and ( name CA or name BB or name N1 )) $cm_dist $cm_dist 1.0 + else + assign (segid $prot_segid_$nchain1) + (segid $prot_segid_$nchain2) $cm_dist $cm_dist 1.0 + end if + end if + end if + end loop nloop2 + end if + end loop nloop1 + + averaging contact center + scale contact $Data.kcm + sqconstant contact 1.0 + sqexponent contact 2 + soexponent contact 1 + rswitch contact 1.0 + sqoffset contact 0.0 + asymptote contact 2.0 + msoexponent contact 1 + masymptote contact -0.1 + mrswitch contact 1.0 +end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/contactairs.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/contactairs.cns new file mode 100644 index 0000000000000000000000000000000000000000..aa8028ab7d3b40e56df692afec9eda66b1a45c68 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/contactairs.cns @@ -0,0 +1,27 @@ +! contactairs.cns +! Define ambiguous distance restraints between residues at interfaces +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +eval($nchain1 = 0) +while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + for $id in id (tag and segid $prot_segid_$nchain1 + and (not (segid $prot_segid_$nchain1 or resn ANI or resn DAN or resn XAN + or resn SHA or resn WAT or resn HOH or resn TIP* or resn DUM) around 5.0)) loop defnoe1 + show (resid) (id $id) + evaluate ($inres = $result) + noe + assign (resid $inres and segid $prot_segid_$nchain1) + (byres (not (segid $prot_segid_$nchain1 or resn ANI or resn DAN or resn XAN + or resn SHA or resn WAT or resn HOH or resn TIP* or resn DUM) + and (segid $prot_segid_$nchain1) around 5.0)) 2.0 2.0 0.0 + end + end loop defnoe1 +end loop nloop1 diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/def_solv_param.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/def_solv_param.cns new file mode 100644 index 0000000000000000000000000000000000000000..5a9e07a042e08d15d5b98d859fa199151e7b4a43 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/def_solv_param.cns @@ -0,0 +1,105 @@ +! def_solv_param.cns +! Define atomic solvation parameters +! Original valus taken from Fernandez-Recio et al. JMB 335:843 (2004) +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +evaluate ($arofac = 6.26) +evaluate ($alifac = 1.27) +evaluate ($polfac = 2.30) + + +do (store1 = 0.0000) (all) +do (store1 = 0.0151 * $alifac) (name C*) +do (store1 = 0.0176 * $arofac) ((name CG* or name CD* or name CE* or name CH* or name CZ*) and (resn PHE or resn TYR or resn HIS or resn TRP)) +do (store1 = -0.0170 * $polfac) (name N*) +do (store1 = -0.0548 * $polfac) (name NT* or (name NZ* and resn LYS)) +do (store1 = -0.0273 * $polfac) (name NH* and resn ARG) +do (store1 = -0.0136 * $polfac) (name O*) +do (store1 = -0.0185 * $polfac) (name OG* or name OH) +do (store1 = -0.0299 * $polfac) ((name OD* and resn ASP) or (name OE* and resn GLU)) +do (store1 = 0.0112 * $polfac) (name S*) +do (store1 = 0.0022 * $polfac) ((name S* and attr charge = -0.3) or (name SD and resn MET)) +do (store1 = 0.0000) (name SHA) + +! +! CG parameters matched from the original terms +! +! Edesolv_aa +! ASP_cg = _________________________ +! ASA_cg +! +! ASA_cg and Edesol_aa calculated on a GGXGG peptide +! accuracy=0.0025, rh2o=1.4, delete H, sele=(resn X) +! +! e.g. BB bead alanine +! +! BB = CA + C + N + O +! ASA_cg = 176.4940 +! Edesolv_aa = -1.8889 +! +! ASP_cg = -0.0107 +! +! Charleen Don (2012), JR (2014), Jorge Roel (2017) +! +! + +do (store1 = 0.0000) (name BB or name SC*) +! Backbone beads +do (store1 = -0.0107) (name BB and resn ALA) +do (store1 = -0.0089) (name BB and resn GLY) +do (store1 = -0.0153) (name BB and resn ILE) +do (store1 = -0.0158) (name BB and resn VAL) +do (store1 = -0.0046) (name BB and resn PRO) +do (store1 = -0.0137) (name BB and resn ASN) +do (store1 = -0.0147) (name BB and resn GLN) +do (store1 = -0.0165) (name BB and resn THR) +do (store1 = -0.0154) (name BB and resn SER) +do (store1 = -0.0130) (name BB and resn MET) +do (store1 = -0.0167) (name BB and resn CYS) +do (store1 = -0.0126) (name BB and resn PHE) +do (store1 = -0.0134) (name BB and resn TYR) +do (store1 = -0.0134) (name BB and resn TRP) +do (store1 = -0.0169) (name BB and resn ASP) +do (store1 = -0.0150) (name BB and resn GLU) +do (store1 = -0.0155) (name BB and resn HIS) +do (store1 = -0.0163) (name BB and resn LYS) +do (store1 = -0.0162) (name BB and resn ARG) + +! Side-chain beads +!do (store1 = 0.0000) (name SC* and resn ALA) +!do (store1 = 0.0000) (name SC* and resn GLY) +do (store1 = 0.0255) (name SC* and resn ILE) +do (store1 = 0.0222) (name SC* and resn VAL) +do (store1 = 0.0230) (name SC* and resn PRO) +do (store1 = -0.0192) (name SC* and resn ASN) +do (store1 = -0.0135) (name SC* and resn GLN) +do (store1 = -0.0009) (name SC* and resn THR) +do (store1 = -0.0056) (name SC* and resn SER) +do (store1 = 0.0202) (name SC* and resn MET) +do (store1 = 0.0201) (name SC* and resn CYS) +do (store1 = 0.1005) (name SC* and resn PHE) +do (store1 = 0.0669) (name SC* and resn TYR) +do (store1 = 0.0872) (name SC* and resn TRP) +do (store1 = -0.0360) (name SC* and resn ASP) +do (store1 = -0.0301) (name SC* and resn GLU) +do (store1 = 0.0501) (name SC* and resn HIS) +do (store1 = -0.0210) (name SC* and resn LYS) +do (store1 = -0.0229) (name SC* and resn ARG) + +! Fake beads +do (store1 = 0.0) (name SCD* and resn ASN) +do (store1 = 0.0) (name SCD* and resn GLN) +do (store1 = 0.0) (name SCD* and resn SER) +do (store1 = 0.0) (name SCD* and resn THR) +do (store1 = 0.0) (name SCD* and resn ARG) +do (store1 = 0.0) (name SCD* and resn LYS) +do (store1 = 0.0) (name SCD* and resn GLU) +do (store1 = 0.0) (name SCD* and resn ASP) + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/dna-rna_restraints.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/dna-rna_restraints.cns new file mode 100644 index 0000000000000000000000000000000000000000..feb27b3999cec077b4e20abd921dac061b7ded1f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/dna-rna_restraints.cns @@ -0,0 +1,424 @@ +! dna-rna_restraints.def +! Define backbone dihedral angles, hbonds and planarity restraints +! for nucleic acids +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +{+ file: dna-rna_restraints.def +} +{+ description: Creates restraints to maintain conformation of DNA/RNA +} +{+ Additions and changes were made to allow for flexibility during docking +} +{+ comment:This file is to be read by refinement files that modify atom coordinates +} +{+ authors: Axel T. Brunger, and Paul D. Adams +} +{+ modified by Alexandre Bonvin and Marc van Dijk for HADDOCK use +} + +{============================================== base planarity =============================================} + +{* Restrain base planarity. This selection must only include nucleotide residues *} +evaluate ($dna_bases_planar=true) + +{=================================== sugar-pucker dihedral angle restraints ================================} + +{* Pick the dihedral angles of the sugar pucker from the input structure + and restrain them within the given error range *} +evaluate ($dna_pick_pucdih=true) + +{* dihedral C1'-C2'-C3'-C4' error range *} +evaluate ($error_nu2=0.0) +{* dihedral C5'-C4'-C3'-C2' error range *} +evaluate ($error_nu3=0.0) +{* dihedral C1'-O4'-C4'-C5' error range *} +evaluate ($error_nu4=0.0) + +{================================ phosphate backbone dihedral angle restraints =============================} + +{* Pick the dihedral angles of the phosphate backbone from the input structure and + restrain them within the given error range *} +evaluate ($dna_pick_bacdih=true) + +{* Error range for phosphate backbone dihedrals *} +{* alpha dihedral O3'-P-O5'-C5' error range *} +evaluate ($error_alpha=10.0) +{* beta dihedral P-O5'-C5'-C4' error range *} +evaluate ($error_beta=40.0) +{* gamma dihedral O5'-C5'-C4'-C3' error range *} +evaluate ($error_gamma=20.0) +{* delta dihedral C5'-C4'-C3'-O3' error range *} +evaluate ($error_delta=50.0) +{* epsilon dihedral C4'-C3'-O3'-P error range *} +evaluate ($error_eps=10.0) +{* zeta dihedral C3'-O3'-P-O5' error range *} +evaluate ($error_zeta=50.0) + + +{=========================================== Watson-Crick base pairs =======================================} + +{* automatically pick Watson-Crick restraint values from structure *} +evaluate ($dna_pick_wc=true) + +{* error range used for dna_pick_wc defined Watson-Crick restraints *} +evaluate ($wc_low=0.05) +evaluate ($wc_up=0.05) + + +{=========================================== Coarse-Grained ===========================================================} +{* Is the DNA/RNA molecule CG? *} +evaluate ($dna_cg=false) + +{=========================================================================================================} +{ things below this line do not normally need to be changed } +{=========================================================================================================} + + +{- find max and min residue numbers -} +evaluate ($min_resid = 99999) +evaluate ($max_resid = -99999) +show sum(1) ( (resn DA or resn A or resn DG or resn G or resn DT or resn T or resn DC or resn C or resn U) and tag ) +if ( $result > 0 ) then + for $id in id ( (resn DA or resn A or resn DG or resn G or resn DT or resn T or resn DC or resn C or resn U) and tag ) loop resid + show (resid) ( id $id ) + evaluate ($resid=decode($result)) + evaluate ($min_resid = max($min_resid,$resid)) + evaluate ($max_resid = max($max_resid,$resid)) + end loop resid +end if + +{- the planarity restraints single bases -} +if ($dna_bases_planar=true) then + for $id in id ( tag and (resn DA or resn A or resn DG or resn G or resn DT or resn T or resn DC or resn C or resn U) ) loop plan + show (segid) (id $id) + evaluate ($segid=$result) + show (resid) (id $id) + evaluate ($resid=decode($result)) + evaluate ($plweight = 20) + + restraints plane + group + selection=( segid $segid and resid $resid and + (resn T or resn C or resn G or resn A or resn U or + resn DT or resn DC or resn DG or resn DA) and + not (name c#' or name h#' or name h#'' or name o#p or + name h7# or name o#' or name p or name h#t or name o#t)) + weight=$plweight + end + end + end loop plan +end if + +{- Dihedral restraints for the sugar pucker -} + +if ($dna_pick_pucdih=true) then + show sum(1) ( (resn DA or resn A or resn DG or resn G or resn DT or resn T or resn DC or resn C or resn U) and tag ) + if ( $result > 0 ) then + for $id in id ( (resn DA or resn A or resn DG or resn G or resn DT or resn T or resn DC or resn C or resn U) and tag ) loop resid + show (segid) (id $id) + evaluate ($segid=$result) + show (resid) ( id $id ) + evaluate ($resid=decode($result)) + pick dihedral + ( segid $segid and resid $resid and name c1' ) + ( segid $segid and resid $resid and name c2' ) + ( segid $segid and resid $resid and name c3' ) + ( segid $segid and resid $resid and name c4' ) + geometry + evaluatate ($dihedral_nu2=$result) + pick dihedral + ( segid $segid and resid $resid and name c5' ) + ( segid $segid and resid $resid and name c4' ) + ( segid $segid and resid $resid and name c3' ) + ( segid $segid and resid $resid and name c2' ) + geometry + evaluatate ($dihedral_nu3=$result) + pick dihedral + ( segid $segid and resid $resid and name c1' ) + ( segid $segid and resid $resid and name o4' ) + ( segid $segid and resid $resid and name c4' ) + ( segid $segid and resid $resid and name c5' ) + geometry + evaluatate ($dihedral_nu4=$result) + restraints dihedral + assign ( segid $segid and resid $resid and name c1' ) + ( segid $segid and resid $resid and name c2' ) + ( segid $segid and resid $resid and name c3' ) + ( segid $segid and resid $resid and name c4' ) + 20.0 $dihedral_nu2 $error_nu2 2 + assign ( segid $segid and resid $resid and name c5' ) + ( segid $segid and resid $resid and name c4' ) + ( segid $segid and resid $resid and name c3' ) + ( segid $segid and resid $resid and name c2' ) + 20.0 $dihedral_nu3 $error_nu3 2 + assign ( segid $segid and resid $resid and name c1' ) + ( segid $segid and resid $resid and name o4' ) + ( segid $segid and resid $resid and name c4' ) + ( segid $segid and resid $resid and name c5' ) + 20.0 $dihedral_nu4 $error_nu4 2 + scale=20.0 + end + end loop resid + flags include cdih end + end if +end if + +{- Dihedral restraints for the phosphate backbone -} + +if ($dna_pick_bacdih=true) then + show sum(1) ( (resn DA or resn A or resn DG or resn G or resn DT or resn T or resn DC or resn C or resn U) and tag ) + if ( $result > 0 ) then + evaluate ($resid=$min_resid) + evaluate ($nres=$max_resid - $min_resid + 1) + evaluate ($error_alpha=$error_alpha) + evaluate ($error_beta=$error_beta) + evaluate ($error_gamma=$error_gamma) + evaluate ($error_zeta=$error_zeta) + evaluate ($error_epsilon=$error_eps) + evaluate ($error_delta=$error_delta) + for $id in id ( (resn DA or resn A or resn DG or resn G or resn DT or resn T or resn DC or resn C or resn U) and tag ) loop resid + show (segid) (id $id) + evaluate ($segid=$result) + show (resid) ( id $id ) + evaluate ($resid=decode($result)) + if ($resid > $min_resid) then + evaluate ($rprec = $resid - 1) + ! check if previous residue exists + show sum(1) ( resid $rprec and tag ) + if ( $result > 0 ) then + pick dihedral + ( segid $segid and resid $rprec and name O3' ) + ( segid $segid and resid $resid and name P ) + ( segid $segid and resid $resid and name O5' ) + ( segid $segid and resid $resid and name C5' ) + geometry + evaluatate ($dihedral_alpha=$result) + pick dihedral + ( segid $segid and resid $resid and name P ) + ( segid $segid and resid $resid and name O5' ) + ( segid $segid and resid $resid and name C5' ) + ( segid $segid and resid $resid and name C4' ) + geometry + evaluatate ($dihedral_beta=$result) + restraint dihedral + ! alpha + assign ( segid $segid and resid $rprec and name O3' ) + ( segid $segid and resid $resid and name P ) + ( segid $segid and resid $resid and name O5' ) + ( segid $segid and resid $resid and name C5' ) + 1.0 $dihedral_alpha $error_alpha 2 + ! beta + assign ( segid $segid and resid $resid and name P ) + ( segid $segid and resid $resid and name O5' ) + ( segid $segid and resid $resid and name C5' ) + ( segid $segid and resid $resid and name C4' ) + 1.0 $dihedral_beta $error_beta 2 + scale 200.0 + end + end if + end if + + pick dihedral + ( segid $segid and resid $resid and name O5' ) + ( segid $segid and resid $resid and name C5' ) + ( segid $segid and resid $resid and name C4' ) + ( segid $segid and resid $resid and name C3' ) + geometry + evaluatate ($dihedral_gamma=$result) + pick dihedral + ( segid $segid and resid $resid and name C5' ) + ( segid $segid and resid $resid and name C4' ) + ( segid $segid and resid $resid and name C3' ) + ( segid $segid and resid $resid and name O3' ) + geometry + evaluatate ($dihedral_delta=$result) + + restraints dihedral + ! gamma + assign ( segid $segid and resid $resid and name O5' ) + ( segid $segid and resid $resid and name C5' ) + ( segid $segid and resid $resid and name C4' ) + ( segid $segid and resid $resid and name C3' ) + 1.0 $dihedral_gamma $error_gamma 2 + ! delta + assign ( segid $segid and resid $resid and name C5' ) + ( segid $segid and resid $resid and name C4' ) + ( segid $segid and resid $resid and name C3' ) + ( segid $segid and resid $resid and name O3' ) + 1.0 $dihedral_delta $error_delta 2 + scale=200.0 + end + + if ($resid < $max_resid) then + evaluate ($rfoll = $resid + 1) + ! check if next residue exists + show sum(1) ( resid $rfoll and segid $segid and tag ) + if ( $result > 0 ) then + pick dihedral + ( segid $segid and resid $resid and name C4' ) + ( segid $segid and resid $resid and name C3' ) + ( segid $segid and resid $resid and name O3' ) + ( segid $segid and resid $rfoll and name P ) + geometry + evaluatate ($dihedral_epsilon=$result) + pick dihedral + ( segid $segid and resid $resid and name C3' ) + ( segid $segid and resid $resid and name O3' ) + ( segid $segid and resid $rfoll and name P ) + ( segid $segid and resid $rfoll and name O5' ) + geometry + evaluatate ($dihedral_zeta=$result) + restraint dihedral + ! epsilon + assign ( segid $segid and resid $resid and name C4' ) + ( segid $segid and resid $resid and name C3' ) + ( segid $segid and resid $resid and name O3' ) + ( segid $segid and resid $rfoll and name P ) + 1.0 $dihedral_epsilon $error_epsilon 2 + ! zeta + assign ( segid $segid and resid $resid and name C3' ) + ( segid $segid and resid $resid and name O3' ) + ( segid $segid and resid $rfoll and name P ) + ( segid $segid and resid $rfoll and name O5' ) + 1.0 $dihedral_zeta $error_zeta 2 + scale 200.0 + end + end if + end if + end loop resid + flags include cdih end + end if +end if + +{- Watson-Crick base pairing -} + +if ($dna_pick_wc = true) then + evaluate ($hbcut = 3.5) + ! We only to check for ADE and CYT + show sum(1) ( (resn DA or resn A or resn DC or resn C) and tag ) + if ( $result > 0 ) then + noe + class hres + averaging hres cent + potential hres square + sqconstant hres 1. + sqexponent hres 2 + scale hres 70. + end + for $id in id ( (resn DA or resn A or resn DC or resn C) and tag ) loop resid + show (segid) (id $id) + evaluate ($segid=$result) + show (resid) ( id $id ) + evaluate ($resid=decode($result)) + evaluate ($presid=$resid-1) + evaluate ($fresid=$resid+1) + evaluate ($ares_name = none) + show ( resn ) (id $id) + evaluate ($ares=$result) + + if ( $ares = DA ) then + eval ($ares_name = ADE) + elseif ( $ares = A ) then + eval ($ares_name = ADE) + end if + + if ( $ares = DC ) then + eval ($ares_name = CYT) + elseif ( $ares = C ) then + eval ($ares_name = CYT) + end if + + if ($ares_name = ADE) then + show sum(1) ( ((resn DT or resn T or resn U) and not (resid $presid or resid $fresid) and name N3) + and (resid $resid and name N1) around $hbcut) + if ($result = 1) then + show (resid) ( ((resn DT or resn T or resn U) and not (resid $presid or resid $fresid) and name N3) + and (resid $resid and name N1) around $hbcut) + evaluate ($rpair = $result) + pick bond + (resid $resid and name N6) + (resid $rpair and name O4) + geometry + evaluate ($n6o4=$result) + pick bond + (resid $resid and name N1) + (resid $rpair and name N3) + geometry + evaluate ($n1n3=$result) + pick bond + (resid $resid and name N1) + (resid $rpair and name O4) + geometry + evaluate ($n1o4=$result) + pick bond + (resid $resid and name N1) + (resid $rpair and name O2) + geometry + evaluate ($n1o2=$result) + noe + assign (resid $resid and name N6) + (resid $rpair and name O4) + $n6o4 $wc_low $wc_up + assign (resid $resid and name N1) + (resid $rpair and name N3) + $n1n3 $wc_low $wc_up + assign (resid $resid and name N1) + (resid $rpair and name O4) + $n1o4 $wc_low $wc_up + assign (resid $resid and name N1) + (resid $rpair and name O2) + $n1o2 $wc_low $wc_up + end + end if + end if + + !find possible pairing for DC/C with DG/G + if ($ares_name = CYT) then + show sum(1) ( ((resn DG or resn G) and not (resid $presid or resid $fresid) and name N1) + and (resid $resid and name N3) around $hbcut) + if ($result = 1) then + show (resid) ( ((resn DG or resn G) and not (resid $presid or resid $fresid) and name N1) + and (resid $resid and name N3) around $hbcut) + evaluate ($rpair = $result) + pick bond + (resid $resid and name N3) + (resid $rpair and name N1) + geometry + evaluate ($n3n1=$result) + pick bond + (resid $resid and name N4) + (resid $rpair and name O6) + geometry + evaluate ($n4o6=$result) + pick bond + (resid $resid and name O2) + (resid $rpair and name N2) + geometry + evaluate ($o2n2=$result) + pick bond + (resid $resid and name N3) + (resid $rpair and name O6) + geometry + evaluate ($n3o6=$result) + pick bond + (resid $resid and name N3) + (resid $rpair and name N2) + geometry + evaluate ($n3n2=$result) + noe + assign (resid $resid and name N3) + (resid $rpair and name N1) $n3n1 $wc_low $wc_up + assign (resid $resid and name N4) + (resid $rpair and name O6) $n4o6 $wc_low $wc_up + assign (resid $resid and name O2) + (resid $rpair and name N2) $o2n2 $wc_low $wc_up + assign (resid $resid and name N3) + (resid $rpair and name O6) $n3o6 $wc_low $wc_up + assign (resid $resid and name N3) + (resid $rpair and name N2) $n3n2 $wc_low $wc_up + end + end if + end if + end loop resid + end if +end if diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/flex_segment_back.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/flex_segment_back.cns new file mode 100644 index 0000000000000000000000000000000000000000..31bbdd34d3d1c84ce03a999d66f036b3903ae3aa --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/flex_segment_back.cns @@ -0,0 +1,56 @@ +! flex_segment_back.cns +! Define the semi-flexible segments (both side-chains and backbone) +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +do (store5 = 0) (all) +do (store6 = 0) (all) + +!first flexible segments for docking +evaluate($nchain1 = 0) +while ($nchain1 < $data.ncomponents) loop nloop1 + evaluate($nchain1 = $nchain1 + 1) + evaluate($nf=0) + + if ($nseg$nchain1 = 0) then + display NO FLEXIBLE SEGMENTS for molecule $nchain1 + else + if ($nseg$nchain1 < 0) then + display AUTOMATIC DEFINITION OF FLEXIBLE SEGMENTS BASED ON INTERMOLECULAR PROXIMITY FOR MOLECULE $nchain1 + inline @MODULE:flexauto-neighbors.cns + else + display FLEXIBLE SIDE-CHAINS SEGMENTS for molecule $nchain1 + while ($nf < $nseg$nchain1) loop Xflex + evaluate($nf=$nf + 1) + do (store5 = $nchain1) ( resid $seg_sta_$nchain1_$nf : $seg_end_$nchain1_$nf + and segid $prot_segid_$nchain1) + display FLEXIBLE SEGMENT NR $nf FROM $seg_sta_$nchain1_$nf TO $seg_end_$nchain1_$nf + end loop Xflex + end if + end if +end loop nloop1 + +!then fully flexible segments for all stages +display NO FLEXIBLE SEGMENTS for all molecule at this stage +if ($nfle = 0) then + display NO FULLY FLEXIBLE SEGMENTS +else + evaluate($nf=0) + while ($nf < $nfle) loop Xfflex + evaluate($nf=$nf + 1) + do (store5 = 1) ( resid $fle_sta_$nf : $fle_end_$nf and segid $fle_seg_$nf ) + display FULLY FLEXIBLE SEGMENT NR $nf FROM $fle_sta_$nf TO $fle_end_$nf FOR CHAIN $fle_seg_$nf + end loop Xfflex +end if + +do (store5 = 21) (resn WAT or resn HOH or resn TIP*) + +do (store1 = 0) (all) +do (store1 = 1) ((resn WAT or resn HOH or resn TIP*) and name OH2) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/flex_segment_side.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/flex_segment_side.cns new file mode 100644 index 0000000000000000000000000000000000000000..b4985e3523a183a197a5e0f225bbb4b0e1393d58 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/flex_segment_side.cns @@ -0,0 +1,47 @@ + +!first flexible segments for docking +evaluate($nchain1 = 0) +while ($nchain1 < $data.ncomponents) loop nloop1 + evaluate($nchain1 = $nchain1 + 1) + evaluate($nf=0) + if ($nseg$nchain1 = 0) then + display NO FLEXIBLE SIDE-CHAINS SEGMENTS for molecule $nchain1 + else + if ($nseg$nchain1 < 0) then + display AUTOMATIC DEFINITION OF FLEXIBLE SEGMENTS BASED ON INTERMOLECULAR PROXIMITY FOR MOLECULE $nchain1 + inline @MODULE:flexauto-neighbors.cns + do (store5 = 0) (name CA or name BB or name C or name N or name O) + else + display FLEXIBLE SIDE-CHAINS SEGMENTS for molecule $nchain1 + while ($nf < $nseg$nchain1) loop Xflex + evaluate($nf=$nf + 1) + do (store5 = $nchain1) ( resid $seg_sta_$nchain1_$nf : $seg_end_$nchain1_$nf + and segid $prot_segid_$nchain1 + and not(name CA or name BB or name C or name N or name O) ) + display FLEXIBLE SIDE-CHAINS SEGMENT NR $nf FROM $seg_sta_$nchain1_$nf TO $seg_end_$nchain1_$nf + end loop Xflex + end if + end if +end loop nloop1 + +!then fully flexible segments for all stages + +!then fully flexible segments for all stages +display NO FLEXIBLE SEGMENTS for all molecule at this stage +if ($nfle = 0) then + display NO FULLY FLEXIBLE SEGMENTS +else + evaluate($nf=0) + while ($nf < $nfle) loop Xfflex + evaluate($nf=$nf + 1) + do (store5 = 1) ( resid $fle_sta_$nf : $fle_end_$nf and segid $fle_seg_$nf ) + display FULLY FLEXIBLE SEGMENT NR $nf FROM $fle_sta_$nf TO $fle_end_$nf FOR CHAIN $fle_seg_$nf + end loop Xfflex +end if + +do (store5 = 21) (resn WAT or resn HOH or resn TIP*) + +do (store1 = 0) (all) +do (store1 = 1) ((resn WAT or resn HOH or resn TIP*) and name OH2) +show sum (store1) ((resn WAT or resn HOH or resn TIP*)) + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/flexauto-neighbors.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/flexauto-neighbors.cns new file mode 100644 index 0000000000000000000000000000000000000000..f3fe74b83b0aa2a99d80a117239d87e052648b11 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/flexauto-neighbors.cns @@ -0,0 +1,42 @@ +! flexauto-neighbors.cns +! Automatic definition of flexible segments for docking for contacting residues +! including neighboring residues of residues making contacts +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +evaluate ($flcut = 5.0) + +do (store5 = $nchain1) (byres (segid $prot_segid_$nchain1 + and (not (segid $prot_segid_$nchain1 or resn SHA)) around $flcut)) + +do (store6 = 0) (segid $prot_segid_$nchain1) +for $id in id (tag and attr store5 >0 and not ((resn WAT or resn HOH or resn TIP*) or resn DMSO) and segid $prot_segid_$nchain1) loop flexres1 + show (resid) (id $id) + evaluate ($inres = decode($result)) + evaluate ($preres = $inres) + evaluate ($nexres = $inres) + evaluate ($preres = $preres - 1) + do (store6 = $nchain1) (resid $preres and segid $prot_segid_$nchain1) + do (store6 = $nchain1) (resid $nexres and segid $prot_segid_$nchain1) +end loop flexres1 + +do (store5 = store6) (segid $prot_segid_$nchain1) + +display THE FOLLOWING RESIDUES HAVE BEEN DEFINED AS FLEXIBLE for molecule $nchain1 +for $id in id (tag and attr store5 >0 and not ((resn WAT or resn HOH or resn TIP*) or resn DMSO) and segid $prot_segid_$nchain1) loop flexres2 + show (resid) (id $id) + evaluate ($inres = $result) + show (resn) (id $id) + evaluate ($nares = $result) + show (segid) (id $id) + evaluate ($seres = $result) + display AUTOMATICALLY SELECTED SEGMENT: $nares,$inres,$seres +end loop flexres2 + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/generate_dmso.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/generate_dmso.cns new file mode 100644 index 0000000000000000000000000000000000000000..2acdf950614511fcaac33db9ab7fa54cd478b947 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/generate_dmso.cns @@ -0,0 +1,121 @@ +! generate_dmso.cns +! Generate a DMSO solvent layer around the molecule +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * Originally adapted from Aria 1.2 from Nilges and Linge, EMBL. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +eval ($boxlength = 29.1) ! length of the dmso box +eval ($thickness = 12.5) ! maxi. initial dmso-protein distance (heavy atoms) +eval ($pw_dist = 2.4) ! mini. initial dmso-protein distance (heavy atoms) +eval ($dmso_diam = 4.1) ! diameter of dmso molecule +eval ($dyncount = 1) ! iteration number (usually 1) + +eval ($dmso = "DMS" + encode($dyncount)) + +!-------------------------------------------------- +! read in the same box of dmso several times, and move it around +! so as to cover all the space around the site of interest. +! take into account box offset + +show max (x) ((not resn dms) and not resn ANI and not resn DAN and not resn XAN or resn DUM or resn SHA) +evaluate ($xmax = $result) +show min (x) ((not resn DMS) and not resn ANI and not resn DAN and not resn XAN or resn DUM or resn SHA) +evaluate ($xmin = $result) + +show max (y) ((not resn DMS) and not resn ANI and not resn DAN and not resn XAN or resn DUM or resn SHA) +evaluate ($ymax = $result) +show min (y) ((not resn DMS) and not resn ANI and not resn DAN and not resn XAN or resn DUM or resn SHA) +evaluate ($ymin = $result) + +show max (z) ((not resn DMS) and not resn ANI and not resn DAN and not resn XAN or resn DUM or resn SHA) +evaluate ($zmax = $result) +show min (z) ((not resn DMS) and not resn ANI and not resn DAN and not resn XAN or resn DUM or resn SHA) +evaluate ($zmin = $result) + + +! loop over several iterations of dmso filling and dynamics + + +!-------------------------------------------------- +! read in the same box of dmso several times, and move it around +! so as to cover all the space around the site of interest. +! take into account box offset + + +! determine how many boxes are necessary in each dimension +eval ($xbox = int( ($xmax - $xmin + 2 * ($thickness + $dmso_diam)) / $boxlength + 0.5)) +eval ($ybox = int( ($ymax - $ymin + 2 * ($thickness + $dmso_diam)) / $boxlength + 0.5)) +eval ($zbox = int( ($zmax - $zmin + 2 * ($thickness + $dmso_diam)) / $boxlength + 0.5)) + +eval ($xmtran = $xmax + $thickness - $boxlength/2 + $dmso_diam) +eval ($ymtran = $ymax + $thickness - $boxlength/2 + $dmso_diam) +eval ($zmtran = $zmax + $thickness - $boxlength/2 + $dmso_diam) + +eval ($xcount=0) +eval ($xtrans = $xmin - $thickness - $dmso_diam - $boxlength ) +while ($xtrans < $xmtran) loop dms1 + eval ($xcount=$xcount+1) + eval ($xtrans = $xtrans + $boxlength) + + eval ($ycount=0) + eval ($ytrans = $ymin - $thickness - $dmso_diam - $boxlength ) + while ($ytrans < $ymtran) loop dms2 + eval ($ycount=$ycount+1) + eval ($ytrans = $ytrans + $boxlength) + + eval ($zcount=0) + eval ($ztrans = $zmin - $thickness - $dmso_diam - $boxlength ) + while ($ztrans < $zmtran) loop dms3 + eval ($zcount=$zcount+1) + eval ($ztrans = $ztrans + $boxlength) + + segment + name=" " + chain + coordinates @@TOPPAR:dmso.pdb + end + end + coor @@TOPPAR/dmso.pdb + do (segid=DMSO) (segid " ") + coor sele=(segid DMSO) translate vector = ($xtrans $ytrans $ztrans) end + + ! all new dmso oxygens + ident (store1) (segid DMSO and name sd) + ! all new dmso oxygens close to a protein heavy atom + ident (store2) (store1 and (not (resn DMS or resn ANI or resn DAN or resn XAN or resn DUM or resn SHA or hydro)) around $pw_dist) + ! all new dmso oxygens close to old dmso oxygens + ident (store3) (store1 and (segid DMS# and not hydro) around $dmso_diam) + ! all new dmso oxygens further than thickness away from a protein heavy atom + ident (store4) (store1 and not (not (resn DMS or resn ANI or resn DAN or resn XAN or resn DUM or resn SHA or hydro)) around $thickness) + delete sele= (byres (store2 or store3 or store4)) end + + + ! give dmso unique segid name + eval ($segid= "W" + encode($xcount) + encode($ycount) + encode($zcount)) + do (segid = $segid) (segid DMSO) + + end loop dms3 + end loop dms2 +end loop dms1 + +! now, give dmso a unique resid so that we get the segid to play around with +ident (store1) (all) +show min (store1) (segid w*) +do (store1 = store1 - $result + 1) (segid w*) +do (resid = encode(int(store1/3 -0.1) +1)) (segid w* and not segid DMS#) +do (segid = $dmso) (segid w* and not segid DMS#) + +! shave off any dmso that left +delete sele= (byres (name sd and not (not (resn DMS or resn ANI or resn DAN or resn XAN or resn DUM or resn SHA or hydro)) around $thickness)) end + +{* write out initial coordinates just for testing *} +!evaluate ($filename=$output_pdb_filename - ".pdb" + "wini.pdb") +!write coordinates sele= (all) output =$filename end + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/generate_water.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/generate_water.cns new file mode 100644 index 0000000000000000000000000000000000000000..3590ca25a9294d764d8b146cb1727408179b3b93 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/generate_water.cns @@ -0,0 +1,122 @@ +! generate_water.cns +! Generate a water solvent layer around the molecule +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * Originally adapted from Aria 1.2 from Nilges and Linge, EMBL. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +eval ($boxlength = 18.856) ! length of Brooks' water box +eval ($thickness = 8) ! maxi. initial water-protein distance (heavy atoms) +eval ($pw_dist = 2.4) ! mini. initial water-protein distance (heavy atoms) +eval ($water_diam = 2.4) ! diameter of water molecule +eval ($dyncount = 21) ! for water segid (max number of molecules + 1) + +eval ($water = "WA" + encode($dyncount)) + +!-------------------------------------------------- +! read in the same box of water several times, and move it around +! so as to cover all the space around the site of interest. +! take into account box offset + +show max (x) ((not (resn WAT or resn HOH or resn TIP*)) and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) +evaluate ($xmax = $result) +show min (x) ((not (resn WAT or resn HOH or resn TIP*)) and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) +evaluate ($xmin = $result) + +show max (y) ((not (resn WAT or resn HOH or resn TIP*)) and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) +evaluate ($ymax = $result) +show min (y) ((not (resn WAT or resn HOH or resn TIP*)) and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) +evaluate ($ymin = $result) + +show max (z) ((not (resn WAT or resn HOH or resn TIP*)) and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) +evaluate ($zmax = $result) +show min (z) ((not (resn WAT or resn HOH or resn TIP*)) and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) +evaluate ($zmin = $result) + + +! loop over several iterations of water filling and dynamics + +!-------------------------------------------------- +! read in the same box of water several times, and move it around +! so as to cover all the space around the site of interest. +! take into account box offset + + +! determine how many boxes are necessary in each dimension +eval ($xbox = int( ($xmax - $xmin + 2 * ($thickness + $water_diam)) / $boxlength + 0.5)) +eval ($ybox = int( ($ymax - $ymin + 2 * ($thickness + $water_diam)) / $boxlength + 0.5)) +eval ($zbox = int( ($zmax - $zmin + 2 * ($thickness + $water_diam)) / $boxlength + 0.5)) + +eval ($xmtran = $xmax + $thickness - $boxlength/2 + $water_diam) +eval ($ymtran = $ymax + $thickness - $boxlength/2 + $water_diam) +eval ($zmtran = $zmax + $thickness - $boxlength/2 + $water_diam) + +eval ($xcount=0) +eval ($xtrans = $xmin - $thickness - $water_diam - $boxlength/2 ) +while ($xtrans < $xmtran) loop wat1 + eval ($xcount=$xcount+1) + eval ($xtrans = $xtrans + $boxlength) + + eval ($ycount=0) + eval ($ytrans = $ymin - $thickness - $water_diam - $boxlength/2 ) + while ($ytrans < $ymtran) loop wat2 + eval ($ycount=$ycount+1) + eval ($ytrans = $ytrans + $boxlength) + + eval ($zcount=0) + eval ($ztrans = $zmin - $thickness - $water_diam - $boxlength/2 ) + while ($ztrans < $zmtran) loop wat3 + eval ($zcount=$zcount+1) + eval ($ztrans = $ztrans + $boxlength) + segment + name=" " + chain + coordinates @@TOPPAR:boxtyp20.pdb + end + end + coor @@TOPPAR:boxtyp20.pdb + do (segid=W000) (segid " ") + coor sele=(segid W000) translate vector = ($xtrans $ytrans $ztrans) end + + ! all new water oxygens + ident (store1) (segid W000 and name OH2) + ! all new water oxygens close to a protein heavy atom + ident (store2) (store1 and (not (resn WAT or resn HOH or resn TIP* + or resn ANI or resn DAN or resn XAN or resn DUM or resn SHA or hydro)) around $pw_dist) + ! all new water oxygens close to old water oxygens + ident (store3) (store1 and (segid wat# and not hydro) around $water_diam) + ! all new water oxygens further than thickness away from a protein heavy atom + ident (store4) (store1 and not (not (resn WAT or resn HOH or resn TIP* + or resn ANI or resn DAN or resn XAN or resn DUM or resn SHA or hydro)) around $thickness) + delete sele= (byres (store2 or store3 or store4)) end + + ! give waters unique segid name + eval ($segid= "W" + encode($xcount) + encode($ycount) + encode($zcount)) + do (segid = $segid) (segid W000) + + end loop wat3 + end loop wat2 +end loop wat1 + +! now, give waters a unique resid so that we get the segid to play around with +ident (store1) (all) +show min (store1) (segid w*) +do (store1 = store1 - $result + 1) (segid w*) +do (resid = encode(int(store1/3 -0.1) +1)) (segid w* and not segid wat#) +do (segid = $water) (segid w* and not segid wat#) + +! shave off any waters that left +delete sele= (byres (name oh2 and segid W* and + not (not (resn WAT or resn HOH or resn TIP* + or resn ANI or resn DAN or resn XAN or resn DUM or resn SHA or hydro)) around $thickness)) end + +{* write out initial coordinates just for testing *} +!evaluate ($filename=$output_pdb_filename - ".pdb" + "wini.pdb") +!write coordinates sele= (all) output =$filename end + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/mdref.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/mdref.cns new file mode 100644 index 0000000000000000000000000000000000000000..0c6a365a5d670322dc905723e02100df3df102fd --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/mdref.cns @@ -0,0 +1,616 @@ +! mdref.cns +! Perform an explitic solvent (water or dmso) refinement +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +if ( $log_level = "verbose" ) then + set message=all echo=on end +elseif ( $log_level = "normal" ) then + set message=normal echo=off end +else + set message=off echo=off end +end if + +!==================================================================! +! Initialisation of variables +!==================================================================! + +evaluate ($saprotocol.timestep=$timestep) +evaluate ($saprotocol.fbeta=100) +evaluate ($saprotocol.mass=100) + +evaluate ($ini_count =1) + +evaluate ($data.ncomponents=$ncomponents) + + +! non-bonded parameter set to use +evaluate ($toppar.par_nonbonded = "OPLSX") + + +! dihedrals, DNA and distance restraints +evaluate ($Data.dnarest =$dnarest_on) +evaluate ($Data.flags.cdih =$dihedrals_on) +evaluate ($Data.cdih.on =$dihedrals_on) +evaluate ($Data.ssdihed =$ssdihed) +evaluate ($Data.error_dih =$error_dih) +evaluate ($data.dihedrals.on=$dihedrals_on) +evaluate ($data.dihedrals_scale=$dihedrals_scale) + +! planarity restraints +evaluate ($Data.flags.plan = false) + +! distance restraints +evaluate ($Data.flags.noe = true) +evaluate ($data.randremoval=$randremoval) +evaluate ($data.npart=$npart) + +evaluate ($data.ambig_scale=$ambig_scale) +evaluate ($data.unambig_scale=$unambig_scale) +evaluate ($data.hbond_scale=$hbond_scale) + +evaluate ($data.cmrest=$cmrest) +evaluate ($data.cmtight=$cmtight) +evaluate ($data.kcm=$kcm) +evaluate ($data.contactairs=$contactairs) +evaluate ($data.kcont=$kcont) +if ($data.contactairs eq true) then + evaluate ($data.randremoval = false) +end if + +! NCS restraints +evaluate ($data.kncs = $kncs) +evaluate ($Data.flags.ncs = $ncs_on) +evaluate ($data.nncs = $nncs) + +! Symmetry restraints +evaluate ($data.ksym = $ksym) +evaluate ($Data.flags.sym = $sym_on) +evaluate ($data.nc2sym = $nc2sym) +evaluate ($data.nc3sym = $nc3sym) +evaluate ($data.ns3sym = $ns3sym) +evaluate ($data.nc4sym = $nc4sym) +evaluate ($data.nc5sym = $nc5sym) +evaluate ($data.nc6sym = $nc6sym) + +!Electrostatics: +evaluate ($Data.flags.dihed =$dihedflag) +evaluate ($Data.flags.elec =$elecflag) +evaluate ($Data.epsilon =$epsilon) +evaluate ($Data.dielec =$dielec) + +!Interaction matrix: +evaluate ($nmol1=1) +while ($nmol1 <=$data.ncomponents) loop mol1 + evaluate ($nmol2=$nmol1 + 1) + evaluate ($scale.int_$nmol1_$nmol1 =$int_$nmol1_$nmol1) + while ($nmol2 <=$data.ncomponents) loop mol2 + evaluate ($scale.int_$nmol1_$nmol2 =$int_$nmol1_$nmol2) + evaluate ($scale.int_$nmol2_$nmol1 =$int_$nmol1_$nmol2) + evaluate ($nmol2=$nmol2 + 1) + end loop mol2 + evaluate ($nmol1 = $nmol1 + 1) +end loop mol1 + + +! Unsupported restraints +evaluate ($Data.flags.em = false) +evaluate ($Data.flags.rg = false) +evaluate ($Data.flags.zres = false) +evaluate ($Data.flags.sani = false) +evaluate ($Data.flags.xrdc = false) +evaluate ($Data.flags.xpcs = false) +evaluate ($Data.flags.dani = false) +evaluate ($Data.flags.vean = false) + +! Other parameters +evaluate ($refine.keepwater = false) +evaluate ($refine.keepwater=$keepwater) +evaluate ($refine.solvent=$solvent) +evaluate ($refine.heatsteps=$waterheatsteps) +evaluate ($refine.steps=$watersteps) +evaluate ($refine.coolsteps=$watercoolsteps) + +!==================================================================! + +{* Read paramters and set various force field related variables *} + +@MODULE:read_param.cns + +parameter + bond (resn WAT ) (resn WAT ) 1000 TOKEN + angle (resn WAT ) (resn WAT ) (resn WAT ) 500 TOKEN + bond (resn HOH ) (resn HOH ) 1000 TOKEN + angle (resn HOH ) (resn HOH ) (resn HOH ) 500 TOKEN + bond (resn TIP*) (resn TIP*) 1000 TOKEN + angle (resn TIP*) (resn TIP*) (resn TIP*) 500 TOKEN +end + +igroup + interaction (not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) + (not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) weight * 1 end + interaction (resn ANI or resn DAN or resn XAN or resn DUM or resn DUM) + (resn ANI or resn DAN or resn XAN or resn DUM or resn DUM) weight * 1 vdw 0.0 elec 0.0 end + interaction (resn SHA) (not resn SHA) weight * 0 end +end + +flag include bond angle impr vdw end + +if ($Data.flags.dihed eq true) then + flag include dihed end +end if + +if ($Data.flags.elec eq true) then + flag include elec end + if ($Data.dielec eq "rdie") then + parameter nbonds eps=$Data.epsilon rdie shift switch end end + ! shift statement needed first to activate switch (CNS bug?) + else + parameter nbonds eps=$Data.epsilon cdie end end + end if + parameter nbonds ? end end +else + evaluate ($elec=0.0) + flag exclude elec end +end if + +coor copy end + +topology @@TOPPAR:solvent-allhdg5-4.top end + +if ($refine.solvent = "water") then + do (segid = "PROT") (segid " ") + @MODULE:generate_water.cns + do (segid = " ") (segid "PROT") +elseif ($refine.solvent = "dmso") then + do (segid = "PROT") (segid " ") + @MODULE:generate_dmso.cns + do (segid = " ") (segid "PROT") +end if + + +{* Read the distance restraints ================================ *} +set seed $seed end +set message=normal echo=on end +inline @MODULE:read_data.cns + +! random removal of restaints +if ($Data.randremoval eq true) then + noe cv $npart ? end +end if + +if ( $log_level = "verbose" ) then + set message=all echo=on end +elseif ( $log_level = "normal" ) then + set message=normal echo=off end +else + set message=off echo=off end +end if + + +evaluate ($numnoe = 0) + +!Make sure that at least as many distance restraints are successfully +!read as the number of partitions for cross-validation +evaluate ($numnoe = 999) +noe ? end +if ($NUMNOE = 0) then + evaluate ($Data.npart = 1) + evaluate ($Data.randremoval = FALSE) +end if + +if ($NUMNOE lt $Data.npart) then + noe part=1 end + evaluate ($Data.npart = 1) + evaluate ($Data.randremoval = FALSE) +end if + +noe + averaging * sum + potential * soft + scale * 1.0 + scale ambi $ambig_scale + scale dist $unambig_scale + scale hbon $hbond_scale + sqconstant * 1.0 + sqexponent * 2 + soexponent * 1 + rswitch * 0.5 + sqoffset * 0.0 + asymptote * 0.1 + msoexponent * 1 + masymptote * -0.1 + mrswitch * 0.5 +end + +{* set the energy flags ======================================================== *} + +inline @MODULE:setflags.cns + + +{* Check for other restraints ================================================== *} + +@MODULE:symmultimer.cns + +if ($Data.cmrest eq true ) then + @MODULE:cm-restraints.cns +end if + +if ($Data.contactairs eq true ) then + @MODULE:contactairs.cns +end if + +if ($Data.dnarest eq true ) then + @MODULE:dna-rna_restraints.cns +end if + +if ($Data.ssdihed eq "all" ) then + inline @MODULE:protein-ss-restraints-all.cns +end if +if ($Data.ssdihed eq "alpha" ) then + inline @MODULE:protein-ss-restraints-alpha.cns +end if +if ($Data.ssdihed eq "alphabeta" ) then + inline @MODULE:protein-ss-restraints-alpha-beta.cns +end if + + +{* Check for the presence of ions and add distance restraints / covalent bond == *} + +@MODULE:restrain-ions.cns + + +{* Energy minimisation of solvent first ============================================= *} + +! fix everything except the solvent for initial minimization +fix sele = (not (resn WAT or resn HOH or resn TIP* or resn DMS)) end + +if ($nemsteps > 0) then + minimize powell nstep=$nemsteps drop=100 end +end if + + +{* Energy minimisation with harmonic restraints on the molecules ==================== *} + +fix sele = (not all) end + +! fix the shape +fix sele = (resn SHA) end + +! fix rigid molecules +evaluate($nchain1 = 0) +while ($nchain1 < $data.ncomponents) loop nloop1 + evaluate($nchain1 = $nchain1 + 1) + evaluate($fcounter=0) + if ($nseg$nchain1 = 0) then + display NO FLEXIBLE SIDE-CHAINS SEGMENTS for molecule $nchain1 + display FIXING IT + fix sele = (segid $prot_segid_$nchain1 and not name H*) end + end if +end loop nloop1 + +do (refx=x) (all) +do (refy=y) (all) +do (refz=z) (all) + +! Define harmonic restraints on heavy atoms of molecules +restraints harmonic + exponent = 2 +end +do (harm = 0) (all) +do (harm = 5) (not name h* and not (resn WAT or resn HOH or resn TIP* or resn DMS)) + +igroup + interaction (not (resn ANI or resn DAN or resn XAN or resn SHA)) (not (resn ANI or resn DAN or resn XAN or resn SHA)) weight * 1 end + interaction (resn ANI or resn DAN or resn XAN) + (resn ANI or resn DAN or resn XAN) weight * 1 vdw 0.0 elec 0.0 end +end + +if ($nemsteps > 0) then + minimize powell nstep=$nemsteps drop=10 end +end if + + +{* MD refinement with harmonic restraints on the molecules ==================== *} + +do (refx=x) (all) +do (refy=y) (all) +do (refz=z) (all) + +! Define harmonic restraints on heavy atoms of molecules +do (harm = 0) (all) +do (harm = 5) (not name h* and not resn ANI and not resn DAN and not resn XAN and not (resn WAT or resn HOH or resn TIP3)) +do (harm = 20) (resn ANI and name OO) +do (harm = 20) (resn DAN and name OO) + +! Remove harmonic restraints on interface side-chains +@MODULE:flex_segment_side.cns +eval ($nchain1 = 0) +while ($nchain1 < $data.ncomponents) loop nloop1 + eval ($nchain1=$nchain1+1) + do (harm = 0) (attribute store5 = $nchain1 and + not ( name CA or name BB or name C or name N or name P or name C# or name C## )) +end loop nloop1 + + +! Start MD refinement + +do (mass =$Saprotocol.mass) (all) +do (mass=1000) (resn ANI or resn DAN or resn XAN) +do (fbeta = 0) (all) +do (fbeta = $Saprotocol.fbeta {1/ps} ) ( all ) + +! heat to 300 K +for $bath in (100 200 300) loop heat + + do (vx=maxwell($bath)) (all) + do (vy=maxwell($bath)) (all) + do (vz=maxwell($bath)) (all) + + dynamics cartesian + nstep=$refine.heatsteps timest=0.002{ps} + temperature=$bath tcoupling = true + nprint=50 + end + +end loop heat + +do (refx=x) (all) +do (refy=y) (all) +do (refz=z) (all) + +!define weaker harmonic restraints on heavy atoms of molecules +do (harm = 0) (all) +do (harm = 1) (not name h* and not resn ANI and not resn DAN and not resn XAN and not (resn WAT or resn HOH or resn TIP3)) + +!define flexible segments and remove harmonic restraints on backbone + side-chains of interface +@MODULE:flex_segment_back.cns +eval ($nchain1 = 0) +while ($nchain1 < $data.ncomponents) loop nloop1 + eval ($nchain1=$nchain1+1) + do (harm = 0) (attribute store5 = $nchain1) +end loop nloop1 +do (harm = 20) (resn ANI and name OO) +do (harm = 20) (resn DAN and name OO) + +! MD refinement +dynamics cartesian + nstep=$refine.steps timest=0.002{ps} + temperature=$bath tcoupling = true + nprint=50 +end + +do (refx=x) (all) +do (refy=y) (all) +do (refz=z) (all) + +! Define weak harmonic restraints on backbone only of molecules +do (harm = 0) (all) +do (harm = 1) (name CA or name BB or name C or name N or name P or name C# or name C##) +! Remove harmonic restraints on interface side-chains +@MODULE:flex_segment_side.cns +eval ($nchain1 = 0) +while ($nchain1 < $data.ncomponents) loop nloop1 + eval ($nchain1=$nchain1+1) + do (harm = 0) (attribute store5 = $nchain1) +end loop nloop1 +do (harm = 20) (resn ANI and name OO) +do (harm = 20) (resn DAN and name OO) + + +! cooling phase +for $bath in (300 200 100) loop cool + + dynamics cartesian + nstep=$refine.coolsteps timest=0.002{ps} + temperature=$bath tcoupling = true + nprint=50 + end + +end loop cool + + +! final minimization without harmonic restraints + +flag excl harm end + +if ($nemsteps > 0) then + minimize powell nstep=$nemsteps drop=10 end +end if + + +{* ======================= calculate free molecules internal energy *} + +igroup + interaction (not (resn ANI or resn DAN or resn XAN or resn SHA or resn WAT or resn HOH or resn TIP* or resn DUM)) + (not (resn ANI or resn DAN or resn XAN or resn SHA or resn WAT or resn HOH or resn TIP* or resn DUM)) weight * 1 end +end + +do (refx=x) (all) +do (refy=y) (all) +do (refz=z) (all) + +fix sele=(resn ANI or resn DAN or resn XAN or resn SHA or resn WAT or resn HOH or resn TIP* or resn DMS) end + +flag excl noe dani sani vean xrdc xpcs coll cdih zhar end +flag include bond angle dihe impr vdw end + +evaluate ($elec = 0.0) +evaluate ($eintfree = 0.0) +if ($Data.flags.elec eq true) then + flag include elec end +end if + +if ($Data.dielec eq "rdie") then + parameter nbonds eps=$Data.epsilon rdie shift switch end end + ! shift statement needed first to activate switch (CNS bug?) +else + parameter nbonds eps=$Data.epsilon cdie end end +end if +parameter nbonds ? end end +inline @MODULE:calc_free-ene.cns + +fix sele=(not all) end + +do (x = refx) (all) +do (y = refy) (all) +do (z = refz) (all) + + +{* ===================== calculate complex internal energy *} + +evaluate ($kinter = 1.0) +flag include bond angle dihe impr vdw end +energy end + +@MODULE:scale_intra_only.cns + +evaluate ($elec = 0.0) +evaluate ($eintcplx = 0.0) +if ($Data.flags.elec eq true) then + flag include elec end +end if + +energy end + +evaluate ($eintcplx = $bond + $angl + $impr + $dihe + $vdw + $elec) +evaluate ($ebond = $bond) +evaluate ($eangl= $angl) +evaluate ($eimpr= $impr) +evaluate ($edihe= $dihe) + +evaluate ($result=0) +print thres=0.05 bonds +evaluate ($rms_bonds=$result) +evaluate ($result=0) +print thres=5. angles +evaluate ($rms_angles=$result) +evaluate ($result=0) +print thres=5. impropers +evaluate ($rms_impropers=$result) +evaluate ($result=0) +print thres=30. dihedrals +evaluate ($rms_dihedrals=$result) + + +{* ===================== calculate final energies and write structure *} +evaluate ($cdih=0.0) +flag incl noe cdih end +if ($Data.ncomponents > 1) then + evaluate ($kinter = 1.0) + @MODULE:scale_inter_final.cns +else + @MODULE:scale_intra_only.cns +end if + +noe + scale dist $Data.unambig_scale + scale ambi $Data.ambig_scale + scale hbon $Data.hbond_scale + scale symm 0.0 + scale cont 0.0 +end +energy end +evaluate ($eair= $noe) + +evaluate ($esym = 0.0) +evaluate ($ncs = 0.0) +evaluate ($zhar = 0.0) +evaluate ($rms_test_noe = 0.0) +evaluate ($violations_test_noe = 0) +if ($Data.flags.sym eq true) then + ! calculatee first the symmetry energy + noe reset nres= 1200000 end + @MODULE:symmultimer.cns + noe + scale symm $Data.ksym + end + energy end + evaluate ($esym = $noe) + noe reset end + set seed=$seed end + !read back all the distance restraints: + @@MODULE:read_noes.cns + !random removal of restaints + if ($Data.randremoval eq true) then + noe cv $npart ? end + end if + noe + scale dist $Data.unambig_scale + scale ambi $Data.ambig_scale + scale hbon $Data.hbond_scale + end + print threshold=0.3 noe + evaluate ($rms_noe=$result) + evaluate ($violations_noe=$violations) + if ($Data.randremoval eq true) then + evaluate ($rms_test_noe=$test_rms) + evaluate ($violations_test_noe=$test_violations) + end if +else + print threshold=0.3 noe + evaluate ($rms_noe=$result) + evaluate ($violations_noe=$violations) + if ($Data.randremoval eq true) then + evaluate ($rms_test_noe=$test_rms) + evaluate ($violations_test_noe=$test_violations) + end if +end if + +if ($Data.dnarest eq true ) then + @MODULE:dna-rna_restraints.cns +end if + +energy end +evaluate ($etot = $ener - $noe) +evaluate ($noe = $eair) +evaluate ($etot = $etot + $noe) + +inline @MODULE:print_coorheader.cns + + +{* determine whether the final models should be reoriented along their principal *} +{* axes before writing to file ================================================= *} +eval($reorient = true) +evaluate ($ncount = 0) +while ($ncount < $data.ncomponents) loop orientmol + evaluate ($ncount = $ncount + 1) + eval($watersegname_$ncount="WA" + encode($ncount)) + if ($mol_fix_origin_$ncount eq true) then + eval($reorient = false) + end if +end loop orientmol + +if ($reorient = true) then + coor sele= (not name H* and not resn ANI and not resn XAN and not resn DAN) orient end +end if + +inline @MODULE:check_coordinates.cns + +if ($failure eq true) then + evaluate ($failfile = $output_pdb_filename - ".pdb" + ".fail") + set display=$failfile end + display "MAX/MIN possible coordinates exceeded - stopping" + close $failfile end + stop +else + write coordinates sele=(not (resn WA* or resn HOH or resn TIP* or resn DMS)) format=pdbo output=$output_pdb_filename end +end if + +if ($refine.keepwater eq true) then + evaluate ($filename= $output_pdb_filename - ".pdb" + "_solvent.pdb") + write coordinates sele=(all) format=pdbo output=$filename end +end if + +set message=normal echo=on end + +display OUTPUT: $output_pdb_filename + +stop + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/print_coorheader.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/print_coorheader.cns new file mode 100644 index 0000000000000000000000000000000000000000..1a06f68f63b409e44be920b6dada5a05ff1e762f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/print_coorheader.cns @@ -0,0 +1,308 @@ +! print_coorheader.cns +! Generate the coordinate header (REMARKS) +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * Originally adapted from Aria 1.2 from Nilges and Linge, EMBL. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +if ($Data.flags.dihed eq false) then evaluate ($dihe = 0) end if +if ($Data.flags.sani eq false) then evaluate ($sani = 0) end if +if ($Data.flags.xrdc eq false) then evaluate ($xrdc = 0) end if +if ($Data.flags.xpcs eq false) then evaluate ($xpcs = 0) end if +if ($Data.flags.dani eq false) then evaluate ($dani = 0) end if +if ($Data.flags.vean eq false) then evaluate ($vean = 0) end if +if ($Data.flags.cdih eq false) then evaluate ($cdih = 0) end if +if ($Data.flags.noe eq false) then evaluate ($noe = 0) end if +if ($Data.flags.rg eq false) then evaluate ($coll = 0) end if +if ($Data.flags.zres eq false) then evaluate ($zhar = 0) end if +if ($Data.flags.em eq false) then evaluate ($lcc = 0) end if + +evaluate($enerall=$etot) +evaluate($bondall=$ebond) +evaluate($anglall=$eangl) +evaluate($imprall=$eimpr) +evaluate($diheall=$edihe) +evaluate($vdwall=$vdw) +evaluate($elecall=$elec) +evaluate($noeall=$noe) +evaluate($rgall=$coll) +evaluate($zresall=$zhar) +evaluate($cdihall=$cdih) +evaluate($coupall=0) +evaluate($saniall=$sani+$xrdc) +evaluate($veanall=$vean) +evaluate($xpcsall=$xpcs) +evaluate($daniall=$dani) + +if ($Data.flags.sym eq true) then + evaluate ($result=0) + evaluate ($violations=0) + print threshold=0.3 noe + evaluate ($rms_noe=$result) + evaluate ($violations_noe=$violations) +end if + +if ($Data.randremoval eq false) then + evaluate ($violations_test_noe= 0) + evaluate ($rms_test_noe = 0) + evaluate ($npart = 0) +end if + +evaluate ($result=0) +evaluate ($violations=0) +print threshold=5. cdih +evaluate ($rms_cdih=$result) +evaluate ($violations_cdih=$violations) +evaluate ($result=0) +evaluate ($violations=0) +evaluate ($rms_coup = 0) +evaluate ($violations_coup = 0) + +evaluate( $rms_sani = 0) +evaluate( $violations_sani = 0) +if ($Data.flags.sani eq TRUE) then + sani print threshold = 0.20 class rd* end + evaluate( $rms_sani = $result) + evaluate( $violations_sani = $violations) +end if + +evaluate( $rms_xrdc = 0) +evaluate( $violations_xrdc = 0) +if ($Data.flags.xrdc eq TRUE) then + xrdc print threshold = 0.2 class xr* end + evaluate( $rms_xrdc = $result) + evaluate( $violations_xrdc = $violations) +end if + +evaluate( $violations_sani = $violations_sani + $violations_xrdc) +evaluate( $rms_sani = $rms_sani + $rms_xrdc) + +evaluate( $rms_xpcs = 0) +evaluate( $violations_xpcs = 0) +if ($Data.flags.xpcs eq TRUE) then + xpcs print threshold = 0.2 class pc* end + evaluate( $rms_xpcs = $result) + evaluate( $violations_xpcs = $violations) +end if + +evaluate( $rms_vean = 0) +evaluate( $violations_vean = 0) +if ($Data.flags.vean eq TRUE) then + vean print threshold = 5.00 class ve* end + evaluate( $rms_vean = $result) + evaluate( $violations_vean = $violations) +end if + +evaluate( $rms_dani = 0) +evaluate( $violations_dani = 0) +if ($Data.flags.dani eq TRUE) then + dani print threshold = 0.20 class da* end + evaluate( $rms_dani = $result) + evaluate( $violations_dani = $violations) +end if + +{====>} {* define ASA-based solvation parameters *} +inline @MODULE:def_solv_param.cns + +{====>} {* buried surface area and desolvation*} +evaluate ($nchain1 = 0) +evaluate ($saafree = 0) +evaluate ($esolfree = 0) +while ($nchain1 < $data.ncomponents) loop nloop1 + evaluate ($nchain1 = $nchain1 + 1) + {====>} {* buried surface area and desolvation*} + do (rmsd = 0) (all) + surface mode=access accu=0.075 rh2o=1.4 sele=(segid $prot_segid_$nchain1 and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) end + show sum (rmsd) (segid $prot_segid_$nchain1 and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) + evaluate ($saafree = $saafree + $result) + do (store2 = rmsd * store1) (segid $prot_segid_$nchain1 and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) + show sum (store2) (segid $prot_segid_$nchain1 and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) + evaluate ($esolfree = $esolfree + $result) +end loop nloop1 + +do (rmsd = 0) (all) +do (store2 = 0) (all) +surface mode=access accu=0.075 rh2o=1.4 sele=(not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) end +show sum (rmsd) (not ((resn WAT or resn HOH or resn TIP*) or resn DMS or resn SHA)) +evaluate ($satot = $result) +do (store2 = rmsd * store1) (not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) +show sum (store2) (not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) +evaluate ($esolcplx = $result) +evaluate ($saburied = $saafree - $satot) +if ($saburied < 0) then + evaluate ($saburied = -999999) +end if + +evaluate ($edesolv = $esolcplx - $esolfree) + +evaluate ($dhbinding = $edesolv + $eintcplx - $eintfree + $elecall + $vdwall) + +evaluate ($nshape = 0) +evaluate ($ncount = 0) +while ($ncount < $data.ncomponents) loop shape + evaluate ($ncount = $ncount + 1) + if ($mol_shape_$ncount eq true) then + evaluate ($nshape = $nshape + 1) + end if +end loop shape + +evaluate ($nonshape = $Data.ncomponents - $nshape) + +if ($nonshape = 1) then + evaluate ($saburied = 0) + evaluate ($edesolv = 0) + evaluate ($dhbinding = 0) + evaluate ($eintfree = $eintcplx) +end if + +if ($Data.flags.sym eq true) then + evaluate ($enerall = $enerall + $esym) +end if +if ($Data.flags.ncs eq true) then + evaluate ($enerall = $enerall + $ncs) +end if + +evaluate ($procwat = false) +if ($refine.keepwater eq true) then + evaluate ($procwat = true) +end if + +if ($procwat eq true) then + ident (store3) (not all) + flag exclude * include vdw elec end + + eval($nchain1 = 0) + + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + + igroup + interaction (segid $prot_segid_$nchain1) ((resn WAT or resn HOH or resn TIP* or resn DMS) and not store3) weight * 1.0 end + interaction (not segid $prot_segid_$nchain1) (resn WAT or resn HOH or resn TIP* or resn DMS) weight * 0.0 end + interaction (segid $prot_segid_$nchain1) (not ((resn WAT or resn HOH or resn TIP* or resn DMS) and store3)) weight * 0.0 end + end + energy end + evaluate ($ener_water_$nchain1 = $ener) + evaluate ($enerall = $enerall + $ener) + evaluate ($vdw_water_$nchain1 = $vdw) + evaluate ($elec_water_$nchain1 = $elec) + + end loop nloop1 + if ($data.ncomponents > 1) then + eval($nchain1 = $data.ncomponents) + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + evaluate ($ener_water_$nchain1 = 0.0) + evaluate ($vdw_water_$nchain1 = 0.0) + evaluate ($elec_water_$nchain1 = 0.0) + end loop nloop1 + end if + + eval($nchain1 = 0) + + igroup + while ($nchain1 < $data.ncomponents) loop nloop2 + eval($nchain1 = $nchain1 + 1) + interaction (segid $prot_segid_$nchain1) (all) weight * 0.0 end + end loop nloop2 + interaction ((resn WAT or resn HOH or resn TIP* or resn DMS) and not store3) + ((resn WAT or resn HOH or resn TIP* or resn DMS) and not store3) weight * 1.0 end + interaction (store3) (store3) weight * 0.0 end + interaction (resn SHA) (not resn SHA) weight * 0.0 end + interaction (resn SHA) (resn SHA) weight * 0.0 end + end + energy end + evaluate ($ener_water_water = $ener) + evaluate ($enerall = $enerall + $ener) + evaluate ($vdw_water_water = $vdw) + evaluate ($elec_water_water = $elec) +else + eval($nchain1 = 0) + + while ($nchain1 < $data.ncomponents ) loop nloop1 + eval($nchain1 = $nchain1 + 1) + evaluate ($ener_water_$nchain1 = 0.0) + evaluate ($vdw_water_$nchain1 = 0.0) + evaluate ($elec_water_$nchain1 = 0.0) + end loop nloop1 + evaluate ($ener_water_water = 0.0) + evaluate ($vdw_water_water = 0.0) + evaluate ($elec_water_water = 0.0) +end if + +! calculate the HADDOCK score +evaluate ($hscore = $w_vdw * $vdwall) +evaluate ($hscore = $hscore + $w_elec * $elecall) +evaluate ($hscore = $hscore + $w_air * $noeall) +evaluate ($hscore = $hscore + $w_rg * $rgall) +evaluate ($hscore = $hscore + $w_cdih * $cdihall) +evaluate ($hscore = $hscore + $w_sani * $saniall) +evaluate ($hscore = $hscore + $w_xpcs * $xpcsall) +evaluate ($hscore = $hscore + $w_dani * $daniall) +evaluate ($hscore = $hscore + $w_vean * $veanall) +evaluate ($hscore = $hscore + $w_sym * $esym) +evaluate ($hscore = $hscore + $w_bsa * $saburied) +evaluate ($hscore = $hscore + $w_desolv * $edesolv) +evaluate ($hscore = $hscore + $w_lcc * $lcc) + +set message=on echo=on end +set remarks=reset end +set remarks=accumulate end +remarks =============================================================== +remarks HADDOCK stats for $output_pdb_filename +remarks =============================================================== +remarks HADDOCK score: $hscore +remarks =============================================================== + +!list input molecules +evaluate ($nmol=1) +while ($nmol <=$data.ncomponents) loop mol + if ( $exist_input_pdb_filename_$nmol = true) then + remarks initial structure $nmol - $input_pdb_filename_$nmol + end if + evaluate ($nmol = $nmol + 1) +end loop mol + +remarks =============================================================== +remarks total,bonds,angles,improper,dihe,vdw,elec,air,cdih,coup,rdcs,vean,dani,xpcs,rg +remarks energies: $enerall, $bondall, $anglall, $imprall, $diheall, $vdwall, $elecall, $noeall, $cdihall, $coupall, $saniall, $veanall, $daniall, $xpcsall, $rgall +remarks =============================================================== +remarks bonds,angles,impropers,dihe,air,cdih,coup,rdcs,vean,dani,xpcs +remarks rms-dev.: $rms_bonds,$rms_angles,$rms_impropers,$rms_dihedrals,$rms_noe,$rms_cdih,$rms_coup, $rms_sani, $rms_vean, $rms_dani, $rms_xpcs +remarks =============================================================== +remarks air,cdih,coup,rdcs,vean,dani,xpcs +remarks >0.3,>5,>1,>0,>5,>0.2,>0.2 +remarks violations.: $violations_noe, $violations_cdih, $violations_coup, $violations_sani, $violations_vean, $violations_dani, $violations_xpcs +remarks =============================================================== +remarks CVpartition#,violations,rms +remarks AIRs cross-validation: $npart, $violations_test_noe, $rms_test_noe +remarks =============================================================== +remarks NCS energy: $ncs +remarks =============================================================== +remarks Symmetry energy: $esym +remarks =============================================================== +remarks Membrane restraining energy: $zresall +remarks =============================================================== +remarks Local cross-correlation: $lcc[f7.4] +remarks =============================================================== +remarks Desolvation energy: $edesolv +remarks Internal energy free molecules: $eintfree +remarks Internal energy complex: $eintcplx +remarks Binding energy: $dhbinding +remarks =============================================================== +remarks buried surface area: $saburied +remarks =============================================================== +set remark accumulate end +evaluate($ncount = 0) +while ($ncount < $data.ncomponents) loop waterremark + evaluate ($ncount = $ncount +1) + remarks water - chain_$ncount: $ener_water_$ncount $vdw_water_$ncount $elec_water_$ncount +end loop waterremark +remarks =============================================================== +remarks water - water: $ener_water_water $vdw_water_water $elec_water_water +remarks =============================================================== diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/protein-ss-restraints-all.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/protein-ss-restraints-all.cns new file mode 100644 index 0000000000000000000000000000000000000000..ce6537b77378451041f63bb9fb07cb9fce35b4d7 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/protein-ss-restraints-all.cns @@ -0,0 +1,88 @@ +! protein-ss-restraints-all.def +! Define automatically secondary stucture dihedral angle restraints for all residues +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +{+ file: protein-ss-restraints.def +} +{+ description: Creates dihedral angle restraints to maintain conformation of the protein backbone +} +{+ authors: Axel T. Brunger, and Paul D. Adams, +} +{+ modified by Alexandre Bonvin for HADDOCK use +} + +{=========================================================================================================} +{ things below this line do not normally need to be changed } +{=========================================================================================================} + +{- Dihedral restraints for the protein backbone -} +restraint dihedral + nass = 50000 +end +do (store1 = 1) (all) +evaluate ($group=1) +evaluate ($done=false) +while ( $done = false ) loop bdihe + if ( $exist_prot_segid_$group = true ) then + show sum(1) ( segid $prot_segid_$group ) + if ( $result > 0 ) then + evaluate ($error_phi=$Data.error_dih) + evaluate ($error_psi=$Data.error_dih) + for $id in id ( segid $prot_segid_$group and tag and not resn TIP3 ) loop resid + show (segid) (id $id) + evaluate ($segid=$result) + show (resid) ( id $id ) + evaluate ($resid=decode($result)) + evaluate ($rprec = $resid - 1) + show sum (store1) (resid $rprec and name C) + if ($result ne 0) then + evaluate ($rprec = $resid - 1) + pick dihedral + ( segid $segid and resid $rprec and name C ) + ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + geometry + evaluatate ($dihedral_phi=$result) + restraint dihedral + ! phi + assign ( segid $segid and resid $rprec and name C ) + ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + 1.0 $dihedral_phi $error_phi 2 + scale 200.0 + end + end if + evaluate ($rnext = $resid + 1) + show sum (store1) (resid $rnext and name N) + if ($result ne 0) then + pick dihedral + ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + ( segid $segid and resid $rnext and name N ) + geometry + evaluatate ($dihedral_psi=$result) + restraint dihedral + ! psi + assign ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + ( segid $segid and resid $rnext and name N ) + 1.0 $dihedral_psi $error_psi 2 + scale 200.0 + end + end if + end loop resid + end if + else + evaluate ($done=true) + end if + evaluate ($group=$group+1) +end loop bdihe + +flags include cdih end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/protein-ss-restraints-alpha-beta.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/protein-ss-restraints-alpha-beta.cns new file mode 100644 index 0000000000000000000000000000000000000000..0d6d8e4aa9b00b11bd201f8f9917a4628821978b --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/protein-ss-restraints-alpha-beta.cns @@ -0,0 +1,128 @@ +! protein-ss-restraints-alpha-beta.cns +! Define automatically secondary structure dihedral angle restraints +! for helical and beta-sheet segments +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +{+ file: protein-ss-restraints.def +} +{+ description: Creates dihedral angle restraints to maintain conformation of the protein backbone +} +{+ comment:This file is to be read by refinement files that modify atom coordinates +} +{+ authors: Axel T. Brunger, and Paul D. Adams +} +{+ modified by Alexandre Bonvin for HADDOCK use +} + +{=========================================================================================================} +{ things below this line do not normally need to be changed } +{=========================================================================================================} + +{- Dihedral restraints for the protein backbone in alpha-beta regions -} + +do (store1 = 1) (all) +restraint dihedral + nass = 50000 +end +evaluate ($group=1) +evaluate ($done=false) +while ( $done = false ) loop bdihe + if ( $exist_prot_segid_$group = true ) then + show sum(1) ( segid $prot_segid_$group ) + if ( $result > 0 ) then + evaluate ($error_phi=$Data.error_dih) + evaluate ($error_psi=$Data.error_dih) + for $id in id ( segid $prot_segid_$group and tag and not resn TIP* ) loop resid + show (segid) (id $id) + evaluate ($segid=$result) + show (resid) ( id $id ) + evaluate ($resid=decode($result)) + evaluate ($alphaphi = 0) + evaluate ($alphapsi = 0) + evaluate ($alpha_check = 0) + evaluate ($betaphi = 0) + evaluate ($betapsi = 0) + evaluate ($beta_check = 0) + evaluate ($rprec = $resid - 1) + show sum (store1) (resid $rprec and name C) + if ($result ne 0) then + pick dihedral + ( segid $segid and resid $rprec and name C ) + ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + geometry + evaluate ($dihedral_phi=$result) + evaluate ($alphaphi=max($dihedral_phi,-77)) + evaluate ($alphaphi=max($dihedral_phi,-37)) + if ($alphaphi eq -37) then + evaluate ($alpha_check = 1) + else + evaluate ($alpha_check = 0) + end if + evaluate ($betaphi=max($dihedral_phi,-145)) + evaluate ($betaphi=max($dihedral_phi,-105)) + if ($betaphi eq -105) then + evaluate ($beta_check = 1) + else + evaluate ($beta_check = 0) + end if + end if + evaluate ($rnext = $resid + 1) + show sum (store1) (resid $rnext and name N) + if ($result ne 0) then + pick dihedral + ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + ( segid $segid and resid $rnext and name N ) + geometry + evaluate ($dihedral_psi=$result) + evaluate ($alphapsi=max($dihedral_psi,-67)) + evaluate ($alphapsi=max($dihedral_psi,-27)) + if ($alphapsi eq -27) then + evaluate ($alpha_check = $alpha_check + 1) + end if + evaluate ($betapsi=max($dihedral_psi,105)) + evaluate ($betapsi=max($dihedral_psi,145)) + if ($betapsi eq 145) then + evaluate ($beta_check = $beta_check + 1) + end if + end if + evaluate ($defrest = 0) + if ($alpha_check eq 2) then + evaluate ($defrest = 1) + end if + if ($beta_check eq 2) then + evaluate ($defrest = 1) + end if + if ($defrest = 1) then + restraint dihedral + ! phi + assign ( segid $segid and resid $rprec and name C ) + ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + 1.0 $dihedral_phi $error_phi 2 + ! psi + assign ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + ( segid $segid and resid $rnext and name N ) + 1.0 $dihedral_psi $error_psi 2 + scale 200.0 + end + end if + end loop resid + end if + else + evaluate ($done=true) + end if + evaluate ($group=$group+1) +end loop bdihe + +flags include cdih end + + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/protein-ss-restraints-alpha.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/protein-ss-restraints-alpha.cns new file mode 100644 index 0000000000000000000000000000000000000000..38416657fc086d88a8288b50371b1f3e697103a8 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/protein-ss-restraints-alpha.cns @@ -0,0 +1,109 @@ +! protein-ss-restraints-alpha.cns +! Define automatically secondary structure dihedral angle restraints +! for helical segments +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +{+ file: protein-ss-restraints.def +} +{+ description: Creates dihedral angle restraints to maintain conformation of the protein backbone +} +{+ comment:This file is to be read by refinement files that modify atom coordinates +} +{+ authors: Axel T. Brunger, and Paul D. Adams +} +{+ modified by Alexandre Bonvin for HADDOCK use +} + +{=========================================================================================================} +{ things below this line do not normally need to be changed } +{=========================================================================================================} + +{- Dihedral restraints for the protein backbone in alpha-helical regions -} +restraint dihedral + nass = 50000 +end +do (store1 = 1) (all) +evaluate ($group=1) +evaluate ($done=false) +while ( $done = false ) loop bdihe + if ( $exist_prot_segid_$group = true ) then + show sum(1) ( segid $prot_segid_$group ) + if ( $result > 0 ) then + evaluate ($error_phi=$Data.error_dih) + evaluate ($error_psi=$Data.error_dih) + for $id in id (segid $prot_segid_$group and tag and not resn TIP3 ) loop resid + show (segid) (id $id) + evaluate ($segid=$result) + show (resid) ( id $id ) + evaluate ($resid=decode($result)) + evaluate ($alphaphi = 0) + evaluate ($alphapsi = 0) + evaluate ($alpha_check = 0) + evaluate ($rprec = $resid - 1) + show sum (store1) (resid $rprec and name C) + if ($result ne 0) then + pick dihedral + ( segid $segid and resid $rprec and name C ) + ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + geometry + evaluate ($dihedral_phi=$result) + evaluate ($alphaphi=max($dihedral_phi,-77)) + evaluate ($alphaphi=max($dihedral_phi,-37)) + if ($alphaphi eq -37) then + evaluate ($alpha_check = 1) + else + evaluate ($alpha_check = 0) + end if + end if + evaluate ($rnext = $resid + 1) + show sum (store1) (resid $rnext and name N) + if ($result ne 0) then + pick dihedral + ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + ( segid $segid and resid $rnext and name N ) + geometry + evaluate ($dihedral_psi=$result) + evaluate ($alphapsi=max($dihedral_psi,-67)) + evaluate ($alphapsi=max($dihedral_psi,-27)) + if ($alphapsi eq -27) then + evaluate ($alpha_check = $alpha_check + 1) + end if + end if + evaluate ($defrest = 0) + if ($alpha_check eq 2) then + evaluate ($defrest = 1) + end if + if ($defrest = 1) then + restraint dihedral + ! phi + assign ( segid $segid and resid $rprec and name C ) + ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + 1.0 $dihedral_phi $error_phi 2 + ! psi + assign ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + ( segid $segid and resid $rnext and name N ) + 1.0 $dihedral_psi $error_psi 2 + scale 200.0 + end + end if + end loop resid + end if + else + evaluate ($done=true) + end if + evaluate ($group=$group+1) +end loop bdihe + +flags include cdih end + + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/read_data.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/read_data.cns new file mode 100644 index 0000000000000000000000000000000000000000..0499183803224fbed8de2940b8499c9eb8f29d50 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/read_data.cns @@ -0,0 +1,81 @@ +! read_data.cns +! Read the various restraints data +! (distances and dihedral angles only in this version) +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +! Ambiguous and unambiguous distance restraints, hbonds +noe + reset + nrestraints = 12000000 ! allocate space for NOEs + ceiling 1000 +end + +evaluate ($filenam0 = $ambig_fname + "_" + encode($count)) +fileexist $filenam0 end +if ($result eq false) then + evaluate ($filenam0 = $ambig_fname) +end if + +if ($filenam0 # "") then + fileexist $filenam0 end + if ($result eq true) then + noe class ambi @@$filenam0 end + end if +end if + +if ($Data.randremoval eq true) then + noe part $Data.npart end +end if + +if ($unambig_fname # "") then + fileexist $unambig_fname end + if ($result eq true) then + noe class dist @@$unambig_fname end + end if +end if + +if ($hbond_fname # "") then + fileexist $hbond_fname end + if ($result eq true) then + noe class hbon @@$hbond_fname end + end if +end if + +noe + averaging * sum + potential * soft + scale * 1.0 + sqconstant * 1.0 + sqexponent * 2 + soexponent * 1 + rswitch * 1.0 + sqoffset * 0.0 + asymptote * 2.0 + msoexponent * 1 + masymptote * -0.1 + mrswitch * 1.0 +end + + +!dihedral restraints: +restraints dihedral + reset + nassign 50000 +end +if ($dihe_fname # "") then + fileexist $dihe_fname end + if ($result eq true) then + restraints dihedral + @@$dihe_fname + end + end if +end if + +restraints dihedral ? end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/read_noes.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/read_noes.cns new file mode 100644 index 0000000000000000000000000000000000000000..be5c0b8c55dbbd984e82a3fceb10553d0ee60281 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/read_noes.cns @@ -0,0 +1,65 @@ +! read_noes.cns +! Read the various restraints data +! In this version only distance-based restraints +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * Originally adapted from Aria 1.2 from Nilges and Linge, EMBL. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +! Ambiguous and unambiguous distance restraints, hbonds +noe + reset + nrestraints = 12000000 ! allocate space for NOEs + ceiling 1000 +end + +evaluate ($filenam0 = $ambig_fname + "_" + encode($count)) +fileexist $filenam0 end +if ($result eq false) then + evaluate ($filenam0 = $ambig_fname) +end if + +if ($filenam0 # "") then + fileexist $filenam0 end + if ($result eq true) then + noe class ambi @@$filenam0 end + end if +end if + +if ($Data.randremoval eq true) then + noe part $Data.npart end +end if + +if ($unambig_fname # "") then + fileexist $unambig_fname end + if ($result eq true) then + noe class dist @@$unambig_fname end + end if +end if + +if ($hbond_fname # "") then + fileexist $hbond_fname end + if ($result eq true) then + noe class hbon @@$hbond_fname end + end if +end if + +noe + averaging * sum + potential * soft + scale * 1.0 + sqconstant * 1.0 + sqexponent * 2 + soexponent * 1 + rswitch * 1.0 + sqoffset * 0.0 + asymptote * 2.0 + msoexponent * 1 + masymptote * -0.1 + mrswitch * 1.0 +end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/read_param.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/read_param.cns new file mode 100644 index 0000000000000000000000000000000000000000..6f549a453e49c118de295658c1294a8a429b9365 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/read_param.cns @@ -0,0 +1,64 @@ +! read_param.cns +! Reads parameter files. +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +!! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** + +{* protein parameter file *} +eval ($prot_parameter_infile="TOPPAR:protein-allhdg5-4.param") + +{* nucleic acid parameter file *} +eval ($nucl_parameter_infile="TOPPAR:dna-rna-allatom-hj-opls-1.3.param") + +{* carbohydrate parameter file *} +eval ($carbo_parameter_infile="TOPPAR:carbohydrate.param") + +{* solvent parameter file *} +eval ($solv_parameter_infile="TOPPAR:solvent-allhdg5-4.param") + +{* fragment probes parameter file *} +eval ($ligands_parameter_infile="TOPPAR:fragment_probes.param") + +{* ion parameter file *} +eval ($ion_parameter_infile="TOPPAR:ion.param") + +{* heme parameter file *} +eval ($heme_parameter_infile="TOPPAR:hemes-allhdg.param") + +{* shape parameter file *} +eval ($shape_parameter_infile="TOPPAR:shape.param") + +{* cofactors parameter file *} +eval ($cofactors_parameter_infile="TOPPAR:cofactors.param") + +parameter + @@$prot_parameter_infile + @@$ion_parameter_infile + @@$nucl_parameter_infile + @@$carbo_parameter_infile + @@$solv_parameter_infile + @@$ligands_parameter_infile + @@$heme_parameter_infile + @@$shape_parameter_infile + @@$cofactors_parameter_infile + if ($ligand_param_fname # "") then + fileexist $ligand_param_fname end + if ($result eq true) then + @@$ligand_param_fname + end if + end if +end + +parameter + nbonds + nbxmod=5 atom cdie shift + cutnb=9.5 ctofnb=8.5 ctonnb=6.5 eps=1.0 e14fac=0.4 inhibit 0.25 + wmin=0.5 tolerance 0.5 + end +end + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/restrain-ions.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/restrain-ions.cns new file mode 100644 index 0000000000000000000000000000000000000000..7ee0c904e818e09c8f233f7f44702444fbfc6cc4 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/restrain-ions.cns @@ -0,0 +1,109 @@ +! restrain-ions.cns +! distance restraints between an ion and any coordinating atom within 5A +! to maintain the coordination topologu +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +noe class dist end + +! first deal with monoatomic ions +evaluate ($pcount = 0) +for $id1 in id ( name "LI+1" or name "F-1" or name "NA+1" or name "MG+2" or name "AL+3" + or name "CL-1" or name "K+1" or name "CA+2" or name "V+2" or name "V+3" + or name "CR+2" or name "CR+3" or name "MN+2" or name "MN+3" or name "FE+2" + or name "FE+3" or name "NI+2" or name "CO+2" or name "CO+3" or name "CU+1" + or name "CU+2" or name "ZN+2" or name "BR-1" or name "SR+2" or name "MO+3" + or name "AG+1" or name "CD+2" or name "I-1" or name "CS+2" or name "HO+3" + or name "YB+2" or name "YB+3" or name "OS+4" or name "IR+3" or name "PT+2" + or name "AU+1" or name "AU+2" or name "HG+1" or name "HG+2" or name "PB+2" + or name "U+3" or name "U+4" or name "ZN+1" or name "ZN" ) loop sions + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + show (resname) (id $id1) + evaluate ($resname1=$result) + show (name) (id $id1) + evaluate ($name1=$result) + + evaluate ($mindis = 4.0) + for $id2 in id ( (name O* or name S* or name N*) and (id $id1) around $mindis and + (resn ACE or resn ALA or resn ALY or resn ARG or resn ASN or resn ASH or resn ASP or + resn CSP or resn CTN or resn CYC or resn CYF or resn CYM or resn CYS or resn DDZ or + resn GLN or resn GLH or resn GLU or resn GLY or resn HIS or resn HY3 or resn HYP or + resn ILE or resn LEU or resn LYS or resn M3L or resn MLY or resn MLZ or resn MET or + resn MSE or resn NEP or resn NME or resn PHE or resn PNS or resn PRO or resn PTR or + resn QSR or resn SEP or resn SER or resn THR or resn TOP or resn TRP or resn TYP or + resn TYR or resn TYS or resn VAL or resn A or resn C or resn G or resn T or + resn DA or resn DC or resn DG or resn DT or resn DJ )) loop search + + pick bond (id $id1) (id $id2) geometry + evaluate ($upper = $result) + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + show (name) (id $id2) + evaluate ($name2=$result) + + if ($segid1 eq $segid2) then + noe + assign (resid $resid1 and segid $segid1 and name $name1) + (resid $resid2 and segid $segid2 and name $name2) $upper 0.1 0.1 + end + end if + + end loop search + +end loop sions + +! then deal with multiatomic mions +evaluate ($pcount = 0) +for $id1 in id ( (resn SO4 or resn PO4 or resn WO4) and name O* ) loop mions + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + show (resname) (id $id1) + evaluate ($resname1=$result) + show (name) (id $id1) + evaluate ($name1=$result) + + evaluate ($mindis = 4.0) + for $id2 in id ( (name O* or name S* or name N*) and (id $id1) around $mindis and + (resn ACE or resn ALA or resn ALY or resn ARG or resn ASN or resn ASH or resn ASP or + resn CSP or resn CTN or resn CYC or resn CYF or resn CYM or resn CYS or resn DDZ or + resn GLN or resn GLH or resn GLU or resn GLY or resn HIS or resn HY3 or resn HYP or + resn ILE or resn LEU or resn LYS or resn M3L or resn MLY or resn MLZ or resn MET or + resn MSE or resn NEP or resn NME or resn PHE or resn PNS or resn PRO or resn PTR or + resn QSR or resn SEP or resn SER or resn THR or resn TOP or resn TRP or resn TYP or + resn TYR or resn TYS or resn VAL or resn A or resn C or resn G or resn T or + resn DA or resn DC or resn DG or resn DT or resn DJ )) loop search + + pick bond (id $id1) (id $id2) geometry + evaluate ($upper = $result) + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + show (name) (id $id2) + evaluate ($name2=$result) + + if ($segid1 eq $segid2) then + noe + assign (resid $resid1 and segid $segid1 and name $name1) + (resid $resid2 and segid $segid2 and name $name2) $upper 0.1 0.1 + end + end if + + end loop search + +end loop mions diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/scale_inter.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/scale_inter.cns new file mode 100644 index 0000000000000000000000000000000000000000..7088087a65b71bcdb213cce29d86ab6c043225e8 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/scale_inter.cns @@ -0,0 +1,45 @@ +! scale_inter.cns +! Scaling of intermolecular interactions +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +igroup interaction (not all) (not all) end + +igroup + + eval($nchain1 = 0) + + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + + interaction (segid $prot_segid_$nchain1 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) + (segid $prot_segid_$nchain1 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) weight * $scale.int_$nchain1_$nchain1 end + interaction (segid $prot_segid_$nchain1 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) + ((resn WAT or resn HOH or resn TIP* or resn DMS)) weight * 1.0 vdw $kinter elec $kinter end + + eval($nchain2 = $nchain1 ) + while ($nchain2 < $data.ncomponents) loop nloop2 + eval($nchain2 = $nchain2 + 1) + eval($scalfac = $kinter * $scale.int_$nchain1_$nchain2) + interaction (segid $prot_segid_$nchain1 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) + (segid $prot_segid_$nchain2 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) weight * 1.0 vdw $scalfac elec $scalfac end + end loop nloop2 + + end loop nloop1 + + interaction (resn ANI) (resn ANI) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DAN) (resn DAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn XAN) (resn XAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DUM) (resn DUM) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (resn SHA) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (not resn SHA) weight * 0.0 end + + interaction ((resn WAT or resn HOH or resn TIP* or resn DMS)) ((resn WAT or resn HOH or resn TIP* or resn DMS)) weight * 1.0 end + +end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/scale_inter_final.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/scale_inter_final.cns new file mode 100644 index 0000000000000000000000000000000000000000..efae5ce10a1fdafe1ef2f1d47a0ff9ebe57a1c8f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/scale_inter_final.cns @@ -0,0 +1,39 @@ +! scale_inter_final.cns +! Scaling of intermolecular interactions +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +igroup interaction (not all) (not all) end + +igroup + + eval($nchain1 = 0) + + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + eval($nchain2 = $nchain1 ) + while ($nchain2 < $data.ncomponents) loop nloop2 + eval($nchain2 = $nchain2 + 1) + eval($scalfac = $kinter * $scale.int_$nchain1_$nchain2) + interaction (segid $prot_segid_$nchain1 and not + (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA or resn DPP or resn PCW or resn PEE)) + (segid $prot_segid_$nchain2 and not + (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA or resn DPP or resn PCW or resn PEE)) weight * 1.0 vdw $scalfac elec $scalfac end + end loop nloop2 + + end loop nloop1 + + interaction (resn ANI) (resn ANI) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DAN) (resn DAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn XAN) (resn XAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DUM) (resn DUM) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (resn SHA) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (not resn SHA) weight * 0.0 end + +end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/scale_intra_only.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/scale_intra_only.cns new file mode 100644 index 0000000000000000000000000000000000000000..15b0adfbb562862214f161c494c14a17dbf6beb7 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/scale_intra_only.cns @@ -0,0 +1,36 @@ +! scale_intra_only.cns +! Scaling of intramolecular energies (no intermolecular energies) +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +igroup interaction (not all) (not all) end + +igroup + + eval($nchain1 = 0) + + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + + interaction (segid $prot_segid_$nchain1 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) + (segid $prot_segid_$nchain1 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) weight * 1.0 end + + end loop nloop1 + + interaction (resn ANI) (resn ANI) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DAN) (resn DAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn XAN) (resn XAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DUM) (resn DUM) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (resn SHA) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (not resn SHA) weight * 0.0 end + +end + + + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/setflags.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/setflags.cns new file mode 100644 index 0000000000000000000000000000000000000000..fd3e181f3cc822ca390f8d3f0ec6368c7305498b --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/setflags.cns @@ -0,0 +1,21 @@ +! setflags.cns +! Defines energy flags +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +if ($Data.flags.noe = TRUE) then + flags include noe end +end if +if ($Data.flags.cdih = TRUE) then + flags include cdih end +end if +if ($Data.flags.ncs = TRUE) then + flags include ncs end +end if diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/symmultimer.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/symmultimer.cns new file mode 100644 index 0000000000000000000000000000000000000000..3b4f731e948bf1d58eab0f71f457da6e52afc3e9 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/cns/symmultimer.cns @@ -0,0 +1,677 @@ +! symmultimer.cns +! Define symmetry restraints +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * Originally adapted from Aria 1.2 from Nilges and Linge, EMBL. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +if ($Data.flags.sym eq true) then + + noe class symm end + + ! Define C2 symmetry restraints for symmetrical multimers + ! + eval ($ncount = 0) + while ($ncount < $data.nc2sym) loop c2symloop + + eval ($ncount = $ncount + 1) + evaluate ($i1start = $c2sym_sta1_$ncount) + evaluate ($i1end = $c2sym_end1_$ncount) + evaluate ($chain1 = $c2sym_seg1_$ncount) + evaluate ($i2start = $c2sym_sta2_$ncount) + evaluate ($i2end = $c2sym_end2_$ncount) + evaluate ($chain2 = $c2sym_seg2_$ncount) + + !first check that the chain lengths are equal for the two defined molecules + evaluate ($diff1 = $i1end - $i1start) + evaluate ($diff2 = $i2end - $i2start) + if ($diff1 ne $diff2) then + display CHAIN LENGTH FOR SYMMETRY RESTRAINTS DOES NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + + eval ($icount = 0) + while ($i1start < $i1end) loop genc2sym + + evaluate ($resid1 = $i1start) + evaluate ($resid2 = $i2end - $icount) + evaluate ($resid3 = $i2start) + evaluate ($resid4 = $i1end - $icount) + + noe + assign (resid $resid1 and (name CA or name P or name BB) and segid $chain1) + (resid $resid2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resid3 and (name CA or name P or name BB) and segid $chain2) + (resid $resid4 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + end + + evaluate ($icount = $icount + 1) + evaluate ($i1start = $i1start + 1) + evaluate ($i2start = $i2start + 1) + + end loop genc2sym + + end loop c2symloop + + + ! Define C3 symmetry restraints for symmetrical multimers + ! + eval ($ncount = 0) + while ($ncount < $data.nc3sym) loop c3symloop + + eval ($ncount = $ncount + 1) + evaluate ($i1start = $c3sym_sta1_$ncount) + evaluate ($i1end = $c3sym_end1_$ncount) + evaluate ($chain1 = $c3sym_seg1_$ncount) + evaluate ($i2start = $c3sym_sta2_$ncount) + evaluate ($i2end = $c3sym_end2_$ncount) + evaluate ($chain2 = $c3sym_seg2_$ncount) + evaluate ($i3start = $c3sym_sta3_$ncount) + evaluate ($i3end = $c3sym_end3_$ncount) + evaluate ($chain3 = $c3sym_seg3_$ncount) + + !first check that the chain lengths are equal for the two defined molecules + evaluate ($diff1 = $i1end - $i1start) + evaluate ($diff2 = $i2end - $i2start) + evaluate ($diff3 = $i3end - $i3start) + if ($diff1 ne $diff2) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff1 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff2 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + + eval ($icount = 0) + while ($i1start < $i1end) loop genc3sym + + evaluate ($resst1 = $i1start) + evaluate ($resst2 = $i2start) + evaluate ($resst3 = $i3start) + evaluate ($resen1 = $i1end - $icount) + evaluate ($resen2 = $i2end - $icount) + evaluate ($resen3 = $i3end - $icount) + + noe + + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resen2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resen3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resen3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resen1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resen1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resen2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + + end + + evaluate ($icount = $icount + 2) + evaluate ($i1start = $i1start + 2) + evaluate ($i2start = $i2start + 2) + evaluate ($i3start = $i3start + 2) + + end loop genc3sym + + end loop c3symloop + + ! Define S3 symmetry restraints for symmetrical multimers + ! + eval ($ncount = 0) + while ($ncount < $data.ns3sym) loop s3symloop + + eval ($ncount = $ncount + 1) + evaluate ($i1start = $s3sym_sta1_$ncount) + evaluate ($i1end = $s3sym_end1_$ncount) + evaluate ($chain1 = $s3sym_seg1_$ncount) + evaluate ($i2start = $s3sym_sta2_$ncount) + evaluate ($i2end = $s3sym_end2_$ncount) + evaluate ($chain2 = $s3sym_seg2_$ncount) + evaluate ($i3start = $s3sym_sta3_$ncount) + evaluate ($i3end = $s3sym_end3_$ncount) + evaluate ($chain3 = $s3sym_seg3_$ncount) + + !first check that the chain lengths are equal for the two defined molecules + evaluate ($diff1 = $i1end - $i1start) + evaluate ($diff2 = $i2end - $i2start) + evaluate ($diff3 = $i3end - $i3start) + if ($diff1 ne $diff2) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff1 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff2 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + + eval ($icount = 0) + eval ($istep = 4) + eval ($istop = $i1end - $istep) + while ($i1start < $istop) loop gens3sym + + evaluate ($resst11 = $i1start) + evaluate ($resst21 = $i1start+1) + evaluate ($resst12 = $i2start) + evaluate ($resst22 = $i2start+1) + evaluate ($resst13 = $i3start) + evaluate ($resst23 = $i3start+1) + + + noe + + assign (resid $resst11 and (name CA or name P or name BB) and segid $chain1) + (resid $resst12 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resst12 and (name CA or name P or name BB) and segid $chain2) + (resid $resst13 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + + assign (resid $resst21 and (name CA or name P or name BB) and segid $chain1) + (resid $resst22 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resst22 and (name CA or name P or name BB) and segid $chain2) + (resid $resst23 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + + end + + evaluate ($icount = $icount + $istep) + evaluate ($i1start = $i1start + $istep) + evaluate ($i2start = $i2start + $istep) + evaluate ($i3start = $i3start + $istep) + + end loop gens3sym + + end loop s3symloop + + ! Define C4 symmetry restraints for symmetrical multimers + ! + eval ($istep = 10) + eval ($ncount = 0) + while ($ncount < $data.nc4sym) loop c4symloop + + eval ($ncount = $ncount + 1) + evaluate ($i1start = $c4sym_sta1_$ncount) + evaluate ($i1end = $c4sym_end1_$ncount) + evaluate ($chain1 = $c4sym_seg1_$ncount) + evaluate ($i2start = $c4sym_sta2_$ncount) + evaluate ($i2end = $c4sym_end2_$ncount) + evaluate ($chain2 = $c4sym_seg2_$ncount) + evaluate ($i3start = $c4sym_sta3_$ncount) + evaluate ($i3end = $c4sym_end3_$ncount) + evaluate ($chain3 = $c4sym_seg3_$ncount) + evaluate ($i4start = $c4sym_sta4_$ncount) + evaluate ($i4end = $c4sym_end4_$ncount) + evaluate ($chain4 = $c4sym_seg4_$ncount) + + !first check that the chain lengths are equal for the four defined molecules + evaluate ($diff1 = $i1end - $i1start) + evaluate ($diff2 = $i2end - $i2start) + evaluate ($diff3 = $i3end - $i3start) + evaluate ($diff4 = $i4end - $i4start) + if ($diff1 ne $diff2) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff1 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff1 ne $diff4) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff2 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff2 ne $diff4) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff3 ne $diff4) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + + eval ($icount = 0) + while ($i1start < $i1end) loop genc4sym + + evaluate ($resst1 = $i1start) + evaluate ($resst2 = $i2start) + evaluate ($resst3 = $i3start) + evaluate ($resst4 = $i4start) + evaluate ($resen1 = $i1end - $icount) + evaluate ($resen2 = $i2end - $icount) + evaluate ($resen3 = $i3end - $icount) + evaluate ($resen4 = $i4end - $icount) + + noe + + ! N to N sequential restraints to prevent anti-parallel arrangements + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resst2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resst3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resst3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resst4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resst4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resst1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resst1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resst2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + + ! N to C sequential restraints to assure planarity + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resen2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resen3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resen3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resen4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resen4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resen1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resen1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resen2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + + assign (resid $resen1 and (name CA or name P or name BB) and segid $chain1) + (resid $resst2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resen2 and (name CA or name P or name BB) and segid $chain2) + (resid $resst3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + + assign (resid $resen2 and (name CA or name P or name BB) and segid $chain2) + (resid $resst3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + assign (resid $resen3 and (name CA or name P or name BB) and segid $chain3) + (resid $resst4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + + assign (resid $resen3 and (name CA or name P or name BB) and segid $chain3) + (resid $resst4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + assign (resid $resen4 and (name CA or name P or name BB) and segid $chain4) + (resid $resst1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + + assign (resid $resen4 and (name CA or name P or name BB) and segid $chain4) + (resid $resst1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + assign (resid $resen1 and (name CA or name P or name BB) and segid $chain1) + (resid $resst2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + + end + + evaluate ($icount = $icount + $istep) + evaluate ($i1start = $i1start + $istep) + evaluate ($i2start = $i2start + $istep) + evaluate ($i3start = $i3start + $istep) + evaluate ($i4start = $i4start + $istep) + + end loop genc4sym + + end loop c4symloop + + + ! Define C5 symmetry restraints for symmetrical multimers + ! + eval ($istep = 4) + eval ($ncount = 0) + while ($ncount < $data.nc5sym) loop c5symloop + + eval ($ncount = $ncount + 1) + evaluate ($i1start = $c5sym_sta1_$ncount) + evaluate ($i1end = $c5sym_end1_$ncount) + evaluate ($chain1 = $c5sym_seg1_$ncount) + evaluate ($i2start = $c5sym_sta2_$ncount) + evaluate ($i2end = $c5sym_end2_$ncount) + evaluate ($chain2 = $c5sym_seg2_$ncount) + evaluate ($i3start = $c5sym_sta3_$ncount) + evaluate ($i3end = $c5sym_end3_$ncount) + evaluate ($chain3 = $c5sym_seg3_$ncount) + evaluate ($i4start = $c5sym_sta4_$ncount) + evaluate ($i4end = $c5sym_end4_$ncount) + evaluate ($chain4 = $c5sym_seg4_$ncount) + evaluate ($i5start = $c5sym_sta5_$ncount) + evaluate ($i5end = $c5sym_end5_$ncount) + evaluate ($chain5 = $c5sym_seg5_$ncount) + + !first check that the chain lengths are equal for the two defined molecules + evaluate ($diff1 = $i1end - $i1start) + evaluate ($diff2 = $i2end - $i2start) + evaluate ($diff3 = $i3end - $i3start) + evaluate ($diff4 = $i4end - $i4start) + evaluate ($diff5 = $i5end - $i5start) + if ($diff1 ne $diff2) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff1 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff2 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff3 ne $diff4) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff4 ne $diff5) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + + eval ($icount = 0) + while ($i1start < $i1end) loop genc5sym + + evaluate ($resst1 = $i1start) + evaluate ($resst2 = $i2start) + evaluate ($resst3 = $i3start) + evaluate ($resst4 = $i4start) + evaluate ($resst5 = $i5start) + evaluate ($resen1 = $i1end - $icount) + evaluate ($resen2 = $i2end - $icount) + evaluate ($resen3 = $i3end - $icount) + evaluate ($resen4 = $i4end - $icount) + evaluate ($resen5 = $i5end - $icount) + + noe + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resst3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resst4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resst4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resst5 and (name CA or name P or name BB) and segid $chain5) 0 0 0 + + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resst5 and (name CA or name P or name BB) and segid $chain5) 0 0 0 + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resst1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resst1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resst2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + + assign (resid $resst5 and (name CA or name P or name BB) and segid $chain5) + (resid $resst2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resst5 and (name CA or name P or name BB) and segid $chain5) + (resid $resst3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + + end + + evaluate ($icount = $icount + $istep) + evaluate ($i1start = $i1start + $istep) + evaluate ($i2start = $i2start + $istep) + evaluate ($i3start = $i3start + $istep) + evaluate ($i4start = $i4start + $istep) + evaluate ($i5start = $i5start + $istep) + + end loop genc5sym + + end loop c5symloop + + ! Define C6 symmetry restraints for symmetrical multimers + ! + eval ($istep = 10) + eval ($ncount = 0) + while ($ncount < $data.nc6sym) loop c6symloop + + eval ($ncount = $ncount + 1) + evaluate ($i1start = $c6sym_sta1_$ncount) + evaluate ($i1end = $c6sym_end1_$ncount) + evaluate ($chain1 = $c6sym_seg1_$ncount) + evaluate ($i2start = $c6sym_sta2_$ncount) + evaluate ($i2end = $c6sym_end2_$ncount) + evaluate ($chain2 = $c6sym_seg2_$ncount) + evaluate ($i3start = $c6sym_sta3_$ncount) + evaluate ($i3end = $c6sym_end3_$ncount) + evaluate ($chain3 = $c6sym_seg3_$ncount) + evaluate ($i4start = $c6sym_sta4_$ncount) + evaluate ($i4end = $c6sym_end4_$ncount) + evaluate ($chain4 = $c6sym_seg4_$ncount) + evaluate ($i5start = $c6sym_sta5_$ncount) + evaluate ($i5end = $c6sym_end5_$ncount) + evaluate ($chain5 = $c6sym_seg5_$ncount) + evaluate ($i6start = $c6sym_sta6_$ncount) + evaluate ($i6end = $c6sym_end6_$ncount) + evaluate ($chain6 = $c6sym_seg6_$ncount) + + !first check that the chain lengths are equal for the two defined molecules + evaluate ($diff1 = $i1end - $i1start) + evaluate ($diff2 = $i2end - $i2start) + evaluate ($diff3 = $i3end - $i3start) + evaluate ($diff4 = $i4end - $i4start) + evaluate ($diff5 = $i5end - $i5start) + evaluate ($diff6 = $i6end - $i6start) + if ($diff1 ne $diff2) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff1 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff2 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff3 ne $diff4) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff4 ne $diff5) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff5 ne $diff6) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + + eval ($icount = 0) + while ($i1start < $i1end) loop genc6sym + + evaluate ($resst1 = $i1start) + evaluate ($resst2 = $i2start) + evaluate ($resst3 = $i3start) + evaluate ($resst4 = $i4start) + evaluate ($resst5 = $i5start) + evaluate ($resst6 = $i6start) + evaluate ($resen1 = $i1end - $icount) + evaluate ($resen2 = $i2end - $icount) + evaluate ($resen3 = $i3end - $icount) + evaluate ($resen4 = $i4end - $icount) + evaluate ($resen5 = $i5end - $icount) + evaluate ($resen6 = $i6end - $icount) + + noe + + ! Around the C6 ring + ! N to N sequential restraints to prevent anti-parallel arrangements + + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resst2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resst3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resst3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resst4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resst4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resst5 and (name CA or name P or name BB) and segid $chain5) 0 0 0 + + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resst5 and (name CA or name P or name BB) and segid $chain5) 0 0 0 + assign (resid $resst5 and (name CA or name P or name BB) and segid $chain5) + (resid $resst6 and (name CA or name P or name BB) and segid $chain6) 0 0 0 + + assign (resid $resst5 and (name CA or name P or name BB) and segid $chain5) + (resid $resst6 and (name CA or name P or name BB) and segid $chain6) 0 0 0 + assign (resid $resst6 and (name CA or name P or name BB) and segid $chain6) + (resid $resst1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + + assign (resid $resst6 and (name CA or name P or name BB) and segid $chain6) + (resid $resst1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resst2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + + ! N to C sequential restraints to assure planarity + + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resen2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resen3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resen3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resen4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resen4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resen5 and (name CA or name P or name BB) and segid $chain5) 0 0 0 + + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resen5 and (name CA or name P or name BB) and segid $chain5) 0 0 0 + assign (resid $resst5 and (name CA or name P or name BB) and segid $chain5) + (resid $resen6 and (name CA or name P or name BB) and segid $chain6) 0 0 0 + + assign (resid $resst5 and (name CA or name P or name BB) and segid $chain5) + (resid $resen6 and (name CA or name P or name BB) and segid $chain6) 0 0 0 + assign (resid $resst6 and (name CA or name P or name BB) and segid $chain6) + (resid $resen1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + + ! Triples + + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resen3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resen5 and (name CA or name P or name BB) and segid $chain5) 0 0 0 + + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resen5 and (name CA or name P or name BB) and segid $chain5) 0 0 0 + assign (resid $resst5 and (name CA or name P or name BB) and segid $chain5) + (resid $resen1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resen4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resen6 and (name CA or name P or name BB) and segid $chain6) 0 0 0 + + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resen6 and (name CA or name P or name BB) and segid $chain6) 0 0 0 + assign (resid $resst6 and (name CA or name P or name BB) and segid $chain6) + (resid $resen2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + + end + + evaluate ($icount = $icount + $istep) + evaluate ($i1start = $i1start + $istep) + evaluate ($i2start = $i2start + $istep) + evaluate ($i3start = $i3start + $istep) + evaluate ($i4start = $i4start + $istep) + evaluate ($i5start = $i5start + $istep) + evaluate ($i6start = $i6start + $istep) + + end loop genc6sym + + end loop c6symloop + + + noe + potential symm symmetry + scale symm $Data.ksym + sqconstant symm 1.0 + sqexponent symm 2 + soexponent symm 1 + rswitch symm 0.5 + sqoffset symm 0.0 + asymptote symm 1.0 + end + +end if diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/defaults.yaml b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/defaults.yaml new file mode 100644 index 0000000000000000000000000000000000000000..270043c46a1f0ec6dd82cf3b874160e5dd9776e5 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/mdref/defaults.yaml @@ -0,0 +1,4751 @@ +# +# Group molecule +# +mol_fix_origin_1: + default: false + type: boolean + title: Fix molecule + short: Fixes the molecule in its original position. + long: Fixes the molecule in its original position. + group: 'molecule' + explevel: expert +mol_shape_1: + default: false + type: boolean + title: Is the molecule a shape? + short: Defines a molecule as a shape. + long: Defines a molecule as a shape, which is a collection of beads. + group: 'molecule' + explevel: easy +# +# Group distance restraints +# +ambig_fname: + default: '' + type: file + title: Ambiguous distance restraints filename + short: Filename of the ambiguous distance restraints file + long: Filename of the ambiguous distance restraints file. By default 50% of those restraints will be randomly discared. + This can be changed/turned off and is controlled by the randremoval and npart parameters. + Note that this file can contain both ambiguous and unambiguous restraints. + group: 'distance restraints' + explevel: easy +previous_ambig: + default: false + type: boolean + title: Boolean condition on the previous ambiguous distance restraints file + short: Boolean condition on the previous ambiguous distance restraints file. + If true, use the the restraint information coming from the previous CNS module. If false, don't use previous information. + long: Boolean condition on the ambiguous distance restraints file. + If true, use the restraint information coming from the previous CNS module, as long as an ambig_fname is not defined for the current module. + If false, don't use previous information. + group: 'distance restraints' + explevel: expert +unambig_fname: + default: '' + type: file + title: Unambiguous restraints filename + short: Filename of the unambiguous distance restraints file + long: Filename of the unambiguous distance restraints file. All restraints in that file will be used. + Note that this file can contain both ambiguous and unambiguous restraints. + group: 'distance restraints' + explevel: easy +hbond_fname: + default: '' + type: file + title: H-bond restraints filename + short: Filename of the hydrogen bond distance restraints file + long: Filename of the hydrogen bond distance restraints file. Note that this file can contain any type of distance restraints. + group: 'distance restraints' + explevel: easy +ambig_scale: + default: 50 + type: integer + min: 0 + max: 1000 + title: Force constant for ambiguous distance restraints + short: Force constant applied to the distance restraints defined in ambig_fname. + long: Force constant applied to the distance restraints defined in ambig_fname. + group: 'distance restraints' + explevel: expert +unambig_scale: + default: 50 + type: integer + min: 0 + max: 1000 + title: Force constant for unambiguous distance restraints + short: Force constant applied to the distance restraints defined in unambig_fname. + long: Force constant applied to the distance restraints defined in unambig_fname. + group: 'distance restraints' + explevel: expert +hbond_scale: + default: 50 + type: integer + min: 0 + max: 1000 + title: Force constant for hbonds distance restraints + short: Force constant applied to the distance restraints defined in hbond_fname. + long: Force constant applied to the distance restraints defined in hbond_fname. + group: 'distance restraints' + explevel: expert +randremoval: + default: true + type: boolean + title: Random removal of ambiguous restraints + short: If set to true (default) this will cause the random removal of ambiguous restraints for each model generated. + long: If set to true (default) this will cause the random removal of ambiguous restraints for each model generated. + The fraction of restraints randomly removed depends on the npart parameter which defines in how many sets the restraints should be randomly split. + The first set will be removed. The fraction of randomly removed ambiguous restraints is thus 1/npart. + group: 'distance restraints' + explevel: expert +npart: + default: 2 + type: integer + min: 1 + max: 20 + title: Number partitions for ambiguous restraints + short: Number of sets into which to randomly partition the ambiguous restraints. + long: Number of sets into which to randomly partition the ambiguous restraints. + The fraction of restraints randomly removed depends on the npart parameter which defines in how many sets the restraints should be randomly split. + The first set will be removed. The fraction of randomly removed ambiguous restraints is thus 1/npart. + group: 'distance restraints' + explevel: expert +contactairs: + default: false + type: boolean + title: Contact restraints + short: Contact restraints between molecules + long: Contact restraints between molecules. These are defined as ambiguous distance restraint + between each residue of a molecule and all residues of the other molecules with 5A from that residue. + This can be used to restraint the contacts between the interfaces. Note that this can generate a large number of ambiguous restraints + and slow down the computations + group: 'distance restraints' + explevel: expert +kcont: + default: 1.0 + type: float + min: 0 + max: 1000 + precision: 1 + title: Contact restraints force constant + short: Force constant applied to the contact restraints. + long: Force constant applied to the contact restraints. + group: 'distance restraints' + explevel: expert +cmrest: + default: false + type: boolean + title: Center of mass restraints + short: Automatically defines distance restraints between the geometric center of the various molecules. + long: When turned on, this option will automatically define center of mass restraints between the various molecules. + This allows HADDOCK to operate in ab-initio mode in the absence of any other restraints. But those restraints can also + be combined with other restraints to ensure more compact solutions. The distance restraints are defined between the + geometrical centers of the various molecules (calculated on CA atoms for proteins (BB in case of Martini coarse-grained + molecules) and N1 atoms for nucleic acids. For small ligands, all atoms will be used to define the geometric center. + The upper limit distance is automatically calculated based on the dimension of the molecules (see cmtight description). + group: 'distance restraints' + explevel: expert +cmtight: + default: true + type: boolean + title: Center of mass restraint tightness + short: Defines the upper distance limit based on the sum of the average dimension of the two molecule, + if cmtight=false all three dimensions are used, if set to true the shortest two only are used, + resulting in tighter distance restraints. + long: This parameter controls how the upper limit distance is defined for the center of mass restraints between molecules. + Each molecule is oriented along its principle components and the x,y and z dimensions are calculated. + If cmtight=true, the molecule distance (size) is set to the average of its smallest two half dimensions. + If cmtight=false, the molecule distance (size) is set to the average of its three half dimensions.. + In case of DNA or small ligands the molecule distance (size) is set to 0. + The effective upper distance limit for the center or mass distance restraint is the sum of the two molecule distances. + group: 'distance restraints' + explevel: expert +kcm: + default: 1.0 + type: float + min: 0 + max: 1000 + precision: 1 + title: Center of mass restraints force constant + short: Force constant applied to the center of mass restraints + long: Force constant applied to the center of mass restraints + group: 'distance restraints' + explevel: expert +# +# Group dihedral restraints +# +dihe_fname: + default: '' + type: file + title: Dihedral angle restraints filename + short: Filename of the Dihedral angle restraints file + long: Filename of the Dihedral angle restraints file. + group: 'dihedral restraints' + explevel: easy +dihedrals_on: + default: false + type: boolean + title: Use dihedral angle restraints + short: Turns on dihedral angle restraints. + long: Turns on dihedral angle restraints. Those should be defined in the dihe_fname file. + group: 'dihedral restraints' + explevel: easy +dihedrals_scale: + default: 200 + type: integer + min: 0 + max: 9999 + title: Force constant for dihedral angle restraints + short: Force constant applied to the dihedral angle restraints read from dihe_fname. + long: Force constant applied to the dihedral angle restraints read from dihe_fname. + group: 'dihedral restraints' + explevel: easy +ssdihed: + default: none + type: string + minchars: 0 + maxchars: 100 + choices: + - none + - all + - alpha + - alphabeta + title: Define automatically backbone dihedral angle restraints + short: If turned on, this option will automatically defined backbone dihedral angle restraints for the selected regions. + long: This option allows to utomatically defined backbone dihedral angle restraints for the selected regions. + The restraints will be defined for the phi and psi backbone dihedral angles of amino acids, with the target value taken from + the measured angle in the input structure, and the error bound defined by the error_dih parameter. + Those restraints can be applied to the entire structure (all), the alpha/beta secondary structure elements (alphabeta) or + only to the alpha helical regions (alpha). Those are automatically detected based on the measured dihedral angle combinations. + group: 'dihedral restraints' + explevel: easy +error_dih: + default: 10 + type: integer + min: 0 + max: 180 + title: Force constant for backbone dihedral angle restraints + short: Force constant for backbone dihedral angle restraints (ssdihed option) + long: Force constant for backbone dihedral angle restraints (ssdihed option) + group: 'dihedral restraints' + explevel: easy +# +# Group other restraints +# +dnarest_on: + default: false + type: boolean + title: Restrain the DNA conformation + short: Automatically creates restraints to maintain the conformation of DNA/RNA + long: "This option allows to restraint the conformation of nucleic acids based on the values from the input structures. + The following restraints will be automatically defined: + - single base planarity + - sugar pucker + - phosphate backbone diherdral angle restraints + - Watson-Crick base pairing" + group: 'other restraints' + explevel: easy +# +# Group symmetry +# +sym_on: + default: false + type: boolean + title: Symmetry restraints + short: Enables symmetry restraints + long: Enables symmetry restraints. The symmetry type (C2,C3,C4,C5,C6,S3 supported) + and the segments to which those apply must be defined. In addition a custom symmetry restraint file can be supplied (symrest_fname). + group: 'symmetry' + explevel: expert +ksym: + default: 10.0 + type: float + min: 0 + max: 1000 + precision: 1 + title: Force constant for symmetry restraints + short: Force constant for symmetry restraints + long: Force constant for symmetry restraints + group: 'symmetry' + explevel: expert +symtbl_fname: + default: '' + type: file + title: Custom symmetry restraints filename + short: Filename of the custom symmetry restraints file + long: Filename of the custom symmetry restraints file. + group: 'symmetry' + explevel: expert +nc2sym: + default: 0 + type: integer + min: 0 + max: 40 + title: Number of C2 symmetry restraints + short: Defines the number of C2 symmetry restraints. + long: Defines the number of C2 symmetry restraints. + For each, a pair of segments on which the symmetry restraint is applied will have to be defined. + Those must all have the same length. + group: 'symmetry' + explevel: hidden +c2sym_sta1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the first C2 symmetry segment + long: Residue number of first residue in the first C2 symmetry segment + group: 'symmetry' + explevel: expert +c2sym_end1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the first C2 symmetry segment + long: Residue number of last residue in the first C2 symmetry segment + group: 'symmetry' + explevel: expert +c2sym_seg1_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of first C2 segment + short: Segment ID of first C2 segment + long: Segment ID of first C2 segment + group: 'symmetry' + explevel: expert +c2sym_sta2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the second C2 symmetry segment + long: Residue number of first residue in the second C2 symmetry segment + group: 'symmetry' + explevel: expert +c2sym_end2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the second C2 symmetry segment + long: Residue number of last residue in the second C2 symmetry segment + group: 'symmetry' + explevel: expert +c2sym_seg2_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of second C2 segment + short: Segment ID of second C2 segment + long: Segment ID of second C2 segment + group: 'symmetry' + explevel: expert +nc3sym: + default: 0 + type: integer + min: 0 + max: 10 + title: Number of C3 symmetry restraints + short: Defines the number of C3 symmetry restraints. + long: Defines the number of C3 symmetry restraints. + For each, three segments on which the symmetry restraint is applied will have to be defined. + Those must all have the same length. + group: 'symmetry' + explevel: hidden +c3sym_sta1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the first C3 symmetry segment + long: Residue number of first residue in the first C3 symmetry segment + group: 'symmetry' + explevel: expert +c3sym_end1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the first C3 symmetry segment + long: Residue number of last residue in the first C3 symmetry segment + group: 'symmetry' + explevel: expert +c3sym_seg1_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of first C3 segment + short: Segment ID of first C3 segment + long: Segment ID of first C3 segment + group: 'symmetry' + explevel: expert +c3sym_sta2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the second C3 symmetry segment + long: Residue number of first residue in the second C3 symmetry segment + group: 'symmetry' + explevel: expert +c3sym_end2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the second C3 symmetry segment + long: Residue number of last residue in the second C3 symmetry segment + group: 'symmetry' + explevel: expert +c3sym_seg2_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of second C3 segment + short: Segment ID of second C3 segment + long: Segment ID of second C3 segment + group: 'symmetry' + explevel: expert +c3sym_sta3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the third C3 symmetry segment + long: Residue number of first residue in the third C3 symmetry segment + group: 'symmetry' + explevel: expert +c3sym_end3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the third C3 symmetry segment + long: Residue number of last residue in the third C3 symmetry segment + group: 'symmetry' + explevel: expert +c3sym_seg3_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of third C3 segment + short: Segment ID of third C3 segment + long: Segment ID of third C3 segment + group: 'symmetry' + explevel: expert +nc4sym: + default: 0 + type: integer + min: 0 + max: 10 + title: Number of C4 symmetry restraints + short: Defines the number of C4 symmetry restraints. + long: Defines the number of C4 symmetry restraints. + For each, four segments on which the symmetry restraint is applied will have to be defined. + Those must all have the same length. + group: 'symmetry' + explevel: hidden +c4sym_sta1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the first C4 symmetry segment + long: Residue number of first residue in the first C4 symmetry segment + group: 'symmetry' + explevel: expert +c4sym_end1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the first C4 symmetry segment + long: Residue number of last residue in the first C4 symmetry segment + group: 'symmetry' + explevel: expert +c4sym_seg1_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of first C4 segment + short: Segment ID of first C4 segment + long: Segment ID of first C4 segment + group: 'symmetry' + explevel: expert +c4sym_sta2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the second C4 symmetry segment + long: Residue number of first residue in the second C4 symmetry segment + group: 'symmetry' + explevel: expert +c4sym_end2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the second C4 symmetry segment + long: Residue number of last residue in the second C4 symmetry segment + group: 'symmetry' + explevel: expert +c4sym_seg2_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of second C4 segment + short: Segment ID of second C4 segment + long: Segment ID of second C4 segment + group: 'symmetry' + explevel: expert +c4sym_sta3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the third C4 symmetry segment + long: Residue number of first residue in the third C4 symmetry segment + group: 'symmetry' + explevel: expert +c4sym_end3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the third C4 symmetry segment + long: Residue number of last residue in the third C4 symmetry segment + group: 'symmetry' + explevel: expert +c4sym_seg3_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of third C4 segment + short: Segment ID of third C4 segment + long: Segment ID of third C4 segment + group: 'symmetry' + explevel: expert +c4sym_sta4_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the fourth C4 symmetry segment + long: Residue number of first residue in the fourth C4 symmetry segment + group: 'symmetry' + explevel: expert +c4sym_end4_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the fourth C4 symmetry segment + long: Residue number of last residue in the fourth C4 symmetry segment + group: 'symmetry' + explevel: expert +c4sym_seg4_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of fourth C4 segment + short: Segment ID of fourth C4 segment + long: Segment ID of fourth C4 segment + group: 'symmetry' + explevel: expert +nc5sym: + default: 0 + type: integer + min: 0 + max: 10 + title: Number of C5 symmetry restraints + short: Defines the number of C5 symmetry restraints. + long: Defines the number of C5 symmetry restraints. + For each, five segments on which the symmetry restraint is applied will have to be defined. + Those must all have the same length. + group: 'symmetry' + explevel: hidden +c5sym_sta1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the first C5 symmetry segment + long: Residue number of first residue in the first C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_end1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the first C5 symmetry segment + long: Residue number of last residue in the first C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_seg1_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of first C5 segment + short: Segment ID of first C5 segment + long: Segment ID of first C5 segment + group: 'symmetry' + explevel: expert +c5sym_sta2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the second C5 symmetry segment + long: Residue number of first residue in the second C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_end2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the second C5 symmetry segment + long: Residue number of last residue in the second C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_seg2_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of second C5 segment + short: Segment ID of second C5 segment + long: Segment ID of second C5 segment + group: 'symmetry' + explevel: expert +c5sym_sta3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the third C5 symmetry segment + long: Residue number of first residue in the third C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_end3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the third C5 symmetry segment + long: Residue number of last residue in the third C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_seg3_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of third C5 segment + short: Segment ID of third C5 segment + long: Segment ID of third C5 segment + group: 'symmetry' + explevel: expert +c5sym_sta4_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the fourth C5 symmetry segment + long: Residue number of first residue in the fourth C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_end4_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the fourth C5 symmetry segment + long: Residue number of last residue in the fourth C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_seg4_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of fourth C5 segment + short: Segment ID of fourth C5 segment + long: Segment ID of fourth C5 segment + group: 'symmetry' + explevel: expert +c5sym_sta5_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the fifth C5 symmetry segment + long: Residue number of first residue in the fifth C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_end5_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the fifth C5 symmetry segment + long: Residue number of last residue in the fifth C5 symmetry segment + group: 'symmetry' + explevel: expert +c5sym_seg5_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of fifth C5 segment + short: Segment ID of fifth C5 segment + long: Segment ID of fifth C5 segment + group: 'symmetry' + explevel: expert +nc6sym: + default: 0 + type: integer + min: 0 + max: 10 + title: Number of C6 symmetry restraints + short: Defines the number of C6 symmetry restraints. + long: Defines the number of C6 symmetry restraints. + For each, six segments on which the symmetry restraint is applied will have to be defined. + Those must all have the same length. + group: 'symmetry' + explevel: hidden +c6sym_sta1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the first C6 symmetry segment + long: Residue number of first residue in the first C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_end1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the first C6 symmetry segment + long: Residue number of last residue in the first C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_seg1_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of first C6 segment + short: Segment ID of first C6 segment + long: Segment ID of first C6 segment + group: 'symmetry' + explevel: expert +c6sym_sta2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the second C6 symmetry segment + long: Residue number of first residue in the second C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_end2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the second C6 symmetry segment + long: Residue number of last residue in the second C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_seg2_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of second C6 segment + short: Segment ID of second C6 segment + long: Segment ID of second C6 segment + group: 'symmetry' + explevel: expert +c6sym_sta3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the third C6 symmetry segment + long: Residue number of first residue in the third C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_end3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the third C6 symmetry segment + long: Residue number of last residue in the third C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_seg3_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of third C6 segment + short: Segment ID of third C6 segment + long: Segment ID of third C6 segment + group: 'symmetry' + explevel: expert +c6sym_sta4_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the fourth C6 symmetry segment + long: Residue number of first residue in the fourth C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_end4_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the fourth C6 symmetry segment + long: Residue number of last residue in the fourth C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_seg4_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of fourth C6 segment + short: Segment ID of fourth C6 segment + long: Segment ID of fourth C6 segment + group: 'symmetry' + explevel: expert +c6sym_sta5_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the fifth C6 symmetry segment + long: Residue number of first residue in the fifth C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_end5_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the fifth C6 symmetry segment + long: Residue number of last residue in the fifth C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_seg5_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of fifth C6 segment + short: Segment ID of fifth C6 segment + long: Segment ID of fifth C6 segment + group: 'symmetry' + explevel: expert +c6sym_sta6_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the sixth C6 symmetry segment + long: Residue number of first residue in the sixth C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_end6_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the sixth C6 symmetry segment + long: Residue number of last residue in the sixth C6 symmetry segment + group: 'symmetry' + explevel: expert +c6sym_seg6_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of sixth C6 segment + short: Segment ID of sixth C6 segment + long: Segment ID of sixth C6 segment + group: 'symmetry' + explevel: expert +ns3sym: + default: 0 + type: integer + min: 0 + max: 10 + title: Number of S3 symmetry restraints + short: Defines the number of S3 symmetry restraints. + long: Defines the number of S3 symmetry restraints. + For each, three segments on which the symmetry restraint is applied will have to be defined. + Those must all have the same length. + group: 'symmetry' + explevel: hidden +s3sym_sta1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the first S3 symmetry segment + long: Residue number of first residue in the first S3 symmetry segment + group: 'symmetry' + explevel: expert +s3sym_end1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the first S3 symmetry segment + long: Residue number of last residue in the first S3 symmetry segment + group: 'symmetry' + explevel: expert +s3sym_seg1_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of first S3 segment + short: Segment ID of first S3 segment + long: Segment ID of first S3 segment + group: 'symmetry' + explevel: expert +s3sym_sta2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the second S3 symmetry segment + long: Residue number of first residue in the second S3 symmetry segment + group: 'symmetry' + explevel: expert +s3sym_end2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the second S3 symmetry segment + long: Residue number of last residue in the second S3 symmetry segment + group: 'symmetry' + explevel: expert +s3sym_seg2_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of second S3 segment + short: Segment ID of second S3 segment + long: Segment ID of second S3 segment + group: 'symmetry' + explevel: expert +s3sym_sta3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the third S3 symmetry segment + long: Residue number of first residue in the third S3 symmetry segment + group: 'symmetry' + explevel: expert +s3sym_end3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the third S3 symmetry segment + long: Residue number of last residue in the third S3 symmetry segment + group: 'symmetry' + explevel: expert +s3sym_seg3_1: + default: '' + type: string + minchars: 0 + maxchars: 4 + title: Segment ID of third S3 segment + short: Segment ID of third S3 segment + long: Segment ID of third S3 segment + group: 'symmetry' + explevel: expert +ncs_on: + default: false + type: boolean + title: Non-crystallographic symmetry restraints + short: Non-crystallographic symmetry restraints to ensure two molecules will have the same conformation. + long: Non-crystallographic symmetry restraints to ensure two molecules will have the same conformation. + This does not apply any symmetry between the two molecules but rather defines restraints such as the RMSD between those is 0. + group: 'symmetry' + explevel: expert +kncs: + default: 1.0 + type: float + min: 0 + max: 1000 + precision: 1 + title: Force constant for non-crystallographic restraints + short: Force constant for non-crystallographic restraints + long: Force constant for non-crystallographic restraints + group: 'symmetry' + explevel: expert +nncs: + default: 0 + type: integer + min: 0 + max: 100 + title: Number of non-crystallographic symmetry restraints + short: Number of non-crystallographic symmetry restraints (NCS). + long: Number of non-crystallographic symmetry restraints. For each pairs of segments will have to be defined. + Note that those must contain exactly the same residues/atom combinations. + group: 'symmetry' + explevel: hidden +ncs_sta1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the first NCS segment + long: Residue number of first residue in the first NCS segment + group: 'symmetry' + explevel: expert +ncs_end1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the first NCS segment + long: Residue number of last residue in the first NCS segment + group: 'symmetry' + explevel: expert +ncs_seg1_1: + default: '' + type: string + minchars: 0 + maxchars: 100 + title: Segment ID of first NCS segment + short: Segment ID of first NCS segment + long: Segment ID of first NCS segment + group: 'symmetry' + explevel: expert +ncs_sta2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of first residue + short: Residue number of first residue in the second NCS segment + long: Residue number of first residue in the second NCS segment + group: 'symmetry' + explevel: expert +ncs_end2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Residue number of last residue + short: Residue number of last residue in the second NCS segment + long: Residue number of last residue in the second NCS segment + group: 'symmetry' + explevel: expert +ncs_seg2_1: + default: '' + type: string + minchars: 0 + maxchars: 100 + title: Segment ID of second NCS segment + short: Segment ID of second NCS segment + long: Segment ID of second NCS segment + group: 'symmetry' + explevel: expert +# +# Group scoring +# +w_air: + default: 0.1 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the distance restraint energy + short: Weight of the distance restraints energy in the scoring function + long: Weight of the distance restraints energy in the scoring function. + Note that this is different from the force constants used during the calculations. + group: 'scoring' + explevel: expert +w_bsa: + default: 0.0 + type: float + min: -9999 + max: 9999 + precision: 3 + title: Weight of the buried surface area term + short: Weight of the buried surface area term in the scoring function + long: Weight of the buried surface area (BSA) term in the scoring function. + Note that the BSA is only used for scoring. + group: 'scoring' + explevel: expert +w_cdih: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the dihedral angle restraint energy + short: Weight of the dihedral angle restraints energy in the scoring function + long: Weight of the dihedral angle restraints energy in the scoring function. + Note that this is different from the force constant used during the calculations. + group: 'scoring' + explevel: expert +w_dani: + default: 0.1 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the relaxation anisotropy (DANI) restraint energy + short: Weight of the relaxation anisotropy (DANI) restraint energy + long: Weight of the relaxation anisotropy (DANI) restraint energy + group: 'scoring' + explevel: hidden +w_deint: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the interaction energy term + short: Weight of the interaction energy term + long: Weight of the interaction energy term calculated as the difference in total energy of the complex and of the separate components + group: 'scoring' + explevel: hidden +w_desolv: + default: 1.0 + type: float + min: -9999 + max: 9999 + precision: 3 + title: Weight of the desolvation energy term + short: Weight of the desolvation energy term in the scoring function + long: Weight of the desolvation energy term in the scoring function. + Note that the desolvation energy is only used for scoring. + group: 'scoring' + explevel: expert +w_elec: + default: 0.2 + type: float + min: -9999 + max: 9999 + precision: 3 + title: Weight of the intermolecular electrostatic energy + short: Weight of the intermolecular electrostatic energy in the scoring function + long: Weight of the intermolecular electrostatic energy in the scoring function. + Note that this does not affect the electostatic energy during the MD refinement. + group: 'scoring' + explevel: expert +w_lcc: + default: -10000.0 + type: float + min: -10000.0 + max: 0 + precision: 3 + title: Weight of the EM local correlation coefficient + short: Weight of the EM local correlation coefficient + long: Weight of the EM local correlation coefficient + group: 'scoring' + explevel: hidden +w_rg: + default: 1.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the radius of gyration restraint energy + short: Weight of the radius of gyration restraint energy + long: Weight of the radius of gyration restraint energy + group: 'scoring' + explevel: hidden +w_sani: + default: 0.1 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the residual dipolar coupling (SANI) restraint energy + short: Weight of the residual dipolar coupling (SANI) restraint energy + long: Weight of the residual dipolar coupling (SANI) restraint energy + group: 'scoring' + explevel: hidden +w_sym: + default: 0.1 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the symmetry restraint energy + short: Weight of the symmetry restraints energy in the scoring function + long: Weight of the symmetry restraints energy in the scoring function. + Note that this is different from the force constant used during the calculations. + group: 'scoring' + explevel: expert +w_vdw: + default: 1.0 + type: float + min: -9999 + max: 9999 + precision: 3 + title: Weight of the intermolecular van der Waals energy + short: Weight of the intermolecular van der Waals energy in the scoring function + long: Weight of the intermolecular van der Waals energy in the scoring function. + Note that this does not affect the van der Waals energy during the MD refinement. + group: 'scoring' + explevel: expert +w_vean: + default: 0.1 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the residual dipolar coupling (VEAN) restraint energy + short: Weight of the residual dipolar coupling (VEAN) restraint energy + long: Weight of the residual dipolar coupling (VEAN) restraint energy + group: 'scoring' + explevel: hidden +w_xpcs: + default: 0.1 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the pseudo contact shifts (XPCS) restraint energy + short: Weight of the pseudo contact shifts (XPCS) restraint energy + long: Weight of the pseudo contact shifts (XPCS) restraint energy + group: 'scoring' + explevel: hidden +w_xrdc: + default: 0.1 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the residual dipolar coupling (XRDC) restraint energy + short: Weight of the residual dipolar coupling (XRDC) restraint energy + long: Weight of the residual dipolar coupling (XRDC) restraint energy + group: 'scoring' + explevel: hidden +w_zres: + default: 0.1 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the Z-restraining potential energy + short: Weight of the Z-restraining potential energy + long: Weight of the Z-restraining potential energy + group: 'scoring' + explevel: hidden +# +# Group force field +# +ligand_param_fname: + default: '' + type: file + title: Custom ligand parameter file + short: Ligand parameter file in CNS format + long: Ligand parameter file in CNS format containing all force field parameters + (bond, angles, dihedrals, impropers, van der waals) for any ligand not supported by default by HADDOCK + group: 'force field' + explevel: easy +ligand_top_fname: + default: '' + type: file + title: Custom ligand topology file + short: Ligand topology file in CNS format + long: Ligand topology file in CNS format containing the ligand topologies + (atoms, masses, charges, bond definitions...) for any ligand not supported by default by HADDOCK + group: 'force field' + explevel: easy +elecflag: + default: true + type: boolean + title: Include electrostatics energy + short: Include electrostatics energy during the calculations. + long: Include electrostatics energy during the calculations. If set to false electrostatics will not be considered. + group: 'force field' + explevel: easy +dielec: + default: cdie + type: string + minchars: 0 + maxchars: 4 + choices: + - cdie + - rdie + title: Constant (cdie) or distance-dependent dielectric (rdie) constant. + short: Use a constant (cdie option) or a distance-dependent dielectric (rdie) constant in the Coulomb potential. + long: Use a constant (cdie option) or a distance-dependent dielectric (rdie) constant in the Coulomb potential. + A distance dependent dielectric constant will effectively scale down the electrostatic energy + by having a 1/r**2 dependency instead of 1/r + group: 'force field' + explevel: expert +epsilon: + default: 1.0 + type: float + min: 1 + max: 78 + precision: 1 + title: Dielectric constant + short: Dielectric constant for the electrostatic Coulomb energy term. + long: Dielectric constant for the electrostatic Coulomb energy term. + group: 'force field' + explevel: expert +dihedflag: + default: true + type: boolean + title: Use torsion angle dihedral energy term + short: Turns on the torsion angle dihedral energy terms of the force field. + long: Turns on the torsion angle dihedral energy terms of the force field. + group: 'force field' + explevel: expert +# +# Group sampling +# +sampling_factor: + default: 1 + type: integer + min: 1 + max: 500 + title: Sampling factor for each starting model + short: This parameter control how many times a model will be refined. + long: This parameter control how many times a model will be refined. + group: 'sampling' + explevel: expert +max_nmodels: + default: 50000 + type: integer + min: 1 + max: 100000 + title: Maximum number of models to refine + short: This parameter controls the maximum number of models to refine. + long: This parameter controls the maximum number of models to refine. + group: 'sampling' + explevel: expert +solvent: + default: water + type: string + minchars: 0 + maxchars: 100 + choices: + - water + - dmso + title: Solvent + short: Solvent to use during the short MD refinement + long: Solvent to use during the short MD refinement. Water and DMSO are supported. + A solvent shelll is generated by shifting pre-equilibrated boxes around the complex. + For water an 8A water shell is generated and for DMSO a 12.5A shell. + For DMSO, + group: '' + explevel: easy +nemsteps: + default: 200 + type: integer + min: 0 + max: 10000 + title: Number of EM steps + short: Number of energy minimisation steps to perform. + long: Number of energy minimisation steps to perform in the various EM stages of this refinement protocol. + Note that the effective number might be smaller if the minimisation converges earlier. + group: 'sampling' + explevel: expert +timestep: + default: 0.002 + type: float + min: 0.0005 + max: 0.004 + precision: 4 + title: MD integrating time step + short: Integration time step for the molecular dynamics. + long: Integration time step for the molecular dynamics. + group: 'sampling' + explevel: guru +waterheatsteps: + default: 100 + type: integer + min: 0 + max: 10000 + title: Number of MD steps for the heating + short: Number of MD steps for the heating phase. + long: Number of MD steps for the heating phase. The heating consists of three successive + short molecular dynamics simluations at 100, 200 and 300 Kelvin. + group: 'sampling' + explevel: expert +watersteps: + default: 1250 + type: integer + min: 0 + max: 100000 + title: Number of MD steps at 300K. + short: Number of MD steps for 300K simulation. + long: Number of MD steps for 300K simulation. This is the sampling state of the refinement. + group: 'sampling' + explevel: expert +watercoolsteps: + default: 500 + type: integer + min: 0 + max: 10000 + title: Number of MD steps for the cooling + short: Number of MD steps for the cooling phase. + long: Number of MD steps for the cooling phase. The cooling consists of three successive + short molecular dynamics simluations at 300, 200 and 100 Kelvin. + group: 'sampling' + explevel: expert +iniseed: + default: 917 + type: integer + min: 0 + max: 9999999999999999 + title: Random seed + short: Random seed used in CNS to initialize the random seed function + long: Random seed used in CNS to initialize the random seed function + group: 'sampling' + explevel: guru +keepwater: + default: false + type: boolean + title: Write water molecules to output file + short: Write water molecules if present to the output file. + long: Write water molecules if present to the output file. + group: 'sampling' + explevel: guru +tolerance: + default: 5 + type: integer + min: 0 + max: 99 + precision: 3 + title: Failure tolerance percentage + short: Percentage of allowed failures for a module to successfully complete + long: Percentage of allowed failures for a module to successfully complete + group: 'module' + explevel: expert +log_level: + default: quiet + type: string + minchars: 0 + maxchars: 100 + choices: + - verbose + - normal + - quiet + title: Log level verbosity for CNS + short: Set the log level verbosity for CNS + long: CNS, the computational engine used by HADDOCK can generate a lot of output + messages. This parameter controls the verbosity of CNS (verbose, normal or quiet). + group: module + explevel: guru +# +# Group flexibility +# +# +# Semi-flexible segments +# +nseg1: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_1_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg2: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_2_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg3: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_3_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg4: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_4_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_4_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg5: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_5_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_5_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg6: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_6_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_6_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg7: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_7_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_7_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg8: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_8_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_8_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg9: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_9_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_9_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg10: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_10_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_10_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg11: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_11_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_11_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg12: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_12_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_12_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg13: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_13_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_13_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg14: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_14_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_14_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg15: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_15_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_15_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg16: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_16_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_16_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg17: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_17_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_17_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg18: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_18_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_18_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg19: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_19_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_19_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +nseg20: + default: -1 + type: integer + min: -1 + max: 1000 + title: Number of semi-flexible segments + short: This defines the number of semi-flexible segments (-1 automatic, 0 ridig, >1 manual definition). + long: This parameter defines the number of semi-flexible segments for the specified molecule. + If set to -1 then those are automatically defined based on contacts. Those can also be manually defined by defining the number of segment (nseg>=1). + In that case the starting and ending residues of each segment must be defined. The position of atoms in regions outside the semi-flexible regions + will have weak harmonic positional restraints during the energy minimisation. If nseg is set to 0, then the molecule will be kept ridig. + group: 'flexibility' + explevel: expert +seg_sta_20_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the semi-flexible segment. + long: Residue number defining the start of the semi-flexible segment. + group: 'flexibility' + explevel: expert +seg_end_20_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Ending residue number + short: Residue number defining the end of the semi-flexible segment. + long: Residue number defining the end of the semi-flexible segment. + group: 'flexibility' + explevel: expert +# +# Fully flexible segments +# +nfle: + default: 0 + type: integer + min: 0 + max: 1000 + title: Number of fully flexible segments + short: This defines the number of fully flexible segments. + long: This parameter defines the number of fully flexible segments for all molecules. + If >=1 then those must be defined manually with segment ID (segid) in the fle_seg_* variable, + followed by the starting and ending residue numbers in the fle_sta_* and fle_end_* variables. + group: 'flexibility' + explevel: hidden +fle_sta_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: Starting residue number + short: Residue number defining the start of the fully flexible segment. + long: Residue number defining the start of this (1st) fully flexible segment. + group: 'flexibility' + explevel: expert +fle_end_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: End residue number + short: Residue number defining the end of the fully flexible segment. + long: Residue number defining the end of this (1st) fully flexible segment. + group: 'flexibility' + explevel: expert +fle_seg_1: + default: none + type: string + minchars: 1 + maxchars: 4 + title: Segment ID (segid) + short: Segment ID of the molecule for which this flexible segment is defined. + long: Segment ID of the molecule for which this (1st) flexible segment is defined. + group: 'flexibility' + explevel: expert +# +# Group interaction matrix +# +int_1_1: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_2: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_3: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_4: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_5: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_6: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_7: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_8: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_9: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_1_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_2: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_3: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_4: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_5: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_6: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_7: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_8: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_9: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_2_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_3: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_4: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_5: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_6: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_7: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_8: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_9: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_3_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_4: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_5: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_6: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_7: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_8: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_9: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_4_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_5: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_6: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_7: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_8: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_9: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_5_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_6: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_7: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_8: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_9: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_6_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_7: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_8: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_9: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_8: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_9: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_7_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_8_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_9: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_9_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_10: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_10_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_11: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_11_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_12_12: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_12_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_12_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_12_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_12_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_12_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_12_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_12_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_12_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_13_13: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_13_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_13_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_13_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_13_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_13_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_13_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_13_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_14_14: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_14_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_14_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_14_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_14_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_14_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_14_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_15_15: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_15_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_15_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_15_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_15_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_15_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_16_16: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_16_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_16_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_16_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_16_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_17_17: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_17_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_17_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_17_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_18_18: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_18_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_18_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_19_19: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_19_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden +int_20_20: + default: 1.0 + type: float + min: 0 + max: 1 + precision: 3 + title: Scaling factor for intermolecular energies + short: Scaling factor for intermolecular energies + long: Scaling factor for intermolecular energies between the two molecules. + This can be used for example in ensemble docking to have two molecules binding to the same site without seeing eachother. + group: 'interaction matrix' + explevel: hidden diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/openmm/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/openmm/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2a2f85af1dc9c08c4c841a14689fb58c3a64ad9c --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/openmm/__init__.py @@ -0,0 +1,181 @@ +"""OpenMM Molecular Dynamics refinement module for HADDOCK3. + +The potential of OpenMM can be exploited to perform potentially different +tasks, such as: + +* Run MD simulation for each model from previous step; +* Refine the models in the middle of a docking run. For example, it can be used + to refine the models coming from a `[rigidbody]` module before `[flexref]` is + executed, or to replace the `[mdref]` step. +* Generate conformers prior to their use in a thorough docking run. + +To get a list of all possible parameters, run: + +>>> haddock3-cfg -m openmm + +Module workflow: + +* Generate openmm topology and fix atoms +* Build solvation box +* Equilibration solvation box restraining the protein +* Run MD simulation: increase temperature, run MD, reduce temperature. +* Either generate an ensemble of multiple frames or return the last frame. + +This module will refine all models coming from the previous workflow step and +send them to the next step in the workflow. If you want to use other modules +such as `flexref` or `emref` after the OpenMM module, you need to recreate the +topologies by simply adding a `[topoaa]` step in the workflow. +See examples in `examples/thirdparty/openmm` folder. +""" +import os +import shutil + +from contextlib import suppress +from pathlib import Path +from subprocess import run as subprocrun + +from haddock.core.defaults import MODULE_DEFAULT_YAML +from haddock.core.exceptions import ThirdPartyIntallationError +from haddock.libs.libontology import PDBFile +from haddock.modules import BaseHaddockModule, get_engine + +# allow general testing when OpenMM is not installed +with suppress(ImportError): + from haddock.modules.refinement.openmm.openmm import OPENMM + + +RECIPE_PATH = Path(__file__).resolve().parent +DEFAULT_CONFIG = Path(RECIPE_PATH, MODULE_DEFAULT_YAML) + + +class HaddockModule(BaseHaddockModule): + """HADDOCK3 OpenMM module.""" + + name = RECIPE_PATH.name + + def __init__(self, order, path, initial_params=DEFAULT_CONFIG): + super().__init__(order, path, initial_params) + + def create_directories(self) -> dict[str, str]: + """Create the necessary directories and provides the paths.""" + directory_list = ( + "pdbfixer", + "solvation_boxes", + "intermediates", + "md_raw_output", + "openmm_output", + "simulation_stats", + ) + + directory_dict: dict[str, str] = {} + for dir in directory_list: + self.log(f"Creating directory {dir}") + os.mkdir(dir) + directory_dict[dir] = dir + + return directory_dict + + def remove_directories(self) -> None: + """Remove unnecessary directories full of heavy files.""" + directory_list = ( + "pdbfixer", + "md_raw_output", + "solvation_boxes", + ) + for dir in directory_list: + self.log(f"Removing temporary directory {dir}") + shutil.rmtree(dir) + return None + + @classmethod + def confirm_installation(cls) -> None: + """Confirm installation of openmm and pdfixer. + + Raises + ------ + ThirdPartyIntallationError + When OpenMM is not installed + ThirdPartyIntallationError + When OpenMM pdbfixer is not installed + """ + try: + import openmm + except ModuleNotFoundError: + raise ThirdPartyIntallationError( + "OpenMM is not installed." + ) + try: + import pdbfixer + except ModuleNotFoundError: + raise ThirdPartyIntallationError( + "OpenMM pdbfixer is not installed." + ) + return None + + @staticmethod + def set_max_cpu(nbcpu: int) -> None: + from openmm import Platform + cpu_platform = Platform.getPlatformByName('CPU') + cpu_platform.setPropertyDefaultValue('Threads', str(nbcpu)) + + def _run(self) -> None: + """Execute module.""" + # Retrieve previous models + previous_models = self.previous_io.retrieve_models( + individualize=True, + ) + + # create directories + directory_dict = self.create_directories() + + # Limit cpu usage + self.set_max_cpu(self.params["ncores"]) + + # Build list of OPENMM jobs + openmm_jobs: list[OPENMM] = [] + for i, model_to_be_simulated in enumerate(previous_models, start=1): + # Create a openmm job + openmm_job_i = OPENMM( + i, + model_to_be_simulated, + Path("."), + directory_dict, + self.params, + ) + # Hold it + openmm_jobs.append(openmm_job_i) + + # running jobs + scheduling_engine = get_engine(self.params["mode"], self.params) + scheduler = scheduling_engine(openmm_jobs) + scheduler.run() + + # Retrieve generated models + output_pdbs = list(Path(directory_dict["openmm_output"]).glob("*.pdb")) + + # Check if at least one output file has been generated + if len(output_pdbs) == 0: + self.finish_with_error( + "No output models generated. " + "Check Openmm Execution and logfile." + ) + + # deleting unnecessary directories + self.log("Removing unnecessary directories...") + # self.remove_directories() + + # Add small message to the user + self.log("Completed OpenMM module run.") + self.log( + "If you want to continue the haddock3 workflow after " + "the OpenMM module, the next module should be `[topoaa]`, " + "to rebuild the CNS molecular topologies." + ) + + # Setting the output variable + self.output_models = [ + PDBFile(openmmout) + for openmmout in sorted(output_pdbs) + ] + # Generating standardized haddock3 outputs + self.export_io_models() diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/openmm/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/openmm/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9ead34a192f26d97c4217e5ce77d618a9406589a Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/openmm/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/openmm/__pycache__/openmm.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/openmm/__pycache__/openmm.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a34c33d328e461f4d350f53581b8c80cb6e1a466 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/openmm/__pycache__/openmm.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/openmm/defaults.yaml b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/openmm/defaults.yaml new file mode 100644 index 0000000000000000000000000000000000000000..058b5bbf3a702d0b6b319776b6e71cb353a4be24 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/openmm/defaults.yaml @@ -0,0 +1,302 @@ +forcefield: + default: 'amber14-all.xml' + type: string + minchars: 10 + maxchars: 100 + choices: + - 'amber14-all.xml' + - 'amber14/protein.ff14SB.xml' + - 'amber14/protein.ff15ipq.xml' + - 'amber14/DNA.OL15.xml' + - 'amber14/DNA.bsc1.xml' + - 'amber14/RNA.OL3.xml' + - 'amber14/lipid17.xml' + - 'amber14/GLYCAM_06j-1.xml' + - 'charmm36.xml' + title: Forcefield used by OpenMM. + short: Forcefields that can be used by OpenMM. + long: Forcefields that can be used by OpenMM. + group: 'force field' + explevel: easy + +explicit_solvent_model: + default: 'amber14/tip3p.xml' + type: string + minchars: 0 + maxchars: 100 + choices: + - 'amber14/tip3p.xml' + - 'amber14/spce.xml' + - 'charmm36/spce.xml' + - 'amber14/tip4pew.xml' + - 'charmm36/tip4pew.xml' + - 'charmm36/tip5p.xml' + title: Explicit solvent models. + short: Solvent models supported by the OpenMM modeller to build the water solvation box. + long: Solvent models supported by the OpenMM modeller to build the water solvation box. + group: 'force field' + explevel: easy + +ph: + default: 7.4 + type: float + precision: 1 + min: -3.0 + max: 12 + title: pH of the buffer. + short: pH of the buffer. + long: pH of the buffer. This has an infulence on the protonation states of the resiudes. + group: simulation + explevel: expert + +keep_solvent: + default: false + type: boolean + title: Whether-or-not solvent be removed from provided structures. + short: Whether-or-not solvent be removed from provided structures. + long: Whether-or-not solvent be removed from provided structures. + If 'false', all HETATM atoms will be removed. + group: 'post processing' + explevel: easy + +implicit_solvent: + default: false + type: boolean + title: Indicate use of implicit solvent. + short: Indicate use of implicit solvent, avoids building a water solvation box around pdbs. + long: Indicate use of implicit solvent, avoids building a water solvation box around pdbs. + group: 'force field' + explevel: easy + +implicit_solvent_model: + default: 'implicit/hct.xml' + type: string + minchars: 0 + maxchars: 100 + choices: + - 'implicit/hct.xml' + - 'implicit/obc1.xml' + - 'implicit/obc2.xml' + - 'implicit/gbn.xml' + - 'implicit/gbn2.xml' + title: Implicit solvent models. + short: Implicit solvent models supported by OpenMM. + long: Implicit solvent models supported by OpenMM. + group: 'force field' + explevel: easy + +add_extra_particles_for_forcefield: + default: false + type: boolean + title: Add extra particles for forcefield. + short: Add extra particles for forcefield if needed such as e.g. Drude particles. + long: Add extra particles for forcefield if needed such as e.g. Drude particles. + group: 'force field' + explevel: easy + +timestep_ps: + default: 0.002 + type: float + precision: 3 + min: 0.001 + max: 0.004 + title: Timestep definition. + short: Definition of timestep used by the integrator to progress the simulation. + long: Definition of timestep used by the integrator to progress the simulation. + group: 'sampling' + explevel: expert + +constraints: + default: 'HBonds' + type: string + minchars: 1 + maxchars: 20 + choices: + - 'None' + - 'HBonds' + - 'AllBonds' + - 'HAngles' + title: Integration constraints. + short: Integration constraints used to allow for larger integration time step. + long: Integration constraints used to allow for larger integration time step. + For extra info see http://docs.openmm.org/latest/userguide/application/02_running_sims.html#constraints + group: 'restraints' + explevel: easy + +equilibration_timesteps: + default: 2000 + type: integer + min: 0 + max: 100000 + title: Equilibration timesteps. + short: Equilibration timesteps performed without saving the simulation state. + long: Equilibration timesteps performed without saving the simulation state. + group: 'sampling' + explevel: expert + +simulation_timesteps: + default: 2000 + type: integer + min: 0 + max: 1000000 + title: Simulation timesteps. + short: Simulation timesteps performed during the simulation. + long: Simulation timesteps performed during the simulation. + group: 'sampling' + explevel: expert + +sampling_factor: + default: 1 + type: integer + min: 1 + max: 20 + title: Number of simulation replicas. + short: Number of simulation replicas. + long: Number of simulation replicas. + group: 'sampling' + explevel: easy + +temperature_kelvin: + default: 298.15 + type: float + precision: 2 + min: 1.00 + max: 1000.00 + title: Average temperature. + short: Average temperature used by e.g. the integrator or by for temperature coupling. + long: Average temperature used by e.g. the integrator or by for temperature coupling. + group: 'sampling' + explevel: easy + +remove_center_of_mass_motion: + default: true + type: boolean + title: Remove center of mass motion. + short: Remove center of mass motion when overall molecular drift is detected. + long: Remove center of mass motion when overall molecular drift is detected. + group: 'sampling' + explevel: easy + +generate_ensemble: + default: true + type: boolean + title: Generate ensemble of configurations. + short: Generate ensemble of configurations. + long: If 'true', generates 1 single ensemble .pdb file holding various configurations; composed of the equilibrated one, all intermediates and the final one. If 'false', only return the last configuration obtained after 'simulation_timesteps' steps. + group: 'post processing' + explevel: easy + +save_intermediate: + default: 1 + type: integer + min: 0 + max: 100 + title: Number of intermediate configurations to save. + short: Number of intermediate configurations to save during the simulation. + long: Number of intermediate configurations to save during the simulation. The code divides the length of the simulation (simulation_timesteps) by this parameter to get how often configurations should be saved. + group: 'sampling' + explevel: expert + +padding: + default: 1.0 + type: float + precision: 3 + min: 0.3 + max: 10 + title: Padding value in nanometers. + short: Padding value in nanometers. + long: Padding value in nanometers. This is used to create the solvation box by adding water molecules around the molecule up to this padding distance. + When performing a long refinement of a complex, increase this parameter as the molecules will likely move away from each other. + group: 'sampling' + explevel: expert + +rigid_water: + default: true + type: boolean + title: Use rigid water. + short: Use of rigid water in the simulation. + long: Use of rigid water in the simulation. Flexible water molecules usually require a slower taken timestep by the used integrator. + group: 'restraints' + explevel: easy + +iniseed: + default: 917 + type: integer + min: 0 + max: 1000000 + title: Simulation seed. + short: Set a pseudo-random seed for the simulation. + long: Set a pseudo-random seed for the simulation. This defines how the + initial velocities are created, but has no effect on the randomicity + of the solvation box. + group: 'sampling' + explevel: easy + +ion_concentration: + default: 0.15 + precision: 3 + min: 0 + max: 5 + type: float + title: Ion concentration. + short: Ion concentration in Molar. + long: Ion concentration in Molar. + group: 'sampling' + explevel: easy + +solv_equilibration: + default: true + type: boolean + title: Process the solvent equilibration phase. + short: Process the solvent equilibration phase. + long: Process the solvent equilibration phase. + If 'true', the solvent will be equilibrated while constraining proteins positions to intial ones. + group: 'sampling' + explevel: easy + +solv_eq_max_temperature_kelvin: + default: 310.0 + precision: 1 + min: 1 + max: 400 + type: float + title: Upper boundary of temperature to reach during solvent eauilibration phase. + short: Upper boundary of temperature to reach during solvent eauilibration phase. + long: Upper boundary of temperature to reach during solvent eauilibration phase. + group: 'sampling' + explevel: expert + +solv_eq_stepsize_fs: + default: 2.0 + precision: 1 + min: 0.5 + max: 4 + type: float + title: Step size for the solvent equilibration phase. + short: Step size (in femptoseconds) for the solvent equilibration phase. + long: Step size (in femptoseconds) for the solvent equilibration phase. + group: 'sampling' + explevel: expert + +solv_eq_timesteps: + default: 500 + min: 10 + max: 50000 + type: integer + title: Number of timesteps to be performed during solvent equilibration phase. + short: Number of timesteps to be performed during solvent equilibration phase. + long: Number of timesteps to be performed during solvent equilibration phase. + group: 'sampling' + explevel: guru + +solv_eq_spring_constant: + default: 20.0 + precision: 1 + min: 0 + max: 10000 + type: float + title: Spring constant (k) used to restrain protein coordinates during solvent equilibration phase. + short: Spring constant (k) used to restrain protein coordintes during solvent equilibration phase. + long: Spring constant (k) used to restrain protein coordinates during solvent equilibration phase. + group: 'sampling' + explevel: guru diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/openmm/openmm.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/openmm/openmm.py new file mode 100644 index 0000000000000000000000000000000000000000..56ba04ae24b84fd266c4593cc353e10a08e3ad7a --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/refinement/openmm/openmm.py @@ -0,0 +1,1005 @@ +""" +OpenMM Molecular Dynamics refinement module for HADDOCK3. +""" + +# Standard libarires importation +import os + +from contextlib import suppress +from pathlib import Path + +# Import OpenMM and pdbfixer third-party libraries +# >conda activate haddock3 +# >conda install -c conda-forge libstdcxx-ng openmm pdbfixer + +# allow general testing when OpenMM is not installed +#with suppress(ImportError): +from openmm import ( + CustomCentroidBondForce, + CustomExternalForce, + LangevinMiddleIntegrator, + MonteCarloBarostat, + System, + ) +from openmm.app import ( + PME, + NoCutoff, + AllBonds, + ForceField, + HAngles, + HBonds, + Modeller, + PDBxFile, + Simulation, + statedatareporter, + ) +from openmm.app.pdbfile import PDBFile as openmmpdbfile +from openmm.unit import ( + MOLAR_GAS_CONSTANT_R, + angstroms, + atmosphere, + femtoseconds, + kelvin, + kilocalorie_per_mole, + molar, + nanometer, + nanometers, + picosecond, + picoseconds, + ) +from pdbfixer import PDBFixer + +# Haddock libraries +from pdbtools import pdb_delhetatm, pdb_mkensemble +from haddock import log +from haddock.core.exceptions import ModuleError +from haddock.core.typing import Optional, Union, ParamDict +from haddock.libs.libontology import PDBFile +from haddock.libs.libpdb import add_TER_on_chain_breaks + + +class OPENMM: + """OPENMM class.""" + + def __init__( + self, + identificator: int, + model: PDBFile, + path: Path, + directory_dict: dict[str, str], + params: ParamDict, + ): + """ + Initialize the class. + + Parameters + ---------- + identificator : str + The identificator of the object. + model : PosixPath or :py:class:`haddock.libs.libontology.PDBFile` + The model to be evaluated. + path : Path + Reference that defines where output should be saved. + directory_dict : dict[str, str] + Dictionary of the directories handled by the openmm module. + {d: d + for d in [ + "pdbfixer", + "solvation_boxes", + "intermediates", + "md_raw_output", + "openmm_output", + "simulation_stats" + ] + } + params : ParamDict + The openmm modules parameters. + """ + self.identificator = identificator + self.model = model + self.path = path + self.directory_dict = directory_dict + self.params = params + self.log = log + + # other parameters + self.output = Path("output_openmm.log") + self.constraints = self.import_constraints() + self.output_filename = self.model.file_name.replace(".pdb", "_omm.pdb") + + def import_constraints(self): # type: ignore + """Cast parameter string to proper openmm constraints.""" + if self.params["constraints"] == "HBonds": + return HBonds + elif self.params["constraints"] == "AllBonds": + return AllBonds + elif self.params["constraints"] == "HAngles": + return HAngles + return None + + def get_pdb_filepath(self, folder: Union[bool, str] = None) -> str: + """Get correct path to pdb file. + + Parameters + ---------- + folder : str + Path to folder + """ + if folder: + pdb_filepath = os.path.join( + self.directory_dict["pdbfixer"], + self.model.file_name, + ) + else: + if isinstance(self.model, PDBFile): + pdb_filepath = f"{self.model.rel_path}" + else: + pdb_filepath = str(Path(self.model.path, self.model.file_name)) + self.log.debug(f"pdb_filepath is {pdb_filepath}") + return pdb_filepath + + def handle_chainbreaks(self, pdb_fpath: str) -> str: + output_filepath = os.path.join( + self.directory_dict["pdbfixer"], + f"withTER_{self.model.file_name}", + ) + add_TER_on_chain_breaks(pdb_fpath, output_filepath) + return output_filepath + + def openmm_pdbfixer(self): + """Call Pdbfixer on the model pdb.""" + input_pdb_filepath = self.get_pdb_filepath() + pdb_filepath = self.handle_chainbreaks(input_pdb_filepath) + self.log.info( + f"Fixing pdb: {self.model.file_name} (path {pdb_filepath})" + ) + # creating PDBFixer + fixer = PDBFixer(filename=pdb_filepath) + fixer.findMissingResidues() + fixer.findNonstandardResidues() + fixer.replaceNonstandardResidues() + fixer.findMissingAtoms() + fixer.addMissingAtoms() + fixer.addMissingHydrogens(self.params["ph"]) + # calling PDBFixer + output_filepath = os.path.join( + self.directory_dict["pdbfixer"], + self.model.file_name, + ) + openmmpdbfile.writeFile( + fixer.topology, + fixer.positions, + open(output_filepath, 'w'), + keepIds=True, + ) + + def create_solvation_box(self, solvent_model: str) -> Optional[str]: + """Create solvation box for an explicit solvent simulation. + + Parameters + ---------- + solvent_model : str + One of the OpenMM's solvent models. + + Returns + ------- + box_path : Optional[str] + Path to the solvated system + + Raise + ---------- + Exception + Not able to generate the solvation box. + """ + self.log.info(f"Building solvation box for: {self.model.file_name}") + pdb_filepath = self.get_pdb_filepath(self.directory_dict["pdbfixer"]) + forcefield = self.params["forcefield"] + try: + if ('.cif' in pdb_filepath): + openmmpdb = PDBxFile(pdb_filepath) + else: + openmmpdb = openmmpdbfile(pdb_filepath) + # Obtain initial input chains + self.input_chains = [ + chain.id + for chain in openmmpdb.topology.chains() + ] + # creating Modeller + modeller = Modeller(openmmpdb.topology, openmmpdb.positions) + usedForcefield = ForceField(forcefield, solvent_model) + modeller.deleteWater() + modeller.addHydrogens(usedForcefield, pH=self.params["ph"]) + # check the existence of xray cell data + padding = self.params["padding"] * nanometers + ions_conc = self.params["ion_concentration"] * molar + # with neutralize=False it doesn't neutralize + log.info( + f"Solvating and adding ions to the system:" + f"padding {padding}, ions conc. : {ions_conc}" + ) + modeller.addSolvent( + usedForcefield, + padding=padding, + neutralize=True, + ionicStrength=ions_conc, + ) + # Add required extra particles for forcefield, + # e.g. Drude particles. + if self.params["add_extra_particles_for_forcefield"]: + log.info("adding extra particles") + modeller.addExtraParticles(forcefield) + # write solvation box + box_path = os.path.join( + self.directory_dict["solvation_boxes"], + self.model.file_name + ) + openmmpdbfile.writeFile( + modeller.topology, + modeller.positions, + open(box_path, "w"), + keepIds=True, + ) + + except Exception as e: + error_msg = ( + f"An error occured when building solvation box: {e}" + ) + self.log.error(error_msg) + raise ModuleError(f"[openMM] module error: {error_msg}") + else: + return box_path + + def equilibrate_solvation_box( + self, + pdb_filepath: str, + solvent_model: str, + ) -> Optional[str]: + """Machinery for the equilibration of water in presence of the protein. + + Here, the idea is to: + 0. Check if something has to be done + 1. Initiate the system + 2. Construct restrain forces on protein atom positions + 3. Run simulation under restrain + 4. Save new coordinates file + + Parameters + ---------- + pdb_filepath : str + Path to a water boxed system + solvent_model : str + One of the OpenMM's solvent models. + + Returns + ------- + eq_pdb_filepath: str + Path to an equilibrated water boxed system, readdy of MD + + Raises + ------ + Exception + Unable to preform the equilibration. + """ + # Check if spring constant > 0 + if not self.params["solv_equilibration"]: + return pdb_filepath + + self.log.info(f"Equilibrating solvation box from {pdb_filepath}...") + try: + # 1. Initiate the system and simulation objects + # Load structure coordinates + system_coordinates = openmmpdbfile(pdb_filepath) + # Initiate forcefiled object + forcefield = ForceField(self.params["forcefield"], solvent_model) + # system setup + # should give an ERROR when system_constraints = 'None'. + system = forcefield.createSystem( + system_coordinates.topology, + nonbondedMethod=PME, + nonbondedCutoff=1 * nanometer, + constraints=HAngles, + removeCMMotion=self.params["remove_center_of_mass_motion"], + rigidWater=self.params["rigid_water"], + ) + # Initiate intergrator + integrator = LangevinMiddleIntegrator( + self.params["solv_eq_max_temperature_kelvin"] * kelvin, + 1 / picosecond, + self.params["solv_eq_stepsize_fs"] * femtoseconds + ) + # Set pseudo-random seed + integrator.setRandomNumberSeed(self.params["iniseed"]) + + # 2. Add constraints to the protein atoms + self.log.info("Adding protein constraints") + # Add position restraint force + rest_force, spring_force_index = self._gen_restrain_force( + system_coordinates.topology.atoms(), + system_coordinates.positions, + spring_constant=self.params["solv_eq_spring_constant"], + ) + # Add the restrain force to the system + system.addForce(rest_force) + + # Initiate simulation object + simulation = Simulation( + system_coordinates.topology, + system, + integrator, + ) + + # Initiate state reporter object + reported_output_fname = ( + f'{self.directory_dict["simulation_stats"]}/' + f"solv_eq_observables_{self.identificator}.dat" + ) + statereporter = statedatareporter.StateDataReporter( + reported_output_fname, + 10, + step=True, + totalEnergy=True, + potentialEnergy=True, + temperature=True, + volume=True, + density=True, + ) + simulation.reporters.append(statereporter) + simulation.context.setPositions(system_coordinates.positions) + + # 3. Run simulation under constraints + # Process energy minimization prior to any dynamic simulation + self.log.info("Minimizing system energy") + simulation.minimizeEnergy() + # Set parameters + eq_steps = self.params["solv_eq_timesteps"] + nvt_sims = 7 + delta_steps = max(1, int(eq_steps / nvt_sims)) + max_temperature = self.params["solv_eq_max_temperature_kelvin"] + max_temperature = max_temperature + delta_temp = max_temperature / nvt_sims + # Progressively warmup the system + self.log.info("Warming system up...") + integrator.setFriction(100 / picosecond) + for n in range(1, nvt_sims + 1): + # Compute new values + qtemp = n * delta_temp + # Set values + integrator.setTemperature(qtemp * kelvin) + # Run some md steps + simulation.step(delta_steps) + # Set final temperature and temperature coupling + integrator.setTemperature(max_temperature * kelvin) + integrator.setFriction(1 / picosecond) + # Makes sure temperature of the system is reached + self._stabilize_temperature( + simulation, + max_temperature, + statereporter._dof, + tolerance=10.0, + steps=50 + ) + # Print log info + self.log.info( + "Running solvent equilibration phase " + "under protein coordinate position restraints:" + ) + self.log.info( + f"For {self.params['solv_eq_timesteps']} timesteps at " + f"{self.params['solv_eq_max_temperature_kelvin']} K " + f"(stepsize={self.params['solv_eq_stepsize_fs']} fs)..." + ) + # Do few simulation steps at max temperature + # progressively releasing the position restraints on the protein + slow_reduction_steps = 10 + red_delta_steps = int(eq_steps / slow_reduction_steps) + for n in range(slow_reduction_steps - 1, -1, -1): + const_stength = n / slow_reduction_steps + new_spring_const = self.params["solv_eq_spring_constant"] * const_stength + rest_force.setGlobalParameterDefaultValue( + spring_force_index, + new_spring_const, + ) + simulation.step(red_delta_steps) + # Progressively freeze the system + self.log.info("Cooling down the system...") + for n in range(nvt_sims - 1, 0, -1): + qtemp = n * delta_temp + integrator.setTemperature(qtemp * kelvin) + simulation.step(delta_steps) + + # 4. Save new coordinates file + # Write finale frame structure + eq_pdb_filepath = os.path.join( + self.directory_dict["solvation_boxes"], + f"solvent_eq_{self.model.file_name}", + ) + # Retrieve last coordinates + eq_state = simulation.context.getState(getPositions=True) + eq_positions = eq_state.getPositions() + openmmpdbfile.writeFile( + simulation.topology, + eq_positions, + open(eq_pdb_filepath, "w"), + keepIds=True, + ) + self.log.info(f"Equilibrated solvated system: {eq_pdb_filepath} !") + return eq_pdb_filepath + + except Exception: + import traceback + strerr = traceback.format_exc() + self.log.debug( + "Error durring solvent equilibration for file " + f"{pdb_filepath}:\n{strerr}.{os.linesep}" + "Continuing from unequilibrated solvent frame." + ) + return pdb_filepath + + def _stabilize_temperature( + self, + simulation: Simulation, + temperature: float, + dof: int, + tolerance: float = 5.0, + steps: int = 50, + ) -> int: + """ + Make sure the simulated system reached the desired temperature. + + Parameters + ---------- + simulation : py:class:`openmm.Simulation` + An openmm system + temperature : float + The temperature hoped to be reached + dof : int + The degree of freedom obtained from the statereporter._dof + tolerance : float + The tolerance allowed for the temperature + steps : int + The number of steps to do before checking again that + temperature was reached + """ + additional_steps: int = 0 + # Makes sure temperature of the system is reached + while not ((temperature - tolerance) + <= self._get_simulation_temperature(simulation, dof) + <= (temperature + tolerance)): + # Do several simulation steps + simulation.step(steps) + additional_steps += steps + return additional_steps + + @staticmethod + def _gen_restrain_force( + atoms: list, + positions: list, + subset: Union[bool, list] = None, + spring_constant: float = 20.0, + ) -> CustomExternalForce: + """ + Generate CustomExternalForce aiming at restraining protein coordinates. + + Parameters + ---------- + atoms : list + List of the particules present in the topology of the system + positions : list + Initial position of the particules in the system + subset : list + List of atom indexes on which to apply the restrain force + spring_constant : float + Initial value of the position restrain spring constant. + + Return + ---------- + rest_force: :py:class:`openmm.openmm.CustomExternalForce` + Set CustomExternalForce object restraining protein position + spring_force_index: int + Index of the spring force constant + """ + # Initiate Custom Force to restrain positions + rest_force = CustomExternalForce( + # could have been "k*((x-x0)^2+(y-y0)^2+(z-z0)^2)" + # but because we are in periodic boundary conditions, + # it is better to use "k*periodicdistance(x, y, z, x0, y0, z0)^2" + # c.f. OpenMM documentation + "k*periodicdistance(x, y, z, x0, y0, z0)^2" + ) + # Define spring constant value + spring_force_index = rest_force.addGlobalParameter( + "k", + spring_constant * kilocalorie_per_mole / angstroms ** 2 + ) + rest_force.addPerParticleParameter('x0') + rest_force.addPerParticleParameter('y0') + rest_force.addPerParticleParameter('z0') + # Set of atom indexes to work on + ind_subset = list(range(len(positions))) if not subset else subset + # Loop over topology atoms + for atom in atoms: + # Filter out non-protein particles and hydrogens + if atom.element.symbol == 'H': # Hydrogen atom + continue + if atom.residue.name == 'HOH': # Water molecule + continue + if len(atom.residue.name) != 3: # Skip ions + continue + if atom.index not in ind_subset: # Not in subset + continue + # Hold index of the restrained atom + rest_force.addParticle(atom.index, positions[atom.index]) + return rest_force, spring_force_index + + def _gen_centroid_forces(self, system: System) -> None: + """Add centroid forces between protein monomers to the system. + + FIXME: Not functionning due to issue of group definitions in + the self._chain_centroid_force() function + + Parameters + ---------- + system : py:class:`openmm.System` + An openmm system + """ + for i, chainid in enumerate(self.input_chains[:-1]): + for chain2 in self.input_chains[i + 1:]: + new_force = self._chain_centroid_force(system, chainid, chain2) + system.addForce(new_force) + + @staticmethod + def _get_chain_atoms(system: System, chainid: str) -> list[int]: + """Retrun list of atom ids belonging to a chain. + + Parameters + ---------- + system : py:class:`openmm.System` + An openmm system + chainid : str + Chain id on which atom ids must be retrieved from + """ + for chain in system.topology.chains(): + if chain.id == chainid: + return [atom.id for atom in chain.atoms()] + return [] + + def _chain_centroid_force( + self, + system: System, + chain1: str, + chain2: str, + ) -> CustomCentroidBondForce: + """Set up a centroid force betweem two chains. + + FIXME: Not functionning ... + + Parameters + ---------- + system : py:class:`openmm.System` + An openmm system + chain1 : str + One of system chain (hopfully a monomer) to apply the force on + chain2 : str + Second chain (hopfully a monomer) to apply the force on + """ + centroid_force = CustomCentroidBondForce(2, "0.1*k*distance(g1,g2)^2") + centroid_force.addPerBondParameter("k") + gc1 = centroid_force.addGroup(self._get_chain_atoms(system, chain1)) + gc2 = centroid_force.addGroup(self._get_chain_atoms(system, chain2)) + centroid_force.addBond([gc1, gc2], [1]) + return centroid_force + + @staticmethod + def _get_simulation_temperature(simulation: Simulation, dof: int) -> float: + """Computes/gather the current system temperature. + + NOTE: this function is similar to the lines of code found in + the :py:class:`openmm.app.statedatareporter.StateDataReporter()` + + NOTE2: Would be better if in the StateustomCentroidBondForce class... + + Parameters + ---------- + simulation : :py:class:`openmm.app.simulation.Simulation()` + The current simulation + dof : int + Value of the StateDataReporter._dof + + Return + ---------- + temperature_k : float + The current simulation temperature (in kelvin) + """ + integrator = simulation.context.getIntegrator() + if hasattr(integrator, "computeSystemTemperature"): + temperature = integrator.computeSystemTemperature() + else: + state = simulation.context.getState(getEnergy=True) + temperature = ( + 2 * state.getKineticEnergy() / (dof * MOLAR_GAS_CONSTANT_R) + ) + tempreature_k = temperature.value_in_unit(kelvin) + return tempreature_k + + @staticmethod + def remove_water_and_ions(input_filepath: str) -> str: + """Remove water from the output of an explicit solvent run. + + Uses the pdb-tools.pdb_delhetatm() module to do this + + NOTE: May produce an issue with TER atoms (Water + ions) + + NOTE2: May lead to issue with modified AA e.g: phsophoserine, etc... + + Parameters + ---------- + input_filepath : str + Path to the file to be modified + + Return + ---------- + output_filepath : str + Path to the modified file not containing anymore HETATM + """ + log.info(f"Removing water and ions from {input_filepath}") + output_filepath = input_filepath.replace('.pdb', '_nosolv.pdb') + with open(input_filepath, 'r') as fh: + pdbYieldedLines = pdb_delhetatm.run(fh) + with open(output_filepath, 'w') as writefh: + writefh.writelines(pdbYieldedLines) + return output_filepath + + def run_openmm( + self, + inputPDBfile: str, + output_directory: str, + solvent_model: str, + replica_index: int, + ) -> dict: + """ + Run openmm simulation of the model pdb. + + Parameters + ---------- + inputPDBfile : str + Path to the PDB file. + + output_folder : str + Path to the output directory. + + solvent_model : str + One of the OpenMM's solvent models. + + Return + ---------- + output_files : dict + Dict holding paths to configurations generated along the simulation + """ + # Initiate output dictionary + output_files: dict[str, Union[str, list[str]]] = {} + # Split output path + fn, ext = os.path.splitext(self.output_filename) + + # Make sure something has to be done... + if self.params["simulation_timesteps"] == 0: + output_filepath = os.path.join( + output_directory, + f"{fn}_{replica_index}{ext}" + ) + os.rename(inputPDBfile, output_filepath) + output_files["final"] = output_filepath + return output_files + + # Load pdb + pdb = openmmpdbfile(inputPDBfile) + forcefield = ForceField(self.params['forcefield'], solvent_model) + # system setup + nonbondedMethod = NoCutoff if self.params["implicit_solvent"] else PME + # should give an ERROR when system_constraints = 'None'. + system = forcefield.createSystem( + pdb.topology, + nonbondedMethod=nonbondedMethod, + nonbondedCutoff=1 * nanometer, + constraints=self.constraints, + removeCMMotion=self.params['remove_center_of_mass_motion'], + rigidWater=self.params['rigid_water'] + ) + # integrator definition. Few freedom here + integrator = LangevinMiddleIntegrator( + self.params['temperature_kelvin'] * kelvin, + 1 / picosecond, + self.params['timestep_ps'] * picoseconds + ) + + # Add the restrain force to the system + # self._gen_centroid_forces(pdb) + + # setting integrator seed + replica_seed = self.params["iniseed"] + replica_index + if replica_seed != 0: + log.info(f"setting non-random seed = {replica_seed}") + integrator.setRandomNumberSeed(replica_seed) + # retrieving integrator seed + get_seed = integrator.getRandomNumberSeed() + log.info(f"simulation seed {get_seed} for {self.model.file_name}") + + # simulation + simulation = Simulation(pdb.topology, system, integrator) + statereporter = statedatareporter.StateDataReporter( + f'{self.directory_dict["simulation_stats"]}/observables_{self.identificator}_{replica_index}.dat', # noqa : E501 + 50, + step=True, + totalEnergy=True, + potentialEnergy=True, + temperature=True, + volume=True, + density=True, + ) + simulation.reporters.append(statereporter) + + platform = simulation.context.getPlatform() + log.info(f"Running on platform {platform.getName()}") + log.info(f"Estimated platform speed: {platform.getSpeed()}") + simulation.context.setPositions(pdb.positions) + simulation.minimizeEnergy() + log.info(f"Running NVT equilibration for {self.model.file_name}") + + # warming up the system with a NVT equilibration (canonical ensemble) + eq_steps = self.params["equilibration_timesteps"] + log.info( + f"Warming up the system to {self.params['temperature_kelvin']}" + f" K in ~{eq_steps} steps" + ) + # In how many iterations are we inceasing the temperature ? + nvt_sims = 10 + # How much should be increase the temperature at each iteration + delta_temp = self.params["temperature_kelvin"] / nvt_sims + integrator.setFriction(100 / picosecond) + for n in range(1, nvt_sims + 1): + qtemp = n * delta_temp + integrator.setTemperature(qtemp * kelvin) + simulation.step(int(eq_steps / nvt_sims)) + # Set final temperature and temperature coupling parameters + integrator.setTemperature(self.params["temperature_kelvin"] * kelvin) + integrator.setFriction(1 / picosecond) + # Try to obtain the degree of freedom + try: + dof = statereporter._dof + except AttributeError: + # may not exists if in implicit solvent.. + dof = system.getNumParticles() * 3 + # Makes sure temperature of the system is reached + self._stabilize_temperature( + simulation, + self.params["temperature_kelvin"], + dof, + tolerance=5.0, + steps=50 + ) + log.info( + f"Temperature of {self.params['temperature_kelvin']} K " + f"reached in {simulation.context.getStepCount()} steps" + ) + + # Write + eq_pdb_filepath = os.path.join( + self.directory_dict["intermediates"], + f"{fn}_eq_{replica_index}{ext}" + ) + self._write_current_pdb(simulation, eq_pdb_filepath) + output_files["equilibrated"] = eq_pdb_filepath + + # NPT simulation (isothermal-isobaric ensemble) + _barostat = MonteCarloBarostat( # noqa : F841 + 1 * atmosphere, + self.params["temperature_kelvin"] * kelvin + ) + # FIXME : Once the MonteCarloBarostat will no more split chains + # appart in different periodic boxes, please uncomment next line + # simulation.system.addForce(_barostat) + + # Reinitialize the simulation + simulation.context.reinitialize(True) + + # Running real simulation + log.info( + f"Running simulation for {self.model.file_name} for " + f"{self.params['simulation_timesteps']} timesteps" + ) + + # Save intermediates + if self.params["save_intermediate"]: + # Initialize variables + done_steps = 0 + output_files["intermediates"] = [] + steps_intermediate = int( + self.params["simulation_timesteps"] + // self.params["save_intermediate"] + ) + starting_step_inter = int(steps_intermediate / 2) + + # Do few steps + simulation.step(starting_step_inter) + done_steps += starting_step_inter + # Define intermediates output file + int_filepath = os.path.join( + self.directory_dict["intermediates"], + f"{fn}_{replica_index}_{done_steps}steps{ext}" + ) + self._write_current_pdb(simulation, int_filepath) + output_files["intermediates"].append(int_filepath) + + # Loop over intermediate steps + for _i in range(self.params["save_intermediate"] - 1): + simulation.step(steps_intermediate) + done_steps += steps_intermediate + # Define intermediates output file + int_filepath = os.path.join( + self.directory_dict["intermediates"], + f"{fn}_{replica_index}_{done_steps}steps{ext}" + ) + self._write_current_pdb(simulation, int_filepath) + output_files["intermediates"].append(int_filepath) + + # Do the remaining simulation steps + simulation.step(self.params["simulation_timesteps"] - done_steps) + else: + simulation.step(self.params["simulation_timesteps"]) + + # Write final pdb file + output_filepath = os.path.join( + output_directory, + f"{fn}_{replica_index}{ext}" + ) + self._write_current_pdb(simulation, output_filepath) + output_files["final"] = output_filepath + # Log end of OpenMM simulation info + log.info(f"OpenMM simulation successful for: {output_filepath}") + # Return data + return output_files + + @staticmethod + def _write_current_pdb( + simulation: Simulation, + output_path: str, + reference_pdb: Optional[list] = None, + ) -> None: + """Write the current position of atoms in the simulation. + + Parameters + ---------- + simulation: :py:class:`openmm.app.simulation.Simulation` + An openmm simulation class + + output_path : str + Path of the file where to write the pdb file + """ + # Retrieve last state data + current_state = simulation.context.getState( + getPositions=True, + # enforcePeriodicBox=True + ) + # Write pdb file + openmmpdbfile.writeFile( + simulation.topology, + current_state.getPositions(), + open(output_path, "w"), + keepIds=True, + ) + + def generate_output_ensemble( + self, + replicas_outputs: list[dict[str, Union[str, list[str]]]], + ) -> str: + """Combine all replicas outputs into a single file. + + Parameters + ---------- + replicas_outputs: list[dict[str, Union[str, list[str]]]] + List of dictionnary mapping to all simulation replicas outputs. + + Returns + ------- + final_openmm_output: str + Path to the ensemble (composed of the equilibrated, intermediates, + and final structure), for all replicas, generated by the module. + """ + # Combines all outputs in a list + all_files: list[str] = [] + for sample in replicas_outputs: + for _outputtype, outputpath in sample.items(): + if isinstance(outputpath, str): + all_files.append(outputpath) + elif isinstance(outputpath, list): + all_files += outputpath + # Generate ensemble + ensemble_filepath = os.path.join( + self.directory_dict["openmm_output"], + self.output_filename, + ) + log.info( + f"Generating ensemble from {len(all_files)} samples: " + f"{ensemble_filepath}" + ) + ensemble = pdb_mkensemble.run(all_files) + with open(ensemble_filepath, "w") as wfile: + for line in ensemble: + wfile.write(line) + # Remove single structure files + for non_ensemble_fp in all_files: + os.remove(non_ensemble_fp) + return ensemble_filepath + + def run(self) -> None: + """Run openmm simulation.""" + # using pdbfixer + self.openmm_pdbfixer() + # explicit solvent simulation + if not self.params["implicit_solvent"]: + # define solvent model and create solvation box + solvent_model = self.params["explicit_solvent_model"] + # create solvation box + try: + pdbPath = self.create_solvation_box(solvent_model) + except ModuleError as _err: + return + # Eauilibrate this box around system + pdbPath = self.equilibrate_solvation_box(pdbPath, solvent_model) + # set variables + output_folder = self.directory_dict["md_raw_output"] + solvent = "explicit solvent" + # implicit solvent simulation + else: + pdbPath = os.path.join( + self.directory_dict["pdbfixer"], + self.model.file_name + ) + output_folder = self.directory_dict["openmm_output"] + solvent_model = self.params["implicit_solvent_model"] + solvent = "implicit solvent" + + log.info(f"starting {solvent} openMM simulation with file: {pdbPath}") + + # Loop over samplings/replicas + replicas_outputs: list[dict[str, Union[str, list[str]]]] = [] + for replica_ind in range(self.params["sampling_factor"]): + replica_struct = self.run_openmm( + pdbPath, + output_folder, + solvent_model, + replica_ind + 1, + ) + replicas_outputs.append(replica_struct) + + # Solvent removal procedure + if not self.params["implicit_solvent"] and \ + not self.params["keep_solvent"]: + # Loop over replicas + for replica_structs in replicas_outputs: + for outputtype in replica_structs.keys(): + # Remove solvent molecules from outputs + if isinstance(replica_structs[outputtype], list): + nosolv_out = [ + self.remove_water_and_ions(pdb) + for pdb in replica_structs[outputtype] + ] # type: ignore + else: + nosolv_out = self.remove_water_and_ions( + replica_structs[outputtype] + ) # type: ignore + # Modify paths in files mapper + replica_structs[outputtype] = nosolv_out + + # Post-process results and place them in appropriate directory + if self.params["generate_ensemble"]: + # Generate ensemble + self.generate_output_ensemble(replicas_outputs) + else: + # Generate list of final structures only + for replica_mapper in replicas_outputs: + raw_output = replica_mapper["final"] + final_output = raw_output.replace( + self.directory_dict["md_raw_output"], + self.directory_dict["openmm_output"] + ) + os.rename(raw_output, final_output) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3aabc2a87e5c1773085453f6420936be2921b0c8 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/__init__.py @@ -0,0 +1 @@ +"""HADDOCK3 modules for sampling.""" diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/lightdock/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/lightdock/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ad8605e5459a165fcfcab4e8a28ea65d5dd99871 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/lightdock/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/bestener.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/bestener.cns new file mode 100644 index 0000000000000000000000000000000000000000..533e5ad429389bc80c9545031176313f00107194 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/bestener.cns @@ -0,0 +1,108 @@ +! bestener.cns +! Store best score model from rigid-body dooking (it0) +! Version supporting only distance-based restraints +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +eval ($kinter = 1.0) +@MODULE:scale_inter_mini.cns + +evaluate ($unambig_scale = $Data.unambig_scale) +evaluate ($ambig_scale = $Data.ambig_scale) +evaluate ($hbond_scale = $Data.hbond_scale) + +noe + scale dist $unambig_scale + scale ambi $ambig_scale + scale hbon $hbond_scale + scale symm 0.0 +end + +evaluate ($ener = 0.0) +evaluate ($vdw = 0.0) +evaluate ($elec = 0.0) +evaluate ($noe = 0.0) +evaluate ($coll = 0.0) +evaluate ($eair = 0.0) +evaluate ($cdih = 0.0) +evaluate ($vean = 0.0) +evaluate ($sani = 0.0) +evaluate ($xrdc = 0.0) +evaluate ($xpcs = 0.0) +evaluate ($dani = 0.0) +evaluate ($esym = 0.0) +evaluate ($zhar = 0.0) +evaluate ($bsa = 0.0) +evaluate ($desolv = 0.0) +evaluate ($lcc = 0.0) + +energy end +evaluate ($eair = $noe) + +if ($Data.flags.sym eq true) then + noe + scale * 0.0 + scale symm $Data.ksym + end + energy end + evaluate ($esym = $noe) +end if + +if ($SaProtocol.rigidtrans eq true) then + inline @MODULE:bsa.cns +end if + +evaluate ($etot = $w_vdw * $vdw) +evaluate ($etot = $etot + $w_elec * $elec) +evaluate ($etot = $etot + $w_air * $eair) +evaluate ($etot = $etot + $w_rg * $coll) +evaluate ($etot = $etot + $w_cdih * $cdih) +evaluate ($etot = $etot + $w_sani * $sani) +evaluate ($etot = $etot + $w_xrdc * $xrdc) +evaluate ($etot = $etot + $w_xpcs * $xpcs) +evaluate ($etot = $etot + $w_dani * $dani) +evaluate ($etot = $etot + $w_vean * $vean) +evaluate ($etot = $etot + $w_sym * $esym) +evaluate ($etot = $etot + $w_zres * $zhar) +evaluate ($etot = $etot + $w_bsa * $bsa) +evaluate ($etot = $etot + $w_desolv * $desolv) +evaluate ($etot = $etot + $w_lcc * $lcc) + +if ($nfirst = 1) then + evaluate ($bestener = $etot) + evaluate ($bestair = $eair) + do (refx = x) (all) + do (refy = y) (all) + do (refz = z) (all) + evaluate ($nfirst = 0) + ident (store3) (not all) +else + if ($etot < $bestener) then + evaluate ($bestener = $etot) + evaluate ($bestair = $eair) + do (refx = x) (all) + do (refy = y) (all) + do (refz = z) (all) + end if +end if + +evaluate ($kinter = $SaProtocol.inter_rigid) +@MODULE:scale_inter_mini.cns + +evaluate ($unambig_scale = $unambig_scale_store) +evaluate ($ambig_scale = $ambig_scale_store) +evaluate ($hbond_scale = $hbond_scale_store) +evaluate ($symm_scale = $symm_scale_store) + +noe + scale dist $unambig_scale + scale ambi $ambig_scale + scale hbon $hbond_scale + scale symm $symm_scale +end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/bsa.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/bsa.cns new file mode 100644 index 0000000000000000000000000000000000000000..79569bb0ae41f556a493b6f2ce44a5abe9ee71e7 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/bsa.cns @@ -0,0 +1,52 @@ +! bsa.cns +! +! Calculate buried surface area and desolvation energy of the complex +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +{====>} {* define ASA-based solvation parameters *} +inline @MODULE:def_solv_param.cns + +{====>} {* buried surface area and desolvation of single chains *} +evaluate ($nchain1 = 0) +evaluate ($saafree = 0) +evaluate ($esolfree = 0) +while ($nchain1 < $data.ncomponents) loop nloop1 + evaluate ($nchain1 = $nchain1 + 1) + {====>} {* buried surface area and desolvation*} + do (rmsd = 0) (all) + surface mode=access accu=0.075 rh2o=1.4 sele=(segid $prot_segid_$nchain1 and not ((resn WAT or resn HOH or resn TIP*) or resn DMS or resn SHA)) end + show sum (rmsd) (segid $prot_segid_$nchain1 and not ((resn WAT or resn HOH or resn TIP*) or resn DMS or resn SHA)) + evaluate ($saafree = $saafree + $result) + do (store2 = rmsd * store1) (segid $prot_segid_$nchain1 and not ((resn WAT or resn HOH or resn TIP*) or resn DMS or resn SHA)) + show sum (store2) (segid $prot_segid_$nchain1 and not ((resn WAT or resn HOH or resn TIP*) or resn DMS or resn SHA)) + evaluate ($esolfree = $esolfree + $result) +end loop nloop1 + +{====>} {* buried surface area and desolvation of complex *} +do (rmsd = 0) (all) +do (store2 = 0) (all) +surface mode=access accu=0.075 rh2o=1.4 sele=(not ((resn WAT or resn HOH or resn TIP*) or resn DMS or resn SHA)) end +show sum (rmsd) (not ((resn WAT or resn HOH or resn TIP*) or resn DMS or resn SHA)) +evaluate ($satot = $result) +do (store2 = rmsd * store1) (not ((resn WAT or resn HOH or resn TIP*) or resn DMS or resn SHA)) +show sum (store2) (not ((resn WAT or resn HOH or resn TIP*) or resn DMS or resn SHA)) +evaluate ($esolcplx = $result) +evaluate ($saburied = $saafree - $satot) +! minimum BSA value set to 15 (one H atom would have SASA of 12.56 A**2) +if ($saburied < 15) then + evaluate ($saburied = -999999) +end if + +evaluate ($edesolv = $esolcplx - $esolfree) + +if ($data.ncomponents eq 1) then + evaluate ($bsa = 0) + evaluate ($desolv = 0) +end if diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/charge-beads-interactions.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/charge-beads-interactions.cns new file mode 100644 index 0000000000000000000000000000000000000000..cc737f48b257038b92405bc3db93fbfc47440066 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/charge-beads-interactions.cns @@ -0,0 +1,43 @@ +! charge-beads-interactions.cns +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +for $id1 in id ( (resn SER or resn THR or resn ASN or resn GLN) and name BB ) loop c1beads + + show (segid) (id $id1) + evaluate ($cgsegid=$result) + show (resid) (id $id1) + evaluate ($cgresid=$result) + + igroup + ! turn off all vdw interactions between charged beads and all beads + interaction (segid $cgsegid and resid $cgresid and name SCD1) (all) weight vdw 0.0 end + interaction (segid $cgsegid and resid $cgresid and name SCD2) (all) weight vdw 0.0 end + + ! turn off all vdw and elec interactions between the charged beads within one residue + interaction (segid $cgsegid and resid $cgresid and name SCD1) + (segid $cgsegid and resid $cgresid and name SCD2) weight * 1.0 vdw 0.0 elec 0.0 end + end + +end loop c1beads + +for $id1 in id ( (resn LYS or resn ARG or resn ASP or resn GLU) and name BB ) loop c2beads + + show (segid) (id $id1) + evaluate ($cgsegid=$result) + show (resid) (id $id1) + evaluate ($cgresid=$result) + + igroup + ! turn off all vdw interactions between charged beads and all beads + interaction (segid $cgsegid and resid $cgresid and name SCD1) (all) weight vdw 0.0 end + end + +end loop c2beads + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/check-homomers.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/check-homomers.cns new file mode 100644 index 0000000000000000000000000000000000000000..7faf7a4c90f49812724e0a5e217f380cba1b712f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/check-homomers.cns @@ -0,0 +1,56 @@ +! check-homomers.cns +! check for homomeric complexes +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +evaluate ($homosymmetry = false) + +evaluate($n_moving_mol = 0) +evaluate ($ncount = 0) +while ($ncount < $data.ncomponents) loop checkmol + evaluate ($ncount = $ncount + 1) + if ($mol_shape_$ncount eq false) then + evaluate($n_moving_mol = $n_moving_mol + 1) + end if +end loop checkmol + +if ($data.flags.sym eq true) then + if ($data.nc2sym > 0) then + if ($n_moving_mol = 2) then + evaluate ($homosymmetry = true) + end if + end if + if ($data.nc2sym = 6) then + if ($n_moving_mol = 4) then + evaluate ($homosymmetry = true) + end if + end if + if ($data.nc3sym > 0) then + if ($n_moving_mol = 3) then + evaluate ($homosymmetry = true) + end if + end if + if ($data.nc4sym > 0) then + if ($n_moving_mol = 4) then + evaluate ($homosymmetry = true) + end if + end if + if ($data.nc5sym > 0) then + if ($n_moving_mol = 5) then + evaluate ($homosymmetry = true) + end if + end if + if ($data.nc6sym > 0) then + if ($n_moving_mol = 6) then + evaluate ($homosymmetry = true) + end if + end if +end if + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/check_coordinates.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/check_coordinates.cns new file mode 100644 index 0000000000000000000000000000000000000000..d23c8e64804060c61ff6aeea38925dc8e61dc8d6 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/check_coordinates.cns @@ -0,0 +1,100 @@ +! check_coordinates.cns +! Check max/min coordinates for compatibility with PDB format +! +! *********************************************************************** +! * Copyright 2025 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +evaluate ($failure = false) + +!check for coordinates >9999.999 (max writable in PDB format) + +show max (x) (all) +evaluate ($maxcoor = $result) +show max (y) (all) +if ($result gt $maxcoor) then + evaluate ($maxcoor = $result) +end if +show max (z) (all) +if ($result gt $maxcoor) then + evaluate ($maxcoor = $result) +end if +if ($maxcoor gt 9999.999) then + evaluate ($failure = true) +end if + +!check for coordinates <-999.999 (min writable in PDB format) + +show min (x) (all) +evaluate ($mincoor = $result) +show min (y) (all) +if ($result lt $mincoor) then + evaluate ($maxcoor = $result) +end if +show min (z) (all) +if ($result lt $mincoor) then + evaluate ($mincoor = $result) +end if +if ($mincoor lt -999.999) then + evaluate ($failure = true) +end if + +!if problem detected try correcting it by centering the system around 4500,4500,4500 +!but only if no EM restraints are used + +if ($failure eq true) then + if ($data.flags.em eq false) then + + evaluate ($xc = 0.0) + evaluate ($yc = 0.0) + evaluate ($zc = 0.0) + show ave (x) (all) + evaluate ($xc = 4500 - $result) + show ave (y) (all) + evaluate ($yc = 4500 - $result) + show ave (z) (all) + evaluate ($zc = 4500 -$result) + + do (x = x + $xc) (all) + do (y = y + $yc) (all) + do (z = z + $zc) (all) + + evaluate ($failure = false) + evaluate ($maxcoor = -999) + evaluate ($mincoor = 9999) + !check again for coordinates >9999.999 (max writable in PDB format) + show max (x) (all) + evaluate ($maxcoor = $result) + show max (y) (all) + if ($result gt $maxcoor) then + evaluate ($maxcoor = $result) + end if + show max (z) (all) + if ($result gt $maxcoor) then + evaluate ($maxcoor = $result) + end if + if ($maxcoor gt 9999.999) then + evaluate ($failure = true) + end if + + !check for coordinates <-999.999 (min writable in PDB format) + show min (x) (all) + evaluate ($mincoor = $result) + show min (y) (all) + if ($result lt $mincoor) then + evaluate ($maxcoor = $result) + end if + show min (z) (all) + if ($result lt $mincoor) then + evaluate ($mincoor = $result) + end if + if ($mincoor lt -999.999) then + evaluate ($failure = true) + end if + end if +end if + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/cm-restraints.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/cm-restraints.cns new file mode 100644 index 0000000000000000000000000000000000000000..51a4b9e4a4ed699653e4e65c1ddaa729202f3628 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/cm-restraints.cns @@ -0,0 +1,131 @@ +! cm-restraints.cns +! Define center-of-mass restraints between molecules +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +!define center of mass restraints between all molecules +!using distance restraints between CA, BB or N1 atoms with center averaging + +evaluate ($ncount = 0) + +! store original coordinates +do (refx = x) (all) +do (refy = y) (all) +do (refz = z) (all) + +while ($ncount < $data.ncomponents) loop nloop1 + evaluate ($ncount = $ncount +1) + evaluate ($dim_$ncount = 0.0) + + !orient molecule + coor orient sele=(segid $prot_segid_$ncount) end + + ! find dimensions + show max (x) (segid $prot_segid_$ncount and (name CA or name BB or name N1)) + evaluate ($xdim = $result) + show max (y) (segid $prot_segid_$ncount and (name CA or name BB or name N1)) + evaluate ($ydim = $result) + show max (z) (segid $prot_segid_$ncount and (name CA or name BB or name N1)) + evaluate ($zdim = $result) + show min (x) (segid $prot_segid_$ncount and (name CA or name BB or name N1)) + evaluate ($xdim = $xdim - $result) + show min (y) (segid $prot_segid_$ncount and (name CA or name BB or name N1)) + evaluate ($ydim = $ydim - $result) + show min (z) (segid $prot_segid_$ncount and (name CA or name BB or name N1)) + evaluate ($zdim = $zdim - $result) + + evaluate ($corr = max($xdim,$ydim)) + evaluate ($corr = max($corr,$zdim)) + + if ($data.cmtight eq false) then + ! use average of all three dimensions + evaluate ($dim_$ncount = ($xdim + $ydim + $zdim)/6.0) + else + ! use only the average of the smallest two dimensions + evaluate ($dim_$ncount = ($xdim + $ydim + $zdim - $corr)/4.0) + end if + + ! check for anything not protein + do (store6 = 0) (all) + do (store6 = 1) (segid $prot_segid_$ncount and (name CA or name BB)) + show sum (store6) (all) + if ($result eq 0) then + ! we are dealing with a ligand, nucleic acid or glycan -> set dimension to 0 + evaluate ($dim_$ncount = 0.0) + end if + +end loop nloop1 + +! restore original coordinates +do (x = refx) (all) +do (y = refy) (all) +do (z = refz) (all) + +eval($nchain = 0) +do (store9 = 0) (all) +do (store9 = 1) (name CA or name BB or name N1) +while ($nchain < $data.ncomponents) loop nloop0 + eval($nchain = $nchain + 1) + show sum (store9) (segid $prot_segid_$nchain) + if ($result < 3) then + evaluate ($selat$nchain = 0 ) + else + evaluate ($selat$nchain = 1 ) + end if +end loop nloop0 + +eval($nchain1 = 0) +noe + class contact + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + eval($nchain2 = $nchain1 ) + if ($mol_shape_$nchain1 eq false) then + while ($nchain2 < $data.ncomponents) loop nloop2 + eval($nchain2 = $nchain2 + 1) + if ($mol_shape_$nchain2 eq false) then + if ($data.cmtight eq false) then + eval($cm_dist = $dim_$nchain1 + $dim_$nchain2) + else + eval($cm_dist = ($dim_$nchain1 + $dim_$nchain2)/2 ) + end if + if ($selat$nchain1 = 1) then + if ($selat$nchain2 = 1) then + assign (segid $prot_segid_$nchain1 and ( name CA or name BB or name N1 )) + (segid $prot_segid_$nchain2 and ( name CA or name BB or name N1 )) $cm_dist $cm_dist 1.0 + else + assign (segid $prot_segid_$nchain1 and ( name CA or name BB or name N1 )) + (segid $prot_segid_$nchain2) $cm_dist $cm_dist 1.0 + end if + else + if ($selat$nchain2 = 1) then + assign (segid $prot_segid_$nchain1) + (segid $prot_segid_$nchain2 and ( name CA or name BB or name N1 )) $cm_dist $cm_dist 1.0 + else + assign (segid $prot_segid_$nchain1) + (segid $prot_segid_$nchain2) $cm_dist $cm_dist 1.0 + end if + end if + end if + end loop nloop2 + end if + end loop nloop1 + + averaging contact center + scale contact $data.kcm + sqconstant contact 1.0 + sqexponent contact 2 + soexponent contact 1 + rswitch contact 1.0 + sqoffset contact 0.0 + asymptote contact 2.0 + msoexponent contact 1 + masymptote contact -0.1 + mrswitch contact 1.0 +end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/def_solv_param.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/def_solv_param.cns new file mode 100644 index 0000000000000000000000000000000000000000..5a9e07a042e08d15d5b98d859fa199151e7b4a43 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/def_solv_param.cns @@ -0,0 +1,105 @@ +! def_solv_param.cns +! Define atomic solvation parameters +! Original valus taken from Fernandez-Recio et al. JMB 335:843 (2004) +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +evaluate ($arofac = 6.26) +evaluate ($alifac = 1.27) +evaluate ($polfac = 2.30) + + +do (store1 = 0.0000) (all) +do (store1 = 0.0151 * $alifac) (name C*) +do (store1 = 0.0176 * $arofac) ((name CG* or name CD* or name CE* or name CH* or name CZ*) and (resn PHE or resn TYR or resn HIS or resn TRP)) +do (store1 = -0.0170 * $polfac) (name N*) +do (store1 = -0.0548 * $polfac) (name NT* or (name NZ* and resn LYS)) +do (store1 = -0.0273 * $polfac) (name NH* and resn ARG) +do (store1 = -0.0136 * $polfac) (name O*) +do (store1 = -0.0185 * $polfac) (name OG* or name OH) +do (store1 = -0.0299 * $polfac) ((name OD* and resn ASP) or (name OE* and resn GLU)) +do (store1 = 0.0112 * $polfac) (name S*) +do (store1 = 0.0022 * $polfac) ((name S* and attr charge = -0.3) or (name SD and resn MET)) +do (store1 = 0.0000) (name SHA) + +! +! CG parameters matched from the original terms +! +! Edesolv_aa +! ASP_cg = _________________________ +! ASA_cg +! +! ASA_cg and Edesol_aa calculated on a GGXGG peptide +! accuracy=0.0025, rh2o=1.4, delete H, sele=(resn X) +! +! e.g. BB bead alanine +! +! BB = CA + C + N + O +! ASA_cg = 176.4940 +! Edesolv_aa = -1.8889 +! +! ASP_cg = -0.0107 +! +! Charleen Don (2012), JR (2014), Jorge Roel (2017) +! +! + +do (store1 = 0.0000) (name BB or name SC*) +! Backbone beads +do (store1 = -0.0107) (name BB and resn ALA) +do (store1 = -0.0089) (name BB and resn GLY) +do (store1 = -0.0153) (name BB and resn ILE) +do (store1 = -0.0158) (name BB and resn VAL) +do (store1 = -0.0046) (name BB and resn PRO) +do (store1 = -0.0137) (name BB and resn ASN) +do (store1 = -0.0147) (name BB and resn GLN) +do (store1 = -0.0165) (name BB and resn THR) +do (store1 = -0.0154) (name BB and resn SER) +do (store1 = -0.0130) (name BB and resn MET) +do (store1 = -0.0167) (name BB and resn CYS) +do (store1 = -0.0126) (name BB and resn PHE) +do (store1 = -0.0134) (name BB and resn TYR) +do (store1 = -0.0134) (name BB and resn TRP) +do (store1 = -0.0169) (name BB and resn ASP) +do (store1 = -0.0150) (name BB and resn GLU) +do (store1 = -0.0155) (name BB and resn HIS) +do (store1 = -0.0163) (name BB and resn LYS) +do (store1 = -0.0162) (name BB and resn ARG) + +! Side-chain beads +!do (store1 = 0.0000) (name SC* and resn ALA) +!do (store1 = 0.0000) (name SC* and resn GLY) +do (store1 = 0.0255) (name SC* and resn ILE) +do (store1 = 0.0222) (name SC* and resn VAL) +do (store1 = 0.0230) (name SC* and resn PRO) +do (store1 = -0.0192) (name SC* and resn ASN) +do (store1 = -0.0135) (name SC* and resn GLN) +do (store1 = -0.0009) (name SC* and resn THR) +do (store1 = -0.0056) (name SC* and resn SER) +do (store1 = 0.0202) (name SC* and resn MET) +do (store1 = 0.0201) (name SC* and resn CYS) +do (store1 = 0.1005) (name SC* and resn PHE) +do (store1 = 0.0669) (name SC* and resn TYR) +do (store1 = 0.0872) (name SC* and resn TRP) +do (store1 = -0.0360) (name SC* and resn ASP) +do (store1 = -0.0301) (name SC* and resn GLU) +do (store1 = 0.0501) (name SC* and resn HIS) +do (store1 = -0.0210) (name SC* and resn LYS) +do (store1 = -0.0229) (name SC* and resn ARG) + +! Fake beads +do (store1 = 0.0) (name SCD* and resn ASN) +do (store1 = 0.0) (name SCD* and resn GLN) +do (store1 = 0.0) (name SCD* and resn SER) +do (store1 = 0.0) (name SCD* and resn THR) +do (store1 = 0.0) (name SCD* and resn ARG) +do (store1 = 0.0) (name SCD* and resn LYS) +do (store1 = 0.0) (name SCD* and resn GLU) +do (store1 = 0.0) (name SCD* and resn ASP) + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/get_random_rotation.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/get_random_rotation.cns new file mode 100644 index 0000000000000000000000000000000000000000..892bf6f3a0706502aa8e8bfad7fee09c6bfa5405 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/get_random_rotation.cns @@ -0,0 +1,91 @@ +! get_random_rotation.cns +! Define a random rotation +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +{* + The random rotation is calculated by taking a random unit quaternion, + so that all rotations are uniformely distributed. For more details, see + "Quaternions in molecular modeling" Charles F.F. Karney + Journal of Molecular Graphics and Modelling 25 (2007) 595-604 + + Original author: Christophe Schmidt + Modularized it: Gydo van Zundert + + Parameters + ---------- + Rotation : A struct which will hold the random rotation + + Type : Optional string, either 'Quaternion' or 'Matrix' + Determines whether the random rotation is expressed as a quaternion or a matrix + + Note + ---- + There is no need in general to specify the Type as a matrix when performing the rotation. + + Example: + >>>> ! $rand_rot does NOT have to exist currently + !>>>> @MODULE:get_random_rotation.cns(Rotation=$rand_rot;) + >>>> coor rotate + >>>> quaternion $rand_rot.q0 $rand_rot.q1 $rand_rot.q2 $rand_rot.q3 + >>>> selection=(all) + >>>> end + + Example using a rotation matrix: + !>>>> @MODULE:get_random_rotation.cns(Rotation=$rr; Type='Matrix';) + >>>> coor rotate + >>>> matrix $rr.a11 $rr.a12 $rr.a13 + >>>> $rr.a21 $rr.a22 $rr.a23 + >>>> $rr.a31 $rr.a32 $rr.a33 + >>>> selection=(all) + >>>> end +*} + +!1. Generate random e1 e2 e3 and e4 in [-1, 1] so that e1^2 + e2^2 < 1 and e3^2+e4^2 < 1 +evaluate ($RRM_e1 = random() * 2 - 1) +evaluate ($RRM_e2 = random() * 2 - 1) +evaluate ($RRM_s1 = ($RRM_e1)*($RRM_e1) + ($RRM_e2)*($RRM_e2)) +while ( $RRM_s1 >= 1) loop s1loop + evaluate ($RRM_e1 = random() * 2 - 1) + evaluate ($RRM_e2 = random() * 2 - 1) + evaluate ($RRM_s1 = ($RRM_e1)*($RRM_e1) + ($RRM_e2)*($RRM_e2)) +end loop s1loop + +evaluate ($RRM_e3 = random() * 2 - 1) +evaluate ($RRM_e4 = random() * 2 - 1) +evaluate ($RRM_s2 = ($RRM_e3)*($RRM_e3) + ($RRM_e4)*($RRM_e4)) +while ( $RRM_s2 >= 1) loop s2loop + evaluate ($RRM_e3 = random() * 2 - 1) + evaluate ($RRM_e4 = random() * 2 - 1) + evaluate ($RRM_s2 = ($RRM_e3)*($RRM_e3) + ($RRM_e4)*($RRM_e4)) +end loop s2loop + +!2. the quaternion q0 q1 q2 q3 +evaluate($RRM_q0 = $RRM_e1) +evaluate($RRM_q1 = $RRM_e2) +evaluate($RRM_q2 = $RRM_e3 * sqrt((1 - $RRM_s1)/$RRM_s2) ) +evaluate($RRM_q3 = $RRM_e4 * sqrt((1 - $RRM_s1)/$RRM_s2) ) + +! package it in a struct +if (&Type='Quaternion') then + evaluate(&Rotation.q0 = $RRM_q0) + evaluate(&Rotation.q1 = $RRM_q1) + evaluate(&Rotation.q2 = $RRM_q2) + evaluate(&Rotation.q3 = $RRM_q3) +elseif (&Type='Matrix') then + evaluate (&Rotation.a11 = $RRM_q0 * $RRM_q0 + $RRM_q1 * $RRM_q1 - $RRM_q2 * $RRM_q2 - $RRM_q3 * $RRM_q3) + evaluate (&Rotation.a12 = 2 * ($RRM_q1 * $RRM_q2 - $RRM_q0 * $RRM_q3) ) + evaluate (&Rotation.a13 = 2 * ($RRM_q1 * $RRM_q3 + $RRM_q0 * $RRM_q2) ) + evaluate (&Rotation.a21 = 2 * ($RRM_q1 * $RRM_q2 + $RRM_q0 * $RRM_q3) ) + evaluate (&Rotation.a22 = $RRM_q0 * $RRM_q0 - $RRM_q1 * $RRM_q1 + $RRM_q2 * $RRM_q2 - $RRM_q3 * $RRM_q3) + evaluate (&Rotation.a23 = 2 * ($RRM_q2 * $RRM_q3 - $RRM_q0 * $RRM_q1) ) + evaluate (&Rotation.a31 = 2 * ($RRM_q1 * $RRM_q3 - $RRM_q0 * $RRM_q2) ) + evaluate (&Rotation.a32 = 2 * ($RRM_q2 * $RRM_q3 + $RRM_q0 * $RRM_q1) ) + evaluate (&Rotation.a33 = $RRM_q0 * $RRM_q0 - $RRM_q1 * $RRM_q1 - $RRM_q2 * $RRM_q2 + $RRM_q3 * $RRM_q3) +end if diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/print_coorheader.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/print_coorheader.cns new file mode 100644 index 0000000000000000000000000000000000000000..1a06f68f63b409e44be920b6dada5a05ff1e762f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/print_coorheader.cns @@ -0,0 +1,308 @@ +! print_coorheader.cns +! Generate the coordinate header (REMARKS) +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * Originally adapted from Aria 1.2 from Nilges and Linge, EMBL. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +if ($Data.flags.dihed eq false) then evaluate ($dihe = 0) end if +if ($Data.flags.sani eq false) then evaluate ($sani = 0) end if +if ($Data.flags.xrdc eq false) then evaluate ($xrdc = 0) end if +if ($Data.flags.xpcs eq false) then evaluate ($xpcs = 0) end if +if ($Data.flags.dani eq false) then evaluate ($dani = 0) end if +if ($Data.flags.vean eq false) then evaluate ($vean = 0) end if +if ($Data.flags.cdih eq false) then evaluate ($cdih = 0) end if +if ($Data.flags.noe eq false) then evaluate ($noe = 0) end if +if ($Data.flags.rg eq false) then evaluate ($coll = 0) end if +if ($Data.flags.zres eq false) then evaluate ($zhar = 0) end if +if ($Data.flags.em eq false) then evaluate ($lcc = 0) end if + +evaluate($enerall=$etot) +evaluate($bondall=$ebond) +evaluate($anglall=$eangl) +evaluate($imprall=$eimpr) +evaluate($diheall=$edihe) +evaluate($vdwall=$vdw) +evaluate($elecall=$elec) +evaluate($noeall=$noe) +evaluate($rgall=$coll) +evaluate($zresall=$zhar) +evaluate($cdihall=$cdih) +evaluate($coupall=0) +evaluate($saniall=$sani+$xrdc) +evaluate($veanall=$vean) +evaluate($xpcsall=$xpcs) +evaluate($daniall=$dani) + +if ($Data.flags.sym eq true) then + evaluate ($result=0) + evaluate ($violations=0) + print threshold=0.3 noe + evaluate ($rms_noe=$result) + evaluate ($violations_noe=$violations) +end if + +if ($Data.randremoval eq false) then + evaluate ($violations_test_noe= 0) + evaluate ($rms_test_noe = 0) + evaluate ($npart = 0) +end if + +evaluate ($result=0) +evaluate ($violations=0) +print threshold=5. cdih +evaluate ($rms_cdih=$result) +evaluate ($violations_cdih=$violations) +evaluate ($result=0) +evaluate ($violations=0) +evaluate ($rms_coup = 0) +evaluate ($violations_coup = 0) + +evaluate( $rms_sani = 0) +evaluate( $violations_sani = 0) +if ($Data.flags.sani eq TRUE) then + sani print threshold = 0.20 class rd* end + evaluate( $rms_sani = $result) + evaluate( $violations_sani = $violations) +end if + +evaluate( $rms_xrdc = 0) +evaluate( $violations_xrdc = 0) +if ($Data.flags.xrdc eq TRUE) then + xrdc print threshold = 0.2 class xr* end + evaluate( $rms_xrdc = $result) + evaluate( $violations_xrdc = $violations) +end if + +evaluate( $violations_sani = $violations_sani + $violations_xrdc) +evaluate( $rms_sani = $rms_sani + $rms_xrdc) + +evaluate( $rms_xpcs = 0) +evaluate( $violations_xpcs = 0) +if ($Data.flags.xpcs eq TRUE) then + xpcs print threshold = 0.2 class pc* end + evaluate( $rms_xpcs = $result) + evaluate( $violations_xpcs = $violations) +end if + +evaluate( $rms_vean = 0) +evaluate( $violations_vean = 0) +if ($Data.flags.vean eq TRUE) then + vean print threshold = 5.00 class ve* end + evaluate( $rms_vean = $result) + evaluate( $violations_vean = $violations) +end if + +evaluate( $rms_dani = 0) +evaluate( $violations_dani = 0) +if ($Data.flags.dani eq TRUE) then + dani print threshold = 0.20 class da* end + evaluate( $rms_dani = $result) + evaluate( $violations_dani = $violations) +end if + +{====>} {* define ASA-based solvation parameters *} +inline @MODULE:def_solv_param.cns + +{====>} {* buried surface area and desolvation*} +evaluate ($nchain1 = 0) +evaluate ($saafree = 0) +evaluate ($esolfree = 0) +while ($nchain1 < $data.ncomponents) loop nloop1 + evaluate ($nchain1 = $nchain1 + 1) + {====>} {* buried surface area and desolvation*} + do (rmsd = 0) (all) + surface mode=access accu=0.075 rh2o=1.4 sele=(segid $prot_segid_$nchain1 and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) end + show sum (rmsd) (segid $prot_segid_$nchain1 and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) + evaluate ($saafree = $saafree + $result) + do (store2 = rmsd * store1) (segid $prot_segid_$nchain1 and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) + show sum (store2) (segid $prot_segid_$nchain1 and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) + evaluate ($esolfree = $esolfree + $result) +end loop nloop1 + +do (rmsd = 0) (all) +do (store2 = 0) (all) +surface mode=access accu=0.075 rh2o=1.4 sele=(not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) end +show sum (rmsd) (not ((resn WAT or resn HOH or resn TIP*) or resn DMS or resn SHA)) +evaluate ($satot = $result) +do (store2 = rmsd * store1) (not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) +show sum (store2) (not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) +evaluate ($esolcplx = $result) +evaluate ($saburied = $saafree - $satot) +if ($saburied < 0) then + evaluate ($saburied = -999999) +end if + +evaluate ($edesolv = $esolcplx - $esolfree) + +evaluate ($dhbinding = $edesolv + $eintcplx - $eintfree + $elecall + $vdwall) + +evaluate ($nshape = 0) +evaluate ($ncount = 0) +while ($ncount < $data.ncomponents) loop shape + evaluate ($ncount = $ncount + 1) + if ($mol_shape_$ncount eq true) then + evaluate ($nshape = $nshape + 1) + end if +end loop shape + +evaluate ($nonshape = $Data.ncomponents - $nshape) + +if ($nonshape = 1) then + evaluate ($saburied = 0) + evaluate ($edesolv = 0) + evaluate ($dhbinding = 0) + evaluate ($eintfree = $eintcplx) +end if + +if ($Data.flags.sym eq true) then + evaluate ($enerall = $enerall + $esym) +end if +if ($Data.flags.ncs eq true) then + evaluate ($enerall = $enerall + $ncs) +end if + +evaluate ($procwat = false) +if ($refine.keepwater eq true) then + evaluate ($procwat = true) +end if + +if ($procwat eq true) then + ident (store3) (not all) + flag exclude * include vdw elec end + + eval($nchain1 = 0) + + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + + igroup + interaction (segid $prot_segid_$nchain1) ((resn WAT or resn HOH or resn TIP* or resn DMS) and not store3) weight * 1.0 end + interaction (not segid $prot_segid_$nchain1) (resn WAT or resn HOH or resn TIP* or resn DMS) weight * 0.0 end + interaction (segid $prot_segid_$nchain1) (not ((resn WAT or resn HOH or resn TIP* or resn DMS) and store3)) weight * 0.0 end + end + energy end + evaluate ($ener_water_$nchain1 = $ener) + evaluate ($enerall = $enerall + $ener) + evaluate ($vdw_water_$nchain1 = $vdw) + evaluate ($elec_water_$nchain1 = $elec) + + end loop nloop1 + if ($data.ncomponents > 1) then + eval($nchain1 = $data.ncomponents) + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + evaluate ($ener_water_$nchain1 = 0.0) + evaluate ($vdw_water_$nchain1 = 0.0) + evaluate ($elec_water_$nchain1 = 0.0) + end loop nloop1 + end if + + eval($nchain1 = 0) + + igroup + while ($nchain1 < $data.ncomponents) loop nloop2 + eval($nchain1 = $nchain1 + 1) + interaction (segid $prot_segid_$nchain1) (all) weight * 0.0 end + end loop nloop2 + interaction ((resn WAT or resn HOH or resn TIP* or resn DMS) and not store3) + ((resn WAT or resn HOH or resn TIP* or resn DMS) and not store3) weight * 1.0 end + interaction (store3) (store3) weight * 0.0 end + interaction (resn SHA) (not resn SHA) weight * 0.0 end + interaction (resn SHA) (resn SHA) weight * 0.0 end + end + energy end + evaluate ($ener_water_water = $ener) + evaluate ($enerall = $enerall + $ener) + evaluate ($vdw_water_water = $vdw) + evaluate ($elec_water_water = $elec) +else + eval($nchain1 = 0) + + while ($nchain1 < $data.ncomponents ) loop nloop1 + eval($nchain1 = $nchain1 + 1) + evaluate ($ener_water_$nchain1 = 0.0) + evaluate ($vdw_water_$nchain1 = 0.0) + evaluate ($elec_water_$nchain1 = 0.0) + end loop nloop1 + evaluate ($ener_water_water = 0.0) + evaluate ($vdw_water_water = 0.0) + evaluate ($elec_water_water = 0.0) +end if + +! calculate the HADDOCK score +evaluate ($hscore = $w_vdw * $vdwall) +evaluate ($hscore = $hscore + $w_elec * $elecall) +evaluate ($hscore = $hscore + $w_air * $noeall) +evaluate ($hscore = $hscore + $w_rg * $rgall) +evaluate ($hscore = $hscore + $w_cdih * $cdihall) +evaluate ($hscore = $hscore + $w_sani * $saniall) +evaluate ($hscore = $hscore + $w_xpcs * $xpcsall) +evaluate ($hscore = $hscore + $w_dani * $daniall) +evaluate ($hscore = $hscore + $w_vean * $veanall) +evaluate ($hscore = $hscore + $w_sym * $esym) +evaluate ($hscore = $hscore + $w_bsa * $saburied) +evaluate ($hscore = $hscore + $w_desolv * $edesolv) +evaluate ($hscore = $hscore + $w_lcc * $lcc) + +set message=on echo=on end +set remarks=reset end +set remarks=accumulate end +remarks =============================================================== +remarks HADDOCK stats for $output_pdb_filename +remarks =============================================================== +remarks HADDOCK score: $hscore +remarks =============================================================== + +!list input molecules +evaluate ($nmol=1) +while ($nmol <=$data.ncomponents) loop mol + if ( $exist_input_pdb_filename_$nmol = true) then + remarks initial structure $nmol - $input_pdb_filename_$nmol + end if + evaluate ($nmol = $nmol + 1) +end loop mol + +remarks =============================================================== +remarks total,bonds,angles,improper,dihe,vdw,elec,air,cdih,coup,rdcs,vean,dani,xpcs,rg +remarks energies: $enerall, $bondall, $anglall, $imprall, $diheall, $vdwall, $elecall, $noeall, $cdihall, $coupall, $saniall, $veanall, $daniall, $xpcsall, $rgall +remarks =============================================================== +remarks bonds,angles,impropers,dihe,air,cdih,coup,rdcs,vean,dani,xpcs +remarks rms-dev.: $rms_bonds,$rms_angles,$rms_impropers,$rms_dihedrals,$rms_noe,$rms_cdih,$rms_coup, $rms_sani, $rms_vean, $rms_dani, $rms_xpcs +remarks =============================================================== +remarks air,cdih,coup,rdcs,vean,dani,xpcs +remarks >0.3,>5,>1,>0,>5,>0.2,>0.2 +remarks violations.: $violations_noe, $violations_cdih, $violations_coup, $violations_sani, $violations_vean, $violations_dani, $violations_xpcs +remarks =============================================================== +remarks CVpartition#,violations,rms +remarks AIRs cross-validation: $npart, $violations_test_noe, $rms_test_noe +remarks =============================================================== +remarks NCS energy: $ncs +remarks =============================================================== +remarks Symmetry energy: $esym +remarks =============================================================== +remarks Membrane restraining energy: $zresall +remarks =============================================================== +remarks Local cross-correlation: $lcc[f7.4] +remarks =============================================================== +remarks Desolvation energy: $edesolv +remarks Internal energy free molecules: $eintfree +remarks Internal energy complex: $eintcplx +remarks Binding energy: $dhbinding +remarks =============================================================== +remarks buried surface area: $saburied +remarks =============================================================== +set remark accumulate end +evaluate($ncount = 0) +while ($ncount < $data.ncomponents) loop waterremark + evaluate ($ncount = $ncount +1) + remarks water - chain_$ncount: $ener_water_$ncount $vdw_water_$ncount $elec_water_$ncount +end loop waterremark +remarks =============================================================== +remarks water - water: $ener_water_water $vdw_water_water $elec_water_water +remarks =============================================================== diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/random_rotations.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/random_rotations.cns new file mode 100644 index 0000000000000000000000000000000000000000..a50e9f5624abb6405affc6a2d38b29187ea5c9bc --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/random_rotations.cns @@ -0,0 +1,180 @@ +! random_rotations.cns +! Perform a random rotation +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +! check if homomer + +inline @MODULE:check-homomers.cns + +do (store4 = 0) (all) +evaluate ($ncount = 0) +while ($ncount < $data.ncomponents) loop fixed + evaluate ($ncount = $ncount + 1) + eval($watersegname_$ncount="WA" + encode($ncount)) + if ($mol_fix_origin_$ncount eq true) then + do (store4 = 1) (segid $prot_segid_$ncount) + end if +end loop fixed + +if ($homosymmetry eq false) then + ! Random translation within a 10A cube + evaluate ($ncount = 0) + while ($ncount < $data.ncomponents) loop randtrans + evaluate ($ncount = $ncount +1) + if ($mol_fix_origin_$ncount eq false) then + evaluate ($xd = 10.0 * (0.5 - ran())) + evaluate ($yd = 10.0 * (0.5 - ran())) + evaluate ($zd = 10.0 * (0.5 - ran())) + coor trans sele=(segid $prot_segid_$ncount or segid $watersegname_$ncount) vector=($xd,$yd,$zd) end + end if + end loop randtrans +end if + +! Random rotation of molecules +evaluate ($ncount = 0) +evaluate ($nrotset = 0) +while ($ncount < $data.ncomponents) loop randrot + evaluate ($ncount = $ncount +1) + if ($mol_fix_origin_$ncount eq false) then + show ave (x) (segid $prot_segid_$ncount or segid $watersegname_$ncount) + evaluate ($xc = $result) + show ave (y) (segid $prot_segid_$ncount or segid $watersegname_$ncount) + evaluate ($yc = $result) + show ave (z) (segid $prot_segid_$ncount or segid $watersegname_$ncount) + evaluate ($zc = $result) + + ! Random rotation for each molecule except for symmtrical homomers for which + ! the same rotation is applied to all molecules to keep the symmetry + if ($nrotset = 0) then + !1. Generate random e1 e2 e3 and e4 in [-1, 1] so that e1^2 + e2^2 < 1 and e3^2+e4^2 < 1 + evaluate ($RRM_e1 = ran () * 2 - 1) + evaluate ($RRM_e2 = ran () * 2 - 1) + evaluate ($RRM_s1 = ($RRM_e1)*($RRM_e1) + ($RRM_e2)*($RRM_e2)) + + while ( $RRM_s1 >= 1) loop s1loop + evaluate ($RRM_e1 = ran () * 2 - 1) + evaluate ($RRM_e2 = ran () * 2 - 1) + evaluate ($RRM_s1 = ($RRM_e1)*($RRM_e1) + ($RRM_e2)*($RRM_e2)) + end loop s1loop + + evaluate ($RRM_e3 = ran () * 2 - 1) + evaluate ($RRM_e4 = ran () * 2 - 1) + evaluate ($RRM_s2 = ($RRM_e3)*($RRM_e3) + ($RRM_e4)*($RRM_e4)) + while ( $RRM_s2 >= 1) loop s2loop + evaluate ($RRM_e3 = ran () * 2 - 1) + evaluate ($RRM_e4 = ran () * 2 - 1) + evaluate ($RRM_s2 = ($RRM_e3)*($RRM_e3) + ($RRM_e4)*($RRM_e4)) + end loop s2loop + + !2. the quaternion q0 q1 q2 q3 + evaluate($RRM_q0 = $RRM_e1) + evaluate($RRM_q1 = $RRM_e2) + evaluate($RRM_q2 = $RRM_e3 * sqrt((1 - $RRM_s1)/$RRM_s2) ) + evaluate($RRM_q3 = $RRM_e4 * sqrt((1 - $RRM_s1)/$RRM_s2) ) + + !3. The rotation matrix from the quaternion + evaluate ($x1 = $RRM_q0 * $RRM_q0 + $RRM_q1 * $RRM_q1 - $RRM_q2 * $RRM_q2 - $RRM_q3 * $RRM_q3) + evaluate ($x2 = 2 * ($RRM_q1 * $RRM_q2 - $RRM_q0 * $RRM_q3) ) + evaluate ($x3 = 2 * ($RRM_q1 * $RRM_q3 + $RRM_q0 * $RRM_q2) ) + evaluate ($y1 = 2 * ($RRM_q1 * $RRM_q2 + $RRM_q0 * $RRM_q3) ) + evaluate ($y2 = $RRM_q0 * $RRM_q0 - $RRM_q1 * $RRM_q1 + $RRM_q2 * $RRM_q2 - $RRM_q3 * $RRM_q3) + evaluate ($y3 = 2 * ($RRM_q2 * $RRM_q3 - $RRM_q0 * $RRM_q1) ) + evaluate ($z1 = 2 * ($RRM_q1 * $RRM_q3 - $RRM_q0 * $RRM_q2) ) + evaluate ($z2 = 2 * ($RRM_q2 * $RRM_q3 + $RRM_q0 * $RRM_q1) ) + evaluate ($z3 = $RRM_q0 * $RRM_q0 - $RRM_q1 * $RRM_q1 - $RRM_q2 * $RRM_q2 + $RRM_q3 * $RRM_q3) + + if ($homosymmetry eq true) then + evaluate ($nrotset = 1) + end if + end if + + !4. The rotation + coor + center=($xc $yc $zc) + rotate matrix=($x1 $x2 $x3) ($y1 $y2 $y3) ($z1 $z2 $z3) + sele=(segid $prot_segid_$ncount or segid $watersegname_$ncount) + end + end if +end loop randrot + + +! If there are fixed molecules, randomly rotate as one unit all non-fixed ones +! around the geometric center of the fixed ones + +show sum (store4) (all) + +if ($result > 0) then + + show ave (x) (attribute store4 = 1) + evaluate ($xc = $result) + show ave (y) (attribute store4 = 1) + evaluate ($yc = $result) + show ave (z) (attribute store4 = 1) + evaluate ($zc = $result) + + ! Random rotation for each molecule except for symmtrical homomers for which + ! the same rotation is applied to all molecules to keep the symmetry + if ($nrotset = 0) then + !1. Generate random e1 e2 e3 and e4 in [-1, 1] so that e1^2 + e2^2 < 1 and e3^2+e4^2 < 1 + evaluate ($RRM_e1 = ran () * 2 - 1) + evaluate ($RRM_e2 = ran () * 2 - 1) + evaluate ($RRM_s1 = ($RRM_e1)*($RRM_e1) + ($RRM_e2)*($RRM_e2)) + + while ( $RRM_s1 >= 1) loop s1loop + evaluate ($RRM_e1 = ran () * 2 - 1) + evaluate ($RRM_e2 = ran () * 2 - 1) + evaluate ($RRM_s1 = ($RRM_e1)*($RRM_e1) + ($RRM_e2)*($RRM_e2)) + end loop s1loop + + evaluate ($RRM_e3 = ran () * 2 - 1) + evaluate ($RRM_e4 = ran () * 2 - 1) + evaluate ($RRM_s2 = ($RRM_e3)*($RRM_e3) + ($RRM_e4)*($RRM_e4)) + while ( $RRM_s2 >= 1) loop s2loop + evaluate ($RRM_e3 = ran () * 2 - 1) + evaluate ($RRM_e4 = ran () * 2 - 1) + evaluate ($RRM_s2 = ($RRM_e3)*($RRM_e3) + ($RRM_e4)*($RRM_e4)) + end loop s2loop + + !2. the quaternion q0 q1 q2 q3 + evaluate($RRM_q0 = $RRM_e1) + evaluate($RRM_q1 = $RRM_e2) + evaluate($RRM_q2 = $RRM_e3 * sqrt((1 - $RRM_s1)/$RRM_s2) ) + evaluate($RRM_q3 = $RRM_e4 * sqrt((1 - $RRM_s1)/$RRM_s2) ) + + !3. The rotation matrix from the quaternion + evaluate ($x1 = $RRM_q0 * $RRM_q0 + $RRM_q1 * $RRM_q1 - $RRM_q2 * $RRM_q2 - $RRM_q3 * $RRM_q3) + evaluate ($x2 = 2 * ($RRM_q1 * $RRM_q2 - $RRM_q0 * $RRM_q3) ) + evaluate ($x3 = 2 * ($RRM_q1 * $RRM_q3 + $RRM_q0 * $RRM_q2) ) + evaluate ($y1 = 2 * ($RRM_q1 * $RRM_q2 + $RRM_q0 * $RRM_q3) ) + evaluate ($y2 = $RRM_q0 * $RRM_q0 - $RRM_q1 * $RRM_q1 + $RRM_q2 * $RRM_q2 - $RRM_q3 * $RRM_q3) + evaluate ($y3 = 2 * ($RRM_q2 * $RRM_q3 - $RRM_q0 * $RRM_q1) ) + evaluate ($z1 = 2 * ($RRM_q1 * $RRM_q3 - $RRM_q0 * $RRM_q2) ) + evaluate ($z2 = 2 * ($RRM_q2 * $RRM_q3 + $RRM_q0 * $RRM_q1) ) + evaluate ($z3 = $RRM_q0 * $RRM_q0 - $RRM_q1 * $RRM_q1 - $RRM_q2 * $RRM_q2 + $RRM_q3 * $RRM_q3) + + if ($homosymmetry eq true) then + evaluate ($nrotset = 1) + end if + end if + + !4. The rotation + coor + center=($xc $yc $zc) + rotate matrix=($x1 $x2 $x3) ($y1 $y2 $y3) ($z1 $z2 $z3) + sele=(attribute store4 = 0) + end +end if + +do (x = refx) (resn ANI or resn DAN or resn XAN or resn SHA) +do (y = refy) (resn ANI or resn DAN or resn XAN or resn SHA) +do (z = refz) (resn ANI or resn DAN or resn XAN or resn SHA) + +!evaluate ($outname = "MODULE:" + "begin/" + $Filenames.fileroot + "_init_" + encode($count) + ".pdb") +!write coor format=pdbo output=$outname end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/randomairs.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/randomairs.cns new file mode 100644 index 0000000000000000000000000000000000000000..f2b5cc6a7be9c26516a0b697e999d99ed9700878 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/randomairs.cns @@ -0,0 +1,246 @@ +! randomairs.cns +! Define random AIRs from solvent accessible residues +! +! *********************************************************************** +! * Copyright 2003-2018 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +if ($data.ncomponents > 2) then + evaluate ($errfile = "FAILED") + fileexist $errfile end + if ($result eq false) then + set display=$errfile end + display RANDOM DEFINITION OF AIRS FROM SOLVENT ACCESSIBLE RESIDUES ONLY + display SUPPORTED FOR TWO MOLECULES. USE CENTER-OF-MASS RESTRAINTS INSTEAD + close $errfile end + end if +end if +! +! first calculate accessible surface area +! +do (store3 = 0) (all) +surface mode=access rh2o=1.4 sele=(segid $prot_segid_1 and not (resn WAT or resn HOH or resn TIP*)) end +show sum (rmsd) (segid $prot_segid_1 and not (resn WAT or resn HOH or resn TIP*)) +do (store3 = rmsd) (segid $prot_segid_1 and not (resn WAT or resn HOH or resn TIP*)) +surface mode=access rh2o=1.4 sele=(segid $prot_segid_2 and not (resn WAT or resn HOH or resn TIP*)) end +do (store3 = rmsd) (segid $prot_segid_2 and not (resn WAT or resn HOH or resn TIP*)) +! +! normalize by standard residue accessibilities (taken from NACCESS) +! +do (store3 = store3 / 107.95) (resn ALA) +do (store3 = store3 / 134.28) (resn CY*) +do (store3 = store3 / 134.28) (resn CSP) +do (store3 = store3 / 140.39) (resn ASP) +do (store3 = store3 / 140.39) (resn ASH) +do (store3 = store3 / 172.25) (resn GLU) +do (store3 = store3 / 172.25) (resn GLH) +do (store3 = store3 / 199.48) (resn PHE) +do (store3 = store3 / 80.10) (resn GLY) +do (store3 = store3 / 182.88) (resn HIS) +do (store3 = store3 / 182.88) (resn NEP) +do (store3 = store3 / 175.12) (resn ILE) +do (store3 = store3 / 200.81) (resn LYS) +do (store3 = store3 / 200.81) (resn ALY) +do (store3 = store3 / 200.81) (resn MLZ) +do (store3 = store3 / 200.81) (resn MLY) +do (store3 = store3 / 200.81) (resn M3L) +do (store3 = store3 / 178.63) (resn LEU) +do (store3 = store3 / 194.15) (resn MET) +do (store3 = store3 / 194.15) (resn MSE) +do (store3 = store3 / 143.94) (resn ASN) +do (store3 = store3 / 136.13) (resn PRO) +do (store3 = store3 / 136.13) (resn HY3) +do (store3 = store3 / 136.13) (resn HYP) +do (store3 = store3 / 178.50) (resn GLN) +do (store3 = store3 / 238.76) (resn ARG) +do (store3 = store3 / 116.50) (resn SER) +do (store3 = store3 / 116.50) (resn SEC) +do (store3 = store3 / 116.50) (resn SEP) +do (store3 = store3 / 116.50) (resn PNS) +do (store3 = store3 / 139.27) (resn THR) +do (store3 = store3 / 139.27) (resn DDZ) +do (store3 = store3 / 139.27) (resn TOP) +do (store3 = store3 / 151.44) (resn VAL) +do (store3 = store3 / 249.36) (resn TRP) +do (store3 = store3 / 212.76) (resn TYR) +do (store3 = store3 / 212.76) (resn TYP) +do (store3 = store3 / 212.76) (resn PTR) +do (store3 = store3 / 212.76) (resn TYS) +do (store3 = store3 / 402.89) (resn QSR) +! DNA/RNA bases +do (store3 = store3 / 170.0) (resn A or resn DA) +do (store3 = store3 / 170.0) (resn C or resn DC) +do (store3 = store3 / 170.0) (resn G or resn DG) +do (store3 = store3 / 170.0) (resn T or resn DT) +do (store3 = store3 / 170.0) (resn U) +! +! Define random AIR restraints +! +evaluate ($icount = 1) +do (store4 = 0) (all) +do (store5 = 0) (all) + +! Check if segments defined from which to sample random AIRs +evaluate($nchain1 = 0) +while ($nchain1 < $data.ncomponents) loop nloop1 + evaluate($nchain1 = $nchain1 + 1) + evaluate($fcounter=0) + evaluate($samplesurf = false) + + if ($nrair_$nchain1 = 0) then + evaluate($samplesurf = true) + end if + + if ($samplesurf eq true) then + do (store5 = $nchain1) (segid $prot_segid_$nchain1) + display RANDOM AIRS SAMPLED FROM ENTIRE SURFACE FOR MOLECULE $nchain1 + else + evaluate ($numseg = $nrair_$nchain1) + display RANDOM AIRS SAMPLED FROM SEGMENTS FOR MOLECULE $nchain1 + while ($fcounter < $numseg) loop Xflex + evaluate($fcounter=$fcounter + 1) + do (store5 = $nchain1) ( resid $rair_sta_$nchain1_$fcounter : $rair_end_$nchain1_$fcounter + and segid $prot_segid_$nchain1) + display FLEXIBLE SEGMENT NR $fcounter FROM $rair_sta_$nchain1_$fcounter TO $rair_end_$nchain1_$fcounter + end loop Xflex + end if +end loop nloop1 + +! +! Filter out lipids +! +do (store3 = 0) ( resn DPP or resn PCW or resn PEE) +do (store5 = 0) ( resn DPP or resn PCW or resn PEE) + +for $atom_id in id ( tag and (attr store5 ne 0)) loop count + do (store4 = $icount) (byres (id $atom_id)) + show sum (store3) (byres (id $atom_id)) + do (store2 = $result) (byres (id $atom_id)) + evaluate ($icount = $icount + 1) +end loop count + +show min(store4) (segid $prot_segid_1 and (attr store5 ne 0)) +evaluate ($rmin = $result) + +show max(store4) (segid $prot_segid_1 and (attr store5 ne 0)) +evaluate ($rmax = $result) + +evaluate ($nres = $rmax - $rmin + 1) +display $nres RESIDUE IN MOLECULE A SELECTED FOR RANDOM AIR DEFINITION +if ($nres < 1) then + display NO RESIDUES IN DEFINED RANAIR SEGMENTS FOR MOLECULE A + display RANDOM RESTRAINTS DEFINITION FAILED + display STOPPING... + stop +end if + +if ($nres = 1) then + evaluate ($iselres1 = $rmax) +else + evaluate ($done = 0) + while ($done = 0) loop trial + evaluate ($iselres1 = 0) + evaluate ($iselres1 = int(ran() * $rmax) + 1) + evaluate ($iselres1 = min($iselres1, $rmax)) + show sum (store3) (attribute store4 = $iselres1) + if ($result > 0.2) then + evaluate ($done = 1) + end if + end loop trial +end if + +show min(store4) (segid $prot_segid_2 and (attr store5 ne 0)) +evaluate ($rmin = $result) + +show max(store4) (segid $prot_segid_2 and (attr store5 ne 0)) +evaluate ($rmax = $result) + +display $nres RESIDUE IN MOLECULE B SELECTED FOR RANDOM AIR DEFINITION +evaluate ($nres = $rmax - $rmin + 1) +if ($nres < 1) then + display NO RESIDUES IN DEFINED RANAIR SEGMENTS FOR MOLECULE B + display RANDOM RESTRAINTS DEFINITION FAILED + display STOPPING... + stop +end if + +if ($nres = 1) then + evaluate ($iselres2 = $rmax) +else + evaluate ($done = 0) + while ($done = 0) loop trial + evaluate ($iselres2 = 0) + evaluate ($iselres2 = int(ran() * ($rmax-$rmin+1)) + $rmin) + show sum (store3) (attribute store4 = $iselres2) + if ($result > 0.2) then + evaluate ($done = 1) + end if + end loop trial +end if + +show (resid) (attribute store4 = $iselres1 and tag) +evaluate ($selres1 = $result) +show (segid) (attribute store4 = $iselres1 and tag) +evaluate ($selseg1 = $result) +show (resn) (attribute store4 = $iselres1 and tag) +evaluate ($selnam1 = $result) + +show (resid) (attribute store4 = $iselres2 and tag) +evaluate ($selres2 = $result) +show (segid) (attribute store4 = $iselres2 and tag) +evaluate ($selseg2 = $result) +show (resn) (attribute store4 = $iselres2 and tag) +evaluate ($selnam2 = $result) + +evaluate ($dispname= $output_pdb_filename - ".pdb" + ".disp") +set display=$dispname end + +display $selnam1 $selres1 $selseg1 + +noe class ambig end + +noe + assign (resid $selres1 and segid $prot_segid_1) + (attr store2 > 0.2 and segid $prot_segid_2 and + attr store5 ne 0 and (resid $selres2 or (resid $selres2) around 7.5)) 2.0 2.0 0.0 + assign (resid $selres2 and segid $prot_segid_2) + (attr store2 > 0.2 and segid $prot_segid_1 and + attr store5 ne 0 and (resid $selres1 or (resid $selres1) around 7.5)) 2.0 2.0 0.0 +end + +for $id in id ((resid $selres1 and attr store2 > 0.2) around 5.0 and tag and segid $selseg1 and not resid $selres1) loop neighbors1 + show (resid) (id $id) + evaluate ($inres = $result) + show (segid) (id $id) + evaluate ($inseg = $result) + show (resn) (id $id) + evaluate ($inrsn = $result) + display $inrsn $inres $inseg + noe + assign (resid $inres and segid $prot_segid_1) + (attr store2 > 0.2 and segid $prot_segid_2 and + attr store5 ne 0 and (resid $selres2 or (resid $selres2) around 7.5)) 2.0 2.0 0.0 + end +end loop neighbors1 + +for $id in id ((resid $selres2 and attr store2 > 0.2) around 5.0 and tag and segid $selseg2 and not resid $selres2) loop neighbors2 + show (resid) (id $id) + evaluate ($inres = $result) + show (segid) (id $id) + evaluate ($inseg = $result) + show (resn) (id $id) + evaluate ($inrsn = $result) + display $inrsn $inres $inseg + noe + assign (resid $inres and segid $prot_segid_2) + (attr store2 > 0.2 and segid $prot_segid_1 and + attr store5 ne 0 and (resid $selres1 or (resid $selres1) around 7.5)) 2.0 2.0 0.0 + end +end loop neighbors2 + +close $dispname end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/read_noes.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/read_noes.cns new file mode 100644 index 0000000000000000000000000000000000000000..be5c0b8c55dbbd984e82a3fceb10553d0ee60281 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/read_noes.cns @@ -0,0 +1,65 @@ +! read_noes.cns +! Read the various restraints data +! In this version only distance-based restraints +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * Originally adapted from Aria 1.2 from Nilges and Linge, EMBL. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +! Ambiguous and unambiguous distance restraints, hbonds +noe + reset + nrestraints = 12000000 ! allocate space for NOEs + ceiling 1000 +end + +evaluate ($filenam0 = $ambig_fname + "_" + encode($count)) +fileexist $filenam0 end +if ($result eq false) then + evaluate ($filenam0 = $ambig_fname) +end if + +if ($filenam0 # "") then + fileexist $filenam0 end + if ($result eq true) then + noe class ambi @@$filenam0 end + end if +end if + +if ($Data.randremoval eq true) then + noe part $Data.npart end +end if + +if ($unambig_fname # "") then + fileexist $unambig_fname end + if ($result eq true) then + noe class dist @@$unambig_fname end + end if +end if + +if ($hbond_fname # "") then + fileexist $hbond_fname end + if ($result eq true) then + noe class hbon @@$hbond_fname end + end if +end if + +noe + averaging * sum + potential * soft + scale * 1.0 + sqconstant * 1.0 + sqexponent * 2 + soexponent * 1 + rswitch * 1.0 + sqoffset * 0.0 + asymptote * 2.0 + msoexponent * 1 + masymptote * -0.1 + mrswitch * 1.0 +end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/read_param.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/read_param.cns new file mode 100644 index 0000000000000000000000000000000000000000..6f549a453e49c118de295658c1294a8a429b9365 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/read_param.cns @@ -0,0 +1,64 @@ +! read_param.cns +! Reads parameter files. +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +!! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** + +{* protein parameter file *} +eval ($prot_parameter_infile="TOPPAR:protein-allhdg5-4.param") + +{* nucleic acid parameter file *} +eval ($nucl_parameter_infile="TOPPAR:dna-rna-allatom-hj-opls-1.3.param") + +{* carbohydrate parameter file *} +eval ($carbo_parameter_infile="TOPPAR:carbohydrate.param") + +{* solvent parameter file *} +eval ($solv_parameter_infile="TOPPAR:solvent-allhdg5-4.param") + +{* fragment probes parameter file *} +eval ($ligands_parameter_infile="TOPPAR:fragment_probes.param") + +{* ion parameter file *} +eval ($ion_parameter_infile="TOPPAR:ion.param") + +{* heme parameter file *} +eval ($heme_parameter_infile="TOPPAR:hemes-allhdg.param") + +{* shape parameter file *} +eval ($shape_parameter_infile="TOPPAR:shape.param") + +{* cofactors parameter file *} +eval ($cofactors_parameter_infile="TOPPAR:cofactors.param") + +parameter + @@$prot_parameter_infile + @@$ion_parameter_infile + @@$nucl_parameter_infile + @@$carbo_parameter_infile + @@$solv_parameter_infile + @@$ligands_parameter_infile + @@$heme_parameter_infile + @@$shape_parameter_infile + @@$cofactors_parameter_infile + if ($ligand_param_fname # "") then + fileexist $ligand_param_fname end + if ($result eq true) then + @@$ligand_param_fname + end if + end if +end + +parameter + nbonds + nbxmod=5 atom cdie shift + cutnb=9.5 ctofnb=8.5 ctonnb=6.5 eps=1.0 e14fac=0.4 inhibit 0.25 + wmin=0.5 tolerance 0.5 + end +end + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/rigidbody.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/rigidbody.cns new file mode 100644 index 0000000000000000000000000000000000000000..14405603351d382f6d8438fb56a4c3216357ec43 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/rigidbody.cns @@ -0,0 +1,617 @@ +! rigidbody.cns +! The basic rigid-body docking CNS script for HADDOCK3 with support only +! for distance-based restraints and symmetry restrainted +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * Originally adapted from Aria 1.2 from Nilges and Linge, EMBL. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** + +if ( $log_level = "verbose" ) then + set message=all echo=on end +elseif ( $log_level = "normal" ) then + set message=normal echo=off end +else + set message=off echo=off end +end if + +!==================================================================! +! Initialisation of variables +!==================================================================! + +evaluate ($saprotocol.crossdock=$crossdock) +evaluate ($saprotocol.randorien=$randorien) +evaluate ($saprotocol.rigidtrans=$rigidtrans) +evaluate ($saprotocol.ntrials=$ntrials) +evaluate ($saprotocol.inter_rigid=$inter_rigid) +evaluate ($saprotocol.rotate180=$rotate180) + +evaluate ($ini_count =1) +evaluate ($structures =$sampling) +evaluate ($w_vdw =$w_vdw) +evaluate ($w_elec =$w_elec) +evaluate ($w_air =$w_air) +evaluate ($w_rg =$w_rg) +evaluate ($w_sani =$w_sani) +evaluate ($w_xrdc =$w_xrdc) +evaluate ($w_xpcs =$w_xpcs) +evaluate ($w_dani =$w_dani) +evaluate ($w_vean =$w_vean) +evaluate ($w_cdih =$w_cdih) +evaluate ($w_sym =$w_sym) +evaluate ($w_zres =$w_zres) +evaluate ($w_bsa =$w_bsa) +evaluate ($w_deint =$w_deint) +evaluate ($w_desolv =$w_desolv) +evaluate ($w_lcc =$w_lcc) + + +evaluate ($data.ncomponents=$ncomponents) + +! non-bonded parameter set to use +evaluate ($toppar.par_nonbonded = "OPLSX") + +! Symmetry restraints +evaluate ($data.ksym = $ksym) +evaluate ($Data.flags.sym = $sym_on) +evaluate ($data.nc2sym = $nc2sym) +evaluate ($data.nc3sym = $nc3sym) +evaluate ($data.ns3sym = $ns3sym) +evaluate ($data.nc4sym = $nc4sym) +evaluate ($data.nc5sym = $nc5sym) +evaluate ($data.nc6sym = $nc6sym) + +if ( $data.nc2sym eq 6) then + evaluate ($saprotocol.rotate180 = false) +end if +if ( $data.nc3sym ne 0) then + evaluate ($saprotocol.rotate180 = false) +end if +if ( $data.nc4sym ne 0) then + evaluate ($saprotocol.rotate180 = false) +end if +if ( $data.nc5sym ne 0) then + evaluate ($saprotocol.rotate180 = false) +end if +if ( $data.nc6sym ne 0) then + evaluate ($saprotocol.rotate180 = false) +end if + +! distance restraints +evaluate ($Data.flags.noe = true) +evaluate ($data.randremoval=$randremoval) +evaluate ($data.npart=$npart) + +evaluate ($data.ambig_scale=$ambig_scale) +evaluate ($data.unambig_scale=$unambig_scale) +evaluate ($data.hbond_scale=$hbond_scale) + + +evaluate ($data.ranair=$ranair) +if ($data.ranair eq true) then + evaluate ($data.randremoval = false) +end if +evaluate ($data.cmrest=$cmrest) +evaluate ($data.cmtight=$cmtight) +evaluate ($data.kcm=$kcm) +evaluate ($data.surfrest=$surfrest) +evaluate ($data.ksurf=$ksurf) + + +!Electrostatics: +evaluate ($Data.flags.elec =$elecflag) +evaluate ($Data.epsilon =$epsilon) +evaluate ($Data.dielec =$dielec) + + +!Interaction matrix: +evaluate ($nmol1=1) +while ($nmol1 <=$data.ncomponents) loop mol1 + evaluate ($nmol2=$nmol1 + 1) + evaluate ($scale.int_$nmol1_$nmol1 =int_$nmol1_$nmol1) + while ($nmol2 <=$data.ncomponents) loop mol2 + evaluate ($scale.int_$nmol1_$nmol2 =$int_$nmol1_$nmol2) + evaluate ($scale.int_$nmol2_$nmol1 =$int_$nmol1_$nmol2) + evaluate ($nmol2=$nmol2 + 1) + end loop mol2 + evaluate ($nmol1 = $nmol1 + 1) +end loop mol1 + +! Unsupported restraints +evaluate ($Data.flags.cdih = false) +evaluate ($Data.flags.em = false) +evaluate ($Data.flags.rg = false) +evaluate ($Data.flags.zres = false) +evaluate ($Data.flags.sani = false) +evaluate ($Data.flags.xrdc = false) +evaluate ($Data.flags.xpcs = false) +evaluate ($Data.flags.dani = false) +evaluate ($Data.flags.vean = false) +evaluate ($Data.flags.ncs = false) + +! Other parameters +evaluate ($refine.keepwater = false) + +!==================================================================! + +@MODULE:read_param.cns + +igroup + interaction (not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) + (not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) weight * 1 end + interaction (resn ANI or resn DAN or resn XAN or resn DUM or resn DUM) + (resn ANI or resn DAN or resn XAN or resn DUM or resn DUM) weight * 1 vdw 0.0 elec 0.0 end + interaction (resn SHA) (not resn SHA) weight * 0 end +end + +flag include bond angle impr vdw end + +do (refx=x) (all) +do (refy=y) (all) +do (refz=z) (all) + +{* Read the distance restraints ================================ *} +set seed $seed end +set message=normal echo=on end +inline @MODULE:read_noes.cns ! rigidbody version with only distance restraints support + +{* random removal of restaints ================================== *} +if ($Data.randremoval eq true) then + noe cv $npart ? end +end if + +if ( $log_level = "verbose" ) then + set message=all echo=on end +elseif ( $log_level = "normal" ) then + set message=normal echo=off end +else + set message=off echo=off end +end if + +{* set distance restraint energy flag =========================== *} +if ($Data.flags.noe = TRUE) then + flags include noe end +end if + +{* ============================================================== *} +! determine whether the final models should be reoriented along their principal +! axes before writing to file in it0 and it1 +eval($reorient = true) +eval($fixmol = false) +evaluate ($ncount = 0) +while ($ncount < $data.ncomponents) loop orientmol + evaluate ($ncount = $ncount + 1) + eval($watersegname_$ncount="WA" + encode($ncount)) + if ($mol_fix_origin_$ncount eq true) then + eval($reorient = false) + eval($fixmol = true) + end if +end loop orientmol + + +{*======================= random orientations and rigid body minimisation *} +!Make sure that at least as many distance restraints are successfully +!read as the number of partitions for cross-validation +evaluate ($numnoe = 0) +noe ? end +if ($NUMNOE = 0) then + if ($Data.ncomponents > 1) then + if ($Data.surfrest eq FALSE) then + if ($Data.cmrest eq FALSE) then + if ($Data.ranair eq FALSE) then + evaluate ($errfile = "MODDIR:WARNING") + fileexist $errfile end + if ($result eq false) then + set display=$errfile end + display TOTAL NUMBER OF DISTANCE RESTRAINTS FOR RIGID BODY DOCKING IS ZERO! + display CONTROL YOUR PARAMETER SETTINGS AND RESTRAINT DEFINITIONS + display STRUCTURE NUMBER $count + close $errfile end + end if + end if + end if + end if + end if + evaluate ($Data.npart = 1) + evaluate ($Data.randremoval = FALSE) +end if + +if ($NUMNOE lt $Data.npart) then + noe part=1 end + evaluate ($Data.npart = 1) + evaluate ($Data.randremoval = FALSE) +end if + +flag excl bond angl dihe impr end + +if ($Data.flags.elec eq true) then + flag include elec end + if ($Data.dielec eq "rdie") then + parameter nbonds eps=$Data.epsilon rdie shift switch end end + ! shift statement needed first to activate switch (CNS bug?) + else + parameter nbonds eps=$Data.epsilon cdie shift end end + end if + parameter nbonds ? end end +else + evaluate ($elec=0.0) + flag exclude elec end +end if + +flag excl cdih end + +if ($Data.ranair eq true) then + if ($Data.ncomponents > 2) then + evaluate ($errfile = "MODDIR:FAILED") + fileexist $errfile end + if ($result eq false) then + set display=$errfile end + display ========= Unsupported option =========== + display Random definition of AIRs with more than + display two molecules currently unsupported + display ======================================== + close $errfile end + end if + stop + end if + evaluate ($Data.randremoval = false) + noe + reset + nrestraints = 100000 ! allocate space for NOEs + ceiling 1000 + class ambi + end + @MODULE:randomairs.cns + + noe + averaging * sum + potential * soft + scale * 1.0 + sqconstant * 1.0 + sqexponent * 2 + soexponent * 1 + rswitch * 1.0 + sqoffset * 0.0 + asymptote * 2.0 + msoexponent * 1 + masymptote * -0.1 + mrswitch * 1.0 + avexpo hbond 20 + end +end if + +@MODULE:symmultimer.cns + +if ($Data.cmrest eq true ) then + @MODULE:cm-restraints.cns +end if + +if ($Data.surfrest eq true ) then + @MODULE:surf-restraints.cns +end if + +flag excl ncs end +evaluate ($nrig = 0) +evaluate ($nfirst = 1) +evaluate ($bestair = 0) + +while ($nrig < $SaProtocol.ntrials) loop trials + + evaluate ($nrig = $nrig + 1) + + if ( $log_level = "verbose" ) then + set message=all echo=on end + elseif ( $log_level = "normal" ) then + set message=normal echo=off end + else + set message=off echo=off end + end if + + ! random placement of molecules + if ($SaProtocol.randorien eq true) then + @MODULE:separate.cns + @MODULE:random_rotations.cns + end if + + evaluate ($unambig_scale = 1.0) + evaluate ($ambig_scale = 1.0) + evaluate ($hbond_scale = 1.0) + evaluate ($symm_scale = 1.0) + evaluate ($cont_scale = 0.0) + evaluate ($surf_scale = 0.0) + + noe + scale dist $unambig_scale + scale ambi $ambig_scale + scale hbon $hbond_scale + scale symm $symm_scale + scale contact $cont_scale + scale surface $surf_scale + end + + evaluate ($kinter = $SaProtocol.inter_rigid) + @MODULE:scale_inter_mini.cns + + ! a few rounds of rotational rigid body minimization for each independent chain + evaluate ($imini = 0) + while ($imini le 4) loop rigmin + + evaluate ($imini = $imini + 1) + eval ($ministeps = 500 * nint ($data.ncomponents/6 + 1)) + if ($SaProtocol.randorien eq true) then + flag excl vdw elec end + end if + eval ($nchain1 = 0) + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + if ($mol_fix_origin_$nchain1 eq false) then + fix sele=(not all) end + fix sele=( not (segid $prot_segid_$nchain1 or segid $watersegname_$nchain1) and not name OO) end + minimize rigid + group ((segid $prot_segid_$nchain1 or segid $watersegname_$nchain1) and not name MAP) + translation=false + nstep $ministeps + drop 10.0 + tole 0.1 + nprint 10 + end + end if + end loop nloop1 + fix sele=(not all) end + + flag include vdw end + if ($Data.flags.elec eq true) then + flag include elec end + end if + + evaluate ($unambig_scale = min(($unambig_scale * 2),$Data.unambig_scale)) + evaluate ($ambig_scale = min(($ambig_scale * 2),$Data.ambig_scale)) + evaluate ($hbond_scale = min(($hbond_scale * 2),$Data.hbond_scale)) + evaluate ($symm_scale = min(($symm_scale * 2),$Data.ksym)) + + noe + scale dist $unambig_scale + scale ambi $ambig_scale + scale hbon $hbond_scale + scale symm $symm_scale + end + + end loop rigmin + + evaluate ($unambig_scale_store = $unambig_scale) + evaluate ($ambig_scale_store = $ambig_scale) + evaluate ($hbond_scale_store = $hbond_scale) + evaluate ($symm_scale_store = $symm_scale) + + flag include vdw end + if ($Data.flags.elec eq true) then + flag include elec end + end if + + if ($SaProtocol.rigidtrans eq true) then + + evaluate ($cont_scale = $data.kcm) + evaluate ($surf_scale = $data.ksurf) + noe + scale contact $cont_scale + scale surface $surf_scale + end + fix sele=(name OO and not resn XAN) end + minimize rigid + eval ($nchain1 = 0) + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + if ($mol_fix_origin_$nchain1 eq false) then + group ((segid $prot_segid_$nchain1 or segid $watersegname_$nchain1) and not name MAP) + end if + translation=false + end loop nloop1 + nstep 1000 + nprint 10 + end + + energy end + + fix sele=(name OO and not resn XAN) end + minimize rigid + eval ($nchain1 = 0) + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + if ($mol_fix_origin_$nchain1 eq false) then + group ((segid $prot_segid_$nchain1 or segid $watersegname_$nchain1) and not name MAP) + end if + translation=true + end loop nloop1 + nstep $ministeps + nprint 10 + end + + energy end + + fix sele=(name OO and not resn XAN) end + minimize rigid + eval ($nchain1 = 0) + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + if ($mol_fix_origin_$nchain1 eq false) then + group (segid $prot_segid_$nchain1 and not (resn WAT or resn HOH or resn TIP* or name MAP)) + end if + translation=true + end loop nloop1 + for $id in id (segid WA* and (resn WAT or resn HOH or resn TIP*) and name OH2 and (attr store5 ne 1)) loop miniwater + group (byres(id $id)) + end loop miniwater + translation=true + nstep $ministeps + nprint 10 + end + energy end + + fix sele=(not all) end + + end if ! ($Saprotocol.rigidtrans eq true) + + inline @MODULE:bestener.cns + + if ($saprotocol.rotate180 eq true) then + eval($nchain1 = 0) + while ($nchain1 < $data.ncomponents) loop nloop4 + eval($nchain1 = $nchain1 + 1) + if ($mol_shape_$nchain1 eq false) then + eval($nchain2 = $nchain1 ) + while ($nchain2 < $data.ncomponents) loop nloop3 + eval($nchain2 = $nchain2 + 1) + if ($mol_shape_$nchain2 eq false) then + @MODULE:rotation180.cns + inline @MODULE:bestener.cns + end if + end loop nloop3 + end if + end loop nloop4 + end if + +end loop trials + + +{* ===================== calculate complex internal energy *} +evaluate ($kinter = 1.0) +@MODULE:scale_intra_only.cns + +flag include bond angle dihe impr vdw end + +evaluate ($elec = 0.0) +evaluate ($eintfree = 0.0) +if ($Data.flags.elec eq true) then + flag include elec end +end if + +energy end + +evaluate ($eintcplx = $bond + $angl + $impr + $dihe + $vdw + $elec) +evaluate ($eintfree = $eintcplx) +{* at this stage the two are similar since rigid-body EM only *} + +evaluate ($ebond = $bond) +evaluate ($eangl= $angl) +evaluate ($eimpr= $impr) +evaluate ($edihe= $dihe) + +evaluate ($result=0) +print thres=0.05 bonds +evaluate ($rms_bonds=$result) +evaluate ($result=0) +print thres=5. angles +evaluate ($rms_angles=$result) +evaluate ($result=0) +print thres=5. impropers +evaluate ($rms_impropers=$result) +evaluate ($result=0) +print thres=30. dihedrals +evaluate ($rms_dihedrals=$result) + + +{* =========================== write out structure after rigid body refinement *} + +!bestener.cns: for waterdock, store3 contains store5 from lowest energy structure +do (x = refx) (not store3) +do (y = refy) (not store3) +do (z = refz) (not store3) + +evaluate ($esym = 0.0) +evaluate ($ncs = 0.0) +evaluate ($zhar = 0.0) +evaluate ($rms_test_noe = 0.0) +evaluate ($violations_test_noe = 0) +if ($Data.flags.sym eq true) then + noe reset nres= 2000000 end + @MODULE:symmultimer.cns + noe + scale symm $Data.ksym + end + energy end + evaluate ($esym = $noe) + if ($Data.randremoval eq true) then + display Print out of cross-validated violations and rms not + display possible in combination with symmetry restraints + display CV values set therefore to 0 + end if + noe reset end + set seed=$seed end + !read again the NOE data, needed to remove the symmetry restraints + inline @@MODULE:read_noes.cns + !random removal of restaints + if ($Data.randremoval eq true) then + noe cv $npart ? end + end if + print threshold=0.3 noe + evaluate ($rms_noe=$result) + evaluate ($violations_noe=$violations) + if ($Data.randremoval eq true) then + evaluate ($rms_test_noe=$test_rms) + evaluate ($violations_test_noe=$test_violations) + end if +else + print threshold=0.3 noe + evaluate ($rms_noe=$result) + evaluate ($violations_noe=$violations) + if ($Data.randremoval eq true) then + evaluate ($rms_test_noe=$test_rms) + evaluate ($violations_test_noe=$test_violations) + end if +end if + +evaluate ($unambig_scale = $Data.unambig_scale) +evaluate ($ambig_scale = $Data.ambig_scale) +evaluate ($hbond_scale = $Data.hbond_scale) + +noe + scale dist $unambig_scale + scale ambi $ambig_scale + scale hbon $hbond_scale + scale cont 0.0 +end + +{* ===================== calculate final energies and write structure *} +flag incl bond angl impr noe end + +if ($data.ncomponents > 1) then + evaluate ($kinter = 1.0) + @MODULE:scale_inter_final.cns +else + @MODULE:scale_intra_only.cns +end if + +energy end +evaluate ($cdih = 0.0) +evaluate ($etot = $ener - $noe) +evaluate ($noe = $bestair) +evaluate ($etot = $etot + $noe) + +evaluate ($Data.flags.dihed = false) +inline @MODULE:print_coorheader.cns + +if ($reorient eq true) then + coor sele=(segid $prot_segid_1) orient end +end if + +inline @MODULE:check_coordinates.cns + +if ($failure eq true) then + evaluate ($failfile = $output_pdb_filename - ".pdb" + ".fail") + set display=$failfile end + display "MAX/MIN possible coordinates exceeded - stopping" + close $failfile end + stop +else + write coordinates format=pdbo output=$output_pdb_filename end +end if + +set message=normal echo=on end +display OUTPUT: $output_pdb_filename + +! end of the recipe +stop diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/rotation180.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/rotation180.cns new file mode 100644 index 0000000000000000000000000000000000000000..cec7dd5d7d507ff1c37df7f0d9886b2a3fc30523 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/rotation180.cns @@ -0,0 +1,80 @@ +! rotation180.cns +! Perform a 180 degree rotation around a vector perpendicular to +! the interface of the complex +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +eval($distcu = 5.0) +eval($rotate180 = 180.0) +eval($xa = 0.0) +eval($ya = 0.0) +eval($za = 0.0) +eval($xb = 0.0) +eval($zb = 0.0) +eval($zb = 0.0) + +show aver (x) (segid $prot_segid_$nchain1 and ((segid $prot_segid_$nchain2) around $distcu)) +evaluate ($xa = $result) +show aver (y) (segid $prot_segid_$nchain1 and ((segid $prot_segid_$nchain2) around $distcu)) +evaluate ($ya = $result) +show aver (z) (segid $prot_segid_$nchain1 and ((segid $prot_segid_$nchain2) around $distcu)) +evaluate ($za = $result) +show aver (x) (segid $prot_segid_$nchain2 and ((segid $prot_segid_$nchain1) around $distcu)) +evaluate ($xb = $result) +show aver (y) (segid $prot_segid_$nchain2 and ((segid $prot_segid_$nchain1) around $distcu)) +evaluate ($yb = $result) +show aver (z) (segid $prot_segid_$nchain2 and ((segid $prot_segid_$nchain1) around $distcu)) +evaluate ($zb = $result) +eval($xdiff=$xa-$xb) +eval($ydiff=$ya-$yb) +eval($zdiff=$za-$zb) +eval($rnorm=$xdiff**2+$ydiff**2+$zdiff**2) + +if ($rnorm > 0.0) then + + coor + rotate sele= (segid $prot_segid_$nchain2 or segid $watersegname_$nchain2 and not name MAP) + center=($xa $ya $za) + axis ($xdiff $ydiff $zdiff) + $rotate180 + end + + fix sele=(name OO) end + + minimize rigid + eval ($nch1 = 0) + while ($nch1 < $data.ncomponents) loop nloop1 + eval($nch1 = $nch1 + 1) + if ($mol_fix_origin_$nch1 eq false) then + group (segid $prot_segid_$nch1 or segid $watersegname_$nch1 and not name MAP) + end if + translation=true + end loop nloop1 + translation=true + nstep 250 + nprint 10 + end + + minimize rigid + eval ($nch1 = 0) + while ($nch1 < $data.ncomponents) loop nloop1 + eval($nch1 = $nch1 + 1) + if ($mol_fix_origin_$nch1 eq false) then + group (segid $prot_segid_$nch1 or segid $watersegname_$nch1 and not name MAP) + end if + translation=true + end loop nloop1 + translation=true + nstep 250 + nprint 10 + end + + energy end + +end if diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/scale_inter_final.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/scale_inter_final.cns new file mode 100644 index 0000000000000000000000000000000000000000..efae5ce10a1fdafe1ef2f1d47a0ff9ebe57a1c8f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/scale_inter_final.cns @@ -0,0 +1,39 @@ +! scale_inter_final.cns +! Scaling of intermolecular interactions +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +igroup interaction (not all) (not all) end + +igroup + + eval($nchain1 = 0) + + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + eval($nchain2 = $nchain1 ) + while ($nchain2 < $data.ncomponents) loop nloop2 + eval($nchain2 = $nchain2 + 1) + eval($scalfac = $kinter * $scale.int_$nchain1_$nchain2) + interaction (segid $prot_segid_$nchain1 and not + (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA or resn DPP or resn PCW or resn PEE)) + (segid $prot_segid_$nchain2 and not + (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA or resn DPP or resn PCW or resn PEE)) weight * 1.0 vdw $scalfac elec $scalfac end + end loop nloop2 + + end loop nloop1 + + interaction (resn ANI) (resn ANI) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DAN) (resn DAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn XAN) (resn XAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DUM) (resn DUM) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (resn SHA) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (not resn SHA) weight * 0.0 end + +end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/scale_inter_mini.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/scale_inter_mini.cns new file mode 100644 index 0000000000000000000000000000000000000000..c8776f616b6a1743628001dbd59867294b2330b2 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/scale_inter_mini.cns @@ -0,0 +1,37 @@ +! scale_inter_mini.cns +! Scaling of intermolecular interations +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +igroup interaction (not all) (not all) end + +igroup + + eval($nchain1 = 0) + + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + eval($nchain2 = $nchain1 ) + while ($nchain2 < $data.ncomponents) loop nloop2 + eval($nchain2 = $nchain2 + 1) + eval($scalfac = $kinter * $scale.int_$nchain1_$nchain2) + interaction (segid $prot_segid_$nchain1 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) + (segid $prot_segid_$nchain2 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) weight * 1.0 vdw $scalfac elec $scalfac end + end loop nloop2 + + end loop nloop1 + + interaction (resn ANI) (resn ANI) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DAN) (resn DAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn XAN) (resn XAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DUM) (resn DUM) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (resn SHA) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (not resn SHA) weight * 0.0 end + +end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/scale_inter_only.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/scale_inter_only.cns new file mode 100644 index 0000000000000000000000000000000000000000..7abf15e4f42ad05aaeaf8c654c01ad1ea178d2c5 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/scale_inter_only.cns @@ -0,0 +1,41 @@ +! scale_inter_only.cns +! Scaling of intermolecular interaction (not internal energies) +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +igroup interaction (not all) (not all) end + +igroup + + eval($nchain1 = 0) + + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + eval($nchain2 = $nchain1 ) + while ($nchain2 < $data.ncomponents) loop nloop2 + eval($nchain2 = $nchain2 + 1) + eval($scalfac = $kinter * $mol_int_$nchain1_$nchain2) + interaction (segid $prot_segid_$nchain1 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) + (segid $prot_segid_$nchain2 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) weight * 1.0 vdw $scalfac elec $scalfac end + end loop nloop2 + interaction (segid $prot_segid_$nchain1 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) + ((resn WAT or resn HOH or resn TIP* or resn DMS)) weight * 1.0 vdw $kinter elec $kinter end + + end loop nloop1 + + interaction ((resn WAT or resn HOH or resn TIP*)) ((resn WAT or resn HOH or resn TIP*)) weight * 1.0 end + + interaction (resn ANI) (resn ANI) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DAN) (resn DAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn XAN) (resn XAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DUM) (resn DUM) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (resn SHA) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (not resn SHA) weight * 0.0 end + +end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/scale_intra_only.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/scale_intra_only.cns new file mode 100644 index 0000000000000000000000000000000000000000..15b0adfbb562862214f161c494c14a17dbf6beb7 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/scale_intra_only.cns @@ -0,0 +1,36 @@ +! scale_intra_only.cns +! Scaling of intramolecular energies (no intermolecular energies) +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +igroup interaction (not all) (not all) end + +igroup + + eval($nchain1 = 0) + + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + + interaction (segid $prot_segid_$nchain1 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) + (segid $prot_segid_$nchain1 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) weight * 1.0 end + + end loop nloop1 + + interaction (resn ANI) (resn ANI) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DAN) (resn DAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn XAN) (resn XAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DUM) (resn DUM) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (resn SHA) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (not resn SHA) weight * 0.0 end + +end + + + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/separate.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/separate.cns new file mode 100644 index 0000000000000000000000000000000000000000..b25ebaee28aca28e90322a5466a5700a2f100538 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/separate.cns @@ -0,0 +1,236 @@ +! separate.cns +! Distribute molecules in 3D space +! Orient each molecule according to its principal axes +! and restore them all at the end (after the while loop) +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +! first flag all fixed molecules +do (store4 = 0) (all) +evaluate ($ncount = 0) +evaluate ($nfixed = 0) +while ($ncount < $data.ncomponents) loop orientmol + evaluate ($ncount = $ncount + 1) + if ($mol_fix_origin_$ncount eq true) then + evaluate ($nfixed = $nfixed + 1) + do (store4 = 1) (segid $prot_segid_$ncount) + end if +end loop orientmol + +if ($nfixed < $data.ncomponents) then + + evaluate ($xc = 0.0) + evaluate ($yc = 0.0) + evaluate ($zc = 0.0) + ! then define the geometrical center of the fixed molecules if present + show sum (store4) (all) + if ($result > 0) then + show ave (x) (attribute store4 = 1) + evaluate ($xc = $result) + show ave (y) (attribute store4 = 1) + evaluate ($yc = $result) + show ave (z) (attribute store4 = 1) + evaluatee ($zc = $result) + end if + + do (xcomp = x) (all) + do (ycomp = y) (all) + do (zcomp = z) (all) + + ! then orient each moving molecule separately at the origin + ! and translate it to the geometric center of the fixed molecules + evaluate ($ncount = 0) + while ($ncount < $data.ncomponents) loop orientmol + evaluate ($ncount = $ncount +1) + eval($watersegname_$ncount="WA" + encode($ncount)) + if ($mol_fix_origin_$ncount eq false) then + coor orient sele=(segid $prot_segid_$ncount or segid $watersegname_$ncount) end + coor sele=(segid $prot_segid_$ncount or segid $watersegname_$ncount) translate vector = ($xc $yc $zc) end + do (xcomp = x) (segid $prot_segid_$ncount or segid $watersegname_$ncount) + do (ycomp = y) (segid $prot_segid_$ncount or segid $watersegname_$ncount) + do (zcomp = z) (segid $prot_segid_$ncount or segid $watersegname_$ncount) + end if + end loop orientmol + + do (x = xcomp) (not (resn ANI or resn XAN or resn DAN)) + do (y = ycomp) (not (resn ANI or resn XAN or resn DAN)) + do (z = zcomp) (not (resn ANI or resn XAN or resn DAN)) + + ! Find the largest axis of all molecules + evaluate ($minispacing = 25.0) + evaluate ($mxdim = 0) + evaluate ($ncount = 0) + + while ($ncount < $data.ncomponents) loop findmax + evaluate ($ncount = $ncount +1) + + show max (x) (segid $prot_segid_$ncount or segid $watersegname_$ncount) + evaluate ($xdim = $result) + show min (x) (segid $prot_segid_$ncount or segid $watersegname_$ncount) + evaluate ($xdim = $xdim - $result) + + show max (y) (segid $prot_segid_$ncount or segid $watersegname_$ncount) + evaluate ($ydim = $result) + show min (y) (segid $prot_segid_$ncount or segid $watersegname_$ncount) + evaluate ($ydim = $ydim - $result) + + show max (z) (segid $prot_segid_$ncount or segid $watersegname_$ncount) + evaluate ($zdim = $result) + show min (z) (segid $prot_segid_$ncount or segid $watersegname_$ncount) + evaluate ($zdim = $zdim - $result) + + ! Check which dimension (x,y,z) is the largest = mxdim + evaluate ($mxdim = max($mxdim, $xdim, $ydim, $zdim)) + + end loop findmax + + evaluate ($spacing = $minispacing + $mxdim ) + display SPACING SET TO $spacing ANGSTROM + + ! This has to be manually coded because of the variable name + ! Should be fine since we support only a few types of symmetry + ! Maybe change the variable name later if these are expanded + ! to have the number at the end? + + inline @MODULE:check-homomers.cns + + if ($homosymmetry eq true) then + ! In case of homosymmetry, place molecules in a plane + do (store4 = 0) (all) + evaluate ($ncount = 0) + while ($ncount < $data.ncomponents) loop orientmol + evaluate ($ncount = $ncount + 1) + if ($mol_fix_origin_$ncount eq false) then + do (store4 = 1) (segid $prot_segid_$ncount) + end if + end loop orientmol + + {* translate and generate symmetric positions by rotation around z *} + coor trans sele=(attr store4=1) vector=($spacing,0,0) end + + ! if one molecule is fixed (e.g. plane), move all others along z-axis + !if ($data.ncomponents > $n_moving_mol) then + ! coor trans sele=(attr store4=1) vector=(0,0,$spacing) end + !end if + + evaluate ($ncount = 2) + evaluate ($increment = 360/$n_moving_mol) + while ($ncount le $data.ncomponents) loop orientsym + + if ($mol_fix_origin_$ncount eq false) then + {* rotate around z axis *} + evaluate ($xr = $increment) + evaluate ($x1 = cos($xr)) + evaluate ($x2 = -sin($xr)) + evaluate ($x3 = 0 ) + evaluate ($y1 = sin($xr)) + evaluate ($y2 = cos($xr)) + evaluate ($y3 = 0 ) + evaluate ($z1 = 0 ) + evaluate ($z2 = 0 ) + evaluate ($z3 = 1 ) + coor + center=($xc $yc $zc) + rotate matrix=($x1 $x2 $x3) ($y1 $y2 $y3) ($z1 $z2 $z3) + sele=(segid $prot_segid_$ncount or segid $watersegname_$ncount) + end + evaluate ($increment = $xr + 360/$n_moving_mol) + + end if + evaluate ($ncount = $ncount + 1) + + end loop orientsym + + else + ! Do we need fix any molecule? + evaluate($n_moving_mol = 0) + evaluate ($ncount = 0) + while ($ncount < $data.ncomponents) loop centermol + evaluate ($ncount = $ncount + 1) + if ($mol_fix_origin_$ncount eq false) then + evaluate($n_moving_mol = $n_moving_mol + 1) + end if + end loop centermol + + ! Translate molecules to positions calculated using an algorithm + ! based on minimization of electrostatic potential of N equally charged particles. + ! See Thomson problem: http://en.wikipedia.org/wiki/Thomson_problem + evaluate ($filename = "TOPPAR:initial_positions/trans_vector_" + encode($n_moving_mol) ) + inline @@$filename + + ! Logic: + ! Assign a random number larger than 0 to every molecule + ! Assign 0.0 to fixed molecules + ! For every i up to the number of molecules + ! pick the mol with the largest number and displace it + ! then zero its number. + ! This will place molecules in space sort of randomly + ! Stop when the sum of all numbers is zero + + ! Generate as many random numbers as the # of mols + evaluate ($ncount = 0) + while ($ncount < $data.ncomponents) loop genrandom + evaluate ($ncount = $ncount + 1) + if ($mol_fix_origin_$ncount eq true) then + evaluate ($random_$ncount = 0.0) + else + evaluate ($random_$ncount = random()) + end if + end loop genrandom + + ! Randomly pick a molecule and place it + ! on the pre-defined position - iterate + evaluate ($sum_random = 999) + evaluate ($molcounter = 1) + + while ($sum_random > 0) loop placemol + evaluate ($maximum = 0) + evaluate ($maxid = 0) + evaluate ($ncount = 0) + + ! Select molecule with largest random number + while ($ncount < $data.ncomponents) loop selectmol + evaluate ($ncount = $ncount + 1) + if ($random_$ncount > $maximum) then + evaluate ($maximum = $random_$ncount) + evaluate ($maxid = $ncount) + end if + end loop selectmol + + if ($mol_fix_origin_$maxid eq false) then + coor trans + sele=(segid $prot_segid_$maxid or segid $watersegname_$maxid) + vector=($x_$molcounter, $y_$molcounter, $z_$molcounter) + end + + ! Reset random_ncount to 0 to avoid re-selecting + evaluate ($random_$maxid = 0) + + ! Increment molcounter to update new + evaluate ($molcounter = $molcounter + 1) + + ! Update sum_random + evaluate ($ncount = 0) + evaluate ($sum_random = 0) + + while ($ncount < $data.ncomponents) loop resetsumrandom + evaluate ($ncount = $ncount + 1) + evaluate( $sum_random = $sum_random + $random_$ncount) + end loop resetsumrandom + + end if + end loop placemol + end if + + do (x = refx) (resn ANI or resn DAN or resn XAN) + do (y = refy) (resn ANI or resn DAN or resn XAN) + do (z = refz) (resn ANI or resn DAN or resn XAN) + +end if diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/surf-restraints.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/surf-restraints.cns new file mode 100644 index 0000000000000000000000000000000000000000..7ea400ff205e3f356854b16b6cff493e15ad1e9d --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/surf-restraints.cns @@ -0,0 +1,69 @@ +! surf-restraints.cns +! Define surface contact restraints +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +!define surface contact restraints between all molecules +!using distance restraints between CA atoms with sum averaging + +eval($nchain = 0) +do (store9 = 0) (all) +do (store9 = 1) (name CA or name BB or name N1) +while ($nchain < $data.ncomponents) loop nloop0 + eval($nchain = $nchain + 1) + show sum (store9) (segid $prot_segid_$nchain) + if ($result < 3) then + evaluate ($selat$nchain = 0) + evaluate ($dist$nchain = 1.0) + else + evaluate ($selat$nchain = 1) + evaluate ($dist$nchain = 3.5) + end if +end loop nloop0 + +eval($nchain1 = 0) +noe class surface + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + eval($nchain2 = $nchain1 ) + while ($nchain2 < $data.ncomponents) loop nloop2 + eval($nchain2 = $nchain2 + 1) + evaluate ($updist = $dist$nchain1 + $dist$nchain2) + if ($selat$nchain1 = 1) then + if ($selat$nchain2 = 1) then + assign (segid $prot_segid_$nchain1 and ( name CA or name BB or name N1 )) + (segid $prot_segid_$nchain2 and ( name CA or name BB or name N1 )) $updist $updist 1.0 + else + assign (segid $prot_segid_$nchain1 and ( name CA or name BB or name N1 )) + (segid $prot_segid_$nchain2) $updist $updist 1.0 + end if + else + if ($selat$nchain2 = 1) then + assign (segid $prot_segid_$nchain1) + (segid $prot_segid_$nchain2 and ( name CA or name BB or name N1 )) $updist $updist 1.0 + else + assign (segid $prot_segid_$nchain1) + (segid $prot_segid_$nchain2) $updist $updist 1.0 + end if + end if + end loop nloop2 + end loop nloop1 + + averaging surface sum + scale surface $Data.ksurf + sqconstant surface 1.0 + sqexponent surface 2 + soexponent surface 1 + rswitch surface 1.0 + sqoffset surface 0.0 + asymptote surface 2.0 + msoexponent surface 1 + masymptote surface -0.1 + mrswitch surface 1.0 +end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/symmultimer.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/symmultimer.cns new file mode 100644 index 0000000000000000000000000000000000000000..3b4f731e948bf1d58eab0f71f457da6e52afc3e9 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/sampling/rigidbody/cns/symmultimer.cns @@ -0,0 +1,677 @@ +! symmultimer.cns +! Define symmetry restraints +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * Originally adapted from Aria 1.2 from Nilges and Linge, EMBL. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +if ($Data.flags.sym eq true) then + + noe class symm end + + ! Define C2 symmetry restraints for symmetrical multimers + ! + eval ($ncount = 0) + while ($ncount < $data.nc2sym) loop c2symloop + + eval ($ncount = $ncount + 1) + evaluate ($i1start = $c2sym_sta1_$ncount) + evaluate ($i1end = $c2sym_end1_$ncount) + evaluate ($chain1 = $c2sym_seg1_$ncount) + evaluate ($i2start = $c2sym_sta2_$ncount) + evaluate ($i2end = $c2sym_end2_$ncount) + evaluate ($chain2 = $c2sym_seg2_$ncount) + + !first check that the chain lengths are equal for the two defined molecules + evaluate ($diff1 = $i1end - $i1start) + evaluate ($diff2 = $i2end - $i2start) + if ($diff1 ne $diff2) then + display CHAIN LENGTH FOR SYMMETRY RESTRAINTS DOES NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + + eval ($icount = 0) + while ($i1start < $i1end) loop genc2sym + + evaluate ($resid1 = $i1start) + evaluate ($resid2 = $i2end - $icount) + evaluate ($resid3 = $i2start) + evaluate ($resid4 = $i1end - $icount) + + noe + assign (resid $resid1 and (name CA or name P or name BB) and segid $chain1) + (resid $resid2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resid3 and (name CA or name P or name BB) and segid $chain2) + (resid $resid4 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + end + + evaluate ($icount = $icount + 1) + evaluate ($i1start = $i1start + 1) + evaluate ($i2start = $i2start + 1) + + end loop genc2sym + + end loop c2symloop + + + ! Define C3 symmetry restraints for symmetrical multimers + ! + eval ($ncount = 0) + while ($ncount < $data.nc3sym) loop c3symloop + + eval ($ncount = $ncount + 1) + evaluate ($i1start = $c3sym_sta1_$ncount) + evaluate ($i1end = $c3sym_end1_$ncount) + evaluate ($chain1 = $c3sym_seg1_$ncount) + evaluate ($i2start = $c3sym_sta2_$ncount) + evaluate ($i2end = $c3sym_end2_$ncount) + evaluate ($chain2 = $c3sym_seg2_$ncount) + evaluate ($i3start = $c3sym_sta3_$ncount) + evaluate ($i3end = $c3sym_end3_$ncount) + evaluate ($chain3 = $c3sym_seg3_$ncount) + + !first check that the chain lengths are equal for the two defined molecules + evaluate ($diff1 = $i1end - $i1start) + evaluate ($diff2 = $i2end - $i2start) + evaluate ($diff3 = $i3end - $i3start) + if ($diff1 ne $diff2) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff1 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff2 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + + eval ($icount = 0) + while ($i1start < $i1end) loop genc3sym + + evaluate ($resst1 = $i1start) + evaluate ($resst2 = $i2start) + evaluate ($resst3 = $i3start) + evaluate ($resen1 = $i1end - $icount) + evaluate ($resen2 = $i2end - $icount) + evaluate ($resen3 = $i3end - $icount) + + noe + + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resen2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resen3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resen3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resen1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resen1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resen2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + + end + + evaluate ($icount = $icount + 2) + evaluate ($i1start = $i1start + 2) + evaluate ($i2start = $i2start + 2) + evaluate ($i3start = $i3start + 2) + + end loop genc3sym + + end loop c3symloop + + ! Define S3 symmetry restraints for symmetrical multimers + ! + eval ($ncount = 0) + while ($ncount < $data.ns3sym) loop s3symloop + + eval ($ncount = $ncount + 1) + evaluate ($i1start = $s3sym_sta1_$ncount) + evaluate ($i1end = $s3sym_end1_$ncount) + evaluate ($chain1 = $s3sym_seg1_$ncount) + evaluate ($i2start = $s3sym_sta2_$ncount) + evaluate ($i2end = $s3sym_end2_$ncount) + evaluate ($chain2 = $s3sym_seg2_$ncount) + evaluate ($i3start = $s3sym_sta3_$ncount) + evaluate ($i3end = $s3sym_end3_$ncount) + evaluate ($chain3 = $s3sym_seg3_$ncount) + + !first check that the chain lengths are equal for the two defined molecules + evaluate ($diff1 = $i1end - $i1start) + evaluate ($diff2 = $i2end - $i2start) + evaluate ($diff3 = $i3end - $i3start) + if ($diff1 ne $diff2) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff1 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff2 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + + eval ($icount = 0) + eval ($istep = 4) + eval ($istop = $i1end - $istep) + while ($i1start < $istop) loop gens3sym + + evaluate ($resst11 = $i1start) + evaluate ($resst21 = $i1start+1) + evaluate ($resst12 = $i2start) + evaluate ($resst22 = $i2start+1) + evaluate ($resst13 = $i3start) + evaluate ($resst23 = $i3start+1) + + + noe + + assign (resid $resst11 and (name CA or name P or name BB) and segid $chain1) + (resid $resst12 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resst12 and (name CA or name P or name BB) and segid $chain2) + (resid $resst13 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + + assign (resid $resst21 and (name CA or name P or name BB) and segid $chain1) + (resid $resst22 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resst22 and (name CA or name P or name BB) and segid $chain2) + (resid $resst23 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + + end + + evaluate ($icount = $icount + $istep) + evaluate ($i1start = $i1start + $istep) + evaluate ($i2start = $i2start + $istep) + evaluate ($i3start = $i3start + $istep) + + end loop gens3sym + + end loop s3symloop + + ! Define C4 symmetry restraints for symmetrical multimers + ! + eval ($istep = 10) + eval ($ncount = 0) + while ($ncount < $data.nc4sym) loop c4symloop + + eval ($ncount = $ncount + 1) + evaluate ($i1start = $c4sym_sta1_$ncount) + evaluate ($i1end = $c4sym_end1_$ncount) + evaluate ($chain1 = $c4sym_seg1_$ncount) + evaluate ($i2start = $c4sym_sta2_$ncount) + evaluate ($i2end = $c4sym_end2_$ncount) + evaluate ($chain2 = $c4sym_seg2_$ncount) + evaluate ($i3start = $c4sym_sta3_$ncount) + evaluate ($i3end = $c4sym_end3_$ncount) + evaluate ($chain3 = $c4sym_seg3_$ncount) + evaluate ($i4start = $c4sym_sta4_$ncount) + evaluate ($i4end = $c4sym_end4_$ncount) + evaluate ($chain4 = $c4sym_seg4_$ncount) + + !first check that the chain lengths are equal for the four defined molecules + evaluate ($diff1 = $i1end - $i1start) + evaluate ($diff2 = $i2end - $i2start) + evaluate ($diff3 = $i3end - $i3start) + evaluate ($diff4 = $i4end - $i4start) + if ($diff1 ne $diff2) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff1 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff1 ne $diff4) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff2 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff2 ne $diff4) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff3 ne $diff4) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + + eval ($icount = 0) + while ($i1start < $i1end) loop genc4sym + + evaluate ($resst1 = $i1start) + evaluate ($resst2 = $i2start) + evaluate ($resst3 = $i3start) + evaluate ($resst4 = $i4start) + evaluate ($resen1 = $i1end - $icount) + evaluate ($resen2 = $i2end - $icount) + evaluate ($resen3 = $i3end - $icount) + evaluate ($resen4 = $i4end - $icount) + + noe + + ! N to N sequential restraints to prevent anti-parallel arrangements + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resst2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resst3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resst3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resst4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resst4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resst1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resst1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resst2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + + ! N to C sequential restraints to assure planarity + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resen2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resen3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resen3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resen4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resen4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resen1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resen1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resen2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + + assign (resid $resen1 and (name CA or name P or name BB) and segid $chain1) + (resid $resst2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resen2 and (name CA or name P or name BB) and segid $chain2) + (resid $resst3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + + assign (resid $resen2 and (name CA or name P or name BB) and segid $chain2) + (resid $resst3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + assign (resid $resen3 and (name CA or name P or name BB) and segid $chain3) + (resid $resst4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + + assign (resid $resen3 and (name CA or name P or name BB) and segid $chain3) + (resid $resst4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + assign (resid $resen4 and (name CA or name P or name BB) and segid $chain4) + (resid $resst1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + + assign (resid $resen4 and (name CA or name P or name BB) and segid $chain4) + (resid $resst1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + assign (resid $resen1 and (name CA or name P or name BB) and segid $chain1) + (resid $resst2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + + end + + evaluate ($icount = $icount + $istep) + evaluate ($i1start = $i1start + $istep) + evaluate ($i2start = $i2start + $istep) + evaluate ($i3start = $i3start + $istep) + evaluate ($i4start = $i4start + $istep) + + end loop genc4sym + + end loop c4symloop + + + ! Define C5 symmetry restraints for symmetrical multimers + ! + eval ($istep = 4) + eval ($ncount = 0) + while ($ncount < $data.nc5sym) loop c5symloop + + eval ($ncount = $ncount + 1) + evaluate ($i1start = $c5sym_sta1_$ncount) + evaluate ($i1end = $c5sym_end1_$ncount) + evaluate ($chain1 = $c5sym_seg1_$ncount) + evaluate ($i2start = $c5sym_sta2_$ncount) + evaluate ($i2end = $c5sym_end2_$ncount) + evaluate ($chain2 = $c5sym_seg2_$ncount) + evaluate ($i3start = $c5sym_sta3_$ncount) + evaluate ($i3end = $c5sym_end3_$ncount) + evaluate ($chain3 = $c5sym_seg3_$ncount) + evaluate ($i4start = $c5sym_sta4_$ncount) + evaluate ($i4end = $c5sym_end4_$ncount) + evaluate ($chain4 = $c5sym_seg4_$ncount) + evaluate ($i5start = $c5sym_sta5_$ncount) + evaluate ($i5end = $c5sym_end5_$ncount) + evaluate ($chain5 = $c5sym_seg5_$ncount) + + !first check that the chain lengths are equal for the two defined molecules + evaluate ($diff1 = $i1end - $i1start) + evaluate ($diff2 = $i2end - $i2start) + evaluate ($diff3 = $i3end - $i3start) + evaluate ($diff4 = $i4end - $i4start) + evaluate ($diff5 = $i5end - $i5start) + if ($diff1 ne $diff2) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff1 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff2 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff3 ne $diff4) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff4 ne $diff5) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + + eval ($icount = 0) + while ($i1start < $i1end) loop genc5sym + + evaluate ($resst1 = $i1start) + evaluate ($resst2 = $i2start) + evaluate ($resst3 = $i3start) + evaluate ($resst4 = $i4start) + evaluate ($resst5 = $i5start) + evaluate ($resen1 = $i1end - $icount) + evaluate ($resen2 = $i2end - $icount) + evaluate ($resen3 = $i3end - $icount) + evaluate ($resen4 = $i4end - $icount) + evaluate ($resen5 = $i5end - $icount) + + noe + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resst3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resst4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resst4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resst5 and (name CA or name P or name BB) and segid $chain5) 0 0 0 + + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resst5 and (name CA or name P or name BB) and segid $chain5) 0 0 0 + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resst1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resst1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resst2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + + assign (resid $resst5 and (name CA or name P or name BB) and segid $chain5) + (resid $resst2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resst5 and (name CA or name P or name BB) and segid $chain5) + (resid $resst3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + + end + + evaluate ($icount = $icount + $istep) + evaluate ($i1start = $i1start + $istep) + evaluate ($i2start = $i2start + $istep) + evaluate ($i3start = $i3start + $istep) + evaluate ($i4start = $i4start + $istep) + evaluate ($i5start = $i5start + $istep) + + end loop genc5sym + + end loop c5symloop + + ! Define C6 symmetry restraints for symmetrical multimers + ! + eval ($istep = 10) + eval ($ncount = 0) + while ($ncount < $data.nc6sym) loop c6symloop + + eval ($ncount = $ncount + 1) + evaluate ($i1start = $c6sym_sta1_$ncount) + evaluate ($i1end = $c6sym_end1_$ncount) + evaluate ($chain1 = $c6sym_seg1_$ncount) + evaluate ($i2start = $c6sym_sta2_$ncount) + evaluate ($i2end = $c6sym_end2_$ncount) + evaluate ($chain2 = $c6sym_seg2_$ncount) + evaluate ($i3start = $c6sym_sta3_$ncount) + evaluate ($i3end = $c6sym_end3_$ncount) + evaluate ($chain3 = $c6sym_seg3_$ncount) + evaluate ($i4start = $c6sym_sta4_$ncount) + evaluate ($i4end = $c6sym_end4_$ncount) + evaluate ($chain4 = $c6sym_seg4_$ncount) + evaluate ($i5start = $c6sym_sta5_$ncount) + evaluate ($i5end = $c6sym_end5_$ncount) + evaluate ($chain5 = $c6sym_seg5_$ncount) + evaluate ($i6start = $c6sym_sta6_$ncount) + evaluate ($i6end = $c6sym_end6_$ncount) + evaluate ($chain6 = $c6sym_seg6_$ncount) + + !first check that the chain lengths are equal for the two defined molecules + evaluate ($diff1 = $i1end - $i1start) + evaluate ($diff2 = $i2end - $i2start) + evaluate ($diff3 = $i3end - $i3start) + evaluate ($diff4 = $i4end - $i4start) + evaluate ($diff5 = $i5end - $i5start) + evaluate ($diff6 = $i6end - $i6start) + if ($diff1 ne $diff2) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff1 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff2 ne $diff3) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff3 ne $diff4) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff4 ne $diff5) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + if ($diff5 ne $diff6) then + display CHAIN LENGHT FOR SYMMETRY RESTRAINTS DO NOT MATCH + display PLEASE CHECK CAREFULLY YOUR INPUT + display ... stopping ... + stop + end if + + eval ($icount = 0) + while ($i1start < $i1end) loop genc6sym + + evaluate ($resst1 = $i1start) + evaluate ($resst2 = $i2start) + evaluate ($resst3 = $i3start) + evaluate ($resst4 = $i4start) + evaluate ($resst5 = $i5start) + evaluate ($resst6 = $i6start) + evaluate ($resen1 = $i1end - $icount) + evaluate ($resen2 = $i2end - $icount) + evaluate ($resen3 = $i3end - $icount) + evaluate ($resen4 = $i4end - $icount) + evaluate ($resen5 = $i5end - $icount) + evaluate ($resen6 = $i6end - $icount) + + noe + + ! Around the C6 ring + ! N to N sequential restraints to prevent anti-parallel arrangements + + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resst2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resst3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resst3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resst4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resst4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resst5 and (name CA or name P or name BB) and segid $chain5) 0 0 0 + + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resst5 and (name CA or name P or name BB) and segid $chain5) 0 0 0 + assign (resid $resst5 and (name CA or name P or name BB) and segid $chain5) + (resid $resst6 and (name CA or name P or name BB) and segid $chain6) 0 0 0 + + assign (resid $resst5 and (name CA or name P or name BB) and segid $chain5) + (resid $resst6 and (name CA or name P or name BB) and segid $chain6) 0 0 0 + assign (resid $resst6 and (name CA or name P or name BB) and segid $chain6) + (resid $resst1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + + assign (resid $resst6 and (name CA or name P or name BB) and segid $chain6) + (resid $resst1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resst2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + + ! N to C sequential restraints to assure planarity + + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resen2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resen3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resen3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resen4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resen4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resen5 and (name CA or name P or name BB) and segid $chain5) 0 0 0 + + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resen5 and (name CA or name P or name BB) and segid $chain5) 0 0 0 + assign (resid $resst5 and (name CA or name P or name BB) and segid $chain5) + (resid $resen6 and (name CA or name P or name BB) and segid $chain6) 0 0 0 + + assign (resid $resst5 and (name CA or name P or name BB) and segid $chain5) + (resid $resen6 and (name CA or name P or name BB) and segid $chain6) 0 0 0 + assign (resid $resst6 and (name CA or name P or name BB) and segid $chain6) + (resid $resen1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + + ! Triples + + assign (resid $resst1 and (name CA or name P or name BB) and segid $chain1) + (resid $resen3 and (name CA or name P or name BB) and segid $chain3) 0 0 0 + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resen5 and (name CA or name P or name BB) and segid $chain5) 0 0 0 + + assign (resid $resst3 and (name CA or name P or name BB) and segid $chain3) + (resid $resen5 and (name CA or name P or name BB) and segid $chain5) 0 0 0 + assign (resid $resst5 and (name CA or name P or name BB) and segid $chain5) + (resid $resen1 and (name CA or name P or name BB) and segid $chain1) 0 0 0 + + assign (resid $resst2 and (name CA or name P or name BB) and segid $chain2) + (resid $resen4 and (name CA or name P or name BB) and segid $chain4) 0 0 0 + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resen6 and (name CA or name P or name BB) and segid $chain6) 0 0 0 + + assign (resid $resst4 and (name CA or name P or name BB) and segid $chain4) + (resid $resen6 and (name CA or name P or name BB) and segid $chain6) 0 0 0 + assign (resid $resst6 and (name CA or name P or name BB) and segid $chain6) + (resid $resen2 and (name CA or name P or name BB) and segid $chain2) 0 0 0 + + end + + evaluate ($icount = $icount + $istep) + evaluate ($i1start = $i1start + $istep) + evaluate ($i2start = $i2start + $istep) + evaluate ($i3start = $i3start + $istep) + evaluate ($i4start = $i4start + $istep) + evaluate ($i5start = $i5start + $istep) + evaluate ($i6start = $i6start + $istep) + + end loop genc6sym + + end loop c6symloop + + + noe + potential symm symmetry + scale symm $Data.ksym + sqconstant symm 1.0 + sqexponent symm 2 + soexponent symm 1 + rswitch symm 0.5 + sqoffset symm 0.0 + asymptote symm 1.0 + end + +end if diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..478d1e9088c7f6d7b745248e771e332728d670e6 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/__init__.py @@ -0,0 +1,305 @@ +"""HADDOCK3 modules to score models.""" +import pandas as pd + +from haddock.core.typing import FilePath, Optional, Path, Any +from haddock.gear.haddockmodel import HaddockModel +from haddock.modules import BaseHaddockModule +from haddock.modules.base_cns_module import BaseCNSModule + + +class ScoringModule(BaseHaddockModule): + """Parent class for Scoring modules.""" + + def output( + self, + output_fname: FilePath, + sep: str = "\t", + ascending_sort: bool = True, + ) -> None: + r"""Save the output in comprehensive tables. + + Parameters + ---------- + output_fname : FilePath + Path to the file where to write scoring data. + sep : str, optional + Character used as separator in file, by default "\t" + ascending_sort : bool, optional + Should the data be sorted in ascending order, by default True + """ + # saves scoring data + sc_data = [ + [pdb.file_name, pdb.ori_name, pdb.md5, pdb.score] + for pdb in self.output_models + ] + + # converts to pandas dataframe and sorts by score + df_columns = ["structure", "original_name", "md5", "score"] + df_sc = pd.DataFrame(sc_data, columns=df_columns) + df_sc_sorted = df_sc.sort_values(by="score", ascending=ascending_sort) + # writes to disk + df_sc_sorted.to_csv( + output_fname, + sep=sep, + index=False, + na_rep="None", + float_format="%.3f", + ) + return + + +class CNSScoringModule(BaseCNSModule, ScoringModule): + """Parent class for CNS Scoring modules.""" + + def per_interface_output( + self, + output_fname: FilePath, + models: list[HaddockModel], + sep: str = "\t", + ascending_sort: bool = True, + ) -> None: + r"""Generate per interface scoring tsv output files. + + Parameters + ---------- + output_fname : FilePath + Path to the file where to write scoring data. + models : list[HaddockModel] + List of HaddockModel object obtained by loading the PDB files. + sep : str, optional + Character used as separator in file, by default "\t" + ascending_sort : bool, optional + Should the data be sorted in ascending order, by default True + """ + # Skip the analysis if not desired by the user + if not self.per_interface_scoring: + return + + # Retrieve all interfaces data for all pdb + set_interfaces: list[str] = [] + pdb_interfaces_scores: dict[tuple[Any, Any, Any], dict[str, dict[str, float]]] = {} # noqa : E501 + + # Loop over models to recover interfaces + for pdb, haddock_model in zip(self.output_models, models): + # if the pdb does not exist, skip + if not Path(pdb.file_name).exists(): + continue + # Make reverse interface checks + # Score A->B == Score B->A + reversed_interfaces_scores = {} + # Hold list of interfaces + for interface, scores in haddock_model.interface_energies.items(): + # Check if reverse chain order present + split_inter = interface.split("_") + reverse_interface = f"{split_inter[1]}_{split_inter[0]}" + if reverse_interface in set_interfaces: + reversed_interfaces_scores[reverse_interface] = scores + # Check if interface present + if interface not in set_interfaces: + set_interfaces.append(interface) + + # Combine with reversed interface scores + haddock_model.interface_energies.update(reversed_interfaces_scores) + # Hold data + pdbkey = (pdb.file_name, pdb.ori_name, pdb.md5) + pdb_interfaces_scores[pdbkey] = haddock_model.interface_energies + + # Preset output file basename and extension + output_file = Path(output_fname) + output_bn = output_file.stem + ouput_ext = "".join(output_file.suffixes) + # Write separated files for all interfaces + for interface in set_interfaces: + # Point data + sc_data = [] + for pdbkey, interfaces_scores in pdb_interfaces_scores.items(): + if interface not in interfaces_scores.keys(): + continue + interface_scores = interfaces_scores[interface] + score = interface_scores["HADDOCKscore"] + sc_data.append([pdbkey[0], pdbkey[1], pdbkey[2], score]) + # Check that the list is not empty + if len(sc_data) == 0: + continue + # converts to pandas dataframe and sorts by score + df_columns = ["structure", "original_name", "md5", "score"] + df_sc = pd.DataFrame(sc_data, columns=df_columns) + df_sc_sorted = df_sc.sort_values( + by="score", + ascending=ascending_sort, + ) + # Generate output filename + interface_output_fname = f"{output_bn}_{interface}{ouput_ext}" + # writes to disk + df_sc_sorted.to_csv( + interface_output_fname, + sep=sep, + index=False, + na_rep="None", + float_format="%.3f", + ) + return + + def extract_interface_combinations(self) -> list[str]: + """Read interface specific parameters. + + Removes the `interface_combinations` from the parameters as not + supported by CNS. + Sets the `per_interface_scoring` to True if `interface_combinations` + is not empty, as it is required for the interface-scores to be + present in the PDB file. + + Returns + ------- + interface_combinations : list[str] + List of user-defined combinations. + """ + # Here we pop the parameter as not supported by CNS and only used + # at the python level for downstream analysis + interface_combinations = self.params.pop("interface_combinations") + # Set the per_interface_scoring parameter value as set by the user + self.per_interface_scoring = self.params["per_interface_scoring"] + # Check if the parameter is used + if interface_combinations != []: + # NOTE: per_interface_scoring must be set to true for the interface + # scores to be present as REMARK in the header of the PDB file. + self.params["per_interface_scoring"] = True + return interface_combinations + + def update_pdb_scores( + self, + interface_combinations: list[str], + ) -> tuple[list[HaddockModel], dict[str, list[str]]]: + """Update the score attributes in the output pdb files. + + Parameters + ---------- + interface_combinations : list[str] + Input list of chains to be considered. + Each list entry must be composed of two chains separated by coma. + e.g.: + [] -> Consider all non-redundant chain pairs + ["A,H", "A,L"] -> Consider only the interface scores between A,H and A,L + + Returns + ------- + output_haddock_models : list[HaddockModel] + List of HaddockModel for each input pdb, that contain the actual + scores loaded from the file. + """ + # Obtain list of user defined interfaces + desired_interfaces = self.build_interface_sets_combinations( + interface_combinations + ) + # Get the weights from the parameters + _weight_keys = ("w_vdw", "w_elec", "w_desolv", "w_air", "w_bsa") + weights = {e: self.params[e] for e in _weight_keys} + + interface_errors: dict[str, list[str]] = {} + # Check for generated output, fail it not all expected files are found + output_haddock_models: list[HaddockModel] = [] + for pdb in self.output_models: + if pdb.is_present(): + # Convert pdb file into a HaddockModel to read the scores + haddock_model = HaddockModel(pdb.file_name) + # Set the unweighted energy terms + pdb.unw_energies = haddock_model.energies + # Compute set of interfaces if some are defined + if len(desired_interfaces) >= 1: + try: + score = self.compute_interfaces_score( + haddock_model.interface_energies, + desired_interfaces, + ) + # In case the output is None, fall back to standard + # haddock score that will always be ok to compute + except ValueError as interface_error: + # Hold that specific error + error_msg = str(interface_error) + if error_msg not in interface_errors.keys(): + interface_errors[error_msg] = [] + interface_errors[error_msg].append(pdb.file_name) + # Compute the haddock score instead + score = haddock_model.calc_haddock_score(**weights) + finally: + haddock_score = score + # Otherwise simply compute the standard haddock score + else: + # Compute the haddock score + haddock_score = haddock_model.calc_haddock_score(**weights) + # Set the score attribute + pdb.score = haddock_score + output_haddock_models.append(haddock_model) + # Log errors + for error_msg, models in interface_errors.items(): + self.log( + f"Interface error: '{error_msg}' occured {len(models)} times." + " Falling back on classic HADDOCKscore." + ) + return output_haddock_models + + @staticmethod + def build_interface_sets_combinations( + interface_combinations: list[str], + ) -> list[str]: + """Build desired combinatation of interfaces. + + Parameters + ---------- + interface_combinations : list[str] | None + Input list of chains to be considered. + Each list entry must be composed of two chains separated by coma. + e.g.: + [] -> Consider all non-redundant chain pairs + ["A,H", "A,L"] -> Consider only the interface scores between A,H and A,L + + Returns + ------- + combinations : list[str] + Unpacked list of interface combinations to consider. + ["A,H", "A,L"] -> ["A_H", "A_L"] + """ + combinations: list[str] = [ + "_".join([c.strip() for c in chains.split(",")]) + for chains in interface_combinations + if chains.count(",") == 1 # ensures input only contains pairs + ] + return combinations + + @staticmethod + def compute_interfaces_score( + interface_energies: dict[str, dict[str, float]], + interface_sets_combinations: list[str], + ) -> Optional[float]: + """Compute the sum of selected interface haddock score. + + Parameters + ---------- + interfaces_scores : dict[str, dict[str, float]] + Scores of the various interfaces present in the pdb. + interface_sets_combinations : list[str] + List of interface combinations to consider + """ + # Minimum set of interfaces must be >= 1 + if len(interface_sets_combinations) == 0: + raise ValueError("No input interfaces") + + # Get all desired interfaces scores + selected_interfaces_scores: list[float] = [] + for interface in interface_sets_combinations: + if interface in interface_energies.keys(): + interface_score = interface_energies[interface]["HADDOCKscore"] + selected_interfaces_scores.append(interface_score) + else: + # Check if reverse chain order present + split_inter = interface.split("_") + reverse_interface = f"{split_inter[1]}_{split_inter[0]}" + if reverse_interface in interface_energies.keys(): + interface_score = interface_energies[reverse_interface]["HADDOCKscore"] + selected_interfaces_scores.append(interface_score) + # Sum all desired interfaces scores + if len(selected_interfaces_scores) >= 1: + new_score = sum(selected_interfaces_scores) + else: + raise ValueError("Selected interface not found") + return new_score diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2f1f4d54bbbca3cf0be0dd45acf2faf53d9e621f Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7f2b4a7bf04fd6ecacd027789275995d085ecccc --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/__init__.py @@ -0,0 +1,101 @@ +"""EM scoring module. + +This module performs energy minimization and scoring of the models generated in +the previous step of the workflow. No restraints are applied during this step. +""" + +from pathlib import Path + +from haddock.core.defaults import MODULE_DEFAULT_YAML +from haddock.core.typing import FilePath +from haddock.libs.libcns import prepare_cns_input, prepare_expected_pdb +from haddock.libs.libontology import PDBFile +from haddock.libs.libsubprocess import CNSJob +from haddock.modules import get_engine +from haddock.modules.scoring import CNSScoringModule + + +RECIPE_PATH = Path(__file__).resolve().parent +DEFAULT_CONFIG = Path(RECIPE_PATH, MODULE_DEFAULT_YAML) + + +class HaddockModule(CNSScoringModule): + """HADDOCK3 module to perform energy minimization scoring.""" + + name = RECIPE_PATH.name + + def __init__( + self, order: int, path: Path, initial_params: FilePath = DEFAULT_CONFIG + ) -> None: + cns_script = Path(RECIPE_PATH, "cns", f"{self.name}.cns") + super().__init__(order, path, initial_params, cns_script=cns_script) + + @classmethod + def confirm_installation(cls) -> None: + """Confirm module is installed.""" + return + + def _run(self) -> None: + """Execute module.""" + # Pool of jobs to be executed by the CNS engine + jobs: list[CNSJob] = [] + + try: + models_to_score = self.previous_io.retrieve_models(individualize=True) + except Exception as e: + self.finish_with_error(e) + + # Here we pop the parameter as not supported by CNS and only used + # at the python level for downstream analysis + interface_combinations = self.extract_interface_combinations() + + # Itereate over models to prepare CNS inputs + self.output_models = [] + for model_num, model in enumerate(models_to_score, start=1): + scoring_input = prepare_cns_input( + model_num, + model, + self.path, + self.recipe_str, + self.params, + self.name, + native_segid=True, + debug=self.params["debug"], + seed=model.seed if isinstance(model, PDBFile) else None, + ) + + scoring_out = f"{self.name}_{model_num}.out" + err_fname = f"{self.name}_{model_num}.cnserr" + + # create the expected PDBobject + expected_pdb = prepare_expected_pdb(model, model_num, ".", self.name) + # fill the ori_name field of expected_pdb + expected_pdb.ori_name = model.file_name + expected_pdb.md5 = model.md5 + expected_pdb.restr_fname = model.restr_fname + + self.output_models.append(expected_pdb) + + job = CNSJob(scoring_input, scoring_out, err_fname, envvars=self.envvars) + + jobs.append(job) + + # Run CNS Jobs + self.log(f"Running CNS Jobs n={len(jobs)}") + Engine = get_engine(self.params["mode"], self.params) + engine = Engine(jobs) + engine.run() + self.log("CNS jobs have finished") + + # Update the score attributes for each output pdb + output_haddock_models = self.update_pdb_scores(interface_combinations) + + # Set output filename + output_fname = f"{self.name}.tsv" + # Process per-interface analysis + self.per_interface_output(output_fname, output_haddock_models) + # Generate output + self.log(f"Saving output to {output_fname}") + self.output(output_fname) + # Export models to next module + self.export_io_models(faulty_tolerance=self.params["tolerance"]) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..09869b50da7f3a01969c55f33ac223de5394a7f3 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/cns/calc_free-ene.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/cns/calc_free-ene.cns new file mode 100644 index 0000000000000000000000000000000000000000..7446e9921a6b2811cb61317ee38c452f6fa8d9a0 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/cns/calc_free-ene.cns @@ -0,0 +1,24 @@ +! calc_free-ene.cns +! Calculate the total energy of the separated components +! +! Script uses the store1 and store2 atom object, and COMP, REF and RMSD object +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +@MODULE:scale_intra_only.cns + +evaluate ($eintfree = 0.0) + +if ($nemsteps > 0) then + minimize powell nstep=$nemsteps drop=10.0 nprint=25 end +end if +energy end + +evaluate ($eintfree = $bond + $angl + $impr + $dihe + $vdw + $elec) + +display FREE MOLECULES INTERNAL ENERGY = $eintfree diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/cns/check_coordinates.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/cns/check_coordinates.cns new file mode 100644 index 0000000000000000000000000000000000000000..d23c8e64804060c61ff6aeea38925dc8e61dc8d6 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/cns/check_coordinates.cns @@ -0,0 +1,100 @@ +! check_coordinates.cns +! Check max/min coordinates for compatibility with PDB format +! +! *********************************************************************** +! * Copyright 2025 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +evaluate ($failure = false) + +!check for coordinates >9999.999 (max writable in PDB format) + +show max (x) (all) +evaluate ($maxcoor = $result) +show max (y) (all) +if ($result gt $maxcoor) then + evaluate ($maxcoor = $result) +end if +show max (z) (all) +if ($result gt $maxcoor) then + evaluate ($maxcoor = $result) +end if +if ($maxcoor gt 9999.999) then + evaluate ($failure = true) +end if + +!check for coordinates <-999.999 (min writable in PDB format) + +show min (x) (all) +evaluate ($mincoor = $result) +show min (y) (all) +if ($result lt $mincoor) then + evaluate ($maxcoor = $result) +end if +show min (z) (all) +if ($result lt $mincoor) then + evaluate ($mincoor = $result) +end if +if ($mincoor lt -999.999) then + evaluate ($failure = true) +end if + +!if problem detected try correcting it by centering the system around 4500,4500,4500 +!but only if no EM restraints are used + +if ($failure eq true) then + if ($data.flags.em eq false) then + + evaluate ($xc = 0.0) + evaluate ($yc = 0.0) + evaluate ($zc = 0.0) + show ave (x) (all) + evaluate ($xc = 4500 - $result) + show ave (y) (all) + evaluate ($yc = 4500 - $result) + show ave (z) (all) + evaluate ($zc = 4500 -$result) + + do (x = x + $xc) (all) + do (y = y + $yc) (all) + do (z = z + $zc) (all) + + evaluate ($failure = false) + evaluate ($maxcoor = -999) + evaluate ($mincoor = 9999) + !check again for coordinates >9999.999 (max writable in PDB format) + show max (x) (all) + evaluate ($maxcoor = $result) + show max (y) (all) + if ($result gt $maxcoor) then + evaluate ($maxcoor = $result) + end if + show max (z) (all) + if ($result gt $maxcoor) then + evaluate ($maxcoor = $result) + end if + if ($maxcoor gt 9999.999) then + evaluate ($failure = true) + end if + + !check for coordinates <-999.999 (min writable in PDB format) + show min (x) (all) + evaluate ($mincoor = $result) + show min (y) (all) + if ($result lt $mincoor) then + evaluate ($maxcoor = $result) + end if + show min (z) (all) + if ($result lt $mincoor) then + evaluate ($mincoor = $result) + end if + if ($mincoor lt -999.999) then + evaluate ($failure = true) + end if + end if +end if + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/cns/def_solv_param.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/cns/def_solv_param.cns new file mode 100644 index 0000000000000000000000000000000000000000..5a9e07a042e08d15d5b98d859fa199151e7b4a43 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/cns/def_solv_param.cns @@ -0,0 +1,105 @@ +! def_solv_param.cns +! Define atomic solvation parameters +! Original valus taken from Fernandez-Recio et al. JMB 335:843 (2004) +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +evaluate ($arofac = 6.26) +evaluate ($alifac = 1.27) +evaluate ($polfac = 2.30) + + +do (store1 = 0.0000) (all) +do (store1 = 0.0151 * $alifac) (name C*) +do (store1 = 0.0176 * $arofac) ((name CG* or name CD* or name CE* or name CH* or name CZ*) and (resn PHE or resn TYR or resn HIS or resn TRP)) +do (store1 = -0.0170 * $polfac) (name N*) +do (store1 = -0.0548 * $polfac) (name NT* or (name NZ* and resn LYS)) +do (store1 = -0.0273 * $polfac) (name NH* and resn ARG) +do (store1 = -0.0136 * $polfac) (name O*) +do (store1 = -0.0185 * $polfac) (name OG* or name OH) +do (store1 = -0.0299 * $polfac) ((name OD* and resn ASP) or (name OE* and resn GLU)) +do (store1 = 0.0112 * $polfac) (name S*) +do (store1 = 0.0022 * $polfac) ((name S* and attr charge = -0.3) or (name SD and resn MET)) +do (store1 = 0.0000) (name SHA) + +! +! CG parameters matched from the original terms +! +! Edesolv_aa +! ASP_cg = _________________________ +! ASA_cg +! +! ASA_cg and Edesol_aa calculated on a GGXGG peptide +! accuracy=0.0025, rh2o=1.4, delete H, sele=(resn X) +! +! e.g. BB bead alanine +! +! BB = CA + C + N + O +! ASA_cg = 176.4940 +! Edesolv_aa = -1.8889 +! +! ASP_cg = -0.0107 +! +! Charleen Don (2012), JR (2014), Jorge Roel (2017) +! +! + +do (store1 = 0.0000) (name BB or name SC*) +! Backbone beads +do (store1 = -0.0107) (name BB and resn ALA) +do (store1 = -0.0089) (name BB and resn GLY) +do (store1 = -0.0153) (name BB and resn ILE) +do (store1 = -0.0158) (name BB and resn VAL) +do (store1 = -0.0046) (name BB and resn PRO) +do (store1 = -0.0137) (name BB and resn ASN) +do (store1 = -0.0147) (name BB and resn GLN) +do (store1 = -0.0165) (name BB and resn THR) +do (store1 = -0.0154) (name BB and resn SER) +do (store1 = -0.0130) (name BB and resn MET) +do (store1 = -0.0167) (name BB and resn CYS) +do (store1 = -0.0126) (name BB and resn PHE) +do (store1 = -0.0134) (name BB and resn TYR) +do (store1 = -0.0134) (name BB and resn TRP) +do (store1 = -0.0169) (name BB and resn ASP) +do (store1 = -0.0150) (name BB and resn GLU) +do (store1 = -0.0155) (name BB and resn HIS) +do (store1 = -0.0163) (name BB and resn LYS) +do (store1 = -0.0162) (name BB and resn ARG) + +! Side-chain beads +!do (store1 = 0.0000) (name SC* and resn ALA) +!do (store1 = 0.0000) (name SC* and resn GLY) +do (store1 = 0.0255) (name SC* and resn ILE) +do (store1 = 0.0222) (name SC* and resn VAL) +do (store1 = 0.0230) (name SC* and resn PRO) +do (store1 = -0.0192) (name SC* and resn ASN) +do (store1 = -0.0135) (name SC* and resn GLN) +do (store1 = -0.0009) (name SC* and resn THR) +do (store1 = -0.0056) (name SC* and resn SER) +do (store1 = 0.0202) (name SC* and resn MET) +do (store1 = 0.0201) (name SC* and resn CYS) +do (store1 = 0.1005) (name SC* and resn PHE) +do (store1 = 0.0669) (name SC* and resn TYR) +do (store1 = 0.0872) (name SC* and resn TRP) +do (store1 = -0.0360) (name SC* and resn ASP) +do (store1 = -0.0301) (name SC* and resn GLU) +do (store1 = 0.0501) (name SC* and resn HIS) +do (store1 = -0.0210) (name SC* and resn LYS) +do (store1 = -0.0229) (name SC* and resn ARG) + +! Fake beads +do (store1 = 0.0) (name SCD* and resn ASN) +do (store1 = 0.0) (name SCD* and resn GLN) +do (store1 = 0.0) (name SCD* and resn SER) +do (store1 = 0.0) (name SCD* and resn THR) +do (store1 = 0.0) (name SCD* and resn ARG) +do (store1 = 0.0) (name SCD* and resn LYS) +do (store1 = 0.0) (name SCD* and resn GLU) +do (store1 = 0.0) (name SCD* and resn ASP) + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/cns/emscoring.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/cns/emscoring.cns new file mode 100644 index 0000000000000000000000000000000000000000..26b64ad46e1bc807913e0122674b6826d0426e48 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/cns/emscoring.cns @@ -0,0 +1,227 @@ + +! scoring.cns +! Minimizes complex and score +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +if ( $log_level = "verbose" ) then + set message=all echo=on end +elseif ( $log_level = "normal" ) then + set message=normal echo=off end +else + set message=off echo=off end +end if + +!==================================================================! +! Initialisation of variables +!==================================================================! + +evaluate ($ini_count =1) + +evaluate ($Data.flags.ncs = false) +evaluate ($Data.flags.sym = false) +evaluate ($Data.flags.cdih = false) +evaluate ($Data.flags.plan = false) +evaluate ($Data.flags.noe = false) +evaluate ($Data.flags.dihed = $dihedflag) +evaluate ($Data.flags.elec = $elecflag) +evaluate ($Data.flags.em = false) +evaluate ($Data.flags.rg = false) +evaluate ($Data.flags.zres = false) +evaluate ($Data.flags.sani = false) +evaluate ($Data.flags.xrdc = false) +evaluate ($Data.flags.xpcs = false) +evaluate ($Data.flags.dani = false) +evaluate ($Data.flags.vean = false) + +evaluate ($Data.noecv = false) +evaluate ($Data.randremoval = false) +evaluate ($refine.keepwater = false) + +evaluate ($data.ncomponents=$ncomponents) + +evaluate ($nmol=1) +while ($nmol <= $data.ncomponents) loop mol + evaluate ($toppar.prot_segid_$nmol = $prot_segid_$nmol) + evaluate ($mol_shape_$nmol = false) + evaluate ($nmol = $nmol + 1) +end loop mol + + +! non-bonded parameter set to use +evaluate ($toppar.par_nonbonded = "OPLSX") + +!Electrostatics: +evaluate ($Data.flags.dihed =$dihedflag) +evaluate ($Data.flags.elec =$elecflag) +evaluate ($Data.epsilon =$epsilon) +evaluate ($Data.dielec =$dielec) + +!==================================================================! + +{* Read paramters and set various force field related variables *} + +@MODULE:read_param.cns + +parameter + bond (resn WAT ) (resn WAT ) 1000 TOKEN + angle (resn WAT ) (resn WAT ) (resn WAT ) 500 TOKEN + bond (resn HOH ) (resn HOH ) 1000 TOKEN + angle (resn HOH ) (resn HOH ) (resn HOH ) 500 TOKEN + bond (resn TIP*) (resn TIP*) 1000 TOKEN + angle (resn TIP*) (resn TIP*) (resn TIP*) 500 TOKEN +end + +igroup + interaction (not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) + (not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) weight * 1 end + interaction (resn ANI or resn DAN or resn XAN or resn DUM or resn DUM) + (resn ANI or resn DAN or resn XAN or resn DUM or resn DUM) weight * 1 vdw 0.0 elec 0.0 end + interaction (resn SHA) (not resn SHA) weight * 0 end +end + +flag include bond angle impr vdw end + +if ($Data.flags.dihed eq true) then + flag include dihed end +end if + +if ($Data.flags.elec eq true) then + flag include elec end + if ($Data.dielec eq "rdie") then + parameter nbonds eps=$Data.epsilon rdie shift switch end end + ! shift statement needed first to activate switch (CNS bug?) + else + parameter nbonds eps=$Data.epsilon cdie end end + end if + parameter nbonds ? end end +else + evaluate ($elec=0.0) + flag exclude elec end +end if + + +{* Check for the presence of ions and add distance restraints / covalent bond == *} + +@MODULE:restrain-ions.cns + +{* Energy minimisation ========================================================= *} + +fix sele = (not all) end + +! Short minimization + +if ($nemsteps > 0) then + minimize powell nstep=$nemsteps drop=10 end +end if + +{* ======================= calculate free molecules internal energy ============ *} + +igroup + interaction (not (resn ANI or resn DAN or resn XAN or resn SHA or resn WAT or resn HOH or resn TIP* or resn DUM)) + (not (resn ANI or resn DAN or resn XAN or resn SHA or resn WAT or resn HOH or resn TIP* or resn DUM)) weight * 1 end +end + +do (refx=x) (all) +do (refy=y) (all) +do (refz=z) (all) + +fix sele=(resn ANI or resn DAN or resn XAN or resn SHA or resn WAT or resn HOH or resn TIP* or resn DMS) end + +inline @MODULE:calc_free-ene.cns + +fix sele=(not all) end + +do (x = refx) (all) +do (y = refy) (all) +do (z = refz) (all) + + +{* ===================== calculate complex internal energy *} + +evaluate ($kinter = 1.0) + +@MODULE:scale_intra_only.cns + +evaluate ($elec = 0.0) +evaluate ($eintcplx = 0.0) + +energy end + +evaluate ($eintcplx = $bond + $angl + $impr + $dihe + $vdw + $elec) +evaluate ($ebond = $bond) +evaluate ($eangl= $angl) +evaluate ($eimpr= $impr) +evaluate ($edihe= $dihe) + +evaluate ($result=0) +print thres=0.05 bonds +evaluate ($rms_bonds=$result) +evaluate ($result=0) +print thres=5. angles +evaluate ($rms_angles=$result) +evaluate ($result=0) +print thres=5. impropers +evaluate ($rms_impropers=$result) +evaluate ($result=0) +print thres=30. dihedrals +evaluate ($rms_dihedrals=$result) + + +{* ===================== calculate final energies and write structure *} +evaluate ($cdih=0.0) +evaluate ($noe=0.0) +if ($Data.ncomponents > 1) then + evaluate ($kinter = 1.0) + @MODULE:scale_inter_final.cns +else + @MODULE:scale_intra_only.cns +end if + +evaluate ($coll = 0.0) +evaluate ($eair = 0.0) +evaluate ($esym = 0.0) +evaluate ($ncs = 0.0) +evaluate ($zhar = 0.0) +evaluate ($dani = 0.0) +evaluate ($sani = 0.0) +evaluate ($vean = 0.0) +evaluate ($xrdc = 0.0) +evaluate ($xpcs = 0.0) +evaluate ($rms_noe=0.0) +evaluate ($violations_noe=0) +evaluate ($rms_test_noe=0.0) +evaluate ($violations_test_noe=0) + +energy end +evaluate ($etot = $ener - $noe) +evaluate ($noe = $eair) +evaluate ($etot = $etot + $noe) + +inline @MODULE:print_coorheader.cns + +coor sele= (not name H* and not resn ANI and not resn XAN and not resn DAN) orient end + +inline @MODULE:check_coordinates.cns + +if ($failure eq true) then + evaluate ($failfile = $output_pdb_filename - ".pdb" + ".fail") + set display=$failfile end + display "MAX/MIN possible coordinates exceeded - stopping" + close $failfile end + stop +else + write coordinates sele=(not (resn WA* or resn HOH or resn TIP* or resn DMS)) format=pdbo output=$output_pdb_filename end +end if + +set message=normal echo=on end + +display OUTPUT: $output_pdb_filename + +stop diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/cns/print_coorheader.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/cns/print_coorheader.cns new file mode 100644 index 0000000000000000000000000000000000000000..be945dbe877b5cb3f549b95e85498d399f1d41ec --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/cns/print_coorheader.cns @@ -0,0 +1,396 @@ +! print_coorheader.cns +! Generate the coordinate header (REMARKS) +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * Originally adapted from Aria 1.2 from Nilges and Linge, EMBL. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +if ($Data.flags.dihed eq false) then evaluate ($dihe = 0) end if +if ($Data.flags.sani eq false) then evaluate ($sani = 0) end if +if ($Data.flags.xrdc eq false) then evaluate ($xrdc = 0) end if +if ($Data.flags.xpcs eq false) then evaluate ($xpcs = 0) end if +if ($Data.flags.dani eq false) then evaluate ($dani = 0) end if +if ($Data.flags.vean eq false) then evaluate ($vean = 0) end if +if ($Data.flags.cdih eq false) then evaluate ($cdih = 0) end if +if ($Data.flags.noe eq false) then evaluate ($noe = 0) end if +if ($Data.flags.rg eq false) then evaluate ($coll = 0) end if +if ($Data.flags.zres eq false) then evaluate ($zhar = 0) end if +if ($Data.flags.em eq false) then evaluate ($lcc = 0) end if + +evaluate($enerall=$etot) +evaluate($bondall=$ebond) +evaluate($anglall=$eangl) +evaluate($imprall=$eimpr) +evaluate($diheall=$edihe) +evaluate($vdwall=$vdw) +evaluate($elecall=$elec) +evaluate($noeall=$noe) +evaluate($rgall=$coll) +evaluate($zresall=$zhar) +evaluate($cdihall=$cdih) +evaluate($coupall=0) +evaluate($saniall=$sani+$xrdc) +evaluate($veanall=$vean) +evaluate($xpcsall=$xpcs) +evaluate($daniall=$dani) + +if ($Data.flags.sym eq true) then + evaluate ($result=0) + evaluate ($violations=0) + print threshold=0.3 noe + evaluate ($rms_noe=$result) + evaluate ($violations_noe=$violations) +end if + +if ($Data.randremoval eq false) then + evaluate ($violations_test_noe= 0) + evaluate ($rms_test_noe = 0) + evaluate ($npart = 0) +end if + +evaluate ($result=0) +evaluate ($violations=0) +print threshold=5. cdih +evaluate ($rms_cdih=$result) +evaluate ($violations_cdih=$violations) +evaluate ($result=0) +evaluate ($violations=0) +evaluate ($rms_coup = 0) +evaluate ($violations_coup = 0) + +evaluate( $rms_sani = 0) +evaluate( $violations_sani = 0) +if ($Data.flags.sani eq TRUE) then + sani print threshold = 0.20 class rd* end + evaluate( $rms_sani = $result) + evaluate( $violations_sani = $violations) +end if + +evaluate( $rms_xrdc = 0) +evaluate( $violations_xrdc = 0) +if ($Data.flags.xrdc eq TRUE) then + xrdc print threshold = 0.2 class xr* end + evaluate( $rms_xrdc = $result) + evaluate( $violations_xrdc = $violations) +end if + +evaluate( $violations_sani = $violations_sani + $violations_xrdc) +evaluate( $rms_sani = $rms_sani + $rms_xrdc) + +evaluate( $rms_xpcs = 0) +evaluate( $violations_xpcs = 0) +if ($Data.flags.xpcs eq TRUE) then + xpcs print threshold = 0.2 class pc* end + evaluate( $rms_xpcs = $result) + evaluate( $violations_xpcs = $violations) +end if + +evaluate( $rms_vean = 0) +evaluate( $violations_vean = 0) +if ($Data.flags.vean eq TRUE) then + vean print threshold = 5.00 class ve* end + evaluate( $rms_vean = $result) + evaluate( $violations_vean = $violations) +end if + +evaluate( $rms_dani = 0) +evaluate( $violations_dani = 0) +if ($Data.flags.dani eq TRUE) then + dani print threshold = 0.20 class da* end + evaluate( $rms_dani = $result) + evaluate( $violations_dani = $violations) +end if + +{====>} {* define ASA-based solvation parameters *} +inline @MODULE:def_solv_param.cns + +{====>} {* buried surface area and desolvation*} +evaluate ($nchain1 = 0) +evaluate ($saafree = 0) +evaluate ($esolfree = 0) +while ($nchain1 < $data.ncomponents) loop nloop1 + evaluate ($nchain1 = $nchain1 + 1) + {====>} {* buried surface area and desolvation*} + do (rmsd = 0) (all) + surface mode=access accu=0.075 rh2o=1.4 sele=(segid $prot_segid_$nchain1 and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) end + show sum (rmsd) (segid $prot_segid_$nchain1 and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) + evaluate ($saafree = $saafree + $result) + evaluate ($saafree_$nchain1 = $result) + do (store2 = rmsd * store1) (segid $prot_segid_$nchain1 and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) + show sum (store2) (segid $prot_segid_$nchain1 and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) + evaluate ($esolfree = $esolfree + $result) + evaluate ($esolfree_$nchain1 = $result) +end loop nloop1 + +do (rmsd = 0) (all) +do (store2 = 0) (all) +surface mode=access accu=0.075 rh2o=1.4 sele=(not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) end +show sum (rmsd) (not ((resn WAT or resn HOH or resn TIP*) or resn DMS or resn SHA)) +evaluate ($satot = $result) +do (store2 = rmsd * store1) (not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) +show sum (store2) (not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) +evaluate ($esolcplx = $result) +evaluate ($saburied = $saafree - $satot) +if ($saburied < 0) then + evaluate ($saburied = -999999) +end if + +evaluate ($edesolv = $esolcplx - $esolfree) + +evaluate ($dhbinding = $edesolv + $eintcplx - $eintfree + $elecall + $vdwall) + +evaluate ($nshape = 0) +evaluate ($ncount = 0) +while ($ncount < $data.ncomponents) loop shape + evaluate ($ncount = $ncount + 1) + if ($mol_shape_$ncount eq true) then + evaluate ($nshape = $nshape + 1) + end if +end loop shape + +evaluate ($nonshape = $Data.ncomponents - $nshape) + +if ($nonshape = 1) then + evaluate ($saburied = 0) + evaluate ($edesolv = 0) + evaluate ($dhbinding = 0) + evaluate ($eintfree = $eintcplx) +end if + +if ($Data.flags.sym eq true) then + evaluate ($enerall = $enerall + $esym) +end if +if ($Data.flags.ncs eq true) then + evaluate ($enerall = $enerall + $ncs) +end if + +evaluate ($procwat = false) +if ($refine.keepwater eq true) then + evaluate ($procwat = true) +end if + +{====>} {* calculate interface-specific scores *} +if ($data.ncomponents > 1) then + if ($per_interface_scoring eq true) then + if ($data.ncomponents eq 2) then + {====>} {* dimer: no need to recalculate anything *} + evaluate ($nrstscore= 0.0) + evaluate($nchain1 = 1) + evaluate($nchain2 = 2) + evaluate ($bsa_$nchain1_$nchain2 = $saburied) + evaluate ($edesol_$nchain1_$nchain2 = $edesolv) + evaluate ($vdw_$nchain1_$nchain2 = $vdwall) + evaluate ($elec_$nchain1_$nchain2 = $elecall) + evaluate ($haddockscore_$nchain1_$nchain2 = $w_vdw * $vdw_$nchain1_$nchain2 + + $w_elec* $elec_$nchain1_$nchain2 + + $w_bsa * $bsa_$nchain1_$nchain2 + + $w_desolv * $edesol_$nchain1_$nchain2) + + evaluate ($nrstscore = $nrstscore + $haddockscore_$nchain1_$nchain2) + else + {====>} {* define ASA-based solvation parameters *} + do (store1 = 0) (all) + evaluate ($nrstscore= 0.0) + inline @MODULE:def_solv_param.cns + + eval($nchain1 = 1) + + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain2 = $nchain1 + 1) + while ($nchain2 <= $data.ncomponents) loop nloop2 + igroup + interaction (segid $prot_segid_$nchain1 and not (resn WAT or resn HOH or resn TIP* or resn DMS)) + (segid $prot_segid_$nchain2 and not (resn WAT or resn HOH or resn TIP* or resn DMS)) weight * 1.0 end + end + energy end + evaluate ($vdw_$nchain1_$nchain2 = $vdw) + evaluate ($elec_$nchain1_$nchain2 = $elec) + + do (rmsd = 0) (all) + do (store2 = 0) (all) + surface mode=access accu=0.075 rh2o=1.4 + sele=((segid $prot_segid_$nchain1 or segid $prot_segid_$nchain2) and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) end + show sum (rmsd) ((segid $prot_segid_$nchain1 or segid $prot_segid_$nchain2) and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) + evaluate ($bsa_$nchain1_$nchain2 = $saafree_$nchain1 + $saafree_$nchain2 - $result) + if ($bsa_$nchain1_$nchain2 < 0) then + evaluate ($bsa_$nchain1_$nchain2 = 0) + end if + + do (store2 = rmsd * store1) ((segid $prot_segid_$nchain1 or segid $prot_segid_$nchain2) and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) + show sum (store2) ((segid $prot_segid_$nchain1 or segid $prot_segid_$nchain2) and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) + evaluate ($edesol_$nchain1_$nchain2 = $result - $esolfree_$nchain1 - $esolfree_$nchain2) + + evaluate ($haddockscore_$nchain1_$nchain2 = $w_vdw * $vdw_$nchain1_$nchain2 + + $w_elec* $elec_$nchain1_$nchain2 + + $w_bsa * $bsa_$nchain1_$nchain2 + + $w_desolv * $edesol_$nchain1_$nchain2) + + evaluate ($nrstscore = $nrstscore + $haddockscore_$nchain1_$nchain2) + + eval($nchain2 = $nchain2 + 1) + end loop nloop2 + eval($nchain1 = $nchain1 + 1) + end loop nloop1 + end if + end if +else + evaluate ($nrstscore = $w_vdw * $vdwall + $w_elec * $elecall + $w_bsa * $saburied + $w_desolv * $edesolv) +end if + + +if ($procwat eq true) then + ident (store3) (not all) + flag exclude * include vdw elec end + + eval($nchain1 = 0) + + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + + igroup + interaction (segid $prot_segid_$nchain1) ((resn WAT or resn HOH or resn TIP* or resn DMS) and not store3) weight * 1.0 end + interaction (not segid $prot_segid_$nchain1) (resn WAT or resn HOH or resn TIP* or resn DMS) weight * 0.0 end + interaction (segid $prot_segid_$nchain1) (not ((resn WAT or resn HOH or resn TIP* or resn DMS) and store3)) weight * 0.0 end + end + energy end + evaluate ($ener_water_$nchain1 = $ener) + evaluate ($enerall = $enerall + $ener) + evaluate ($vdw_water_$nchain1 = $vdw) + evaluate ($elec_water_$nchain1 = $elec) + + end loop nloop1 + if ($data.ncomponents > 1) then + eval($nchain1 = $data.ncomponents) + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + evaluate ($ener_water_$nchain1 = 0.0) + evaluate ($vdw_water_$nchain1 = 0.0) + evaluate ($elec_water_$nchain1 = 0.0) + end loop nloop1 + end if + + eval($nchain1 = 0) + + igroup + while ($nchain1 < $data.ncomponents) loop nloop2 + eval($nchain1 = $nchain1 + 1) + interaction (segid $prot_segid_$nchain1) (all) weight * 0.0 end + end loop nloop2 + interaction ((resn WAT or resn HOH or resn TIP* or resn DMS) and not store3) + ((resn WAT or resn HOH or resn TIP* or resn DMS) and not store3) weight * 1.0 end + interaction (store3) (store3) weight * 0.0 end + interaction (resn SHA) (not resn SHA) weight * 0.0 end + interaction (resn SHA) (resn SHA) weight * 0.0 end + end + energy end + evaluate ($ener_water_water = $ener) + evaluate ($enerall = $enerall + $ener) + evaluate ($vdw_water_water = $vdw) + evaluate ($elec_water_water = $elec) +else + eval($nchain1 = 0) + + while ($nchain1 < $data.ncomponents ) loop nloop1 + eval($nchain1 = $nchain1 + 1) + evaluate ($ener_water_$nchain1 = 0.0) + evaluate ($vdw_water_$nchain1 = 0.0) + evaluate ($elec_water_$nchain1 = 0.0) + end loop nloop1 + evaluate ($ener_water_water = 0.0) + evaluate ($vdw_water_water = 0.0) + evaluate ($elec_water_water = 0.0) +end if + +! calculate the HADDOCK score +evaluate ($hscore = $w_vdw * $vdwall) +evaluate ($hscore = $hscore + $w_elec * $elecall) +evaluate ($hscore = $hscore + $w_air * $noeall) +evaluate ($hscore = $hscore + $w_rg * $rgall) +evaluate ($hscore = $hscore + $w_cdih * $cdihall) +evaluate ($hscore = $hscore + $w_sani * $saniall) +evaluate ($hscore = $hscore + $w_xpcs * $xpcsall) +evaluate ($hscore = $hscore + $w_dani * $daniall) +evaluate ($hscore = $hscore + $w_vean * $veanall) +evaluate ($hscore = $hscore + $w_sym * $esym) +evaluate ($hscore = $hscore + $w_bsa * $saburied) +evaluate ($hscore = $hscore + $w_desolv * $edesolv) +evaluate ($hscore = $hscore + $w_lcc * $lcc) + +set message=on echo=on end +set remarks=reset end +set remarks=accumulate end +remarks =============================================================== +remarks HADDOCK stats for $output_pdb_filename +remarks =============================================================== +remarks HADDOCK score: $hscore +remarks =============================================================== + +!list input molecules +evaluate ($nmol=1) +while ($nmol <=$data.ncomponents) loop mol + if ( $exist_input_pdb_filename_$nmol = true) then + remarks initial structure $nmol - $input_pdb_filename_$nmol + end if + evaluate ($nmol = $nmol + 1) +end loop mol + +remarks =============================================================== +remarks total,bonds,angles,improper,dihe,vdw,elec,air,cdih,coup,rdcs,vean,dani,xpcs,rg +remarks energies: $enerall, $bondall, $anglall, $imprall, $diheall, $vdwall, $elecall, $noeall, $cdihall, $coupall, $saniall, $veanall, $daniall, $xpcsall, $rgall +remarks =============================================================== +remarks bonds,angles,impropers,dihe,air,cdih,coup,rdcs,vean,dani,xpcs +remarks rms-dev.: $rms_bonds,$rms_angles,$rms_impropers,$rms_dihedrals,$rms_noe,$rms_cdih,$rms_coup, $rms_sani, $rms_vean, $rms_dani, $rms_xpcs +remarks =============================================================== +remarks air,cdih,coup,rdcs,vean,dani,xpcs +remarks >0.3,>5,>1,>0,>5,>0.2,>0.2 +remarks violations.: $violations_noe, $violations_cdih, $violations_coup, $violations_sani, $violations_vean, $violations_dani, $violations_xpcs +remarks =============================================================== +remarks CVpartition#,violations,rms +remarks AIRs cross-validation: $npart, $violations_test_noe, $rms_test_noe +remarks =============================================================== +remarks NCS energy: $ncs +remarks =============================================================== +remarks Symmetry energy: $esym +remarks =============================================================== +remarks Membrane restraining energy: $zresall +remarks =============================================================== +remarks Local cross-correlation: $lcc[f7.4] +remarks =============================================================== +remarks Desolvation energy: $edesolv +remarks Internal energy free molecules: $eintfree +remarks Internal energy complex: $eintcplx +remarks Binding energy: $dhbinding +remarks =============================================================== +remarks buried surface area: $saburied +remarks =============================================================== +if ($data.ncomponents > 1) then + if ($per_interface_scoring eq true) then + evaluate($nchain1 = 1) + remarks Interface Chain1 Chain2 HADDOCKscore Evdw Eelec Edesol BSA + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain2 = $nchain1 + 1) + while ($nchain2 <= $data.ncomponents) loop nloop2 + remarks Interface: $prot_segid_$nchain1 $prot_segid_$nchain2 $haddockscore_$nchain1_$nchain2 $vdw_$nchain1_$nchain2 $elec_$nchain1_$nchain2 $edesol_$nchain1_$nchain2 $bsa_$nchain1_$nchain2 + eval($nchain2 = $nchain2 + 1) + end loop nloop2 + eval($nchain1 = $nchain1 + 1) + end loop nloop1 + remarks Total HADDOCK score without restraints: $nrstscore + end if +else + remarks Total HADDOCK score without restraints: $nrstscore +end if +remarks =============================================================== +evaluate($ncount = 0) +while ($ncount < $data.ncomponents) loop waterremark + evaluate ($ncount = $ncount +1) + remarks water - chain-$prot_segid_$ncount: $ener_water_$ncount $vdw_water_$ncount $elec_water_$ncount +end loop waterremark +remarks =============================================================== +remarks water - water: $ener_water_water $vdw_water_water $elec_water_water +remarks =============================================================== diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/cns/read_param.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/cns/read_param.cns new file mode 100644 index 0000000000000000000000000000000000000000..6f549a453e49c118de295658c1294a8a429b9365 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/cns/read_param.cns @@ -0,0 +1,64 @@ +! read_param.cns +! Reads parameter files. +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +!! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** + +{* protein parameter file *} +eval ($prot_parameter_infile="TOPPAR:protein-allhdg5-4.param") + +{* nucleic acid parameter file *} +eval ($nucl_parameter_infile="TOPPAR:dna-rna-allatom-hj-opls-1.3.param") + +{* carbohydrate parameter file *} +eval ($carbo_parameter_infile="TOPPAR:carbohydrate.param") + +{* solvent parameter file *} +eval ($solv_parameter_infile="TOPPAR:solvent-allhdg5-4.param") + +{* fragment probes parameter file *} +eval ($ligands_parameter_infile="TOPPAR:fragment_probes.param") + +{* ion parameter file *} +eval ($ion_parameter_infile="TOPPAR:ion.param") + +{* heme parameter file *} +eval ($heme_parameter_infile="TOPPAR:hemes-allhdg.param") + +{* shape parameter file *} +eval ($shape_parameter_infile="TOPPAR:shape.param") + +{* cofactors parameter file *} +eval ($cofactors_parameter_infile="TOPPAR:cofactors.param") + +parameter + @@$prot_parameter_infile + @@$ion_parameter_infile + @@$nucl_parameter_infile + @@$carbo_parameter_infile + @@$solv_parameter_infile + @@$ligands_parameter_infile + @@$heme_parameter_infile + @@$shape_parameter_infile + @@$cofactors_parameter_infile + if ($ligand_param_fname # "") then + fileexist $ligand_param_fname end + if ($result eq true) then + @@$ligand_param_fname + end if + end if +end + +parameter + nbonds + nbxmod=5 atom cdie shift + cutnb=9.5 ctofnb=8.5 ctonnb=6.5 eps=1.0 e14fac=0.4 inhibit 0.25 + wmin=0.5 tolerance 0.5 + end +end + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/cns/restrain-ions.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/cns/restrain-ions.cns new file mode 100644 index 0000000000000000000000000000000000000000..52a5b3d2024ac21f44456d9ed204d455d8380ac2 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/cns/restrain-ions.cns @@ -0,0 +1,109 @@ +! restrain-ions.cns +! distance restraints between an ion and any coordinating atom within 5A +! to maintain the coordination topologu +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +noe class dist end + +! first deal with monoatomic ions +evaluate ($pcount = 0) +for $id1 in id ( name "LI+1" or name "F-1" or name "NA+1" or name "MG+2" or name "AL+3" + or name "CL-1" or name "K+1" or name "CA+2" or name "V+2" or name "V+3" + or name "CR+2" or name "CR+3" or name "MN+2" or name "MN+3" or name "FE+2" + or name "FE+3" or name "NI+2" or name "CO+2" or name "CO+3" or name "CU+1" + or name "CU+2" or name "ZN+2" or name "BR-1" or name "SR+2" or name "MO+3" + or name "AG+1" or name "CD+2" or name "I-1" or name "CS+2" or name "HO+3" + or name "YB+2" or name "YB+3" or name "OS+4" or name "IR+3" or name "PT+2" + or name "AU+1" or name "AU+2" or name "HG+1" or name "HG+2" or name "PB+2" + or name "U+3" or name "U+4" or name "ZN+1" or name "ZN" ) loop sions + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + show (resname) (id $id1) + evaluate ($resname1=$result) + show (name) (id $id1) + evaluate ($name1=$result) + + evaluate ($mindis = 4.0) + for $id2 in id ( (name O* or name S* or name N*) and (id $id1) around $mindis and + (resn ACE or resn ALA or resn ALY or resn ARG or resn ASN or resn ASH or resn ASP or + resn CSP or resn CTN or resn CYC or resn CYF or resn CYM or resn CYS or resn DDZ or + resn GLN or resn GLH or resn GLU or resn GLY or resn HIS or resn HY3 or resn HYP or + resn ILE or resn LEU or resn LYS or resn M3L or resn MLY or resn MLZ or resn MET or + resn MSE or resn NEP or resn NME or resn PHE or resn PNS or resn PRO or resn PTR or + resn QSR or resn SEP or resn SER or resn SEC or resn THR or resn TOP or resn TRP or + resn TYP or resn TYR or resn TYS or resn VAL or resn A or resn C or resn G or + resn T or resn DA or resn DC or resn DG or resn DT or resn DJ )) loop search + + pick bond (id $id1) (id $id2) geometry + evaluate ($upper = $result) + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + show (name) (id $id2) + evaluate ($name2=$result) + + if ($segid1 eq $segid2) then + noe + assign (resid $resid1 and segid $segid1 and name $name1) + (resid $resid2 and segid $segid2 and name $name2) $upper 0.1 0.1 + end + end if + + end loop search + +end loop sions + +! then deal with multiatomic mions +evaluate ($pcount = 0) +for $id1 in id ( (resn SO4 or resn PO4 or resn WO4) and name O* ) loop mions + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + show (resname) (id $id1) + evaluate ($resname1=$result) + show (name) (id $id1) + evaluate ($name1=$result) + + evaluate ($mindis = 4.0) + for $id2 in id ( (name O* or name S* or name N*) and (id $id1) around $mindis and + (resn ACE or resn ALA or resn ALY or resn ARG or resn ASN or resn ASH or resn ASP or + resn CSP or resn CTN or resn CYC or resn CYF or resn CYM or resn CYS or resn DDZ or + resn GLN or resn GLH or resn GLU or resn GLY or resn HIS or resn HY3 or resn HYP or + resn ILE or resn LEU or resn LYS or resn M3L or resn MLY or resn MLZ or resn MET or + resn MSE or resn NEP or resn NME or resn PHE or resn PNS or resn PRO or resn PTR or + resn QSR or resn SEP or resn SER or resn SEC or resn THR or resn TOP or resn TRP or + resn TYP or resn TYR or resn TYS or resn VAL or resn A or resn C or resn G or + resn T or resn DA or resn DC or resn DG or resn DT or resn DJ )) loop search + + pick bond (id $id1) (id $id2) geometry + evaluate ($upper = $result) + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + show (name) (id $id2) + evaluate ($name2=$result) + + if ($segid1 eq $segid2) then + noe + assign (resid $resid1 and segid $segid1 and name $name1) + (resid $resid2 and segid $segid2 and name $name2) $upper 0.1 0.1 + end + end if + + end loop search + +end loop mions diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/cns/scale_inter_final.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/cns/scale_inter_final.cns new file mode 100644 index 0000000000000000000000000000000000000000..a8bf9c44f98b1303779d68d46e24855e47321548 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/cns/scale_inter_final.cns @@ -0,0 +1,39 @@ +! scale_inter_final.cns +! Scaling of intermolecular interactions +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +igroup interaction (not all) (not all) end + +igroup + + eval($nchain1 = 0) + + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + eval($nchain2 = $nchain1 ) + while ($nchain2 < $data.ncomponents) loop nloop2 + eval($nchain2 = $nchain2 + 1) + eval($scalfac = 1.0) + interaction (segid $prot_segid_$nchain1 and not + (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA or resn DPP or resn PCW or resn PEE)) + (segid $prot_segid_$nchain2 and not + (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA or resn DPP or resn PCW or resn PEE)) weight * 1.0 vdw $scalfac elec $scalfac end + end loop nloop2 + + end loop nloop1 + + interaction (resn ANI) (resn ANI) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DAN) (resn DAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn XAN) (resn XAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DUM) (resn DUM) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (resn SHA) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (not resn SHA) weight * 0.0 end + +end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/cns/scale_intra_only.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/cns/scale_intra_only.cns new file mode 100644 index 0000000000000000000000000000000000000000..15b0adfbb562862214f161c494c14a17dbf6beb7 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/cns/scale_intra_only.cns @@ -0,0 +1,36 @@ +! scale_intra_only.cns +! Scaling of intramolecular energies (no intermolecular energies) +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +igroup interaction (not all) (not all) end + +igroup + + eval($nchain1 = 0) + + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + + interaction (segid $prot_segid_$nchain1 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) + (segid $prot_segid_$nchain1 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) weight * 1.0 end + + end loop nloop1 + + interaction (resn ANI) (resn ANI) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DAN) (resn DAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn XAN) (resn XAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DUM) (resn DUM) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (resn SHA) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (not resn SHA) weight * 0.0 end + +end + + + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/defaults.yaml b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/defaults.yaml new file mode 100644 index 0000000000000000000000000000000000000000..58227eb82017aa6f0b4c935839d68d3698e531cd --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/emscoring/defaults.yaml @@ -0,0 +1,324 @@ +# +# Group scoring +# +per_interface_scoring: + default: false + type: boolean + title: Interchains scoring + short: Output scores per interface in the PDB header. + long: With this option true, the interface of all combinations of chains will be analysed and the corresponding HADDOCK scores (without restraints terms) and their components (Eelec, Evdw, Edesol, BSA) will be written to the header of each PDB file. + group: 'scoring' + explevel: expert +interface_combinations: + default: [] + type: list + minitems: 0 + maxitems: 20 + title: Chains to be scored. + short: List of chains to be scored. Use this parameter to provide a list of + chain pairs (coma separated) that should be considered for the calculation. + If empty/unspecified, all inter-chains contacts will be considered + for the final prediction. + long: List of chains to be scored. If empty/unspecified, all inter-chains + contacts will be considered for the final prediction. In specific cases, + for example antibody-antigen complexes, some chains should be considered + as a single molecule. Use this parameter to provide a list of chain pairs + (separated by coma) that should be considered for the calculation. + [] => Compute all interface scores + ["A,H", "A,L"] => Compute sum of per-interface scores between chains A and H; A and L + group: 'scoring' + explevel: expert +w_air: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the distance restraint energy + short: Weight of the distance restraints energy in the scoring function + long: Weight of the distance restraints energy in the scoring function. + Note that this is different from the force constants used during the calculations. + group: 'scoring' + explevel: expert +w_bsa: + default: 0.0 + type: float + min: -9999 + max: 9999 + precision: 3 + title: Weight of the buried surface area term + short: Weight of the buried surface area term in the scoring function + long: Weight of the buried surface area (BSA) term in the scoring function. + Note that the BSA is only used for scoring. + group: 'scoring' + explevel: expert +w_cdih: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the dihedral angle restraint energy + short: Weight of the dihedral angle restraints energy in the scoring function + long: Weight of the dihedral angle restraints energy in the scoring function. + Note that this is different from the force constant used during the calculations. + group: 'scoring' + explevel: expert +w_dani: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the relaxation anisotropy (DANI) restraint energy + short: Weight of the relaxation anisotropy (DANI) restraint energy + long: Weight of the relaxation anisotropy (DANI) restraint energy + group: 'scoring' + explevel: hidden +w_deint: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the interaction energy term + short: Weight of the interaction energy term + long: Weight of the interaction energy term calculated as the difference in total energy of the complex and of the separate components + group: 'scoring' + explevel: hidden +w_desolv: + default: 1.0 + type: float + min: -9999 + max: 9999 + precision: 3 + title: Weight of the desolvation energy term + short: Weight of the desolvation energy term in the scoring function + long: Weight of the desolvation energy term in the scoring function. + Note that the desolvation energy is only used for scoring. + group: 'scoring' + explevel: expert +w_elec: + default: 0.2 + type: float + min: -9999 + max: 9999 + precision: 3 + title: Weight of the intermolecular electrostatic energy + short: Weight of the intermolecular electrostatic energy in the scoring function + long: Weight of the intermolecular electrostatic energy in the scoring function. + Note that this does not affect the electostatic energy during the EM minimization. + group: 'scoring' + explevel: expert +w_lcc: + default: -10000.0 + type: float + min: -10000.0 + max: 0 + precision: 3 + title: Weight of the EM local correlation coefficient + short: Weight of the EM local correlation coefficient + long: Weight of the EM local correlation coefficient + group: 'scoring' + explevel: hidden +w_rg: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the radius of gyration restraint energy + short: Weight of the radius of gyration restraint energy + long: Weight of the radius of gyration restraint energy + group: 'scoring' + explevel: hidden +w_sani: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the residual dipolar coupling (SANI) restraint energy + short: Weight of the residual dipolar coupling (SANI) restraint energy + long: Weight of the residual dipolar coupling (SANI) restraint energy + group: 'scoring' + explevel: hidden +w_sym: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the symmetry restraint energy + short: Weight of the symmetry restraints energy in the scoring function + long: Weight of the symmetry restraints energy in the scoring function. + Note that this is different from the force constant used during the calculations. + group: 'scoring' + explevel: hidden +w_vdw: + default: 1.0 + type: float + min: -9999 + max: 9999 + precision: 3 + title: Weight of the intermolecular van der Waals energy + short: Weight of the intermolecular van der Waals energy in the scoring function + long: Weight of the intermolecular van der Waals energy in the scoring function. + Note that this does not affect the van der Waals energy during the EM minimization. + group: 'scoring' + explevel: expert +w_vean: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the residual dipolar coupling (VEAN) restraint energy + short: Weight of the residual dipolar coupling (VEAN) restraint energy + long: Weight of the residual dipolar coupling (VEAN) restraint energy + group: 'scoring' + explevel: hidden +w_xpcs: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the pseudo contact shifts (XPCS) restraint energy + short: Weight of the pseudo contact shifts (XPCS) restraint energy + long: Weight of the pseudo contact shifts (XPCS) restraint energy + group: 'scoring' + explevel: hidden +w_xrdc: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the residual dipolar coupling (XRDC) restraint energy + short: Weight of the residual dipolar coupling (XRDC) restraint energy + long: Weight of the residual dipolar coupling (XRDC) restraint energy + group: 'scoring' + explevel: hidden +w_zres: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the Z-restraining potential energy + short: Weight of the Z-restraining potential energy + long: Weight of the Z-restraining potential energy + group: 'scoring' + explevel: hidden +# +# Group force field +# +ligand_param_fname: + default: '' + type: file + title: Custom ligand parameter file + short: Ligand parameter file in CNS format + long: Ligand parameter file in CNS format containing all force field parameters + (bond, angles, dihedrals, impropers, van der waals) for any ligand not supported by default by HADDOCK + group: 'force field' + explevel: easy +ligand_top_fname: + default: '' + type: file + title: Custom ligand topology file + short: Ligand topology file in CNS format + long: Ligand topology file in CNS format containing the ligand topologies + (atoms, masses, charges, bond definitions...) for any ligand not supported by default by HADDOCK + group: 'force field' + explevel: easy +elecflag: + default: true + type: boolean + title: Include electrostatics energy + short: Include electrostatics energy during the calculations. + long: Include electrostatics energy during the calculations. If set to false electrostatics will not be considered. + group: 'force field' + explevel: easy +dielec: + default: cdie + type: string + minchars: 0 + maxchars: 4 + choices: + - cdie + - rdie + title: Constant (cdie) or distance-dependent dielectric (rdie) constant. + short: Use a constant (cdie option) or a distance-dependent dielectric (rdie) constant in the Coulomb potential. + long: Use a constant (cdie option) or a distance-dependent dielectric (rdie) constant in the Coulomb potential. + A distance dependent dielectric constant will effectively scale down the electrostatic energy + by having a 1/r**2 dependency instead of 1/r + group: 'force field' + explevel: expert +epsilon: + default: 1.0 + type: float + min: 1 + max: 78 + precision: 1 + title: Dielectric constant + short: Dielectric constant for the electrostatic Coulomb energy term. + long: Dielectric constant for the electrostatic Coulomb energy term. + group: 'force field' + explevel: expert +dihedflag: + default: true + type: boolean + title: No title yet + short: No short description yet + long: No long description yet + group: 'force field' + explevel: expert +# +# Group sampling +# +individualize: + default: true + type: boolean + title: Individualise models + short: Treat each model in the PDB ensemble as a separate entity. + long: Treat each model in the PDB ensemble as a separate entity. This means that for each a separate topology file will be generated. The models in the ensemble can thus correspond to different molecules. + group: 'sampling' + explevel: expert +nemsteps: + default: 50 + type: integer + min: 0 + max: 10000 + title: Number of EM steps + short: Number of energy minimisation steps to perform. + long: Number of energy minimisation steps to perform. Note that the effective number might be smaller if the minimisation converges earlier. + group: 'sampling' + explevel: expert +tolerance: + default: 5 + type: integer + min: 0 + max: 99 + precision: 3 + title: Failure tolerance percentage + short: Percentage of allowed failures for a module to successfully complete + long: Percentage of allowed failures for a module to successfully complete + group: 'module' + explevel: expert +log_level: + default: quiet + type: string + minchars: 0 + maxchars: 100 + choices: + - verbose + - normal + - quiet + title: Log level verbosity for CNS + short: Set the log level verbosity for CNS + long: CNS, the computational engine used by HADDOCK can generate a lot of output + messages. This parameter controls the verbosity of CNS (verbose, normal or quiet) + group: module + explevel: guru + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f992c34611c8d3121313bb4b1846e41a8144922d --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/__init__.py @@ -0,0 +1,102 @@ +"""MD scoring module. + +This module will perform a short MD simulation on the input models and +score them. No restraints are applied during this step. +""" + +from pathlib import Path + +from haddock.core.defaults import MODULE_DEFAULT_YAML +from haddock.core.typing import FilePath +from haddock.gear.haddockmodel import HaddockModel +from haddock.libs.libcns import prepare_cns_input, prepare_expected_pdb +from haddock.libs.libontology import PDBFile +from haddock.libs.libsubprocess import CNSJob +from haddock.modules import get_engine +from haddock.modules.scoring import CNSScoringModule + + +RECIPE_PATH = Path(__file__).resolve().parent +DEFAULT_CONFIG = Path(RECIPE_PATH, MODULE_DEFAULT_YAML) + + +class HaddockModule(CNSScoringModule): + """HADDOCK3 module to perform energy minimization scoring.""" + + name = RECIPE_PATH.name + + def __init__( + self, order: int, path: Path, initial_params: FilePath = DEFAULT_CONFIG + ) -> None: + cns_script = Path(RECIPE_PATH, "cns", f"{self.name}.cns") + super().__init__(order, path, initial_params, cns_script=cns_script) + + @classmethod + def confirm_installation(cls) -> None: + """Confirm module is installed.""" + return + + def _run(self) -> None: + """Execute module.""" + # Pool of jobs to be executed by the CNS engine + jobs: list[CNSJob] = [] + + try: + models_to_score = self.previous_io.retrieve_models(individualize=True) + except Exception as e: + self.finish_with_error(e) + + # Here we pop the parameter as not supported by CNS and only used + # at the python level for downstream analysis + interface_combinations = self.extract_interface_combinations() + + # Prepare all CNS runs + self.output_models = [] + for model_num, model in enumerate(models_to_score, start=1): + scoring_inpyt = prepare_cns_input( + model_num, + model, + self.path, + self.recipe_str, + self.params, + self.name, + native_segid=True, + debug=self.params["debug"], + seed=model.seed if isinstance(model, PDBFile) else None, + ) + + scoring_out = f"{self.name}_{model_num}.out" + err_fname = f"{self.name}_{model_num}.cnserr" + + # create the expected PDBobject + expected_pdb = prepare_expected_pdb(model, model_num, ".", self.name) + # fill the ori_name field of expected_pdb + expected_pdb.ori_name = model.file_name + expected_pdb.md5 = model.md5 + expected_pdb.restr_fname = model.restr_fname + + self.output_models.append(expected_pdb) + + job = CNSJob(scoring_inpyt, scoring_out, err_fname, envvars=self.envvars) + + jobs.append(job) + + # Run CNS Jobs + self.log(f"Running CNS Jobs n={len(jobs)}") + Engine = get_engine(self.params["mode"], self.params) + engine = Engine(jobs) + engine.run() + self.log("CNS jobs have finished") + + # Update the score attributes for each output pdb + output_haddock_models = self.update_pdb_scores(interface_combinations) + + # Set output filename + output_fname = f"{self.name}.tsv" + # Process per-interface analysis + self.per_interface_output(output_fname, output_haddock_models) + # Make final output file + self.log(f"Saving output to {output_fname}") + self.output(output_fname) + # Export models + self.export_io_models(faulty_tolerance=self.params["tolerance"]) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c5fea90a52d82c1d747a6ec786550a4ec47e1a42 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/calc_free-ene.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/calc_free-ene.cns new file mode 100644 index 0000000000000000000000000000000000000000..0466f939be3a1b65c698e77621e36fbcd68e0174 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/calc_free-ene.cns @@ -0,0 +1,24 @@ +! calc_free-ene.cns +! Calculate the total energy of the separated components +! +! Script uses the store1 and store2 atom object, and COMP, REF and RMSD object +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +@MODULE:scale_intra_only.cns + +evaluate ($eintfree = 0.0) +@MODULE:flex_segment_back.cns +fix sele=(((attr store5 = 0) or resn ANI or resn DAN or resn XAN or resn SHA) and not name H* and not (resn WAT or resn HOH or resn TIP*)) end + +minimize powell nstep=100 drop=10.0 nprint=25 end +fix sele=(not all) end +energy end +evaluate ($eintfree = $bond + $angl + $impr + $dihe + $vdw + $elec) + +display FREE MOLECULES INTERNAL ENERGY = $eintfree diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/check_coordinates.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/check_coordinates.cns new file mode 100644 index 0000000000000000000000000000000000000000..d23c8e64804060c61ff6aeea38925dc8e61dc8d6 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/check_coordinates.cns @@ -0,0 +1,100 @@ +! check_coordinates.cns +! Check max/min coordinates for compatibility with PDB format +! +! *********************************************************************** +! * Copyright 2025 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +evaluate ($failure = false) + +!check for coordinates >9999.999 (max writable in PDB format) + +show max (x) (all) +evaluate ($maxcoor = $result) +show max (y) (all) +if ($result gt $maxcoor) then + evaluate ($maxcoor = $result) +end if +show max (z) (all) +if ($result gt $maxcoor) then + evaluate ($maxcoor = $result) +end if +if ($maxcoor gt 9999.999) then + evaluate ($failure = true) +end if + +!check for coordinates <-999.999 (min writable in PDB format) + +show min (x) (all) +evaluate ($mincoor = $result) +show min (y) (all) +if ($result lt $mincoor) then + evaluate ($maxcoor = $result) +end if +show min (z) (all) +if ($result lt $mincoor) then + evaluate ($mincoor = $result) +end if +if ($mincoor lt -999.999) then + evaluate ($failure = true) +end if + +!if problem detected try correcting it by centering the system around 4500,4500,4500 +!but only if no EM restraints are used + +if ($failure eq true) then + if ($data.flags.em eq false) then + + evaluate ($xc = 0.0) + evaluate ($yc = 0.0) + evaluate ($zc = 0.0) + show ave (x) (all) + evaluate ($xc = 4500 - $result) + show ave (y) (all) + evaluate ($yc = 4500 - $result) + show ave (z) (all) + evaluate ($zc = 4500 -$result) + + do (x = x + $xc) (all) + do (y = y + $yc) (all) + do (z = z + $zc) (all) + + evaluate ($failure = false) + evaluate ($maxcoor = -999) + evaluate ($mincoor = 9999) + !check again for coordinates >9999.999 (max writable in PDB format) + show max (x) (all) + evaluate ($maxcoor = $result) + show max (y) (all) + if ($result gt $maxcoor) then + evaluate ($maxcoor = $result) + end if + show max (z) (all) + if ($result gt $maxcoor) then + evaluate ($maxcoor = $result) + end if + if ($maxcoor gt 9999.999) then + evaluate ($failure = true) + end if + + !check for coordinates <-999.999 (min writable in PDB format) + show min (x) (all) + evaluate ($mincoor = $result) + show min (y) (all) + if ($result lt $mincoor) then + evaluate ($maxcoor = $result) + end if + show min (z) (all) + if ($result lt $mincoor) then + evaluate ($mincoor = $result) + end if + if ($mincoor lt -999.999) then + evaluate ($failure = true) + end if + end if +end if + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/contactairs.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/contactairs.cns new file mode 100644 index 0000000000000000000000000000000000000000..aa8028ab7d3b40e56df692afec9eda66b1a45c68 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/contactairs.cns @@ -0,0 +1,27 @@ +! contactairs.cns +! Define ambiguous distance restraints between residues at interfaces +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +eval($nchain1 = 0) +while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + for $id in id (tag and segid $prot_segid_$nchain1 + and (not (segid $prot_segid_$nchain1 or resn ANI or resn DAN or resn XAN + or resn SHA or resn WAT or resn HOH or resn TIP* or resn DUM) around 5.0)) loop defnoe1 + show (resid) (id $id) + evaluate ($inres = $result) + noe + assign (resid $inres and segid $prot_segid_$nchain1) + (byres (not (segid $prot_segid_$nchain1 or resn ANI or resn DAN or resn XAN + or resn SHA or resn WAT or resn HOH or resn TIP* or resn DUM) + and (segid $prot_segid_$nchain1) around 5.0)) 2.0 2.0 0.0 + end + end loop defnoe1 +end loop nloop1 diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/def_solv_param.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/def_solv_param.cns new file mode 100644 index 0000000000000000000000000000000000000000..5a9e07a042e08d15d5b98d859fa199151e7b4a43 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/def_solv_param.cns @@ -0,0 +1,105 @@ +! def_solv_param.cns +! Define atomic solvation parameters +! Original valus taken from Fernandez-Recio et al. JMB 335:843 (2004) +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +evaluate ($arofac = 6.26) +evaluate ($alifac = 1.27) +evaluate ($polfac = 2.30) + + +do (store1 = 0.0000) (all) +do (store1 = 0.0151 * $alifac) (name C*) +do (store1 = 0.0176 * $arofac) ((name CG* or name CD* or name CE* or name CH* or name CZ*) and (resn PHE or resn TYR or resn HIS or resn TRP)) +do (store1 = -0.0170 * $polfac) (name N*) +do (store1 = -0.0548 * $polfac) (name NT* or (name NZ* and resn LYS)) +do (store1 = -0.0273 * $polfac) (name NH* and resn ARG) +do (store1 = -0.0136 * $polfac) (name O*) +do (store1 = -0.0185 * $polfac) (name OG* or name OH) +do (store1 = -0.0299 * $polfac) ((name OD* and resn ASP) or (name OE* and resn GLU)) +do (store1 = 0.0112 * $polfac) (name S*) +do (store1 = 0.0022 * $polfac) ((name S* and attr charge = -0.3) or (name SD and resn MET)) +do (store1 = 0.0000) (name SHA) + +! +! CG parameters matched from the original terms +! +! Edesolv_aa +! ASP_cg = _________________________ +! ASA_cg +! +! ASA_cg and Edesol_aa calculated on a GGXGG peptide +! accuracy=0.0025, rh2o=1.4, delete H, sele=(resn X) +! +! e.g. BB bead alanine +! +! BB = CA + C + N + O +! ASA_cg = 176.4940 +! Edesolv_aa = -1.8889 +! +! ASP_cg = -0.0107 +! +! Charleen Don (2012), JR (2014), Jorge Roel (2017) +! +! + +do (store1 = 0.0000) (name BB or name SC*) +! Backbone beads +do (store1 = -0.0107) (name BB and resn ALA) +do (store1 = -0.0089) (name BB and resn GLY) +do (store1 = -0.0153) (name BB and resn ILE) +do (store1 = -0.0158) (name BB and resn VAL) +do (store1 = -0.0046) (name BB and resn PRO) +do (store1 = -0.0137) (name BB and resn ASN) +do (store1 = -0.0147) (name BB and resn GLN) +do (store1 = -0.0165) (name BB and resn THR) +do (store1 = -0.0154) (name BB and resn SER) +do (store1 = -0.0130) (name BB and resn MET) +do (store1 = -0.0167) (name BB and resn CYS) +do (store1 = -0.0126) (name BB and resn PHE) +do (store1 = -0.0134) (name BB and resn TYR) +do (store1 = -0.0134) (name BB and resn TRP) +do (store1 = -0.0169) (name BB and resn ASP) +do (store1 = -0.0150) (name BB and resn GLU) +do (store1 = -0.0155) (name BB and resn HIS) +do (store1 = -0.0163) (name BB and resn LYS) +do (store1 = -0.0162) (name BB and resn ARG) + +! Side-chain beads +!do (store1 = 0.0000) (name SC* and resn ALA) +!do (store1 = 0.0000) (name SC* and resn GLY) +do (store1 = 0.0255) (name SC* and resn ILE) +do (store1 = 0.0222) (name SC* and resn VAL) +do (store1 = 0.0230) (name SC* and resn PRO) +do (store1 = -0.0192) (name SC* and resn ASN) +do (store1 = -0.0135) (name SC* and resn GLN) +do (store1 = -0.0009) (name SC* and resn THR) +do (store1 = -0.0056) (name SC* and resn SER) +do (store1 = 0.0202) (name SC* and resn MET) +do (store1 = 0.0201) (name SC* and resn CYS) +do (store1 = 0.1005) (name SC* and resn PHE) +do (store1 = 0.0669) (name SC* and resn TYR) +do (store1 = 0.0872) (name SC* and resn TRP) +do (store1 = -0.0360) (name SC* and resn ASP) +do (store1 = -0.0301) (name SC* and resn GLU) +do (store1 = 0.0501) (name SC* and resn HIS) +do (store1 = -0.0210) (name SC* and resn LYS) +do (store1 = -0.0229) (name SC* and resn ARG) + +! Fake beads +do (store1 = 0.0) (name SCD* and resn ASN) +do (store1 = 0.0) (name SCD* and resn GLN) +do (store1 = 0.0) (name SCD* and resn SER) +do (store1 = 0.0) (name SCD* and resn THR) +do (store1 = 0.0) (name SCD* and resn ARG) +do (store1 = 0.0) (name SCD* and resn LYS) +do (store1 = 0.0) (name SCD* and resn GLU) +do (store1 = 0.0) (name SCD* and resn ASP) + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/dna-rna_restraints.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/dna-rna_restraints.cns new file mode 100644 index 0000000000000000000000000000000000000000..feb27b3999cec077b4e20abd921dac061b7ded1f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/dna-rna_restraints.cns @@ -0,0 +1,424 @@ +! dna-rna_restraints.def +! Define backbone dihedral angles, hbonds and planarity restraints +! for nucleic acids +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +{+ file: dna-rna_restraints.def +} +{+ description: Creates restraints to maintain conformation of DNA/RNA +} +{+ Additions and changes were made to allow for flexibility during docking +} +{+ comment:This file is to be read by refinement files that modify atom coordinates +} +{+ authors: Axel T. Brunger, and Paul D. Adams +} +{+ modified by Alexandre Bonvin and Marc van Dijk for HADDOCK use +} + +{============================================== base planarity =============================================} + +{* Restrain base planarity. This selection must only include nucleotide residues *} +evaluate ($dna_bases_planar=true) + +{=================================== sugar-pucker dihedral angle restraints ================================} + +{* Pick the dihedral angles of the sugar pucker from the input structure + and restrain them within the given error range *} +evaluate ($dna_pick_pucdih=true) + +{* dihedral C1'-C2'-C3'-C4' error range *} +evaluate ($error_nu2=0.0) +{* dihedral C5'-C4'-C3'-C2' error range *} +evaluate ($error_nu3=0.0) +{* dihedral C1'-O4'-C4'-C5' error range *} +evaluate ($error_nu4=0.0) + +{================================ phosphate backbone dihedral angle restraints =============================} + +{* Pick the dihedral angles of the phosphate backbone from the input structure and + restrain them within the given error range *} +evaluate ($dna_pick_bacdih=true) + +{* Error range for phosphate backbone dihedrals *} +{* alpha dihedral O3'-P-O5'-C5' error range *} +evaluate ($error_alpha=10.0) +{* beta dihedral P-O5'-C5'-C4' error range *} +evaluate ($error_beta=40.0) +{* gamma dihedral O5'-C5'-C4'-C3' error range *} +evaluate ($error_gamma=20.0) +{* delta dihedral C5'-C4'-C3'-O3' error range *} +evaluate ($error_delta=50.0) +{* epsilon dihedral C4'-C3'-O3'-P error range *} +evaluate ($error_eps=10.0) +{* zeta dihedral C3'-O3'-P-O5' error range *} +evaluate ($error_zeta=50.0) + + +{=========================================== Watson-Crick base pairs =======================================} + +{* automatically pick Watson-Crick restraint values from structure *} +evaluate ($dna_pick_wc=true) + +{* error range used for dna_pick_wc defined Watson-Crick restraints *} +evaluate ($wc_low=0.05) +evaluate ($wc_up=0.05) + + +{=========================================== Coarse-Grained ===========================================================} +{* Is the DNA/RNA molecule CG? *} +evaluate ($dna_cg=false) + +{=========================================================================================================} +{ things below this line do not normally need to be changed } +{=========================================================================================================} + + +{- find max and min residue numbers -} +evaluate ($min_resid = 99999) +evaluate ($max_resid = -99999) +show sum(1) ( (resn DA or resn A or resn DG or resn G or resn DT or resn T or resn DC or resn C or resn U) and tag ) +if ( $result > 0 ) then + for $id in id ( (resn DA or resn A or resn DG or resn G or resn DT or resn T or resn DC or resn C or resn U) and tag ) loop resid + show (resid) ( id $id ) + evaluate ($resid=decode($result)) + evaluate ($min_resid = max($min_resid,$resid)) + evaluate ($max_resid = max($max_resid,$resid)) + end loop resid +end if + +{- the planarity restraints single bases -} +if ($dna_bases_planar=true) then + for $id in id ( tag and (resn DA or resn A or resn DG or resn G or resn DT or resn T or resn DC or resn C or resn U) ) loop plan + show (segid) (id $id) + evaluate ($segid=$result) + show (resid) (id $id) + evaluate ($resid=decode($result)) + evaluate ($plweight = 20) + + restraints plane + group + selection=( segid $segid and resid $resid and + (resn T or resn C or resn G or resn A or resn U or + resn DT or resn DC or resn DG or resn DA) and + not (name c#' or name h#' or name h#'' or name o#p or + name h7# or name o#' or name p or name h#t or name o#t)) + weight=$plweight + end + end + end loop plan +end if + +{- Dihedral restraints for the sugar pucker -} + +if ($dna_pick_pucdih=true) then + show sum(1) ( (resn DA or resn A or resn DG or resn G or resn DT or resn T or resn DC or resn C or resn U) and tag ) + if ( $result > 0 ) then + for $id in id ( (resn DA or resn A or resn DG or resn G or resn DT or resn T or resn DC or resn C or resn U) and tag ) loop resid + show (segid) (id $id) + evaluate ($segid=$result) + show (resid) ( id $id ) + evaluate ($resid=decode($result)) + pick dihedral + ( segid $segid and resid $resid and name c1' ) + ( segid $segid and resid $resid and name c2' ) + ( segid $segid and resid $resid and name c3' ) + ( segid $segid and resid $resid and name c4' ) + geometry + evaluatate ($dihedral_nu2=$result) + pick dihedral + ( segid $segid and resid $resid and name c5' ) + ( segid $segid and resid $resid and name c4' ) + ( segid $segid and resid $resid and name c3' ) + ( segid $segid and resid $resid and name c2' ) + geometry + evaluatate ($dihedral_nu3=$result) + pick dihedral + ( segid $segid and resid $resid and name c1' ) + ( segid $segid and resid $resid and name o4' ) + ( segid $segid and resid $resid and name c4' ) + ( segid $segid and resid $resid and name c5' ) + geometry + evaluatate ($dihedral_nu4=$result) + restraints dihedral + assign ( segid $segid and resid $resid and name c1' ) + ( segid $segid and resid $resid and name c2' ) + ( segid $segid and resid $resid and name c3' ) + ( segid $segid and resid $resid and name c4' ) + 20.0 $dihedral_nu2 $error_nu2 2 + assign ( segid $segid and resid $resid and name c5' ) + ( segid $segid and resid $resid and name c4' ) + ( segid $segid and resid $resid and name c3' ) + ( segid $segid and resid $resid and name c2' ) + 20.0 $dihedral_nu3 $error_nu3 2 + assign ( segid $segid and resid $resid and name c1' ) + ( segid $segid and resid $resid and name o4' ) + ( segid $segid and resid $resid and name c4' ) + ( segid $segid and resid $resid and name c5' ) + 20.0 $dihedral_nu4 $error_nu4 2 + scale=20.0 + end + end loop resid + flags include cdih end + end if +end if + +{- Dihedral restraints for the phosphate backbone -} + +if ($dna_pick_bacdih=true) then + show sum(1) ( (resn DA or resn A or resn DG or resn G or resn DT or resn T or resn DC or resn C or resn U) and tag ) + if ( $result > 0 ) then + evaluate ($resid=$min_resid) + evaluate ($nres=$max_resid - $min_resid + 1) + evaluate ($error_alpha=$error_alpha) + evaluate ($error_beta=$error_beta) + evaluate ($error_gamma=$error_gamma) + evaluate ($error_zeta=$error_zeta) + evaluate ($error_epsilon=$error_eps) + evaluate ($error_delta=$error_delta) + for $id in id ( (resn DA or resn A or resn DG or resn G or resn DT or resn T or resn DC or resn C or resn U) and tag ) loop resid + show (segid) (id $id) + evaluate ($segid=$result) + show (resid) ( id $id ) + evaluate ($resid=decode($result)) + if ($resid > $min_resid) then + evaluate ($rprec = $resid - 1) + ! check if previous residue exists + show sum(1) ( resid $rprec and tag ) + if ( $result > 0 ) then + pick dihedral + ( segid $segid and resid $rprec and name O3' ) + ( segid $segid and resid $resid and name P ) + ( segid $segid and resid $resid and name O5' ) + ( segid $segid and resid $resid and name C5' ) + geometry + evaluatate ($dihedral_alpha=$result) + pick dihedral + ( segid $segid and resid $resid and name P ) + ( segid $segid and resid $resid and name O5' ) + ( segid $segid and resid $resid and name C5' ) + ( segid $segid and resid $resid and name C4' ) + geometry + evaluatate ($dihedral_beta=$result) + restraint dihedral + ! alpha + assign ( segid $segid and resid $rprec and name O3' ) + ( segid $segid and resid $resid and name P ) + ( segid $segid and resid $resid and name O5' ) + ( segid $segid and resid $resid and name C5' ) + 1.0 $dihedral_alpha $error_alpha 2 + ! beta + assign ( segid $segid and resid $resid and name P ) + ( segid $segid and resid $resid and name O5' ) + ( segid $segid and resid $resid and name C5' ) + ( segid $segid and resid $resid and name C4' ) + 1.0 $dihedral_beta $error_beta 2 + scale 200.0 + end + end if + end if + + pick dihedral + ( segid $segid and resid $resid and name O5' ) + ( segid $segid and resid $resid and name C5' ) + ( segid $segid and resid $resid and name C4' ) + ( segid $segid and resid $resid and name C3' ) + geometry + evaluatate ($dihedral_gamma=$result) + pick dihedral + ( segid $segid and resid $resid and name C5' ) + ( segid $segid and resid $resid and name C4' ) + ( segid $segid and resid $resid and name C3' ) + ( segid $segid and resid $resid and name O3' ) + geometry + evaluatate ($dihedral_delta=$result) + + restraints dihedral + ! gamma + assign ( segid $segid and resid $resid and name O5' ) + ( segid $segid and resid $resid and name C5' ) + ( segid $segid and resid $resid and name C4' ) + ( segid $segid and resid $resid and name C3' ) + 1.0 $dihedral_gamma $error_gamma 2 + ! delta + assign ( segid $segid and resid $resid and name C5' ) + ( segid $segid and resid $resid and name C4' ) + ( segid $segid and resid $resid and name C3' ) + ( segid $segid and resid $resid and name O3' ) + 1.0 $dihedral_delta $error_delta 2 + scale=200.0 + end + + if ($resid < $max_resid) then + evaluate ($rfoll = $resid + 1) + ! check if next residue exists + show sum(1) ( resid $rfoll and segid $segid and tag ) + if ( $result > 0 ) then + pick dihedral + ( segid $segid and resid $resid and name C4' ) + ( segid $segid and resid $resid and name C3' ) + ( segid $segid and resid $resid and name O3' ) + ( segid $segid and resid $rfoll and name P ) + geometry + evaluatate ($dihedral_epsilon=$result) + pick dihedral + ( segid $segid and resid $resid and name C3' ) + ( segid $segid and resid $resid and name O3' ) + ( segid $segid and resid $rfoll and name P ) + ( segid $segid and resid $rfoll and name O5' ) + geometry + evaluatate ($dihedral_zeta=$result) + restraint dihedral + ! epsilon + assign ( segid $segid and resid $resid and name C4' ) + ( segid $segid and resid $resid and name C3' ) + ( segid $segid and resid $resid and name O3' ) + ( segid $segid and resid $rfoll and name P ) + 1.0 $dihedral_epsilon $error_epsilon 2 + ! zeta + assign ( segid $segid and resid $resid and name C3' ) + ( segid $segid and resid $resid and name O3' ) + ( segid $segid and resid $rfoll and name P ) + ( segid $segid and resid $rfoll and name O5' ) + 1.0 $dihedral_zeta $error_zeta 2 + scale 200.0 + end + end if + end if + end loop resid + flags include cdih end + end if +end if + +{- Watson-Crick base pairing -} + +if ($dna_pick_wc = true) then + evaluate ($hbcut = 3.5) + ! We only to check for ADE and CYT + show sum(1) ( (resn DA or resn A or resn DC or resn C) and tag ) + if ( $result > 0 ) then + noe + class hres + averaging hres cent + potential hres square + sqconstant hres 1. + sqexponent hres 2 + scale hres 70. + end + for $id in id ( (resn DA or resn A or resn DC or resn C) and tag ) loop resid + show (segid) (id $id) + evaluate ($segid=$result) + show (resid) ( id $id ) + evaluate ($resid=decode($result)) + evaluate ($presid=$resid-1) + evaluate ($fresid=$resid+1) + evaluate ($ares_name = none) + show ( resn ) (id $id) + evaluate ($ares=$result) + + if ( $ares = DA ) then + eval ($ares_name = ADE) + elseif ( $ares = A ) then + eval ($ares_name = ADE) + end if + + if ( $ares = DC ) then + eval ($ares_name = CYT) + elseif ( $ares = C ) then + eval ($ares_name = CYT) + end if + + if ($ares_name = ADE) then + show sum(1) ( ((resn DT or resn T or resn U) and not (resid $presid or resid $fresid) and name N3) + and (resid $resid and name N1) around $hbcut) + if ($result = 1) then + show (resid) ( ((resn DT or resn T or resn U) and not (resid $presid or resid $fresid) and name N3) + and (resid $resid and name N1) around $hbcut) + evaluate ($rpair = $result) + pick bond + (resid $resid and name N6) + (resid $rpair and name O4) + geometry + evaluate ($n6o4=$result) + pick bond + (resid $resid and name N1) + (resid $rpair and name N3) + geometry + evaluate ($n1n3=$result) + pick bond + (resid $resid and name N1) + (resid $rpair and name O4) + geometry + evaluate ($n1o4=$result) + pick bond + (resid $resid and name N1) + (resid $rpair and name O2) + geometry + evaluate ($n1o2=$result) + noe + assign (resid $resid and name N6) + (resid $rpair and name O4) + $n6o4 $wc_low $wc_up + assign (resid $resid and name N1) + (resid $rpair and name N3) + $n1n3 $wc_low $wc_up + assign (resid $resid and name N1) + (resid $rpair and name O4) + $n1o4 $wc_low $wc_up + assign (resid $resid and name N1) + (resid $rpair and name O2) + $n1o2 $wc_low $wc_up + end + end if + end if + + !find possible pairing for DC/C with DG/G + if ($ares_name = CYT) then + show sum(1) ( ((resn DG or resn G) and not (resid $presid or resid $fresid) and name N1) + and (resid $resid and name N3) around $hbcut) + if ($result = 1) then + show (resid) ( ((resn DG or resn G) and not (resid $presid or resid $fresid) and name N1) + and (resid $resid and name N3) around $hbcut) + evaluate ($rpair = $result) + pick bond + (resid $resid and name N3) + (resid $rpair and name N1) + geometry + evaluate ($n3n1=$result) + pick bond + (resid $resid and name N4) + (resid $rpair and name O6) + geometry + evaluate ($n4o6=$result) + pick bond + (resid $resid and name O2) + (resid $rpair and name N2) + geometry + evaluate ($o2n2=$result) + pick bond + (resid $resid and name N3) + (resid $rpair and name O6) + geometry + evaluate ($n3o6=$result) + pick bond + (resid $resid and name N3) + (resid $rpair and name N2) + geometry + evaluate ($n3n2=$result) + noe + assign (resid $resid and name N3) + (resid $rpair and name N1) $n3n1 $wc_low $wc_up + assign (resid $resid and name N4) + (resid $rpair and name O6) $n4o6 $wc_low $wc_up + assign (resid $resid and name O2) + (resid $rpair and name N2) $o2n2 $wc_low $wc_up + assign (resid $resid and name N3) + (resid $rpair and name O6) $n3o6 $wc_low $wc_up + assign (resid $resid and name N3) + (resid $rpair and name N2) $n3n2 $wc_low $wc_up + end + end if + end if + end loop resid + end if +end if diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/flex_segment_back.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/flex_segment_back.cns new file mode 100644 index 0000000000000000000000000000000000000000..bc36e726eff3efc780d3805fa67bde831135d182 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/flex_segment_back.cns @@ -0,0 +1,26 @@ +! flex_segment_back.cns +! Define the semi-flexible segments (both side-chains and backbone) +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +do (store5 = 0) (all) +do (store6 = 0) (all) +do (store7 = 0) (all) + +!define interface flexible regions +evaluate($nchain1 = 0) +while ($nchain1 < $data.ncomponents) loop nloop1 + evaluate($nchain1 = $nchain1 + 1) + inline @MODULE:flexauto-neighbors.cns +end loop nloop1 + +do (store5 = 21) (resn WAT or resn HOH or resn TIP*) +do (store1 = 0) (all) +do (store1 = 1) ((resn WAT or resn HOH or resn TIP*) and name OH2) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/flex_segment_side.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/flex_segment_side.cns new file mode 100644 index 0000000000000000000000000000000000000000..f40eb6fd59aec01cec788a37e89a392826de01df --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/flex_segment_side.cns @@ -0,0 +1,29 @@ +! flex_segment_side.cns +! Define semi-flexible segments (side-chains only) +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +do (store5 = 0) (all) +do (store6 = 0) (all) +do (store7 = 0) (all) + +!define interface flexible regions +evaluate($nchain1 = 0) +while ($nchain1 < $data.ncomponents) loop nloop1 + evaluate($nchain1 = $nchain1 + 1) + inline @MODULE:flexauto-neighbors.cns +end loop nloop1 + +! freeze backbone +do (store5 = 0) (name CA or name BB or name C or name N or name O) + +do (store5 = 21) (resn WAT or resn HOH or resn TIP*) +do (store1 = 0) (all) +do (store1 = 1) ((resn WAT or resn HOH or resn TIP*) and name OH2) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/flexauto-neighbors.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/flexauto-neighbors.cns new file mode 100644 index 0000000000000000000000000000000000000000..38689b8dceef65e750e714ed535daaf9e7981354 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/flexauto-neighbors.cns @@ -0,0 +1,45 @@ +! flexauto-neighbors.cns +! Automatic definition of flexible segments for docking for contacting residues +! including neighboring residues of residues making contacts +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +evaluate ($flcut = 5.0) + +do (store5 = $nchain1) (byres (segid $prot_segid_$nchain1 + and (not (segid $prot_segid_$nchain1 or resn SHA)) around $flcut)) +do (store7 = $nchain1) (byres (segid $prot_segid_$nchain1 + and (not (segid $prot_segid_$nchain1 or resn SHA)) around $flcut)) + +do (store6 = 0) (segid $prot_segid_$nchain1) +for $id in id (tag and attr store5 >0 and not ((resn WAT or resn HOH or resn TIP*) or resn DMSO) and segid $prot_segid_$nchain1) loop flexres1 + show (resid) (id $id) + evaluate ($inres = decode($result)) + evaluate ($preres = $inres) + evaluate ($nexres = $inres) + evaluate ($preres = $preres - 1) + do (store6 = $nchain1) (resid $preres and segid $prot_segid_$nchain1) + do (store6 = $nchain1) (resid $nexres and segid $prot_segid_$nchain1) +end loop flexres1 + +do (store5 = store6) (segid $prot_segid_$nchain1) +do (store7 = store6) (segid $prot_segid_$nchain1) + +display THE FOLLOWING RESIDUES HAVE BEEN DEFINED AS FLEXIBLE for molecule $nchain1 +for $id in id (tag and attr store5 >0 and not ((resn WAT or resn HOH or resn TIP*) or resn DMSO) and segid $prot_segid_$nchain1) loop flexres2 + show (resid) (id $id) + evaluate ($inres = $result) + show (resn) (id $id) + evaluate ($nares = $result) + show (segid) (id $id) + evaluate ($seres = $result) + display AUTOMATICALLY SELECTED SEGMENT: $nares,$inres,$seres +end loop flexres2 + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/generate_dmso.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/generate_dmso.cns new file mode 100644 index 0000000000000000000000000000000000000000..2acdf950614511fcaac33db9ab7fa54cd478b947 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/generate_dmso.cns @@ -0,0 +1,121 @@ +! generate_dmso.cns +! Generate a DMSO solvent layer around the molecule +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * Originally adapted from Aria 1.2 from Nilges and Linge, EMBL. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +eval ($boxlength = 29.1) ! length of the dmso box +eval ($thickness = 12.5) ! maxi. initial dmso-protein distance (heavy atoms) +eval ($pw_dist = 2.4) ! mini. initial dmso-protein distance (heavy atoms) +eval ($dmso_diam = 4.1) ! diameter of dmso molecule +eval ($dyncount = 1) ! iteration number (usually 1) + +eval ($dmso = "DMS" + encode($dyncount)) + +!-------------------------------------------------- +! read in the same box of dmso several times, and move it around +! so as to cover all the space around the site of interest. +! take into account box offset + +show max (x) ((not resn dms) and not resn ANI and not resn DAN and not resn XAN or resn DUM or resn SHA) +evaluate ($xmax = $result) +show min (x) ((not resn DMS) and not resn ANI and not resn DAN and not resn XAN or resn DUM or resn SHA) +evaluate ($xmin = $result) + +show max (y) ((not resn DMS) and not resn ANI and not resn DAN and not resn XAN or resn DUM or resn SHA) +evaluate ($ymax = $result) +show min (y) ((not resn DMS) and not resn ANI and not resn DAN and not resn XAN or resn DUM or resn SHA) +evaluate ($ymin = $result) + +show max (z) ((not resn DMS) and not resn ANI and not resn DAN and not resn XAN or resn DUM or resn SHA) +evaluate ($zmax = $result) +show min (z) ((not resn DMS) and not resn ANI and not resn DAN and not resn XAN or resn DUM or resn SHA) +evaluate ($zmin = $result) + + +! loop over several iterations of dmso filling and dynamics + + +!-------------------------------------------------- +! read in the same box of dmso several times, and move it around +! so as to cover all the space around the site of interest. +! take into account box offset + + +! determine how many boxes are necessary in each dimension +eval ($xbox = int( ($xmax - $xmin + 2 * ($thickness + $dmso_diam)) / $boxlength + 0.5)) +eval ($ybox = int( ($ymax - $ymin + 2 * ($thickness + $dmso_diam)) / $boxlength + 0.5)) +eval ($zbox = int( ($zmax - $zmin + 2 * ($thickness + $dmso_diam)) / $boxlength + 0.5)) + +eval ($xmtran = $xmax + $thickness - $boxlength/2 + $dmso_diam) +eval ($ymtran = $ymax + $thickness - $boxlength/2 + $dmso_diam) +eval ($zmtran = $zmax + $thickness - $boxlength/2 + $dmso_diam) + +eval ($xcount=0) +eval ($xtrans = $xmin - $thickness - $dmso_diam - $boxlength ) +while ($xtrans < $xmtran) loop dms1 + eval ($xcount=$xcount+1) + eval ($xtrans = $xtrans + $boxlength) + + eval ($ycount=0) + eval ($ytrans = $ymin - $thickness - $dmso_diam - $boxlength ) + while ($ytrans < $ymtran) loop dms2 + eval ($ycount=$ycount+1) + eval ($ytrans = $ytrans + $boxlength) + + eval ($zcount=0) + eval ($ztrans = $zmin - $thickness - $dmso_diam - $boxlength ) + while ($ztrans < $zmtran) loop dms3 + eval ($zcount=$zcount+1) + eval ($ztrans = $ztrans + $boxlength) + + segment + name=" " + chain + coordinates @@TOPPAR:dmso.pdb + end + end + coor @@TOPPAR/dmso.pdb + do (segid=DMSO) (segid " ") + coor sele=(segid DMSO) translate vector = ($xtrans $ytrans $ztrans) end + + ! all new dmso oxygens + ident (store1) (segid DMSO and name sd) + ! all new dmso oxygens close to a protein heavy atom + ident (store2) (store1 and (not (resn DMS or resn ANI or resn DAN or resn XAN or resn DUM or resn SHA or hydro)) around $pw_dist) + ! all new dmso oxygens close to old dmso oxygens + ident (store3) (store1 and (segid DMS# and not hydro) around $dmso_diam) + ! all new dmso oxygens further than thickness away from a protein heavy atom + ident (store4) (store1 and not (not (resn DMS or resn ANI or resn DAN or resn XAN or resn DUM or resn SHA or hydro)) around $thickness) + delete sele= (byres (store2 or store3 or store4)) end + + + ! give dmso unique segid name + eval ($segid= "W" + encode($xcount) + encode($ycount) + encode($zcount)) + do (segid = $segid) (segid DMSO) + + end loop dms3 + end loop dms2 +end loop dms1 + +! now, give dmso a unique resid so that we get the segid to play around with +ident (store1) (all) +show min (store1) (segid w*) +do (store1 = store1 - $result + 1) (segid w*) +do (resid = encode(int(store1/3 -0.1) +1)) (segid w* and not segid DMS#) +do (segid = $dmso) (segid w* and not segid DMS#) + +! shave off any dmso that left +delete sele= (byres (name sd and not (not (resn DMS or resn ANI or resn DAN or resn XAN or resn DUM or resn SHA or hydro)) around $thickness)) end + +{* write out initial coordinates just for testing *} +!evaluate ($filename=$output_pdb_filename - ".pdb" + "wini.pdb") +!write coordinates sele= (all) output =$filename end + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/generate_water.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/generate_water.cns new file mode 100644 index 0000000000000000000000000000000000000000..3590ca25a9294d764d8b146cb1727408179b3b93 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/generate_water.cns @@ -0,0 +1,122 @@ +! generate_water.cns +! Generate a water solvent layer around the molecule +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * Originally adapted from Aria 1.2 from Nilges and Linge, EMBL. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +eval ($boxlength = 18.856) ! length of Brooks' water box +eval ($thickness = 8) ! maxi. initial water-protein distance (heavy atoms) +eval ($pw_dist = 2.4) ! mini. initial water-protein distance (heavy atoms) +eval ($water_diam = 2.4) ! diameter of water molecule +eval ($dyncount = 21) ! for water segid (max number of molecules + 1) + +eval ($water = "WA" + encode($dyncount)) + +!-------------------------------------------------- +! read in the same box of water several times, and move it around +! so as to cover all the space around the site of interest. +! take into account box offset + +show max (x) ((not (resn WAT or resn HOH or resn TIP*)) and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) +evaluate ($xmax = $result) +show min (x) ((not (resn WAT or resn HOH or resn TIP*)) and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) +evaluate ($xmin = $result) + +show max (y) ((not (resn WAT or resn HOH or resn TIP*)) and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) +evaluate ($ymax = $result) +show min (y) ((not (resn WAT or resn HOH or resn TIP*)) and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) +evaluate ($ymin = $result) + +show max (z) ((not (resn WAT or resn HOH or resn TIP*)) and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) +evaluate ($zmax = $result) +show min (z) ((not (resn WAT or resn HOH or resn TIP*)) and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) +evaluate ($zmin = $result) + + +! loop over several iterations of water filling and dynamics + +!-------------------------------------------------- +! read in the same box of water several times, and move it around +! so as to cover all the space around the site of interest. +! take into account box offset + + +! determine how many boxes are necessary in each dimension +eval ($xbox = int( ($xmax - $xmin + 2 * ($thickness + $water_diam)) / $boxlength + 0.5)) +eval ($ybox = int( ($ymax - $ymin + 2 * ($thickness + $water_diam)) / $boxlength + 0.5)) +eval ($zbox = int( ($zmax - $zmin + 2 * ($thickness + $water_diam)) / $boxlength + 0.5)) + +eval ($xmtran = $xmax + $thickness - $boxlength/2 + $water_diam) +eval ($ymtran = $ymax + $thickness - $boxlength/2 + $water_diam) +eval ($zmtran = $zmax + $thickness - $boxlength/2 + $water_diam) + +eval ($xcount=0) +eval ($xtrans = $xmin - $thickness - $water_diam - $boxlength/2 ) +while ($xtrans < $xmtran) loop wat1 + eval ($xcount=$xcount+1) + eval ($xtrans = $xtrans + $boxlength) + + eval ($ycount=0) + eval ($ytrans = $ymin - $thickness - $water_diam - $boxlength/2 ) + while ($ytrans < $ymtran) loop wat2 + eval ($ycount=$ycount+1) + eval ($ytrans = $ytrans + $boxlength) + + eval ($zcount=0) + eval ($ztrans = $zmin - $thickness - $water_diam - $boxlength/2 ) + while ($ztrans < $zmtran) loop wat3 + eval ($zcount=$zcount+1) + eval ($ztrans = $ztrans + $boxlength) + segment + name=" " + chain + coordinates @@TOPPAR:boxtyp20.pdb + end + end + coor @@TOPPAR:boxtyp20.pdb + do (segid=W000) (segid " ") + coor sele=(segid W000) translate vector = ($xtrans $ytrans $ztrans) end + + ! all new water oxygens + ident (store1) (segid W000 and name OH2) + ! all new water oxygens close to a protein heavy atom + ident (store2) (store1 and (not (resn WAT or resn HOH or resn TIP* + or resn ANI or resn DAN or resn XAN or resn DUM or resn SHA or hydro)) around $pw_dist) + ! all new water oxygens close to old water oxygens + ident (store3) (store1 and (segid wat# and not hydro) around $water_diam) + ! all new water oxygens further than thickness away from a protein heavy atom + ident (store4) (store1 and not (not (resn WAT or resn HOH or resn TIP* + or resn ANI or resn DAN or resn XAN or resn DUM or resn SHA or hydro)) around $thickness) + delete sele= (byres (store2 or store3 or store4)) end + + ! give waters unique segid name + eval ($segid= "W" + encode($xcount) + encode($ycount) + encode($zcount)) + do (segid = $segid) (segid W000) + + end loop wat3 + end loop wat2 +end loop wat1 + +! now, give waters a unique resid so that we get the segid to play around with +ident (store1) (all) +show min (store1) (segid w*) +do (store1 = store1 - $result + 1) (segid w*) +do (resid = encode(int(store1/3 -0.1) +1)) (segid w* and not segid wat#) +do (segid = $water) (segid w* and not segid wat#) + +! shave off any waters that left +delete sele= (byres (name oh2 and segid W* and + not (not (resn WAT or resn HOH or resn TIP* + or resn ANI or resn DAN or resn XAN or resn DUM or resn SHA or hydro)) around $thickness)) end + +{* write out initial coordinates just for testing *} +!evaluate ($filename=$output_pdb_filename - ".pdb" + "wini.pdb") +!write coordinates sele= (all) output =$filename end + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/mdscoring.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/mdscoring.cns new file mode 100644 index 0000000000000000000000000000000000000000..7deb6e54c858904970bde1366511062ae8102d9c --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/mdscoring.cns @@ -0,0 +1,471 @@ +! mdref.cns +! Perform an explitic solvent (water or dmso) refinement +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +if ( $log_level = "verbose" ) then + set message=all echo=on end +elseif ( $log_level = "normal" ) then + set message=normal echo=off end +else + set message=off echo=off end +end if + +!==================================================================! +! Initialisation of variables +!==================================================================! + +evaluate ($ini_count =1) + +evaluate ($Data.flags.ncs = false) +evaluate ($Data.flags.sym = false) +evaluate ($Data.flags.cdih = false) +evaluate ($Data.flags.plan = false) +evaluate ($Data.flags.noe = false) +evaluate ($Data.flags.dihed = $dihedflag) +evaluate ($Data.flags.elec = $elecflag) +evaluate ($Data.flags.em = false) +evaluate ($Data.flags.rg = false) +evaluate ($Data.flags.zres = false) +evaluate ($Data.flags.sani = false) +evaluate ($Data.flags.xrdc = false) +evaluate ($Data.flags.xpcs = false) +evaluate ($Data.flags.dani = false) +evaluate ($Data.flags.vean = false) + +evaluate ($Data.noecv = false) +evaluate ($refine.keepwater = false) + +evaluate ($data.ncomponents=$ncomponents) + +evaluate ($nmol=1) +while ($nmol <= $data.ncomponents) loop mol + evaluate ($toppar.prot_segid_$nmol = $prot_segid_$nmol) + evaluate ($mol_shape_$nmol = false) + evaluate ($nmol = $nmol + 1) +end loop mol + + +! non-bonded parameter set to use +evaluate ($toppar.par_nonbonded = "OPLSX") + +!Electrostatics: +evaluate ($Data.flags.dihed =$dihedflag) +evaluate ($Data.flags.elec =$elecflag) +evaluate ($Data.epsilon =$epsilon) +evaluate ($Data.dielec =$dielec) + + +! dihedrals, DNA and distance restraints +evaluate ($Data.dnarest =$dnarest_on) +evaluate ($Data.flags.cdih = false) +evaluate ($Data.ssdihed =$ssdihed) +evaluate ($Data.error_dih =$error_dih) + +! planarity restraints +evaluate ($Data.flags.plan = false) + +! distance restraints +evaluate ($Data.flags.noe = false) +evaluate ($data.randremoval = false) +evaluate ($data.npart=1) +evaluate ($data.contactairs=$contactairs) +evaluate ($data.kcont=$kcont) + + +! Other parameters +evaluate ($refine.keepwater = false) +evaluate ($refine.keepwater=$keepwater) +evaluate ($refine.solvent=$solvent) +evaluate ($refine.heatsteps=$waterheatsteps) +evaluate ($refine.steps=$watersteps) +evaluate ($refine.coolsteps=$watercoolsteps) +evaluate ($refine.iniseed=$iniseed) +evaluate ($refine.timestep=$timestep) +evaluate ($refine.fbeta=100) +evaluate ($refine.mass=100) + + +!==================================================================! + +{* Read paramters and set various force field related variables *} + +@MODULE:read_param.cns + +parameter + bond (resn WAT ) (resn WAT ) 1000 TOKEN + angle (resn WAT ) (resn WAT ) (resn WAT ) 500 TOKEN + bond (resn HOH ) (resn HOH ) 1000 TOKEN + angle (resn HOH ) (resn HOH ) (resn HOH ) 500 TOKEN + bond (resn TIP*) (resn TIP*) 1000 TOKEN + angle (resn TIP*) (resn TIP*) (resn TIP*) 500 TOKEN +end + +igroup + interaction (not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) + (not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) weight * 1 end + interaction (resn ANI or resn DAN or resn XAN or resn DUM or resn DUM) + (resn ANI or resn DAN or resn XAN or resn DUM or resn DUM) weight * 1 vdw 0.0 elec 0.0 end + interaction (resn SHA) (not resn SHA) weight * 0 end +end + +flag include bond angle impr vdw end + +if ($Data.flags.dihed eq true) then + flag include dihed end +end if + +if ($Data.flags.elec eq true) then + flag include elec end + if ($Data.dielec eq "rdie") then + parameter nbonds eps=$Data.epsilon rdie shift switch end end + ! shift statement needed first to activate switch (CNS bug?) + else + parameter nbonds eps=$Data.epsilon cdie end end + end if + parameter nbonds ? end end +else + evaluate ($elec=0.0) + flag exclude elec end +end if + +coor copy end + +topology @@TOPPAR:solvent-allhdg5-4.top end + +if ($refine.solvent = "water") then + do (segid = "PROT") (segid " ") + @MODULE:generate_water.cns + do (segid = " ") (segid "PROT") +elseif ($refine.solvent = "dmso") then + do (segid = "PROT") (segid " ") + @MODULE:generate_dmso.cns + do (segid = " ") (segid "PROT") +end if + +! The seed definition logic is handled at haddock.libs.libcns.prepare_cns_input (July 2024) +set seed $seed end + + +if ( $log_level = "verbose" ) then + set message=all echo=on end +elseif ( $log_level = "normal" ) then + set message=normal echo=off end +else + set message=off echo=off end +end if + + +{* Check for other restraints ================================================== *} + +if ($Data.contactairs eq true ) then + evaluate ($Data.flags.noe = true) + noe + reset + nrestraints = 12000000 ! allocate space for contactairs + ceiling 1000 + averaging * sum + potential * soft + scale * $kcont + sqconstant * 1.0 + sqexponent * 2 + soexponent * 1 + rswitch * 0.5 + sqoffset * 0.0 + asymptote * 0.1 + msoexponent * 1 + masymptote * -0.1 + mrswitch * 0.5 + avexpo hbond 20 + end + @MODULE:contactairs.cns +end if + +if ($Data.dnarest eq true ) then + @MODULE:dna-rna_restraints.cns +end if + +if ($Data.ssdihed eq "all" ) then + inline @MODULE:protein-ss-restraints-all.cns +end if +if ($Data.ssdihed eq "alpha" ) then + inline @MODULE:protein-ss-restraints-alpha.cns +end if +if ($Data.ssdihed eq "alphabeta" ) then + inline @MODULE:protein-ss-restraints-alpha-beta.cns +end if + + +{* Check for the presence of ions and add distance restraints / covalent bond == *} + +@MODULE:restrain-ions.cns + + +{* set the energy flags ======================================================== *} + +inline @MODULE:setflags.cns + + +{* Energy minimisation of solvent first ============================================= *} + +! fix everything except the solvent for initial minimization +fix sele = (not (resn WAT or resn HOH or resn TIP* or resn DMS)) end + +if ($nemsteps > 0) then + minimize powell nstep=$nemsteps drop=100 end +end if + + +{* Energy minimisation with harmonic restraints on the molecules ==================== *} + +fix sele = (not all) end + +! fix the shape +fix sele = (resn SHA) end + +do (refx=x) (all) +do (refy=y) (all) +do (refz=z) (all) + +! Define harmonic restraints on heavy atoms of molecules +restraints harmonic + exponent = 2 +end +do (harm = 0) (all) +do (harm = 5) (not name h* and not (resn WAT or resn HOH or resn TIP* or resn DMS)) + +igroup + interaction (not (resn ANI or resn DAN or resn XAN or resn SHA)) (not (resn ANI or resn DAN or resn XAN or resn SHA)) weight * 1 end + interaction (resn ANI or resn DAN or resn XAN) + (resn ANI or resn DAN or resn XAN) weight * 1 vdw 0.0 elec 0.0 end +end + +if ($nemsteps > 0) then + minimize powell nstep=$nemsteps drop=10 end +end if + + +{* MD refinement with harmonic restraints on the molecules ==================== *} + +do (refx=x) (all) +do (refy=y) (all) +do (refz=z) (all) + +! Define harmonic restraints on heavy atoms of molecules +do (harm = 0) (all) +do (harm = 5) (not name h* and not resn ANI and not resn DAN and not resn XAN and not (resn WAT or resn HOH or resn TIP3)) +do (harm = 20) (resn ANI and name OO) +do (harm = 20) (resn DAN and name OO) + +! Remove harmonic restraints on interface side-chains +@MODULE:flex_segment_side.cns +eval ($nchain1 = 0) +while ($nchain1 < $data.ncomponents) loop nloop1 + eval ($nchain1=$nchain1+1) + do (harm = 0) (attribute store5 = $nchain1 and + not ( name CA or name BB or name C or name N or name P or name C# or name C## )) +end loop nloop1 + + +! Start MD refinement + +do (mass =$refine.mass) (all) +do (mass=1000) (resn ANI or resn DAN or resn XAN) +do (fbeta = 0) (all) +do (fbeta = $refine.fbeta {1/ps} ) ( all ) + +! heat to 300 K +for $bath in (100 200 300) loop heat + + do (vx=maxwell($bath)) (all) + do (vy=maxwell($bath)) (all) + do (vz=maxwell($bath)) (all) + + dynamics cartesian + nstep=$refine.heatsteps timest=0.002{ps} + temperature=$bath tcoupling = true + nprint=50 + end + +end loop heat + +do (refx=x) (all) +do (refy=y) (all) +do (refz=z) (all) + +!define weaker harmonic restraints on heavy atoms of molecules +do (harm = 0) (all) +do (harm = 1) (not name h* and not resn ANI and not resn DAN and not resn XAN and not (resn WAT or resn HOH or resn TIP3)) + +!define flexible segments and remove harmonic restraints on backbone + side-chains of interface +@MODULE:flex_segment_back.cns +eval ($nchain1 = 0) +while ($nchain1 < $data.ncomponents) loop nloop1 + eval ($nchain1=$nchain1+1) + do (harm = 0) (attribute store5 = $nchain1) +end loop nloop1 +do (harm = 20) (resn ANI and name OO) +do (harm = 20) (resn DAN and name OO) + +! MD refinement +dynamics cartesian + nstep=$refine.steps timest=0.002{ps} + temperature=$bath tcoupling = true + nprint=50 +end + +do (refx=x) (all) +do (refy=y) (all) +do (refz=z) (all) + +! Define weak harmonic restraints on backbone only of molecules +do (harm = 0) (all) +do (harm = 1) (name CA or name BB or name C or name N or name P or name C# or name C##) +! Remove harmonic restraints on interface side-chains +@MODULE:flex_segment_side.cns +eval ($nchain1 = 0) +while ($nchain1 < $data.ncomponents) loop nloop1 + eval ($nchain1=$nchain1+1) + do (harm = 0) (attribute store5 = $nchain1) +end loop nloop1 +do (harm = 20) (resn ANI and name OO) +do (harm = 20) (resn DAN and name OO) + + +! cooling phase +for $bath in (300 200 100) loop cool + + dynamics cartesian + nstep=$refine.coolsteps timest=0.002{ps} + temperature=$bath tcoupling = true + nprint=50 + end + +end loop cool + + +! final minimization without harmonic restraints + +flag excl harm end + +if ($nemsteps > 0) then + minimize powell nstep=$nemsteps drop=10 end +end if + + +{* ======================= calculate free molecules internal energy *} + +igroup + interaction (not (resn ANI or resn DAN or resn XAN or resn SHA or resn WAT or resn HOH or resn TIP* or resn DUM)) + (not (resn ANI or resn DAN or resn XAN or resn SHA or resn WAT or resn HOH or resn TIP* or resn DUM)) weight * 1 end +end + +do (refx=x) (all) +do (refy=y) (all) +do (refz=z) (all) + +fix sele=(resn ANI or resn DAN or resn XAN or resn SHA or resn WAT or resn HOH or resn TIP* or resn DMS) end + +inline @MODULE:calc_free-ene.cns + +fix sele=(not all) end + +do (x = refx) (all) +do (y = refy) (all) +do (z = refz) (all) + + + +{* ===================== calculate complex internal energy *} + +evaluate ($kinter = 1.0) + +@MODULE:scale_intra_only.cns + +evaluate ($elec = 0.0) +evaluate ($eintcplx = 0.0) + +energy end + +evaluate ($eintcplx = $bond + $angl + $impr + $dihe + $vdw + $elec) +evaluate ($ebond = $bond) +evaluate ($eangl= $angl) +evaluate ($eimpr= $impr) +evaluate ($edihe= $dihe) + +evaluate ($result=0) +print thres=0.05 bonds +evaluate ($rms_bonds=$result) +evaluate ($result=0) +print thres=5. angles +evaluate ($rms_angles=$result) +evaluate ($result=0) +print thres=5. impropers +evaluate ($rms_impropers=$result) +evaluate ($result=0) +print thres=30. dihedrals +evaluate ($rms_dihedrals=$result) + + +{* ===================== calculate final energies and write structure *} +evaluate ($cdih=0.0) +evaluate ($noe=0.0) +if ($Data.ncomponents > 1) then + evaluate ($kinter = 1.0) + @MODULE:scale_inter_final.cns +else + @MODULE:scale_intra_only.cns +end if + +evaluate ($coll = 0.0) +evaluate ($eair = 0.0) +evaluate ($esym = 0.0) +evaluate ($ncs = 0.0) +evaluate ($zhar = 0.0) +evaluate ($dani = 0.0) +evaluate ($sani = 0.0) +evaluate ($vean = 0.0) +evaluate ($xrdc = 0.0) +evaluate ($xpcs = 0.0) +evaluate ($rms_noe=0.0) +evaluate ($violations_noe=0) +evaluate ($rms_test_noe=0.0) +evaluate ($violations_test_noe=0) + +energy end +evaluate ($etot = $ener - $noe) +evaluate ($noe = $eair) +evaluate ($etot = $etot + $noe) + +inline @MODULE:print_coorheader.cns + +coor sele= (not name H* and not resn ANI and not resn XAN and not resn DAN) orient end + +inline @MODULE:check_coordinates.cns + +if ($failure eq true) then + evaluate ($failfile = $output_pdb_filename - ".pdb" + ".fail") + set display=$failfile end + display "MAX/MIN possible coordinates exceeded - stopping" + close $failfile end + stop +else + write coordinates sele=(not (resn WA* or resn HOH or resn TIP* or resn DMS)) format=pdbo output=$output_pdb_filename end +end if + +if ($refine.keepwater eq true) then + evaluate ($filename= $output_pdb_filename - ".pdb" + "_solvent.pdb") + write coordinates sele=(all) format=pdbo output=$filename end +end if + +set message=normal echo=on end +display OUTPUT: $output_pdb_filename + +stop + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/print_coorheader.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/print_coorheader.cns new file mode 100644 index 0000000000000000000000000000000000000000..be945dbe877b5cb3f549b95e85498d399f1d41ec --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/print_coorheader.cns @@ -0,0 +1,396 @@ +! print_coorheader.cns +! Generate the coordinate header (REMARKS) +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * Originally adapted from Aria 1.2 from Nilges and Linge, EMBL. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +if ($Data.flags.dihed eq false) then evaluate ($dihe = 0) end if +if ($Data.flags.sani eq false) then evaluate ($sani = 0) end if +if ($Data.flags.xrdc eq false) then evaluate ($xrdc = 0) end if +if ($Data.flags.xpcs eq false) then evaluate ($xpcs = 0) end if +if ($Data.flags.dani eq false) then evaluate ($dani = 0) end if +if ($Data.flags.vean eq false) then evaluate ($vean = 0) end if +if ($Data.flags.cdih eq false) then evaluate ($cdih = 0) end if +if ($Data.flags.noe eq false) then evaluate ($noe = 0) end if +if ($Data.flags.rg eq false) then evaluate ($coll = 0) end if +if ($Data.flags.zres eq false) then evaluate ($zhar = 0) end if +if ($Data.flags.em eq false) then evaluate ($lcc = 0) end if + +evaluate($enerall=$etot) +evaluate($bondall=$ebond) +evaluate($anglall=$eangl) +evaluate($imprall=$eimpr) +evaluate($diheall=$edihe) +evaluate($vdwall=$vdw) +evaluate($elecall=$elec) +evaluate($noeall=$noe) +evaluate($rgall=$coll) +evaluate($zresall=$zhar) +evaluate($cdihall=$cdih) +evaluate($coupall=0) +evaluate($saniall=$sani+$xrdc) +evaluate($veanall=$vean) +evaluate($xpcsall=$xpcs) +evaluate($daniall=$dani) + +if ($Data.flags.sym eq true) then + evaluate ($result=0) + evaluate ($violations=0) + print threshold=0.3 noe + evaluate ($rms_noe=$result) + evaluate ($violations_noe=$violations) +end if + +if ($Data.randremoval eq false) then + evaluate ($violations_test_noe= 0) + evaluate ($rms_test_noe = 0) + evaluate ($npart = 0) +end if + +evaluate ($result=0) +evaluate ($violations=0) +print threshold=5. cdih +evaluate ($rms_cdih=$result) +evaluate ($violations_cdih=$violations) +evaluate ($result=0) +evaluate ($violations=0) +evaluate ($rms_coup = 0) +evaluate ($violations_coup = 0) + +evaluate( $rms_sani = 0) +evaluate( $violations_sani = 0) +if ($Data.flags.sani eq TRUE) then + sani print threshold = 0.20 class rd* end + evaluate( $rms_sani = $result) + evaluate( $violations_sani = $violations) +end if + +evaluate( $rms_xrdc = 0) +evaluate( $violations_xrdc = 0) +if ($Data.flags.xrdc eq TRUE) then + xrdc print threshold = 0.2 class xr* end + evaluate( $rms_xrdc = $result) + evaluate( $violations_xrdc = $violations) +end if + +evaluate( $violations_sani = $violations_sani + $violations_xrdc) +evaluate( $rms_sani = $rms_sani + $rms_xrdc) + +evaluate( $rms_xpcs = 0) +evaluate( $violations_xpcs = 0) +if ($Data.flags.xpcs eq TRUE) then + xpcs print threshold = 0.2 class pc* end + evaluate( $rms_xpcs = $result) + evaluate( $violations_xpcs = $violations) +end if + +evaluate( $rms_vean = 0) +evaluate( $violations_vean = 0) +if ($Data.flags.vean eq TRUE) then + vean print threshold = 5.00 class ve* end + evaluate( $rms_vean = $result) + evaluate( $violations_vean = $violations) +end if + +evaluate( $rms_dani = 0) +evaluate( $violations_dani = 0) +if ($Data.flags.dani eq TRUE) then + dani print threshold = 0.20 class da* end + evaluate( $rms_dani = $result) + evaluate( $violations_dani = $violations) +end if + +{====>} {* define ASA-based solvation parameters *} +inline @MODULE:def_solv_param.cns + +{====>} {* buried surface area and desolvation*} +evaluate ($nchain1 = 0) +evaluate ($saafree = 0) +evaluate ($esolfree = 0) +while ($nchain1 < $data.ncomponents) loop nloop1 + evaluate ($nchain1 = $nchain1 + 1) + {====>} {* buried surface area and desolvation*} + do (rmsd = 0) (all) + surface mode=access accu=0.075 rh2o=1.4 sele=(segid $prot_segid_$nchain1 and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) end + show sum (rmsd) (segid $prot_segid_$nchain1 and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) + evaluate ($saafree = $saafree + $result) + evaluate ($saafree_$nchain1 = $result) + do (store2 = rmsd * store1) (segid $prot_segid_$nchain1 and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) + show sum (store2) (segid $prot_segid_$nchain1 and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) + evaluate ($esolfree = $esolfree + $result) + evaluate ($esolfree_$nchain1 = $result) +end loop nloop1 + +do (rmsd = 0) (all) +do (store2 = 0) (all) +surface mode=access accu=0.075 rh2o=1.4 sele=(not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) end +show sum (rmsd) (not ((resn WAT or resn HOH or resn TIP*) or resn DMS or resn SHA)) +evaluate ($satot = $result) +do (store2 = rmsd * store1) (not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) +show sum (store2) (not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) +evaluate ($esolcplx = $result) +evaluate ($saburied = $saafree - $satot) +if ($saburied < 0) then + evaluate ($saburied = -999999) +end if + +evaluate ($edesolv = $esolcplx - $esolfree) + +evaluate ($dhbinding = $edesolv + $eintcplx - $eintfree + $elecall + $vdwall) + +evaluate ($nshape = 0) +evaluate ($ncount = 0) +while ($ncount < $data.ncomponents) loop shape + evaluate ($ncount = $ncount + 1) + if ($mol_shape_$ncount eq true) then + evaluate ($nshape = $nshape + 1) + end if +end loop shape + +evaluate ($nonshape = $Data.ncomponents - $nshape) + +if ($nonshape = 1) then + evaluate ($saburied = 0) + evaluate ($edesolv = 0) + evaluate ($dhbinding = 0) + evaluate ($eintfree = $eintcplx) +end if + +if ($Data.flags.sym eq true) then + evaluate ($enerall = $enerall + $esym) +end if +if ($Data.flags.ncs eq true) then + evaluate ($enerall = $enerall + $ncs) +end if + +evaluate ($procwat = false) +if ($refine.keepwater eq true) then + evaluate ($procwat = true) +end if + +{====>} {* calculate interface-specific scores *} +if ($data.ncomponents > 1) then + if ($per_interface_scoring eq true) then + if ($data.ncomponents eq 2) then + {====>} {* dimer: no need to recalculate anything *} + evaluate ($nrstscore= 0.0) + evaluate($nchain1 = 1) + evaluate($nchain2 = 2) + evaluate ($bsa_$nchain1_$nchain2 = $saburied) + evaluate ($edesol_$nchain1_$nchain2 = $edesolv) + evaluate ($vdw_$nchain1_$nchain2 = $vdwall) + evaluate ($elec_$nchain1_$nchain2 = $elecall) + evaluate ($haddockscore_$nchain1_$nchain2 = $w_vdw * $vdw_$nchain1_$nchain2 + + $w_elec* $elec_$nchain1_$nchain2 + + $w_bsa * $bsa_$nchain1_$nchain2 + + $w_desolv * $edesol_$nchain1_$nchain2) + + evaluate ($nrstscore = $nrstscore + $haddockscore_$nchain1_$nchain2) + else + {====>} {* define ASA-based solvation parameters *} + do (store1 = 0) (all) + evaluate ($nrstscore= 0.0) + inline @MODULE:def_solv_param.cns + + eval($nchain1 = 1) + + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain2 = $nchain1 + 1) + while ($nchain2 <= $data.ncomponents) loop nloop2 + igroup + interaction (segid $prot_segid_$nchain1 and not (resn WAT or resn HOH or resn TIP* or resn DMS)) + (segid $prot_segid_$nchain2 and not (resn WAT or resn HOH or resn TIP* or resn DMS)) weight * 1.0 end + end + energy end + evaluate ($vdw_$nchain1_$nchain2 = $vdw) + evaluate ($elec_$nchain1_$nchain2 = $elec) + + do (rmsd = 0) (all) + do (store2 = 0) (all) + surface mode=access accu=0.075 rh2o=1.4 + sele=((segid $prot_segid_$nchain1 or segid $prot_segid_$nchain2) and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) end + show sum (rmsd) ((segid $prot_segid_$nchain1 or segid $prot_segid_$nchain2) and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) + evaluate ($bsa_$nchain1_$nchain2 = $saafree_$nchain1 + $saafree_$nchain2 - $result) + if ($bsa_$nchain1_$nchain2 < 0) then + evaluate ($bsa_$nchain1_$nchain2 = 0) + end if + + do (store2 = rmsd * store1) ((segid $prot_segid_$nchain1 or segid $prot_segid_$nchain2) and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) + show sum (store2) ((segid $prot_segid_$nchain1 or segid $prot_segid_$nchain2) and not (resn WAT or resn HOH or resn TIP* or resn DMS or resn SHA)) + evaluate ($edesol_$nchain1_$nchain2 = $result - $esolfree_$nchain1 - $esolfree_$nchain2) + + evaluate ($haddockscore_$nchain1_$nchain2 = $w_vdw * $vdw_$nchain1_$nchain2 + + $w_elec* $elec_$nchain1_$nchain2 + + $w_bsa * $bsa_$nchain1_$nchain2 + + $w_desolv * $edesol_$nchain1_$nchain2) + + evaluate ($nrstscore = $nrstscore + $haddockscore_$nchain1_$nchain2) + + eval($nchain2 = $nchain2 + 1) + end loop nloop2 + eval($nchain1 = $nchain1 + 1) + end loop nloop1 + end if + end if +else + evaluate ($nrstscore = $w_vdw * $vdwall + $w_elec * $elecall + $w_bsa * $saburied + $w_desolv * $edesolv) +end if + + +if ($procwat eq true) then + ident (store3) (not all) + flag exclude * include vdw elec end + + eval($nchain1 = 0) + + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + + igroup + interaction (segid $prot_segid_$nchain1) ((resn WAT or resn HOH or resn TIP* or resn DMS) and not store3) weight * 1.0 end + interaction (not segid $prot_segid_$nchain1) (resn WAT or resn HOH or resn TIP* or resn DMS) weight * 0.0 end + interaction (segid $prot_segid_$nchain1) (not ((resn WAT or resn HOH or resn TIP* or resn DMS) and store3)) weight * 0.0 end + end + energy end + evaluate ($ener_water_$nchain1 = $ener) + evaluate ($enerall = $enerall + $ener) + evaluate ($vdw_water_$nchain1 = $vdw) + evaluate ($elec_water_$nchain1 = $elec) + + end loop nloop1 + if ($data.ncomponents > 1) then + eval($nchain1 = $data.ncomponents) + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + evaluate ($ener_water_$nchain1 = 0.0) + evaluate ($vdw_water_$nchain1 = 0.0) + evaluate ($elec_water_$nchain1 = 0.0) + end loop nloop1 + end if + + eval($nchain1 = 0) + + igroup + while ($nchain1 < $data.ncomponents) loop nloop2 + eval($nchain1 = $nchain1 + 1) + interaction (segid $prot_segid_$nchain1) (all) weight * 0.0 end + end loop nloop2 + interaction ((resn WAT or resn HOH or resn TIP* or resn DMS) and not store3) + ((resn WAT or resn HOH or resn TIP* or resn DMS) and not store3) weight * 1.0 end + interaction (store3) (store3) weight * 0.0 end + interaction (resn SHA) (not resn SHA) weight * 0.0 end + interaction (resn SHA) (resn SHA) weight * 0.0 end + end + energy end + evaluate ($ener_water_water = $ener) + evaluate ($enerall = $enerall + $ener) + evaluate ($vdw_water_water = $vdw) + evaluate ($elec_water_water = $elec) +else + eval($nchain1 = 0) + + while ($nchain1 < $data.ncomponents ) loop nloop1 + eval($nchain1 = $nchain1 + 1) + evaluate ($ener_water_$nchain1 = 0.0) + evaluate ($vdw_water_$nchain1 = 0.0) + evaluate ($elec_water_$nchain1 = 0.0) + end loop nloop1 + evaluate ($ener_water_water = 0.0) + evaluate ($vdw_water_water = 0.0) + evaluate ($elec_water_water = 0.0) +end if + +! calculate the HADDOCK score +evaluate ($hscore = $w_vdw * $vdwall) +evaluate ($hscore = $hscore + $w_elec * $elecall) +evaluate ($hscore = $hscore + $w_air * $noeall) +evaluate ($hscore = $hscore + $w_rg * $rgall) +evaluate ($hscore = $hscore + $w_cdih * $cdihall) +evaluate ($hscore = $hscore + $w_sani * $saniall) +evaluate ($hscore = $hscore + $w_xpcs * $xpcsall) +evaluate ($hscore = $hscore + $w_dani * $daniall) +evaluate ($hscore = $hscore + $w_vean * $veanall) +evaluate ($hscore = $hscore + $w_sym * $esym) +evaluate ($hscore = $hscore + $w_bsa * $saburied) +evaluate ($hscore = $hscore + $w_desolv * $edesolv) +evaluate ($hscore = $hscore + $w_lcc * $lcc) + +set message=on echo=on end +set remarks=reset end +set remarks=accumulate end +remarks =============================================================== +remarks HADDOCK stats for $output_pdb_filename +remarks =============================================================== +remarks HADDOCK score: $hscore +remarks =============================================================== + +!list input molecules +evaluate ($nmol=1) +while ($nmol <=$data.ncomponents) loop mol + if ( $exist_input_pdb_filename_$nmol = true) then + remarks initial structure $nmol - $input_pdb_filename_$nmol + end if + evaluate ($nmol = $nmol + 1) +end loop mol + +remarks =============================================================== +remarks total,bonds,angles,improper,dihe,vdw,elec,air,cdih,coup,rdcs,vean,dani,xpcs,rg +remarks energies: $enerall, $bondall, $anglall, $imprall, $diheall, $vdwall, $elecall, $noeall, $cdihall, $coupall, $saniall, $veanall, $daniall, $xpcsall, $rgall +remarks =============================================================== +remarks bonds,angles,impropers,dihe,air,cdih,coup,rdcs,vean,dani,xpcs +remarks rms-dev.: $rms_bonds,$rms_angles,$rms_impropers,$rms_dihedrals,$rms_noe,$rms_cdih,$rms_coup, $rms_sani, $rms_vean, $rms_dani, $rms_xpcs +remarks =============================================================== +remarks air,cdih,coup,rdcs,vean,dani,xpcs +remarks >0.3,>5,>1,>0,>5,>0.2,>0.2 +remarks violations.: $violations_noe, $violations_cdih, $violations_coup, $violations_sani, $violations_vean, $violations_dani, $violations_xpcs +remarks =============================================================== +remarks CVpartition#,violations,rms +remarks AIRs cross-validation: $npart, $violations_test_noe, $rms_test_noe +remarks =============================================================== +remarks NCS energy: $ncs +remarks =============================================================== +remarks Symmetry energy: $esym +remarks =============================================================== +remarks Membrane restraining energy: $zresall +remarks =============================================================== +remarks Local cross-correlation: $lcc[f7.4] +remarks =============================================================== +remarks Desolvation energy: $edesolv +remarks Internal energy free molecules: $eintfree +remarks Internal energy complex: $eintcplx +remarks Binding energy: $dhbinding +remarks =============================================================== +remarks buried surface area: $saburied +remarks =============================================================== +if ($data.ncomponents > 1) then + if ($per_interface_scoring eq true) then + evaluate($nchain1 = 1) + remarks Interface Chain1 Chain2 HADDOCKscore Evdw Eelec Edesol BSA + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain2 = $nchain1 + 1) + while ($nchain2 <= $data.ncomponents) loop nloop2 + remarks Interface: $prot_segid_$nchain1 $prot_segid_$nchain2 $haddockscore_$nchain1_$nchain2 $vdw_$nchain1_$nchain2 $elec_$nchain1_$nchain2 $edesol_$nchain1_$nchain2 $bsa_$nchain1_$nchain2 + eval($nchain2 = $nchain2 + 1) + end loop nloop2 + eval($nchain1 = $nchain1 + 1) + end loop nloop1 + remarks Total HADDOCK score without restraints: $nrstscore + end if +else + remarks Total HADDOCK score without restraints: $nrstscore +end if +remarks =============================================================== +evaluate($ncount = 0) +while ($ncount < $data.ncomponents) loop waterremark + evaluate ($ncount = $ncount +1) + remarks water - chain-$prot_segid_$ncount: $ener_water_$ncount $vdw_water_$ncount $elec_water_$ncount +end loop waterremark +remarks =============================================================== +remarks water - water: $ener_water_water $vdw_water_water $elec_water_water +remarks =============================================================== diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/protein-ss-restraints-all.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/protein-ss-restraints-all.cns new file mode 100644 index 0000000000000000000000000000000000000000..ce6537b77378451041f63bb9fb07cb9fce35b4d7 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/protein-ss-restraints-all.cns @@ -0,0 +1,88 @@ +! protein-ss-restraints-all.def +! Define automatically secondary stucture dihedral angle restraints for all residues +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +{+ file: protein-ss-restraints.def +} +{+ description: Creates dihedral angle restraints to maintain conformation of the protein backbone +} +{+ authors: Axel T. Brunger, and Paul D. Adams, +} +{+ modified by Alexandre Bonvin for HADDOCK use +} + +{=========================================================================================================} +{ things below this line do not normally need to be changed } +{=========================================================================================================} + +{- Dihedral restraints for the protein backbone -} +restraint dihedral + nass = 50000 +end +do (store1 = 1) (all) +evaluate ($group=1) +evaluate ($done=false) +while ( $done = false ) loop bdihe + if ( $exist_prot_segid_$group = true ) then + show sum(1) ( segid $prot_segid_$group ) + if ( $result > 0 ) then + evaluate ($error_phi=$Data.error_dih) + evaluate ($error_psi=$Data.error_dih) + for $id in id ( segid $prot_segid_$group and tag and not resn TIP3 ) loop resid + show (segid) (id $id) + evaluate ($segid=$result) + show (resid) ( id $id ) + evaluate ($resid=decode($result)) + evaluate ($rprec = $resid - 1) + show sum (store1) (resid $rprec and name C) + if ($result ne 0) then + evaluate ($rprec = $resid - 1) + pick dihedral + ( segid $segid and resid $rprec and name C ) + ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + geometry + evaluatate ($dihedral_phi=$result) + restraint dihedral + ! phi + assign ( segid $segid and resid $rprec and name C ) + ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + 1.0 $dihedral_phi $error_phi 2 + scale 200.0 + end + end if + evaluate ($rnext = $resid + 1) + show sum (store1) (resid $rnext and name N) + if ($result ne 0) then + pick dihedral + ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + ( segid $segid and resid $rnext and name N ) + geometry + evaluatate ($dihedral_psi=$result) + restraint dihedral + ! psi + assign ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + ( segid $segid and resid $rnext and name N ) + 1.0 $dihedral_psi $error_psi 2 + scale 200.0 + end + end if + end loop resid + end if + else + evaluate ($done=true) + end if + evaluate ($group=$group+1) +end loop bdihe + +flags include cdih end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/protein-ss-restraints-alpha-beta.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/protein-ss-restraints-alpha-beta.cns new file mode 100644 index 0000000000000000000000000000000000000000..0d6d8e4aa9b00b11bd201f8f9917a4628821978b --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/protein-ss-restraints-alpha-beta.cns @@ -0,0 +1,128 @@ +! protein-ss-restraints-alpha-beta.cns +! Define automatically secondary structure dihedral angle restraints +! for helical and beta-sheet segments +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +{+ file: protein-ss-restraints.def +} +{+ description: Creates dihedral angle restraints to maintain conformation of the protein backbone +} +{+ comment:This file is to be read by refinement files that modify atom coordinates +} +{+ authors: Axel T. Brunger, and Paul D. Adams +} +{+ modified by Alexandre Bonvin for HADDOCK use +} + +{=========================================================================================================} +{ things below this line do not normally need to be changed } +{=========================================================================================================} + +{- Dihedral restraints for the protein backbone in alpha-beta regions -} + +do (store1 = 1) (all) +restraint dihedral + nass = 50000 +end +evaluate ($group=1) +evaluate ($done=false) +while ( $done = false ) loop bdihe + if ( $exist_prot_segid_$group = true ) then + show sum(1) ( segid $prot_segid_$group ) + if ( $result > 0 ) then + evaluate ($error_phi=$Data.error_dih) + evaluate ($error_psi=$Data.error_dih) + for $id in id ( segid $prot_segid_$group and tag and not resn TIP* ) loop resid + show (segid) (id $id) + evaluate ($segid=$result) + show (resid) ( id $id ) + evaluate ($resid=decode($result)) + evaluate ($alphaphi = 0) + evaluate ($alphapsi = 0) + evaluate ($alpha_check = 0) + evaluate ($betaphi = 0) + evaluate ($betapsi = 0) + evaluate ($beta_check = 0) + evaluate ($rprec = $resid - 1) + show sum (store1) (resid $rprec and name C) + if ($result ne 0) then + pick dihedral + ( segid $segid and resid $rprec and name C ) + ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + geometry + evaluate ($dihedral_phi=$result) + evaluate ($alphaphi=max($dihedral_phi,-77)) + evaluate ($alphaphi=max($dihedral_phi,-37)) + if ($alphaphi eq -37) then + evaluate ($alpha_check = 1) + else + evaluate ($alpha_check = 0) + end if + evaluate ($betaphi=max($dihedral_phi,-145)) + evaluate ($betaphi=max($dihedral_phi,-105)) + if ($betaphi eq -105) then + evaluate ($beta_check = 1) + else + evaluate ($beta_check = 0) + end if + end if + evaluate ($rnext = $resid + 1) + show sum (store1) (resid $rnext and name N) + if ($result ne 0) then + pick dihedral + ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + ( segid $segid and resid $rnext and name N ) + geometry + evaluate ($dihedral_psi=$result) + evaluate ($alphapsi=max($dihedral_psi,-67)) + evaluate ($alphapsi=max($dihedral_psi,-27)) + if ($alphapsi eq -27) then + evaluate ($alpha_check = $alpha_check + 1) + end if + evaluate ($betapsi=max($dihedral_psi,105)) + evaluate ($betapsi=max($dihedral_psi,145)) + if ($betapsi eq 145) then + evaluate ($beta_check = $beta_check + 1) + end if + end if + evaluate ($defrest = 0) + if ($alpha_check eq 2) then + evaluate ($defrest = 1) + end if + if ($beta_check eq 2) then + evaluate ($defrest = 1) + end if + if ($defrest = 1) then + restraint dihedral + ! phi + assign ( segid $segid and resid $rprec and name C ) + ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + 1.0 $dihedral_phi $error_phi 2 + ! psi + assign ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + ( segid $segid and resid $rnext and name N ) + 1.0 $dihedral_psi $error_psi 2 + scale 200.0 + end + end if + end loop resid + end if + else + evaluate ($done=true) + end if + evaluate ($group=$group+1) +end loop bdihe + +flags include cdih end + + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/protein-ss-restraints-alpha.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/protein-ss-restraints-alpha.cns new file mode 100644 index 0000000000000000000000000000000000000000..38416657fc086d88a8288b50371b1f3e697103a8 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/protein-ss-restraints-alpha.cns @@ -0,0 +1,109 @@ +! protein-ss-restraints-alpha.cns +! Define automatically secondary structure dihedral angle restraints +! for helical segments +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +{+ file: protein-ss-restraints.def +} +{+ description: Creates dihedral angle restraints to maintain conformation of the protein backbone +} +{+ comment:This file is to be read by refinement files that modify atom coordinates +} +{+ authors: Axel T. Brunger, and Paul D. Adams +} +{+ modified by Alexandre Bonvin for HADDOCK use +} + +{=========================================================================================================} +{ things below this line do not normally need to be changed } +{=========================================================================================================} + +{- Dihedral restraints for the protein backbone in alpha-helical regions -} +restraint dihedral + nass = 50000 +end +do (store1 = 1) (all) +evaluate ($group=1) +evaluate ($done=false) +while ( $done = false ) loop bdihe + if ( $exist_prot_segid_$group = true ) then + show sum(1) ( segid $prot_segid_$group ) + if ( $result > 0 ) then + evaluate ($error_phi=$Data.error_dih) + evaluate ($error_psi=$Data.error_dih) + for $id in id (segid $prot_segid_$group and tag and not resn TIP3 ) loop resid + show (segid) (id $id) + evaluate ($segid=$result) + show (resid) ( id $id ) + evaluate ($resid=decode($result)) + evaluate ($alphaphi = 0) + evaluate ($alphapsi = 0) + evaluate ($alpha_check = 0) + evaluate ($rprec = $resid - 1) + show sum (store1) (resid $rprec and name C) + if ($result ne 0) then + pick dihedral + ( segid $segid and resid $rprec and name C ) + ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + geometry + evaluate ($dihedral_phi=$result) + evaluate ($alphaphi=max($dihedral_phi,-77)) + evaluate ($alphaphi=max($dihedral_phi,-37)) + if ($alphaphi eq -37) then + evaluate ($alpha_check = 1) + else + evaluate ($alpha_check = 0) + end if + end if + evaluate ($rnext = $resid + 1) + show sum (store1) (resid $rnext and name N) + if ($result ne 0) then + pick dihedral + ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + ( segid $segid and resid $rnext and name N ) + geometry + evaluate ($dihedral_psi=$result) + evaluate ($alphapsi=max($dihedral_psi,-67)) + evaluate ($alphapsi=max($dihedral_psi,-27)) + if ($alphapsi eq -27) then + evaluate ($alpha_check = $alpha_check + 1) + end if + end if + evaluate ($defrest = 0) + if ($alpha_check eq 2) then + evaluate ($defrest = 1) + end if + if ($defrest = 1) then + restraint dihedral + ! phi + assign ( segid $segid and resid $rprec and name C ) + ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + 1.0 $dihedral_phi $error_phi 2 + ! psi + assign ( segid $segid and resid $resid and name N ) + ( segid $segid and resid $resid and name CA ) + ( segid $segid and resid $resid and name C ) + ( segid $segid and resid $rnext and name N ) + 1.0 $dihedral_psi $error_psi 2 + scale 200.0 + end + end if + end loop resid + end if + else + evaluate ($done=true) + end if + evaluate ($group=$group+1) +end loop bdihe + +flags include cdih end + + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/read_param.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/read_param.cns new file mode 100644 index 0000000000000000000000000000000000000000..6f549a453e49c118de295658c1294a8a429b9365 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/read_param.cns @@ -0,0 +1,64 @@ +! read_param.cns +! Reads parameter files. +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +!! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** + +{* protein parameter file *} +eval ($prot_parameter_infile="TOPPAR:protein-allhdg5-4.param") + +{* nucleic acid parameter file *} +eval ($nucl_parameter_infile="TOPPAR:dna-rna-allatom-hj-opls-1.3.param") + +{* carbohydrate parameter file *} +eval ($carbo_parameter_infile="TOPPAR:carbohydrate.param") + +{* solvent parameter file *} +eval ($solv_parameter_infile="TOPPAR:solvent-allhdg5-4.param") + +{* fragment probes parameter file *} +eval ($ligands_parameter_infile="TOPPAR:fragment_probes.param") + +{* ion parameter file *} +eval ($ion_parameter_infile="TOPPAR:ion.param") + +{* heme parameter file *} +eval ($heme_parameter_infile="TOPPAR:hemes-allhdg.param") + +{* shape parameter file *} +eval ($shape_parameter_infile="TOPPAR:shape.param") + +{* cofactors parameter file *} +eval ($cofactors_parameter_infile="TOPPAR:cofactors.param") + +parameter + @@$prot_parameter_infile + @@$ion_parameter_infile + @@$nucl_parameter_infile + @@$carbo_parameter_infile + @@$solv_parameter_infile + @@$ligands_parameter_infile + @@$heme_parameter_infile + @@$shape_parameter_infile + @@$cofactors_parameter_infile + if ($ligand_param_fname # "") then + fileexist $ligand_param_fname end + if ($result eq true) then + @@$ligand_param_fname + end if + end if +end + +parameter + nbonds + nbxmod=5 atom cdie shift + cutnb=9.5 ctofnb=8.5 ctonnb=6.5 eps=1.0 e14fac=0.4 inhibit 0.25 + wmin=0.5 tolerance 0.5 + end +end + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/restrain-ions.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/restrain-ions.cns new file mode 100644 index 0000000000000000000000000000000000000000..52a5b3d2024ac21f44456d9ed204d455d8380ac2 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/restrain-ions.cns @@ -0,0 +1,109 @@ +! restrain-ions.cns +! distance restraints between an ion and any coordinating atom within 5A +! to maintain the coordination topologu +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +noe class dist end + +! first deal with monoatomic ions +evaluate ($pcount = 0) +for $id1 in id ( name "LI+1" or name "F-1" or name "NA+1" or name "MG+2" or name "AL+3" + or name "CL-1" or name "K+1" or name "CA+2" or name "V+2" or name "V+3" + or name "CR+2" or name "CR+3" or name "MN+2" or name "MN+3" or name "FE+2" + or name "FE+3" or name "NI+2" or name "CO+2" or name "CO+3" or name "CU+1" + or name "CU+2" or name "ZN+2" or name "BR-1" or name "SR+2" or name "MO+3" + or name "AG+1" or name "CD+2" or name "I-1" or name "CS+2" or name "HO+3" + or name "YB+2" or name "YB+3" or name "OS+4" or name "IR+3" or name "PT+2" + or name "AU+1" or name "AU+2" or name "HG+1" or name "HG+2" or name "PB+2" + or name "U+3" or name "U+4" or name "ZN+1" or name "ZN" ) loop sions + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + show (resname) (id $id1) + evaluate ($resname1=$result) + show (name) (id $id1) + evaluate ($name1=$result) + + evaluate ($mindis = 4.0) + for $id2 in id ( (name O* or name S* or name N*) and (id $id1) around $mindis and + (resn ACE or resn ALA or resn ALY or resn ARG or resn ASN or resn ASH or resn ASP or + resn CSP or resn CTN or resn CYC or resn CYF or resn CYM or resn CYS or resn DDZ or + resn GLN or resn GLH or resn GLU or resn GLY or resn HIS or resn HY3 or resn HYP or + resn ILE or resn LEU or resn LYS or resn M3L or resn MLY or resn MLZ or resn MET or + resn MSE or resn NEP or resn NME or resn PHE or resn PNS or resn PRO or resn PTR or + resn QSR or resn SEP or resn SER or resn SEC or resn THR or resn TOP or resn TRP or + resn TYP or resn TYR or resn TYS or resn VAL or resn A or resn C or resn G or + resn T or resn DA or resn DC or resn DG or resn DT or resn DJ )) loop search + + pick bond (id $id1) (id $id2) geometry + evaluate ($upper = $result) + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + show (name) (id $id2) + evaluate ($name2=$result) + + if ($segid1 eq $segid2) then + noe + assign (resid $resid1 and segid $segid1 and name $name1) + (resid $resid2 and segid $segid2 and name $name2) $upper 0.1 0.1 + end + end if + + end loop search + +end loop sions + +! then deal with multiatomic mions +evaluate ($pcount = 0) +for $id1 in id ( (resn SO4 or resn PO4 or resn WO4) and name O* ) loop mions + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + show (resname) (id $id1) + evaluate ($resname1=$result) + show (name) (id $id1) + evaluate ($name1=$result) + + evaluate ($mindis = 4.0) + for $id2 in id ( (name O* or name S* or name N*) and (id $id1) around $mindis and + (resn ACE or resn ALA or resn ALY or resn ARG or resn ASN or resn ASH or resn ASP or + resn CSP or resn CTN or resn CYC or resn CYF or resn CYM or resn CYS or resn DDZ or + resn GLN or resn GLH or resn GLU or resn GLY or resn HIS or resn HY3 or resn HYP or + resn ILE or resn LEU or resn LYS or resn M3L or resn MLY or resn MLZ or resn MET or + resn MSE or resn NEP or resn NME or resn PHE or resn PNS or resn PRO or resn PTR or + resn QSR or resn SEP or resn SER or resn SEC or resn THR or resn TOP or resn TRP or + resn TYP or resn TYR or resn TYS or resn VAL or resn A or resn C or resn G or + resn T or resn DA or resn DC or resn DG or resn DT or resn DJ )) loop search + + pick bond (id $id1) (id $id2) geometry + evaluate ($upper = $result) + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + show (name) (id $id2) + evaluate ($name2=$result) + + if ($segid1 eq $segid2) then + noe + assign (resid $resid1 and segid $segid1 and name $name1) + (resid $resid2 and segid $segid2 and name $name2) $upper 0.1 0.1 + end + end if + + end loop search + +end loop mions diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/scale_inter_final.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/scale_inter_final.cns new file mode 100644 index 0000000000000000000000000000000000000000..a8bf9c44f98b1303779d68d46e24855e47321548 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/scale_inter_final.cns @@ -0,0 +1,39 @@ +! scale_inter_final.cns +! Scaling of intermolecular interactions +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +igroup interaction (not all) (not all) end + +igroup + + eval($nchain1 = 0) + + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + eval($nchain2 = $nchain1 ) + while ($nchain2 < $data.ncomponents) loop nloop2 + eval($nchain2 = $nchain2 + 1) + eval($scalfac = 1.0) + interaction (segid $prot_segid_$nchain1 and not + (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA or resn DPP or resn PCW or resn PEE)) + (segid $prot_segid_$nchain2 and not + (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA or resn DPP or resn PCW or resn PEE)) weight * 1.0 vdw $scalfac elec $scalfac end + end loop nloop2 + + end loop nloop1 + + interaction (resn ANI) (resn ANI) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DAN) (resn DAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn XAN) (resn XAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DUM) (resn DUM) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (resn SHA) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (not resn SHA) weight * 0.0 end + +end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/scale_intra_only.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/scale_intra_only.cns new file mode 100644 index 0000000000000000000000000000000000000000..15b0adfbb562862214f161c494c14a17dbf6beb7 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/scale_intra_only.cns @@ -0,0 +1,36 @@ +! scale_intra_only.cns +! Scaling of intramolecular energies (no intermolecular energies) +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +igroup interaction (not all) (not all) end + +igroup + + eval($nchain1 = 0) + + while ($nchain1 < $data.ncomponents) loop nloop1 + eval($nchain1 = $nchain1 + 1) + + interaction (segid $prot_segid_$nchain1 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) + (segid $prot_segid_$nchain1 and not (resn ANI or resn DAN or resn XAN or resn DUM or resn SHA)) weight * 1.0 end + + end loop nloop1 + + interaction (resn ANI) (resn ANI) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DAN) (resn DAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn XAN) (resn XAN) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn DUM) (resn DUM) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (resn SHA) weight * 1.0 vdw 0.0 elec 0.0 end + interaction (resn SHA) (not resn SHA) weight * 0.0 end + +end + + + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/setflags.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/setflags.cns new file mode 100644 index 0000000000000000000000000000000000000000..fd3e181f3cc822ca390f8d3f0ec6368c7305498b --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/cns/setflags.cns @@ -0,0 +1,21 @@ +! setflags.cns +! Defines energy flags +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +if ($Data.flags.noe = TRUE) then + flags include noe end +end if +if ($Data.flags.cdih = TRUE) then + flags include cdih end +end if +if ($Data.flags.ncs = TRUE) then + flags include ncs end +end if diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/defaults.yaml b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/defaults.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ed3bfa9df711f38d47bd893afc2626d19de6989b --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/mdscoring/defaults.yaml @@ -0,0 +1,474 @@ +# +# Group scoring +# +per_interface_scoring: + default: false + type: boolean + title: Interchain scoring + short: Output scores per interface in the PDB header. + long: With this option true, the interface of all combinations of chains will be analysed and the corresponding HADDOCK scores (without restraints terms) and their components (Eelec, Evdw, Edesol, BSA) will be written to the header of each PDB file. + group: 'scoring' + explevel: expert +interface_combinations: + default: [] + type: list + minitems: 0 + maxitems: 20 + title: Chains to be scored. + short: List of chains to be scored. Use this parameter to provide a list of + chain pairs (coma separated) that should be considered for the calculation. + If empty/unspecified, all inter-chains contacts will be considered + for the final prediction. + long: List of chains to be scored. If empty/unspecified, all inter-chains + contacts will be considered for the final prediction. In specific cases, + for example antibody-antigen complexes, some chains should be considered + as a single molecule. Use this parameter to provide a list of chain pairs + (separated by coma) that should be considered for the calculation. + [] => Compute all interface scores + ["A,H", "A,L"] => Compute sum of per-interface scores between chains A and H; A and L + group: 'scoring' + explevel: expert +w_air: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the distance restraint energy + short: Weight of the distance restraints energy in the scoring function + long: Weight of the distance restraints energy in the scoring function. + Note that this is different from the force constants used during the calculations. + group: 'scoring' + explevel: hidden +w_bsa: + default: 0.0 + type: float + min: -9999 + max: 9999 + precision: 3 + title: Weight of the buried surface area term + short: Weight of the buried surface area term in the scoring function + long: Weight of the buried surface area (BSA) term in the scoring function. + Note that the BSA is only used for scoring. + group: 'scoring' + explevel: expert +w_cdih: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the dihedral angle restraint energy + short: Weight of the dihedral angle restraints energy in the scoring function + long: Weight of the dihedral angle restraints energy in the scoring function. + Note that this is different from the force constant used during the calculations. + group: 'scoring' + explevel: expert +w_dani: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the relaxation anisotropy (DANI) restraint energy + short: Weight of the relaxation anisotropy (DANI) restraint energy + long: Weight of the relaxation anisotropy (DANI) restraint energy + group: 'scoring' + explevel: hidden +w_deint: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the interaction energy term + short: Weight of the interaction energy term + long: Weight of the interaction energy term calculated as the difference in total energy of the complex and of the separate components + group: 'scoring' + explevel: hidden +w_desolv: + default: 1.0 + type: float + min: -9999 + max: 9999 + precision: 3 + title: Weight of the desolvation energy term + short: Weight of the desolvation energy term in the scoring function + long: Weight of the desolvation energy term in the scoring function. + Note that the desolvation energy is only used for scoring. + group: 'scoring' + explevel: expert +w_elec: + default: 0.2 + type: float + min: -9999 + max: 9999 + precision: 3 + title: Weight of the intermolecular electrostatic energy + short: Weight of the intermolecular electrostatic energy in the scoring function + long: Weight of the intermolecular electrostatic energy in the scoring function. + Note that this does not affect the electostatic energy during the MD refinement. + group: 'scoring' + explevel: expert +w_lcc: + default: -10000.0 + type: float + min: -10000.0 + max: 0 + precision: 3 + title: Weight of the EM local correlation coefficient + short: Weight of the EM local correlation coefficient + long: Weight of the EM local correlation coefficient + group: 'scoring' + explevel: hidden +w_rg: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the radius of gyration restraint energy + short: Weight of the radius of gyration restraint energy + long: Weight of the radius of gyration restraint energy + group: 'scoring' + explevel: hidden +w_sani: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the residual dipolar coupling (SANI) restraint energy + short: Weight of the residual dipolar coupling (SANI) restraint energy + long: Weight of the residual dipolar coupling (SANI) restraint energy + group: 'scoring' + explevel: hidden +w_sym: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the symmetry restraint energy + short: Weight of the symmetry restraints energy in the scoring function + long: Weight of the symmetry restraints energy in the scoring function. + Note that this is different from the force constant used during the calculations. + group: 'scoring' + explevel: hidden +w_vdw: + default: 1.0 + type: float + min: -9999 + max: 9999 + precision: 3 + title: Weight of the intermolecular van der Waals energy + short: Weight of the intermolecular van der Waals energy in the scoring function + long: Weight of the intermolecular van der Waals energy in the scoring function. + Note that this does not affect the van der Waals energy during the EM minimization. + group: 'scoring' + explevel: expert +w_vean: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the residual dipolar coupling (VEAN) restraint energy + short: Weight of the residual dipolar coupling (VEAN) restraint energy + long: Weight of the residual dipolar coupling (VEAN) restraint energy + group: 'scoring' + explevel: hidden +w_xpcs: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the pseudo contact shifts (XPCS) restraint energy + short: Weight of the pseudo contact shifts (XPCS) restraint energy + long: Weight of the pseudo contact shifts (XPCS) restraint energy + group: 'scoring' + explevel: hidden +w_xrdc: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the residual dipolar coupling (XRDC) restraint energy + short: Weight of the residual dipolar coupling (XRDC) restraint energy + long: Weight of the residual dipolar coupling (XRDC) restraint energy + group: 'scoring' + explevel: hidden +w_zres: + default: 0.0 + type: float + min: 0 + max: 9999 + precision: 3 + title: Weight of the Z-restraining potential energy + short: Weight of the Z-restraining potential energy + long: Weight of the Z-restraining potential energy + group: 'scoring' + explevel: hidden +# +# Group distance restraints +# +contactairs: + default: false + type: boolean + title: Contact restraints + short: Contact restraints between molecules + long: Contact restraints between molecules. These are defined as ambiguous distance restraint + between each residue of a molecule and all residues of the other molecules with 5A from that residue. + This can be used to restraint the contacts between the interfaces. Note that this can generate a large number of ambiguous restraints + and slow down the computations + group: 'distance restraints' + explevel: expert +kcont: + default: 1.0 + type: float + min: 0 + max: 1000 + precision: 1 + title: Contact restraints force constant + short: Force constant applied to the contact restraints. + long: Force constant applied to the contact restraints. + group: 'distance restraints' + explevel: expert +# +# Group dihedral restraints +# +ssdihed: + default: none + type: string + minchars: 0 + maxchars: 100 + choices: + - none + - all + - alpha + - alphabeta + title: Define automatically backbone dihedral angle restraints + short: If turned on, this option will automatically defined backbone dihedral angle restraints for the selected regions. + long: This option allows to utomatically defined backbone dihedral angle restraints for the selected regions. + The restraints will be defined for the phi and psi backbone dihedral angles of amino acids, with the target value taken from + the measured angle in the input structure, and the error bound defined by the error_dih parameter. + Those restraints can be applied to the entire structure (all), the alpha/beta secondary structure elements (alphabeta) or + only to the alpha helical regions (alpha). Those are automatically detected based on the measured dihedral angle combinations. + group: 'dihedral restraints' + explevel: easy +error_dih: + default: 10 + type: integer + min: 0 + max: 1000 + title: Force constant for backbone dihedral angle restraints + short: Force constant for backbone dihedral angle restraints (ssdihed option) + long: Force constant for backbone dihedral angle restraints (ssdihed option) + group: 'dihedral restraints' + explevel: easy +# +# Group other restraints +# +dnarest_on: + default: false + type: boolean + title: Restrain the DNA conformation + short: Automatically creates restraints to maintain the conformation of DNA/RNA + long: "This option allows to restraint the conformation of nucleic acids based on the values from the input structures. + The following restraints will be automatically defined: + - single base planarity + - sugar pucker + - phosphate backbone diherdral angle restraints + - Watson-Crick base pairing" + group: 'other restraints' + explevel: easy +# +# Group force field +# +ligand_param_fname: + default: '' + type: file + title: Custom ligand parameter file + short: Ligand parameter file in CNS format + long: Ligand parameter file in CNS format containing all force field parameters + (bond, angles, dihedrals, impropers, van der waals) for any ligand not supported by default by HADDOCK + group: 'force field' + explevel: easy +ligand_top_fname: + default: '' + type: file + title: Custom ligand topology file + short: Ligand topology file in CNS format + long: Ligand topology file in CNS format containing the ligand topologies + (atoms, masses, charges, bond definitions...) for any ligand not supported by default by HADDOCK + group: 'force field' + explevel: easy +elecflag: + default: true + type: boolean + title: Include electrostatics energy + short: Include electrostatics energy during the calculations. + long: Include electrostatics energy during the calculations. If set to false electrostatics will not be considered. + group: 'force field' + explevel: easy +dielec: + default: cdie + type: string + minchars: 0 + maxchars: 4 + choices: + - cdie + - rdie + title: Constant (cdie) or distance-dependent dielectric (rdie) constant. + short: Use a constant (cdie option) or a distance-dependent dielectric (rdie) constant in the Coulomb potential. + long: Use a constant (cdie option) or a distance-dependent dielectric (rdie) constant in the Coulomb potential. + A distance dependent dielectric constant will effectively scale down the electrostatic energy + by having a 1/r**2 dependency instead of 1/r + group: 'force field' + explevel: expert +epsilon: + default: 1.0 + type: float + min: 1 + max: 78 + precision: 1 + title: Dielectric constant + short: Dielectric constant for the electrostatic Coulomb energy term. + long: Dielectric constant for the electrostatic Coulomb energy term. + group: 'force field' + explevel: expert +dihedflag: + default: true + type: boolean + title: Use torsion angle dihedral energy term + short: Turns on the torsion angle dihedral energy terms of the force field. + long: Turns on the torsion angle dihedral energy terms of the force field. + group: 'force field' + explevel: expert +# +# Group sampling +# +individualize: + default: true + type: boolean + title: Individualise models + short: Treat each model in the PDB ensemble as a separate entity. + long: Treat each model in the PDB ensemble as a separate entity. This means that for each a separate topology file will be generated. The models in the ensemble can thus correspond to different molecules. + group: 'sampling' + explevel: expert +solvent: + default: water + type: string + minchars: 0 + maxchars: 100 + choices: + - water + - dmso + title: Solvent + short: Solvent to use during the short MD refinement + long: Solvent to use during the short MD refinement. Water and DMSO are supported. + A solvent shelll is generated by shifting pre-equilibrated boxes around the complex. + For water an 8A water shell is generated and for DMSO a 12.5A shell. + For DMSO, + group: '' + explevel: easy +nemsteps: + default: 200 + type: integer + min: 0 + max: 10000 + title: Number of EM steps + short: Number of energy minimisation steps to perform. + long: Number of energy minimisation steps to perform in the various EM stages of this refinement protocol. + Note that the effective number might be smaller if the minimisation converges earlier. + group: 'sampling' + explevel: expert +timestep: + default: 0.002 + type: float + min: 0.0005 + max: 0.004 + precision: 4 + title: MD integrating time step + short: Integration time step for the molecular dynamics. + long: Integration time step for the molecular dynamics. + group: 'sampling' + explevel: guru +waterheatsteps: + default: 100 + type: integer + min: 0 + max: 10000 + title: Number of MD steps for the heating + short: Number of MD steps for the heating phase. + long: Number of MD steps for the heating phase. The heating consists of three successive + short molecular dynamics simluations at 100, 200 and 300 Kelvin. + group: 'sampling' + explevel: expert +watersteps: + default: 1250 + type: integer + min: 0 + max: 100000 + title: Number of MD steps at 300K. + short: Number of MD steps for 300K simulation. + long: Number of MD steps for 300K simulation. This is the sampling state of the refinement. + group: 'sampling' + explevel: expert +watercoolsteps: + default: 500 + type: integer + min: 0 + max: 10000 + title: Number of MD steps for the cooling + short: Number of MD steps for the cooling phase. + long: Number of MD steps for the cooling phase. The cooling consists of three successive + short molecular dynamics simluations at 300, 200 and 100 Kelvin. + group: 'sampling' + explevel: expert +iniseed: + default: 917 + type: integer + min: 0 + max: 9999999999999999 + title: Random seed + short: Random seed used in CNS to initialize the random seed function + long: Random seed used in CNS to initialize the random seed function + group: 'sampling' + explevel: guru +keepwater: + default: false + type: boolean + title: Write water molecules to output file + short: Write water molecules if present to the output file. + long: Write water molecules if present to the output file. + group: 'sampling' + explevel: guru +tolerance: + default: 5 + type: integer + min: 0 + max: 99 + precision: 3 + title: Failure tolerance percentage + short: Percentage of allowed failures for a module to successfully complete + long: Percentage of allowed failures for a module to successfully complete + group: 'module' + explevel: expert +log_level: + default: quiet + type: string + minchars: 0 + maxchars: 100 + choices: + - verbose + - normal + - quiet + title: Log level verbosity for CNS + short: Set the log level verbosity for CNS + long: CNS, the computational engine used by HADDOCK can generate a lot of output + messages. This parameter controls the verbosity of CNS (verbose, normal or quiet). + group: module + explevel: guru diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyligand/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyligand/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8c11aeadf3661d9fe3c9dd527b5ac806bbc68d7d --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyligand/__init__.py @@ -0,0 +1,92 @@ +"""PRODIGY-ligand scoring module. + +This module performs the scoring of input complexes using PRODIGY-ligand. +It predicts deltaG of the complex and can return predictions as either deltaG +or pKd values. +""" + +from pathlib import Path + +from haddock.core.defaults import MODULE_DEFAULT_YAML +from haddock.core.typing import FilePath +from haddock.libs.libontology import PDBFile +from haddock.libs.libprodigy import CheckInstall +from haddock.modules import get_engine +from haddock.modules.scoring import ScoringModule +from haddock.modules.scoring.prodigyligand.prodigylig import ProdigyJob + + +RECIPE_PATH = Path(__file__).resolve().parent +DEFAULT_CONFIG = Path(RECIPE_PATH, MODULE_DEFAULT_YAML) + + +class HaddockModule(ScoringModule): + """HADDOCK3 module to perform energy minimization scoring.""" + + name = RECIPE_PATH.name + + def __init__( + self, + order: int, + path: Path, + initial_params: FilePath = DEFAULT_CONFIG, + ) -> None: + super().__init__(order, path, initial_params) + + @classmethod + def confirm_installation(cls) -> None: + """Confirm module is installed.""" + CheckInstall() + return + + def _run(self) -> None: + """Execute module.""" + # Retrieve previous models + try: + models_to_score = self.previous_io.retrieve_models(individualize=True) + except Exception as e: + self.finish_with_error(e) + + # Pool of Prodigy jobs to be executed + jobs: list[ProdigyJob] = [] + self.output_models: list[PDBFile] = [] + + for mi, model in enumerate(models_to_score): + self.output_models.append(model) + prodigy_job = ProdigyJob( + model, + self.params, + index=mi, + ) + jobs.append(prodigy_job) + + # Run CNS Jobs + self.log(f"Running {len(jobs)} Prodigy Jobs") + Engine = get_engine(self.params["mode"], self.params) + engine = Engine(jobs) + engine.run() + self.log("Prodigy jobs have finished") + + # Loop over results and set computed scores are attributes to models + successes: int = 0 + for model_score in engine.results: + # point score stored in engine + prodigy_score = model_score.score + model_index = model_score.index + # Point corresponding model + self.output_models[model_index].score = prodigy_score + if prodigy_score: + successes += 1 + + # Printing number of successful predictions + self.log( + f"Number of successful prodigy-ligand predictions: {successes:d} " + f"({successes * 100 / len(models_to_score):.2f} %)" + ) + + # Generate a tsv file containing the computed scores + output_fname = "prodigyligand.tsv" + self.log(f"Saving output to {output_fname}") + self.output(output_fname) + # Finalise module by exporting models + self.export_io_models() diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyligand/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyligand/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..823977b64f02f965f5e0ee873fb44a94bbda2eb2 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyligand/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyligand/__pycache__/prodigylig.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyligand/__pycache__/prodigylig.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a64fd5e80cb3bf473869ba5324552c614525de15 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyligand/__pycache__/prodigylig.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyligand/defaults.yaml b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyligand/defaults.yaml new file mode 100644 index 0000000000000000000000000000000000000000..cf0d3e2c5ba866ca3d20921a2d1b331bd93ebe2d --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyligand/defaults.yaml @@ -0,0 +1,76 @@ +receptor_chain: + default: "A" + type: string + minchars: 1 + maxchars: 1 + title: Chain ID of the receptor. + short: Chain ID of the receptor. + long: Chain ID of the receptor. Used to know what chain should be considered as receptor interacting with the ligand. + group: scoring + explevel: easy + +ligand_chain: + default: "B" + type: string + minchars: 1 + maxchars: 1 + title: Chain ID of the ligand. + short: Chain ID of the ligand. + long: Chain of the ligand to score. Used to know in which chain the ligand is found. + group: scoring + explevel: easy + +ligand_resname: + default: "UNK" + type: string + minchars: 1 + maxchars: 3 + title: Residue name of the ligand. + short: Residue name of the ligand. + long: Residue name of the ligand to score. Must be present in the ligand chain. + group: scoring + explevel: easy + +temperature: + default: 25.00 + type: float + min: -273.15 + max: 95.00 + precision: 2 + title: Temperature (°C) at which to perform the conversion to pKd. + short: Temperature (°C) at which to perform the conversion from deltaG (kcal.mol-1) to pKd. + long: Temperature (°C) at which to perform the conversion from deltaG (kcal.mol-1) to pKd. + group: conversion + explevel: easy + +electrostatics: + default: true + type: boolean + title: Use the electrostatic component. + short: Use the electrostatic component from the input model to make the prediction. + long: Use the electrostatic component from the input model to make the prediction, + if available. The electroststics must have been computed by HADDOCK and written + in the REMARK of the model. + group: scoring + explevel: expert + +to_pkd: + default: true + type: boolean + title: Converts binding affinity values to pKd. + short: Converts binding affinity values to pKd. + long: By default, prodigy-lig results in deltaG (kcal.mol-1), but this parameter allows to convert results to pKd. + group: conversion + explevel: easy + +distance_cutoff: + default: 10.5 + type: float + min: 1.00 + max: 100.00 + precision: 2 + title: Distance cutoff (Å) to extract amino-acids from the receptor. + short: Distance cutoff (Å) to extract amino-acids from the receptor. + long: Distance cutoff (Å) to extract amino-acids from the receptor in contact with the ligand. + group: scoring + explevel: expert diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyligand/prodigylig.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyligand/prodigylig.py new file mode 100644 index 0000000000000000000000000000000000000000..19abbff80d183d24b56e98b96c848a47b33984d9 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyligand/prodigylig.py @@ -0,0 +1,85 @@ +"""Set of functionalities to run prodigy-ligand. + +DevNotes: +The magic happens in haddock/libs/libprodigy.py +""" + +from haddock.core.typing import FilePath, ParamDict +from haddock.libs.libontology import PDBFile +from haddock.libs.libprodigy import ProdigyBaseJob, ProdigyWorker + + +class ProdigyLigand(ProdigyWorker): + """Class managing the computation of protein-ligand with prodigy.""" + + def __init__(self, model: FilePath, params: ParamDict) -> None: + """Instantiate the class with superclass.""" + super().__init__(model, params) + # Hold specific parameters + self.receptor_chain = params["receptor_chain"] + self.lig_resname = params["ligand_resname"] + self.lig_chain = params["ligand_chain"] + self.use_electrostatics = params["electrostatics"] + + def evaluate_complex(self) -> float: + """Evaluate a complex with prodigy-lig. + + Returns + ------- + deltaG : float + The computed DeltaG of the input complex. + """ + from prodigy_lig.prodigy_lig import ( + basename, + extract_electrostatics, + FastMMCIFParser, + PDBParser, + ProdigyLig, + splitext, + ) + # Mimic prodigy-ligand main + fname, s_ext = splitext(basename(self.model)) + if s_ext in (".pdb", ".ent", ): + parser = PDBParser(QUIET=1) + elif s_ext == ".cif": + parser = FastMMCIFParser(QUIET=1) + + with open(self.model) as in_file: + # try to set electrostatics from input file if not provided by user + electrostatics = extract_electrostatics(in_file) + # Setup the prodigy lig object + prodigy_lig = ProdigyLig( + parser.get_structure(fname, in_file), + chains=[ + f"{self.receptor_chain},{self.lig_chain}", + f"{self.lig_chain}:{self.lig_resname}", + ], + electrostatics=electrostatics, + cutoff=self.dist_cutoff, + ) + # Run predictions + prodigy_lig.predict() + # Retrieve DeltaG + if self.use_electrostatics and prodigy_lig.dg_elec: + deltaG = prodigy_lig.dg_elec + else: + deltaG = prodigy_lig.dg + return deltaG + + +class ProdigyJob(ProdigyBaseJob): + """Managing the computation of prodigy scores within haddock3.""" + + def __init__( + self, + model: PDBFile, + params: ParamDict, + index: int = 1, + ) -> None: + """Instantiate the class with superclass.""" + super().__init__(model, params, index) + + @staticmethod + def get_worker() -> object: + """Return the appropriate worker.""" + return ProdigyLigand diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyprotein/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyprotein/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..65d8351cf45f4e8d838652bf77b7e91ed0f0ce25 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyprotein/__init__.py @@ -0,0 +1,94 @@ +"""PRODIGY protein complex scoring module + +This module performs the scoring of input complexes using PRODIGY (protein). +It predicts deltaG of the complex and can return predictions as either deltaG +or pKd values. + +Note that PRODIGY-protein is limited to natural amino-acids. +""" + +from pathlib import Path + +from haddock.core.defaults import MODULE_DEFAULT_YAML +from haddock.core.typing import FilePath +from haddock.libs.libontology import PDBFile +from haddock.libs.libprodigy import CheckInstall +from haddock.modules import get_engine +from haddock.modules.scoring import ScoringModule +from haddock.modules.scoring.prodigyprotein.prodigy import ProdigyJob + + +RECIPE_PATH = Path(__file__).resolve().parent +DEFAULT_CONFIG = Path(RECIPE_PATH, MODULE_DEFAULT_YAML) + + +class HaddockModule(ScoringModule): + """HADDOCK3 module to perform energy minimization scoring.""" + + name = RECIPE_PATH.name + + def __init__( + self, + order: int, + path: Path, + initial_params: FilePath = DEFAULT_CONFIG, + ) -> None: + super().__init__(order, path, initial_params) + + @classmethod + def confirm_installation(cls) -> None: + """Confirm module is installed.""" + CheckInstall() + return + + def _run(self) -> None: + """Execute module.""" + # Retrieve previous models + try: + models_to_score = self.previous_io.retrieve_models(individualize=True) + except Exception as e: + self.finish_with_error(e) + + # Pool of Prodigy jobs to be executed + jobs: list[ProdigyJob] = [] + self.output_models: list[PDBFile] = [] + + for mi, model in enumerate(models_to_score): + self.output_models.append(model) + prodigy_job = ProdigyJob( + model, + self.params, + index=mi, + ) + jobs.append(prodigy_job) + + # Run CNS Jobs + self.log(f"Running {len(jobs)} Prodigy Jobs") + Engine = get_engine(self.params["mode"], self.params) + engine = Engine(jobs) + engine.run() + self.log("Prodigy jobs have finished") + + # Loop over results and set computed scores are attributes to models + successes: int = 0 + for model_score in engine.results: + # point score stored in engine + prodigy_score = model_score.score + model_index = model_score.index + # Point corresponding model + self.output_models[model_index].score = prodigy_score + if prodigy_score: + successes += 1 + + # Printing number of successful predictions + self.log( + f"Number of successful prodigy-protein predictions: {successes:d} " + f"({successes * 100 / len(models_to_score):.2f} %)" + ) + + # Generate a tsv file containing the computed scores + output_fname = "prodigyprotein.tsv" + self.log(f"Saving output to {output_fname}") + self.output(output_fname) + # Finalise module by exporting models + self.export_io_models() diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyprotein/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyprotein/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..98dd595350a1050b724dd9f98e65d38f8016b7a3 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyprotein/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyprotein/__pycache__/prodigy.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyprotein/__pycache__/prodigy.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f47e2e815fa4d5c0ae38afac043320d0616ae53d Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyprotein/__pycache__/prodigy.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyprotein/defaults.yaml b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyprotein/defaults.yaml new file mode 100644 index 0000000000000000000000000000000000000000..228abf1a142dc7e82501739b942331347eb66ce7 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyprotein/defaults.yaml @@ -0,0 +1,64 @@ +chains: + default: [] + type: list + minitems: 0 + maxitems: 20 + title: Chains to be scored. + short: List of chains to be scored. If empty/unspecified, all inter-chains + contacts will be considered for the final prediction. + long: List of chains to be scored. If empty/unspecified, all inter-chains + contacts will be considered for the final prediction. In specific cases, + for example antibody-antigen complexes, some chains should be considered + as a single molecule. Use the chains parameter to provide a list of chains + that should be considered for the calculation. Use commas to include + multiple chains as part of a single group. + ["A", "B"] => Contacts calculated (only) between chains A and B. + ["A,B", "C"] => Contacts calculated (only) between chains A and C; and B and C. + ["A", "B", "C"] => Contacts calculated (only) between chains A and B; B and C; and A and C. + group: scoring + explevel: easy + +distance_cutoff: + default: 5.5 + type: float + min: 1.00 + max: 100.00 + precision: 2 + title: Distance cutoff (Å) to extract amino-acids in contact between the two chains. + short: Distance cutoff (Å) to extract amino-acids in contact between the two chains. + long: Distance cutoff (Å) to extract amino-acids in contact between the two chains. + group: scoring + explevel: expert + +accessibility_cutoff: + default: 0.05 + type: float + min: 0.00 + max: 1.00 + precision: 2 + title: Accessibility threshold for BSA analysis. + short: Accessibility threshold for BSA analysis. + long: Accessibility threshold for BSA analysis. + group: scoring + explevel: expert + +temperature: + default: 25.00 + type: float + min: -273.15 + max: 95.00 + precision: 2 + title: Temperature (°C) at which to perform the conversion to pKd. + short: Temperature (°C) at which to perform the conversion from deltaG (kcal.mol-1) to pKd. + long: Temperature (°C) at which to perform the conversion from deltaG (kcal.mol-1) to pKd. + group: conversion + explevel: easy + +to_pkd: + default: true + type: boolean + title: Converts binding affinity values to pKd. + short: Converts binding affinity values to pKd. + long: By default, prodigy-lig results in deltaG (kcal.mol-1), but this parameter allows to convert results to pKd. + group: conversion + explevel: easy diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyprotein/prodigy.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyprotein/prodigy.py new file mode 100644 index 0000000000000000000000000000000000000000..5e6621b295449f0bf349f64be80773e796f19d6c --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/prodigyprotein/prodigy.py @@ -0,0 +1,78 @@ +"""Set of functionalities to run prodigy-protein. + +DevNotes: +The magic happens in haddock/libs/libprodigy.py +""" + +from haddock.core.typing import FilePath, Optional, ParamDict +from haddock.libs.libontology import PDBFile +from haddock.libs.libprodigy import ProdigyBaseJob, ProdigyWorker + + +class ProdigyProtein(ProdigyWorker): + """Class managing the computation of protein-protein with prodigy.""" + + def __init__(self, model: FilePath, params: ParamDict) -> None: + """Instantiate the class with superclass.""" + super().__init__(model, params) + # Hold specific parameters + self.acc_cutoff = params["accessibility_cutoff"] + self.chains = self.convert_chains(params["chains"]) + + @staticmethod + def convert_chains(chains: list[str]) -> Optional[list[str]]: + """Read and convert the `chains` parameter. + + Parameters + ---------- + chains : Optional[list[str]] + Content of the chains parameter as provided by the user. + + Returns + ------- + Optional[list[str]] + None or list of strings containing the chains. + """ + if len(chains) == 0: + return None + else: + # Removes potential spaces if user is inputing something wrong + # e.g.: "A, B" needs to be "A,B" + return [c.replace(" ", "") for c in chains] + + def evaluate_complex(self) -> float: + """Evaluate a complex with prodigy-prot. + + Returns + ------- + deltaG : float + The computed DeltaG of the input complex. + """ + from prodigy_prot.modules.prodigy import Prodigy + from prodigy_prot.modules.parsers import parse_structure + structure, _n_chains, _n_res = parse_structure(self.model) + prodigy = Prodigy(structure, self.chains, self.temperature) + prodigy.predict( + distance_cutoff=self.dist_cutoff, + acc_threshold=self.acc_cutoff, + ) + deltaG = prodigy.ba_val + return deltaG + + +class ProdigyJob(ProdigyBaseJob): + """Managing the computation of prodigy scores within haddock3.""" + + def __init__( + self, + model: PDBFile, + params: ParamDict, + index: int = 1, + ) -> None: + """Instantiate the class with superclass.""" + super().__init__(model, params, index) + + @staticmethod + def get_worker() -> object: + """Return the appropriate worker.""" + return ProdigyProtein diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/sasascore/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/sasascore/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ed82f39ebb20e0d4f396d329422a3fe4b5a2cc60 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/sasascore/__init__.py @@ -0,0 +1,126 @@ +""" +Surface accessibility scoring module. + +This module performs a solvent accessibility analysis based on +some user-defined residues that should be buried or accessible. + +If a supposedly buried (resp. accessible) residue is accessible (resp. buried), +the score should increase by one. The lower the final score the more consistent +the model with the user data. + +To run this module, the user must provide a dictionary with the buried and/or accessible +residues. The keys of the dictionary should be the chain identifiers and the values +should be lists of residue numbers. + +Example: + +>>> resdic_buried_A: [1, 2, 3] +>>> resdic_accessible_B: [4, 5, 6] +""" +from pathlib import Path +import os + +from haddock.core.defaults import MODULE_DEFAULT_YAML +from haddock.core.typing import FilePath +from haddock.modules import get_engine +from haddock.modules.scoring import ScoringModule +from haddock.libs.libontology import PDBFile +from haddock.libs.libutil import parse_ncores +from haddock.libs.libparallel import get_index_list, Scheduler +from haddock.modules.scoring.sasascore.sasascore import ( + AccScore, + extract_data_from_accscore_class + ) + +RECIPE_PATH = Path(__file__).resolve().parent +DEFAULT_CONFIG = Path(RECIPE_PATH, MODULE_DEFAULT_YAML) + + +class HaddockModule(ScoringModule): + """HADDOCK3 module to perform accessibility scoring.""" + + name = RECIPE_PATH.name + + def __init__(self, + order: int, + path: Path, + initial_params: FilePath = DEFAULT_CONFIG) -> None: + super().__init__(order, path, initial_params) + + @classmethod + def confirm_installation(cls) -> None: + """Confirm module is installed.""" + return + + def _run(self) -> None: + """Execute module.""" + try: + models_to_score = self.previous_io.retrieve_models( + individualize=True + ) + except Exception as e: + self.finish_with_error(e) + if self.params["mode"] == "mpi": + input_ncores_slurm = int(os.getenv('SLURM_CPUS_ON_NODE', 1)) + input_ncores_pbs = int(os.getenv('PBS_CPUS_ON_NODE', 1)) + ncores = max(input_ncores_slurm, input_ncores_pbs) + else: + ncores = self.params["ncores"] + # loading buried and accessible residue dictionaries + buried_resdic = { + key[-1]: value for key, value + in self.params.items() + if key.startswith("resdic_buried") + } + acc_resdic = { + key[-1]: value for key, value + in self.params.items() + if key.startswith("resdic_accessible") + } + # remove _ + buried_resdic.pop("_") + acc_resdic.pop("_") + + self.output_models: list[PDBFile] = [] + # initialize jobs + sasascore_jobs: list[AccScore] = [] + for i, model_to_be_evaluated in enumerate(models_to_score): + accscore_obj = AccScore( + model=model_to_be_evaluated, + path=Path("."), + buried_resdic=buried_resdic, + acc_resdic=acc_resdic, + cutoff=self.params["cutoff"], + probe_radius=self.params["probe_radius"], + identificator=i, + ) + sasascore_jobs.append(accscore_obj) + # append model to output models + self.output_models.append(model_to_be_evaluated) + + # Run sasascore Jobs using Scheduler + engine = Scheduler( + ncores=ncores, + tasks=sasascore_jobs, + ) + engine.run() + + # extract results and overwrite scores + sasascore_jobs = engine.results + sasascore_jobs = sorted(sasascore_jobs, + key=lambda accscore: accscore.identificator) + + for i, job in enumerate(sasascore_jobs): + pdb = self.output_models[i] + pdb.score = job.data[3] + output_name = Path("sasascore.tsv") + self.output(output_name) + + # now violations + viol_output_name = Path("violations.tsv") + extract_data_from_accscore_class( + sasascore_objects=sasascore_jobs, + violations_output_fname=viol_output_name + ) + + self.export_io_models() diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/sasascore/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/sasascore/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..46d94486aa29cc83839db5fb396058f9c1158212 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/sasascore/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/sasascore/__pycache__/sasascore.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/sasascore/__pycache__/sasascore.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1940e1938ae6b15214a0cb2c90386cce17b7d68f Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/sasascore/__pycache__/sasascore.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/sasascore/defaults.yaml b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/sasascore/defaults.yaml new file mode 100644 index 0000000000000000000000000000000000000000..4744f43e57ed14adfb658e005cbe2cb3d1586cb3 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/sasascore/defaults.yaml @@ -0,0 +1,49 @@ +# +# Group scoring +# +cutoff: + default: 0.4 + type: float + min: 0.0 + max: 1.0 + precision: 3 + title: relative side chain surface accessibility cutoff + short: relative side chain surface accessibility cutoff + long: relative side chain surface accessibility cutoff. Residues with a relative side chain surface accessibility below this value are considered buried. + group: 'scoring' + explevel: easy +resdic_buried_: + default: [] + type: list + minitems: 0 + maxitems: 100 + title: List of residues supposed to be buried + short: List of residues supposed to be buried + long: resdic_buried_* is an expandable parameter. You can provide resdic_buried_A, + resdic_buried_B, resdic_buried_C, etc, where the last capital letter is the chain + identifier. + group: analysis + explevel: easy +resdic_accessible_: + default: [] + type: list + minitems: 0 + maxitems: 100 + title: List of residues supposed to be accessible + short: List of residues supposed to be accessible + long: resdic_* is an expandable parameter. You can provide resdic_accessible_A, + resdic_accessible_B, resdic_accessible_C, etc, where the last capital letter is the chain + identifier. + group: analysis + explevel: easy +probe_radius: + default: 1.4 + type: float + min: 0.0 + max: 10.0 + precision: 3 + title: Probe radius + short: Probe radius + long: Sets the probe radius (in Angstrom) used to compute solvent accessible surface area. + group: analysis + explevel: expert \ No newline at end of file diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/sasascore/sasascore.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/sasascore/sasascore.py new file mode 100644 index 0000000000000000000000000000000000000000..947f5e937a57c2e961764abb8a8f2990a2df5b70 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/scoring/sasascore/sasascore.py @@ -0,0 +1,151 @@ +"""Accessibility scoring calculations.""" +import copy +from pathlib import Path + +from typing import Optional + +from haddock.libs.libio import write_nested_dic_to_file +from haddock import log +from haddock.core.typing import ParamDict +from haddock.clis.restraints.calc_accessibility import ( + apply_cutoff, + get_accessibility, + ) + + +def calc_acc_score(result_dict, buried_resdic, acc_resdic): + """Calculate the accessibility score. + + The accessibility score is calculated as the sum of the number of + residues that are not in the correct category (buried or accessible). + + Parameters + ---------- + result_dict : dict + A dictionary with the results from the accessibility calculation. + + buried_resdic : dict + A dictionary with the buried residues. + + acc_resdic : dict + A dictionary with the accessible residues. + + Returns + ------- + acc_score : int + The accessibility score. + """ + # filter the residues + acc_score: int = 0 + b_viols: dict[str, set] = {} + a_viols: dict[str, set] = {} + for ch in result_dict: + if ch in buried_resdic: + # for every supposedly buried residue that is not buried, + # the score should increase by one. + b_viols[ch] = set(buried_resdic[ch]).intersection(result_dict[ch]) + buried_viol_sc = len(b_viols[ch]) + acc_score += buried_viol_sc + if ch in acc_resdic: + # now the opposite logic with the accessible amino acids. + a_viols[ch] = set(acc_resdic[ch]).difference(result_dict[ch]) + acc_viol_sc = len(a_viols[ch]) + acc_score += acc_viol_sc + return acc_score, b_viols, a_viols + + +class AccScore: + """AccScore class.""" + + def __init__( + self, + model, + path, + buried_resdic, + acc_resdic, + cutoff, + probe_radius, + identificator, + ): + """Initialise AccScore class.""" + self.model = model + self.path = path + self.buried_resdic = buried_resdic + self.acc_resdic = acc_resdic + self.cutoff = cutoff + self.data = [] + self.violations = [] + self.probe_radius = probe_radius + self.violations_data = [self.model.file_name] + self.identificator = identificator + + def run(self) -> None: + """Run accessibility calculations.""" + mod_path = str(Path(self.model.path, self.model.file_name)) + try: + access_data = get_accessibility(mod_path, + probe_radius=self.probe_radius) + result_dic = apply_cutoff(access_data, self.cutoff) + acc_sc, b_viols, a_viols = calc_acc_score(result_dic, + self.buried_resdic, + self.acc_resdic) + except AssertionError as e: + log.warning(f"Error in get_accessibility for {self.model}: {e}.") + acc_sc, b_viols, a_viols = None, None, None + self.data = [self.model.file_name, self.model.ori_name, self.model.md5, acc_sc] + for ch in self.buried_resdic: + if ch in b_viols and b_viols[ch] != set(): + buried_str = ",".join([str(res) for res in sorted(b_viols[ch])]) + self.violations_data.append(buried_str) + else: + self.violations_data.append(None) + for ch in self.acc_resdic: + if ch in a_viols and a_viols[ch] != set(): + acc_str = ",".join([str(res) for res in sorted(a_viols[ch])]) + self.violations_data.append(acc_str) + else: + self.violations_data.append(None) + return copy.deepcopy(self) + + +def extract_data_from_accscore_class(sasascore_objects: list[AccScore], + violations_output_fname: Path + ) -> Optional[dict[int, ParamDict]]: + """ + Extracts data attributes from a list of AccScore objects into a structured dictionary, + optionally sorts the data based on a specified key, and writes the sorted data to + a file. + + Args: + sasascore_objects (list[AccScore]): List of AccScore objects containing data attributes + to be extracted. + violations_output_fname (Path): Path to the output file with the sorted violations data + + Returns: + Optional[dict[int, ParamDict]]: The structured violations_data dictionary + Raises: + (Include any specific exceptions the function may raise) + """ + violations_data: dict[int, ParamDict] = {} + for i, sasa_obj in enumerate(sasascore_objects): + nbur = len(sasa_obj.buried_resdic) + + # fill in violations + violations_data[i] = { + "structure": sasa_obj.data[0], + } + for b, bur in enumerate(sasa_obj.buried_resdic): + bur_key = f"bur_{bur}" + violations_data[i].update( + {bur_key: sasa_obj.violations_data[b+1]} + ) + for a, acc in enumerate(sasa_obj.acc_resdic): + acc_key = f"acc_{acc}" + violations_data[i].update( + {acc_key: sasa_obj.violations_data[nbur+a+1]} + ) + + # violations do not need to be sorted + write_nested_dic_to_file(violations_data, violations_output_fname) + + return violations_data diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..29db3cd6576b0258f712894fffc6ea915ed35c65 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/__init__.py @@ -0,0 +1 @@ +"""HADDOCK3 modules to create topologies.""" diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f1b221ecdc652c609cd994898d472093a5203158 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/__init__.py b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..30135ff012ae469defb2a4c452ef63fb5da46fdc --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/__init__.py @@ -0,0 +1,390 @@ +"""Create and manage CNS all-atom topology. + +The ``[topoaa]`` module is dedicated to the generation of CNS compatible +parameters (.param) and topologies (.psf) for each of the input structures. + +It will: +- Detect missing atoms, including hydrogens +- Re-build them when missing +- Build and write out topologies (psf) and coordinates (pdb) files + +This module is a pre-requisite to run any downstream modules using CNS. +Having access to parameters and topology is mandatory for any kind +of EM/MD related tasks. +Therefore this is the reason why the module [topoaa] is often used as first +module in a workflow. + +Note that for non-standard bio-molecules +(apart from standard amino-acids, some modified ones, DNA, RNA, ions +and carbohydrates ... see `detailed list of supported molecules +`_), +such as small-molecules, parameters and topology must be obtained and provided +by the user, as there is currently no built-in solution to generate +them on the fly. +""" + +import operator +import os +import re +from copy import deepcopy +from functools import partial +from pathlib import Path + +from haddock.core.defaults import MODULE_DEFAULT_YAML, cns_exec +from haddock.core.typing import FilePath, Optional, ParamDict, ParamMap, Union +from haddock.libs import libligand, libpdb +from haddock.libs.libcns import ( + find_desired_linkfiles, + generate_default_header, + load_workflow_params, + prepare_output, + prepare_single_input, +) +from haddock.libs.libontology import Format, PDBFile, TopologyFile +from haddock.libs.libstructure import make_molecules +from haddock.libs.libsubprocess import CNSJob +from haddock.modules import get_engine +from haddock.modules.base_cns_module import BaseCNSModule + + +RECIPE_PATH = Path(__file__).resolve().parent +DEFAULT_CONFIG = Path(RECIPE_PATH, MODULE_DEFAULT_YAML) + + +def generate_topology( + input_pdb: Path, + recipe_str: str, + defaults: ParamMap, + mol_params: ParamMap, + default_params_path: Optional[FilePath] = None, + write_to_disk: Optional[bool] = True, +) -> Union[Path, str]: + """Generate a HADDOCK topology file from input_pdb.""" + # generate params headers + general_param = load_workflow_params(**defaults) + input_mols_params = load_workflow_params(param_header="", **mol_params) + general_param = general_param + input_mols_params + + # generate default headers + _link, trans_vec, tensor, scatter, axis, water_box = generate_default_header( + path=default_params_path + ) + + output = prepare_output( + output_pdb_filename=f"{input_pdb.stem}_haddock{input_pdb.suffix}", + output_psf_filename=f"{input_pdb.stem}_haddock.{Format.TOPOLOGY}", + ) + + input_str = prepare_single_input(str(input_pdb)) + # Order CNS statements + inp_parts = ( + general_param, + input_str, + output, + trans_vec, + tensor, + scatter, + axis, + water_box, + recipe_str, + ) + # Combine all CNS statments as a single string + inp = "".join(inp_parts) + + if write_to_disk: + output_inp_filename = Path(f"{input_pdb.stem}.{Format.CNS_INPUT}") + output_inp_filename.write_text(inp) + return output_inp_filename + else: + return inp + + +class HaddockModule(BaseCNSModule): + """HADDOCK3 module to create CNS all-atom topologies.""" + + name = RECIPE_PATH.name + + def __init__( + self, order: int, path: Path, initial_params: FilePath = DEFAULT_CONFIG + ) -> None: + cns_script = RECIPE_PATH / "cns" / "generate-topology.cns" + super().__init__(order, path, initial_params, cns_script=cns_script) + + @classmethod + def confirm_installation(cls) -> None: + """Confirm if module is installed.""" + return + + @staticmethod + def get_md5(ensemble_f: FilePath) -> dict[int, str]: + """Get MD5 hash of a multi-model PDB file.""" + md5_dic: dict[int, str] = {} + text = Path(ensemble_f).read_text() + lines = text.split(os.linesep) + REMARK_lines = (line for line in lines if line.startswith("REMARK")) + remd5 = re.compile(r"^[a-f0-9]{32}$") + for line in REMARK_lines: + parts = line.strip().split() + + try: + idx = parts.index("MODEL") + except ValueError: # MODEL not in parts, this line can be ignored + continue + + # check if there's a md5 hash in line + for part in parts: + group = remd5.fullmatch(part) + if group: + # the model num comes after the MODEL + model_num = int(parts[idx + 1]) + md5_dic[model_num] = group.string # md5 hash + break + + return md5_dic + + @staticmethod + def get_ensemble_origin(ensemble_f: FilePath) -> dict[int, str]: + """Try to find origin for each model in ensemble. + + Parameters + ---------- + ensemble_f : FilePath + Path to a pdb file containing an ensemble. + + Returns + ------- + origin_dic : dict[int, str] + Dictionary holding as keys the modelID and values its origin. + """ + origin_dic: dict[int, str] = {} + text = Path(ensemble_f).read_text() + lines = text.split(os.linesep) + REMARK_lines = (line for line in lines if line.startswith("REMARK")) + re_origin = re.compile( + r"REMARK\s+MODEL\s+(\d+)\s+(FROM|from|From)\s+(([\w_-]+\.?)+)" + ) + for line in REMARK_lines: + if match := re_origin.search(line): + model_num = int(match.group(1).strip()) + original_path = match.group(3).strip() + original_name = Path(original_path).stem + origin_dic[model_num] = original_name + return origin_dic + + def _run(self) -> None: + """Execute module.""" + if self.order == 0: + # topoaa is the first step in the workflow + molecules = make_molecules(self.params.pop("molecules")) + + else: + # in case topoaa is not the first step, the topology is rebuilt for + # each retrieved model + _molecules = self.previous_io.retrieve_models() + molecules_paths: list[Path] = [mol.rel_path for mol in _molecules] # type: ignore + molecules = make_molecules(molecules_paths, no_parent=True) + + # extracts `input` key from params. The `input` keyword needs to + # be treated separately + mol_params: ParamDict = {} + for k in list(self.params.keys()): + if k.startswith("mol") and k[3:].isdigit(): + mol_params[k] = self.params.pop(k) + + # to facilitate the for loop down the line, we create a list with the + # keys of `mol_params` with inverted order (we will use .pop) + mol_params_keys = list(mol_params.keys())[::-1] + + # limit is only useful when order == 0 + if self.order == 0 and self.params["limit"]: + mol_params_get = mol_params_keys.pop + + # `else` is used in any case where limit is False. + else: + mol_params_get = partial(operator.getitem, mol_params_keys, -1) + + # Pool of jobs to be executed by the CNS engine + jobs: list[CNSJob] = [] + + models_dic: dict[int, list[Path]] = {} + ens_dic: dict[int, dict[int, str]] = {} + origi_ens_dic: dict[int, dict[int, str]] = {} + for i, molecule in enumerate(molecules, start=1): + self.log(f"Molecule {i}: {molecule.file_name.name}") + models_dic[i] = [] + # Copy the molecule to the step folder + + # Split models + self.log( + f"Split models if needed for {molecule.with_parent}", + level="debug", + ) + # these come already sorted + splited_models = libpdb.split_ensemble( + molecule.with_parent, + dest=Path.cwd(), + ) + + # get the MD5 hash of each model + ens_dic[i] = self.get_md5(molecule.with_parent) + origi_ens_dic[i] = self.get_ensemble_origin(molecule.with_parent) + # nice variable name, isn't it? :-) + # molecule parameters are shared among models of the same molecule + parameters_for_this_molecule = deepcopy(mol_params[mol_params_get()]) + + # Extract termini parameters + charged_nter = parameters_for_this_molecule.pop("charged_nter") + charged_cter = parameters_for_this_molecule.pop("charged_cter") + phosphate_5 = parameters_for_this_molecule.pop("5_phosphate") + self.log( + f"Termini of molecule {i}:{os.linesep}" + f" N-ter: {'un' if not charged_nter else ''}charged" + f" C-ter: {'un' if not charged_cter else ''}charged" + f" 5'phosphate: {'yes' if phosphate_5 else 'no'}" + ) + # Find appropriate link files for this molecule + link_files = find_desired_linkfiles( + charged_nter=charged_nter, + charged_cter=charged_cter, + phosphate_5=phosphate_5, + path=self.toppar_path, + ) + # Update molecule parameters with full path to link files + parameters_for_this_molecule.update(link_files) + + # Loop over molecules conformations + for _task_id, model in enumerate(splited_models): + self.log(f"Sanitizing molecule {model.name}") + models_dic[i].append(model) + + if self.params["ligand_top_fname"]: + custom_top = self.params["ligand_top_fname"] + self.log(f"Using custom topology {custom_top}") + libpdb.sanitize( + model, + overwrite=True, + custom_topology=custom_top, + ) + _params = self.params + + elif self.params["autotoppar"]: + # No `ligand_top_fname` was provided, check if there are any unknown molecules + unknown = libligand.identify_unknown_hetatms(model) + if unknown: + self.log( + f"Unknown ligand(s) {unknown} detected, " + "running PRODRG to generate topology" + ) + top_path = "" + par_path = "" + try: + top_path, par_path = libligand.run_prodrg(model, Path(".")) + except RuntimeError as e: + self.finish_with_error( + f"Your input contains unknown atoms, you did not provide the `top`/`param` files and we could not execute PRODRG to get them automatically: {e}" + ) + # Inject the automated toppar into the params for module + _params = { + **self.params, + "ligand_top_fname": top_path, + "ligand_param_fname": par_path, + } + # Overwrite `ligand_top_fname` and `ligand_param_fname` in the following modules + # this means that if these were NOT defined in other modules, they will take the + # values defined here + self._output_params["ligand_top_fname"] = top_path + self._output_params["ligand_param_fname"] = par_path + + libpdb.sanitize(model, overwrite=True, custom_topology=top_path) + else: + self.log("No unknown atoms found") + _params = self.params + else: + libpdb.sanitize(model, overwrite=True) + _params = self.params + + # Prepare generation of topologies jobs + topoaa_input = generate_topology( + model, + self.recipe_str, + _params, + parameters_for_this_molecule, + default_params_path=self.toppar_path, + write_to_disk=self.params["debug"], + ) + + self.log("Topology CNS input created") + + # Add new job to the pool + output_filename = Path(f"{model.stem}.{Format.CNS_OUTPUT}") + err_fname = f"{model.stem}.cnserr" + job = CNSJob( + topoaa_input, + output_filename, + err_fname, + envvars=self.envvars, + cns_exec=cns_exec, + ) + + jobs.append(job) + + # Run CNS Jobs + self.log(f"Running CNS Jobs n={len(jobs)}") + Engine = get_engine(self.params["mode"], self.params) + engine = Engine(jobs) + engine.run() + self.log("CNS jobs have finished") + + # Check for generated output, fail it not all expected files + # are found + expected: dict[int, dict[int, PDBFile]] = {} + for i in models_dic: + expected[i] = {} + md5_dic = ens_dic[i] + origin_names = origi_ens_dic[i] + for j, model in enumerate(models_dic[i]): + md5_hash = None + try: + model_id = int(model.stem.split("_")[-1]) + except ValueError: + model_id = 0 + + if model_id in md5_dic: + md5_hash = md5_dic[model_id] + + model_name = model.stem + processed_pdb = Path(f"{model_name}_haddock.{Format.PDB}") + processed_topology = Path(f"{model_name}_haddock.{Format.TOPOLOGY}") + + # Check if origin or md5 is available + if md5_hash or model_id in origin_names.keys(): + # Select prefix + if md5_hash: + prefix_name = md5_hash + else: + prefix_name = origin_names[model_id] + # Check if topology and file created + if processed_pdb.exists() and processed_topology.exists(): + # Build new filename + model_name = f"{prefix_name}_from_{model_name}" + # Rename files + processed_pdb = processed_pdb.rename( + f"{model_name}_haddock.{Format.PDB}" + ) + processed_topology = processed_topology.rename( + f"{model_name}_haddock.{Format.TOPOLOGY}" + ) + + topology = TopologyFile(processed_topology, path=".") + pdb = PDBFile( + file_name=processed_pdb, + topology=topology, + path=".", + md5=md5_hash, + ) + pdb.ori_name = model.stem + expected[i][j] = pdb + + # Save module information + self.output_models = list(expected.values()) # type: ignore + self.export_io_models(faulty_tolerance=self.params["tolerance"]) diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b8d3bd7efef0b48bc92d9e81dce8279c63ac9800 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/auto-his.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/auto-his.cns new file mode 100644 index 0000000000000000000000000000000000000000..1fa5cdab445bdfa316860a3a027db03f398cbd43 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/auto-his.cns @@ -0,0 +1,141 @@ +! auto-his.cns +! Automatically define the protonation state of histidines +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +{- turn on electrostatic and proper non-bonded-} +parameter + nbonds + repel=0 + nbxmod=5 atom cdie shift + cutnb=9.5 ctofnb=8.5 ctonnb=6.5 eps=10.0 e14fac=0.4 inhibit 0.25 + wmin=0.5 + tolerance 0.5 + end +end + +flags exclude * include bond angl impr dihe vdw elec end + +evaluate ($nhisd = 0) +evaluate ($nhise = 0) + +for $id1 in id ( resn HIS and name CA ) loop hisp + + evaluate ($hisdpatch = false) + evaluate ($hisepatch = false) + evaluate ($hiselec = 9999999) + + igroup interaction (not all) (not all) end + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + + do (refx = x) (all) + do (refy = y) (all) + do (refz = z) (all) + + igroup interaction (segid $segid1 and resid $resid1) (not (segid $segid1 and resid $resid1)) end + minimize powell nstep=10 drop=40.0 nprint=5 end + energy end + evaluate ($hiselec = $elec) + + do (x = refx) (all) + do (y = refy) (all) + do (z = refz) (all) + + !change partial charges of HIS side-chain to minic HISD + + do (charge = 0.00) (segid $segid1 and resid $resid1 and name CB) + do (charge = 0.13) (segid $segid1 and resid $resid1 and name CG) + do (charge = -0.57) (segid $segid1 and resid $resid1 and name ND1) + do (charge = 0.42) (segid $segid1 and resid $resid1 and name HD1) + do (charge = 0.10) (segid $segid1 and resid $resid1 and name CD2) + do (charge = -0.49) (segid $segid1 and resid $resid1 and name NE2) + do (charge = 0.41) (segid $segid1 and resid $resid1 and name CE1) + do (charge = 0.00) (segid $segid1 and resid $resid1 and name HE2) + + minimize powell nstep=10 drop=40.0 nprint=5 end + energy end + if ($elec < $hiselec) then + evaluate ($hiselec = $elec) + evaluate ($hisdpatch = true) + end if + + do (x = refx) (all) + do (y = refy) (all) + do (z = refz) (all) + + !change partial charges of HIS side-chain to minic HISE + + do (charge = 0.00) (segid $segid1 and resid $resid1 and name CB) + do (charge = 0.13) (segid $segid1 and resid $resid1 and name CG) + do (charge = -0.49) (segid $segid1 and resid $resid1 and name ND1) + do (charge = 0.00) (segid $segid1 and resid $resid1 and name HD1) + do (charge = 0.10) (segid $segid1 and resid $resid1 and name CD2) + do (charge = -0.57) (segid $segid1 and resid $resid1 and name NE2) + do (charge = 0.41) (segid $segid1 and resid $resid1 and name CE1) + do (charge = 0.42) (segid $segid1 and resid $resid1 and name HE2) + + minimize powell nstep=10 drop=40.0 nprint=5 end + energy end + if ($elec < $hiselec) then + evaluate ($hiselec = $elec) + evaluate ($hisepatch = true) + evaluate ($hisdpatch = false) + end if + + !change partial charges of HIS side-chain to the initial default + + do (charge = 0.00) (segid $segid1 and resid $resid1 and name CB) + do (charge = 0.33) (segid $segid1 and resid $resid1 and name CG) + do (charge = -0.54) (segid $segid1 and resid $resid1 and name ND1) + do (charge = 0.46) (segid $segid1 and resid $resid1 and name HD1) + do (charge = 0.33) (segid $segid1 and resid $resid1 and name CD2) + do (charge = -0.54) (segid $segid1 and resid $resid1 and name NE2) + do (charge = 0.50) (segid $segid1 and resid $resid1 and name CE1) + do (charge = 0.46) (segid $segid1 and resid $resid1 and name HE2) + + do (x = refx) (all) + do (y = refy) (all) + do (z = refz) (all) + + if ($hisdpatch = true) then + evaluate ($nhisd = $nhisd + 1) + evaluate ($seg1.$nhisd=$segid1) + evaluate ($res1.$nhisd=$resid1) + end if + if ($hisepatch = true) then + evaluate ($nhise = $nhise + 1) + evaluate ($seg2.$nhise=$segid1) + evaluate ($res2.$nhise=$resid1) + end if + +end loop hisp + +evaluate ($counter=1) +while ( $counter <= $nhisd ) loop hisd + buffer message + display Patching histidine $res1.$counter to HISD + end + patch hisd reference=nil=(segid $seg1.$counter and resid $res1.$counter) end + evaluate ($counter=$counter+1) +end loop hisd + +evaluate ($counter=1) +while ( $counter <= $nhise ) loop hise + buffer message + display Patching histidine $res2.$counter to HISE + end + patch hise reference=nil=(segid $seg2.$counter and resid $res2.$counter) end + evaluate ($counter=$counter+1) +end loop hise + +igroup interaction (all) (all) end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/bondglycans.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/bondglycans.cns new file mode 100644 index 0000000000000000000000000000000000000000..422fc1457f4d84c406157c2d27494c3081790e53 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/bondglycans.cns @@ -0,0 +1,728 @@ +! +! Patches covalent bonds involving N-linked carbohydrates. +! +! Adapted from CNS 1.3 +! modules/xtal/mtfautogenerate +! +! *********************************************************************** +! * Copyright 2020 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +checkversion 1.3 + +display +display autogenerating linkages involving N-linked carbohydrates +display + +define +( + {- define all alpha anomer carbo residues for the links below -} + alpha= ( resname GLC or resname GLA or resname MAN or resname NDG or resname A2G or resname FUC or resname FCA or resname NDG + or resname MMA or resname XYS or resname RAM or resname ABE); + + {- define all beta anomer carbo residues for the links below -} + beta= ( resname BGC or resname GAL or resname BMA or resname NAG or resname NGA or resname FUL or resname FCB or resname XYP + or resname NAG or resname NGA or resname BDP); + + {- Maximum distance between linkable atoms -} + carbo_dist= 2.0; +) + +{- this is OK here after reading the coordinates since the various -} +{- patches used here do not create or rename atoms -} + +{- first we build a data structure for the patches, and then apply the patches later -} +{- the reason we do it this way is that patch may delete or add atoms which will currently + reset the STORE and loop arrays -} + +eval ($npatch=0) + +{- NAG-C1 or NGA-C1 or NDG-C1 or BGC-C1 to ASN-ND2 -} +for $id1 in id ( (resname NAG or resname NGA or resname NDG or resname BGC) and name C1 and known ) loop B1Na + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + show (resname) (id $id1) + evaluate ($resname1=$result) + + for $id2 in id ( resname ASN and name ND2 and known ) loop B1Nb + + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + + show (x) ( id $id1 ) evaluate ($x1=$result) + show (y) ( id $id1 ) evaluate ($y1=$result) + show (z) ( id $id1 ) evaluate ($z1=$result) + show (x) ( id $id2 ) evaluate ($x2=$result) + show (y) ( id $id2 ) evaluate ($y2=$result) + show (z) ( id $id2 ) evaluate ($z2=$result) + evaluate ($distance=sqrt( ($x1-$x2)^2 + ($y1-$y2)^2 + ($z1-$z2)^2 )) + + if ( $distance <= &carbo_dist ) then + evaluate ($npatch=$npatch+1) + evaluate ($seg1.$npatch=$segid1) + evaluate ($seg2.$npatch=$segid2) + evaluate ($res1.$npatch=$resid1) + evaluate ($res2.$npatch=$resid2) + if ($resname1="NDG") then + evaluate ($pres.$npatch="B1N") ! force to beta anomer, ATB 02/03/2010 + display warning: unusual NDG to ASN patch for NDG segid= $segid1 resid= $resid1 - forced to beta anomer + else + evaluate ($pres.$npatch="B1N") + buffer message + display ASN-glycosylation detected for $resid2 of chain $segid2 + end + + end if + end if + + end loop B1Nb + +end loop B1Na + +{- NAG-C1 or NGA-C1 or NDG-C1 or BGC-C1 to THR-OG1 -} +for $id1 in id ( (resname NAG or resname NGA or resname NDG or resname BGC) and name C1 and known ) loop B1Ta + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + show (resname) (id $id1) + evaluate ($resname1=$result) + + for $id2 in id ( resname THR and name OG1 and known ) loop B1Tb + + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + + show (x) ( id $id1 ) evaluate ($x1=$result) + show (y) ( id $id1 ) evaluate ($y1=$result) + show (z) ( id $id1 ) evaluate ($z1=$result) + show (x) ( id $id2 ) evaluate ($x2=$result) + show (y) ( id $id2 ) evaluate ($y2=$result) + show (z) ( id $id2 ) evaluate ($z2=$result) + evaluate ($distance=sqrt( ($x1-$x2)^2 + ($y1-$y2)^2 + ($z1-$z2)^2 )) + + if ( $distance <= &carbo_dist ) then + evaluate ($npatch=$npatch+1) + evaluate ($seg1.$npatch=$segid1) + evaluate ($seg2.$npatch=$segid2) + evaluate ($res1.$npatch=$resid1) + evaluate ($res2.$npatch=$resid2) + if ($resname1="NDG") then + evaluate ($pres.$npatch="B1T") ! force to beta anomer, ATB 02/03/2010 + display warning: unusual NDG to THR patch for NDG segid= $segid1 resid= $resid1 - forced to beta anomer + else + evaluate ($pres.$npatch="B1T") + buffer message + display THR-glycosylation detected for $resid2 of chain $segid2 + end + + end if + end if + + end loop B1Tb + +end loop B1Ta + +{- A11: GLC to GLC -} +for $id1 in id ( (resname GLC) and name C1 and known ) loop A11a + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + + for $id2 in id ( (resname GLC) and name O1 and known ) loop A11b + + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + + show (x) ( id $id1 ) evaluate ($x1=$result) + show (y) ( id $id1 ) evaluate ($y1=$result) + show (z) ( id $id1 ) evaluate ($z1=$result) + show (x) ( id $id2 ) evaluate ($x2=$result) + show (y) ( id $id2 ) evaluate ($y2=$result) + show (z) ( id $id2 ) evaluate ($z2=$result) + evaluate ($distance=sqrt( ($x1-$x2)^2 + ($y1-$y2)^2 + ($z1-$z2)^2 )) + + if ( $distance <= &carbo_dist ) then + evaluate ($npatch=$npatch+1) + evaluate ($seg1.$npatch=$segid1) + evaluate ($seg2.$npatch=$segid2) + evaluate ($res1.$npatch=$resid1) + evaluate ($res2.$npatch=$resid2) + evaluate ($pres.$npatch="A11") + end if + + end loop A11b + +end loop A11a + +{- A23: GAL, NGA to SIA, SIB -} +for $id1 in id ( (resname GAL or resname NGA) and name C2 and known ) loop A23a + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + + for $id2 in id ( (resname SIA or resname SIB) and name O3 and known ) loop A23b + + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + + show (x) ( id $id1 ) evaluate ($x1=$result) + show (y) ( id $id1 ) evaluate ($y1=$result) + show (z) ( id $id1 ) evaluate ($z1=$result) + show (x) ( id $id2 ) evaluate ($x2=$result) + show (y) ( id $id2 ) evaluate ($y2=$result) + show (z) ( id $id2 ) evaluate ($z2=$result) + evaluate ($distance=sqrt( ($x1-$x2)^2 + ($y1-$y2)^2 + ($z1-$z2)^2 )) + + if ( $distance <= &carbo_dist ) then + evaluate ($npatch=$npatch+1) + evaluate ($seg1.$npatch=$segid1) + evaluate ($seg2.$npatch=$segid2) + evaluate ($res1.$npatch=$resid1) + evaluate ($res2.$npatch=$resid2) + evaluate ($pres.$npatch="A23") + end if + + end loop A23b + +end loop A23a + +{- A23: SIA,SIB to GAL,NGA -} +for $id1 in id ( (resname SIA or resname SIB) and name C2 and known ) loop A23c + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + + for $id2 in id ( (resname GAL or resname NGA) and name O3 and known ) loop A23d + + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + + show (x) ( id $id1 ) evaluate ($x1=$result) + show (y) ( id $id1 ) evaluate ($y1=$result) + show (z) ( id $id1 ) evaluate ($z1=$result) + show (x) ( id $id2 ) evaluate ($x2=$result) + show (y) ( id $id2 ) evaluate ($y2=$result) + show (z) ( id $id2 ) evaluate ($z2=$result) + evaluate ($distance=sqrt( ($x1-$x2)^2 + ($y1-$y2)^2 + ($z1-$z2)^2 )) + + if ( $distance <= &carbo_dist ) then + evaluate ($npatch=$npatch+1) + evaluate ($seg1.$npatch=$segid1) + evaluate ($seg2.$npatch=$segid2) + evaluate ($res1.$npatch=$resid1) + evaluate ($res2.$npatch=$resid2) + evaluate ($pres.$npatch="A23") + end if + + end loop A23d + +end loop A23c + +{- A26: GAL,NGA to SIA,SIB -} +for $id1 in id ( (resname GAL or resname NGA) and name C2 and known ) loop A26a + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + + for $id2 in id ( (resname SIA or resname SIB) and name O6 and known ) loop A26b + + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + + show (x) ( id $id1 ) evaluate ($x1=$result) + show (y) ( id $id1 ) evaluate ($y1=$result) + show (z) ( id $id1 ) evaluate ($z1=$result) + show (x) ( id $id2 ) evaluate ($x2=$result) + show (y) ( id $id2 ) evaluate ($y2=$result) + show (z) ( id $id2 ) evaluate ($z2=$result) + evaluate ($distance=sqrt( ($x1-$x2)^2 + ($y1-$y2)^2 + ($z1-$z2)^2 )) + + if ( $distance <= &carbo_dist ) then + evaluate ($npatch=$npatch+1) + evaluate ($seg1.$npatch=$segid1) + evaluate ($seg2.$npatch=$segid2) + evaluate ($res1.$npatch=$resid1) + evaluate ($res2.$npatch=$resid2) + evaluate ($pres.$npatch="A26") + end if + + end loop A26b + +end loop A26a + +{- A26: SIA,SIB to GAL,NGA -} +for $id1 in id ( (resname SIA or resname SIB) and name C2 and known ) loop A26c + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + + for $id2 in id ( (resname GAL or resname NGA) and name O6 and known ) loop A26d + + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + + show (x) ( id $id1 ) evaluate ($x1=$result) + show (y) ( id $id1 ) evaluate ($y1=$result) + show (z) ( id $id1 ) evaluate ($z1=$result) + show (x) ( id $id2 ) evaluate ($x2=$result) + show (y) ( id $id2 ) evaluate ($y2=$result) + show (z) ( id $id2 ) evaluate ($z2=$result) + evaluate ($distance=sqrt( ($x1-$x2)^2 + ($y1-$y2)^2 + ($z1-$z2)^2 )) + + if ( $distance <= &carbo_dist ) then + evaluate ($npatch=$npatch+1) + evaluate ($seg1.$npatch=$segid1) + evaluate ($seg2.$npatch=$segid2) + evaluate ($res1.$npatch=$resid1) + evaluate ($res2.$npatch=$resid2) + evaluate ($pres.$npatch="A26S") + end if + + end loop A26d + +end loop A26c + +{- A28: SIA,SIB to SIA,SIB -} +for $id1 in id ( (resname SIA or resname SIB) and name C2 and known ) loop A28a + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + + for $id2 in id ( (resname SIA or resname SIB) and name O8 and known ) loop A28b + + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + + show (x) ( id $id1 ) evaluate ($x1=$result) + show (y) ( id $id1 ) evaluate ($y1=$result) + show (z) ( id $id1 ) evaluate ($z1=$result) + show (x) ( id $id2 ) evaluate ($x2=$result) + show (y) ( id $id2 ) evaluate ($y2=$result) + show (z) ( id $id2 ) evaluate ($z2=$result) + evaluate ($distance=sqrt( ($x1-$x2)^2 + ($y1-$y2)^2 + ($z1-$z2)^2 )) + + if ( $distance <= &carbo_dist ) then + evaluate ($npatch=$npatch+1) + evaluate ($seg1.$npatch=$segid1) + evaluate ($seg2.$npatch=$segid2) + evaluate ($res1.$npatch=$resid1) + evaluate ($res2.$npatch=$resid2) + evaluate ($pres.$npatch="A28S") + end if + + end loop A28b + +end loop A28a + +{- now the beta-anomer to any links -} +{- for B12: beta(1,2) link from beta-anomer to any -} +ident (store2) ( ( &alpha or &beta ) and name O2 and known ) +{- for B13: beta(1,3) link from beta-anomer to any -} +ident (store3) ( ( &alpha or &beta ) and name O3 and known ) +{- for B14: beta(1,4) link from beta-anomer to any -} +ident (store4) ( ( &alpha or &beta ) and name O4 and known ) +{- for B16: beta(1,6) link from beta-anomer to any -} +ident (store6) ( ( &alpha or &beta ) and name O6 and known ) + +for $id1 in id ( &beta and name C1 and known ) loop B1 + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + show (resname) (id $id1) + evaluate ($resname1=$result) + + for $id2 in id ( recall2 ) loop B12 + + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + + evaluate ($identical=false) + if ($resid1 = $resid2) then + if ($segid1 = $segid2) then + evaluate ($identical=true) + end if + end if + + if ($identical=false) then + + show (x) ( id $id1 ) evaluate ($x1=$result) + show (y) ( id $id1 ) evaluate ($y1=$result) + show (z) ( id $id1 ) evaluate ($z1=$result) + show (x) ( id $id2 ) evaluate ($x2=$result) + show (y) ( id $id2 ) evaluate ($y2=$result) + show (z) ( id $id2 ) evaluate ($z2=$result) + evaluate ($distance=sqrt( ($x1-$x2)^2 + ($y1-$y2)^2 + ($z1-$z2)^2 )) + + if ( $distance <= &carbo_dist ) then + evaluate ($npatch=$npatch+1) + evaluate ($seg1.$npatch=$segid1) + evaluate ($seg2.$npatch=$segid2) + evaluate ($res1.$npatch=$resid1) + evaluate ($res2.$npatch=$resid2) + if ($resname1="FUL") then + evaluate ($pres.$npatch="B12L") + else + evaluate ($pres.$npatch="B12") + end if + end if + end if + + end loop B12 + + for $id2 in id ( recall3 ) loop B13 + + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + + evaluate ($identical=false) + if ($resid1 = $resid2) then + if ($segid1 = $segid2) then + evaluate ($identical=true) + end if + end if + + if ($identical=false) then + + show (x) ( id $id1 ) evaluate ($x1=$result) + show (y) ( id $id1 ) evaluate ($y1=$result) + show (z) ( id $id1 ) evaluate ($z1=$result) + show (x) ( id $id2 ) evaluate ($x2=$result) + show (y) ( id $id2 ) evaluate ($y2=$result) + show (z) ( id $id2 ) evaluate ($z2=$result) + evaluate ($distance=sqrt( ($x1-$x2)^2 + ($y1-$y2)^2 + ($z1-$z2)^2 )) + + if ( $distance <= &carbo_dist ) then + evaluate ($npatch=$npatch+1) + evaluate ($seg1.$npatch=$segid1) + evaluate ($seg2.$npatch=$segid2) + evaluate ($res1.$npatch=$resid1) + evaluate ($res2.$npatch=$resid2) + if ($resname1="FUL") then + evaluate ($pres.$npatch="B13L") + else + evaluate ($pres.$npatch="B13") + end if + end if + end if + + end loop B13 + + for $id2 in id ( recall4 ) loop B14 + + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + + evaluate ($identical=false) + if ($resid1 = $resid2) then + if ($segid1 = $segid2) then + evaluate ($identical=true) + end if + end if + + if ($identical=false) then + + show (x) ( id $id1 ) evaluate ($x1=$result) + show (y) ( id $id1 ) evaluate ($y1=$result) + show (z) ( id $id1 ) evaluate ($z1=$result) + show (x) ( id $id2 ) evaluate ($x2=$result) + show (y) ( id $id2 ) evaluate ($y2=$result) + show (z) ( id $id2 ) evaluate ($z2=$result) + evaluate ($distance=sqrt( ($x1-$x2)^2 + ($y1-$y2)^2 + ($z1-$z2)^2 )) + + if ( $distance <= &carbo_dist ) then + evaluate ($npatch=$npatch+1) + evaluate ($seg1.$npatch=$segid1) + evaluate ($seg2.$npatch=$segid2) + evaluate ($res1.$npatch=$resid1) + evaluate ($res2.$npatch=$resid2) + if ($resname1="FUL") then + evaluate ($pres.$npatch="B14L") + else + evaluate ($pres.$npatch="B14") + end if + end if + end if + + end loop B14 + + for $id2 in id ( recall6 ) loop B16 + + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + + evaluate ($identical=false) + if ($resid1 = $resid2) then + if ($segid1 = $segid2) then + evaluate ($identical=true) + end if + end if + + if ($identical=false) then + + show (x) ( id $id1 ) evaluate ($x1=$result) + show (y) ( id $id1 ) evaluate ($y1=$result) + show (z) ( id $id1 ) evaluate ($z1=$result) + show (x) ( id $id2 ) evaluate ($x2=$result) + show (y) ( id $id2 ) evaluate ($y2=$result) + show (z) ( id $id2 ) evaluate ($z2=$result) + evaluate ($distance=sqrt( ($x1-$x2)^2 + ($y1-$y2)^2 + ($z1-$z2)^2 )) + + if ( $distance <= &carbo_dist ) then + evaluate ($npatch=$npatch+1) + evaluate ($seg1.$npatch=$segid1) + evaluate ($seg2.$npatch=$segid2) + evaluate ($res1.$npatch=$resid1) + evaluate ($res2.$npatch=$resid2) + if ($resname1="FUL") then + evaluate ($pres.$npatch="B16L") + else + evaluate ($pres.$npatch="B16") + end if + end if + end if + + end loop B16 + +end loop B1 + +{- now the alpha anomer to any links -} +{- for A12: alpha(1,2) link from alpha-anomer to any -} +ident (store2) ( ( &alpha or &beta) and name O2 and known ) +{- for A13: alpha(1,3) link from alpha-anomer to any -} +ident (store3) ( ( &alpha or &beta) and name O3 and known ) +{- for A14: alpha(1,4) link from alpha-anomer to any -} +ident (store4) ( ( &alpha or &beta) and name O4 and known ) +{- for A16: alpha(1,6) link from alpha-anomer to any -} +ident (store6) ( ( &alpha or &beta) and name O6 and known ) + +for $id1 in id ( &alpha and name C1 and known ) loop A1 + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + show (resname) (id $id1) + evaluate ($resname1=$result) + + for $id2 in id ( recall2 ) loop A12 + + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + + evaluate ($identical=false) + if ($resid1 = $resid2) then + if ($segid1 = $segid2) then + evaluate ($identical=true) + end if + end if + + if ($identical=false) then + + show (x) ( id $id1 ) evaluate ($x1=$result) + show (y) ( id $id1 ) evaluate ($y1=$result) + show (z) ( id $id1 ) evaluate ($z1=$result) + show (x) ( id $id2 ) evaluate ($x2=$result) + show (y) ( id $id2 ) evaluate ($y2=$result) + show (z) ( id $id2 ) evaluate ($z2=$result) + evaluate ($distance=sqrt( ($x1-$x2)^2 + ($y1-$y2)^2 + ($z1-$z2)^2 )) + + if ( $distance <= &carbo_dist ) then + evaluate ($npatch=$npatch+1) + evaluate ($seg1.$npatch=$segid1) + evaluate ($seg2.$npatch=$segid2) + evaluate ($res1.$npatch=$resid1) + evaluate ($res2.$npatch=$resid2) + if ($resname1="FUC") then + evaluate ($pres.$npatch="A12L") + else + evaluate ($pres.$npatch="A12") + end if + end if + end if + + end loop A12 + + for $id2 in id ( recall3 ) loop A13 + + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + + evaluate ($identical=false) + if ($resid1 = $resid2) then + if ($segid1 = $segid2) then + evaluate ($identical=true) + end if + end if + + if ($identical=false) then + + show (x) ( id $id1 ) evaluate ($x1=$result) + show (y) ( id $id1 ) evaluate ($y1=$result) + show (z) ( id $id1 ) evaluate ($z1=$result) + show (x) ( id $id2 ) evaluate ($x2=$result) + show (y) ( id $id2 ) evaluate ($y2=$result) + show (z) ( id $id2 ) evaluate ($z2=$result) + evaluate ($distance=sqrt( ($x1-$x2)^2 + ($y1-$y2)^2 + ($z1-$z2)^2 )) + + if ( $distance <= &carbo_dist ) then + evaluate ($npatch=$npatch+1) + evaluate ($seg1.$npatch=$segid1) + evaluate ($seg2.$npatch=$segid2) + evaluate ($res1.$npatch=$resid1) + evaluate ($res2.$npatch=$resid2) + if ($resname1="FUC") then + evaluate ($pres.$npatch="A13L") + else + evaluate ($pres.$npatch="A13") + end if + end if + end if + + end loop A13 + + for $id2 in id ( recall4 ) loop A14 + + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + + evaluate ($identical=false) + if ($resid1 = $resid2) then + if ($segid1 = $segid2) then + evaluate ($identical=true) + end if + end if + + if ($identical=false) then + + show (x) ( id $id1 ) evaluate ($x1=$result) + show (y) ( id $id1 ) evaluate ($y1=$result) + show (z) ( id $id1 ) evaluate ($z1=$result) + show (x) ( id $id2 ) evaluate ($x2=$result) + show (y) ( id $id2 ) evaluate ($y2=$result) + show (z) ( id $id2 ) evaluate ($z2=$result) + evaluate ($distance=sqrt( ($x1-$x2)^2 + ($y1-$y2)^2 + ($z1-$z2)^2 )) + + if ( $distance <= &carbo_dist ) then + evaluate ($npatch=$npatch+1) + evaluate ($seg1.$npatch=$segid1) + evaluate ($seg2.$npatch=$segid2) + evaluate ($res1.$npatch=$resid1) + evaluate ($res2.$npatch=$resid2) + if ($resname1="FUC") then + evaluate ($pres.$npatch="A14L") + else + evaluate ($pres.$npatch="A14") + end if + end if + end if + + end loop A14 + + for $id2 in id ( recall6 ) loop A16 + + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + + evaluate ($identical=false) + if ($resid1 = $resid2) then + if ($segid1 = $segid2) then + evaluate ($identical=true) + end if + end if + + if ($identical=false) then + show (x) ( id $id1 ) evaluate ($x1=$result) + show (y) ( id $id1 ) evaluate ($y1=$result) + show (z) ( id $id1 ) evaluate ($z1=$result) + show (x) ( id $id2 ) evaluate ($x2=$result) + show (y) ( id $id2 ) evaluate ($y2=$result) + show (z) ( id $id2 ) evaluate ($z2=$result) + evaluate ($distance=sqrt( ($x1-$x2)^2 + ($y1-$y2)^2 + ($z1-$z2)^2 )) + + if ( $distance <= &carbo_dist ) then + evaluate ($npatch=$npatch+1) + evaluate ($seg1.$npatch=$segid1) + evaluate ($seg2.$npatch=$segid2) + evaluate ($res1.$npatch=$resid1) + evaluate ($res2.$npatch=$resid2) + if ($resname1="FUC") then + evaluate ($pres.$npatch="A16L") + else + evaluate ($pres.$npatch="A16") + end if + end if + end if + + end loop A16 + +end loop A1 + + +{- now we apply all the patches -} +evaluate ($counter=1) +while ( $counter <= $npatch ) loop patc + + patch $pres.$counter + reference=-=(segid $seg1.$counter and resid $res1.$counter) + reference=+=(segid $seg2.$counter and resid $res2.$counter) + end + + display $pres.$counter link added: $seg1.$counter[a4] $res1.$counter[a4] to $seg2.$counter[a4] $res2.$counter[a4] + evaluate ($counter=$counter+1) +end loop patc diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/build-missing.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/build-missing.cns new file mode 100644 index 0000000000000000000000000000000000000000..710629e31248e57f45f9a1c2384d34e4619a10cd --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/build-missing.cns @@ -0,0 +1,296 @@ +! build-missing.cns +! build missing atoms +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +define(atom_build=(not(known))) + +identity (store9) (none) + +identity (store9) (&atom_build) +if ( &hydrogen_build = "all" ) then + identity (store9) (store9 or hydrogen) +elseif ( &hydrogen_build = "unknown" ) then + identity (store9) (store9 or (not(known) and hydrogen)) +end if + +show sum(1) (store9) +evaluate ($tobuild=$result) + +if ( $tobuild > 0 ) then + + fix selection=(not(store9)) end + + show sum(1) (store9) + evaluate ($moving=$result) + + if ( $moving > 0 ) then + for $id in id (tag and byres(store9)) loop avco + + show ave(x) (byres(id $id) and known) + evaluate ($ave_x=$result) + show ave(y) (byres(id $id) and known) + evaluate ($ave_y=$result) + show ave(z) (byres(id $id) and known) + evaluate ($ave_z=$result) + + do (x=$ave_x) (byres(id $id) and store9) + do (y=$ave_y) (byres(id $id) and store9) + do (z=$ave_z) (byres(id $id) and store9) + + !The following is to deal with problems with THY methyl group + show (x) (byres(id $id) and known and name C7) + evaluate ($ave_x=$result) + show ave(y) (byres(id $id) and known and name C7) + evaluate ($ave_y=$result) + show ave(z) (byres(id $id) and known and name C7) + evaluate ($ave_z=$result) + + do (x=$ave_x) (byres(id $id) and store9 and name H7*) + do (y=$ave_y) (byres(id $id) and store9 and name H7*) + do (z=$ave_z) (byres(id $id) and store9 and name H7*) + + end loop avco + + ! Assign average b-factor of known atoms to unknown ones + if ($set_bfactor = false) then + for $id in id (tag and byres(store9)) loop bfac + show ave(b) (byres(id $id) and not store9) + do (b=$result) (byres(id $id) and store9) + end loop bfac + end if + + ! Better initial position for rebuilding if atoms to which a missing atom is bonded to exist + for $id in id (store9) loop bndto + + show sum(1) (bondedto(id $id) and known) + if ($result > 0) then + show ave(x) (bondedto(id $id) and known) + evaluate ($ave_x=$result) + show ave(y) (bondedto(id $id) and known) + evaluate ($ave_y=$result) + show ave(z) (bondedto(id $id) and known) + evaluate ($ave_z=$result) + end if + + end loop bndto + + for $id in id (store9) loop radis + do (x=x+2*random(1.0)-1) (id $id) + do (y=y+2*random(1.0)-1) (id $id) + do (z=z+2*random(1.0)-1) (id $id) + end loop radis + + {- start parameter for the side chain building -} + parameter + nbonds + rcon=20. nbxmod=-2 repel=0.9 wmin=0.1 tolerance=1. + rexp=2 irexp=2 inhibit=0.25 + end + end + + {- Friction coefficient, in 1/ps. -} + do (fbeta=100) (store9) + + evaluate ($bath=300.0) + evaluate ($nstep=500) + evaluate ($timestep=0.0005) + + do (refy=mass) (store9) + + do (mass=20) (store9) + + igroup interaction + (store9) (store9 or known) + end + + {- turn on initial energy terms -} + flags exclude * include bond angle vdw end + + minimize powell nstep=50 nprint=10 end + + set seed=$iniseed end + + do (vx=maxwell($bath)) (store9) + do (vy=maxwell($bath)) (store9) + do (vz=maxwell($bath)) (store9) + + flags exclude vdw include impr end + + dynamics cartesian + nstep=50 + timestep=$timestep + tcoupling=true temperature=$bath + nprint=$nstep + cmremove=false + end + + flags include vdw end + + minimize powell nstep=50 nprint=10 end + + set seed=$iniseed end + + do (vx=maxwell($bath)) (store9) + do (vy=maxwell($bath)) (store9) + do (vz=maxwell($bath)) (store9) + + dynamics cartesian + nstep=50 + timestep=$timestep + tcoupling=true temperature=$bath + nprint=$nstep + cmremove=false + end + + parameter + nbonds + rcon=2. nbxmod=-3 repel=0.75 + end + end + + minimize powell nstep=100 nprint=25 end + + set seed=$iniseed end + + do (vx=maxwell($bath)) (store9) + do (vy=maxwell($bath)) (store9) + do (vz=maxwell($bath)) (store9) + + dynamics cartesian + nstep=$nstep + timestep=$timestep + tcoupling=true temperature=$bath + nprint=$nstep + cmremove=false + end + + {- turn on all energy terms -} + flags include dihe ? end + + {- set repel to ~vdw radii -} + parameter + nbonds + repel=0.89 + end + end + + minimize powell nstep=500 nprint=50 end + + flags exclude * include bond angl impr dihe vdw elec end + + minimize powell nstep=500 nprint=50 end + + {- return masses to something sensible -} + do (mass=refy) (store9) + + set seed=$iniseed end + + do (vx=maxwell($bath)) (store9) + do (vy=maxwell($bath)) (store9) + do (vz=maxwell($bath)) (store9) + + dynamics cartesian + nstep=$nstep + timestep=$timestep + tcoupling=true temperature=$bath + nprint=$nstep + cmremove=false + end + + {- some final minimisation -} + minimize powell nstep=500 drop=40.0 nprint=50 end + + print thres=0.02 bonds + print thres=5. angles + + end if + + noe reset end + rest dihe reset end + + + ! Check for D-amino acids + + for $id in id ( name HA and not resn GLY ) loop ltod + + show (segid) (id $id) + evaluate ($segid=$result) + show (resid) (id $id) + evaluate ($resid=$result) + show (resn) (id $id) + evaluate ($resn=$result) + + show ave(x) (segid $segid and resid $resid and (name CB or name C or name N) and known) + evaluate ($ave_x=$result) + show ave(y) (segid $segid and resid $resid and (name CB or name C or name N) and known) + evaluate ($ave_y=$result) + show ave(z) (segid $segid and resid $resid and (name CB or name C or name N) and known) + evaluate ($ave_z=$result) + show ave(x) (segid $segid and resid $resid and name CA and known) + evaluate ($ha_x=3*$result-2*$ave_x) + show ave(y) (segid $segid and resid $resid and name CA and known) + evaluate ($ha_y=3*$result-2*$ave_y) + show ave(z) (segid $segid and resid $resid and name CA and known) + evaluate ($ha_z=3*$result-2*$ave_z) + + do (x=$ha_x) (segid $segid and resid $resid and name HA) + do (y=$ha_y) (segid $segid and resid $resid and name HA) + do (z=$ha_z) (segid $segid and resid $resid and name HA) + + flags exclude * include bond angle vdw end + minimize powell nstep=50 drop=40.0 nprint=50 end + + pick impr + (segid $segid and resid $resid and name HA) + (segid $segid and resid $resid and name N) + (segid $segid and resid $resid and name C) + (segid $segid and resid $resid and name CB) + geometry + + if ($result lt 0) then + patch LTOD reference=nil=(segid $segid and resid $resid) end + buffer message + display D-amino acid detected for $resn $resid of chain $segid + end + flag exclude * include bond impr end + minimize powell nstep=50 drop=10.0 nprint=10 end + flag include angle end + minimize powell nstep=50 drop=10.0 nprint=10 end + flag include vdw end + minimize powell nstep=50 drop=10.0 nprint=10 end + end if + + end loop ltod + + fix selection=( none ) end + + flag incl noe cdih end + print threshold=0.3 noe + print threshold=5. cdih + + energy end + + print threshold=0.3 noe + print threshold=5. cdih + print thres=0.02 bonds + print thres=5. angles + flag excl noe cdih end + +end if + +do (store2=0) (all) +for $id in id (tag and name BB) loop cgmodel + do (store2=1) (byres(id $id)) +end loop cgmodel + +fix sele=(attr store2 = 0) end +minimize powell nstep=50 drop=40.0 nprint=10 end + +fix selection=( none ) end diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/check_coordinates.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/check_coordinates.cns new file mode 100644 index 0000000000000000000000000000000000000000..d23c8e64804060c61ff6aeea38925dc8e61dc8d6 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/check_coordinates.cns @@ -0,0 +1,100 @@ +! check_coordinates.cns +! Check max/min coordinates for compatibility with PDB format +! +! *********************************************************************** +! * Copyright 2025 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +evaluate ($failure = false) + +!check for coordinates >9999.999 (max writable in PDB format) + +show max (x) (all) +evaluate ($maxcoor = $result) +show max (y) (all) +if ($result gt $maxcoor) then + evaluate ($maxcoor = $result) +end if +show max (z) (all) +if ($result gt $maxcoor) then + evaluate ($maxcoor = $result) +end if +if ($maxcoor gt 9999.999) then + evaluate ($failure = true) +end if + +!check for coordinates <-999.999 (min writable in PDB format) + +show min (x) (all) +evaluate ($mincoor = $result) +show min (y) (all) +if ($result lt $mincoor) then + evaluate ($maxcoor = $result) +end if +show min (z) (all) +if ($result lt $mincoor) then + evaluate ($mincoor = $result) +end if +if ($mincoor lt -999.999) then + evaluate ($failure = true) +end if + +!if problem detected try correcting it by centering the system around 4500,4500,4500 +!but only if no EM restraints are used + +if ($failure eq true) then + if ($data.flags.em eq false) then + + evaluate ($xc = 0.0) + evaluate ($yc = 0.0) + evaluate ($zc = 0.0) + show ave (x) (all) + evaluate ($xc = 4500 - $result) + show ave (y) (all) + evaluate ($yc = 4500 - $result) + show ave (z) (all) + evaluate ($zc = 4500 -$result) + + do (x = x + $xc) (all) + do (y = y + $yc) (all) + do (z = z + $zc) (all) + + evaluate ($failure = false) + evaluate ($maxcoor = -999) + evaluate ($mincoor = 9999) + !check again for coordinates >9999.999 (max writable in PDB format) + show max (x) (all) + evaluate ($maxcoor = $result) + show max (y) (all) + if ($result gt $maxcoor) then + evaluate ($maxcoor = $result) + end if + show max (z) (all) + if ($result gt $maxcoor) then + evaluate ($maxcoor = $result) + end if + if ($maxcoor gt 9999.999) then + evaluate ($failure = true) + end if + + !check for coordinates <-999.999 (min writable in PDB format) + show min (x) (all) + evaluate ($mincoor = $result) + show min (y) (all) + if ($result lt $mincoor) then + evaluate ($maxcoor = $result) + end if + show min (z) (all) + if ($result lt $mincoor) then + evaluate ($mincoor = $result) + end if + if ($mincoor lt -999.999) then + evaluate ($failure = true) + end if + end if +end if + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/coval-ace-cys.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/coval-ace-cys.cns new file mode 100644 index 0000000000000000000000000000000000000000..0536f6d8c1bc11b85d3a1448b7991cfc504ef11a --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/coval-ace-cys.cns @@ -0,0 +1,57 @@ +! coval-ace-cys.cns +! Add a covalent bond between an acetylated Nter and a cysteine sulphur +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +for $id1 in id ( name CA and resn ACE ) loop ace + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + show (resname) (id $id1) + evaluate ($resname1=$result) + show (name) (id $id1) + evaluate ($name1=$result) + show (chem) (id $id1) + evaluate ($chem1=$result) + + evaluate ($mindis = 3.0) + evaluate ($minid = 0) + for $id2 in id ( name SG and (id $id1) around 3.0 and + (resn CYS or resn CYF) ) loop search + + pick bond (id $id1) (id $id2) geometry + + if ( $result < $mindis) then + evaluate ($mindis = $result) + evaluate ($minid = $id2) + end if + + end loop search + + if ($minid > 0) then + show (segid) (id $minid) + evaluate ($segid2=$result) + show (resid) (id $minid) + evaluate ($resid2=$result) + show (resname) (id $minid) + evaluate ($resname2=$result) + show (name) (id $minid) + evaluate ($name2=$result) + show (chem) (id $minid) + evaluate ($chem2=$result) + + evaluate ($pat1 = "1"+$name1) + evaluate ($pat2 = "2"+$name2) + patch accy refe=1=(resid $resid1 and segid $segid1) refe=2=(resid $resid2 and segid $segid2) end + display COVAL-ACE-CYS: ADDED ONE COVALENT BOND BETWEEN $name1 $resid1 AND $name2 $resname2 $resid2 + end if + +end loop ace diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/covalheme.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/covalheme.cns new file mode 100644 index 0000000000000000000000000000000000000000..e286d3af81d9347edb2ad1ff9df526225f1df137 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/covalheme.cns @@ -0,0 +1,125 @@ +! covalheme.cns +! Add a covalent bond between a hemeC and a cysteine +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +evaluate ($ncac = 0) +for $id1 in id ( name CAC and resn HEC ) loop heme1 + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + show (resname) (id $id1) + evaluate ($resname1=$result) + show (name) (id $id1) + evaluate ($name1=$result) + + evaluate ($mindis = 4.0) + evaluate ($minid = 0) + for $id2 in id ( name SG and (id $id1) around 4.0 and (resn CYS or resn CYF) ) loop search + pick bond (id $id1) (id $id2) geometry + if ( $result < $mindis) then + evaluate ($mindis = $result) + evaluate ($minid = $id2) + end if + end loop search + + if ($minid > 0) then + evaluate ($ncac = $ncac + 1) + show (segid) (id $minid) + evaluate ($segid2=$result) + show (resid) (id $minid) + evaluate ($resid2=$result) + show (resname) (id $minid) + evaluate ($resname2=$result) + show (name) (id $minid) + evaluate ($name2=$result) + + evaluate ($seg1.$ncac=$segid1) + evaluate ($seg2.$ncac=$segid2) + evaluate ($res1.$ncac=$resid1) + evaluate ($res2.$ncac=$resid2) + end if + +end loop heme1 + +evaluate ($counter=1) +while ( $counter <= $ncac ) loop ncac + + patch phcc + refe=2=(resid $res1.$counter and segid $seg1.$counter) + refe=1=(resid $res2.$counter and segid $seg2.$counter) + end + buffer message + display COVALHEME: ADDED ONE COVALENT BOND BETWEEN $name1 $resid1 AND $name2 $resname2 $resid2 + end + evaluate ($counter=$counter+1) +end loop ncac + + +evaluate ($ncab = 0) +for $id1 in id ( name CAB and resn HEC ) loop heme2 + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + show (resname) (id $id1) + evaluate ($resname1=$result) + show (name) (id $id1) + evaluate ($name1=$result) + + evaluate ($mindis = 4.0) + evaluate ($minid = 0) + for $id2 in id ( name SG and (id $id1) around 4.0 and + (resn CYS or resn CYF) ) loop search + + pick bond (id $id1) (id $id2) geometry + + if ( $result < $mindis) then + evaluate ($mindis = $result) + evaluate ($minid = $id2) + end if + + end loop search + + if ($minid > 0) then + evaluate ($ncab = $ncab + 1) + show (segid) (id $minid) + evaluate ($segid2=$result) + show (resid) (id $minid) + evaluate ($resid2=$result) + show (resname) (id $minid) + evaluate ($resname2=$result) + show (name) (id $minid) + evaluate ($name2=$result) + + evaluate ($seg1.$ncab=$segid1) + evaluate ($seg2.$ncab=$segid2) + evaluate ($res1.$ncab=$resid1) + evaluate ($res2.$ncab=$resid2) + end if + +end loop heme2 + +evaluate ($counter=1) +while ( $counter <= $ncab ) loop ncab + + patch phcb + refe=2=(resid $res1.$counter and segid $seg1.$counter) + refe=1=(resid $res2.$counter and segid $seg2.$counter) + end + buffer message + display COVALHEME: ADDED ONE COVALENT BOND BETWEEN $name1 $resid1 AND $name2 $resname2 $resid2 + end + evaluate ($counter=$counter+1) + +end loop ncab + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/dna_break.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/dna_break.cns new file mode 100644 index 0000000000000000000000000000000000000000..fe6db19316d2ee2b96578db3226809cc602bc280 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/dna_break.cns @@ -0,0 +1,82 @@ +! dna_break.cns +! Check for DNA chain breaks +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! + +evaluate ($dbreak=0) + +for $id1 in id ( name O5' and bondedto(name C5') ) loop dbreak + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + show (resn) (id $id1) + evaluate ($resn1=$result) + + show sum(1) (id $id1) + if ( $result = 0 ) then + display unknown coordinates for segid $segid1 resn $resn1 resid $resid1 name O5' + display this coordinate must be known for automatic dna chain break detection + abort + end if + + identity (store1) ( name O3' and bondedto( segid $segid1 and resid $resid1 and name P ) ) + + if ( $select = 1 ) then + show element (store1) (attribute store1 > 0) + evaluate ($id2=$result) + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + show (resn) (id $id2) + evaluate ($resn2=$result) + + show sum(1) (id $id2) + if ( $result = 0 ) then + display unknown coordinates for segid $segid2 resn $resn2 resid $resid2 name O3' + display this coordinate must be known for automatic dna chain break detection + abort + end if + + pick bond + (name P and segid $segid1 and resid $resid1) + (name O3' and segid $segid2 and resid $resid2) + geometry + + if ( $result > &dbreak_cutoff ) then + evaluate ($dbreak=$dbreak+1) + evaluate ($seg1.$dbreak=$segid2) + evaluate ($res1.$dbreak=$resid2) + evaluate ($seg2.$dbreak=$segid1) + evaluate ($res2.$dbreak=$resid1) + evaluate ($patch.$dbreak=DNUC) + end if + end if + +end loop dbreak + +evaluate ($counter=1) + +while ($counter <= $dbreak) loop delete + patch $patch.$counter + reference=-=(segid $seg1.$counter and resid $res1.$counter) + reference=+=(segid $seg2.$counter and resid $res2.$counter) + end + buffer message + display dna link removed (applied $patch.$counter): from \ +$seg1.$counter[a4] $res1.$counter[a4] to $seg2.$counter[a4] $res2.$counter[a4] + end + evaluate ($counter=$counter+1) +end loop delete + + + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/generate-topology.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/generate-topology.cns new file mode 100644 index 0000000000000000000000000000000000000000..3b08ca865dd28955798476c961e180a2b8adb91e --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/generate-topology.cns @@ -0,0 +1,775 @@ +! generate-topology.inp +! Generates missing coordinates and topology +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * Originally adapted from Aria 1.2 from Nilges and Linge, EMBL. * +! * and from the CNS distriution of Brunger and Adams * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** + +define( + +{============================== important =================================} + +{* Different chains in the structure must have either unique segid or + chainid records. If this is no the case, the end of a chain must + be delimited by a TER card. *} + +{* A break in a chain can be detected automatically or should be delimited + by a BREAK card. In this case no patch (head, tail or link) will be + applied between the residues that bound the chain break. *} + +{* NB. The input PDB file must finish with an END statement *} + +{* convert chainid to segid if chainid is non-blank *} +{+ choice: true false +} +{===>} convert=true; + +{* separate chains by segid - a new segid starts a new chain *} +{+ choice: true false +} +{===>} separate=true; +{============================ renaming atoms ===============================} + +{* some atoms may need to be renamed in the topology database to conform + to what is present in the coordinate file *} + +{* delta carbon in isoleucine is named CD in CNS + what is it currently called in the coordinate file? *} +{* this will not be changed if left blank *} +{===>} ile_CD_becomes="CD1"; + +{* terminal oxygens are named OT1 and OT2 in CNS + what are they currently called in the coordinate file? *} +{* these will not be changed if left blank *} +{===>} OT1_becomes="O"; +{===>} OT2_becomes="OXT"; + +{======================= automatic mainchain breaks ========================} + +{* automatically detect mainchain breaks in proteins based on distance *} +{* the peptide link at break points will be removed *} +{+ choice: true false +} +{===>} auto_break=true; + +{* cutoff distance in Angstroms for identification of breaks *} +{* the default of 2.5A for peptide bonds should be reasonable for most cases. If the input + structure has bad geometry it may be necessary to increase this distance *} +{===>} pbreak_cutoff=3.5; +{===>} pcgbreak_cutoff=8.0; +{* the default of 2.5A for nucleic acid linkages should be reasonable for most cases. If the input + structure has bad geometry it may be necessary to increase this distance *} +{===>} dbreak_cutoff=4.5; + +{* file containing patches to delete nucleic acid links *} +{===>} dna_break_infile="TOPPAR:dna_break.top"; + +{======================= automatic disulphide bonds ========================} + +{* cutoff distance in Angstroms for identification of disulphides *} +{* the default of 3.0A should be reasonable for most cases. If the input + structure has bad geometry it may be necessary to increase this distance *} +{===>} disulphide_dist=3.0; + +{======================= automatic cyclic peptidic bond ====================} + +{* cutoff distance in Angstroms for identification of cyclic peptide*} +{* the default of 2.0A should be reasonable for most cases. If the input + structure has bad geometry it may be necessary to increase this distance *} +{===>} cyclicpept_dist=2.0; + +{======================= automatic iron cluster bonds ======================} + +{* cutoff distance in Angstroms for identification of iron cluster bonds *} +{* the default of 8.0A should be reasonable for most cases. If the input + structure has bad geometry it may be necessary to increase this distance *} +{===>} iron1cluster_dist=5.0; +{===>} iron2cluster_dist=8.0; + +{======================= automatic cis peptide bonds =======================} + +{* select atoms to be included in calculation of omega angles *} +{* to define cis peptides*} +{===>} atom_select=(known and not hydrogen); + +{========================= generate parameters =============================} + +{* hydrogen flag - determines whether hydrogens will be output *} +{* must be true for NMR, atomic resolution X-ray crystallography + or modelling. Set to false for most X-ray crystallographic + applications at resolution > 1A *} +{+ choice: true false +} +{===>} hydrogen_flag=true; + +{* which hydrogens to build *} +{+ choice: "all" "unknown" +} +{===>} hydrogen_build="all"; + +{* selection of atoms other than hydrogens for which coordinates + will be generated *} +{* to generate coordinates for all unknown atoms use: (not(known)) *} +{===>} atom_build=(not(known)); + +{* selection of atoms to be deleted *} +{* to delete no atoms use: (none) *} +{===>} atom_delete=(none); + +{* set bfactor value *} +{===>} bfactor=15.0; + +{* set occupancy flag *} +{+ choice: true false +} +{===>} set_occupancy=false; + +{* set occupancy value *} +{===>} occupancy=1.0; + +{================== protein topology and parameter files ===================} + +{* protein topology file *} +{===>} prot_topology_infile="TOPPAR:protein-allhdg5-4.top"; + +{* protein parameter file *} +{===>} prot_parameter_infile="TOPPAR:protein-allhdg5-4.param"; + +{================ nucleic acid topology and parameter files =================} + +{* nucleic acid topology file *} +{===>} nucl_topology_infile="TOPPAR:dna-rna-allatom-hj-opls-1.3.top"; + +{* nucleic acid parameter file *} +{===>} nucl_parameter_infile="TOPPAR:dna-rna-allatom-hj-opls-1.3.param"; + +{================= carbohydrate topology and parameter files ===============} + +{* carbohydrate topology file *} +{===>} carbo_topology_infile="TOPPAR:carbohydrate.top"; + +{* carbohydrate parameter file *} +{===>} carbo_parameter_infile="TOPPAR:carbohydrate.param"; + +{================= solvent topology and parameter files ====================} + +{* solvent topology file *} +{===>} solv_topology_infile="TOPPAR:solvent-allhdg5-4.top"; + +{* solvent parameter file *} +{===>} solv_parameter_infile="TOPPAR:solvent-allhdg5-4.param"; + +{================= cofactor topology and parameter files ===================} + +{* co-factor topology file *} +{===>} cofactors_topology_infile="TOPPAR:cofactors.top"; + +{* co-factor parameter file *} +{===>} cofactors_parameter_infile="TOPPAR:cofactors.param"; + + +{================= known ligands topology and parameter files ==============} + +{* ligands topology file *} +{===>} ligands_topology_infile="TOPPAR:fragment_probes.top"; + +{* ligands parameter file *} +{===>} ligands_parameter_infile="TOPPAR:fragment_probes.param"; + +{===================== ion topology and parameter files ====================} + +{* ion topology file *} +{===>} ion_topology_infile="TOPPAR:ion.top"; + +{* ion parameter file *} +{===>} ion_parameter_infile="TOPPAR:ion.param"; + +{===================== heme topology and parameter files ==================} + +{* heme topology file *} +{===>} heme_topology_infile="TOPPAR:hemes-allhdg.top"; + +{* heme parameter file *} +{===>} heme_parameter_infile="TOPPAR:hemes-allhdg.param"; + +{================= shape topology and parameter files =====================} + +{* shape topology file *} +{===>} shape_topology_infile="TOPPAR:shape.top"; + +{* shape parameter file *} +{===>} shape_parameter_infile="TOPPAR:shape.param"; + +{===================== default number of histidines for patching ===========} + + ) {- end block parameter definition -} + +evaluate ($chain = 1) +evaluate($coor_infile= $file) + +topology + if ( &BLANK%prot_topology_infile = false ) then + @@&prot_topology_infile + end if + if ( &BLANK%cofactors_topology_infile = false ) then + @@&cofactors_topology_infile + end if + if ( &BLANK%ion_topology_infile = false ) then + @@&ion_topology_infile + end if + if ( &BLANK%nucl_topology_infile = false ) then + @@&nucl_topology_infile + end if + if ( &BLANK%carbo_topology_infile = false ) then + @@&carbo_topology_infile + end if + if ( &BLANK%solv_topology_infile = false ) then + @@&solv_topology_infile + end if + if ( &BLANK%heme_topology_infile = false ) then + @@&heme_topology_infile + end if + if ( &BLANK%shape_topology_infile = false ) then + @@&shape_topology_infile + end if + if ( &BLANK%dna_break_infile = false ) then + @@&dna_break_infile + end if + if ($ligand_top_fname # "") then + fileexist $ligand_top_fname end + if ($result eq true) then + @@$ligand_top_fname + end if + end if +end + +parameter + if ( &BLANK%prot_parameter_infile = false ) then + @@&prot_parameter_infile + end if + if ( &BLANK%cofactors_parameter_infile = false ) then + @@&cofactors_parameter_infile + end if + if ( &BLANK%ion_parameter_infile = false ) then + @@&ion_parameter_infile + end if + if ( &BLANK%nucl_parameter_infile = false ) then + @@&nucl_parameter_infile + end if + if ( &BLANK%carbo_parameter_infile = false ) then + @@&carbo_parameter_infile + end if + if ( &BLANK%solv_parameter_infile = false ) then + @@&solv_parameter_infile + end if + if ( &BLANK%heme_parameter_infile = false ) then + @@&heme_parameter_infile + end if + if ( &BLANK%shape_parameter_infile = false ) then + @@&shape_parameter_infile + end if + if ($ligand_param_fname # "") then + fileexist $ligand_param_fname end + if ($result eq true) then + @@$ligand_param_fname + end if + end if +end + +segment + chain + if ( &convert = true ) then + convert=true + end if + if ( &separate = true ) then + separate=true + end if + @@$prot_link_infile + @@$nucl_link_infile + if ( &BLANK%carbo_link_infile = false ) then + @@&carbo_link_infile + end if + coordinates @@$coor_infile + end +end + +coordinates @@$coor_infile + +! next line to remove the MAP atom defined in the DUM residue +! in case of use of dummy particles +delete sele=(name MAP) end + +if ( &BLANK%ile_CD_becomes = false ) then + do (name=&ile_CD_becomes) (resn ILE and name CD) +end if +if ( &BLANK%OT1_becomes = false ) then + do (name=&OT1_becomes) (name OT1) +end if +if ( &BLANK%OT2_becomes = false ) then + do (name=&OT2_becomes) (name OT2) +end if + +!for the histidine patches: +if ($autohis = false) then + evaluate($hisd_counter=1) + while ($hisd_counter le $nhisd) loop hisd + show (resn) (tag and resid $hisd_$hisd_counter) + if ($result eq "HIS") then + patch hisd reference=nil=(resid $hisd_$hisd_counter) end + end if + evaluate($hisd_counter=$hisd_counter + 1) + end loop hisd + + evaluate($hise_counter=1) + while ($hise_counter le $nhise) loop hise + show (resn) (tag and resid $hise_$hise_counter) + if ($result eq "HIS") then + patch hise reference=nil=(resid $hise_$hise_counter) end + end if + evaluate($hise_counter=$hise_counter + 1) + end loop hise +end if + +! The following patches would define covalent bond between a CA+2 and oxygen ligands +! from Asp and Glu (first selection is amino-acid, second is ion) +! patch dca2 refe=1=(resid 25) refe=2=(resid 83) end +! patch dca2 refe=1=(resid 29) refe=2=(resid 83) end +! patch dca2 refe=1=(resid 35) refe=2=(resid 83) end +! patch eca2 refe=1=(resid 36) refe=2=(resid 83) end +! +! following patch is to attach a heme (resid YY) CAB atom to a cys (resid XX) +! patch phcb refe=1=(resid XX) refe=2=(resid YY) end +! following patch is to attach a heme (resid YY) CAC atom to a cys (resid XX) +! patch phcc refe=1=(resid XX) refe=2=(resid YY) end +! +! following patch is to define an isopeptide bond between a Cter and a Lys side-chain +! patch clys refe=1=(resid 72) refe=2=(resid 148) end +! +! following patch is to define an isopeptide bond between a Cter and a Lys side-chain +! patch clys refe=1=(resid 72) refe=2=(resid 148) end + +! N-linked glycosylation patches +inline @MODULE:bondglycans.cns + +if ($delenph = true) then + delete sele=(name H* and attr charge = 0) end +end if + +set seed=$iniseed end + +show sum(1) ( not(hydrogen) and not(known) ) +if ( $select = 0 ) then + display %INFO: There are no coordinates missing for non-hydrogen atoms +end if + +if ( $log_level = "verbose" ) then + set message=all echo=on end +elseif ( $log_level = "normal") then + set message=normal echo=off end +else + set message=off echo=off end +end if + +inline @MODULE:build-missing.cns + +if ( &auto_break = true ) then + inline @MODULE:prot_break.cns + inline @MODULE:dna_break.cns +end if + + +! checkfor disulphide bonds + +evaluate ($disu=0) + +for $id1 in id ( resn CYS and name SG ) loop dis1 + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + + identity (store9) (all) + + for $id2 in id ( resn CYS and name SG and + ( attr store9 > $id1 ) ) loop dis2 + + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + + pick bond (id $id1) (id $id2) geometry + + if ( $result <= $disulphide_dist ) then + evaluate ($disu=$disu+1) + evaluate ($seg1.$disu=$segid1) + evaluate ($seg2.$disu=$segid2) + evaluate ($res1.$disu=$resid1) + evaluate ($res2.$disu=$resid2) + end if + + end loop dis2 +end loop dis1 + +evaluate ($counter=1) +while ( $counter <= $disu ) loop disu + patch disu + reference=1=(segid $seg1.$counter and resid $res1.$counter) + reference=2=(segid $seg2.$counter and resid $res2.$counter) + end + buffer message + display disulphide added: from \ +$seg1.$counter[a4] $res1.$counter[a4] to $seg2.$counter[a4] $res2.$counter[a4] + end + evaluate ($counter=$counter+1) +end loop disu + + +! check for cyclid peptidic bonds + +if ($cyclicpept eq TRUE ) then + + evaluate ($cycp=0) + + for $id1 in id ( tag and name N ) loop cyp1 + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + show (resn) (id $id1) + evaluate ($resn1=$result) + + for $id2 in id ( name C and bondedto (name O and not resid $resid1 ) ) loop cyp2 + + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + show (resn) (id $id2) + evaluate ($resn2=$result) + + evaluate ($rdiff = decode($resid2) - decode($resid1)) + + if ($rdiff gt 2) then + + pick bond (id $id1) (id $id2) geometry + if ( $result <= $cyclicpept_dist ) then + evaluate ($cycp=$cycp+1) + evaluate ($seg1.$cycp=$segid1) + evaluate ($seg2.$cycp=$segid2) + evaluate ($res1.$cycp=$resid1) + evaluate ($res2.$cycp=$resid2) + evaluate ($rsn1.$cycp=$resn1) + evaluate ($rsn2.$cycp=$resn2) + end if + + end if + + end loop cyp2 + + end loop cyp1 + + evaluate ($counter=1) + + while ( $counter <= $cycp ) loop cypep + + evaluate ($ptype = PEPT) + evaluate ($patchdone = 0) + if ( $rsn2.$counter eq GLY) then + if ($rsn1.$counter eq PRO) then + evaluate ($ptype = PPGP) + evaluate ($patchdone = 1) + end if + if ($rsn1.$counter eq GLY) then + evaluate ($ptype = PPGG) + evaluate ($patchdone = 1) + end if + if ($patchdone eq 0) then + evaluate ($ptype = PPG1) + end if + else + if ($rsn1.$counter eq PRO) then + evaluate ($ptype = PEPP) + end if + if ($rsn1.$counter eq GLY) then + evaluate ($ptype = PPG2) + end if + end if + + patch $ptype + reference=+=(segid $seg1.$counter and resid $res1.$counter) + reference=-=(segid $seg2.$counter and resid $res2.$counter) + end + + buffer message + display cyclic peptide detected: peptidic bond added between \ +$seg1.$counter[a4] $res1.$counter[a4] and $seg2.$counter[a4] $res2.$counter[a4] + end + evaluate ($counter=$counter+1) + end loop cypep + +end if ! check for cyclic peptide + + +! check for covalently-linked hemeC + +inline @MODULE:covalheme.cns + + +! check for covalently-linked Acetylated Nter to CYS + +inline @MODULE:coval-ace-cys.cns + +evaluate ($ironclus=0) + +! check for FE1 bonds in iron cluster +for $id1 in id ( resname CFE and name SG ) loop fes1 + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + + identity (store9) (all) + + for $id2 in id ( resname CYF and name SG ) loop fes2 + + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + + pick bond (id $id1) (id $id2) geometry + + if ( $result <= &iron1cluster_dist ) then + evaluate ($ironclus=$ironclus+1) + evaluate ($seg1.$ironclus=$segid1) + evaluate ($seg2.$ironclus=$segid2) + evaluate ($res1.$ironclus=$resid1) + evaluate ($res2.$ironclus=$resid2) + end if + + end loop fes2 + +end loop fes1 + +evaluate ($counter=1) +while ( $counter <= $ironclus ) loop iron1 + patch sef1 + reference=1=(segid $seg1.$counter and resid $res1.$counter) + reference=2=(segid $seg2.$counter and resid $res2.$counter) + end + buffer message + display iron FE1 sulphur bond added: from $seg1.$counter[a4] $res1.$counter[a4] to $seg2.$counter[a4] $res2.$counter[a4] + end + evaluate ($counter=$counter+1) +end loop iron1 + +evaluate ($ironclus=0) + +! check for FE2 bonds in iron cluster +for $id1 in id ( resname CFE and name SG ) loop fes1 + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + + identity (store9) (all) + + for $id2 in id ( resname CYF and name SG ) loop fes2 + + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + + pick bond (id $id1) (id $id2) geometry + + if ( $result <= &iron2cluster_dist ) then + if ($result > &iron1cluster_dist ) then + evaluate ($ironclus=$ironclus+1) + evaluate ($seg1.$ironclus=$segid1) + evaluate ($seg2.$ironclus=$segid2) + evaluate ($res1.$ironclus=$resid1) + evaluate ($res2.$ironclus=$resid2) + end if + end if + + end loop fes2 + +end loop fes1 + +evaluate ($counter=1) +while ( $counter <= $ironclus ) loop iron2 + patch sef2 + reference=1=(segid $seg1.$counter and resid $res1.$counter) + reference=2=(segid $seg2.$counter and resid $res2.$counter) + end + buffer message + display iron FE2 sulphur bond added: from $seg1.$counter[a4] $res1.$counter[a4] to $seg2.$counter[a4] $res2.$counter[a4] + end + evaluate ($counter=$counter+1) +end loop iron2 + + +! Check for cis-PRO + +for $id in id ( &atom_select and name ca and resn PRO) loop cisp + + show (segid) (id $id) + evaluate ($segid=$result) + show (resid) (id $id) + evaluate ($resid=$result) + show (resn) (id $id) + evaluate ($resn=$result) + + identity (store9) ( &atom_select and ( name c and bondedto + ( name n and resid $resid and segid $segid ) ) ) + if ( $select = 1 ) then + show element (store9) (attribute store9 > 0) + evaluate ($id_prev=$result) + show (segid) (id $id_prev) + evaluate ($segid_prev=$result) + show (resid) (id $id_prev) + evaluate ($resid_prev=$result) + show (resn) (id $id_prev) + evaluate ($resn_prev=$result) + + pick dihedral + (name ca and segid $segid_prev and resid $resid_prev) + (name c and segid $segid_prev and resid $resid_prev) + (name n and segid $segid and resid $resid) + (name ca and segid $segid and resid $resid) + geometry + + evaluate ($dihedral=mod($result+360,360)) + + if ( $dihedral > 180 ) then + evaluate ($dihedral=$dihedral-360) + end if + + evaluate ($absdihedral=abs($dihedral)) + + if ( $absdihedral < 25 ) then + patch cisp reference=NIL=(segid $segid_prev and resid $resid_prev) end + display CIS peptide bon detected for residue $resid_prev + end if + + end if + +end loop cisp + +if (&hydrogen_flag=false) then + delete selection=( hydrogen ) end +end if + +delete selection=( &atom_delete ) end + +!check for histidine protonation state if auto mode on +if ($autohis = true) then + inline @MODULE:auto-his.cns +end if + +energy end +evaluate ($bonded = $bond + $angl + $impr) +if ($bonded > 10000) then + minimize powell nstep=100 drop=10.0 nprint=10 end + energy end + evaluate ($bonded = $bond + $angl + $impr) +end if +if ($bonded > 10000) then + evaluate ($dispfile = $output_pdb_filename - ".pdb" + ".warn") + set display=$dispfile end + display WARNING: the bonded energy is very high: + display Ebonded-total=$bonded Ebond=$bond Eangl=$angl Eimpr=$impr + display Something is possibly wrong with your input structure + close $dispfile end +end if + +show sum(1) (not(known)) +if ( $result < 100 ) then + for $id in id (not(known)) loop print + show (segid) (id $id) + evaluate ($segid=$result) + show (resn) (id $id) + evaluate ($resn=$result) + show (resid) (id $id) + evaluate ($resid=$result) + show (name) (id $id) + evaluate ($name=$result) + buffer message + display unknown coordinates for atom: $segid[a4] $resn[a4] $resid[a4] $name[a4] + end + end loop print +else + buffer message + display unknown coordinates for more than 100 atoms + end +end if + +if ($set_bfactor=true) then + do (b=&bfactor) ( all ) +end if + +if (&set_occupancy=true) then + if (&set_occupancy=true) then + do (q=&occupancy) ( all ) + end if +else + if (&set_occupancy=true) then + do (q=&occupancy) ( not(store9) ) + do (q=0.0) (store9) + end if +end if + +show sum(1) (store9) +if ( $result < 100 ) then + for $id in id (store9) loop print + show (segid) (id $id) + evaluate ($segid=$result) + show (resn) (id $id) + evaluate ($resn=$result) + show (resid) (id $id) + evaluate ($resid=$result) + show (name) (id $id) + evaluate ($name=$result) + buffer message + display coordinates built for atom: $segid[a4] $resn[a4] $resid[a4] $name[a4] + end + end loop print +else + buffer message + display coordinates built for more than 100 hundred atoms + end +end if + +set remarks=reset end + +buffer message + to=remarks + dump +end +buffer message reset end + +inline @MODULE:check_coordinates.cns + +if ($failure eq true) then + evaluate ($failfile = $output_pdb_filename - ".pdb" + ".fail") + set display=$failfile end + display "MAX/MIN possible coordinates exceeded - stopping" + close $failfile end + stop +else + write structure output=$output_psf_filename end + write coordinates format=pdbo output=$output_pdb_filename end +end if + +display OUTPUT: $output_pdb_filename +display OUTPUT: $output_psf_filename + +stop + + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/patch-bb-cg.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/patch-bb-cg.cns new file mode 100644 index 0000000000000000000000000000000000000000..6531a087c13f9b9f350a96b8b70d2472d64ffee5 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/patch-bb-cg.cns @@ -0,0 +1,240 @@ +! patch-bb-cg.cns +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * Originally adapted from Aria 1.2 from Nilges and Linge, EMBL. * +! * and from the CNS distriution of Brunger and Adams * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +! define cutoff for chain break +evaluate ($bdbreak = 8.0) + +! encode beads info +evaluate ($bdnum = 0) +for $id in id (name BB) loop cg1 + evaluate ($bdnum = $bdnum + 1) + show (name) (id $id) + evaluate ($bdname_$bdnum = $result) + show (resid) (id $id) + evaluate ($bdresi_$bdnum = $result) + show (name) (bondedto (name $bdname_$bdnum and resid $bdresi_$bdnum)) + if ($result NE 0) then + evaluate ($sbdname_$bdnum = $result) + else + evaluate ($sbdname_$bdnum = "XXX") + end if +end loop cg1 + + +!!! BBB Angles + +evaluate ($ncount = 0) +evaluate ($nend = $bdnum - 2) +while ($ncount < $nend) loop cg2 + evaluate ($ncount = $ncount + 1) + + ! define three consecutive backbone beads + evaluate ($nat1 = $ncount) + evaluate ($nat2 = $ncount + 1) + evaluate ($nat3 = $ncount + 2) + + ! get their atom names + evaluate ($bname1 = $bdname_$nat1) + evaluate ($bname2 = $bdname_$nat2) + evaluate ($bname3 = $bdname_$nat3) + + ! get their residue number + evaluate ($bresi1 = $bdresi_$nat1) + evaluate ($bresi2 = $bdresi_$nat2) + evaluate ($bresi3 = $bdresi_$nat3) + + ! define atom names for patch + evaluate ($pat1 = "1"+$bname1) + evaluate ($pat2 = "2"+$bname2) + evaluate ($pat3 = "3"+$bname3) + + ! check for breaks before defining any angle + evaluate ($break = "FALSE") + pick bond (name $bname1 and resid $bresi1) (name $bname2 and resid $bresi2) geometry + if ($result > $bdbreak) then + evaluate ($break = "TRUE") + end if + pick bond (name $bname2 and resid $bresi2) (name $bname3 and resid $bresi3) geometry + if ($result > $bdbreak) then + evaluate ($break = "TRUE") + end if + + if ($break EQ FALSE) then + + ! define new backbone angle patch + topology + presidue cgang ! Patch to add an angle between three beads + add angle $pat1 $pat2 $pat3 + end + end + + ! apply new patch to the selected three beads + patch cgang refe=1=(resid $bresi1) refe=2=(resid $bresi2) refe=3=(resid $bresi3) end + display PATCH-BB-CG: ADDED ONE ANGLE BETWEEN $bname1 $bresi1 , $bname2 $bresi2 , $bname3 $bresi3 + + end if + +end loop cg2 + + +!!! BBS Angles +evaluate ($ncount = 0) +evaluate ($nend = $bdnum - 1) +while ($ncount < $nend) loop cg3 + evaluate ($ncount = $ncount + 1) + + !! BBA Angles + ! define two consecutive backbone beads + evaluate ($nat1 = $ncount) + evaluate ($nat2 = $ncount + 1) + + ! get their atom names + evaluate ($bname1 = $bdname_$nat1) + evaluate ($bname2 = $bdname_$nat2) + + ! get their side-chain beads names + evaluate ($sbname1 = $sbdname_$nat1) + evaluate ($sbname2 = $sbdname_$nat2) + + ! get their residue number + evaluate ($bresi1 = $bdresi_$nat1) + evaluate ($bresi2 = $bdresi_$nat2) + + ! define atom names for patch + evaluate ($pat1 = "1"+$bname1) + evaluate ($pat2 = "2"+$bname2) + evaluate ($pas1 = "1"+$sbname1) + evaluate ($pas2 = "2"+$sbname2) + + ! check for breaks before defining any angle + evaluate ($break = "FALSE") + evaluate ($pbreak = "FALSE") + pick bond (name $bname1 and resid $bresi1) (name $bname2 and resid $bresi2) geometry + if ($result > $bdbreak) then + evaluate ($break = "TRUE") + evaluate ($pbreak = "TRUE") + end if + + if ($break EQ FALSE) then + + ! define new side-chain angle patch for 1st residue + if ($ncount EQ 1) then + if ($sbname1 NE "XXX") then + ! define SBB angle patch + topology + presidue scgang ! Patch to add an angle between three beads + add angle $pas1 $pat1 $pat2 + end + end + ! apply new patch to the selected three beads + patch scgang refe=1=(resid $bresi1) refe=2=(resid $bresi1) refe=3=(resid $bresi2) end + display PATCH-SBB-CG: ADDED ONE SIDE-CHAIN/BB ANGLE BETWEEN $sbname1 $bresi1 , $bname1 $bresi1 , $bname2 $bresi2 + end if + end if + + ! define new side-chain angle patch for 1st residue after chain break + if ($pbreak EQ TRUE) then + if ($sbname1 NE "XXX") then + ! define SBB angle patch + topology + presidue scgsang ! Patch to add an angle between three beads + add angle $pas1 $pat1 $pat2 + end + end + ! apply new patch to the selected three beads + patch scgsang refe=1=(resid $bresi1) refe=2=(resid $bresi1) refe=3=(resid $bresi2) end + display PATCH-SBB-CG: ADDED ONE SIDE-CHAIN/BB ANGLE BETWEEN $sbname1 $bresi1 , $bname1 $bresi1 , $bname2 $bresi2 + end if + end if + + ! define BBS angle patch + if ($sbname2 NE "XXX") then + topology + presidue cgsang ! Patch to add an angle between three beads + add angle $pat1 $pat2 $pas2 + end + end + ! apply new patch to the selected three beads + patch cgsang refe=1=(resid $bresi1) refe=2=(resid $bresi2) refe=3=(resid $bresi2) end + display PATCH-BBS-CG: ADDED ONE BB/SIDE-CHAIN ANGLE BETWEEN $bname1 $bresi1 , $bname2 $bresi2 , $sbname2 $bresi2 + end if + + end if + +end loop cg3 + + +!! BBB dihedral + +evaluate ($ncount = 0) +evaluate ($nend = $bdnum - 3) +while ($ncount < $nend) loop cg4 + evaluate ($ncount = $ncount + 1) + + ! define four consecutive beads + evaluate ($nat1 = $ncount) + evaluate ($nat2 = $ncount + 1) + evaluate ($nat3 = $ncount + 2) + evaluate ($nat4 = $ncount + 3) + + ! get their atom names + evaluate ($bname1 = $bdname_$nat1) + evaluate ($bname2 = $bdname_$nat2) + evaluate ($bname3 = $bdname_$nat3) + evaluate ($bname4 = $bdname_$nat4) + + ! get their residue number + evaluate ($bresi1 = $bdresi_$nat1) + evaluate ($bresi2 = $bdresi_$nat2) + evaluate ($bresi3 = $bdresi_$nat3) + evaluate ($bresi4 = $bdresi_$nat4) + + ! define atom names for patch + evaluate ($pat1 = "1"+$bname1) + evaluate ($pat2 = "2"+$bname2) + evaluate ($pat3 = "3"+$bname3) + evaluate ($pat4 = "4"+$bname4) + + evaluate ($break = "FALSE") + ! check for breaks before defining any dihedral + pick bond (name $bname1 and resid $bresi1) (name $bname2 and resid $bresi2) geometry + if ($result > $bdbreak) then + evaluate ($break = "TRUE") + end if + pick bond (name $bname2 and resid $bresi2) (name $bname3 and resid $bresi3) geometry + if ($result > $bdbreak) then + evaluate ($break = "TRUE") + end if + pick bond (name $bname3 and resid $bresi3) (name $bname4 and resid $bresi4) geometry + if ($result > $bdbreak) then + evaluate ($break = "TRUE") + end if + + if ($break EQ FALSE) then + + ! define new patch + topology + presidue cgdihe ! Patch to add a dihedral angle between four beads + add dihedral $pat1 $pat2 $pat3 $pat4 + end + end + + ! apply new patch to the selected four beads + patch cgdihe refe=1=(resid $bresi1) refe=2=(resid $bresi2) refe=3=(resid $bresi3) refe=4=(resid $bresi4) end + display PATCH-BB-CG: ADDED ONE DIHEDRAL BETWEEN $bname1 $bresi1 , $bname2 $bresi2 , $bname3 $bresi3 , $bname4 $bresi4 + + end if + +end loop cg4 + + + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/patch-types-cg.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/patch-types-cg.cns new file mode 100644 index 0000000000000000000000000000000000000000..97d3d69b6d361ef1c5b145c7254373b9228740c7 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/patch-types-cg.cns @@ -0,0 +1,83 @@ +! patch-types-cg.cns +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * Originally adapted from Aria 1.2 from Nilges and Linge, EMBL. * +! * and from the CNS distriution of Brunger and Adams * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +! encode beads info +evaluate ($bdnum = 0) +for $id in id (name BB and (not (resn ALA or resn PRO or resn HY3 or resn HYP))) loop cgt1 + evaluate ($bdnum = $bdnum + 1) + show (name) (id $id) + evaluate ($bdname_$bdnum = $result) + show (resid) (id $id) + evaluate ($bdresi_$bdnum = $result) + show (b) (id $id) + evaluate ($bfactor_$bdnum = $result) + evaluate ($ptype= "PTY"+encode($bfactor_$bdnum)) + patch $ptype refe=NIL=(resid $bdresi_$bdnum) end +end loop cgt1 + +! encode beads info for ALA +evaluate ($bdnum = 0) +for $id in id (name BB and resn ALA) loop cgt2 + evaluate ($bdnum = $bdnum + 1) + show (name) (id $id) + evaluate ($bdname_$bdnum = $result) + show (resid) (id $id) + evaluate ($bdresi_$bdnum = $result) + show (b) (id $id) + evaluate ($bfactor_$bdnum = $result) + evaluate ($ptype= "PTA"+encode($bfactor_$bdnum)) + patch $ptype refe=NIL=(resid $bdresi_$bdnum) end +end loop cgt2 + +! encode beads info for PRO +evaluate ($bdnum = 0) +for $id in id (name BB and resn PRO) loop cgt3 + evaluate ($bdnum = $bdnum + 1) + show (name) (id $id) + evaluate ($bdname_$bdnum = $result) + show (resid) (id $id) + evaluate ($bdresi_$bdnum = $result) + show (b) (id $id) + evaluate ($bfactor_$bdnum = $result) + evaluate ($ptype= "PTP"+encode($bfactor_$bdnum)) + patch $ptype refe=NIL=(resid $bdresi_$bdnum) end +end loop cgt3 + +! encode beads info for HY3 +evaluate ($bdnum = 0) +for $id in id (name BB and resn HY3) loop cgt4 + evaluate ($bdnum = $bdnum + 1) + show (name) (id $id) + evaluate ($bdname_$bdnum = $result) + show (resid) (id $id) + evaluate ($bdresi_$bdnum = $result) + show (b) (id $id) + evaluate ($bfactor_$bdnum = $result) + evaluate ($ptype= "PTH"+encode($bfactor_$bdnum)) + patch $ptype refe=NIL=(resid $bdresi_$bdnum) end +end loop cgt4 + + +! encode beads info for HYP +evaluate ($bdnum = 0) +for $id in id (name BB and resn HYP) loop cgt4 + evaluate ($bdnum = $bdnum + 1) + show (name) (id $id) + evaluate ($bdname_$bdnum = $result) + show (resid) (id $id) + evaluate ($bdresi_$bdnum = $result) + show (b) (id $id) + evaluate ($bfactor_$bdnum = $result) + evaluate ($ptype= "PTH"+encode($bfactor_$bdnum)) + patch $ptype refe=NIL=(resid $bdresi_$bdnum) end +end loop cgt4 + diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/prot_break.cns b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/prot_break.cns new file mode 100644 index 0000000000000000000000000000000000000000..629d570b5183ce7198620931c7880f1eb739795d --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/cns/prot_break.cns @@ -0,0 +1,141 @@ +! prot_break.cns +! Detect protein chain breaks +! +! *********************************************************************** +! * Copyright 2003-2022 Alexandre Bonvin, Utrecht University. * +! * All rights reserved. * +! * This code is part of the HADDOCK software and governed by its * +! * license. Please see the LICENSE file that should have been included * +! * as part of this package. * +! *********************************************************************** +! +evaluate ($pbreak=0) + +for $id1 in id ( name C and bondedto(name CA) and bondedto(name O) ) loop pbreak + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + show (resn) (id $id1) + evaluate ($resn1=$result) + + show sum(1) (id $id1) + if ( $result = 0 ) then + display unknown coordinates for segid $segid1 resn $resn1 resid $resid1 name C + display this coordinate must be known for automatic protein chain break detection + abort + end if + + identity (store1) ( name N and bondedto( segid $segid1 and resid $resid1 and name c ) ) + + if ( $select = 1 ) then + show element (store1) (attribute store1 > 0) + evaluate ($id2=$result) + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + show (resn) (id $id2) + evaluate ($resn2=$result) + + show sum(1) (id $id2) + if ( $result = 0 ) then + display unknown coordinates for segid $segid2 resn $resn2 resid $resid2 name N + display this coordinate must be known for automatic protein chain break detection + abort + end if + + pick bond + (name c and segid $segid1 and resid $resid1) + (name n and segid $segid2 and resid $resid2) + geometry + + if ( $result > &pbreak_cutoff ) then + evaluate ($pbreak=$pbreak+1) + evaluate ($seg1.$pbreak=$segid1) + evaluate ($res1.$pbreak=$resid1) + evaluate ($seg2.$pbreak=$segid2) + evaluate ($res2.$pbreak=$resid2) + if ( $resn2 = PRO ) then + evaluate ($patch.$pbreak=DPPP) + elseif ( $resn2 = CPR ) then + evaluate ($patch.$pbreak=DPPP) + else + evaluate ($patch.$pbreak=DPEP) + end if + end if + end if + +end loop pbreak + +for $id1 in id ( name BB ) loop cgpbreak + + show (segid) (id $id1) + evaluate ($segid1=$result) + show (resid) (id $id1) + evaluate ($resid1=$result) + show (resn) (id $id1) + evaluate ($resn1=$result) + + show sum(1) (id $id1) + if ( $result = 0 ) then + display unknown coordinates for segid $segid1 resn $resn1 resid $resid1 name BB + display this coordinate must be known for automatic protein chain break detection + abort + end if + + for $id2 in id ( name BB and bondedto( segid $segid1 and resid $resid1 and name BB ) ) loop cg2pbreak + + show (segid) (id $id2) + evaluate ($segid2=$result) + show (resid) (id $id2) + evaluate ($resid2=$result) + show (resn) (id $id2) + evaluate ($resn2=$result) + + show sum(1) (id $id2) + if ( $result = 0 ) then + display unknown coordinates for segid $segid2 resn $resn2 resid $resid2 name BB + display this coordinate must be known for automatic protein chain break detection + abort + end if + + pick bond + (name BB and segid $segid1 and resid $resid1) + (name BB and segid $segid2 and resid $resid2) + geometry + + if ( $result > &pcgbreak_cutoff ) then + evaluate ($pbreak=$pbreak+1) + evaluate ($seg1.$pbreak=$segid1) + evaluate ($res1.$pbreak=$resid1) + evaluate ($seg2.$pbreak=$segid2) + evaluate ($res2.$pbreak=$resid2) + evaluate ($patch.$pbreak=DCGP) + end if + + end loop cg2pbreak + +end loop cgpbreak + +evaluate ($counter=1) + +while ($counter <= $pbreak) loop delete + if ($patch.$counter ne "DCGP") then + patch $patch.$counter + reference=-=(segid $seg1.$counter and resid $res1.$counter) + reference=+=(segid $seg2.$counter and resid $res2.$counter) + end + else + patch $patch.$counter + reference=-=(segid $seg1.$counter and resid $res1.$counter and name BB) + reference=+=(segid $seg2.$counter and resid $res2.$counter and name BB) + end + end if + buffer message + display peptide link removed (applied $patch.$counter): from \ +$seg1.$counter[a4] $res1.$counter[a4] to $seg2.$counter[a4] $res2.$counter[a4] + end + evaluate ($counter=$counter+1) +end loop delete diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/defaults.yaml b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/defaults.yaml new file mode 100644 index 0000000000000000000000000000000000000000..0238b30130548e71471180396470263d0be8ba60 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/haddock/modules/topology/topoaa/defaults.yaml @@ -0,0 +1,239 @@ +autohis: + default: true + type: boolean + title: Automatic HIS protonation state + short: + "The protonation state of histidine (+1: HIS or 0: HISD/HISE) will be automatically + set by HADDOCK" + long: + "If set to true, HADDOCK will automatically define the protonation state of + histidines ((+1: HIS or 0: HISD/HISE) by selecting the state leading to the lowest + electrostatic energy" + group: molecule + explevel: expert +autotoppar: + default: false + type: boolean + title: Automatically generate topologies and parameters for unknown atoms + short: Automatically generate topologies and parameters for unknown atoms + long: Automatically generate topologies and parameters for unknown atoms + group: molecule + explevel: easy +delenph: + default: true + type: boolean + title: Keep or remove non-polar hydrogen atoms + short: + If set to true, non-polar hydrogen atoms will be discarded to save computing + time + long: + Since HADDOCK uses a united atom force field, the non-polar hydrogen atoms + can be in principle discarded. This saves computing time. However this should + not be done if you are defining distance restraints to specific hydrogen atoms + (e.g. when using NMR distance restraints). + group: molecule + explevel: easy +log_level: + default: quiet + type: string + minchars: 0 + maxchars: 100 + choices: + - verbose + - normal + - quiet + title: Log level verbosity for CNS + short: Set the log level verbosity for CNS + long: + CNS, the computational engine used by HADDOCK can generate a lot of output + messages. This parameter controls the verbosity of CNS (verbose, normal or quiet). + group: module + explevel: guru +iniseed: + default: 917 + type: integer + min: 0 + max: 9999999999999999 + title: Random seed + short: Random seed used in CNS to initialize the random seed function + long: Random seed used in CNS to initialize the random seed function + group: molecule + explevel: guru +ligand_param_fname: + default: "" + type: file + title: Custom ligand parameter file + short: Ligand parameter file in CNS format + long: + Ligand parameter file in CNS format containing all force field parameters + (bond, angles, dihedrals, impropers, van der waals) for any ligand not supported by default by HADDOCK + group: force field + explevel: easy +ligand_top_fname: + default: "" + type: file + title: Custom ligand topology file + short: Ligand topology file in CNS format + long: Ligand topology file in CNS format containing the ligand topologies + (atoms, masses, charges, bond definitions...) for any ligand not supported by default by HADDOCK + group: force field + explevel: easy +limit: + default: true + type: boolean + title: Limit the number of input molecules. + short: When true, the topoaa module can accept any number of input molecules. + long: Enable/disable the limit of input molecules for the topoaa module. + Setting the limit to false is useful when the topoaa module is followed by + scoring modules such as emscoring, or other analysis modules. If topoaa is + used in the middle of the workflow this parameter has no effect. + group: sampling + explevel: expert +set_bfactor: + default: true + type: boolean + title: Define if the b-factor column must be overwritten + short: When true (default), all b-factors are set to a default value of 15 + long: Defines if the original b-factor values are kept (true) or + all b-factors are set to a default value for 15 (false). + group: module + explevel: expert +tolerance: + default: 0 + type: integer + min: 0 + max: 99 + precision: 3 + title: Failure tolerance percentage + short: Percentage of allowed failures for a module to successfully complete + long: Percentage of allowed failures for a module to successfully complete + group: module + explevel: expert +cyclicpept_dist: + default: 2.00 + type: float + precision: 2 + min: 0.00 + max: 999999.99 + title: Cutoff distance for cyclisation + short: Cutoff distance in Angstroms for identification of backbone cyclic peptide + long: Cutoff distance in Angstroms for identification of backbone cyclic peptide (N - C) + group: molecule + explevel: guru +disulphide_dist: + default: 2.20 + type: float + precision: 2 + min: 0.00 + max: 999999.99 + title: Cutoff distance for S-S bonds + short: Cutoff distance in Angstroms for identification of disulphide bonds + long: Cutoff distance in Angstroms for identification of disulphide bonds (SH - SH) + group: molecule + explevel: guru +mol1: + type: dict + group: input molecules + explevel: easy + title: Input molecule configuration + short: Specific molecule configuration + long: + You can expand this parameter and associated sub-parameters to the other input molecules. For example, + if you input three molecules, you can define mol1, mol2, and mol3 + subparameters. Those not defined will be populated with the defaults. + cyclicpept: + default: false + type: boolean + title: Cyclic peptide + short: Defines the molecule as a cyclic peptide + long: + This option defines the molecule as a cyclic peptide and HADDOCK will generate a peptide bond between the N- and C-ter provided those are within 2A. + This cutoff can be changed in the generate-topology.cns script. + group: molecule + explevel: easy + nhisd: + default: 0 + type: integer + min: 0 + max: 9999 + title: Number of HISD residue + short: Defines the number of HISD residues (neutral HIS with the proton on the ND atom) residues when autohis=false + long: + Defines the number of HISD residues (neutral HIS with the proton on the ND atom) residues. + The corresponding residue numbers must be defined in the following parameter (hisd_1, hisd_2, ...). Add as many as needed. + Note that HIS is interpreted as a charged Histidine) + group: molecule + explevel: expert + hisd_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: HISD residue number + short: Residue number of the Histidine to be defined as HISD + long: Residue number of the Histidine to be defined as HISD + group: molecule + explevel: expert + nhise: + default: 0 + type: integer + min: 0 + max: 9999 + title: Number of HISE residue + short: Defines the number of HISE residues (neutral HIS with the proton on the NE atom) residues when autohis=false + long: + Defines the number of HISE residues (neutral HIS with the proton on the NE atom) residues. + The corresponding residue numbers must be defined in the following parameter (hise_1, hise_2, ...). Add as many as needed. + Note that HIS is interpreted as a charged Histidine) + group: molecule + explevel: expert + hise_1: + default: .nan + type: integer + min: -9999 + max: 9999 + title: HISE residue number + short: Residue number of the Histidine to be defined as HISE + long: Residue number of the Histidine to be defined as HISE + group: molecule + explevel: expert + charged_nter: + default: false + type: boolean + title: N-ter topology + short: Define if N-terminus should be charged or uncharged + long: + This option defines how N-terminus residue should be. If false (default), N-ter will be an uncharged NH, + as it would be in a peptide bond. If true, N-ter will be a charged NH3+. + group: molecule + explevel: easy + charged_cter: + default: false + type: boolean + title: C-ter topology + short: Define if C-terminus should be charged or uncharged + long: + This option defines how N-terminus residue should be. If false (default), C-ter will be an uncharged CO, + as it would be in a peptide bond. If true, C-ter will be a charged COO-. + group: molecule + explevel: easy + 5_phosphate: + default: false + type: boolean + title: Nucleic Acids 5' topology + short: Define if 5' end should be phosphate or not. + long: + This option defines how nucleic acid 5' residue should be. If false (default), + 5' end will be an OH. If true, 5' end will be a phosphate. + group: molecule + explevel: easy +molecules: + default: false + type: boolean + title: Input molecules + short: Path to the input molecules. + long: This parameter is a general mandatory parameter but is masked here to + allow parameter validation while preparing the run. Therefore, the default + and type values of this parameter are meaningless. + explevel: hidden + group: molecules diff --git a/.venv_haddock/lib/python3.12/site-packages/haddock/prodrg/prodrg.param b/.venv_haddock/lib/python3.12/site-packages/haddock/prodrg/prodrg.param new file mode 100644 index 0000000000000000000000000000000000000000..9058b1f2f5caebb289f446e16e54672a63693d92 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/haddock/prodrg/prodrg.param differ diff --git a/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7a1e91e116382cf530ee780af350251a308a4e3a Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/backend.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/backend.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c5307352d65933a66883a38f390a3034a8aa77e6 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/backend.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/compat.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/compat.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..df3852a14fcf741ff17eb0cdb1a22431c9994dac Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/compat.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/errors.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/errors.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d1c8b145df31cbe6fabf792a4ed620ef80b4d7d8 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/errors.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/handlers.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/handlers.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bb560934646c2e60251d3d16a46c7f8c71995c3c Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/handlers.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/pickler.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/pickler.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3d25d85f67ed12a80a6565f4dd11e646a27b922d Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/pickler.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/tags.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/tags.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5c73916bec60aef3fb7f7c08810d193272b4569c Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/tags.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/tags_pd.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/tags_pd.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3578a77429f01b7896feb9db7a233c3ce8089eb2 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/tags_pd.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/unpickler.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/unpickler.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4a1f5fabf86eda73d6f8fda756b8adf4e04cbd2a Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/unpickler.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/util.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/util.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f810ae35e0d9c70e52bccf8711512f1e01d18a33 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/util.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/version.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/version.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..10183490a18a5177bd373e8d72feff36e171a043 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/__pycache__/version.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/__init__.py b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1f49e782deb255e839b5720d54ceeb1fafd8bc54 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/__pycache__/gmpy.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/__pycache__/gmpy.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8ed323fb65c91a2c0b0dadf33be1fb11f32580b5 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/__pycache__/gmpy.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/__pycache__/numpy.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/__pycache__/numpy.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..090072578e8c70bb3ace5f777bd60083fdc69b5b Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/__pycache__/numpy.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/__pycache__/pandas.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/__pycache__/pandas.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..06392e72bc4993854e0a1d09683f9d88a34e2594 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/__pycache__/pandas.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/__pycache__/yaml.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/__pycache__/yaml.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..62a4f2a536ada1c7c57f08e0dad83679dbd37f3a Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/__pycache__/yaml.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/gmpy.py b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/gmpy.py new file mode 100644 index 0000000000000000000000000000000000000000..bc5e3018ea491c8ed9c168eaf53585efc9babb80 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/gmpy.py @@ -0,0 +1,27 @@ +try: + import gmpy2 as gmpy +except ImportError: + gmpy = None + +from ..handlers import BaseHandler, register, unregister + +__all__ = ['register_handlers', 'unregister_handlers'] + + +class GmpyMPZHandler(BaseHandler): + def flatten(self, obj, data): + data['int'] = int(obj) + return data + + def restore(self, data): + return gmpy.mpz(data['int']) + + +def register_handlers(): + if gmpy is not None: + register(gmpy.mpz, GmpyMPZHandler, base=True) + + +def unregister_handlers(): + if gmpy is not None: + unregister(gmpy.mpz) diff --git a/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/numpy.py b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/numpy.py new file mode 100644 index 0000000000000000000000000000000000000000..2b037f73f5864cb5682fb2813d4a98a522857ae7 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/numpy.py @@ -0,0 +1,390 @@ +import ast +import json +import sys +import warnings +import zlib + +import numpy as np + +from ..handlers import BaseHandler, register, unregister +from ..util import b64decode, b64encode + +__all__ = ['register_handlers', 'unregister_handlers'] + +native_byteorder = '<' if sys.byteorder == 'little' else '>' + + +def get_byteorder(arr): + """translate equals sign to native order""" + byteorder = arr.dtype.byteorder + return native_byteorder if byteorder == '=' else byteorder + + +class NumpyBaseHandler(BaseHandler): + def flatten_dtype(self, dtype, data): + if hasattr(dtype, 'tostring'): + data['dtype'] = dtype.tostring() + else: + dtype = str(dtype) + prefix = '(numpy.record, ' + if dtype.startswith(prefix): + dtype = dtype[len(prefix) : -1] + data['dtype'] = dtype + + def restore_dtype(self, data): + dtype = data['dtype'] + if dtype.startswith(('{', '[')): + dtype = ast.literal_eval(dtype) + return np.dtype(dtype) + + +class NumpyDTypeHandler(NumpyBaseHandler): + def flatten(self, obj, data): + self.flatten_dtype(obj, data) + return data + + def restore(self, data): + return self.restore_dtype(data) + + +class NumpyGenericHandler(NumpyBaseHandler): + def flatten(self, obj, data): + self.flatten_dtype(obj.dtype.newbyteorder('N'), data) + data['value'] = self.context.flatten(obj.tolist(), reset=False) + return data + + def restore(self, data): + value = self.context.restore(data['value'], reset=False) + return self.restore_dtype(data).type(value) + + +class NumpyDatetimeHandler(NumpyGenericHandler): + """Extend NumpyGenericHandler to handle nanosecond-resolution datetime64""" + + def restore(self, data): + value = self.context.restore(data['value'], reset=False) + dtype = data['dtype'] + if dtype.endswith('[ns]'): + return self.restore_dtype(data).type(value, 'ns') + return self.restore_dtype(data).type(value) + + +class UnpickleableNumpyGenericHandler(NumpyGenericHandler): + """ + From issue #381, this is used for simplifying the output of numpy arrays + when unpicklable=False (the default is True). + """ + + def flatten(self, obj, data): + if not self.context.unpicklable: + return self.context.flatten(obj.tolist(), reset=False) + else: + return super(NumpyGenericHandler, self).flatten(obj, data) + + def restore(self, data): + raise NotImplementedError + + +class NumpyNDArrayHandler(NumpyBaseHandler): + """Stores arrays as text representation, without regard for views""" + + def flatten_flags(self, obj, data): + if obj.flags.writeable is False: + data['writeable'] = False + + def restore_flags(self, data, arr): + if not data.get('writeable', True): + arr.flags.writeable = False + + def flatten(self, obj, data): + self.flatten_dtype(obj.dtype.newbyteorder('N'), data) + self.flatten_flags(obj, data) + data['values'] = self.context.flatten(obj.tolist(), reset=False) + if 0 in obj.shape: + # add shape information explicitly as it cannot be + # inferred from an empty list + data['shape'] = obj.shape + return data + + def restore(self, data): + values = self.context.restore(data['values'], reset=False) + arr = np.array( + values, dtype=self.restore_dtype(data), order=data.get('order', 'C') + ) + shape = data.get('shape', None) + if shape is not None: + arr = arr.reshape(shape) + + self.restore_flags(data, arr) + return arr + + +class NumpyNDArrayHandlerBinary(NumpyNDArrayHandler): + """stores arrays with size greater than 'size_threshold' as + (optionally) compressed base64 + + Notes + ----- + This would be easier to implement using np.save/np.load, but + that would be less language-agnostic + """ + + def __init__(self, size_threshold=16, compression=zlib): + """ + :param size_threshold: nonnegative int or None + valid values for 'size_threshold' are all nonnegative + integers and None + if size_threshold is None, values are always stored as nested lists + :param compression: a compression module or None + valid values for 'compression' are {zlib, bz2, None} + if compression is None, no compression is applied + """ + self.size_threshold = size_threshold + self.compression = compression + + def flatten_byteorder(self, obj, data): + byteorder = obj.dtype.byteorder + if byteorder != '|': + data['byteorder'] = get_byteorder(obj) + + def restore_byteorder(self, data, arr): + byteorder = data.get('byteorder', None) + if byteorder: + arr.dtype = arr.dtype.newbyteorder(byteorder) + + def flatten(self, obj, data): + """encode numpy to json""" + if self.size_threshold is None or self.size_threshold >= obj.size: + # encode as text + data = super().flatten(obj, data) + else: + # encode as binary + if obj.dtype == object: + # There's a bug deep in the bowels of numpy that causes a + # segfault when round-tripping an ndarray of dtype object. + # E.g., the following will result in a segfault: + # import numpy as np + # arr = np.array([str(i) for i in range(3)], + # dtype=object) + # dtype = arr.dtype + # shape = arr.shape + # buf = arr.tobytes() + # del arr + # arr = np.ndarray(buffer=buf, dtype=dtype, + # shape=shape).copy() + # So, save as a binary-encoded list in this case + buf = json.dumps(obj.tolist()).encode() + elif hasattr(obj, 'tobytes'): + # numpy docstring is lacking as of 1.11.2, + # but this is the option we need + buf = obj.tobytes(order='a') + else: + # numpy < 1.9 compatibility + buf = obj.tostring(order='a') + if self.compression: + buf = self.compression.compress(buf) + data['values'] = b64encode(buf) + data['shape'] = obj.shape + self.flatten_dtype(obj.dtype.newbyteorder('N'), data) + self.flatten_byteorder(obj, data) + self.flatten_flags(obj, data) + + if not obj.flags.c_contiguous: + data['order'] = 'F' + + return data + + def restore(self, data): + """decode numpy from json""" + values = data['values'] + if isinstance(values, list): + # decode text representation + arr = super().restore(data) + elif isinstance(values, (int, float)): + # single-value array + arr = np.array([values], dtype=self.restore_dtype(data)) + else: + # decode binary representation + dtype = self.restore_dtype(data) + buf = b64decode(values) + if self.compression: + buf = self.compression.decompress(buf) + # See note above about segfault bug for numpy dtype object. Those + # are saved as a list to work around that. + if dtype == object: + values = json.loads(buf.decode()) + arr = np.array(values, dtype=dtype, order=data.get('order', 'C')) + shape = data.get('shape', None) + if shape is not None: + arr = arr.reshape(shape) + else: + arr = np.ndarray( + buffer=buf, + dtype=dtype, + shape=data.get('shape'), + order=data.get('order', 'C'), + ).copy() # make a copy, to force the result to own the data + self.restore_byteorder(data, arr) + self.restore_flags(data, arr) + + return arr + + +class NumpyNDArrayHandlerView(NumpyNDArrayHandlerBinary): + """Pickles references inside ndarrays, or array-views + + Notes + ----- + The current implementation has some restrictions. + + 'base' arrays, or arrays which are viewed by other arrays, + must be f-or-c-contiguous. + This is not such a large restriction in practice, because all + numpy array creation is c-contiguous by default. + Relaxing this restriction would be nice though; especially if + it can be done without bloating the design too much. + + Furthermore, ndarrays which are views of array-like objects + implementing __array_interface__, + but which are not themselves nd-arrays, are deepcopied with + a warning (by default), + as we cannot guarantee whatever custom logic such classes + implement is correctly reproduced. + """ + + def __init__(self, mode='warn', size_threshold=16, compression=zlib): + """ + :param mode: {'warn', 'raise', 'ignore'} + How to react when encountering array-like objects whose + references we cannot safely serialize + :param size_threshold: nonnegative int or None + valid values for 'size_threshold' are all nonnegative + integers and None + if size_threshold is None, values are always stored as nested lists + :param compression: a compression module or None + valid values for 'compression' are {zlib, bz2, None} + if compression is None, no compression is applied + """ + super().__init__(size_threshold, compression) + self.mode = mode + + def flatten(self, obj, data): + """encode numpy to json""" + base = obj.base + if base is None and obj.flags.forc: + # store by value + data = super().flatten(obj, data) + # ensure that views on arrays stored as text + # are interpreted correctly + if not obj.flags.c_contiguous: + data['order'] = 'F' + elif isinstance(base, np.ndarray) and base.flags.forc: + # store by reference + data['base'] = self.context.flatten(base, reset=False) + + offset = obj.ctypes.data - base.ctypes.data + if offset: + data['offset'] = offset + + if not obj.flags.c_contiguous: + data['strides'] = obj.strides + + data['shape'] = obj.shape + self.flatten_dtype(obj.dtype.newbyteorder('N'), data) + self.flatten_flags(obj, data) + + if get_byteorder(obj) != '|': + byteorder = 'S' if get_byteorder(obj) != get_byteorder(base) else None + if byteorder: + data['byteorder'] = byteorder + + if self.size_threshold is None or self.size_threshold >= obj.size: + # not used in restore since base is present, but + # include values for human-readability + super(NumpyNDArrayHandlerBinary, self).flatten(obj, data) + else: + # store a deepcopy or fail + if self.mode == 'warn': + msg = ( + "ndarray is defined by reference to an object " + "we do not know how to serialize. " + "A deep copy is serialized instead, breaking " + "memory aliasing." + ) + warnings.warn(msg) + elif self.mode == 'raise': + msg = ( + "ndarray is defined by reference to an object we do " + "not know how to serialize." + ) + raise ValueError(msg) + data = super().flatten(obj.copy(), data) + + return data + + def restore(self, data): + """decode numpy from json""" + base = data.get('base', None) + if base is None: + # decode array with owndata=True + arr = super().restore(data) + else: + # decode array view, which references the data of another array + base = self.context.restore(base, reset=False) + if not isinstance(base, np.ndarray): + # the object is probably a nested list + base = np.array(base) + assert ( + base.flags.forc + ), "Current implementation assumes base is C or F contiguous" + + arr = np.ndarray( + buffer=base.data, + dtype=self.restore_dtype(data).newbyteorder(data.get('byteorder', '|')), + shape=data.get('shape'), + offset=data.get('offset', 0), + strides=data.get('strides', None), + ) + + self.restore_flags(data, arr) + + return arr + + +def register_handlers( + ndarray_mode='warn', + ndarray_size_threshold=16, + ndarray_compression=zlib, +): + """Register handlers for numpy types + + :param ndarray_abc_xyz: Forward constructor arguments to NumpyNDArrayHandlerView. + Options with an 'ndarray_' prefix correspond to the same-named + NumpyNDArrayHandlerView constructor options, sans the 'ndarray_' prefix. + """ + ndarray_handler = NumpyNDArrayHandlerView( + mode=ndarray_mode, + size_threshold=ndarray_size_threshold, + compression=ndarray_compression, + ) + register(np.ndarray, ndarray_handler, base=True) + register(np.dtype, NumpyDTypeHandler, base=True) + register(np.generic, NumpyGenericHandler, base=True) + # Numpy 1.20 has custom dtypes that must be registered separately. + register(np.dtype(np.void).__class__, NumpyDTypeHandler, base=True) + register(np.dtype(np.float32).__class__, NumpyDTypeHandler, base=True) + register(np.dtype(np.int32).__class__, NumpyDTypeHandler, base=True) + register(np.dtype(np.datetime64).__class__, NumpyDTypeHandler, base=True) + register(np.datetime64, NumpyDatetimeHandler, base=True) + + +def unregister_handlers(): + """Remove numpy handlers from the handler registry""" + unregister(np.dtype) + unregister(np.generic) + unregister(np.ndarray) + # Numpy 1.20 dtypes + unregister(np.dtype(np.void).__class__) + unregister(np.dtype(np.float32).__class__) + unregister(np.dtype(np.int32).__class__) + unregister(np.dtype(np.datetime64).__class__) diff --git a/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/pandas.py b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/pandas.py new file mode 100644 index 0000000000000000000000000000000000000000..d5040918b96628025e561454b3b877939e7f4a24 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/pandas.py @@ -0,0 +1,452 @@ +import warnings +import zlib +from io import StringIO + +import numpy as np +import pandas as pd + +from .. import decode, encode +from ..handlers import BaseHandler, register, unregister +from ..tags_pd import REVERSE_TYPE_MAP, TYPE_MAP +from ..util import b64decode, b64encode +from .numpy import register_handlers as register_numpy_handlers +from .numpy import unregister_handlers as unregister_numpy_handlers + +__all__ = ['register_handlers', 'unregister_handlers'] + + +def pd_encode(obj, **kwargs): + if isinstance(obj, np.generic): + # convert pandas/numpy scalar to native Python type + return obj.item() + return encode(obj, **kwargs) + + +def pd_decode(s, **kwargs): + return decode(s, **kwargs) + + +def rle_encode(types_list): + """ + Encodes a list of type codes using Run-Length Encoding (RLE). This allows for object columns in dataframes to contain items of different types without massively bloating the encoded representation. + """ + if not types_list: + return [] + + encoded = [] + current_type = types_list[0] + count = 1 + + for typ in types_list[1:]: + if typ == current_type: + count += 1 + else: + encoded.append([current_type, count]) + current_type = typ + count = 1 + encoded.append([current_type, count]) + + return encoded + + +def rle_decode(encoded_list): + """ + Decodes a Run-Length Encoded (RLE) list back into the original list of type codes. + """ + decoded = [] + for typ, count in encoded_list: + decoded.extend([typ] * count) + return decoded + + +class PandasProcessor: + def __init__(self, size_threshold=500, compression=zlib): + """ + :param size_threshold: nonnegative int or None + valid values for 'size_threshold' are all nonnegative + integers and None. If size_threshold is None, + dataframes are always stored as csv strings + :param compression: a compression module or None + valid values for 'compression' are {zlib, bz2, None} + if compression is None, no compression is applied + """ + self.size_threshold = size_threshold + self.compression = compression + + def flatten_pandas(self, buf, data, meta=None): + if self.size_threshold is not None and len(buf) > self.size_threshold: + if self.compression: + buf = self.compression.compress(buf.encode()) + data['comp'] = True + data['values'] = b64encode(buf) + data['txt'] = False + else: + data['values'] = buf + data['txt'] = True + + data['meta'] = meta + return data + + def restore_pandas(self, data): + if data.get('txt', True): + # It's just text... + buf = data['values'] + else: + buf = b64decode(data['values']) + if data.get('comp', False): + buf = self.compression.decompress(buf).decode() + meta = data.get('meta', {}) + return (buf, meta) + + +def make_read_csv_params(meta, context): + meta_dtypes = context.restore(meta.get('dtypes', {}), reset=False) + # The header is used to select the rows of the csv from which + # the columns names are retrieved + header = meta.get('header', [0]) + parse_dates = [] + converters = {} + timedeltas = [] + # this is only for pandas v2+ due to a backwards-incompatible change + parse_datetime_v2 = {} + dtype = {} + for k, v in meta_dtypes.items(): + if v.startswith('datetime'): + parse_dates.append(k) + parse_datetime_v2[k] = v + elif v.startswith('complex'): + converters[k] = complex + elif v.startswith('timedelta'): + timedeltas.append(k) + dtype[k] = 'object' + else: + dtype[k] = v + + return ( + dict( + dtype=dtype, header=header, parse_dates=parse_dates, converters=converters + ), + timedeltas, + parse_datetime_v2, + ) + + +class PandasDfHandler(BaseHandler): + pp = PandasProcessor() + + def flatten(self, obj, data): + pp = PandasProcessor() + # handle multiindex columns + if isinstance(obj.columns, pd.MultiIndex): + columns = [tuple(col) for col in obj.columns] + column_names = obj.columns.names + is_multicolumns = True + else: + columns = obj.columns.tolist() + column_names = obj.columns.name + is_multicolumns = False + + # handle multiindex index + if isinstance(obj.index, pd.MultiIndex): + index_values = [tuple(idx) for idx in obj.index.values] + index_names = obj.index.names + is_multiindex = True + else: + index_values = obj.index.tolist() + index_names = obj.index.name + is_multiindex = False + + data_columns = {} + type_codes = [] + for col in obj.columns: + col_data = obj[col] + dtype_name = col_data.dtype.name + + if dtype_name == "object": + # check if items are complex types + if col_data.apply( + lambda x: isinstance(x, (list, dict, set, tuple, np.ndarray)) + ).any(): + # if items are complex, erialize each item individually + serialized_values = col_data.apply(lambda x: encode(x)).tolist() + data_columns[col] = serialized_values + type_codes.append("py/jp") + else: + # treat it as regular object dtype + data_columns[col] = col_data.tolist() + type_codes.append(TYPE_MAP.get(dtype_name, "object")) + else: + # for other dtypes, store their values directly + data_columns[col] = col_data.tolist() + type_codes.append(TYPE_MAP.get(dtype_name, "object")) + + # store index data + index_encoded = encode(index_values, keys=True) + + rle_types = rle_encode(type_codes) + # prepare metadata + meta = { + "dtypes_rle": rle_types, + "index": index_encoded, + "index_names": index_names, + "columns": encode(columns, keys=True), + "column_names": column_names, + "is_multiindex": is_multiindex, + "is_multicolumns": is_multicolumns, + } + + # serialize data_columns with keys=True to allow for non-object keys + data_encoded = encode(data_columns, keys=True) + + # use PandasProcessor to flatten + data = pp.flatten_pandas(data_encoded, data, meta) + return data + + def restore(self, obj): + data_encoded, meta = self.pp.restore_pandas(obj) + try: + data_columns = decode(data_encoded, keys=True) + except Exception: + # this may be a specific type of jsondecode error for pre-v3.4 encoding schemes, but also might not be + warnings.warn( + ( + "jsonpickle versions at and above v3.4 have a different encoding scheme for pandas dataframes." + # stack level 6 is where the user called jsonpickle from + " If you're not decoding an object encoded in pre-v3.4 jsonpickle, please file a bug report on our GitHub!" + ), + stacklevel=6, + ) + return self.restore_v3_3(obj) + + # get type codes, un-RLE-ed + try: + rle_types = meta["dtypes_rle"] + except KeyError: + # was definitely encoded with pre-v3.4 scheme, but warn anyway + warnings.warn( + ( + "jsonpickle versions at and above v3.4 have a different encoding scheme for pandas dataframes." + " Please update your jsonpickle and re-encode these objects!" + ), + stacklevel=6, + ) + return self.restore_v3_3(obj) + type_codes = rle_decode(rle_types) + + # handle multicolumns + columns_decoded = decode(meta["columns"], keys=True) + if meta.get("is_multicolumns", False): + columns = pd.MultiIndex.from_tuples( + columns_decoded, names=meta.get("column_names") + ) + else: + columns = columns_decoded + + # progressively reconstruct dataframe as a dict + df_data = {} + dtypes = {} + for col, type_code in zip(columns, type_codes): + col_data = data_columns[col] + if type_code == "py/jp": + # deserialize each item in the column + col_values = [decode(item) for item in col_data] + df_data[col] = col_values + else: + df_data[col] = col_data + # used later to get correct dtypes + dtype_str = REVERSE_TYPE_MAP.get(type_code, "object") + dtypes[col] = dtype_str + + # turn dict into df + df = pd.DataFrame(df_data) + df.columns = columns + + # apply dtypes + for col in df.columns: + dtype_str = dtypes.get(col, "object") + try: + dtype = np.dtype(dtype_str) + df[col] = df[col].astype(dtype) + except Exception: + msg = ( + f"jsonpickle was unable to properly deserialize " + f"the column {col} into its inferred dtype. " + f"Please file a bugreport on the jsonpickle GitHub! " + ) + warnings.warn(msg) + + # decode and set the index + index_values = decode(meta["index"], keys=True) + if meta.get("is_multiindex", False): + index = pd.MultiIndex.from_tuples( + index_values, names=meta.get("index_names") + ) + else: + index = pd.Index(index_values, name=meta.get("index_names")) + df.index = index + + # restore column names for easy readability + if "column_names" in meta: + if meta.get("is_multicolumns", False): + df.columns.names = meta.get("column_names") + else: + df.columns.name = meta.get("column_names") + + return df + + def restore_v3_3(self, data): + csv, meta = self.pp.restore_pandas(data) + params, timedeltas, parse_datetime_v2 = make_read_csv_params(meta, self.context) + # None makes it compatible with objects serialized before + # column_levels_names has been introduced. + column_level_names = meta.get("column_level_names", None) + df = ( + pd.read_csv(StringIO(csv), **params) + if data["values"].strip() + else pd.DataFrame() + ) + for col in timedeltas: + df[col] = pd.to_timedelta(df[col]) + df = df.astype(parse_datetime_v2) + + df.set_index(decode(meta["index"]), inplace=True) + # restore the column level(s) name(s) + if column_level_names: + df.columns.names = column_level_names + return df + + +class PandasSeriesHandler(BaseHandler): + pp = PandasProcessor() + + def flatten(self, obj, data): + """Flatten the index and values for reconstruction""" + data['name'] = obj.name + # This relies on the numpy handlers for the inner guts. + data['index'] = self.context.flatten(obj.index, reset=False) + data['values'] = self.context.flatten(obj.values, reset=False) + return data + + def restore(self, data): + """Restore the flattened data""" + name = data['name'] + index = self.context.restore(data['index'], reset=False) + values = self.context.restore(data['values'], reset=False) + return pd.Series(values, index=index, name=name) + + +class PandasIndexHandler(BaseHandler): + pp = PandasProcessor() + index_constructor = pd.Index + + def name_bundler(self, obj): + return {'name': obj.name} + + def flatten(self, obj, data): + name_bundle = self.name_bundler(obj) + meta = dict(dtype=str(obj.dtype), **name_bundle) + buf = encode(obj.tolist()) + data = self.pp.flatten_pandas(buf, data, meta) + return data + + def restore(self, data): + buf, meta = self.pp.restore_pandas(data) + dtype = meta.get('dtype', None) + name_bundle = { + 'name': (tuple if v is not None else lambda x: x)(v) + for k, v in meta.items() + if k in {'name', 'names'} + } + idx = self.index_constructor(decode(buf), dtype=dtype, **name_bundle) + return idx + + +class PandasPeriodIndexHandler(PandasIndexHandler): + index_constructor = pd.PeriodIndex + + +class PandasMultiIndexHandler(PandasIndexHandler): + def name_bundler(self, obj): + return {'names': obj.names} + + +class PandasTimestampHandler(BaseHandler): + pp = PandasProcessor() + + def flatten(self, obj, data): + meta = {'isoformat': obj.isoformat()} + buf = '' + data = self.pp.flatten_pandas(buf, data, meta) + return data + + def restore(self, data): + _, meta = self.pp.restore_pandas(data) + isoformat = meta['isoformat'] + obj = pd.Timestamp(isoformat) + return obj + + +class PandasPeriodHandler(BaseHandler): + pp = PandasProcessor() + + def flatten(self, obj, data): + meta = { + 'start_time': encode(obj.start_time), + 'freqstr': obj.freqstr, + } + buf = '' + data = self.pp.flatten_pandas(buf, data, meta) + return data + + def restore(self, data): + _, meta = self.pp.restore_pandas(data) + start_time = decode(meta['start_time']) + freqstr = meta['freqstr'] + obj = pd.Period(start_time, freqstr) + return obj + + +class PandasIntervalHandler(BaseHandler): + pp = PandasProcessor() + + def flatten(self, obj, data): + meta = { + 'left': encode(obj.left), + 'right': encode(obj.right), + 'closed': obj.closed, + } + buf = '' + data = self.pp.flatten_pandas(buf, data, meta) + return data + + def restore(self, data): + _, meta = self.pp.restore_pandas(data) + left = decode(meta['left']) + right = decode(meta['right']) + closed = str(meta['closed']) + obj = pd.Interval(left, right, closed=closed) + return obj + + +def register_handlers(): + register_numpy_handlers() + register(pd.DataFrame, PandasDfHandler, base=True) + register(pd.Series, PandasSeriesHandler, base=True) + register(pd.Index, PandasIndexHandler, base=True) + register(pd.PeriodIndex, PandasPeriodIndexHandler, base=True) + register(pd.MultiIndex, PandasMultiIndexHandler, base=True) + register(pd.Timestamp, PandasTimestampHandler, base=True) + register(pd.Period, PandasPeriodHandler, base=True) + register(pd.Interval, PandasIntervalHandler, base=True) + + +def unregister_handlers(): + unregister_numpy_handlers() + unregister(pd.DataFrame) + unregister(pd.Series) + unregister(pd.Index) + unregister(pd.PeriodIndex) + unregister(pd.MultiIndex) + unregister(pd.Timestamp) + unregister(pd.Period) + unregister(pd.Interval) diff --git a/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/yaml.py b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/yaml.py new file mode 100644 index 0000000000000000000000000000000000000000..78c57eab232cffd818b39b9312526c794788155c --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/jsonpickle/ext/yaml.py @@ -0,0 +1,15 @@ +"""YAML extension for jsonpickle + +The YAML extension module connects jsonpickle to the PyYAML `yaml` module. +""" + +from ..backend import json as jsonpickle_backend + + +def register(backend=None): + """Register the yaml module with jsonpickle's JSONBackend""" + if backend is None: + backend = jsonpickle_backend + return backend.load_backend( + 'yaml', dumps='dump', loads='safe_load', loads_exc='YAMLError' + ) diff --git a/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/LICENSE.txt b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..13d91e2842efa733a9c877d7195d610326e6cd9e --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/LICENSE.txt @@ -0,0 +1,935 @@ +Copyright (c) 2005-2025, NumPy Developers. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of the NumPy Developers nor the names of any + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +---- + + +---- + +This binary distribution of NumPy also bundles the following software: + + +Name: OpenBLAS +Files: numpy/.dylibs/libscipy_openblas*.so +Description: bundled as a dynamically linked library +Availability: https://github.com/OpenMathLib/OpenBLAS/ +License: BSD-3-Clause + Copyright (c) 2011-2014, The OpenBLAS Project + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + 3. Neither the name of the OpenBLAS project nor the names of + its contributors may be used to endorse or promote products + derived from this software without specific prior written + permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +Name: LAPACK +Files: numpy/.dylibs/libscipy_openblas*.so +Description: bundled in OpenBLAS +Availability: https://github.com/OpenMathLib/OpenBLAS/ +License: BSD-3-Clause-Open-MPI + Copyright (c) 1992-2013 The University of Tennessee and The University + of Tennessee Research Foundation. All rights + reserved. + Copyright (c) 2000-2013 The University of California Berkeley. All + rights reserved. + Copyright (c) 2006-2013 The University of Colorado Denver. All rights + reserved. + + $COPYRIGHT$ + + Additional copyrights may follow + + $HEADER$ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer listed + in this license in the documentation and/or other materials + provided with the distribution. + + - Neither the name of the copyright holders nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + + The copyright holders provide no reassurances that the source code + provided does not infringe any patent, copyright, or any other + intellectual property rights of third parties. The copyright holders + disclaim any liability to any recipient for claims brought against + recipient by any third party for infringement of that parties + intellectual property rights. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +Name: GCC runtime library +Files: numpy/.dylibs/libgfortran*, numpy/.dylibs/libgcc* +Description: dynamically linked to files compiled with gcc +Availability: https://gcc.gnu.org/git/?p=gcc.git;a=tree;f=libgfortran +License: GPL-3.0-or-later WITH GCC-exception-3.1 + Copyright (C) 2002-2017 Free Software Foundation, Inc. + + Libgfortran is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3, or (at your option) + any later version. + + Libgfortran is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + Under Section 7 of GPL version 3, you are granted additional + permissions described in the GCC Runtime Library Exception, version + 3.1, as published by the Free Software Foundation. + + You should have received a copy of the GNU General Public License and + a copy of the GCC Runtime Library Exception along with this program; + see the files COPYING3 and COPYING.RUNTIME respectively. If not, see + . + +---- + +Full text of license texts referred to above follows (that they are +listed below does not necessarily imply the conditions apply to the +present binary release): + +---- + +GCC RUNTIME LIBRARY EXCEPTION + +Version 3.1, 31 March 2009 + +Copyright (C) 2009 Free Software Foundation, Inc. + +Everyone is permitted to copy and distribute verbatim copies of this +license document, but changing it is not allowed. + +This GCC Runtime Library Exception ("Exception") is an additional +permission under section 7 of the GNU General Public License, version +3 ("GPLv3"). It applies to a given file (the "Runtime Library") that +bears a notice placed by the copyright holder of the file stating that +the file is governed by GPLv3 along with this Exception. + +When you use GCC to compile a program, GCC may combine portions of +certain GCC header files and runtime libraries with the compiled +program. The purpose of this Exception is to allow compilation of +non-GPL (including proprietary) programs to use, in this way, the +header files and runtime libraries covered by this Exception. + +0. Definitions. + +A file is an "Independent Module" if it either requires the Runtime +Library for execution after a Compilation Process, or makes use of an +interface provided by the Runtime Library, but is not otherwise based +on the Runtime Library. + +"GCC" means a version of the GNU Compiler Collection, with or without +modifications, governed by version 3 (or a specified later version) of +the GNU General Public License (GPL) with the option of using any +subsequent versions published by the FSF. + +"GPL-compatible Software" is software whose conditions of propagation, +modification and use would permit combination with GCC in accord with +the license of GCC. + +"Target Code" refers to output from any compiler for a real or virtual +target processor architecture, in executable form or suitable for +input to an assembler, loader, linker and/or execution +phase. Notwithstanding that, Target Code does not include data in any +format that is used as a compiler intermediate representation, or used +for producing a compiler intermediate representation. + +The "Compilation Process" transforms code entirely represented in +non-intermediate languages designed for human-written code, and/or in +Java Virtual Machine byte code, into Target Code. Thus, for example, +use of source code generators and preprocessors need not be considered +part of the Compilation Process, since the Compilation Process can be +understood as starting with the output of the generators or +preprocessors. + +A Compilation Process is "Eligible" if it is done using GCC, alone or +with other GPL-compatible software, or if it is done without using any +work based on GCC. For example, using non-GPL-compatible Software to +optimize any GCC intermediate representations would not qualify as an +Eligible Compilation Process. + +1. Grant of Additional Permission. + +You have permission to propagate a work of Target Code formed by +combining the Runtime Library with Independent Modules, even if such +propagation would otherwise violate the terms of GPLv3, provided that +all Target Code was generated by Eligible Compilation Processes. You +may then convey such a combination under terms of your choice, +consistent with the licensing of the Independent Modules. + +2. No Weakening of GCC Copyleft. + +The availability of this Exception does not imply any general +presumption that third-party software is unaffected by the copyleft +requirements of the license of GCC. + +---- + + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. + +Name: libquadmath +Files: numpy/.dylibs/libquadmath*.so +Description: dynamically linked to files compiled with gcc +Availability: https://gcc.gnu.org/git/?p=gcc.git;a=tree;f=libquadmath +License: LGPL-2.1-or-later + + GCC Quad-Precision Math Library + Copyright (C) 2010-2019 Free Software Foundation, Inc. + Written by Francois-Xavier Coudert + + This file is part of the libquadmath library. + Libquadmath is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + Libquadmath is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html diff --git a/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/_core/include/numpy/libdivide/LICENSE.txt b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/_core/include/numpy/libdivide/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..d72a7c388d406191f2b3113efa5f89916a39d9b2 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/_core/include/numpy/libdivide/LICENSE.txt @@ -0,0 +1,21 @@ + zlib License + ------------ + + Copyright (C) 2010 - 2019 ridiculous_fish, + Copyright (C) 2016 - 2019 Kim Walisch, + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. diff --git a/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/_core/src/common/pythoncapi-compat/COPYING b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/_core/src/common/pythoncapi-compat/COPYING new file mode 100644 index 0000000000000000000000000000000000000000..59a39fb411050556ec1b321a42e870417134671a --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/_core/src/common/pythoncapi-compat/COPYING @@ -0,0 +1,14 @@ +BSD Zero Clause License + +Copyright Contributors to the pythoncapi_compat project. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. diff --git a/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/_core/src/highway/LICENSE b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/_core/src/highway/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..1af4f15ca709c0e74e610c09fe91022f354aea58 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/_core/src/highway/LICENSE @@ -0,0 +1,371 @@ +This project is primarily dual-licensed under your choice of either the Apache +License 2.0 or the BSD 3-Clause License. + +The following files are licensed under different terms: +* hwy/contrib/random/random-inl.h: CC0 1.0 Universal + +The full texts of all applicable licenses are included below, separated by +'---'. + +-------------------------------------------------------------------------------- +Apache License 2.0 +-------------------------------------------------------------------------------- + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + +-------------------------------------------------------------------------------- +BSD 3-Clause License +-------------------------------------------------------------------------------- + +Copyright (c) The Highway Project Authors. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +-------------------------------------------------------------------------------- +CC0 1.0 Universal +-------------------------------------------------------------------------------- + +Creative Commons Legal Code + +CC0 1.0 Universal + + CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE + LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN + ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS + INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES + REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS + PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM + THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED + HEREUNDER. + +Statement of Purpose + +The laws of most jurisdictions throughout the world automatically confer +exclusive Copyright and Related Rights (defined below) upon the creator +and subsequent owner(s) (each and all, an "owner") of an original work of +authorship and/or a database (each, a "Work"). + +Certain owners wish to permanently relinquish those rights to a Work for +the purpose of contributing to a commons of creative, cultural and +scientific works ("Commons") that the public can reliably and without fear +of later claims of infringement build upon, modify, incorporate in other +works, reuse and redistribute as freely as possible in any form whatsoever +and for any purposes, including without limitation commercial purposes. +These owners may contribute to the Commons to promote the ideal of a free +culture and the further production of creative, cultural and scientific +works, or to gain reputation or greater distribution for their Work in +part through the use and efforts of others. + +For these and/or other purposes and motivations, and without any +expectation of additional consideration or compensation, the person +associating CC0 with a Work (the "Affirmer"), to the extent that he or she +is an owner of Copyright and Related Rights in the Work, voluntarily +elects to apply CC0 to the Work and publicly distribute the Work under its +terms, with knowledge of his or her Copyright and Related Rights in the +Work and the meaning and intended legal effect of CC0 on those rights. + +1. Copyright and Related Rights. A Work made available under CC0 may be +protected by copyright and related or neighboring rights ("Copyright and +Related Rights"). Copyright and Related Rights include, but are not +limited to, the following: + + i. the right to reproduce, adapt, distribute, perform, display, + communicate, and translate a Work; + ii. moral rights retained by the original author(s) and/or performer(s); +iii. publicity and privacy rights pertaining to a person's image or + likeness depicted in a Work; + iv. rights protecting against unfair competition in regards to a Work, + subject to the limitations in paragraph 4(a), below; + v. rights protecting the extraction, dissemination, use and reuse of data + in a Work; + vi. database rights (such as those arising under Directive 96/9/EC of the + European Parliament and of the Council of 11 March 1996 on the legal + protection of databases, and under any national implementation + thereof, including any amended or successor version of such + directive); and +vii. other similar, equivalent or corresponding rights throughout the + world based on applicable law or treaty, and any national + implementations thereof. + +2. Waiver. To the greatest extent permitted by, but not in contravention +of, applicable law, Affirmer hereby overtly, fully, permanently, +irrevocably and unconditionally waives, abandons, and surrenders all of +Affirmer's Copyright and Related Rights and associated claims and causes +of action, whether now known or unknown (including existing as well as +future claims and causes of action), in the Work (i) in all territories +worldwide, (ii) for the maximum duration provided by applicable law or +treaty (including future time extensions), (iii) in any current or future +medium and for any number of copies, and (iv) for any purpose whatsoever, +including without limitation commercial, advertising or promotional +purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each +member of the public at large and to the detriment of Affirmer's heirs and +successors, fully intending that such Waiver shall not be subject to +revocation, rescission, cancellation, termination, or any other legal or +equitable action to disrupt the quiet enjoyment of the Work by the public +as contemplated by Affirmer's express Statement of Purpose. + +3. Public License Fallback. Should any part of the Waiver for any reason +be judged legally invalid or ineffective under applicable law, then the +Waiver shall be preserved to the maximum extent permitted taking into +account Affirmer's express Statement of Purpose. In addition, to the +extent the Waiver is so judged Affirmer hereby grants to each affected +person a royalty-free, non transferable, non sublicensable, non exclusive, +irrevocable and unconditional license to exercise Affirmer's Copyright and +Related Rights in the Work (i) in all territories worldwide, (ii) for the +maximum duration provided by applicable law or treaty (including future +time extensions), (iii) in any current or future medium and for any number +of copies, and (iv) for any purpose whatsoever, including without +limitation commercial, advertising or promotional purposes (the +"License"). The License shall be deemed effective as of the date CC0 was +applied by Affirmer to the Work. Should any part of the License for any +reason be judged legally invalid or ineffective under applicable law, such +partial invalidity or ineffectiveness shall not invalidate the remainder +of the License, and in such case Affirmer hereby affirms that he or she +will not (i) exercise any of his or her remaining Copyright and Related +Rights in the Work or (ii) assert any associated claims and causes of +action with respect to the Work, in either case contrary to Affirmer's +express Statement of Purpose. + +4. Limitations and Disclaimers. + + a. No trademark or patent rights held by Affirmer are waived, abandoned, + surrendered, licensed or otherwise affected by this document. + b. Affirmer offers the Work as-is and makes no representations or + warranties of any kind concerning the Work, express, implied, + statutory or otherwise, including without limitation warranties of + title, merchantability, fitness for a particular purpose, non + infringement, or the absence of latent or other defects, accuracy, or + the present or absence of errors, whether or not discoverable, all to + the greatest extent permissible under applicable law. + c. Affirmer disclaims responsibility for clearing rights of other persons + that may apply to the Work or any use thereof, including without + limitation any person's Copyright and Related Rights in the Work. + Further, Affirmer disclaims responsibility for obtaining any necessary + consents, permissions or other rights required for any use of the + Work. + d. Affirmer understands and acknowledges that Creative Commons is not a + party to this document and has no duty or obligation with respect to + this CC0 or use of the Work. \ No newline at end of file diff --git a/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/_core/src/multiarray/dragon4_LICENSE.txt b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/_core/src/multiarray/dragon4_LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..7bd49e7074a8efbd14496e0b82ec51f14cc6dffe --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/_core/src/multiarray/dragon4_LICENSE.txt @@ -0,0 +1,27 @@ +Copyright (c) 2014 Ryan Juckett + +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. + +dragon4.c|h h contains a modified version of Ryan Juckett's Dragon4 +implementation, obtained from https://www.ryanjuckett.com, +which has been ported from C++ to C and which has +modifications specific to printing floats in numpy. + +Ryan Juckett's original code was under the Zlib license; he gave numpy +permission to include it under the MIT license instead. diff --git a/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/_core/src/npysort/x86-simd-sort/LICENSE.md b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/_core/src/npysort/x86-simd-sort/LICENSE.md new file mode 100644 index 0000000000000000000000000000000000000000..3e32165ed474ee2b9877a6716beceb0271643b5a --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/_core/src/npysort/x86-simd-sort/LICENSE.md @@ -0,0 +1,28 @@ +BSD 3-Clause License + +Copyright (c) 2022, Intel. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/_core/src/umath/svml/LICENSE b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/_core/src/umath/svml/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..4723d4ea009e5af16664576c0a4d99d41cb11cc9 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/_core/src/umath/svml/LICENSE @@ -0,0 +1,30 @@ +Copyright (c) 2005-2021, NumPy Developers. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of the NumPy Developers nor the names of any + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/fft/pocketfft/LICENSE.md b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/fft/pocketfft/LICENSE.md new file mode 100644 index 0000000000000000000000000000000000000000..c3a4c06a92d024e12ab76ce6b20eae815979552e --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/fft/pocketfft/LICENSE.md @@ -0,0 +1,25 @@ +Copyright (C) 2010-2018 Max-Planck-Society +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. +* Redistributions in binary form must reproduce the above copyright notice, this + list of conditions and the following disclaimer in the documentation and/or + other materials provided with the distribution. +* Neither the name of the copyright holder nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/linalg/lapack_lite/LICENSE.txt b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/linalg/lapack_lite/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..9b379c9e897351cecb1f31f3061192f4319ac73d --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/linalg/lapack_lite/LICENSE.txt @@ -0,0 +1,48 @@ +Copyright (c) 1992-2013 The University of Tennessee and The University + of Tennessee Research Foundation. All rights + reserved. +Copyright (c) 2000-2013 The University of California Berkeley. All + rights reserved. +Copyright (c) 2006-2013 The University of Colorado Denver. All rights + reserved. + +$COPYRIGHT$ + +Additional copyrights may follow + +$HEADER$ + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + +- Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + +- Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer listed + in this license in the documentation and/or other materials + provided with the distribution. + +- Neither the name of the copyright holders nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +The copyright holders provide no reassurances that the source code +provided does not infringe any patent, copyright, or any other +intellectual property rights of third parties. The copyright holders +disclaim any liability to any recipient for claims brought against +recipient by any third party for infringement of that parties +intellectual property rights. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/ma/LICENSE b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/ma/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b41aae0c89a0f2486843d395f972db759c73c4b8 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/ma/LICENSE @@ -0,0 +1,24 @@ +* Copyright (c) 2006, University of Georgia and Pierre G.F. Gerard-Marchant +* All rights reserved. +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above copyright +* notice, this list of conditions and the following disclaimer in the +* documentation and/or other materials provided with the distribution. +* * Neither the name of the University of Georgia nor the +* names of its contributors may be used to endorse or promote products +* derived from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY +* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +* DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \ No newline at end of file diff --git a/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/random/LICENSE.md b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/random/LICENSE.md new file mode 100644 index 0000000000000000000000000000000000000000..a6cf1b17e99725556ac56ce3661498df1ee2276a --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/random/LICENSE.md @@ -0,0 +1,71 @@ +**This software is dual-licensed under the The University of Illinois/NCSA +Open Source License (NCSA) and The 3-Clause BSD License** + +# NCSA Open Source License +**Copyright (c) 2019 Kevin Sheppard. All rights reserved.** + +Developed by: Kevin Sheppard (, +) +[http://www.kevinsheppard.com](http://www.kevinsheppard.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal with +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: + +Redistributions of source code must retain the above copyright notice, this +list of conditions and the following disclaimers. + +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimers in the documentation and/or +other materials provided with the distribution. + +Neither the names of Kevin Sheppard, nor the names of any contributors may be +used to endorse or promote products derived from this Software without specific +prior written permission. + +**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 +CONTRIBUTORS 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 WITH +THE SOFTWARE.** + + +# 3-Clause BSD License +**Copyright (c) 2019 Kevin Sheppard. All rights reserved.** + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +**THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF +THE POSSIBILITY OF SUCH DAMAGE.** + +# Components + +Many parts of this module have been derived from original sources, +often the algorithm's designer. Component licenses are located with +the component code. diff --git a/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/random/src/distributions/LICENSE.md b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/random/src/distributions/LICENSE.md new file mode 100644 index 0000000000000000000000000000000000000000..31576ba4b1f26876cae13c0e08b6c7a81b4f8521 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/random/src/distributions/LICENSE.md @@ -0,0 +1,61 @@ +## NumPy + +Copyright (c) 2005-2017, NumPy Developers. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + +* Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + +* Neither the name of the NumPy Developers nor the names of any + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +## Julia + +The ziggurat methods were derived from Julia. + +Copyright (c) 2009-2019: Jeff Bezanson, Stefan Karpinski, Viral B. Shah, +and other contributors: + +https://github.com/JuliaLang/julia/contributors + +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. \ No newline at end of file diff --git a/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/random/src/mt19937/LICENSE.md b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/random/src/mt19937/LICENSE.md new file mode 100644 index 0000000000000000000000000000000000000000..f65c3d46e62406a38d984cd0551fe38a298b2d7f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/random/src/mt19937/LICENSE.md @@ -0,0 +1,61 @@ +# MT19937 + +Copyright (c) 2003-2005, Jean-Sebastien Roy (js@jeannot.org) + +The rk_random and rk_seed functions algorithms and the original design of +the Mersenne Twister RNG: + + Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura, + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + 3. The names of its contributors may not be used to endorse or promote + products derived from this software without specific prior written + permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER +OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +Original algorithm for the implementation of rk_interval function from +Richard J. Wagner's implementation of the Mersenne Twister RNG, optimised by +Magnus Jonsson. + +Constants used in the rk_double implementation by Isaku Wada. + +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. \ No newline at end of file diff --git a/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/random/src/pcg64/LICENSE.md b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/random/src/pcg64/LICENSE.md new file mode 100644 index 0000000000000000000000000000000000000000..7aac7a51c96abdd62bbec2bf9a2b518c868743ec --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/random/src/pcg64/LICENSE.md @@ -0,0 +1,22 @@ +# PCG64 + +## The MIT License + +PCG Random Number Generation for C. + +Copyright 2014 Melissa O'Neill + +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. diff --git a/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/random/src/philox/LICENSE.md b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/random/src/philox/LICENSE.md new file mode 100644 index 0000000000000000000000000000000000000000..9738e44de3b4b7c76d33c8980573577bb83cb828 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/random/src/philox/LICENSE.md @@ -0,0 +1,31 @@ +# PHILOX + +Copyright 2010-2012, D. E. Shaw Research. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + +* Redistributions of source code must retain the above copyright + notice, this list of conditions, and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright + notice, this list of conditions, and the following disclaimer in the + documentation and/or other materials provided with the distribution. + +* Neither the name of D. E. Shaw Research nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/random/src/sfc64/LICENSE.md b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/random/src/sfc64/LICENSE.md new file mode 100644 index 0000000000000000000000000000000000000000..21dd604afe16c2ce8d192a1d5fca9aec6702afee --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/random/src/sfc64/LICENSE.md @@ -0,0 +1,27 @@ +# SFC64 + +## The MIT License + +Adapted from a C++ implementation of Chris Doty-Humphrey's SFC PRNG. + +https://gist.github.com/imneme/f1f7821f07cf76504a97f6537c818083 + +Copyright (c) 2018 Melissa E. O'Neill + +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. diff --git a/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/random/src/splitmix64/LICENSE.md b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/random/src/splitmix64/LICENSE.md new file mode 100644 index 0000000000000000000000000000000000000000..3c4d73b920f6eb58c5fa18144962bf8956601b35 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/licenses/numpy/random/src/splitmix64/LICENSE.md @@ -0,0 +1,9 @@ +# SPLITMIX64 + +Written in 2015 by Sebastiano Vigna (vigna@acm.org) + +To the extent possible under law, the author has dedicated all copyright +and related and neighboring rights to this software to the public domain +worldwide. This software is distributed without any warranty. + +See . \ No newline at end of file diff --git a/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/certifi/LICENSE b/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/certifi/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..62b076cdee58ec8f34034141ba0befd9015b0c7e --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/certifi/LICENSE @@ -0,0 +1,20 @@ +This package contains a modified version of ca-bundle.crt: + +ca-bundle.crt -- Bundle of CA Root Certificates + +This is a bundle of X.509 certificates of public Certificate Authorities +(CA). These were automatically extracted from Mozilla's root certificates +file (certdata.txt). This file can be found in the mozilla source tree: +https://hg.mozilla.org/mozilla-central/file/tip/security/nss/lib/ckfw/builtins/certdata.txt +It contains the certificates in PEM format and therefore +can be directly used with curl / libcurl / php_curl, or with +an Apache+mod_ssl webserver for SSL client authentication. +Just configure this file as the SSLCACertificateFile.# + +***** BEGIN LICENSE BLOCK ***** +This Source Code Form is subject to the terms of the Mozilla Public License, +v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain +one at http://mozilla.org/MPL/2.0/. + +***** END LICENSE BLOCK ***** +@(#) $RCSfile: certdata.txt,v $ $Revision: 1.80 $ $Date: 2011/11/03 15:11:58 $ diff --git a/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/idna/LICENSE.md b/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/idna/LICENSE.md new file mode 100644 index 0000000000000000000000000000000000000000..256ba90cd91190a6c980bd44663dc51c201c14d3 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/idna/LICENSE.md @@ -0,0 +1,31 @@ +BSD 3-Clause License + +Copyright (c) 2013-2025, Kim Davies and contributors. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED +TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/pkg_resources/LICENSE b/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/pkg_resources/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..1bb5a44356f00884a71ceeefd24ded6caaba2418 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/pkg_resources/LICENSE @@ -0,0 +1,17 @@ +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. diff --git a/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/platformdirs/LICENSE b/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/platformdirs/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f35fed9191b1142ddaada8a96de4a9461c5d796c --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/platformdirs/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2010-202x The platformdirs developers + +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. diff --git a/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/pyproject_hooks/LICENSE b/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/pyproject_hooks/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b0ae9dbc262b5f7ed4cb6f964cfb5eb5c0d0b0be --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/pyproject_hooks/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2017 Thomas Kluyver + +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. diff --git a/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/requests/LICENSE b/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/requests/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..67db8588217f266eb561f75fae738656325deac9 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/requests/LICENSE @@ -0,0 +1,175 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. diff --git a/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/resolvelib/LICENSE b/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/resolvelib/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b9077766e9b9bdcae49ea5c8fced750ed13ec8f7 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/resolvelib/LICENSE @@ -0,0 +1,13 @@ +Copyright (c) 2018, Tzu-ping Chung + +Permission to use, copy, modify, and distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. diff --git a/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/rich/LICENSE b/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/rich/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..4415505566f261c802b671426be529a31f914137 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/rich/LICENSE @@ -0,0 +1,19 @@ +Copyright (c) 2020 Will McGugan + +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. diff --git a/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/tomli/LICENSE b/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/tomli/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..e859590f886cd78344206af1a8ccb3080d4385e0 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/tomli/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2021 Taneli Hukkinen + +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. diff --git a/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/tomli_w/LICENSE b/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/tomli_w/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..e859590f886cd78344206af1a8ccb3080d4385e0 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/tomli_w/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2021 Taneli Hukkinen + +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. diff --git a/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/urllib3/LICENSE.txt b/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/urllib3/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..429a1767e4476707d2e45ee499e3c834ca4b187f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/pip-26.0.1.dist-info/licenses/src/pip/_vendor/urllib3/LICENSE.txt @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2008-2020 Andrey Petrov and contributors (see CONTRIBUTORS.txt) + +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. diff --git a/.venv_haddock/lib/python3.12/site-packages/plotly-6.5.2.dist-info/licenses/LICENSE.txt b/.venv_haddock/lib/python3.12/site-packages/plotly-6.5.2.dist-info/licenses/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..13ffac3c942fd6f6e8af7d4e58860bb306db3e2f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/plotly-6.5.2.dist-info/licenses/LICENSE.txt @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2016-2024 Plotly Technologies Inc. + +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. diff --git a/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..94471b80dd6aa64f00760b6f73b2a3327a7b82be Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/__pycache__/cli.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/__pycache__/cli.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ae4e5f50927b8768ddae95ee7e0be8eac800beb2 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/__pycache__/cli.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/data/naccess.config b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/data/naccess.config new file mode 100644 index 0000000000000000000000000000000000000000..646f4ca2ead2669c7859abf17d5b74269c340f7a --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/data/naccess.config @@ -0,0 +1,256 @@ +# Contributed by João Rodrigues + +name: NACCESS + +types: +C_ALI 1.87 apolar +C_CAR 1.76 apolar +C_NUC 1.80 apolar +N_AMN 1.50 polar +N_AMD 1.65 polar +N_NUC 1.60 polar +O 1.40 polar +S 1.85 apolar +SE 1.80 apolar +P 1.90 apolar + +atoms: +ANY C C_CAR +ANY O O +ANY CA C_ALI +ANY N N_AMD +ANY CB C_ALI +ANY OXT O +# nucleic acid +ANY P P +ANY OP1 O +ANY OP2 O +ANY OP3 O +ANY O5' O +ANY O4' O +ANY O3' O +ANY O2' O +ANY C5' C_NUC +ANY C4' C_NUC +ANY C3' C_NUC +ANY C2' C_NUC +ANY C1' C_NUC + +ALA CB C_ALI # included so that RSA values will be generated + +ARG CG C_ALI +ARG CD C_ALI +ARG NE N_AMD +ARG CZ C_CAR +ARG NH1 N_AMD +ARG NH2 N_AMD + +ASN CG C_CAR +ASN OD1 O +ASN ND2 N_AMD + +ASP CG C_CAR +ASP OD1 O +ASP OD2 O + +CYS SG S + +GLN CG C_ALI +GLN CD C_CAR +GLN OE1 O +GLN NE2 N_AMD + +GLU CG C_ALI +GLU CD C_CAR +GLU OE1 O +GLU OE2 O + +GLY CA C_ALI # included so that RSA values will be generated + +HIS CG C_CAR +HIS ND1 N_AMD +HIS CD2 C_CAR +HIS NE2 N_AMD +HIS CE1 C_CAR + +ILE CG1 C_ALI +ILE CG2 C_ALI +ILE CD1 C_ALI + +LEU CG C_ALI +LEU CD1 C_ALI +LEU CD2 C_ALI + +LYS CG C_ALI +LYS CD C_ALI +LYS CE C_ALI +LYS NZ N_AMN + +MET CG C_ALI +MET SD S +MET CE C_ALI + +PHE CG C_CAR +PHE CD1 C_CAR +PHE CD2 C_CAR +PHE CE1 C_CAR +PHE CE2 C_CAR +PHE CZ C_CAR + +PRO CG C_ALI +PRO CD C_ALI + +SEC SE SE + +SER OG O + +THR OG1 O +THR CG2 C_ALI + +TRP CG C_CAR +TRP CD1 C_CAR +TRP CD2 C_CAR +TRP NE1 N_AMD +TRP CE2 C_CAR +TRP CE3 C_CAR +TRP CZ2 C_CAR +TRP CZ3 C_CAR +TRP CH2 C_CAR + +TYR CG C_CAR +TYR CD1 C_CAR +TYR CD2 C_CAR +TYR CE1 C_CAR +TYR CE2 C_CAR +TYR CZ C_CAR +TYR OH O + +VAL CG1 C_ALI +VAL CG2 C_ALI + +A N9 N_NUC +A C8 C_NUC +A N7 N_NUC +A C5 C_NUC +A C6 C_NUC +A N6 N_NUC +A N1 N_NUC +A C2 C_NUC +A N3 N_NUC +A C4 C_NUC + +C N1 N_NUC +C C2 C_NUC +C O2 O +C N3 N_NUC +C C4 C_NUC +C N4 N_NUC +C C5 C_NUC +C C6 C_NUC + +G N9 N_NUC +G C8 C_NUC +G N7 N_NUC +G C5 C_NUC +G C6 C_NUC +G O6 O +G N1 N_NUC +G C2 C_NUC +G N2 N_NUC +G N3 N_NUC +G C4 C_NUC + +I N9 N_NUC +I C8 C_NUC +I N7 N_NUC +I C5 C_NUC +I C6 C_NUC +I O6 O +I N1 N_NUC +I C2 C_NUC +I N3 N_NUC +I C4 C_NUC + +T N1 N_NUC +T C2 C_NUC +T O2 O +T N3 N_NUC +T C4 C_NUC +T O4 O +T C5 C_NUC +T C7 C_NUC +T C6 C_NUC + +U N1 N_NUC +U C2 C_NUC +U O2 O +U N3 N_NUC +U C4 C_NUC +U O4 O +U C5 C_NUC +U C6 C_NUC + +DA N9 N_NUC +DA C8 C_NUC +DA N7 N_NUC +DA C5 C_NUC +DA C6 C_NUC +DA N6 N_NUC +DA N1 N_NUC +DA C2 C_NUC +DA N3 N_NUC +DA C4 C_NUC + +DC N1 N_NUC +DC C2 C_NUC +DC O2 O +DC N3 N_NUC +DC C4 C_NUC +DC N4 N_NUC +DC C5 C_NUC +DC C6 C_NUC + +DG N9 N_NUC +DG C8 C_NUC +DG N7 N_NUC +DG C5 C_NUC +DG C6 C_NUC +DG O6 O +DG N1 N_NUC +DG C2 C_NUC +DG N2 N_NUC +DG N3 N_NUC +DG C4 C_NUC + +DI N9 N_NUC +DI C8 C_NUC +DI N7 N_NUC +DI C5 C_NUC +DI C6 C_NUC +DI O6 O +DI N1 N_NUC +DI C2 C_NUC +DI N3 N_NUC +DI C4 C_NUC + +DT N1 N_NUC +DT C2 C_NUC +DT O2 O +DT N3 N_NUC +DT C4 C_NUC +DT O4 O +DT C5 C_NUC +DT C7 C_NUC +DT C6 C_NUC + +DU N1 N_NUC +DU C2 C_NUC +DU O2 O +DU N3 N_NUC +DU C4 C_NUC +DU O4 O +DU C5 C_NUC +DU C6 C_NUC + + + diff --git a/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/__init__.py b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b6c703f28793a5ef353400750e424108d4174534 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/__pycache__/aa_properties.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/__pycache__/aa_properties.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..25edf92aa27ccdd64ae1bbcfb016231ec6bf1c7d Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/__pycache__/aa_properties.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/__pycache__/freesasa_tools.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/__pycache__/freesasa_tools.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8d8f5af20013993d6f715e6d8ca1f16177d7e1cd Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/__pycache__/freesasa_tools.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/__pycache__/models.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/__pycache__/models.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..474cfa7071364dfe22657aaa119f8204b9f7c8b4 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/__pycache__/models.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/__pycache__/parsers.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/__pycache__/parsers.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..97accefd1944e907c374681592c3a139277d7f0c Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/__pycache__/parsers.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/__pycache__/prodigy.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/__pycache__/prodigy.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4db47e0f59555fa665444c6089c79aa4b9aefae2 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/__pycache__/prodigy.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/__pycache__/utils.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/__pycache__/utils.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e50971685909c3c71f9a4742280e7bf5dc8a7a71 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/__pycache__/utils.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/aa_properties.py b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/aa_properties.py new file mode 100644 index 0000000000000000000000000000000000000000..0995a5a1362d90cd1d99b95e6b571b17cee3a6c8 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/aa_properties.py @@ -0,0 +1,122 @@ +""" +Generic properties of amino acids required for the binding affinity +prediction methods. +""" + +aa_character_ic: dict[str, str] = { + "ALA": "A", + "CYS": "A", # ? + "GLU": "C", + "ASP": "C", + "GLY": "A", + "PHE": "A", + "ILE": "A", + "HIS": "C", + "LYS": "C", + "MET": "A", + "LEU": "A", + "ASN": "P", + "GLN": "P", + "PRO": "A", + "SER": "P", + "ARG": "C", + "THR": "P", + "TRP": "A", + "VAL": "A", + "TYR": "A", +} + +aa_character_protorp: dict[str, str] = { + "ALA": "A", + "CYS": "P", + "GLU": "C", + "ASP": "C", + "GLY": "A", + "PHE": "A", + "ILE": "A", + "HIS": "P", + "LYS": "C", + "MET": "A", + "LEU": "A", + "ASN": "P", + "GLN": "P", + "PRO": "A", + "SER": "P", + "ARG": "C", + "THR": "P", + "TRP": "P", + "VAL": "A", + "TYR": "P", +} + +# Scaling factors for relative ASA +# Calculated using extended ALA-X-ALA peptides +# Taken from NACCESS +rel_asa: dict[str, dict[str, float]] = { + "total": { + "ALA": 107.95, + "CYS": 134.28, + "ASP": 140.39, + "GLU": 172.25, + "PHE": 199.48, + "GLY": 80.10, + "HIS": 182.88, + "ILE": 175.12, + "LYS": 200.81, + "LEU": 178.63, + "MET": 194.15, + "ASN": 143.94, + "PRO": 136.13, + "GLN": 178.50, + "ARG": 238.76, + "SER": 116.50, + "THR": 139.27, + "VAL": 151.44, + "TRP": 249.36, + "TYR": 212.76, + }, + "bb": { + "ALA": 38.54, + "CYS": 37.53, + "ASP": 37.70, + "GLU": 37.51, + "PHE": 35.37, + "GLY": 47.77, + "HIS": 35.80, + "ILE": 37.16, + "LYS": 37.51, + "LEU": 37.51, + "MET": 37.51, + "ASN": 37.70, + "PRO": 16.23, + "GLN": 37.51, + "ARG": 37.51, + "SER": 38.40, + "THR": 37.57, + "VAL": 37.16, + "TRP": 38.10, + "TYR": 35.38, + }, + "sc": { + "ALA": 69.41, + "CYS": 96.75, + "ASP": 102.69, + "GLU": 134.74, + "PHE": 164.11, + "GLY": 32.33, + "HIS": 147.08, + "ILE": 137.96, + "LYS": 163.30, + "LEU": 141.12, + "MET": 156.64, + "ASN": 106.24, + "PRO": 119.90, + "GLN": 140.99, + "ARG": 201.25, + "SER": 78.11, + "THR": 101.70, + "VAL": 114.28, + "TRP": 211.26, + "TYR": 177.38, + }, +} diff --git a/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/freesasa_tools.py b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/freesasa_tools.py new file mode 100644 index 0000000000000000000000000000000000000000..a4d943e61f98732a5b6772f381166c9d9fbb2cf0 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/freesasa_tools.py @@ -0,0 +1,65 @@ +""" +Functions to execute freesasa and parse its output. +""" + +import os + +import freesasa +from Bio.PDB.Structure import Structure +from freesasa import Classifier, calc, structureFromBioPDB + +from prodigy_prot import NACCESS_CONFIG +from prodigy_prot.modules.aa_properties import rel_asa + +freesasa.setVerbosity(freesasa.nowarnings) + + +def execute_freesasa_api(structure: Structure) -> tuple[dict, dict]: + """ + Calls freesasa using its Python API and returns + per-residue accessibilities. + """ + + asa_data = {} + rsa_data: dict[tuple[str, int, str], float] = {} + _rsa: dict = rel_asa["total"] + + classifier = Classifier(str(NACCESS_CONFIG)) + + try: + struct = structureFromBioPDB( + structure, + classifier, + ) + result = calc(struct) + except AssertionError as e: + error_message = "" + os.linesep + error_message += "[!] Error when running freesasa:" + os.linesep + error_message += f"[!] {e}" + os.linesep + error_message += ( + "[!] Make sure the atom names in your PDB file match" + " the canonical naming and belong " + "to default residues" + os.linesep + ) + print(error_message) + raise Exception(error_message) + + # iterate over all atoms to get SASA and residue name + for idx in range(struct.nAtoms()): + atname = struct.atomName(idx) + resname = struct.residueName(idx) + resid = struct.residueNumber(idx) + chain = struct.chainLabel(idx) + at_uid = (chain, resname, resid, atname) + res_uid = (chain, resname, resid) + + asa = result.atomArea(idx) + asa_data[at_uid] = asa + # add asa to residue + rsa_data[res_uid] = rsa_data.get(res_uid, 0) + asa + + # convert total asa ro relative asa + rsa_data.update( + (res_uid, asa / _rsa[res_uid[1]]) for res_uid, asa in rsa_data.items() + ) + return asa_data, rsa_data diff --git a/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/models.py b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/models.py new file mode 100644 index 0000000000000000000000000000000000000000..ce1ecf8c5d82df18824d9888aa68a89177ccbaee --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/models.py @@ -0,0 +1,41 @@ +""" +Models to predict binding affinity based on molecular properties. +""" + + +def IC_NIS( + ic_cc: float, + ic_ca: float, + ic_pp: float, + ic_pa: float, + p_nis_a: float, + p_nis_c: float, +) -> float: + """ + Calculates the predicted binding affinity value + based on the IC-NIS model. + """ + + return ( + -0.09459 * ic_cc + + -0.10007 * ic_ca + + 0.19577 * ic_pp + + -0.22671 * ic_pa + + 0.18681 * p_nis_a + + 0.13810 * p_nis_c + + -15.9433 + ) + + +def NIS(p_nis_c: float, p_nis_p: float, n_int_atoms: float) -> float: + """ + Calculates the predicted binding affinity value + based on the NIS model. + """ + + return ( + 0.0856851248873 * p_nis_p + + -0.0685254498746 * p_nis_c + + 0.0261591389985 * n_int_atoms + + 3.0124939659498 + ) diff --git a/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/parsers.py b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/parsers.py new file mode 100644 index 0000000000000000000000000000000000000000..0d8002b7c0b417e08fee223006a2892d0edb810d --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/parsers.py @@ -0,0 +1,166 @@ +""" +Functions to read PDB/mmCIF files +""" + +import logging +import sys +import warnings +from pathlib import Path +from typing import Optional, Union + +from Bio.PDB.Chain import Chain +from Bio.PDB.MMCIFParser import MMCIFParser +from Bio.PDB.PDBExceptions import PDBConstructionWarning +from Bio.PDB.PDBParser import PDBParser +from Bio.PDB.Polypeptide import PPBuilder, is_aa +from Bio.PDB.Structure import Structure + +warnings.filterwarnings("ignore", category=PDBConstructionWarning) +log = logging.getLogger("Prodigy") + + +def get_parser(input_f: Path) -> Union[PDBParser, MMCIFParser]: + if input_f.suffix == ".cif": + return MMCIFParser() + else: + return PDBParser() + + +def validate_structure( + s: Structure, selection: Optional[list[str]] = None, clean: bool = True +) -> Structure: + + # setup logging + logger = logging.getLogger("Prodigy") + + # Keep first model only + if len(s) > 1: + logger.warning( + ( + "[!] Structure contains more than one model." + " Only the first one will be kept" + ) + ) + model_one = s[0].id + for m in s.child_list[:]: + if m.id != model_one: + s.detach_child(m.id) + + # process selected chains + chains: list[Chain] = list(s.get_chains()) + chain_ids = set([c.id for c in chains]) + + if selection: + sel_chains = [] + # Match selected chain with structure + for sel in selection: + for c_str in sel.split(","): + sel_chains.append(c_str) + if c_str not in chain_ids: + raise ValueError( + f"Selected chain not present in provided structure: {c_str}" + ) + + # Remove unselected chains + def _ignore_helper(x) -> bool: + return x.id not in sel_chains + + for c in chains: + if _ignore_helper(c): + if c.parent is not None: + c.parent.detach_child(c.id) + + # Double occupancy check + for atom in list(s.get_atoms()): + if atom.is_disordered(): + residue = atom.parent + sel_at = atom.selected_child + sel_at.altloc = " " + sel_at.disordered_flag = 0 + residue.detach_child(atom.id) + residue.add(sel_at) + + # Insertion code check + for c in chains: + for residue in c.get_residues(): + if residue.get_id()[2] != " ": + c.detach_child(residue.id) + + if clean: + # Remove HETATMs and solvent + res_list = list(s.get_residues()) + + def _ignore(r): + return r.id[0][0] == "W" or r.id[0][0] == "H" + + for res in res_list: + if _ignore(res): + chain = res.parent + chain.detach_child(res.id) + elif not is_aa(res, standard=True): + raise ValueError( + "Unsupported non-standard amino acid found: {0}".format(res.resname) + ) + + # Remove Hydrogens + atom_list = list(s.get_atoms()) + + def _ignore(x): + return x.element == "H" + + for atom in atom_list: + if _ignore(atom): + residue = atom.parent + residue.detach_child(atom.name) + + # Detect gaps and compare with no. of chains + pep_builder = PPBuilder() + peptides = pep_builder.build_peptides(s) + n_peptides = len(peptides) + + if n_peptides != len(chain_ids): + message = "[!] Structure contains gaps:\n" + for i_pp, pp in enumerate(peptides): + message += ( + "\t{1.parent.id} {1.resname}{1.id[1]} < Fragment {0} > " + "{2.parent.id} {2.resname}{2.id[1]}\n".format(i_pp, pp[0], pp[-1]) + ) + logger.warning(message) + # raise Exception(message) + + return s + + +def parse_structure(path: str) -> tuple[Structure, int, int]: + """Return a validated `Structure`, number of chains and number of residues""" + + extension = Path(path).suffix + supported_extensions = [".pdb", ".cif", ".ent"] + if extension not in supported_extensions: + log.error( + f"[!] Structure format '{extension}' is " + "not supported. Use '.pdb' or '.cif'." + ) + sys.exit(1) + + parser = get_parser(Path(path)) + structure_name = Path(path).stem + structure_path = Path(path) + try: + original_structure = parser.get_structure(structure_name, structure_path) + except Exception as e: + log.exception(e) + sys.exit(1) + + assert isinstance(original_structure, Structure) + + structure = validate_structure(original_structure) + + # Get number of chains + number_of_chains = len(set([c.id for c in structure.get_chains()])) + + # Get number of residues + number_of_residues = len(list(structure.get_residues())) + + # structure, n_chains, n_res = parse_structure(path=str(struct_path)) + return (structure, number_of_chains, number_of_residues) diff --git a/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/prodigy.py b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/prodigy.py new file mode 100644 index 0000000000000000000000000000000000000000..2f094534f3c94499631fb91591047e9c57f4bca7 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/prodigy.py @@ -0,0 +1,298 @@ +import sys +from io import TextIOWrapper +from typing import Optional, TextIO, Union + +from Bio.PDB.NeighborSearch import NeighborSearch +from Bio.PDB.Structure import Structure + +from prodigy_prot.modules import aa_properties +from prodigy_prot.modules.freesasa_tools import execute_freesasa_api +from prodigy_prot.modules.models import IC_NIS +from prodigy_prot.modules.utils import dg_to_kd + + +def calculate_ic( + struct: Structure, d_cutoff: float = 5.5, selection: Optional[dict[str, int]] = None +) -> list: + """ + Calculates intermolecular contacts in a parsed struct object. + """ + atom_list = list(struct.get_atoms()) + ns = NeighborSearch(atom_list) + all_list = ns.search_all(radius=d_cutoff, level="R") + + assert all_list is not None + + if selection: + _sd = selection + + def _chain(x): + return x.parent.id + + ic_list = [ + c + for c in all_list + if (_chain(c[0]) in _sd and _chain(c[1]) in _sd) + and (_sd[_chain(c[0])] != _sd[_chain(c[1])]) + ] + else: + ic_list = [c for c in all_list if c[0].parent.id != c[1].parent.id] + + if not ic_list: + raise ValueError("No contacts found for selection") + + ic_list.sort() + return ic_list + + +def analyse_contacts(contact_list: list) -> dict[str, float]: + """ + Enumerates and classifies contacts based on the chemical characteristics + of the participating amino acids. + """ + + bins = { + "AA": 0.0, + "PP": 0.0, + "CC": 0.0, + "AP": 0.0, + "CP": 0.0, + "AC": 0.0, + } + + _data = aa_properties.aa_character_ic + for res_i, res_j in contact_list: + i = _data.get(res_i.resname) + j = _data.get(res_j.resname) + if i is not None and j is not None: + contact_type = "".join(sorted((i, j))) + bins[contact_type] += 1 + + return bins + + +def analyse_nis(sasa_dict: dict, acc_threshold: float = 0.05) -> list[float]: + """ + Returns the percentages of apolar, polar, and charged + residues at the interface, according to an accessibility + criterion. + """ + + _data = aa_properties.aa_character_protorp + + def _char_to_index(x): + return {"A": 0, "C": 1, "P": 2}.get(x) + + count = [0, 0, 0] + + for res, rsa in sasa_dict.items(): + _, resn, _ = res + if rsa >= acc_threshold: + aa_character = _data[resn] + aa_index = _char_to_index(aa_character) + assert aa_index is not None + count[aa_index] += 1 + + percentages = [100.0 * x / sum(count) for x in count] + # print('[+] No. of buried interface residues: {0}'.format(sum(count))) + return percentages + + +class Prodigy: + # init parameters + def __init__( + self, + struct_obj: Structure, + selection: Optional[list[str]] = None, + temp: float = 25.0, + ): + self.temp = float(temp) + if selection is None: + self.selection = [chain.id for chain in struct_obj.get_chains()] + else: + self.selection = selection + self.structure = struct_obj + self.ic_network: list = [] + self.bins: dict[str, float] = { + "CC": 0.0, + "CP": 0.0, + "AC": 0.0, + "PP": 0.0, + "AP": 0.0, + "AA": 0.0, + } + + self.nis_a = 0.0 + self.nis_c = 0.0 + self.ba_val = 0.0 + self.kd_val = 0.0 + + def predict( + self, + temp: Optional[float] = None, + distance_cutoff: float = 5.5, + acc_threshold: float = 0.05, + ): + if temp is not None: + self.temp = temp + # Make selection dict from user option or PDB chains + selection_dict: dict[str, int] = {} + for igroup, group in enumerate(self.selection): + chains = group.split(",") + for chain in chains: + if chain in selection_dict: + errmsg = "Selections must be disjoint sets: " f"{chain} is repeated" + raise ValueError(errmsg) + selection_dict[chain] = igroup + + # Contacts + self.ic_network = calculate_ic( + self.structure, d_cutoff=distance_cutoff, selection=selection_dict + ) + + self.bins = analyse_contacts(self.ic_network) + + # SASA + _, cmplx_sasa = execute_freesasa_api(self.structure) + self.nis_a, self.nis_c, _ = analyse_nis(cmplx_sasa, acc_threshold=acc_threshold) + + # Affinity Calculation + self.ba_val = IC_NIS( + self.bins["CC"], + self.bins["AC"], + self.bins["PP"], + self.bins["AP"], + self.nis_a, + self.nis_c, + ) + self.kd_val = dg_to_kd(self.ba_val, self.temp) + + def as_dict(self) -> dict: + return_dict = { + "structure": self.structure.id, + "selection": self.selection, + "temp": self.temp, + "ICs": len(self.ic_network), + "nis_a": self.nis_a, + "nis_c": self.nis_c, + "ba_val": self.ba_val, + "kd_val": self.kd_val, + } + return_dict.update(self.bins) + return return_dict + + def print_prediction(self, outfile: str = "", quiet: bool = False) -> None: + handle: Union[TextIOWrapper, TextIO] + if outfile: + handle = open(outfile, "w") + else: + handle = sys.stdout + + if quiet: + handle.write("{0}\t{1:8.3f}\n".format(self.structure.id, self.ba_val)) + else: + handle.write( + "[+] No. of intermolecular contacts: {0}\n".format(len(self.ic_network)) + ) + handle.write( + "[+] No. of charged-charged contacts: {0}\n".format(self.bins["CC"]) + ) + handle.write( + "[+] No. of charged-polar contacts: {0}\n".format(self.bins["CP"]) + ) + handle.write( + "[+] No. of charged-apolar contacts: {0}\n".format(self.bins["AC"]) + ) + handle.write( + "[+] No. of polar-polar contacts: {0}\n".format(self.bins["PP"]) + ) + handle.write( + "[+] No. of apolar-polar contacts: {0}\n".format(self.bins["AP"]) + ) + handle.write( + "[+] No. of apolar-apolar contacts: {0}\n".format(self.bins["AA"]) + ) + + handle.write( + "[+] Percentage of apolar NIS residues: {0:3.2f}\n".format(self.nis_a) + ) + handle.write( + "[+] Percentage of charged NIS residues: {0:3.2f}\n".format(self.nis_c) + ) + handle.write( + "[++] Predicted binding " + "affinity (kcal.mol-1): {0:8.1f}\n".format(self.ba_val) + ) + handle.write( + "[++] Predicted dissociation constant (M) at {:.1f}˚C:" + " {:8.1e}\n".format(self.temp, self.kd_val) + ) + + if handle is not sys.stdout: + handle.close() + + def print_contacts(self, outfile: str = "") -> None: + handle: Union[TextIOWrapper, TextIO] + if outfile: + handle = open(outfile, "w") + else: + handle = sys.stdout + + for res1, res2 in self.ic_network: + _fmt_str = ( + "{0.resname:>5s} {0.id[1]:5} {0.parent.id:>3s} {1.resname:>5s}" + " {1.id[1]:5} {1.parent.id:>3s}\n" + ) + if res1.parent.id not in self.selection[0]: + res1, res2 = res2, res1 + handle.write(_fmt_str.format(res1, res2)) + + if handle is not sys.stdout: + handle.close() + + def print_pymol_script(self, outfile: str = "") -> None: + # Writing output PYMOL: pml script + # initialize array with chains and save chain selection string + selection_strings = [] + chains: dict[str, set] = {} + for s in self.selection: + selection_strings.append(s.replace(",", "+")) + for c in s.split(","): + chains[c] = set() + + # loop over pairs and add interface residues to respective chains + for pair in self.ic_network: + for r in pair: + chains[r.parent.id].add(str(r.id[1])) + + # set output stream + handle = open(outfile, "w") if outfile else sys.stdout + + # write default setup strings + handle.writelines( + [ + "color silver\n", + "as cartoon\n", + "bg_color white\n", + "center\n", + "color lightblue, chain {}\n".format(selection_strings[0]), + "color lightpink, chain {}\n".format(selection_strings[1]), + ] + ) + + # loop over interfaces construct selection strings + # and write interface related commands + for color, iface in [("blue", 1), ("hotpink", 2)]: + p_sel_string = " or ".join( + [ + "chain {} and resi {}".format(c, "+".join(chains[c])) + for c in selection_strings[iface - 1].split("+") + ] + ) + handle.write("select iface{}, {}\n".format(iface, p_sel_string)) + handle.write("color {}, iface{}\n".format(color, iface)) + handle.write("show sticks, iface{}\n".format(iface)) + + # close file handle if applicable + if handle is not sys.stdout: + handle.close() diff --git a/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/utils.py b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..056b1de0092b99421875f9ec8f6a45819f069dde --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/prodigy_prot/modules/utils.py @@ -0,0 +1,25 @@ +""" +Assorted utility functions. +""" + +import math +import os + + +def check_path(path: str) -> str: + """ + Checks if a file is readable. + """ + + full_path = os.path.abspath(path) + if not os.path.isfile(full_path): + raise IOError("Could not read file: {0}".format(path)) + return full_path + + +def dg_to_kd(dg: float, temperature: float = 25.0) -> float: + """Coversion of DG into the dissociation constant kd""" + + temp_in_k = temperature + 273.15 + rt = 0.0019858775 * temp_in_k + return math.exp(dg / rt) diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0ae462a640a8862d3d6fc71c4f8443020455157b Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/__pycache__/vq.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/__pycache__/vq.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5fbb74864f334c256d6bf3c72be94840bd93d81a Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/__pycache__/vq.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/__init__.py b/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4a7378f4759183f5178dc362fd1acfd9f960f22d Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/__pycache__/hierarchy_test_data.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/__pycache__/hierarchy_test_data.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..771ae5ee5d39055cf859cfa7843a9977be95e404 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/__pycache__/hierarchy_test_data.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/__pycache__/test_disjoint_set.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/__pycache__/test_disjoint_set.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1525e96630e7573ddef777077c7bbb6857f2f834 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/__pycache__/test_disjoint_set.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/__pycache__/test_hierarchy.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/__pycache__/test_hierarchy.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1209c551075848162317f1b61e2290f9f57055db Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/__pycache__/test_hierarchy.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/__pycache__/test_vq.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/__pycache__/test_vq.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6274a4f997d7912efa06204be42df98c45c14d93 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/__pycache__/test_vq.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/hierarchy_test_data.py b/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/hierarchy_test_data.py new file mode 100644 index 0000000000000000000000000000000000000000..7d874ca5eb7141a44559307d1c28dd412171396f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/hierarchy_test_data.py @@ -0,0 +1,145 @@ +from numpy import array + + +Q_X = array([[5.26563660e-01, 3.14160190e-01, 8.00656370e-02], + [7.50205180e-01, 4.60299830e-01, 8.98696460e-01], + [6.65461230e-01, 6.94011420e-01, 9.10465700e-01], + [9.64047590e-01, 1.43082200e-03, 7.39874220e-01], + [1.08159060e-01, 5.53028790e-01, 6.63804780e-02], + [9.31359130e-01, 8.25424910e-01, 9.52315440e-01], + [6.78086960e-01, 3.41903970e-01, 5.61481950e-01], + [9.82730940e-01, 7.04605210e-01, 8.70978630e-02], + [6.14691610e-01, 4.69989230e-02, 6.02406450e-01], + [5.80161260e-01, 9.17354970e-01, 5.88163850e-01], + [1.38246310e+00, 1.96358160e+00, 1.94437880e+00], + [2.10675860e+00, 1.67148730e+00, 1.34854480e+00], + [1.39880070e+00, 1.66142050e+00, 1.32224550e+00], + [1.71410460e+00, 1.49176380e+00, 1.45432170e+00], + [1.54102340e+00, 1.84374950e+00, 1.64658950e+00], + [2.08512480e+00, 1.84524350e+00, 2.17340850e+00], + [1.30748740e+00, 1.53801650e+00, 2.16007740e+00], + [1.41447700e+00, 1.99329070e+00, 1.99107420e+00], + [1.61943490e+00, 1.47703280e+00, 1.89788160e+00], + [1.59880600e+00, 1.54988980e+00, 1.57563350e+00], + [3.37247380e+00, 2.69635310e+00, 3.39981700e+00], + [3.13705120e+00, 3.36528090e+00, 3.06089070e+00], + [3.29413250e+00, 3.19619500e+00, 2.90700170e+00], + [2.65510510e+00, 3.06785900e+00, 2.97198540e+00], + [3.30941040e+00, 2.59283970e+00, 2.57714110e+00], + [2.59557220e+00, 3.33477370e+00, 3.08793190e+00], + [2.58206180e+00, 3.41615670e+00, 3.26441990e+00], + [2.71127000e+00, 2.77032450e+00, 2.63466500e+00], + [2.79617850e+00, 3.25473720e+00, 3.41801560e+00], + [2.64741750e+00, 2.54538040e+00, 3.25354110e+00]]) + +ytdist = array([662., 877., 255., 412., 996., 295., 468., 268., 400., 754., + 564., 138., 219., 869., 669.]) + +linkage_ytdist_single = array([[2., 5., 138., 2.], + [3., 4., 219., 2.], + [0., 7., 255., 3.], + [1., 8., 268., 4.], + [6., 9., 295., 6.]]) + +linkage_ytdist_complete = array([[2., 5., 138., 2.], + [3., 4., 219., 2.], + [1., 6., 400., 3.], + [0., 7., 412., 3.], + [8., 9., 996., 6.]]) + +linkage_ytdist_average = array([[2., 5., 138., 2.], + [3., 4., 219., 2.], + [0., 7., 333.5, 3.], + [1., 6., 347.5, 3.], + [8., 9., 680.77777778, 6.]]) + +linkage_ytdist_weighted = array([[2., 5., 138., 2.], + [3., 4., 219., 2.], + [0., 7., 333.5, 3.], + [1., 6., 347.5, 3.], + [8., 9., 670.125, 6.]]) + +# the optimal leaf ordering of linkage_ytdist_single +linkage_ytdist_single_olo = array([[5., 2., 138., 2.], + [4., 3., 219., 2.], + [7., 0., 255., 3.], + [1., 8., 268., 4.], + [6., 9., 295., 6.]]) + +X = array([[1.43054825, -7.5693489], + [6.95887839, 6.82293382], + [2.87137846, -9.68248579], + [7.87974764, -6.05485803], + [8.24018364, -6.09495602], + [7.39020262, 8.54004355]]) + +linkage_X_centroid = array([[3., 4., 0.36265956, 2.], + [1., 5., 1.77045373, 2.], + [0., 2., 2.55760419, 2.], + [6., 8., 6.43614494, 4.], + [7., 9., 15.17363237, 6.]]) + +linkage_X_median = array([[3., 4., 0.36265956, 2.], + [1., 5., 1.77045373, 2.], + [0., 2., 2.55760419, 2.], + [6., 8., 6.43614494, 4.], + [7., 9., 15.17363237, 6.]]) + +linkage_X_ward = array([[3., 4., 0.36265956, 2.], + [1., 5., 1.77045373, 2.], + [0., 2., 2.55760419, 2.], + [6., 8., 9.10208346, 4.], + [7., 9., 24.7784379, 6.]]) + +# the optimal leaf ordering of linkage_X_ward +linkage_X_ward_olo = array([[4., 3., 0.36265956, 2.], + [5., 1., 1.77045373, 2.], + [2., 0., 2.55760419, 2.], + [6., 8., 9.10208346, 4.], + [7., 9., 24.7784379, 6.]]) + +inconsistent_ytdist = { + 1: array([[138., 0., 1., 0.], + [219., 0., 1., 0.], + [255., 0., 1., 0.], + [268., 0., 1., 0.], + [295., 0., 1., 0.]]), + 2: array([[138., 0., 1., 0.], + [219., 0., 1., 0.], + [237., 25.45584412, 2., 0.70710678], + [261.5, 9.19238816, 2., 0.70710678], + [233.66666667, 83.9424406, 3., 0.7306594]]), + 3: array([[138., 0., 1., 0.], + [219., 0., 1., 0.], + [237., 25.45584412, 2., 0.70710678], + [247.33333333, 25.38372182, 3., 0.81417007], + [239., 69.36377537, 4., 0.80733783]]), + 4: array([[138., 0., 1., 0.], + [219., 0., 1., 0.], + [237., 25.45584412, 2., 0.70710678], + [247.33333333, 25.38372182, 3., 0.81417007], + [235., 60.73302232, 5., 0.98793042]])} + +fcluster_inconsistent = { + 0.8: array([6, 2, 2, 4, 6, 2, 3, 7, 3, 5, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1]), + 1.0: array([6, 2, 2, 4, 6, 2, 3, 7, 3, 5, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1]), + 2.0: array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1])} + +fcluster_distance = { + 0.6: array([4, 4, 4, 4, 4, 4, 4, 5, 4, 4, 6, 6, 6, 6, 6, 7, 6, 6, 6, 6, 3, + 1, 1, 1, 2, 1, 1, 1, 1, 1]), + 1.0: array([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1]), + 2.0: array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1])} + +fcluster_maxclust = { + 8.0: array([5, 5, 5, 5, 5, 5, 5, 6, 5, 5, 7, 7, 7, 7, 7, 8, 7, 7, 7, 7, 4, + 1, 1, 1, 3, 1, 1, 1, 1, 2]), + 4.0: array([3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, + 1, 1, 1, 1, 1, 1, 1, 1, 1]), + 1.0: array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1])} diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/test_disjoint_set.py b/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/test_disjoint_set.py new file mode 100644 index 0000000000000000000000000000000000000000..a73512d35eef168f625a1942a87d248e73a71aa2 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/test_disjoint_set.py @@ -0,0 +1,202 @@ +import pytest +from pytest import raises as assert_raises +import numpy as np +from scipy.cluster.hierarchy import DisjointSet +import string + + +def generate_random_token(): + k = len(string.ascii_letters) + tokens = list(np.arange(k, dtype=int)) + tokens += list(np.arange(k, dtype=float)) + tokens += list(string.ascii_letters) + tokens += [None for i in range(k)] + tokens = np.array(tokens, dtype=object) + rng = np.random.RandomState(seed=0) + + while 1: + size = rng.randint(1, 3) + element = rng.choice(tokens, size) + if size == 1: + yield element[0] + else: + yield tuple(element) + + +def get_elements(n): + # dict is deterministic without difficulty of comparing numpy ints + elements = {} + for element in generate_random_token(): + if element not in elements: + elements[element] = len(elements) + if len(elements) >= n: + break + return list(elements.keys()) + + +def test_init(): + n = 10 + elements = get_elements(n) + dis = DisjointSet(elements) + assert dis.n_subsets == n + assert list(dis) == elements + + +def test_len(): + n = 10 + elements = get_elements(n) + dis = DisjointSet(elements) + assert len(dis) == n + + dis.add("dummy") + assert len(dis) == n + 1 + + +@pytest.mark.parametrize("n", [10, 100]) +def test_contains(n): + elements = get_elements(n) + dis = DisjointSet(elements) + for x in elements: + assert x in dis + + assert "dummy" not in dis + + +@pytest.mark.parametrize("n", [10, 100]) +def test_add(n): + elements = get_elements(n) + dis1 = DisjointSet(elements) + + dis2 = DisjointSet() + for i, x in enumerate(elements): + dis2.add(x) + assert len(dis2) == i + 1 + + # test idempotency by adding element again + dis2.add(x) + assert len(dis2) == i + 1 + + assert list(dis1) == list(dis2) + + +def test_element_not_present(): + elements = get_elements(n=10) + dis = DisjointSet(elements) + + with assert_raises(KeyError): + dis["dummy"] + + with assert_raises(KeyError): + dis.merge(elements[0], "dummy") + + with assert_raises(KeyError): + dis.connected(elements[0], "dummy") + + +@pytest.mark.parametrize("direction", ["forwards", "backwards"]) +@pytest.mark.parametrize("n", [10, 100]) +def test_linear_union_sequence(n, direction): + elements = get_elements(n) + dis = DisjointSet(elements) + assert elements == list(dis) + + indices = list(range(n - 1)) + if direction == "backwards": + indices = indices[::-1] + + for it, i in enumerate(indices): + assert not dis.connected(elements[i], elements[i + 1]) + assert dis.merge(elements[i], elements[i + 1]) + assert dis.connected(elements[i], elements[i + 1]) + assert dis.n_subsets == n - 1 - it + + roots = [dis[i] for i in elements] + if direction == "forwards": + assert all(elements[0] == r for r in roots) + else: + assert all(elements[-2] == r for r in roots) + assert not dis.merge(elements[0], elements[-1]) + + +@pytest.mark.parametrize("n", [10, 100]) +def test_self_unions(n): + elements = get_elements(n) + dis = DisjointSet(elements) + + for x in elements: + assert dis.connected(x, x) + assert not dis.merge(x, x) + assert dis.connected(x, x) + assert dis.n_subsets == len(elements) + + assert elements == list(dis) + roots = [dis[x] for x in elements] + assert elements == roots + + +@pytest.mark.parametrize("order", ["ab", "ba"]) +@pytest.mark.parametrize("n", [10, 100]) +def test_equal_size_ordering(n, order): + elements = get_elements(n) + dis = DisjointSet(elements) + + rng = np.random.RandomState(seed=0) + indices = np.arange(n) + rng.shuffle(indices) + + for i in range(0, len(indices), 2): + a, b = elements[indices[i]], elements[indices[i + 1]] + if order == "ab": + assert dis.merge(a, b) + else: + assert dis.merge(b, a) + + expected = elements[min(indices[i], indices[i + 1])] + assert dis[a] == expected + assert dis[b] == expected + + +@pytest.mark.parametrize("kmax", [5, 10]) +def test_binary_tree(kmax): + n = 2**kmax + elements = get_elements(n) + dis = DisjointSet(elements) + rng = np.random.RandomState(seed=0) + + for k in 2**np.arange(kmax): + for i in range(0, n, 2 * k): + r1, r2 = rng.randint(0, k, size=2) + a, b = elements[i + r1], elements[i + k + r2] + assert not dis.connected(a, b) + assert dis.merge(a, b) + assert dis.connected(a, b) + + assert elements == list(dis) + roots = [dis[i] for i in elements] + expected_indices = np.arange(n) - np.arange(n) % (2 * k) + expected = [elements[i] for i in expected_indices] + assert roots == expected + + +@pytest.mark.parametrize("n", [10, 100]) +def test_subsets(n): + elements = get_elements(n) + dis = DisjointSet(elements) + + rng = np.random.RandomState(seed=0) + for i, j in rng.randint(0, n, (n, 2)): + x = elements[i] + y = elements[j] + + expected = {element for element in dis if {dis[element]} == {dis[x]}} + assert dis.subset_size(x) == len(dis.subset(x)) + assert expected == dis.subset(x) + + expected = {dis[element]: set() for element in dis} + for element in dis: + expected[dis[element]].add(element) + expected = list(expected.values()) + assert expected == dis.subsets() + + dis.merge(x, y) + assert dis.subset(x) == dis.subset(y) diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/test_hierarchy.py b/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/test_hierarchy.py new file mode 100644 index 0000000000000000000000000000000000000000..e634bb0d9ee2c889236df3e1e4ecb7b6009c449b --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/test_hierarchy.py @@ -0,0 +1,1237 @@ +# +# Author: Damian Eads +# Date: April 17, 2008 +# +# Copyright (C) 2008 Damian Eads +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# 1. Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided +# with the distribution. +# +# 3. The name of the author may not be used to endorse or promote +# products derived from this software without specific prior +# written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS +# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE +# GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +import numpy as np +from numpy.testing import assert_allclose, assert_equal, assert_array_equal, assert_ +import pytest +from pytest import raises as assert_raises + +from scipy.cluster.hierarchy import ( + ClusterWarning, linkage, from_mlab_linkage, to_mlab_linkage, + num_obs_linkage, inconsistent, cophenet, fclusterdata, fcluster, + is_isomorphic, single, ward, leaders, + correspond, is_monotonic, maxdists, maxinconsts, maxRstat, + is_valid_linkage, is_valid_im, to_tree, leaves_list, dendrogram, + set_link_color_palette, cut_tree, optimal_leaf_ordering, + _order_cluster_tree, _hierarchy, _EUCLIDEAN_METHODS, _LINKAGE_METHODS) +from scipy.cluster._hierarchy import Heap +from scipy.spatial.distance import pdist +from scipy._lib._array_api import (eager_warns, make_xp_test_case, + xp_assert_close, xp_assert_equal) +import scipy._lib.array_api_extra as xpx + +from threading import Lock + +from . import hierarchy_test_data + +class eager: + # Bypass xpx.testing.lazy_xp_function when calling + # these functions from this namespace + is_valid_im = is_valid_im + is_valid_linkage = is_valid_linkage + + +# Matplotlib is not a scipy dependency but is optionally used in dendrogram, so +# check if it's available +try: + import matplotlib + # and set the backend to be Agg (no gui) + matplotlib.use('Agg') + # before importing pyplot + import matplotlib.pyplot as plt + have_matplotlib = True +except Exception: + have_matplotlib = False + +skip_xp_backends = pytest.mark.skip_xp_backends + + +@make_xp_test_case(linkage) +class TestLinkage: + + @skip_xp_backends("jax.numpy", reason="Can't raise inside jax.pure_callback") + def test_linkage_non_finite_elements_in_distance_matrix(self, xp): + # Tests linkage(Y) where Y contains a non-finite element (e.g. NaN or Inf). + # Exception expected. + y = xp.asarray([xp.nan] + [0.0]*5) + assert_raises(ValueError, linkage, y) + + def test_linkage_empty_distance_matrix(self, xp): + # Tests linkage(Y) where Y is a 0x4 linkage matrix. Exception expected. + y = xp.zeros((0,)) + assert_raises(ValueError, linkage, y) + + def test_linkage_tdist(self, xp): + for method in ['single', 'complete', 'average', 'weighted']: + self.check_linkage_tdist(method, xp) + + def check_linkage_tdist(self, method, xp): + # Tests linkage(Y, method) on the tdist data set. + Z = linkage(xp.asarray(hierarchy_test_data.ytdist), method) + expectedZ = getattr(hierarchy_test_data, 'linkage_ytdist_' + method) + xp_assert_close(Z, xp.asarray(expectedZ), atol=1e-10) + + def test_linkage_X(self, xp): + for method in ['centroid', 'median', 'ward']: + self.check_linkage_q(method, xp) + + def check_linkage_q(self, method, xp): + # Tests linkage(Y, method) on the Q data set. + Z = linkage(xp.asarray(hierarchy_test_data.X), method) + expectedZ = getattr(hierarchy_test_data, 'linkage_X_' + method) + xp_assert_close(Z, xp.asarray(expectedZ), atol=1e-06) + + X = xp.asarray(hierarchy_test_data.X) + y = pdist(X, metric="euclidean") + Z = linkage(y, method) + xp_assert_close(Z, xp.asarray(expectedZ), atol=1e-06) + + def test_compare_with_trivial(self, xp): + rng = np.random.RandomState(0) + n = 20 + X = rng.rand(n, 2) + d = pdist(X) + + for method, code in _LINKAGE_METHODS.items(): + Z_trivial = _hierarchy.linkage(d, n, code) + Z = linkage(xp.asarray(d), method) + xp_assert_close(Z, xp.asarray(Z_trivial), rtol=1e-14, atol=1e-15) + + def test_optimal_leaf_ordering(self, xp): + Z = linkage(xp.asarray(hierarchy_test_data.ytdist), optimal_ordering=True) + expectedZ = getattr(hierarchy_test_data, 'linkage_ytdist_single_olo') + xp_assert_close(Z, xp.asarray(expectedZ), atol=1e-10) + + @pytest.mark.parametrize("method,expect", [ + ('single', [[0, 1, 1.41421356, 2], + [2, 3, 1.41421356, 3]]), + ('complete', [[0, 1, 1.41421356, 2], + [2, 3, 2.82842712, 3]]), + ('average', [[0, 1, 1.41421356, 2], + [2, 3, 2.12132034, 3]]), + ('weighted', [[0, 1, 1.41421356, 2], + [2, 3, 2.12132034, 3]]), + ('centroid', [[0, 1, 1.41421356, 2], + [2, 3, 2.12132034, 3]]), + ('median', [[0, 1, 1.41421356, 2], + [2, 3, 2.12132034, 3]]), + ('ward', [[0, 1, 1.41421356, 2], + [2, 3, 2.44948974, 3]]), + ]) + def test_linkage_ties(self, method, expect, xp): + X = xp.asarray([[-1, -1], [0, 0], [1, 1]]) + Z = linkage(X, method=method) + expect = xp.asarray(expect, dtype=xp.float64) + xp_assert_close(Z, expect, atol=1e-06) + + def test_unsupported_uncondensed_distance_matrix_linkage_warning(self, xp): + X = xp.asarray([[0, 1], [1, 0]]) + with eager_warns(ClusterWarning, xp=xp): + linkage(X) + + @pytest.mark.parametrize("method", _EUCLIDEAN_METHODS) + def test_euclidean_linkage_value_error(self, method, xp): + X = xp.asarray([[1, 1], [1, 1]]) + with pytest.raises(ValueError): + linkage(X, method=method, metric='cityblock') + + def test_2x2_linkage(self, xp): + Z1 = linkage(xp.asarray([1]), method='single', metric='euclidean') + Z2 = linkage(xp.asarray([[0, 1], [0, 0]]), method='single', metric='euclidean') + xp_assert_close(Z1, Z2, rtol=1e-15) + + @skip_xp_backends("jax.numpy", reason="Can't raise inside jax.pure_callback") + def test_centroid_neg_distance(self, xp): + # gh-21011 + values = xp.asarray([0, 0, -1]) + with pytest.raises(ValueError): + # This is just checking that this doesn't crash + linkage(values, method='centroid') + + +@make_xp_test_case(inconsistent) +class TestInconsistent: + + def test_inconsistent_tdist(self, xp): + for depth in hierarchy_test_data.inconsistent_ytdist: + self.check_inconsistent_tdist(depth, xp) + + def check_inconsistent_tdist(self, depth, xp): + Z = xp.asarray(hierarchy_test_data.linkage_ytdist_single) + xp_assert_close(inconsistent(Z, depth), + xp.asarray(hierarchy_test_data.inconsistent_ytdist[depth])) + + +@make_xp_test_case(cophenet) +class TestCopheneticDistance: + + def test_linkage_cophenet_tdist_Z(self, xp): + # Tests cophenet(Z) on tdist data set. + expectedM = xp.asarray([268, 295, 255, 255, 295, 295, 268, 268, 295, 295, + 295, 138, 219, 295, 295]) + Z = xp.asarray(hierarchy_test_data.linkage_ytdist_single) + M = cophenet(Z) + xp_assert_close(M, xp.asarray(expectedM, dtype=xp.float64), atol=1e-10) + + def test_linkage_cophenet_tdist_Z_Y(self, xp): + # Tests cophenet(Z, Y) on tdist data set. + Z = xp.asarray(hierarchy_test_data.linkage_ytdist_single) + (c, M) = cophenet(Z, xp.asarray(hierarchy_test_data.ytdist)) + expectedM = xp.asarray([268, 295, 255, 255, 295, 295, 268, 268, 295, 295, + 295, 138, 219, 295, 295], dtype=xp.float64) + expectedc = xp.asarray(0.639931296433393415057366837573, dtype=xp.float64)[()] + xp_assert_close(c, expectedc, atol=1e-10) + xp_assert_close(M, expectedM, atol=1e-10) + + @skip_xp_backends("jax.numpy", reason="Can't raise inside jax.pure_callback") + def test_gh_22183(self, xp): + # check for lack of segfault + # (out of bounds memory access) + # and correct interception of + # invalid linkage matrix + arr=[[0.0, 1.0, 1.0, 2.0], + [2.0, 12.0, 1.0, 3.0], + [3.0, 4.0, 1.0, 2.0], + [5.0, 14.0, 1.0, 3.0], + [6.0, 7.0, 1.0, 2.0], + [8.0, 16.0, 1.0, 3.0], + [9.0, 10.0, 1.0, 2.0], + [11.0, 18.0, 1.0, 3.0], + [13.0, 15.0, 2.0, 6.0], + [17.0, 20.0, 2.0, 32.0], + [19.0, 21.0, 2.0, 12.0]] + with pytest.raises(ValueError, match="excessive observations"): + cophenet(xp.asarray(arr)) + + +@make_xp_test_case(from_mlab_linkage, to_mlab_linkage) +class TestMLabLinkageConversion: + + def test_mlab_linkage_conversion_empty(self, xp): + # Tests from/to_mlab_linkage on empty linkage array. + X = xp.asarray([], dtype=xp.float64) + xp_assert_equal(from_mlab_linkage(X), X) + xp_assert_equal(to_mlab_linkage(X), X) + + def test_mlab_linkage_conversion_single_row(self, xp): + # Tests from/to_mlab_linkage on linkage array with single row. + Z = xp.asarray([[0., 1., 3., 2.]]) + Zm = xp.asarray([[1, 2, 3]]) + xp_assert_close(from_mlab_linkage(Zm), xp.asarray(Z, dtype=xp.float64), + rtol=1e-15) + xp_assert_close(to_mlab_linkage(Z), xp.asarray(Zm, dtype=xp.float64), + rtol=1e-15) + + def test_mlab_linkage_conversion_multiple_rows(self, xp): + # Tests from/to_mlab_linkage on linkage array with multiple rows. + Zm = xp.asarray([[3, 6, 138], [4, 5, 219], + [1, 8, 255], [2, 9, 268], [7, 10, 295]]) + Z = xp.asarray([[2., 5., 138., 2.], + [3., 4., 219., 2.], + [0., 7., 255., 3.], + [1., 8., 268., 4.], + [6., 9., 295., 6.]], + dtype=xp.float64) + xp_assert_close(from_mlab_linkage(Zm), Z, rtol=1e-15) + xp_assert_close(to_mlab_linkage(Z), xp.asarray(Zm, dtype=xp.float64), + rtol=1e-15) + + +@make_xp_test_case(fclusterdata) +class TestFclusterData: + + @make_xp_test_case(is_isomorphic) + @pytest.mark.parametrize("criterion,t", + [("inconsistent", t) for t in hierarchy_test_data.fcluster_inconsistent] + + [("distance", t) for t in hierarchy_test_data.fcluster_distance] + + [("maxclust", t) for t in hierarchy_test_data.fcluster_maxclust] + ) + def test_fclusterdata(self, t, criterion, xp): + # Tests fclusterdata(X, criterion=criterion, t=t) on a random 3-cluster data set + expectedT = xp.asarray(getattr(hierarchy_test_data, 'fcluster_' + criterion)[t]) + X = xp.asarray(hierarchy_test_data.Q_X) + T = fclusterdata(X, criterion=criterion, t=t) + assert is_isomorphic(T, expectedT) + + +@make_xp_test_case(fcluster) +class TestFcluster: + + @make_xp_test_case(single, is_isomorphic) + @pytest.mark.parametrize("criterion,t", + [("inconsistent", t) for t in hierarchy_test_data.fcluster_inconsistent] + + [("distance", t) for t in hierarchy_test_data.fcluster_distance] + + [("maxclust", t) for t in hierarchy_test_data.fcluster_maxclust] + ) + def test_fcluster(self, t, criterion, xp): + # Tests fcluster(Z, criterion=criterion, t=t) on a random 3-cluster data set. + expectedT = xp.asarray(getattr(hierarchy_test_data, 'fcluster_' + criterion)[t]) + Z = single(xp.asarray(hierarchy_test_data.Q_X)) + T = fcluster(Z, criterion=criterion, t=t) + assert_(is_isomorphic(T, expectedT)) + + @make_xp_test_case(single, is_isomorphic, maxdists) + @pytest.mark.parametrize("t", hierarchy_test_data.fcluster_distance) + def test_fcluster_monocrit(self, t, xp): + expectedT = xp.asarray(hierarchy_test_data.fcluster_distance[t]) + Z = single(xp.asarray(hierarchy_test_data.Q_X)) + T = fcluster(Z, t, criterion='monocrit', monocrit=maxdists(Z)) + assert_(is_isomorphic(T, expectedT)) + + @make_xp_test_case(single, is_isomorphic, maxdists) + @pytest.mark.parametrize("t", hierarchy_test_data.fcluster_maxclust) + def test_fcluster_maxclust_monocrit(self, t, xp): + expectedT = xp.asarray(hierarchy_test_data.fcluster_maxclust[t]) + Z = single(xp.asarray(hierarchy_test_data.Q_X)) + T = fcluster(Z, t, criterion='maxclust_monocrit', monocrit=maxdists(Z)) + assert_(is_isomorphic(T, expectedT)) + + @make_xp_test_case(single) + def test_fcluster_maxclust_gh_12651(self, xp): + y = xp.asarray([[1], [4], [5]]) + Z = single(y) + assert_array_equal(fcluster(Z, t=1, criterion="maxclust"), + xp.asarray([1, 1, 1])) + assert_array_equal(fcluster(Z, t=2, criterion="maxclust"), + xp.asarray([2, 1, 1])) + assert_array_equal(fcluster(Z, t=3, criterion="maxclust"), + xp.asarray([1, 2, 3])) + assert_array_equal(fcluster(Z, t=5, criterion="maxclust"), + xp.asarray([1, 2, 3])) + + +@make_xp_test_case(leaders) +class TestLeaders: + + def test_leaders_single(self, xp): + # Tests leaders using a flat clustering generated by single linkage. + X = hierarchy_test_data.Q_X + Y = pdist(X) + Z = linkage(Y) + T = fcluster(Z, criterion='maxclust', t=3) + Z = xp.asarray(Z) + T = xp.asarray(T, dtype=xp.int32) + L = leaders(Z, T) + expect = xp.asarray([53, 55, 56, 2, 3, 1], dtype=xp.int32) + xp_assert_close(xp.concat(L), expect, rtol=1e-15) + + +@make_xp_test_case(is_isomorphic) +class TestIsIsomorphic: + + def test_array_like(self): + assert is_isomorphic([1, 1, 1], [2, 2, 2]) + assert is_isomorphic([], []) + + def test_is_isomorphic_1(self, xp): + # Tests is_isomorphic on test case #1 (one flat cluster, different labellings) + a = xp.asarray([1, 1, 1]) + b = xp.asarray([2, 2, 2]) + assert is_isomorphic(a, b) + assert is_isomorphic(b, a) + + def test_is_isomorphic_2(self, xp): + # Tests is_isomorphic on test case #2 (two flat clusters, different labelings) + a = xp.asarray([1, 7, 1]) + b = xp.asarray([2, 3, 2]) + assert is_isomorphic(a, b) + assert is_isomorphic(b, a) + + def test_is_isomorphic_3(self, xp): + # Tests is_isomorphic on test case #3 (no flat clusters) + a = xp.asarray([]) + b = xp.asarray([]) + assert is_isomorphic(a, b) + + def test_is_isomorphic_4A(self, xp): + # Tests is_isomorphic on test case #4A + # (3 flat clusters, different labelings, isomorphic) + a = xp.asarray([1, 2, 3]) + b = xp.asarray([1, 3, 2]) + assert is_isomorphic(a, b) + assert is_isomorphic(b, a) + + def test_is_isomorphic_4B(self, xp): + # Tests is_isomorphic on test case #4B + # (3 flat clusters, different labelings, nonisomorphic) + a = xp.asarray([1, 2, 3, 3]) + b = xp.asarray([1, 3, 2, 3]) + assert not is_isomorphic(a, b) + assert not is_isomorphic(b, a) + + def test_is_isomorphic_4C(self, xp): + # Tests is_isomorphic on test case #4C + # (3 flat clusters, different labelings, isomorphic) + a = xp.asarray([7, 2, 3]) + b = xp.asarray([6, 3, 2]) + assert is_isomorphic(a, b) + assert is_isomorphic(b, a) + + @pytest.mark.parametrize("nclusters", [2, 3, 5]) + def test_is_isomorphic_5(self, nclusters, xp): + # Tests is_isomorphic on test case #5 (1000 observations, 2/3/5 random + # clusters, random permutation of the labeling). + self.is_isomorphic_randperm(1000, nclusters, xp=xp) + + @pytest.mark.parametrize("nclusters", [2, 3, 5]) + def test_is_isomorphic_6(self, nclusters, xp): + # Tests is_isomorphic on test case #5A (1000 observations, 2/3/5 random + # clusters, random permutation of the labeling, slightly + # nonisomorphic.) + self.is_isomorphic_randperm(1000, nclusters, True, 5, xp=xp) + + def test_is_isomorphic_7(self, xp): + # Regression test for gh-6271 + a = xp.asarray([1, 2, 3]) + b = xp.asarray([1, 1, 1]) + assert not is_isomorphic(a, b) + + def is_isomorphic_randperm(self, nobs, nclusters, noniso=False, nerrors=0, *, xp): + rng = np.random.default_rng() + for _ in range(3): + a = rng.integers(0, nclusters, size=nobs) + p = rng.permutation(nclusters) + b = p.take(a.astype(np.intp)) + if noniso: + q = rng.permutation(nobs) + b[q[0:nerrors]] += 1 + b[q[0:nerrors]] %= nclusters + a = xp.asarray(a) + b = xp.asarray(b) + assert is_isomorphic(a, b) == (not noniso) + assert is_isomorphic(b, a) == (not noniso) + + +@make_xp_test_case(is_valid_linkage) +class TestIsValidLinkage: + + @pytest.mark.parametrize("nrow, ncol, valid", [(2, 5, False), (2, 3, False), + (1, 4, True), (2, 4, True)]) + def test_is_valid_linkage_various_size(self, nrow, ncol, valid, xp): + # Tests is_valid_linkage(Z) with linkage matrices of various sizes + Z = xp.asarray([[0, 1, 3.0, 2, 5], + [3, 2, 4.0, 3, 3]], dtype=xp.float64) + Z = Z[:nrow, :ncol] + xp_assert_equal(is_valid_linkage(Z), valid, check_namespace=False) + if not valid: + assert_raises(ValueError, is_valid_linkage, Z, throw=True) + + def test_is_valid_linkage_int_type(self, xp): + # Tests is_valid_linkage(Z) with integer type. + Z = xp.asarray([[0, 1, 3.0, 2], + [3, 2, 4.0, 3]], dtype=xp.int64) + xp_assert_equal(is_valid_linkage(Z), False, check_namespace=False) + assert_raises(TypeError, is_valid_linkage, Z, throw=True) + + def test_is_valid_linkage_empty(self, xp): + # Tests is_valid_linkage(Z) with empty linkage. + Z = xp.zeros((0, 4), dtype=xp.float64) + xp_assert_equal(is_valid_linkage(Z), False, check_namespace=False) + assert_raises(ValueError, is_valid_linkage, Z, throw=True) + + def test_is_valid_linkage_4_and_up(self, xp): + # Tests is_valid_linkage(Z) on linkage on observation sets between + # sizes 4 and 15 (step size 3). + for i in range(4, 15, 3): + y = np.random.rand(i*(i-1)//2) + Z = xp.asarray(linkage(y)) + y = xp.asarray(y) + xp_assert_equal(is_valid_linkage(Z), True, check_namespace=False) + + def test_is_valid_linkage_4_and_up_neg_index_left(self, xp): + # Tests is_valid_linkage(Z) on linkage on observation sets between + # sizes 4 and 15 (step size 3) with negative indices (left). + for i in range(4, 15, 3): + y = np.random.rand(i*(i-1)//2) + Z = xp.asarray(linkage(y)) + y = xp.asarray(y) + Z = xpx.at(Z)[i//2, 0].set(-2) + xp_assert_equal(is_valid_linkage(Z), False, check_namespace=False) + with pytest.raises(ValueError): + eager.is_valid_linkage(Z, throw=True) + + def test_is_valid_linkage_4_and_up_neg_index_right(self, xp): + # Tests is_valid_linkage(Z) on linkage on observation sets between + # sizes 4 and 15 (step size 3) with negative indices (right). + for i in range(4, 15, 3): + y = np.random.rand(i*(i-1)//2) + Z = xp.asarray(linkage(y)) + y = xp.asarray(y) + Z = xpx.at(Z)[i//2, 1].set(-2) + xp_assert_equal(is_valid_linkage(Z), False, check_namespace=False) + with pytest.raises(ValueError): + eager.is_valid_linkage(Z, throw=True) + + def test_is_valid_linkage_4_and_up_neg_dist(self, xp): + # Tests is_valid_linkage(Z) on linkage on observation sets between + # sizes 4 and 15 (step size 3) with negative distances. + for i in range(4, 15, 3): + y = np.random.rand(i*(i-1)//2) + Z = xp.asarray(linkage(y)) + y = xp.asarray(y) + Z = xpx.at(Z)[i//2, 2].set(-0.5) + xp_assert_equal(is_valid_linkage(Z), False, check_namespace=False) + with pytest.raises(ValueError): + eager.is_valid_linkage(Z, throw=True) + + def test_is_valid_linkage_4_and_up_neg_counts(self, xp): + # Tests is_valid_linkage(Z) on linkage on observation sets between + # sizes 4 and 15 (step size 3) with negative counts. + for i in range(4, 15, 3): + y = np.random.rand(i*(i-1)//2) + Z = xp.asarray(linkage(y)) + y = xp.asarray(y) + Z = xpx.at(Z)[i//2, 3].set(-2) + xp_assert_equal(is_valid_linkage(Z), False, check_namespace=False) + with pytest.raises(ValueError): + eager.is_valid_linkage(Z, throw=True) + + +@make_xp_test_case(is_valid_im) +class TestIsValidInconsistent: + + def test_is_valid_im_int_type(self, xp): + # Tests is_valid_im(R) with integer type. + R = xp.asarray([[0, 1, 3.0, 2], + [3, 2, 4.0, 3]], dtype=xp.int64) + xp_assert_equal(is_valid_im(R), False, check_namespace=False) + assert_raises(TypeError, is_valid_im, R, throw=True) + + @pytest.mark.parametrize("nrow, ncol, valid", [(2, 5, False), (2, 3, False), + (1, 4, True), (2, 4, True)]) + def test_is_valid_im_various_size(self, nrow, ncol, valid, xp): + # Tests is_valid_im(R) with linkage matrices of various sizes + R = xp.asarray([[0, 1, 3.0, 2, 5], + [3, 2, 4.0, 3, 3]], dtype=xp.float64) + R = R[:nrow, :ncol] + xp_assert_equal(is_valid_im(R), valid, check_namespace=False) + if not valid: + assert_raises(ValueError, is_valid_im, R, throw=True) + + def test_is_valid_im_empty(self, xp): + # Tests is_valid_im(R) with empty inconsistency matrix. + R = xp.zeros((0, 4), dtype=xp.float64) + xp_assert_equal(is_valid_im(R), False, check_namespace=False) + assert_raises(ValueError, is_valid_im, R, throw=True) + + def test_is_valid_im_4_and_up(self, xp): + # Tests is_valid_im(R) on im on observation sets between sizes 4 and 15 + # (step size 3). + for i in range(4, 15, 3): + y = np.random.rand(i*(i-1)//2) + Z = linkage(y) + R = inconsistent(Z) + R = xp.asarray(R) + xp_assert_equal(is_valid_im(R), True, check_namespace=False) + + def test_is_valid_im_4_and_up_neg_index_left(self, xp): + # Tests is_valid_im(R) on im on observation sets between sizes 4 and 15 + # (step size 3) with negative link height means. + for i in range(4, 15, 3): + y = np.random.rand(i*(i-1)//2) + Z = linkage(y) + R = inconsistent(Z) + R = xpx.at(R)[i//2 , 0].set(-2.0) + R = xp.asarray(R) + xp_assert_equal(is_valid_im(R), False, check_namespace=False) + with pytest.raises(ValueError): + eager.is_valid_im(R, throw=True) + + def test_is_valid_im_4_and_up_neg_index_right(self, xp): + # Tests is_valid_im(R) on im on observation sets between sizes 4 and 15 + # (step size 3) with negative link height standard deviations. + for i in range(4, 15, 3): + y = np.random.rand(i*(i-1)//2) + Z = linkage(y) + R = inconsistent(Z) + R = xpx.at(R)[i//2 , 1].set(-2.0) + R = xp.asarray(R) + xp_assert_equal(is_valid_im(R), False, check_namespace=False) + with pytest.raises(ValueError): + eager.is_valid_im(R, throw=True) + + def test_is_valid_im_4_and_up_neg_dist(self, xp): + # Tests is_valid_im(R) on im on observation sets between sizes 4 and 15 + # (step size 3) with negative link counts. + for i in range(4, 15, 3): + y = np.random.rand(i*(i-1)//2) + Z = linkage(y) + R = inconsistent(Z) + R = xpx.at(R)[i//2, 2].set(-0.5) + R = xp.asarray(R) + xp_assert_equal(is_valid_im(R), False, check_namespace=False) + with pytest.raises(ValueError): + eager.is_valid_im(R, throw=True) + + +class TestNumObsLinkage: + + def test_num_obs_linkage_empty(self, xp): + # Tests num_obs_linkage(Z) with empty linkage. + Z = xp.zeros((0, 4), dtype=xp.float64) + assert_raises(ValueError, num_obs_linkage, Z) + + def test_num_obs_linkage_1x4(self, xp): + # Tests num_obs_linkage(Z) on linkage over 2 observations. + Z = xp.asarray([[0, 1, 3.0, 2]], dtype=xp.float64) + assert num_obs_linkage(Z) == 2 + + def test_num_obs_linkage_2x4(self, xp): + # Tests num_obs_linkage(Z) on linkage over 3 observations. + Z = xp.asarray([[0, 1, 3.0, 2], + [3, 2, 4.0, 3]], dtype=xp.float64) + assert num_obs_linkage(Z) == 3 + + def test_num_obs_linkage_4_and_up(self, xp): + # Tests num_obs_linkage(Z) on linkage on observation sets between sizes + # 4 and 15 (step size 3). + for i in range(4, 15, 3): + y = np.random.rand(i*(i-1)//2) + Z = xp.asarray(linkage(y)) + assert num_obs_linkage(Z) == i + + def test_num_obs_linkage_multi_matrix(self, xp): + # Tests num_obs_linkage with observation matrices of multiple sizes. + for n in range(2, 10): + X = np.random.rand(n, 4) + Y = pdist(X) + Z = xp.asarray(linkage(Y)) + assert num_obs_linkage(Z) == n + + +@make_xp_test_case(leaves_list, to_tree) +class TestLeavesList: + + def test_leaves_list_1x4(self, xp): + # Tests leaves_list(Z) on a 1x4 linkage. + Z = xp.asarray([[0, 1, 3.0, 2]], dtype=xp.float64) + to_tree(Z) + assert_allclose(leaves_list(Z), [0, 1], rtol=1e-15) + + def test_leaves_list_2x4(self, xp): + # Tests leaves_list(Z) on a 2x4 linkage. + Z = xp.asarray([[0, 1, 3.0, 2], + [3, 2, 4.0, 3]], dtype=xp.float64) + to_tree(Z) + assert_allclose(leaves_list(Z), [0, 1, 2], rtol=1e-15) + + @pytest.mark.parametrize("method", + ['single', 'complete', 'average', 'weighted', 'centroid', 'median', 'ward']) + def test_leaves_list_Q(self, method, xp): + # Tests leaves_list(Z) on the Q data set + X = hierarchy_test_data.Q_X + Z = xp.asarray(linkage(X, method)) + node = to_tree(Z) + assert_allclose(node.pre_order(), leaves_list(Z), rtol=1e-15) + + def test_Q_subtree_pre_order(self, xp): + # Tests that pre_order() works when called on sub-trees. + X = hierarchy_test_data.Q_X + Z = xp.asarray(linkage(X, 'single')) + node = to_tree(Z) + assert_allclose(node.pre_order(), + (node.get_left().pre_order() + node.get_right().pre_order()), + rtol=1e-15) + + +@make_xp_test_case(correspond) +class TestCorrespond: + + def test_correspond_empty(self, xp): + # Tests correspond(Z, y) with empty linkage and condensed distance matrix. + y = xp.zeros((0,), dtype=xp.float64) + Z = xp.zeros((0,4), dtype=xp.float64) + assert_raises(ValueError, correspond, Z, y) + + def test_correspond_2_and_up(self, xp): + # Tests correspond(Z, y) on linkage and CDMs over observation sets of + # different sizes. + for i in range(2, 4): + y = np.random.rand(i*(i-1)//2) + Z = xp.asarray(linkage(y)) + y = xp.asarray(y) + assert_(correspond(Z, y)) + for i in range(4, 15, 3): + y = np.random.rand(i*(i-1)//2) + Z = xp.asarray(linkage(y)) + y = xp.asarray(y) + assert_(correspond(Z, y)) + + def test_correspond_4_and_up(self, xp): + # Tests correspond(Z, y) on linkage and CDMs over observation sets of + # different sizes. Correspondence should be false. + for (i, j) in (list(zip(list(range(2, 4)), list(range(3, 5)))) + + list(zip(list(range(3, 5)), list(range(2, 4))))): + y = np.random.rand(i*(i-1)//2) + y2 = np.random.rand(j*(j-1)//2) + Z = xp.asarray(linkage(y)) + Z2 = xp.asarray(linkage(y2)) + y = xp.asarray(y) + y2 = xp.asarray(y2) + assert not correspond(Z, y2) + assert not correspond(Z2, y) + + def test_correspond_4_and_up_2(self, xp): + # Tests correspond(Z, y) on linkage and CDMs over observation sets of + # different sizes. Correspondence should be false. + for (i, j) in (list(zip(list(range(2, 7)), list(range(16, 21)))) + + list(zip(list(range(2, 7)), list(range(16, 21))))): + y = np.random.rand(i*(i-1)//2) + y2 = np.random.rand(j*(j-1)//2) + Z = xp.asarray(linkage(y)) + Z2 = xp.asarray(linkage(y2)) + y = xp.asarray(y) + y2 = xp.asarray(y2) + assert not correspond(Z, y2) + assert not correspond(Z2, y) + + +@make_xp_test_case(is_monotonic) +class TestIsMonotonic: + + def test_is_monotonic_empty(self, xp): + # Tests is_monotonic(Z) on an empty linkage. + Z = xp.zeros((0, 4), dtype=xp.float64) + assert_raises(ValueError, is_monotonic, Z) + + def test_is_monotonic_1x4(self, xp): + # Tests is_monotonic(Z) on 1x4 linkage. Expecting True. + Z = xp.asarray([[0, 1, 0.3, 2]], dtype=xp.float64) + assert is_monotonic(Z) + + def test_is_monotonic_2x4_T(self, xp): + # Tests is_monotonic(Z) on 2x4 linkage. Expecting True. + Z = xp.asarray([[0, 1, 0.3, 2], + [2, 3, 0.4, 3]], dtype=xp.float64) + assert is_monotonic(Z) + + def test_is_monotonic_2x4_F(self, xp): + # Tests is_monotonic(Z) on 2x4 linkage. Expecting False. + Z = xp.asarray([[0, 1, 0.4, 2], + [2, 3, 0.3, 3]], dtype=xp.float64) + assert not is_monotonic(Z) + + def test_is_monotonic_3x4_T(self, xp): + # Tests is_monotonic(Z) on 3x4 linkage. Expecting True. + Z = xp.asarray([[0, 1, 0.3, 2], + [2, 3, 0.4, 2], + [4, 5, 0.6, 4]], dtype=xp.float64) + assert is_monotonic(Z) + + def test_is_monotonic_3x4_F1(self, xp): + # Tests is_monotonic(Z) on 3x4 linkage (case 1). Expecting False. + Z = xp.asarray([[0, 1, 0.3, 2], + [2, 3, 0.2, 2], + [4, 5, 0.6, 4]], dtype=xp.float64) + assert not is_monotonic(Z) + + def test_is_monotonic_3x4_F2(self, xp): + # Tests is_monotonic(Z) on 3x4 linkage (case 2). Expecting False. + Z = xp.asarray([[0, 1, 0.8, 2], + [2, 3, 0.4, 2], + [4, 5, 0.6, 4]], dtype=xp.float64) + assert not is_monotonic(Z) + + def test_is_monotonic_3x4_F3(self, xp): + # Tests is_monotonic(Z) on 3x4 linkage (case 3). Expecting False + Z = xp.asarray([[0, 1, 0.3, 2], + [2, 3, 0.4, 2], + [4, 5, 0.2, 4]], dtype=xp.float64) + assert not is_monotonic(Z) + + def test_is_monotonic_tdist_linkage1(self, xp): + # Tests is_monotonic(Z) on clustering generated by single linkage on + # tdist data set. Expecting True. + Z = xp.asarray(linkage(hierarchy_test_data.ytdist, 'single')) + assert is_monotonic(Z) + + def test_is_monotonic_tdist_linkage2(self, xp): + # Tests is_monotonic(Z) on clustering generated by single linkage on + # tdist data set. Perturbing. Expecting False. + Z = xp.asarray(linkage(hierarchy_test_data.ytdist, 'single')) + Z = xpx.at(Z)[2, 2].set(0.0) + assert not is_monotonic(Z) + + def test_is_monotonic_Q_linkage(self, xp): + # Tests is_monotonic(Z) on clustering generated by single linkage on + # Q data set. Expecting True. + X = hierarchy_test_data.Q_X + Z = xp.asarray(linkage(X, 'single')) + assert is_monotonic(Z) + + +@make_xp_test_case(maxdists) +class TestMaxDists: + + def test_maxdists_empty_linkage(self, xp): + # Tests maxdists(Z) on empty linkage. Expecting exception. + Z = xp.zeros((0, 4), dtype=xp.float64) + assert_raises(ValueError, maxdists, Z) + + def test_maxdists_one_cluster_linkage(self, xp): + # Tests maxdists(Z) on linkage with one cluster. + Z = xp.asarray([[0, 1, 0.3, 4]], dtype=xp.float64) + MD = maxdists(Z) + expectedMD = calculate_maximum_distances(Z, xp) + xp_assert_close(MD, expectedMD, atol=1e-15) + + @pytest.mark.parametrize( + "method", ['single', 'complete', 'ward', 'centroid', 'median']) + def test_maxdists_Q_linkage(self, method, xp): + # Tests maxdists(Z) on the Q data set + X = hierarchy_test_data.Q_X + Z = xp.asarray(linkage(X, method)) + MD = maxdists(Z) + expectedMD = calculate_maximum_distances(Z, xp) + xp_assert_close(MD, expectedMD, atol=1e-15) + + +@make_xp_test_case(maxinconsts) +class TestMaxInconsts: + + def test_maxinconsts_empty_linkage(self, xp): + # Tests maxinconsts(Z, R) on empty linkage. Expecting exception. + Z = xp.zeros((0, 4), dtype=xp.float64) + R = xp.zeros((0, 4), dtype=xp.float64) + assert_raises(ValueError, maxinconsts, Z, R) + + def test_maxinconsts_difrow_linkage(self, xp): + # Tests maxinconsts(Z, R) on linkage and inconsistency matrices with + # different numbers of clusters. Expecting exception. + Z = xp.asarray([[0, 1, 0.3, 4]], dtype=xp.float64) + R = np.random.rand(2, 4) + R = xp.asarray(R) + assert_raises(ValueError, maxinconsts, Z, R) + + def test_maxinconsts_one_cluster_linkage(self, xp): + # Tests maxinconsts(Z, R) on linkage with one cluster. + Z = xp.asarray([[0, 1, 0.3, 4]], dtype=xp.float64) + R = xp.asarray([[0, 0, 0, 0.3]], dtype=xp.float64) + MD = maxinconsts(Z, R) + expectedMD = calculate_maximum_inconsistencies(Z, R, xp=xp) + xp_assert_close(MD, expectedMD, atol=1e-15) + + @pytest.mark.parametrize( + "method", ['single', 'complete', 'ward', 'centroid', 'median']) + def test_maxinconsts_Q_linkage(self, method, xp): + # Tests maxinconsts(Z, R) on the Q data set + X = hierarchy_test_data.Q_X + Z = linkage(X, method) + R = xp.asarray(inconsistent(Z)) + Z = xp.asarray(Z) + MD = maxinconsts(Z, R) + expectedMD = calculate_maximum_inconsistencies(Z, R, xp=xp) + xp_assert_close(MD, expectedMD, atol=1e-15) + + +@make_xp_test_case(maxRstat) +class TestMaxRStat: + + def test_maxRstat_invalid_index(self, xp): + # Tests maxRstat(Z, R, i). Expecting exception. + Z = xp.asarray([[0, 1, 0.3, 4]], dtype=xp.float64) + R = xp.asarray([[0, 0, 0, 0.3]], dtype=xp.float64) + with pytest.raises(TypeError): + maxRstat(Z, R, 3.3) + with pytest.raises(ValueError): + maxRstat(Z, R, -1) + with pytest.raises(ValueError): + maxRstat(Z, R, 4) + + @pytest.mark.parametrize("i", range(4)) + def test_maxRstat_empty_linkage(self, i, xp): + # Tests maxRstat(Z, R, i) on empty linkage. Expecting exception. + Z = xp.zeros((0, 4), dtype=xp.float64) + R = xp.zeros((0, 4), dtype=xp.float64) + assert_raises(ValueError, maxRstat, Z, R, i) + + @pytest.mark.parametrize("i", range(4)) + def test_maxRstat_difrow_linkage(self, i, xp): + # Tests maxRstat(Z, R, i) on linkage and inconsistency matrices with + # different numbers of clusters. Expecting exception. + Z = xp.asarray([[0, 1, 0.3, 4]], dtype=xp.float64) + R = np.random.rand(2, 4) + R = xp.asarray(R) + assert_raises(ValueError, maxRstat, Z, R, i) + + def test_maxRstat_one_cluster_linkage(self, xp): + # Tests maxRstat(Z, R, i) on linkage with one cluster. + Z = xp.asarray([[0, 1, 0.3, 4]], dtype=xp.float64) + R = xp.asarray([[0, 0, 0, 0.3]], dtype=xp.float64) + MD = maxRstat(Z, R, 1) + expectedMD = calculate_maximum_inconsistencies(Z, R, 1, xp) + xp_assert_close(MD, expectedMD, atol=1e-15) + + @pytest.mark.parametrize( + "method", ['single', 'complete', 'ward', 'centroid', 'median']) + def test_maxRstat_Q_linkage(self, method, xp): + # Tests maxRstat(Z, R, 1) on the Q data set + X = hierarchy_test_data.Q_X + Z = linkage(X, method) + R = xp.asarray(inconsistent(Z)) + Z = xp.asarray(Z) + MD = maxRstat(Z, R, 1) + expectedMD = calculate_maximum_inconsistencies(Z, R, 1, xp) + xp_assert_close(MD, expectedMD, atol=1e-15) + + +@make_xp_test_case(dendrogram) +class TestDendrogram: + + def test_dendrogram_single_linkage_tdist(self, xp): + # Tests dendrogram calculation on single linkage of the tdist data set. + Z = xp.asarray(linkage(hierarchy_test_data.ytdist, 'single')) + R = dendrogram(Z, no_plot=True) + leaves = R["leaves"] + assert_equal(leaves, [2, 5, 1, 0, 3, 4]) + + def test_valid_orientation(self, xp): + Z = xp.asarray(linkage(hierarchy_test_data.ytdist, 'single')) + assert_raises(ValueError, dendrogram, Z, orientation="foo") + + def test_labels_as_array_or_list(self, xp): + # test for gh-12418 + Z = xp.asarray(linkage(hierarchy_test_data.ytdist, 'single')) + labels = [1, 3, 2, 6, 4, 5] + result1 = dendrogram(Z, labels=xp.asarray(labels), no_plot=True) + result2 = dendrogram(Z, labels=labels, no_plot=True) + assert result1 == result2 + + @pytest.mark.skipif(not have_matplotlib, reason="no matplotlib") + def test_valid_label_size(self, xp): + link = xp.asarray([ + [0, 1, 1.0, 4], + [2, 3, 1.0, 5], + [4, 5, 2.0, 6], + ]) + plt.figure() + with pytest.raises(ValueError) as exc_info: + dendrogram(link, labels=list(range(100))) + assert "Dimensions of Z and labels must be consistent."\ + in str(exc_info.value) + + with pytest.raises( + ValueError, + match="Dimensions of Z and labels must be consistent."): + dendrogram(link, labels=[]) + + plt.close() + + @skip_xp_backends('torch', + reason='MPL 3.9.2 & torch DeprecationWarning from __array_wrap__' + ' and NumPy 2.0' + ) + @skip_xp_backends('dask.array', + reason='dask.array has bad interaction with matplotlib' + ) + @pytest.mark.skipif(not have_matplotlib, reason="no matplotlib") + @pytest.mark.parametrize("orientation", ['top', 'bottom', 'left', 'right']) + def test_dendrogram_plot(self, orientation, xp): + # Tests dendrogram plotting. + Z = xp.asarray(linkage(hierarchy_test_data.ytdist, 'single')) + expected = {'color_list': ['C1', 'C0', 'C0', 'C0', 'C0'], + 'dcoord': [[0.0, 138.0, 138.0, 0.0], + [0.0, 219.0, 219.0, 0.0], + [0.0, 255.0, 255.0, 219.0], + [0.0, 268.0, 268.0, 255.0], + [138.0, 295.0, 295.0, 268.0]], + 'icoord': [[5.0, 5.0, 15.0, 15.0], + [45.0, 45.0, 55.0, 55.0], + [35.0, 35.0, 50.0, 50.0], + [25.0, 25.0, 42.5, 42.5], + [10.0, 10.0, 33.75, 33.75]], + 'ivl': ['2', '5', '1', '0', '3', '4'], + 'leaves': [2, 5, 1, 0, 3, 4], + 'leaves_color_list': ['C1', 'C1', 'C0', 'C0', 'C0', 'C0'], + } + + fig = plt.figure() + ax = fig.add_subplot(221) + + # test that dendrogram accepts ax keyword + R1 = dendrogram(Z, ax=ax, orientation=orientation) + R1['dcoord'] = np.asarray(R1['dcoord']) + assert_equal(R1, expected) + + # test that dendrogram accepts and handle the leaf_font_size and + # leaf_rotation keywords + dendrogram(Z, ax=ax, orientation=orientation, + leaf_font_size=20, leaf_rotation=90) + testlabel = ( + ax.get_xticklabels()[0] + if orientation in ['top', 'bottom'] + else ax.get_yticklabels()[0] + ) + assert_equal(testlabel.get_rotation(), 90) + assert_equal(testlabel.get_size(), 20) + dendrogram(Z, ax=ax, orientation=orientation, + leaf_rotation=90) + testlabel = ( + ax.get_xticklabels()[0] + if orientation in ['top', 'bottom'] + else ax.get_yticklabels()[0] + ) + assert_equal(testlabel.get_rotation(), 90) + dendrogram(Z, ax=ax, orientation=orientation, + leaf_font_size=20) + testlabel = ( + ax.get_xticklabels()[0] + if orientation in ['top', 'bottom'] + else ax.get_yticklabels()[0] + ) + assert_equal(testlabel.get_size(), 20) + plt.close() + + # test plotting to gca (will import pylab) + R2 = dendrogram(Z, orientation=orientation) + plt.close() + R2['dcoord'] = np.asarray(R2['dcoord']) + assert_equal(R2, expected) + + @skip_xp_backends('torch', + reason='MPL 3.9.2 & torch DeprecationWarning from __array_wrap__' + ' and NumPy 2.0' + ) + @skip_xp_backends('dask.array', + reason='dask.array has bad interaction with matplotlib' + ) + @pytest.mark.skipif(not have_matplotlib, reason="no matplotlib") + def test_dendrogram_truncate_mode(self, xp): + Z = xp.asarray(linkage(hierarchy_test_data.ytdist, 'single')) + + R = dendrogram(Z, 2, 'lastp', show_contracted=True) + plt.close() + R['dcoord'] = np.asarray(R['dcoord']) + assert_equal(R, {'color_list': ['C0'], + 'dcoord': [[0.0, 295.0, 295.0, 0.0]], + 'icoord': [[5.0, 5.0, 15.0, 15.0]], + 'ivl': ['(2)', '(4)'], + 'leaves': [6, 9], + 'leaves_color_list': ['C0', 'C0'], + }) + + R = dendrogram(Z, 2, 'mtica', show_contracted=True) + plt.close() + R['dcoord'] = np.asarray(R['dcoord']) + assert_equal(R, {'color_list': ['C1', 'C0', 'C0', 'C0'], + 'dcoord': [[0.0, 138.0, 138.0, 0.0], + [0.0, 255.0, 255.0, 0.0], + [0.0, 268.0, 268.0, 255.0], + [138.0, 295.0, 295.0, 268.0]], + 'icoord': [[5.0, 5.0, 15.0, 15.0], + [35.0, 35.0, 45.0, 45.0], + [25.0, 25.0, 40.0, 40.0], + [10.0, 10.0, 32.5, 32.5]], + 'ivl': ['2', '5', '1', '0', '(2)'], + 'leaves': [2, 5, 1, 0, 7], + 'leaves_color_list': ['C1', 'C1', 'C0', 'C0', 'C0'], + }) + + @pytest.fixture + def dendrogram_lock(self): + return Lock() + + def test_dendrogram_colors(self, xp, dendrogram_lock): + # Tests dendrogram plots with alternate colors + Z = xp.asarray(linkage(hierarchy_test_data.ytdist, 'single')) + + with dendrogram_lock: + # Global color palette might be changed concurrently + set_link_color_palette(['c', 'm', 'y', 'k']) + R = dendrogram(Z, no_plot=True, + above_threshold_color='g', color_threshold=250) + set_link_color_palette(['g', 'r', 'c', 'm', 'y', 'k']) + + color_list = R['color_list'] + assert_equal(color_list, ['c', 'm', 'g', 'g', 'g']) + + # reset color palette (global list) + set_link_color_palette(None) + + def test_dendrogram_leaf_colors_zero_dist(self, xp): + # tests that the colors of leafs are correct for tree + # with two identical points + X = np.asarray([[1, 0, 0], + [0, 0, 1], + [0, 2, 0], + [0, 0, 1], + [0, 1, 0], + [0, 1, 0]]) + Z = xp.asarray(linkage(X, "single")) + d = dendrogram(Z, no_plot=True) + exp_colors = ['C0', 'C1', 'C1', 'C0', 'C2', 'C2'] + colors = d["leaves_color_list"] + assert_equal(colors, exp_colors) + + def test_dendrogram_leaf_colors(self, xp): + # tests that the colors are correct for a tree + # with two near points ((0, 0, 1.1) and (0, 0, 1)) + X = np.asarray([[1, 0, 0], + [0, 0, 1.1], + [0, 2, 0], + [0, 0, 1], + [0, 1, 0], + [0, 1, 0]]) + Z = xp.asarray(linkage(X, "single")) + d = dendrogram(Z, no_plot=True) + exp_colors = ['C0', 'C1', 'C1', 'C0', 'C2', 'C2'] + colors = d["leaves_color_list"] + assert_equal(colors, exp_colors) + + +def calculate_maximum_distances(Z, xp): + # Used for testing correctness of maxdists. + n = Z.shape[0] + 1 + B = xp.zeros((n-1,), dtype=Z.dtype) + for i in range(0, n - 1): + q = xp.zeros((3,)) + left = Z[i, 0] + right = Z[i, 1] + if left >= n: + b_left = B[xp.asarray(left, dtype=xp.int64) - n] + q = xpx.at(q, 0).set(b_left) + if right >= n: + b_right = B[xp.asarray(right, dtype=xp.int64) - n] + q = xpx.at(q, 1).set(b_right) + q = xpx.at(q, 2).set(Z[i, 2]) + B = xpx.at(B, i).set(xp.max(q)) + return B + + +def calculate_maximum_inconsistencies(Z, R, k=3, xp=np): + # Used for testing correctness of maxinconsts. + n = Z.shape[0] + 1 + dtype = xp.result_type(Z, R) + B = xp.zeros((n-1,), dtype=dtype) + for i in range(0, n - 1): + q = xp.zeros((3,)) + left = Z[i, 0] + right = Z[i, 1] + if left >= n: + b_left = B[xp.asarray(left, dtype=xp.int64) - n] + q = xpx.at(q, 0).set(b_left) + if right >= n: + b_right = B[xp.asarray(right, dtype=xp.int64) - n] + q = xpx.at(q, 1).set(b_right) + q = xpx.at(q, 2).set(R[i, k]) + B = xpx.at(B, i).set(xp.max(q)) + return B + + +@make_xp_test_case(to_tree) +def test_node_compare(xp): + np.random.seed(23) + nobs = 50 + X = np.random.randn(nobs, 4) + Z = xp.asarray(ward(X)) + tree = to_tree(Z) + assert_(tree > tree.get_left()) + assert_(tree.get_right() > tree.get_left()) + assert_(tree.get_right() == tree.get_right()) + assert_(tree.get_right() != tree.get_left()) + + +@make_xp_test_case(cut_tree) +def test_cut_tree(xp): + np.random.seed(23) + nobs = 50 + X = np.random.randn(nobs, 4) + Z = xp.asarray(ward(X)) + cutree = cut_tree(Z) + + # cutree.dtype varies between int32 and int64 over platforms + xp_assert_close(cutree[:, 0], xp.arange(nobs), rtol=1e-15, check_dtype=False) + xp_assert_close(cutree[:, -1], xp.zeros(nobs), rtol=1e-15, check_dtype=False) + assert_equal(np.asarray(cutree).max(0), np.arange(nobs - 1, -1, -1)) + + xp_assert_close(cutree[:, [-5]], cut_tree(Z, n_clusters=5), rtol=1e-15) + xp_assert_close(cutree[:, [-5, -10]], cut_tree(Z, n_clusters=[5, 10]), rtol=1e-15) + xp_assert_close(cutree[:, [-10, -5]], cut_tree(Z, n_clusters=[10, 5]), rtol=1e-15) + + nodes = _order_cluster_tree(Z) + heights = xp.asarray([node.dist for node in nodes]) + + xp_assert_close(cutree[:, np.searchsorted(heights, [5])], + cut_tree(Z, height=5), rtol=1e-15) + xp_assert_close(cutree[:, np.searchsorted(heights, [5, 10])], + cut_tree(Z, height=[5, 10]), rtol=1e-15) + xp_assert_close(cutree[:, np.searchsorted(heights, [10, 5])], + cut_tree(Z, height=[10, 5]), rtol=1e-15) + + +@make_xp_test_case(optimal_leaf_ordering) +def test_optimal_leaf_ordering(xp): + # test with the distance vector y + Z = optimal_leaf_ordering(xp.asarray(linkage(hierarchy_test_data.ytdist)), + xp.asarray(hierarchy_test_data.ytdist)) + expectedZ = hierarchy_test_data.linkage_ytdist_single_olo + xp_assert_close(Z, xp.asarray(expectedZ), atol=1e-10) + + # test with the observation matrix X + Z = optimal_leaf_ordering(xp.asarray(linkage(hierarchy_test_data.X, 'ward')), + xp.asarray(hierarchy_test_data.X)) + expectedZ = hierarchy_test_data.linkage_X_ward_olo + xp_assert_close(Z, xp.asarray(expectedZ), atol=1e-06) + + +@skip_xp_backends(np_only=True, reason='`Heap` only supports NumPy backend') +def test_Heap(xp): + values = xp.asarray([2, -1, 0, -1.5, 3]) + heap = Heap(values) + + pair = heap.get_min() + assert_equal(pair['key'], 3) + assert_equal(pair['value'], -1.5) + + heap.remove_min() + pair = heap.get_min() + assert_equal(pair['key'], 1) + assert_equal(pair['value'], -1) + + heap.change_value(1, 2.5) + pair = heap.get_min() + assert_equal(pair['key'], 2) + assert_equal(pair['value'], 0) + + heap.remove_min() + heap.remove_min() + + heap.change_value(1, 10) + pair = heap.get_min() + assert_equal(pair['key'], 4) + assert_equal(pair['value'], 3) + + heap.remove_min() + pair = heap.get_min() + assert_equal(pair['key'], 1) + assert_equal(pair['value'], 10) diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/test_vq.py b/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/test_vq.py new file mode 100644 index 0000000000000000000000000000000000000000..cd285d96ed0badb8aa42d7c68ae04998b717c4a3 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/scipy/cluster/tests/test_vq.py @@ -0,0 +1,437 @@ +import math +import sys +import warnings +from copy import deepcopy +from threading import Lock + +import numpy as np +from numpy.testing import assert_array_equal +import pytest +from pytest import raises as assert_raises + +from scipy.cluster.vq import (kmeans, kmeans2, py_vq, vq, whiten, + ClusterError, _krandinit) +from scipy.cluster import _vq +from scipy.sparse._sputils import matrix + +from scipy._lib import array_api_extra as xpx +from scipy._lib._array_api import ( + SCIPY_ARRAY_API, eager_warns, is_lazy_array, make_xp_test_case, + xp_copy, xp_assert_close, xp_assert_equal +) + +xfail_xp_backends = pytest.mark.xfail_xp_backends +skip_xp_backends = pytest.mark.skip_xp_backends + +TESTDATA_2D = np.array([ + -2.2, 1.17, -1.63, 1.69, -2.04, 4.38, -3.09, 0.95, -1.7, 4.79, -1.68, 0.68, + -2.26, 3.34, -2.29, 2.55, -1.72, -0.72, -1.99, 2.34, -2.75, 3.43, -2.45, + 2.41, -4.26, 3.65, -1.57, 1.87, -1.96, 4.03, -3.01, 3.86, -2.53, 1.28, + -4.0, 3.95, -1.62, 1.25, -3.42, 3.17, -1.17, 0.12, -3.03, -0.27, -2.07, + -0.55, -1.17, 1.34, -2.82, 3.08, -2.44, 0.24, -1.71, 2.48, -5.23, 4.29, + -2.08, 3.69, -1.89, 3.62, -2.09, 0.26, -0.92, 1.07, -2.25, 0.88, -2.25, + 2.02, -4.31, 3.86, -2.03, 3.42, -2.76, 0.3, -2.48, -0.29, -3.42, 3.21, + -2.3, 1.73, -2.84, 0.69, -1.81, 2.48, -5.24, 4.52, -2.8, 1.31, -1.67, + -2.34, -1.18, 2.17, -2.17, 2.82, -1.85, 2.25, -2.45, 1.86, -6.79, 3.94, + -2.33, 1.89, -1.55, 2.08, -1.36, 0.93, -2.51, 2.74, -2.39, 3.92, -3.33, + 2.99, -2.06, -0.9, -2.83, 3.35, -2.59, 3.05, -2.36, 1.85, -1.69, 1.8, + -1.39, 0.66, -2.06, 0.38, -1.47, 0.44, -4.68, 3.77, -5.58, 3.44, -2.29, + 2.24, -1.04, -0.38, -1.85, 4.23, -2.88, 0.73, -2.59, 1.39, -1.34, 1.75, + -1.95, 1.3, -2.45, 3.09, -1.99, 3.41, -5.55, 5.21, -1.73, 2.52, -2.17, + 0.85, -2.06, 0.49, -2.54, 2.07, -2.03, 1.3, -3.23, 3.09, -1.55, 1.44, + -0.81, 1.1, -2.99, 2.92, -1.59, 2.18, -2.45, -0.73, -3.12, -1.3, -2.83, + 0.2, -2.77, 3.24, -1.98, 1.6, -4.59, 3.39, -4.85, 3.75, -2.25, 1.71, -3.28, + 3.38, -1.74, 0.88, -2.41, 1.92, -2.24, 1.19, -2.48, 1.06, -1.68, -0.62, + -1.3, 0.39, -1.78, 2.35, -3.54, 2.44, -1.32, 0.66, -2.38, 2.76, -2.35, + 3.95, -1.86, 4.32, -2.01, -1.23, -1.79, 2.76, -2.13, -0.13, -5.25, 3.84, + -2.24, 1.59, -4.85, 2.96, -2.41, 0.01, -0.43, 0.13, -3.92, 2.91, -1.75, + -0.53, -1.69, 1.69, -1.09, 0.15, -2.11, 2.17, -1.53, 1.22, -2.1, -0.86, + -2.56, 2.28, -3.02, 3.33, -1.12, 3.86, -2.18, -1.19, -3.03, 0.79, -0.83, + 0.97, -3.19, 1.45, -1.34, 1.28, -2.52, 4.22, -4.53, 3.22, -1.97, 1.75, + -2.36, 3.19, -0.83, 1.53, -1.59, 1.86, -2.17, 2.3, -1.63, 2.71, -2.03, + 3.75, -2.57, -0.6, -1.47, 1.33, -1.95, 0.7, -1.65, 1.27, -1.42, 1.09, -3.0, + 3.87, -2.51, 3.06, -2.6, 0.74, -1.08, -0.03, -2.44, 1.31, -2.65, 2.99, + -1.84, 1.65, -4.76, 3.75, -2.07, 3.98, -2.4, 2.67, -2.21, 1.49, -1.21, + 1.22, -5.29, 2.38, -2.85, 2.28, -5.6, 3.78, -2.7, 0.8, -1.81, 3.5, -3.75, + 4.17, -1.29, 2.99, -5.92, 3.43, -1.83, 1.23, -1.24, -1.04, -2.56, 2.37, + -3.26, 0.39, -4.63, 2.51, -4.52, 3.04, -1.7, 0.36, -1.41, 0.04, -2.1, 1.0, + -1.87, 3.78, -4.32, 3.59, -2.24, 1.38, -1.99, -0.22, -1.87, 1.95, -0.84, + 2.17, -5.38, 3.56, -1.27, 2.9, -1.79, 3.31, -5.47, 3.85, -1.44, 3.69, + -2.02, 0.37, -1.29, 0.33, -2.34, 2.56, -1.74, -1.27, -1.97, 1.22, -2.51, + -0.16, -1.64, -0.96, -2.99, 1.4, -1.53, 3.31, -2.24, 0.45, -2.46, 1.71, + -2.88, 1.56, -1.63, 1.46, -1.41, 0.68, -1.96, 2.76, -1.61, + 2.11]).reshape((200, 2)) + + +# Global data +X = np.array([[3.0, 3], [4, 3], [4, 2], + [9, 2], [5, 1], [6, 2], [9, 4], + [5, 2], [5, 4], [7, 4], [6, 5]]) + +CODET1 = np.array([[3.0000, 3.0000], + [6.2000, 4.0000], + [5.8000, 1.8000]]) + +CODET2 = np.array([[11.0/3, 8.0/3], + [6.7500, 4.2500], + [6.2500, 1.7500]]) + +LABEL1 = np.array([0, 1, 2, 2, 2, 2, 1, 2, 1, 1, 1]) + + +@make_xp_test_case(whiten) +class TestWhiten: + + def test_whiten(self, xp): + desired = xp.asarray([[5.08738849, 2.97091878], + [3.19909255, 0.69660580], + [4.51041982, 0.02640918], + [4.38567074, 0.95120889], + [2.32191480, 1.63195503]]) + + obs = xp.asarray([[0.98744510, 0.82766775], + [0.62093317, 0.19406729], + [0.87545741, 0.00735733], + [0.85124403, 0.26499712], + [0.45067590, 0.45464607]]) + xp_assert_close(whiten(obs), desired, rtol=1e-5) + + def test_whiten_zero_std(self, xp): + desired = xp.asarray([[0., 1.0, 2.86666544], + [0., 1.0, 1.32460034], + [0., 1.0, 3.74382172]]) + + obs = xp.asarray([[0., 1., 0.74109533], + [0., 1., 0.34243798], + [0., 1., 0.96785929]]) + + with eager_warns(RuntimeWarning, match="Some columns have standard...", xp=xp): + actual = whiten(obs) + xp_assert_close(actual, desired, rtol=1e-5) + + @pytest.mark.filterwarnings("ignore:invalid value encountered:RuntimeWarning:dask") + @pytest.mark.parametrize("bad_value", [math.nan, math.inf, -math.inf]) + def test_whiten_not_finite(self, bad_value, xp): + obs = xp.asarray([[0.98744510, bad_value], + [0.62093317, 0.19406729], + [0.87545741, 0.00735733], + [0.85124403, 0.26499712], + [0.45067590, 0.45464607]]) + + if is_lazy_array(obs): + desired = xp.asarray([[5.08738849, math.nan], + [3.19909255, math.nan], + [4.51041982, math.nan], + [4.38567074, math.nan], + [2.32191480, math.nan]]) + xp_assert_close(whiten(obs), desired, rtol=1e-5) + else: + assert_raises(ValueError, whiten, obs) + + @pytest.mark.skipif(SCIPY_ARRAY_API, + reason='`np.matrix` unsupported in array API mode') + def test_whiten_not_finite_matrix(self): + for bad_value in np.nan, np.inf, -np.inf: + obs = matrix([[0.98744510, bad_value], + [0.62093317, 0.19406729], + [0.87545741, 0.00735733], + [0.85124403, 0.26499712], + [0.45067590, 0.45464607]]) + assert_raises(ValueError, whiten, obs) + + +@make_xp_test_case(vq) +class TestVq: + + def test_py_vq(self, xp): + initc = np.concatenate([[X[0]], [X[1]], [X[2]]]) + # label1.dtype varies between int32 and int64 over platforms + label1 = py_vq(xp.asarray(X), xp.asarray(initc))[0] + xp_assert_equal(label1, xp.asarray(LABEL1, dtype=xp.int64), + check_dtype=False) + + @pytest.mark.skipif(SCIPY_ARRAY_API, + reason='`np.matrix` unsupported in array API mode') + def test_py_vq_matrix(self): + initc = np.concatenate([[X[0]], [X[1]], [X[2]]]) + # label1.dtype varies between int32 and int64 over platforms + label1 = py_vq(matrix(X), matrix(initc))[0] + assert_array_equal(label1, LABEL1) + + def test_vq(self, xp): + initc = np.concatenate([[X[0]], [X[1]], [X[2]]]) + label1, _ = _vq.vq(X, initc) + assert_array_equal(label1, LABEL1) + _, _ = vq(xp.asarray(X), xp.asarray(initc)) + + @pytest.mark.skipif(SCIPY_ARRAY_API, + reason='`np.matrix` unsupported in array API mode') + def test_vq_matrix(self): + initc = np.concatenate([[X[0]], [X[1]], [X[2]]]) + label1, _ = _vq.vq(matrix(X), matrix(initc)) + assert_array_equal(label1, LABEL1) + _, _ = vq(matrix(X), matrix(initc)) + + def test_vq_1d(self, xp): + # Test special rank 1 vq algo, python implementation. + data = X[:, 0] + initc = data[:3] + a, b = _vq.vq(data, initc) + data = xp.asarray(data) + initc = xp.asarray(initc) + ta, tb = py_vq(data[:, np.newaxis], initc[:, np.newaxis]) + # ta.dtype varies between int32 and int64 over platforms + xp_assert_equal(ta, xp.asarray(a, dtype=xp.int64), check_dtype=False) + xp_assert_equal(tb, xp.asarray(b)) + + def test__vq_sametype(self): + a = np.asarray([1.0, 2.0]) + b = a.astype(np.float32) + assert_raises(TypeError, _vq.vq, a, b) + + def test__vq_invalid_type(self): + a = np.asarray([1, 2], dtype=int) + assert_raises(TypeError, _vq.vq, a, a) + + def test_vq_large_nfeat(self, xp): + X = np.random.rand(20, 20) + code_book = np.random.rand(3, 20) + + codes0, dis0 = _vq.vq(X, code_book) + codes1, dis1 = py_vq( + xp.asarray(X), xp.asarray(code_book) + ) + xp_assert_close(dis1, xp.asarray(dis0), rtol=1e-5) + # codes1.dtype varies between int32 and int64 over platforms + xp_assert_equal(codes1, xp.asarray(codes0, dtype=xp.int64), check_dtype=False) + + X = X.astype(np.float32) + code_book = code_book.astype(np.float32) + + codes0, dis0 = _vq.vq(X, code_book) + codes1, dis1 = py_vq( + xp.asarray(X), xp.asarray(code_book) + ) + xp_assert_close(dis1, xp.asarray(dis0, dtype=xp.float64), rtol=1e-5) + # codes1.dtype varies between int32 and int64 over platforms + xp_assert_equal(codes1, xp.asarray(codes0, dtype=xp.int64), check_dtype=False) + + def test_vq_large_features(self, xp): + X = np.random.rand(10, 5) * 1000000 + code_book = np.random.rand(2, 5) * 1000000 + + codes0, dis0 = _vq.vq(X, code_book) + codes1, dis1 = py_vq( + xp.asarray(X), xp.asarray(code_book) + ) + xp_assert_close(dis1, xp.asarray(dis0), rtol=1e-5) + # codes1.dtype varies between int32 and int64 over platforms + xp_assert_equal(codes1, xp.asarray(codes0, dtype=xp.int64), check_dtype=False) + + +# Whole class skipped on GPU for now; +# once pdist/cdist are hooked up for CuPy, more tests will work +@make_xp_test_case(kmeans, kmeans2) +class TestKMeans: + + def test_large_features(self, xp): + # Generate a data set with large values, and run kmeans on it to + # (regression for 1077). + d = 300 + n = 100 + + m1 = np.random.randn(d) + m2 = np.random.randn(d) + x = 10000 * np.random.randn(n, d) - 20000 * m1 + y = 10000 * np.random.randn(n, d) + 20000 * m2 + + data = np.empty((x.shape[0] + y.shape[0], d), np.float64) + data[:x.shape[0]] = x + data[x.shape[0]:] = y + + # use `seed` to ensure backwards compatibility after SPEC7 + kmeans(xp.asarray(data), 2, seed=1) + + def test_kmeans_simple(self, xp): + rng = np.random.default_rng(54321) + initc = np.concatenate([[X[0]], [X[1]], [X[2]]]) + code1 = kmeans(xp.asarray(X), xp.asarray(initc), iter=1, rng=rng)[0] + xp_assert_close(code1, xp.asarray(CODET2)) + + @pytest.mark.skipif(SCIPY_ARRAY_API, + reason='`np.matrix` unsupported in array API mode') + def test_kmeans_simple_matrix(self): + rng = np.random.default_rng(54321) + initc = np.concatenate([[X[0]], [X[1]], [X[2]]]) + code1 = kmeans(matrix(X), matrix(initc), iter=1, rng=rng)[0] + xp_assert_close(code1, CODET2) + + def test_kmeans_lost_cluster(self, xp): + # This will cause kmeans to have a cluster with no points. + data = xp.asarray(TESTDATA_2D) + initk = xp.asarray([[-1.8127404, -0.67128041], + [2.04621601, 0.07401111], + [-2.31149087, -0.05160469]]) + + kmeans(data, initk) + with warnings.catch_warnings(): + warnings.filterwarnings( + "ignore", + ("One of the clusters is empty. Re-run kmeans with a different " + "initialization"), + UserWarning, + ) + kmeans2(data, initk, missing='warn') + + assert_raises(ClusterError, kmeans2, data, initk, missing='raise') + + def test_kmeans2_simple(self, xp): + rng = np.random.default_rng(12345678) + initc = xp.asarray(np.concatenate([[X[0]], [X[1]], [X[2]]])) + arrays = [xp.asarray] if SCIPY_ARRAY_API else [np.asarray, matrix] + for tp in arrays: + code1 = kmeans2(tp(X), tp(initc), iter=1, rng=rng)[0] + code2 = kmeans2(tp(X), tp(initc), iter=2, rng=rng)[0] + + xp_assert_close(code1, xp.asarray(CODET1)) + xp_assert_close(code2, xp.asarray(CODET2)) + + @pytest.mark.skipif(SCIPY_ARRAY_API, + reason='`np.matrix` unsupported in array API mode') + def test_kmeans2_simple_matrix(self): + rng = np.random.default_rng(12345678) + initc = np.concatenate([[X[0]], [X[1]], [X[2]]]) + code1 = kmeans2(matrix(X), matrix(initc), iter=1, rng=rng)[0] + code2 = kmeans2(matrix(X), matrix(initc), iter=2, rng=rng)[0] + + xp_assert_close(code1, CODET1) + xp_assert_close(code2, CODET2) + + def test_kmeans2_rank1(self, xp): + data = xp.asarray(TESTDATA_2D) + data1 = data[:, 0] + + initc = data1[:3] + code = xp_copy(initc, xp=xp) + + # use `seed` to ensure backwards compatibility after SPEC7 + kmeans2(data1, code, iter=1, seed=1)[0] + kmeans2(data1, code, iter=2)[0] + + def test_kmeans2_rank1_2(self, xp): + data = xp.asarray(TESTDATA_2D) + data1 = data[:, 0] + kmeans2(data1, 2, iter=1) + + def test_kmeans2_high_dim(self, xp): + # test kmeans2 when the number of dimensions exceeds the number + # of input points + data = xp.asarray(TESTDATA_2D) + data = xp.reshape(data, (20, 20))[:10, :] + kmeans2(data, 2) + + def test_kmeans2_init(self, xp): + rng = np.random.default_rng(12345678) + data = xp.asarray(TESTDATA_2D) + k = 3 + + kmeans2(data, k, minit='points', rng=rng) + kmeans2(data[:, 1], k, minit='points', rng=rng) # special case (1-D) + + kmeans2(data, k, minit='++', rng=rng) + kmeans2(data[:, 1], k, minit='++', rng=rng) # special case (1-D) + + # minit='random' can give warnings, filter those + with warnings.catch_warnings(): + warnings.filterwarnings("ignore", "One of the clusters is empty. Re-run.") + kmeans2(data, k, minit='random', rng=rng) + kmeans2(data[:, 1], k, minit='random', rng=rng) # special case (1-D) + + @pytest.fixture + def krand_lock(self): + return Lock() + + @xfail_xp_backends('dask.array', reason="Wrong answer") + @pytest.mark.skipif(sys.platform == 'win32', + reason='Fails with MemoryError in Wine.') + def test_krandinit(self, xp, krand_lock): + data = xp.asarray(TESTDATA_2D) + datas = [xp.reshape(data, (200, 2)), + xp.reshape(data, (20, 20))[:10, :]] + k = int(1e6) + with krand_lock: + for data in datas: + rng = np.random.default_rng(1234) + init = _krandinit(data, k, rng, xp) + orig_cov = xpx.cov(data.T, xp=xp) + init_cov = xpx.cov(init.T, xp=xp) + xp_assert_close(orig_cov, init_cov, atol=1.1e-2) + + def test_kmeans2_empty(self, xp): + # Regression test for gh-1032. + assert_raises(ValueError, kmeans2, xp.asarray([]), 2) + + def test_kmeans_0k(self, xp): + # Regression test for gh-1073: fail when k arg is 0. + assert_raises(ValueError, kmeans, xp.asarray(X), 0) + assert_raises(ValueError, kmeans2, xp.asarray(X), 0) + assert_raises(ValueError, kmeans2, xp.asarray(X), xp.asarray([])) + + def test_kmeans_large_thres(self, xp): + # Regression test for gh-1774 + x = xp.asarray([1, 2, 3, 4, 10], dtype=xp.float64) + res = kmeans(x, 1, thresh=1e16) + xp_assert_close(res[0], xp.asarray([4.], dtype=xp.float64)) + xp_assert_close(res[1], xp.asarray(2.3999999999999999, dtype=xp.float64)[()]) + + def test_kmeans2_kpp_low_dim(self, xp): + # Regression test for gh-11462 + rng = np.random.default_rng(2358792345678234568) + prev_res = xp.asarray([[-1.95266667, 0.898], + [-3.153375, 3.3945]], dtype=xp.float64) + res, _ = kmeans2(xp.asarray(TESTDATA_2D), 2, minit='++', rng=rng) + xp_assert_close(res, prev_res) + + def test_kmeans2_kpp_high_dim(self, xp): + # Regression test for gh-11462 + rng = np.random.default_rng(23587923456834568) + n_dim = 100 + size = 10 + centers = np.vstack([5 * np.ones(n_dim), + -5 * np.ones(n_dim)]) + + data = np.vstack([ + rng.multivariate_normal(centers[0], np.eye(n_dim), size=size), + rng.multivariate_normal(centers[1], np.eye(n_dim), size=size) + ]) + + data = xp.asarray(data) + res, _ = kmeans2(data, 2, minit='++', rng=rng) + xp_assert_equal(xp.sign(res), xp.sign(xp.asarray(centers))) + + def test_kmeans_diff_convergence(self, xp): + # Regression test for gh-8727 + obs = xp.asarray([-3, -1, 0, 1, 1, 8], dtype=xp.float64) + res = kmeans(obs, xp.asarray([-3., 0.99])) + xp_assert_close(res[0], xp.asarray([-0.4, 8.], dtype=xp.float64)) + xp_assert_close(res[1], xp.asarray(1.0666666666666667, dtype=xp.float64)[()]) + + def test_kmeans_and_kmeans2_random_seed(self, xp): + + seed_list = [ + 1234, np.random.RandomState(1234), np.random.default_rng(1234) + ] + + for seed in seed_list: + seed1 = deepcopy(seed) + seed2 = deepcopy(seed) + data = xp.asarray(TESTDATA_2D) + # test for kmeans + res1, _ = kmeans(data, 2, seed=seed1) + res2, _ = kmeans(data, 2, seed=seed2) + xp_assert_close(res1, res2) # should be same results + # test for kmeans2 + for minit in ["random", "points", "++"]: + res1, _ = kmeans2(data, 2, minit=minit, seed=seed1) + res2, _ = kmeans2(data, 2, minit=minit, seed=seed2) + xp_assert_close(res1, res2) # should be same results diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/misc/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/scipy/misc/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c4cea34c2e4b47c9bae96aa2fde4a83e35d73b90 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/scipy/misc/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/misc/__pycache__/common.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/scipy/misc/__pycache__/common.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..325892d08e64e3bc6a3d7ddaa4e3170aa1a8f97b Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/scipy/misc/__pycache__/common.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/misc/__pycache__/doccer.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/scipy/misc/__pycache__/doccer.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e3b8c56dd02a995635f20a5eebbb3885034cd9d2 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/scipy/misc/__pycache__/doccer.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e3dc09a8526ac97d5b22a88468502fdb148936e3 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/__pycache__/test_c_api.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/__pycache__/test_c_api.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0c84265afc61d8fe8d145cee7ece021c75df1543 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/__pycache__/test_c_api.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/__pycache__/test_datatypes.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/__pycache__/test_datatypes.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fce2540afeb3005bb592016ad5d2957609f84590 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/__pycache__/test_datatypes.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/__pycache__/test_fourier.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/__pycache__/test_fourier.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..97ae4c80afd4257129c9607d3baa894bbd6df2ab Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/__pycache__/test_fourier.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/__pycache__/test_interpolation.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/__pycache__/test_interpolation.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..424a3e737b47e5b2207c52441afe7535cf1d7336 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/__pycache__/test_interpolation.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/__pycache__/test_measurements.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/__pycache__/test_measurements.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f7a9e28a77f935440bbfc193535a90f3502ca277 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/__pycache__/test_measurements.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/__pycache__/test_ni_support.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/__pycache__/test_ni_support.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ea84cbc4057cc035da5fe262b84c01e0a1e1d1e1 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/__pycache__/test_ni_support.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/__pycache__/test_splines.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/__pycache__/test_splines.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0f0039c42f68c792caccb9efe786a96e0412008c Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/__pycache__/test_splines.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/data/label_inputs.txt b/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/data/label_inputs.txt new file mode 100644 index 0000000000000000000000000000000000000000..6c3cff3b12cec4ad050b31cc5d5c327f32784447 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/data/label_inputs.txt @@ -0,0 +1,21 @@ +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 0 1 1 1 +1 1 0 0 0 1 1 +1 0 1 0 1 0 1 +0 0 0 1 0 0 0 +1 0 1 0 1 0 1 +1 1 0 0 0 1 1 +1 1 1 0 1 1 1 +1 0 1 1 1 0 1 +0 0 0 1 0 0 0 +1 0 0 1 0 0 1 +1 1 1 1 1 1 1 +1 0 0 1 0 0 1 +0 0 0 1 0 0 0 +1 0 1 1 1 0 1 diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/data/label_results.txt b/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/data/label_results.txt new file mode 100644 index 0000000000000000000000000000000000000000..c239b0369c9df3e06df9a2fbf048faec2f84941f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/data/label_results.txt @@ -0,0 +1,294 @@ +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +2 2 2 2 2 2 2 +3 3 3 3 3 3 3 +4 4 4 4 4 4 4 +5 5 5 5 5 5 5 +6 6 6 6 6 6 6 +7 7 7 7 7 7 7 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 2 3 4 5 6 7 +8 9 10 11 12 13 14 +15 16 17 18 19 20 21 +22 23 24 25 26 27 28 +29 30 31 32 33 34 35 +36 37 38 39 40 41 42 +43 44 45 46 47 48 49 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 2 3 4 5 6 7 +8 1 2 3 4 5 6 +9 8 1 2 3 4 5 +10 9 8 1 2 3 4 +11 10 9 8 1 2 3 +12 11 10 9 8 1 2 +13 12 11 10 9 8 1 +1 2 3 4 5 6 7 +1 2 3 4 5 6 7 +1 2 3 4 5 6 7 +1 2 3 4 5 6 7 +1 2 3 4 5 6 7 +1 2 3 4 5 6 7 +1 2 3 4 5 6 7 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 2 1 2 1 2 1 +2 1 2 1 2 1 2 +1 2 1 2 1 2 1 +2 1 2 1 2 1 2 +1 2 1 2 1 2 1 +2 1 2 1 2 1 2 +1 2 1 2 1 2 1 +1 2 3 4 5 6 7 +2 3 4 5 6 7 8 +3 4 5 6 7 8 9 +4 5 6 7 8 9 10 +5 6 7 8 9 10 11 +6 7 8 9 10 11 12 +7 8 9 10 11 12 13 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 1 1 1 1 +1 1 1 0 2 2 2 +1 1 0 0 0 2 2 +1 0 3 0 2 0 4 +0 0 0 2 0 0 0 +5 0 2 0 6 0 7 +2 2 0 0 0 7 7 +2 2 2 0 7 7 7 +1 1 1 0 2 2 2 +1 1 0 0 0 2 2 +3 0 1 0 4 0 2 +0 0 0 1 0 0 0 +5 0 6 0 1 0 7 +5 5 0 0 0 1 1 +5 5 5 0 1 1 1 +1 1 1 0 2 2 2 +3 3 0 0 0 4 4 +5 0 6 0 7 0 8 +0 0 0 9 0 0 0 +10 0 11 0 12 0 13 +14 14 0 0 0 15 15 +16 16 16 0 17 17 17 +1 1 1 0 2 3 3 +1 1 0 0 0 3 3 +1 0 4 0 3 0 3 +0 0 0 3 0 0 0 +3 0 3 0 5 0 6 +3 3 0 0 0 6 6 +3 3 7 0 6 6 6 +1 2 3 0 4 5 6 +7 8 0 0 0 9 10 +11 0 12 0 13 0 14 +0 0 0 15 0 0 0 +16 0 17 0 18 0 19 +20 21 0 0 0 22 23 +24 25 26 0 27 28 29 +1 1 1 0 2 2 2 +1 1 0 0 0 2 2 +1 0 3 0 2 0 2 +0 0 0 2 0 0 0 +2 0 2 0 4 0 5 +2 2 0 0 0 5 5 +2 2 2 0 5 5 5 +1 1 1 0 2 2 2 +1 1 0 0 0 2 2 +1 0 3 0 4 0 2 +0 0 0 5 0 0 0 +6 0 7 0 8 0 9 +6 6 0 0 0 9 9 +6 6 6 0 9 9 9 +1 2 3 0 4 5 6 +7 1 0 0 0 4 5 +8 0 1 0 9 0 4 +0 0 0 1 0 0 0 +10 0 11 0 1 0 12 +13 10 0 0 0 1 14 +15 13 10 0 16 17 1 +1 2 3 0 4 5 6 +1 2 0 0 0 5 6 +1 0 7 0 8 0 6 +0 0 0 9 0 0 0 +10 0 11 0 12 0 13 +10 14 0 0 0 15 13 +10 14 16 0 17 15 13 +1 1 1 0 1 1 1 +1 1 0 0 0 1 1 +1 0 1 0 1 0 1 +0 0 0 1 0 0 0 +1 0 1 0 1 0 1 +1 1 0 0 0 1 1 +1 1 1 0 1 1 1 +1 1 2 0 3 3 3 +1 1 0 0 0 3 3 +1 0 1 0 4 0 3 +0 0 0 1 0 0 0 +5 0 6 0 1 0 1 +5 5 0 0 0 1 1 +5 5 5 0 7 1 1 +1 2 1 0 1 3 1 +2 1 0 0 0 1 3 +1 0 1 0 1 0 1 +0 0 0 1 0 0 0 +1 0 1 0 1 0 1 +4 1 0 0 0 1 5 +1 4 1 0 1 5 1 +1 2 3 0 4 5 6 +2 3 0 0 0 6 7 +3 0 8 0 6 0 9 +0 0 0 6 0 0 0 +10 0 6 0 11 0 12 +13 6 0 0 0 12 14 +6 15 16 0 12 14 17 +1 1 1 0 2 2 2 +1 1 0 0 0 2 2 +1 0 1 0 3 0 2 +0 0 0 1 0 0 0 +4 0 5 0 1 0 1 +4 4 0 0 0 1 1 +4 4 4 0 1 1 1 +1 0 2 2 2 0 3 +0 0 0 2 0 0 0 +4 0 0 5 0 0 5 +5 5 5 5 5 5 5 +5 0 0 5 0 0 6 +0 0 0 7 0 0 0 +8 0 7 7 7 0 9 +1 0 2 2 2 0 3 +0 0 0 2 0 0 0 +4 0 0 4 0 0 5 +4 4 4 4 4 4 4 +6 0 0 4 0 0 4 +0 0 0 7 0 0 0 +8 0 7 7 7 0 9 +1 0 2 2 2 0 3 +0 0 0 4 0 0 0 +5 0 0 6 0 0 7 +8 8 8 8 8 8 8 +9 0 0 10 0 0 11 +0 0 0 12 0 0 0 +13 0 14 14 14 0 15 +1 0 2 3 3 0 4 +0 0 0 3 0 0 0 +5 0 0 3 0 0 6 +5 5 3 3 3 6 6 +5 0 0 3 0 0 6 +0 0 0 3 0 0 0 +7 0 3 3 8 0 9 +1 0 2 3 4 0 5 +0 0 0 6 0 0 0 +7 0 0 8 0 0 9 +10 11 12 13 14 15 16 +17 0 0 18 0 0 19 +0 0 0 20 0 0 0 +21 0 22 23 24 0 25 +1 0 2 2 2 0 3 +0 0 0 2 0 0 0 +2 0 0 2 0 0 2 +2 2 2 2 2 2 2 +2 0 0 2 0 0 2 +0 0 0 2 0 0 0 +4 0 2 2 2 0 5 +1 0 2 2 2 0 3 +0 0 0 2 0 0 0 +2 0 0 2 0 0 2 +2 2 2 2 2 2 2 +2 0 0 2 0 0 2 +0 0 0 2 0 0 0 +4 0 2 2 2 0 5 +1 0 2 3 4 0 5 +0 0 0 2 0 0 0 +6 0 0 7 0 0 8 +9 6 10 11 7 12 13 +14 0 0 10 0 0 12 +0 0 0 15 0 0 0 +16 0 17 18 15 0 19 +1 0 2 3 4 0 5 +0 0 0 3 0 0 0 +6 0 0 3 0 0 7 +6 8 9 3 10 11 7 +6 0 0 3 0 0 7 +0 0 0 3 0 0 0 +12 0 13 3 14 0 15 +1 0 2 2 2 0 3 +0 0 0 2 0 0 0 +2 0 0 2 0 0 2 +2 2 2 2 2 2 2 +2 0 0 2 0 0 2 +0 0 0 2 0 0 0 +4 0 2 2 2 0 5 +1 0 2 2 3 0 4 +0 0 0 2 0 0 0 +5 0 0 2 0 0 6 +5 5 2 2 2 6 6 +5 0 0 2 0 0 6 +0 0 0 2 0 0 0 +7 0 8 2 2 0 9 +1 0 2 3 2 0 4 +0 0 0 2 0 0 0 +5 0 0 6 0 0 7 +8 5 6 9 6 7 10 +5 0 0 6 0 0 7 +0 0 0 11 0 0 0 +12 0 11 13 11 0 14 +1 0 2 3 4 0 5 +0 0 0 4 0 0 0 +6 0 0 7 0 0 8 +9 10 7 11 12 8 13 +10 0 0 12 0 0 14 +0 0 0 15 0 0 0 +16 0 15 17 18 0 19 +1 0 2 2 2 0 3 +0 0 0 2 0 0 0 +2 0 0 2 0 0 2 +2 2 2 2 2 2 2 +2 0 0 2 0 0 2 +0 0 0 2 0 0 0 +4 0 2 2 2 0 5 diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/data/label_strels.txt b/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/data/label_strels.txt new file mode 100644 index 0000000000000000000000000000000000000000..35ae8121364d4fb3292c11f2a72333f456fa9c0a --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/scipy/ndimage/tests/data/label_strels.txt @@ -0,0 +1,42 @@ +0 0 1 +1 1 1 +1 0 0 +1 0 0 +1 1 1 +0 0 1 +0 0 0 +1 1 1 +0 0 0 +0 1 1 +0 1 0 +1 1 0 +0 0 0 +0 0 0 +0 0 0 +0 1 1 +1 1 1 +1 1 0 +0 1 0 +1 1 1 +0 1 0 +1 0 0 +0 1 0 +0 0 1 +0 1 0 +0 1 0 +0 1 0 +1 1 1 +1 1 1 +1 1 1 +1 1 0 +0 1 0 +0 1 1 +1 0 1 +0 1 0 +1 0 1 +0 0 1 +0 1 0 +1 0 0 +1 1 0 +1 1 1 +0 1 1 diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/odr/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/scipy/odr/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3c867256ebe563ce1ebf42672347cf4d48d603d4 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/scipy/odr/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/odr/__pycache__/_add_newdocs.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/scipy/odr/__pycache__/_add_newdocs.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..089e68a3e29571a4d0f5cb324ee800b2fbf0b0d5 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/scipy/odr/__pycache__/_add_newdocs.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/odr/__pycache__/_models.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/scipy/odr/__pycache__/_models.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1df49a9c3cca1589ed37a988eccf614fef01da81 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/scipy/odr/__pycache__/_models.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/odr/__pycache__/_odrpack.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/scipy/odr/__pycache__/_odrpack.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..56a5a115572845c824be54dde6fcde4ffa9b4420 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/scipy/odr/__pycache__/_odrpack.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/odr/__pycache__/models.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/scipy/odr/__pycache__/models.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fe53210d88e1cd8e79fa59a9b34a68afdcfecebf Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/scipy/odr/__pycache__/models.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/odr/__pycache__/odrpack.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/scipy/odr/__pycache__/odrpack.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a9ddb0b65c767f42f19b68cf6a14fdf21153840d Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/scipy/odr/__pycache__/odrpack.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/odr/tests/__init__.py b/.venv_haddock/lib/python3.12/site-packages/scipy/odr/tests/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/odr/tests/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/scipy/odr/tests/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..97b573300bc327f3352178f79aa947109442d310 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/scipy/odr/tests/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/odr/tests/__pycache__/test_odr.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/scipy/odr/tests/__pycache__/test_odr.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..09865268179f8fdc9400c34289502ca5ef00d708 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/scipy/odr/tests/__pycache__/test_odr.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/scipy/odr/tests/test_odr.py b/.venv_haddock/lib/python3.12/site-packages/scipy/odr/tests/test_odr.py new file mode 100644 index 0000000000000000000000000000000000000000..5d0545b018097237377878fd085960587082903a --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/scipy/odr/tests/test_odr.py @@ -0,0 +1,621 @@ +import pickle +import tempfile +import shutil +import os + +import numpy as np +from numpy import pi +from numpy.testing import (assert_array_almost_equal, + assert_equal, + assert_allclose) +import pytest +from pytest import raises as assert_raises + +from scipy.odr import (Data, Model, ODR, RealData, OdrStop, OdrWarning, + OdrError, multilinear, exponential, unilinear, + quadratic, polynomial) + + +class TestODR: + + # Bad Data for 'x' + + def test_bad_data(self): + assert_raises(ValueError, Data, 2, 1) + assert_raises(ValueError, RealData, 2, 1) + + # Empty Data for 'x' + def empty_data_func(self, B, x): + return B[0]*x + B[1] + + def test_empty_data(self): + beta0 = [0.02, 0.0] + linear = Model(self.empty_data_func) + + empty_dat = Data([], []) + with pytest.warns(OdrWarning): + ODR(empty_dat, linear, beta0=beta0) + + empty_dat = RealData([], []) + with pytest.warns(OdrWarning): + ODR(empty_dat, linear, beta0=beta0) + + # Explicit Example + + def explicit_fcn(self, B, x): + ret = B[0] + B[1] * np.power(np.exp(B[2]*x) - 1.0, 2) + return ret + + def explicit_fjd(self, B, x): + eBx = np.exp(B[2]*x) + ret = B[1] * 2.0 * (eBx-1.0) * B[2] * eBx + return ret + + def explicit_fjb(self, B, x): + eBx = np.exp(B[2]*x) + res = np.vstack([np.ones(x.shape[-1]), + np.power(eBx-1.0, 2), + B[1]*2.0*(eBx-1.0)*eBx*x]) + return res + + def test_explicit(self): + explicit_mod = Model( + self.explicit_fcn, + fjacb=self.explicit_fjb, + fjacd=self.explicit_fjd, + meta=dict(name='Sample Explicit Model', + ref='ODRPACK UG, pg. 39'), + ) + explicit_dat = Data([0.,0.,5.,7.,7.5,10.,16.,26.,30.,34.,34.5,100.], + [1265.,1263.6,1258.,1254.,1253.,1249.8,1237.,1218.,1220.6, + 1213.8,1215.5,1212.]) + explicit_odr = ODR(explicit_dat, explicit_mod, beta0=[1500.0, -50.0, -0.1], + ifixx=[0,0,1,1,1,1,1,1,1,1,1,0]) + explicit_odr.set_job(deriv=2) + explicit_odr.set_iprint(init=0, iter=0, final=0) + + out = explicit_odr.run() + assert_array_almost_equal( + out.beta, + np.array([1.2646548050648876e+03, -5.4018409956678255e+01, + -8.7849712165253724e-02]), + ) + assert_array_almost_equal( + out.sd_beta, + np.array([1.0349270280543437, 1.583997785262061, 0.0063321988657267]), + ) + assert_array_almost_equal( + out.cov_beta, + np.array([[4.4949592379003039e-01, -3.7421976890364739e-01, + -8.0978217468468912e-04], + [-3.7421976890364739e-01, 1.0529686462751804e+00, + -1.9453521827942002e-03], + [-8.0978217468468912e-04, -1.9453521827942002e-03, + 1.6827336938454476e-05]]), + ) + + # Implicit Example + + def implicit_fcn(self, B, x): + return (B[2]*np.power(x[0]-B[0], 2) + + 2.0*B[3]*(x[0]-B[0])*(x[1]-B[1]) + + B[4]*np.power(x[1]-B[1], 2) - 1.0) + + def test_implicit(self): + implicit_mod = Model( + self.implicit_fcn, + implicit=1, + meta=dict(name='Sample Implicit Model', + ref='ODRPACK UG, pg. 49'), + ) + implicit_dat = Data([ + [0.5,1.2,1.6,1.86,2.12,2.36,2.44,2.36,2.06,1.74,1.34,0.9,-0.28, + -0.78,-1.36,-1.9,-2.5,-2.88,-3.18,-3.44], + [-0.12,-0.6,-1.,-1.4,-2.54,-3.36,-4.,-4.75,-5.25,-5.64,-5.97,-6.32, + -6.44,-6.44,-6.41,-6.25,-5.88,-5.5,-5.24,-4.86]], + 1, + ) + implicit_odr = ODR(implicit_dat, implicit_mod, + beta0=[-1.0, -3.0, 0.09, 0.02, 0.08]) + + out = implicit_odr.run() + assert_array_almost_equal( + out.beta, + np.array([-0.9993809167281279, -2.9310484652026476, 0.0875730502693354, + 0.0162299708984738, 0.0797537982976416]), + ) + assert_array_almost_equal( + out.sd_beta, + np.array([0.1113840353364371, 0.1097673310686467, 0.0041060738314314, + 0.0027500347539902, 0.0034962501532468]), + ) + assert_allclose( + out.cov_beta, + np.array([[2.1089274602333052e+00, -1.9437686411979040e+00, + 7.0263550868344446e-02, -4.7175267373474862e-02, + 5.2515575927380355e-02], + [-1.9437686411979040e+00, 2.0481509222414456e+00, + -6.1600515853057307e-02, 4.6268827806232933e-02, + -5.8822307501391467e-02], + [7.0263550868344446e-02, -6.1600515853057307e-02, + 2.8659542561579308e-03, -1.4628662260014491e-03, + 1.4528860663055824e-03], + [-4.7175267373474862e-02, 4.6268827806232933e-02, + -1.4628662260014491e-03, 1.2855592885514335e-03, + -1.2692942951415293e-03], + [5.2515575927380355e-02, -5.8822307501391467e-02, + 1.4528860663055824e-03, -1.2692942951415293e-03, + 2.0778813389755596e-03]]), + rtol=1e-6, atol=2e-6, + ) + + # Multi-variable Example + + def multi_fcn(self, B, x): + if (x < 0.0).any(): + raise OdrStop + theta = pi*B[3]/2. + ctheta = np.cos(theta) + stheta = np.sin(theta) + omega = np.power(2.*pi*x*np.exp(-B[2]), B[3]) + phi = np.arctan2((omega*stheta), (1.0 + omega*ctheta)) + r = (B[0] - B[1]) * np.power(np.sqrt(np.power(1.0 + omega*ctheta, 2) + + np.power(omega*stheta, 2)), -B[4]) + ret = np.vstack([B[1] + r*np.cos(B[4]*phi), + r*np.sin(B[4]*phi)]) + return ret + + def test_multi(self): + multi_mod = Model( + self.multi_fcn, + meta=dict(name='Sample Multi-Response Model', + ref='ODRPACK UG, pg. 56'), + ) + + multi_x = np.array([30.0, 50.0, 70.0, 100.0, 150.0, 200.0, 300.0, 500.0, + 700.0, 1000.0, 1500.0, 2000.0, 3000.0, 5000.0, 7000.0, 10000.0, + 15000.0, 20000.0, 30000.0, 50000.0, 70000.0, 100000.0, 150000.0]) + multi_y = np.array([ + [4.22, 4.167, 4.132, 4.038, 4.019, 3.956, 3.884, 3.784, 3.713, + 3.633, 3.54, 3.433, 3.358, 3.258, 3.193, 3.128, 3.059, 2.984, + 2.934, 2.876, 2.838, 2.798, 2.759], + [0.136, 0.167, 0.188, 0.212, 0.236, 0.257, 0.276, 0.297, 0.309, + 0.311, 0.314, 0.311, 0.305, 0.289, 0.277, 0.255, 0.24, 0.218, + 0.202, 0.182, 0.168, 0.153, 0.139], + ]) + n = len(multi_x) + multi_we = np.zeros((2, 2, n), dtype=float) + multi_ifixx = np.ones(n, dtype=int) + multi_delta = np.zeros(n, dtype=float) + + multi_we[0,0,:] = 559.6 + multi_we[1,0,:] = multi_we[0,1,:] = -1634.0 + multi_we[1,1,:] = 8397.0 + + for i in range(n): + if multi_x[i] < 100.0: + multi_ifixx[i] = 0 + elif multi_x[i] <= 150.0: + pass # defaults are fine + elif multi_x[i] <= 1000.0: + multi_delta[i] = 25.0 + elif multi_x[i] <= 10000.0: + multi_delta[i] = 560.0 + elif multi_x[i] <= 100000.0: + multi_delta[i] = 9500.0 + else: + multi_delta[i] = 144000.0 + if multi_x[i] == 100.0 or multi_x[i] == 150.0: + multi_we[:,:,i] = 0.0 + + multi_dat = Data(multi_x, multi_y, wd=1e-4/np.power(multi_x, 2), + we=multi_we) + multi_odr = ODR(multi_dat, multi_mod, beta0=[4.,2.,7.,.4,.5], + delta0=multi_delta, ifixx=multi_ifixx) + multi_odr.set_job(deriv=1, del_init=1) + + out = multi_odr.run() + assert_array_almost_equal( + out.beta, + np.array([4.3799880305938963, 2.4333057577497703, 8.0028845899503978, + 0.5101147161764654, 0.5173902330489161]), + ) + assert_array_almost_equal( + out.sd_beta, + np.array([0.0130625231081944, 0.0130499785273277, 0.1167085962217757, + 0.0132642749596149, 0.0288529201353984]), + ) + assert_array_almost_equal( + out.cov_beta, + np.array([[0.0064918418231375, 0.0036159705923791, 0.0438637051470406, + -0.0058700836512467, 0.011281212888768], + [0.0036159705923791, 0.0064793789429006, 0.0517610978353126, + -0.0051181304940204, 0.0130726943624117], + [0.0438637051470406, 0.0517610978353126, 0.5182263323095322, + -0.0563083340093696, 0.1269490939468611], + [-0.0058700836512467, -0.0051181304940204, -0.0563083340093696, + 0.0066939246261263, -0.0140184391377962], + [0.011281212888768, 0.0130726943624117, 0.1269490939468611, + -0.0140184391377962, 0.0316733013820852]]), + ) + + # Pearson's Data + # K. Pearson, Philosophical Magazine, 2, 559 (1901) + + def pearson_fcn(self, B, x): + return B[0] + B[1]*x + + def test_pearson(self): + p_x = np.array([0.,.9,1.8,2.6,3.3,4.4,5.2,6.1,6.5,7.4]) + p_y = np.array([5.9,5.4,4.4,4.6,3.5,3.7,2.8,2.8,2.4,1.5]) + p_sx = np.array([.03,.03,.04,.035,.07,.11,.13,.22,.74,1.]) + p_sy = np.array([1.,.74,.5,.35,.22,.22,.12,.12,.1,.04]) + + p_dat = RealData(p_x, p_y, sx=p_sx, sy=p_sy) + + # Reverse the data to test invariance of results + pr_dat = RealData(p_y, p_x, sx=p_sy, sy=p_sx) + + p_mod = Model(self.pearson_fcn, meta=dict(name='Uni-linear Fit')) + + p_odr = ODR(p_dat, p_mod, beta0=[1.,1.]) + pr_odr = ODR(pr_dat, p_mod, beta0=[1.,1.]) + + out = p_odr.run() + assert_array_almost_equal( + out.beta, + np.array([5.4767400299231674, -0.4796082367610305]), + ) + assert_array_almost_equal( + out.sd_beta, + np.array([0.3590121690702467, 0.0706291186037444]), + ) + assert_array_almost_equal( + out.cov_beta, + np.array([[0.0854275622946333, -0.0161807025443155], + [-0.0161807025443155, 0.003306337993922]]), + ) + + rout = pr_odr.run() + assert_array_almost_equal( + rout.beta, + np.array([11.4192022410781231, -2.0850374506165474]), + ) + assert_array_almost_equal( + rout.sd_beta, + np.array([0.9820231665657161, 0.3070515616198911]), + ) + assert_array_almost_equal( + rout.cov_beta, + np.array([[0.6391799462548782, -0.1955657291119177], + [-0.1955657291119177, 0.0624888159223392]]), + ) + + # Lorentz Peak + # The data is taken from one of the undergraduate physics labs I performed. + + def lorentz(self, beta, x): + return (beta[0]*beta[1]*beta[2] / np.sqrt(np.power(x*x - + beta[2]*beta[2], 2.0) + np.power(beta[1]*x, 2.0))) + + def test_lorentz(self): + l_sy = np.array([.29]*18) + l_sx = np.array([.000972971,.000948268,.000707632,.000706679, + .000706074, .000703918,.000698955,.000456856, + .000455207,.000662717,.000654619,.000652694, + .000000859202,.00106589,.00106378,.00125483, .00140818,.00241839]) + + l_dat = RealData( + [3.9094, 3.85945, 3.84976, 3.84716, 3.84551, 3.83964, 3.82608, + 3.78847, 3.78163, 3.72558, 3.70274, 3.6973, 3.67373, 3.65982, + 3.6562, 3.62498, 3.55525, 3.41886], + [652, 910.5, 984, 1000, 1007.5, 1053, 1160.5, 1409.5, 1430, 1122, + 957.5, 920, 777.5, 709.5, 698, 578.5, 418.5, 275.5], + sx=l_sx, + sy=l_sy, + ) + l_mod = Model(self.lorentz, meta=dict(name='Lorentz Peak')) + l_odr = ODR(l_dat, l_mod, beta0=(1000., .1, 3.8)) + + out = l_odr.run() + assert_array_almost_equal( + out.beta, + np.array([1.4306780846149925e+03, 1.3390509034538309e-01, + 3.7798193600109009e+00]), + ) + assert_array_almost_equal( + out.sd_beta, + np.array([7.3621186811330963e-01, 3.5068899941471650e-04, + 2.4451209281408992e-04]), + ) + assert_array_almost_equal( + out.cov_beta, + np.array([[2.4714409064597873e-01, -6.9067261911110836e-05, + -3.1236953270424990e-05], + [-6.9067261911110836e-05, 5.6077531517333009e-08, + 3.6133261832722601e-08], + [-3.1236953270424990e-05, 3.6133261832722601e-08, + 2.7261220025171730e-08]]), + ) + + def test_ticket_1253(self): + def linear(c, x): + return c[0]*x+c[1] + + c = [2.0, 3.0] + x = np.linspace(0, 10) + y = linear(c, x) + + model = Model(linear) + data = Data(x, y, wd=1.0, we=1.0) + job = ODR(data, model, beta0=[1.0, 1.0]) + result = job.run() + assert_equal(result.info, 2) + + # Verify fix for gh-9140 + + def test_ifixx(self): + x1 = [-2.01, -0.99, -0.001, 1.02, 1.98] + x2 = [3.98, 1.01, 0.001, 0.998, 4.01] + fix = np.vstack((np.zeros_like(x1, dtype=int), np.ones_like(x2, dtype=int))) + data = Data(np.vstack((x1, x2)), y=1, fix=fix) + model = Model(lambda beta, x: x[1, :] - beta[0] * x[0, :]**2., implicit=True) + + odr1 = ODR(data, model, beta0=np.array([1.])) + sol1 = odr1.run() + odr2 = ODR(data, model, beta0=np.array([1.]), ifixx=fix) + sol2 = odr2.run() + assert_equal(sol1.beta, sol2.beta) + + # verify bugfix for #11800 in #11802 + def test_ticket_11800(self): + # parameters + beta_true = np.array([1.0, 2.3, 1.1, -1.0, 1.3, 0.5]) + nr_measurements = 10 + + std_dev_x = 0.01 + x_error = np.array([[0.00063445, 0.00515731, 0.00162719, 0.01022866, + -0.01624845, 0.00482652, 0.00275988, -0.00714734, -0.00929201, -0.00687301], + [-0.00831623, -0.00821211, -0.00203459, 0.00938266, -0.00701829, + 0.0032169, 0.00259194, -0.00581017, -0.0030283, 0.01014164]]) + + std_dev_y = 0.05 + y_error = np.array([[0.05275304, 0.04519563, -0.07524086, 0.03575642, + 0.04745194, 0.03806645, 0.07061601, -0.00753604, -0.02592543, -0.02394929], + [0.03632366, 0.06642266, 0.08373122, 0.03988822, -0.0092536, + -0.03750469, -0.03198903, 0.01642066, 0.01293648, -0.05627085]]) + + beta_solution = np.array([ + 2.62920235756665876536e+00, -1.26608484996299608838e+02, + 1.29703572775403074502e+02, -1.88560985401185465804e+00, + 7.83834160771274923718e+01, -7.64124076838087091801e+01]) + + # model's function and Jacobians + def func(beta, x): + y0 = beta[0] + beta[1] * x[0, :] + beta[2] * x[1, :] + y1 = beta[3] + beta[4] * x[0, :] + beta[5] * x[1, :] + + return np.vstack((y0, y1)) + + def df_dbeta_odr(beta, x): + nr_meas = np.shape(x)[1] + zeros = np.zeros(nr_meas) + ones = np.ones(nr_meas) + + dy0 = np.array([ones, x[0, :], x[1, :], zeros, zeros, zeros]) + dy1 = np.array([zeros, zeros, zeros, ones, x[0, :], x[1, :]]) + + return np.stack((dy0, dy1)) + + def df_dx_odr(beta, x): + nr_meas = np.shape(x)[1] + ones = np.ones(nr_meas) + + dy0 = np.array([beta[1] * ones, beta[2] * ones]) + dy1 = np.array([beta[4] * ones, beta[5] * ones]) + return np.stack((dy0, dy1)) + + # do measurements with errors in independent and dependent variables + x0_true = np.linspace(1, 10, nr_measurements) + x1_true = np.linspace(1, 10, nr_measurements) + x_true = np.array([x0_true, x1_true]) + + y_true = func(beta_true, x_true) + + x_meas = x_true + x_error + y_meas = y_true + y_error + + # estimate model's parameters + model_f = Model(func, fjacb=df_dbeta_odr, fjacd=df_dx_odr) + + data = RealData(x_meas, y_meas, sx=std_dev_x, sy=std_dev_y) + + odr_obj = ODR(data, model_f, beta0=0.9 * beta_true, maxit=100) + #odr_obj.set_iprint(init=2, iter=0, iter_step=1, final=1) + odr_obj.set_job(deriv=3) + + odr_out = odr_obj.run() + + # check results + assert_equal(odr_out.info, 1) + assert_array_almost_equal(odr_out.beta, beta_solution) + + def test_multilinear_model(self): + x = np.linspace(0.0, 5.0) + y = 10.0 + 5.0 * x + data = Data(x, y) + odr_obj = ODR(data, multilinear) + output = odr_obj.run() + assert_array_almost_equal(output.beta, [10.0, 5.0]) + + def test_exponential_model(self): + x = np.linspace(0.0, 5.0) + y = -10.0 + np.exp(0.5*x) + data = Data(x, y) + odr_obj = ODR(data, exponential) + output = odr_obj.run() + assert_array_almost_equal(output.beta, [-10.0, 0.5]) + + def test_polynomial_model(self): + x = np.linspace(0.0, 5.0) + y = 1.0 + 2.0 * x + 3.0 * x ** 2 + 4.0 * x ** 3 + poly_model = polynomial(3) + data = Data(x, y) + odr_obj = ODR(data, poly_model) + output = odr_obj.run() + assert_array_almost_equal(output.beta, [1.0, 2.0, 3.0, 4.0]) + + def test_unilinear_model(self): + x = np.linspace(0.0, 5.0) + y = 1.0 * x + 2.0 + data = Data(x, y) + odr_obj = ODR(data, unilinear) + output = odr_obj.run() + assert_array_almost_equal(output.beta, [1.0, 2.0]) + + def test_quadratic_model(self): + x = np.linspace(0.0, 5.0) + y = 1.0 * x ** 2 + 2.0 * x + 3.0 + data = Data(x, y) + odr_obj = ODR(data, quadratic) + output = odr_obj.run() + assert_array_almost_equal(output.beta, [1.0, 2.0, 3.0]) + + def test_work_ind(self): + + def func(par, x): + b0, b1 = par + return b0 + b1 * x + + # generate some data + n_data = 4 + x = np.arange(n_data) + y = np.where(x % 2, x + 0.1, x - 0.1) + x_err = np.full(n_data, 0.1) + y_err = np.full(n_data, 0.1) + + # do the fitting + linear_model = Model(func) + real_data = RealData(x, y, sx=x_err, sy=y_err) + odr_obj = ODR(real_data, linear_model, beta0=[0.4, 0.4]) + odr_obj.set_job(fit_type=0) + out = odr_obj.run() + + sd_ind = out.work_ind['sd'] + assert_array_almost_equal(out.sd_beta, + out.work[sd_ind:sd_ind + len(out.sd_beta)]) + + @pytest.mark.skipif(True, reason="Fortran I/O prone to crashing so better " + "not to run this test, see gh-13127") + def test_output_file_overwrite(self): + """ + Verify fix for gh-1892 + """ + def func(b, x): + return b[0] + b[1] * x + + p = Model(func) + data = Data(np.arange(10), 12 * np.arange(10)) + tmp_dir = tempfile.mkdtemp() + error_file_path = os.path.join(tmp_dir, "error.dat") + report_file_path = os.path.join(tmp_dir, "report.dat") + try: + ODR(data, p, beta0=[0.1, 13], errfile=error_file_path, + rptfile=report_file_path).run() + ODR(data, p, beta0=[0.1, 13], errfile=error_file_path, + rptfile=report_file_path, overwrite=True).run() + finally: + # remove output files for clean up + shutil.rmtree(tmp_dir) + + def test_odr_model_default_meta(self): + def func(b, x): + return b[0] + b[1] * x + + p = Model(func) + p.set_meta(name='Sample Model Meta', ref='ODRPACK') + assert_equal(p.meta, {'name': 'Sample Model Meta', 'ref': 'ODRPACK'}) + + def test_work_array_del_init(self): + """ + Verify fix for gh-18739 where del_init=1 fails. + """ + def func(b, x): + return b[0] + b[1] * x + + # generate some data + n_data = 4 + x = np.arange(n_data) + y = np.where(x % 2, x + 0.1, x - 0.1) + x_err = np.full(n_data, 0.1) + y_err = np.full(n_data, 0.1) + + linear_model = Model(func) + # Try various shapes of the `we` array from various `sy` and `covy` + rd0 = RealData(x, y, sx=x_err, sy=y_err) + rd1 = RealData(x, y, sx=x_err, sy=0.1) + rd2 = RealData(x, y, sx=x_err, sy=[0.1]) + rd3 = RealData(x, y, sx=x_err, sy=np.full((1, n_data), 0.1)) + rd4 = RealData(x, y, sx=x_err, covy=[[0.01]]) + rd5 = RealData(x, y, sx=x_err, covy=np.full((1, 1, n_data), 0.01)) + for rd in [rd0, rd1, rd2, rd3, rd4, rd5]: + odr_obj = ODR(rd, linear_model, beta0=[0.4, 0.4], + delta0=np.full(n_data, -0.1)) + odr_obj.set_job(fit_type=0, del_init=1) + # Just make sure that it runs without raising an exception. + odr_obj.run() + + def test_pickling_data(self): + x = np.linspace(0.0, 5.0) + y = 1.0 * x + 2.0 + data = Data(x, y) + + obj_pickle = pickle.dumps(data) + del data + pickle.loads(obj_pickle) + + def test_pickling_real_data(self): + x = np.linspace(0.0, 5.0) + y = 1.0 * x + 2.0 + data = RealData(x, y) + + obj_pickle = pickle.dumps(data) + del data + pickle.loads(obj_pickle) + + def test_pickling_model(self): + obj_pickle = pickle.dumps(unilinear) + pickle.loads(obj_pickle) + + def test_pickling_odr(self): + x = np.linspace(0.0, 5.0) + y = 1.0 * x + 2.0 + odr_obj = ODR(Data(x, y), unilinear) + + obj_pickle = pickle.dumps(odr_obj) + del odr_obj + pickle.loads(obj_pickle) + + def test_pickling_output(self): + x = np.linspace(0.0, 5.0) + y = 1.0 * x + 2.0 + output = ODR(Data(x, y), unilinear).run + + obj_pickle = pickle.dumps(output) + del output + pickle.loads(obj_pickle) + + def test_explicit_model_with_implicit_job(self): + """ + Verify fix for gh-23763 that ODR doesn't segfault + """ + x = np.linspace(0, 10, 10) + y = 2.0 + 3.0 * x + + data = Data(x, y) + model = unilinear # this is an explicit model + + # job=1 is implicit, should raise on explicit model + with assert_raises(OdrError): + odr = ODR(data, model, job=1) + odr.run() diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..19452d51641c66c6d0e54df97a9131fa3f2df1ae Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/__pycache__/_itertools.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/__pycache__/_itertools.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8fd1c4ebed62cc9829a1405f7c633ca19ecdfd86 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/__pycache__/_itertools.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/__pycache__/_scripts.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/__pycache__/_scripts.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d630d4ec03fb6d7e909dd17beff77a6badd2a0b2 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/__pycache__/_scripts.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/__pycache__/_shutil.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/__pycache__/_shutil.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..003b93db43b589ef50feab84e05af9a0e6180490 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/__pycache__/_shutil.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/__pycache__/installer.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/__pycache__/installer.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..854d7e08fa42236f4f5f4aa37e9adfa2bfe1f5e6 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/__pycache__/installer.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/__pycache__/monkey.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/__pycache__/monkey.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..800228cf41a0237cfcf272e68d38f1d4b7517321 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/__pycache__/monkey.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/__pycache__/version.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/__pycache__/version.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c56bc3f86884fe4e76d0515dc6212b1f123a83b7 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/__pycache__/version.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__init__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e374d5c5604d0eeed555e68b7523bfac72fd9101 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__init__.py @@ -0,0 +1,14 @@ +import importlib +import sys + +__version__, _, _ = sys.version.partition(' ') + + +try: + # Allow Debian and pkgsrc (only) to customize system + # behavior. Ref pypa/distutils#2 and pypa/distutils#16. + # This hook is deprecated and no other environments + # should use it. + importlib.import_module('_distutils_system_mod') +except ImportError: + pass diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cac12f9323c1524508e88bcdcd078e2a76e65255 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/_log.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/_log.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a50f04d94c8491948eb7c13a1162120dda363014 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/_log.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/_macos_compat.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/_macos_compat.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c68bd4636fd0a5bf79d25aafb1c8972e278f75d8 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/_macos_compat.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/_modified.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/_modified.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..83178640b49a4e3356aee467463025846aa1d4e0 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/_modified.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/_msvccompiler.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/_msvccompiler.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..741f654ae05182230bcd9c4fe8a81bca90927dcd Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/_msvccompiler.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/archive_util.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/archive_util.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..04016116fac3da0a5699025de15366617758871a Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/archive_util.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/ccompiler.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/ccompiler.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..26a321762509fbc35f9751697a3139e1e683d7d3 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/ccompiler.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/cmd.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/cmd.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8dfd7b02c3018f0af7bee467c27c485ed20d8b24 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/cmd.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/core.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/core.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..25d51e58e62058cdd72672452cb50906609afbbe Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/core.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/cygwinccompiler.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/cygwinccompiler.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ffa11aa893accb46a19419851c483886e20b0abf Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/cygwinccompiler.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/debug.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/debug.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3d769c7d634075555a70469c702ec2d1705b6650 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/debug.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/dep_util.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/dep_util.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6f6a2867e0d77db823b08d5bf3ccb7f967be1c6a Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/dep_util.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/dir_util.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/dir_util.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..95986e06c870514e74be04017150b3074515ecc8 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/dir_util.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/dist.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/dist.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..93096b28ab35496da531ad180e16cf50824e1650 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/dist.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/errors.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/errors.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6fc1c770f52be0976223bf89f4a7726c504f220f Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/errors.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/extension.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/extension.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..079bbb52034d0aea79f26a9c03405459d72c3bec Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/extension.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/fancy_getopt.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/fancy_getopt.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..409817debe394041d6da52fea0450f4edd23aea5 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/fancy_getopt.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/file_util.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/file_util.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1bec6cab182b3252fc83a8b7ec5e0e82bbd58f93 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/file_util.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/filelist.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/filelist.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5e588efdc5556c2662b4ca5d0ac9a024843eabba Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/filelist.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/log.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/log.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..53bfff5358286c17c635c57a6ece49ec7dd703a8 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/log.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/spawn.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/spawn.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..16c5f5d2374eec00c6434869bcef035ebf65811e Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/spawn.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/sysconfig.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/sysconfig.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..81ec536f55c3681d925da37cdc19d640a05cbdb1 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/sysconfig.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/text_file.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/text_file.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4658578223e796feb28c25dd39e66b1cc13e1680 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/text_file.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/unixccompiler.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/unixccompiler.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3f33ab930ab55db1c9260e89b826962854fdc418 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/unixccompiler.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/util.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/util.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2fe95faee8cad3c2c3b83f4665fdfc91770ba636 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/util.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/version.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/version.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..706f0ebee244d64dbc0ab51b72c3feac6857d569 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/version.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/versionpredicate.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/versionpredicate.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..40daa350f1ce7fd952cbee950de526c331551147 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/versionpredicate.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/zosccompiler.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/zosccompiler.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..96a8febc5e781f5c7665baba78f881a5d1a8865f Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/zosccompiler.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/_log.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/_log.py new file mode 100644 index 0000000000000000000000000000000000000000..0148f157ff3bf8bd728c82f49cd3d1cd9cb5a43e --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/_log.py @@ -0,0 +1,3 @@ +import logging + +log = logging.getLogger() diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/_macos_compat.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/_macos_compat.py new file mode 100644 index 0000000000000000000000000000000000000000..76ecb96abe478313ce7d09342b2643bf4a765331 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/_macos_compat.py @@ -0,0 +1,12 @@ +import importlib +import sys + + +def bypass_compiler_fixup(cmd, args): + return cmd + + +if sys.platform == 'darwin': + compiler_fixup = importlib.import_module('_osx_support').compiler_fixup +else: + compiler_fixup = bypass_compiler_fixup diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/_modified.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/_modified.py new file mode 100644 index 0000000000000000000000000000000000000000..f64cab7d61ae20dd0c425b8843b068f39faa6961 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/_modified.py @@ -0,0 +1,95 @@ +"""Timestamp comparison of files and groups of files.""" + +from __future__ import annotations + +import functools +import os.path +from collections.abc import Callable, Iterable +from typing import Literal, TypeVar + +from jaraco.functools import splat + +from .compat.py39 import zip_strict +from .errors import DistutilsFileError + +_SourcesT = TypeVar( + "_SourcesT", bound="str | bytes | os.PathLike[str] | os.PathLike[bytes]" +) +_TargetsT = TypeVar( + "_TargetsT", bound="str | bytes | os.PathLike[str] | os.PathLike[bytes]" +) + + +def _newer(source, target): + return not os.path.exists(target) or ( + os.path.getmtime(source) > os.path.getmtime(target) + ) + + +def newer( + source: str | bytes | os.PathLike[str] | os.PathLike[bytes], + target: str | bytes | os.PathLike[str] | os.PathLike[bytes], +) -> bool: + """ + Is source modified more recently than target. + + Returns True if 'source' is modified more recently than + 'target' or if 'target' does not exist. + + Raises DistutilsFileError if 'source' does not exist. + """ + if not os.path.exists(source): + raise DistutilsFileError(f"file {os.path.abspath(source)!r} does not exist") + + return _newer(source, target) + + +def newer_pairwise( + sources: Iterable[_SourcesT], + targets: Iterable[_TargetsT], + newer: Callable[[_SourcesT, _TargetsT], bool] = newer, +) -> tuple[list[_SourcesT], list[_TargetsT]]: + """ + Filter filenames where sources are newer than targets. + + Walk two filename iterables in parallel, testing if each source is newer + than its corresponding target. Returns a pair of lists (sources, + targets) where source is newer than target, according to the semantics + of 'newer()'. + """ + newer_pairs = filter(splat(newer), zip_strict(sources, targets)) + return tuple(map(list, zip(*newer_pairs))) or ([], []) + + +def newer_group( + sources: Iterable[str | bytes | os.PathLike[str] | os.PathLike[bytes]], + target: str | bytes | os.PathLike[str] | os.PathLike[bytes], + missing: Literal["error", "ignore", "newer"] = "error", +) -> bool: + """ + Is target out-of-date with respect to any file in sources. + + Return True if 'target' is out-of-date with respect to any file + listed in 'sources'. In other words, if 'target' exists and is newer + than every file in 'sources', return False; otherwise return True. + ``missing`` controls how to handle a missing source file: + + - error (default): allow the ``stat()`` call to fail. + - ignore: silently disregard any missing source files. + - newer: treat missing source files as "target out of date". This + mode is handy in "dry-run" mode: it will pretend to carry out + commands that wouldn't work because inputs are missing, but + that doesn't matter because dry-run won't run the commands. + """ + + def missing_as_newer(source): + return missing == 'newer' and not os.path.exists(source) + + ignored = os.path.exists if missing == 'ignore' else None + return not os.path.exists(target) or any( + missing_as_newer(source) or _newer(source, target) + for source in filter(ignored, sources) + ) + + +newer_pairwise_group = functools.partial(newer_pairwise, newer=newer_group) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/_msvccompiler.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/_msvccompiler.py new file mode 100644 index 0000000000000000000000000000000000000000..d07c86ef8e41fc31357c989133d51e9618c3e43d --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/_msvccompiler.py @@ -0,0 +1,16 @@ +import warnings + +from .compilers.C import msvc + +__all__ = ["MSVCCompiler"] + +MSVCCompiler = msvc.Compiler + + +def __getattr__(name): + if name == '_get_vc_env': + warnings.warn( + "_get_vc_env is private; find an alternative (pypa/distutils#340)" + ) + return msvc._get_vc_env + raise AttributeError(name) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/archive_util.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/archive_util.py new file mode 100644 index 0000000000000000000000000000000000000000..4a7fb9c9e7a0c4a0ca2a3ab608ffab6acf10bb3e --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/archive_util.py @@ -0,0 +1,284 @@ +"""distutils.archive_util + +Utility functions for creating archive files (tarballs, zip files, +that sort of thing).""" + +from __future__ import annotations + +import os +from typing import Literal, overload + +try: + import zipfile +except ImportError: + zipfile = None + + +from ._log import log +from .dir_util import mkpath +from .errors import DistutilsExecError +from .spawn import spawn + +try: + from pwd import getpwnam +except ImportError: + getpwnam = None + +try: + from grp import getgrnam +except ImportError: + getgrnam = None + + +def _get_gid(name): + """Returns a gid, given a group name.""" + if getgrnam is None or name is None: + return None + try: + result = getgrnam(name) + except KeyError: + result = None + if result is not None: + return result[2] + return None + + +def _get_uid(name): + """Returns an uid, given a user name.""" + if getpwnam is None or name is None: + return None + try: + result = getpwnam(name) + except KeyError: + result = None + if result is not None: + return result[2] + return None + + +def make_tarball( + base_name: str, + base_dir: str | os.PathLike[str], + compress: Literal["gzip", "bzip2", "xz"] | None = "gzip", + verbose: bool = False, + owner: str | None = None, + group: str | None = None, +) -> str: + """Create a (possibly compressed) tar file from all the files under + 'base_dir'. + + 'compress' must be "gzip" (the default), "bzip2", "xz", or None. + + 'owner' and 'group' can be used to define an owner and a group for the + archive that is being built. If not provided, the current owner and group + will be used. + + The output tar file will be named 'base_dir' + ".tar", possibly plus + the appropriate compression extension (".gz", ".bz2", ".xz" or ".Z"). + + Returns the output filename. + """ + tar_compression = { + 'gzip': 'gz', + 'bzip2': 'bz2', + 'xz': 'xz', + None: '', + } + compress_ext = {'gzip': '.gz', 'bzip2': '.bz2', 'xz': '.xz'} + + # flags for compression program, each element of list will be an argument + if compress is not None and compress not in compress_ext.keys(): + raise ValueError( + "bad value for 'compress': must be None, 'gzip', 'bzip2', 'xz'" + ) + + archive_name = base_name + '.tar' + archive_name += compress_ext.get(compress, '') + + mkpath(os.path.dirname(archive_name)) + + # creating the tarball + import tarfile # late import so Python build itself doesn't break + + log.info('Creating tar archive') + + uid = _get_uid(owner) + gid = _get_gid(group) + + def _set_uid_gid(tarinfo): + if gid is not None: + tarinfo.gid = gid + tarinfo.gname = group + if uid is not None: + tarinfo.uid = uid + tarinfo.uname = owner + return tarinfo + + tar = tarfile.open(archive_name, f'w|{tar_compression[compress]}') + try: + tar.add(base_dir, filter=_set_uid_gid) + finally: + tar.close() + + return archive_name + + +def make_zipfile( + base_name: str, + base_dir: str | os.PathLike[str], + verbose: bool = False, +) -> str: + """Create a zip file from all the files under 'base_dir'. + + The output zip file will be named 'base_name' + ".zip". Uses either the + "zipfile" Python module (if available) or the InfoZIP "zip" utility + (if installed and found on the default search path). If neither tool is + available, raises DistutilsExecError. Returns the name of the output zip + file. + """ + zip_filename = base_name + ".zip" + mkpath(os.path.dirname(zip_filename)) + + # If zipfile module is not available, try spawning an external + # 'zip' command. + if zipfile is None: + if verbose: + zipoptions = "-r" + else: + zipoptions = "-rq" + + try: + spawn(["zip", zipoptions, zip_filename, base_dir]) + except DistutilsExecError: + # XXX really should distinguish between "couldn't find + # external 'zip' command" and "zip failed". + raise DistutilsExecError( + f"unable to create zip file '{zip_filename}': " + "could neither import the 'zipfile' module nor " + "find a standalone zip utility" + ) + + else: + log.info("creating '%s' and adding '%s' to it", zip_filename, base_dir) + + try: + zip = zipfile.ZipFile(zip_filename, "w", compression=zipfile.ZIP_DEFLATED) + except RuntimeError: + zip = zipfile.ZipFile(zip_filename, "w", compression=zipfile.ZIP_STORED) + + with zip: + if base_dir != os.curdir: + path = os.path.normpath(os.path.join(base_dir, '')) + zip.write(path, path) + log.info("adding '%s'", path) + for dirpath, dirnames, filenames in os.walk(base_dir): + for name in dirnames: + path = os.path.normpath(os.path.join(dirpath, name, '')) + zip.write(path, path) + log.info("adding '%s'", path) + for name in filenames: + path = os.path.normpath(os.path.join(dirpath, name)) + if os.path.isfile(path): + zip.write(path, path) + log.info("adding '%s'", path) + + return zip_filename + + +ARCHIVE_FORMATS = { + 'gztar': (make_tarball, [('compress', 'gzip')], "gzip'ed tar-file"), + 'bztar': (make_tarball, [('compress', 'bzip2')], "bzip2'ed tar-file"), + 'xztar': (make_tarball, [('compress', 'xz')], "xz'ed tar-file"), + 'ztar': (make_tarball, [('compress', 'compress')], "compressed tar file"), + 'tar': (make_tarball, [('compress', None)], "uncompressed tar file"), + 'zip': (make_zipfile, [], "ZIP file"), +} + + +def check_archive_formats(formats): + """Returns the first format from the 'format' list that is unknown. + + If all formats are known, returns None + """ + for format in formats: + if format not in ARCHIVE_FORMATS: + return format + return None + + +@overload +def make_archive( + base_name: str, + format: str, + root_dir: str | os.PathLike[str] | bytes | os.PathLike[bytes] | None = None, + base_dir: str | None = None, + verbose: bool = False, + owner: str | None = None, + group: str | None = None, +) -> str: ... +@overload +def make_archive( + base_name: str | os.PathLike[str], + format: str, + root_dir: str | os.PathLike[str] | bytes | os.PathLike[bytes], + base_dir: str | None = None, + verbose: bool = False, + owner: str | None = None, + group: str | None = None, +) -> str: ... +def make_archive( + base_name: str | os.PathLike[str], + format: str, + root_dir: str | os.PathLike[str] | bytes | os.PathLike[bytes] | None = None, + base_dir: str | None = None, + verbose: bool = False, + owner: str | None = None, + group: str | None = None, +) -> str: + """Create an archive file (eg. zip or tar). + + 'base_name' is the name of the file to create, minus any format-specific + extension; 'format' is the archive format: one of "zip", "tar", "gztar", + "bztar", "xztar", or "ztar". + + 'root_dir' is a directory that will be the root directory of the + archive; ie. we typically chdir into 'root_dir' before creating the + archive. 'base_dir' is the directory where we start archiving from; + ie. 'base_dir' will be the common prefix of all files and + directories in the archive. 'root_dir' and 'base_dir' both default + to the current directory. Returns the name of the archive file. + + 'owner' and 'group' are used when creating a tar archive. By default, + uses the current owner and group. + """ + save_cwd = os.getcwd() + if root_dir is not None: + log.debug("changing into '%s'", root_dir) + base_name = os.path.abspath(base_name) + os.chdir(root_dir) + + if base_dir is None: + base_dir = os.curdir + + kwargs: dict[str, bool | None] = {} + + try: + format_info = ARCHIVE_FORMATS[format] + except KeyError: + raise ValueError(f"unknown archive format '{format}'") + + func = format_info[0] + kwargs.update(format_info[1]) + + if format != 'zip': + kwargs['owner'] = owner + kwargs['group'] = group + + try: + filename = func(base_name, base_dir, **kwargs) + finally: + if root_dir is not None: + log.debug("changing back to '%s'", save_cwd) + os.chdir(save_cwd) + + return filename diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/ccompiler.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/ccompiler.py new file mode 100644 index 0000000000000000000000000000000000000000..58bc6a55e24fd2b0b170e4499c6095e934313827 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/ccompiler.py @@ -0,0 +1,26 @@ +from .compat.numpy import ( # noqa: F401 + _default_compilers, + compiler_class, +) +from .compilers.C import base +from .compilers.C.base import ( + gen_lib_options, + gen_preprocess_options, + get_default_compiler, + new_compiler, + show_compilers, +) +from .compilers.C.errors import CompileError, LinkError + +__all__ = [ + 'CompileError', + 'LinkError', + 'gen_lib_options', + 'gen_preprocess_options', + 'get_default_compiler', + 'new_compiler', + 'show_compilers', +] + + +CCompiler = base.Compiler diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/cmd.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/cmd.py new file mode 100644 index 0000000000000000000000000000000000000000..530cc108d4743ed26fdf0dd7a8eef204d309b5de --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/cmd.py @@ -0,0 +1,535 @@ +"""distutils.cmd + +Provides the Command class, the base class for the command classes +in the distutils.command package. +""" + +from __future__ import annotations + +import logging +import os +import re +import sys +from abc import abstractmethod +from collections.abc import Callable, MutableSequence +from typing import TYPE_CHECKING, Any, ClassVar, TypeVar, overload + +from . import _modified, archive_util, dir_util, file_util, util +from ._log import log +from .errors import DistutilsOptionError + +if TYPE_CHECKING: + # type-only import because of mutual dependence between these classes + from distutils.dist import Distribution + + from typing_extensions import TypeVarTuple, Unpack + + _Ts = TypeVarTuple("_Ts") + +_StrPathT = TypeVar("_StrPathT", bound="str | os.PathLike[str]") +_BytesPathT = TypeVar("_BytesPathT", bound="bytes | os.PathLike[bytes]") +_CommandT = TypeVar("_CommandT", bound="Command") + + +class Command: + """Abstract base class for defining command classes, the "worker bees" + of the Distutils. A useful analogy for command classes is to think of + them as subroutines with local variables called "options". The options + are "declared" in 'initialize_options()' and "defined" (given their + final values, aka "finalized") in 'finalize_options()', both of which + must be defined by every command class. The distinction between the + two is necessary because option values might come from the outside + world (command line, config file, ...), and any options dependent on + other options must be computed *after* these outside influences have + been processed -- hence 'finalize_options()'. The "body" of the + subroutine, where it does all its work based on the values of its + options, is the 'run()' method, which must also be implemented by every + command class. + """ + + # 'sub_commands' formalizes the notion of a "family" of commands, + # eg. "install" as the parent with sub-commands "install_lib", + # "install_headers", etc. The parent of a family of commands + # defines 'sub_commands' as a class attribute; it's a list of + # (command_name : string, predicate : unbound_method | string | None) + # tuples, where 'predicate' is a method of the parent command that + # determines whether the corresponding command is applicable in the + # current situation. (Eg. we "install_headers" is only applicable if + # we have any C header files to install.) If 'predicate' is None, + # that command is always applicable. + # + # 'sub_commands' is usually defined at the *end* of a class, because + # predicates can be unbound methods, so they must already have been + # defined. The canonical example is the "install" command. + sub_commands: ClassVar[ # Any to work around variance issues + list[tuple[str, Callable[[Any], bool] | None]] + ] = [] + + user_options: ClassVar[ + # Specifying both because list is invariant. Avoids mypy override assignment issues + list[tuple[str, str, str]] | list[tuple[str, str | None, str]] + ] = [] + + # -- Creation/initialization methods ------------------------------- + + def __init__(self, dist: Distribution) -> None: + """Create and initialize a new Command object. Most importantly, + invokes the 'initialize_options()' method, which is the real + initializer and depends on the actual command being + instantiated. + """ + # late import because of mutual dependence between these classes + from distutils.dist import Distribution + + if not isinstance(dist, Distribution): + raise TypeError("dist must be a Distribution instance") + if self.__class__ is Command: + raise RuntimeError("Command is an abstract class") + + self.distribution = dist + self.initialize_options() + + # Per-command versions of the global flags, so that the user can + # customize Distutils' behaviour command-by-command and let some + # commands fall back on the Distribution's behaviour. None means + # "not defined, check self.distribution's copy". + + # verbose is largely ignored, but needs to be set for + # backwards compatibility (I think)? + self.verbose = dist.verbose + + # Some commands define a 'self.force' option to ignore file + # timestamps, but methods defined *here* assume that + # 'self.force' exists for all commands. So define it here + # just to be safe. + self.force = None + + # The 'help' flag is just used for command-line parsing, so + # none of that complicated bureaucracy is needed. + self.help = False + + # 'finalized' records whether or not 'finalize_options()' has been + # called. 'finalize_options()' itself should not pay attention to + # this flag: it is the business of 'ensure_finalized()', which + # always calls 'finalize_options()', to respect/update it. + self.finalized = False + + def ensure_finalized(self) -> None: + if not self.finalized: + self.finalize_options() + self.finalized = True + + # Subclasses must define: + # initialize_options() + # provide default values for all options; may be customized by + # setup script, by options from config file(s), or by command-line + # options + # finalize_options() + # decide on the final values for all options; this is called + # after all possible intervention from the outside world + # (command-line, option file, etc.) has been processed + # run() + # run the command: do whatever it is we're here to do, + # controlled by the command's various option values + + @abstractmethod + def initialize_options(self) -> None: + """Set default values for all the options that this command + supports. Note that these defaults may be overridden by other + commands, by the setup script, by config files, or by the + command-line. Thus, this is not the place to code dependencies + between options; generally, 'initialize_options()' implementations + are just a bunch of "self.foo = None" assignments. + + This method must be implemented by all command classes. + """ + raise RuntimeError( + f"abstract method -- subclass {self.__class__} must override" + ) + + @abstractmethod + def finalize_options(self) -> None: + """Set final values for all the options that this command supports. + This is always called as late as possible, ie. after any option + assignments from the command-line or from other commands have been + done. Thus, this is the place to code option dependencies: if + 'foo' depends on 'bar', then it is safe to set 'foo' from 'bar' as + long as 'foo' still has the same value it was assigned in + 'initialize_options()'. + + This method must be implemented by all command classes. + """ + raise RuntimeError( + f"abstract method -- subclass {self.__class__} must override" + ) + + def dump_options(self, header=None, indent=""): + from distutils.fancy_getopt import longopt_xlate + + if header is None: + header = f"command options for '{self.get_command_name()}':" + self.announce(indent + header, level=logging.INFO) + indent = indent + " " + for option, _, _ in self.user_options: + option = option.translate(longopt_xlate) + if option[-1] == "=": + option = option[:-1] + value = getattr(self, option) + self.announce(indent + f"{option} = {value}", level=logging.INFO) + + @abstractmethod + def run(self) -> None: + """A command's raison d'etre: carry out the action it exists to + perform, controlled by the options initialized in + 'initialize_options()', customized by other commands, the setup + script, the command-line, and config files, and finalized in + 'finalize_options()'. All terminal output and filesystem + interaction should be done by 'run()'. + + This method must be implemented by all command classes. + """ + raise RuntimeError( + f"abstract method -- subclass {self.__class__} must override" + ) + + def announce(self, msg: object, level: int = logging.DEBUG) -> None: + log.log(level, msg) + + def debug_print(self, msg: object) -> None: + """Print 'msg' to stdout if the global DEBUG (taken from the + DISTUTILS_DEBUG environment variable) flag is true. + """ + from distutils.debug import DEBUG + + if DEBUG: + print(msg) + sys.stdout.flush() + + # -- Option validation methods ------------------------------------- + # (these are very handy in writing the 'finalize_options()' method) + # + # NB. the general philosophy here is to ensure that a particular option + # value meets certain type and value constraints. If not, we try to + # force it into conformance (eg. if we expect a list but have a string, + # split the string on comma and/or whitespace). If we can't force the + # option into conformance, raise DistutilsOptionError. Thus, command + # classes need do nothing more than (eg.) + # self.ensure_string_list('foo') + # and they can be guaranteed that thereafter, self.foo will be + # a list of strings. + + def _ensure_stringlike(self, option, what, default=None): + val = getattr(self, option) + if val is None: + setattr(self, option, default) + return default + elif not isinstance(val, str): + raise DistutilsOptionError(f"'{option}' must be a {what} (got `{val}`)") + return val + + def ensure_string(self, option: str, default: str | None = None) -> None: + """Ensure that 'option' is a string; if not defined, set it to + 'default'. + """ + self._ensure_stringlike(option, "string", default) + + def ensure_string_list(self, option: str) -> None: + r"""Ensure that 'option' is a list of strings. If 'option' is + currently a string, we split it either on /,\s*/ or /\s+/, so + "foo bar baz", "foo,bar,baz", and "foo, bar baz" all become + ["foo", "bar", "baz"]. + """ + val = getattr(self, option) + if val is None: + return + elif isinstance(val, str): + setattr(self, option, re.split(r',\s*|\s+', val)) + else: + if isinstance(val, list): + ok = all(isinstance(v, str) for v in val) + else: + ok = False + if not ok: + raise DistutilsOptionError( + f"'{option}' must be a list of strings (got {val!r})" + ) + + def _ensure_tested_string(self, option, tester, what, error_fmt, default=None): + val = self._ensure_stringlike(option, what, default) + if val is not None and not tester(val): + raise DistutilsOptionError( + ("error in '%s' option: " + error_fmt) % (option, val) + ) + + def ensure_filename(self, option: str) -> None: + """Ensure that 'option' is the name of an existing file.""" + self._ensure_tested_string( + option, os.path.isfile, "filename", "'%s' does not exist or is not a file" + ) + + def ensure_dirname(self, option: str) -> None: + self._ensure_tested_string( + option, + os.path.isdir, + "directory name", + "'%s' does not exist or is not a directory", + ) + + # -- Convenience methods for commands ------------------------------ + + def get_command_name(self) -> str: + if hasattr(self, 'command_name'): + return self.command_name + else: + return self.__class__.__name__ + + def set_undefined_options( + self, src_cmd: str, *option_pairs: tuple[str, str] + ) -> None: + """Set the values of any "undefined" options from corresponding + option values in some other command object. "Undefined" here means + "is None", which is the convention used to indicate that an option + has not been changed between 'initialize_options()' and + 'finalize_options()'. Usually called from 'finalize_options()' for + options that depend on some other command rather than another + option of the same command. 'src_cmd' is the other command from + which option values will be taken (a command object will be created + for it if necessary); the remaining arguments are + '(src_option,dst_option)' tuples which mean "take the value of + 'src_option' in the 'src_cmd' command object, and copy it to + 'dst_option' in the current command object". + """ + # Option_pairs: list of (src_option, dst_option) tuples + src_cmd_obj = self.distribution.get_command_obj(src_cmd) + src_cmd_obj.ensure_finalized() + for src_option, dst_option in option_pairs: + if getattr(self, dst_option) is None: + setattr(self, dst_option, getattr(src_cmd_obj, src_option)) + + # NOTE: Because distutils is private to Setuptools and not all commands are exposed here, + # not every possible command is enumerated in the signature. + def get_finalized_command(self, command: str, create: bool = True) -> Command: + """Wrapper around Distribution's 'get_command_obj()' method: find + (create if necessary and 'create' is true) the command object for + 'command', call its 'ensure_finalized()' method, and return the + finalized command object. + """ + cmd_obj = self.distribution.get_command_obj(command, create) + cmd_obj.ensure_finalized() + return cmd_obj + + # XXX rename to 'get_reinitialized_command()'? (should do the + # same in dist.py, if so) + @overload + def reinitialize_command( + self, command: str, reinit_subcommands: bool = False + ) -> Command: ... + @overload + def reinitialize_command( + self, command: _CommandT, reinit_subcommands: bool = False + ) -> _CommandT: ... + def reinitialize_command( + self, command: str | Command, reinit_subcommands=False + ) -> Command: + return self.distribution.reinitialize_command(command, reinit_subcommands) + + def run_command(self, command: str) -> None: + """Run some other command: uses the 'run_command()' method of + Distribution, which creates and finalizes the command object if + necessary and then invokes its 'run()' method. + """ + self.distribution.run_command(command) + + def get_sub_commands(self) -> list[str]: + """Determine the sub-commands that are relevant in the current + distribution (ie., that need to be run). This is based on the + 'sub_commands' class attribute: each tuple in that list may include + a method that we call to determine if the subcommand needs to be + run for the current distribution. Return a list of command names. + """ + commands = [] + for cmd_name, method in self.sub_commands: + if method is None or method(self): + commands.append(cmd_name) + return commands + + # -- External world manipulation ----------------------------------- + + def warn(self, msg: object) -> None: + log.warning("warning: %s: %s\n", self.get_command_name(), msg) + + def execute( + self, + func: Callable[[Unpack[_Ts]], object], + args: tuple[Unpack[_Ts]], + msg: object = None, + level: int = 1, + ) -> None: + util.execute(func, args, msg) + + def mkpath(self, name: str, mode: int = 0o777) -> None: + dir_util.mkpath(name, mode) + + @overload + def copy_file( + self, + infile: str | os.PathLike[str], + outfile: _StrPathT, + preserve_mode: bool = True, + preserve_times: bool = True, + link: str | None = None, + level: int = 1, + ) -> tuple[_StrPathT | str, bool]: ... + @overload + def copy_file( + self, + infile: bytes | os.PathLike[bytes], + outfile: _BytesPathT, + preserve_mode: bool = True, + preserve_times: bool = True, + link: str | None = None, + level: int = 1, + ) -> tuple[_BytesPathT | bytes, bool]: ... + def copy_file( + self, + infile: str | os.PathLike[str] | bytes | os.PathLike[bytes], + outfile: str | os.PathLike[str] | bytes | os.PathLike[bytes], + preserve_mode: bool = True, + preserve_times: bool = True, + link: str | None = None, + level: int = 1, + ) -> tuple[str | os.PathLike[str] | bytes | os.PathLike[bytes], bool]: + """Copy a file respecting verbose, dry-run and force flags. (The + former two default to whatever is in the Distribution object, and + the latter defaults to false for commands that don't define it.)""" + return file_util.copy_file( + infile, + outfile, + preserve_mode, + preserve_times, + not self.force, + link, + ) + + def copy_tree( + self, + infile: str | os.PathLike[str], + outfile: str, + preserve_mode: bool = True, + preserve_times: bool = True, + preserve_symlinks: bool = False, + level: int = 1, + ) -> list[str]: + """Copy an entire directory tree respecting verbose, dry-run, + and force flags. + """ + return dir_util.copy_tree( + infile, + outfile, + preserve_mode, + preserve_times, + preserve_symlinks, + not self.force, + ) + + @overload + def move_file( + self, src: str | os.PathLike[str], dst: _StrPathT, level: int = 1 + ) -> _StrPathT | str: ... + @overload + def move_file( + self, src: bytes | os.PathLike[bytes], dst: _BytesPathT, level: int = 1 + ) -> _BytesPathT | bytes: ... + def move_file( + self, + src: str | os.PathLike[str] | bytes | os.PathLike[bytes], + dst: str | os.PathLike[str] | bytes | os.PathLike[bytes], + level: int = 1, + ) -> str | os.PathLike[str] | bytes | os.PathLike[bytes]: + """Move a file respecting dry-run flag.""" + return file_util.move_file(src, dst) + + def spawn( + self, cmd: MutableSequence[str], search_path: bool = True, level: int = 1 + ) -> None: + """Spawn an external command respecting dry-run flag.""" + from distutils.spawn import spawn + + spawn(cmd, search_path) + + @overload + def make_archive( + self, + base_name: str, + format: str, + root_dir: str | os.PathLike[str] | bytes | os.PathLike[bytes] | None = None, + base_dir: str | None = None, + owner: str | None = None, + group: str | None = None, + ) -> str: ... + @overload + def make_archive( + self, + base_name: str | os.PathLike[str], + format: str, + root_dir: str | os.PathLike[str] | bytes | os.PathLike[bytes], + base_dir: str | None = None, + owner: str | None = None, + group: str | None = None, + ) -> str: ... + def make_archive( + self, + base_name: str | os.PathLike[str], + format: str, + root_dir: str | os.PathLike[str] | bytes | os.PathLike[bytes] | None = None, + base_dir: str | None = None, + owner: str | None = None, + group: str | None = None, + ) -> str: + return archive_util.make_archive( + base_name, + format, + root_dir, + base_dir, + owner=owner, + group=group, + ) + + def make_file( + self, + infiles: str | list[str] | tuple[str, ...], + outfile: str | os.PathLike[str] | bytes | os.PathLike[bytes], + func: Callable[[Unpack[_Ts]], object], + args: tuple[Unpack[_Ts]], + exec_msg: object = None, + skip_msg: object = None, + level: int = 1, + ) -> None: + """Special case of 'execute()' for operations that process one or + more input files and generate one output file. Works just like + 'execute()', except the operation is skipped and a different + message printed if 'outfile' already exists and is newer than all + files listed in 'infiles'. If the command defined 'self.force', + and it is true, then the command is unconditionally run -- does no + timestamp checks. + """ + if skip_msg is None: + skip_msg = f"skipping {outfile} (inputs unchanged)" + + # Allow 'infiles' to be a single string + if isinstance(infiles, str): + infiles = (infiles,) + elif not isinstance(infiles, (list, tuple)): + raise TypeError("'infiles' must be a string, or a list or tuple of strings") + + if exec_msg is None: + exec_msg = "generating {} from {}".format(outfile, ', '.join(infiles)) + + # If 'outfile' must be regenerated (either because it doesn't + # exist, is out-of-date, or the 'force' flag is true) then + # perform the action that presumably regenerates it + if self.force or _modified.newer_group(infiles, outfile): + self.execute(func, args, exec_msg, level) + # Otherwise, print the "skip" message + else: + log.debug(skip_msg) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__init__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..0f8a1692ba96f5e03167e7307c1c2ff5776b74d6 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__init__.py @@ -0,0 +1,23 @@ +"""distutils.command + +Package containing implementation of all the standard Distutils +commands.""" + +__all__ = [ + 'build', + 'build_py', + 'build_ext', + 'build_clib', + 'build_scripts', + 'clean', + 'install', + 'install_lib', + 'install_headers', + 'install_scripts', + 'install_data', + 'sdist', + 'bdist', + 'bdist_dumb', + 'bdist_rpm', + 'check', +] diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..615bdd86b0af60a3b6c7cfdccb535bb56a83702e Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/_framework_compat.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/_framework_compat.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5602b30edb9a474913b60d811780a946eb6d6ac2 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/_framework_compat.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/bdist.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/bdist.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b29fd0f57967ef7dc10049a9d7a9c8460a4f2009 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/bdist.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/bdist_dumb.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/bdist_dumb.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d90d9d27475164afcf2891b22a15f87a8aea43c2 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/bdist_dumb.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/bdist_rpm.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/bdist_rpm.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..24f29c843c10a1fdc7d22818565422a5b93e4f47 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/bdist_rpm.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d1741c02c688ce528452d3b62e2f1000a79dd7a7 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build_clib.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build_clib.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..716fc0689bbc54131e7418a0ee3dad5b43f0b9fd Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build_clib.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build_ext.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build_ext.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1473642b5df1056a8cd540bfc4184daf4d1ab90d Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build_ext.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build_py.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build_py.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..90c253b1a7af5b1bb6bd4bc9363f5b32b1fb004e Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build_py.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build_scripts.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build_scripts.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e2b3397542e4bf62a0757eea4a498020e05cac31 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build_scripts.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/check.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/check.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..92ee237fe2e8db2711b01c4a1e5f3290d9e183ac Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/check.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/clean.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/clean.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fe5bcd5fc6da8637faa131656c2dc256a714ed74 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/clean.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/config.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/config.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b72ed505593617bc9322895854dfa9207958c080 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/config.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..992f9d49e8254de1cac0eb72ccce609c1918560e Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_data.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_data.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a93d4c249e43290ffc7339355cfad03649e9135f Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_data.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_egg_info.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_egg_info.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..42b2b6c505aa3a45731ed9de08500b9485a3e96c Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_egg_info.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_headers.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_headers.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b525d1191fc78f003f56617911ca5dbf337d23e0 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_headers.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_lib.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_lib.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9b6c6ae85eb03dc0e9dd8fa10dc6c003276e5bae Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_lib.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_scripts.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_scripts.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e2685c0733e9992934a9c9553f372bf83a5c3784 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_scripts.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/sdist.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/sdist.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c533677240478217a0d73f7fcbcc380934697b63 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/sdist.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/_framework_compat.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/_framework_compat.py new file mode 100644 index 0000000000000000000000000000000000000000..00d34bc7d8c85126dbae716ebfa48e35b0833222 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/_framework_compat.py @@ -0,0 +1,54 @@ +""" +Backward compatibility for homebrew builds on macOS. +""" + +import functools +import os +import subprocess +import sys +import sysconfig + + +@functools.lru_cache +def enabled(): + """ + Only enabled for Python 3.9 framework homebrew builds + except ensurepip and venv. + """ + PY39 = (3, 9) < sys.version_info < (3, 10) + framework = sys.platform == 'darwin' and sys._framework + homebrew = "Cellar" in sysconfig.get_config_var('projectbase') + venv = sys.prefix != sys.base_prefix + ensurepip = os.environ.get("ENSUREPIP_OPTIONS") + return PY39 and framework and homebrew and not venv and not ensurepip + + +schemes = dict( + osx_framework_library=dict( + stdlib='{installed_base}/{platlibdir}/python{py_version_short}', + platstdlib='{platbase}/{platlibdir}/python{py_version_short}', + purelib='{homebrew_prefix}/lib/python{py_version_short}/site-packages', + platlib='{homebrew_prefix}/{platlibdir}/python{py_version_short}/site-packages', + include='{installed_base}/include/python{py_version_short}{abiflags}', + platinclude='{installed_platbase}/include/python{py_version_short}{abiflags}', + scripts='{homebrew_prefix}/bin', + data='{homebrew_prefix}', + ) +) + + +@functools.lru_cache +def vars(): + if not enabled(): + return {} + homebrew_prefix = subprocess.check_output(['brew', '--prefix'], text=True).strip() + return locals() + + +def scheme(name): + """ + Override the selected scheme for posix_prefix. + """ + if not enabled() or not name.endswith('_prefix'): + return name + return 'osx_framework_library' diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/bdist.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/bdist.py new file mode 100644 index 0000000000000000000000000000000000000000..07811aab27ad7fcd2303883024243e2f52c2bbcb --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/bdist.py @@ -0,0 +1,167 @@ +"""distutils.command.bdist + +Implements the Distutils 'bdist' command (create a built [binary] +distribution).""" + +from __future__ import annotations + +import os +import warnings +from collections.abc import Callable +from typing import TYPE_CHECKING, ClassVar + +from ..core import Command +from ..errors import DistutilsOptionError, DistutilsPlatformError +from ..util import get_platform + +if TYPE_CHECKING: + from typing_extensions import deprecated +else: + + def deprecated(message): + return lambda fn: fn + + +def show_formats(): + """Print list of available formats (arguments to "--format" option).""" + from ..fancy_getopt import FancyGetopt + + formats = [ + ("formats=" + format, None, bdist.format_commands[format][1]) + for format in bdist.format_commands + ] + pretty_printer = FancyGetopt(formats) + pretty_printer.print_help("List of available distribution formats:") + + +class ListCompat(dict[str, tuple[str, str]]): + # adapter to allow for Setuptools compatibility in format_commands + @deprecated("format_commands is now a dict. append is deprecated.") + def append(self, item: object) -> None: + warnings.warn( + "format_commands is now a dict. append is deprecated.", + DeprecationWarning, + stacklevel=2, + ) + + +class bdist(Command): + description = "create a built (binary) distribution" + + user_options = [ + ('bdist-base=', 'b', "temporary directory for creating built distributions"), + ( + 'plat-name=', + 'p', + "platform name to embed in generated filenames " + f"[default: {get_platform()}]", + ), + ('formats=', None, "formats for distribution (comma-separated list)"), + ( + 'dist-dir=', + 'd', + "directory to put final built distributions in [default: dist]", + ), + ('skip-build', None, "skip rebuilding everything (for testing/debugging)"), + ( + 'owner=', + 'u', + "Owner name used when creating a tar file [default: current user]", + ), + ( + 'group=', + 'g', + "Group name used when creating a tar file [default: current group]", + ), + ] + + boolean_options: ClassVar[list[str]] = ['skip-build'] + + help_options: ClassVar[list[tuple[str, str | None, str, Callable[[], object]]]] = [ + ('help-formats', None, "lists available distribution formats", show_formats), + ] + + # The following commands do not take a format option from bdist + no_format_option: ClassVar[tuple[str, ...]] = ('bdist_rpm',) + + # This won't do in reality: will need to distinguish RPM-ish Linux, + # Debian-ish Linux, Solaris, FreeBSD, ..., Windows, Mac OS. + default_format: ClassVar[dict[str, str]] = {'posix': 'gztar', 'nt': 'zip'} + + # Define commands in preferred order for the --help-formats option + format_commands = ListCompat({ + 'rpm': ('bdist_rpm', "RPM distribution"), + 'gztar': ('bdist_dumb', "gzip'ed tar file"), + 'bztar': ('bdist_dumb', "bzip2'ed tar file"), + 'xztar': ('bdist_dumb', "xz'ed tar file"), + 'ztar': ('bdist_dumb', "compressed tar file"), + 'tar': ('bdist_dumb', "tar file"), + 'zip': ('bdist_dumb', "ZIP file"), + }) + + # for compatibility until consumers only reference format_commands + format_command = format_commands + + def initialize_options(self): + self.bdist_base = None + self.plat_name = None + self.formats = None + self.dist_dir = None + self.skip_build = False + self.group = None + self.owner = None + + def finalize_options(self) -> None: + # have to finalize 'plat_name' before 'bdist_base' + if self.plat_name is None: + if self.skip_build: + self.plat_name = get_platform() + else: + self.plat_name = self.get_finalized_command('build').plat_name + + # 'bdist_base' -- parent of per-built-distribution-format + # temporary directories (eg. we'll probably have + # "build/bdist./dumb", "build/bdist./rpm", etc.) + if self.bdist_base is None: + build_base = self.get_finalized_command('build').build_base + self.bdist_base = os.path.join(build_base, 'bdist.' + self.plat_name) + + self.ensure_string_list('formats') + if self.formats is None: + try: + self.formats = [self.default_format[os.name]] + except KeyError: + raise DistutilsPlatformError( + "don't know how to create built distributions " + f"on platform {os.name}" + ) + + if self.dist_dir is None: + self.dist_dir = "dist" + + def run(self) -> None: + # Figure out which sub-commands we need to run. + commands = [] + for format in self.formats: + try: + commands.append(self.format_commands[format][0]) + except KeyError: + raise DistutilsOptionError(f"invalid format '{format}'") + + # Reinitialize and run each command. + for i in range(len(self.formats)): + cmd_name = commands[i] + sub_cmd = self.reinitialize_command(cmd_name) + if cmd_name not in self.no_format_option: + sub_cmd.format = self.formats[i] + + # passing the owner and group names for tar archiving + if cmd_name == 'bdist_dumb': + sub_cmd.owner = self.owner + sub_cmd.group = self.group + + # If we're going to need to run this command again, tell it to + # keep its temporary files around so subsequent runs go faster. + if cmd_name in commands[i + 1 :]: + sub_cmd.keep_temp = True + self.run_command(cmd_name) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/bdist_dumb.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/bdist_dumb.py new file mode 100644 index 0000000000000000000000000000000000000000..c49ef253b47cd0791aae1fc65c005c668cb1e97b --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/bdist_dumb.py @@ -0,0 +1,141 @@ +"""distutils.command.bdist_dumb + +Implements the Distutils 'bdist_dumb' command (create a "dumb" built +distribution -- i.e., just an archive to be unpacked under $prefix or +$exec_prefix).""" + +import os +from distutils._log import log +from typing import ClassVar + +from ..core import Command +from ..dir_util import ensure_relative, remove_tree +from ..errors import DistutilsPlatformError +from ..sysconfig import get_python_version +from ..util import get_platform + + +class bdist_dumb(Command): + description = "create a \"dumb\" built distribution" + + user_options = [ + ('bdist-dir=', 'd', "temporary directory for creating the distribution"), + ( + 'plat-name=', + 'p', + "platform name to embed in generated filenames " + f"[default: {get_platform()}]", + ), + ( + 'format=', + 'f', + "archive format to create (tar, gztar, bztar, xztar, ztar, zip)", + ), + ( + 'keep-temp', + 'k', + "keep the pseudo-installation tree around after creating the distribution archive", + ), + ('dist-dir=', 'd', "directory to put final built distributions in"), + ('skip-build', None, "skip rebuilding everything (for testing/debugging)"), + ( + 'relative', + None, + "build the archive using relative paths [default: false]", + ), + ( + 'owner=', + 'u', + "Owner name used when creating a tar file [default: current user]", + ), + ( + 'group=', + 'g', + "Group name used when creating a tar file [default: current group]", + ), + ] + + boolean_options: ClassVar[list[str]] = ['keep-temp', 'skip-build', 'relative'] + + default_format = {'posix': 'gztar', 'nt': 'zip'} + + def initialize_options(self): + self.bdist_dir = None + self.plat_name = None + self.format = None + self.keep_temp = False + self.dist_dir = None + self.skip_build = None + self.relative = False + self.owner = None + self.group = None + + def finalize_options(self): + if self.bdist_dir is None: + bdist_base = self.get_finalized_command('bdist').bdist_base + self.bdist_dir = os.path.join(bdist_base, 'dumb') + + if self.format is None: + try: + self.format = self.default_format[os.name] + except KeyError: + raise DistutilsPlatformError( + "don't know how to create dumb built distributions " + f"on platform {os.name}" + ) + + self.set_undefined_options( + 'bdist', + ('dist_dir', 'dist_dir'), + ('plat_name', 'plat_name'), + ('skip_build', 'skip_build'), + ) + + def run(self): + if not self.skip_build: + self.run_command('build') + + install = self.reinitialize_command('install', reinit_subcommands=True) + install.root = self.bdist_dir + install.skip_build = self.skip_build + install.warn_dir = False + + log.info("installing to %s", self.bdist_dir) + self.run_command('install') + + # And make an archive relative to the root of the + # pseudo-installation tree. + archive_basename = f"{self.distribution.get_fullname()}.{self.plat_name}" + + pseudoinstall_root = os.path.join(self.dist_dir, archive_basename) + if not self.relative: + archive_root = self.bdist_dir + else: + if self.distribution.has_ext_modules() and ( + install.install_base != install.install_platbase + ): + raise DistutilsPlatformError( + "can't make a dumb built distribution where " + f"base and platbase are different ({install.install_base!r}, {install.install_platbase!r})" + ) + else: + archive_root = os.path.join( + self.bdist_dir, ensure_relative(install.install_base) + ) + + # Make the archive + filename = self.make_archive( + pseudoinstall_root, + self.format, + root_dir=archive_root, + owner=self.owner, + group=self.group, + ) + if self.distribution.has_ext_modules(): + pyversion = get_python_version() + else: + pyversion = 'any' + self.distribution.dist_files.append(('bdist_dumb', pyversion, filename)) + + if not self.keep_temp: + remove_tree(self.bdist_dir) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/bdist_rpm.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/bdist_rpm.py new file mode 100644 index 0000000000000000000000000000000000000000..dfa5f99dda095af76d8ffac33e1dd8bfd6aad931 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/bdist_rpm.py @@ -0,0 +1,597 @@ +"""distutils.command.bdist_rpm + +Implements the Distutils 'bdist_rpm' command (create RPM source and binary +distributions).""" + +import os +import subprocess +import sys +from distutils._log import log +from typing import ClassVar + +from ..core import Command +from ..debug import DEBUG +from ..errors import ( + DistutilsExecError, + DistutilsFileError, + DistutilsOptionError, + DistutilsPlatformError, +) +from ..file_util import write_file +from ..sysconfig import get_python_version + + +class bdist_rpm(Command): + description = "create an RPM distribution" + + user_options = [ + ('bdist-base=', None, "base directory for creating built distributions"), + ( + 'rpm-base=', + None, + "base directory for creating RPMs (defaults to \"rpm\" under " + "--bdist-base; must be specified for RPM 2)", + ), + ( + 'dist-dir=', + 'd', + "directory to put final RPM files in (and .spec files if --spec-only)", + ), + ( + 'python=', + None, + "path to Python interpreter to hard-code in the .spec file " + "[default: \"python\"]", + ), + ( + 'fix-python', + None, + "hard-code the exact path to the current Python interpreter in " + "the .spec file", + ), + ('spec-only', None, "only regenerate spec file"), + ('source-only', None, "only generate source RPM"), + ('binary-only', None, "only generate binary RPM"), + ('use-bzip2', None, "use bzip2 instead of gzip to create source distribution"), + # More meta-data: too RPM-specific to put in the setup script, + # but needs to go in the .spec file -- so we make these options + # to "bdist_rpm". The idea is that packagers would put this + # info in setup.cfg, although they are of course free to + # supply it on the command line. + ( + 'distribution-name=', + None, + "name of the (Linux) distribution to which this " + "RPM applies (*not* the name of the module distribution!)", + ), + ('group=', None, "package classification [default: \"Development/Libraries\"]"), + ('release=', None, "RPM release number"), + ('serial=', None, "RPM serial number"), + ( + 'vendor=', + None, + "RPM \"vendor\" (eg. \"Joe Blow \") " + "[default: maintainer or author from setup script]", + ), + ( + 'packager=', + None, + "RPM packager (eg. \"Jane Doe \") [default: vendor]", + ), + ('doc-files=', None, "list of documentation files (space or comma-separated)"), + ('changelog=', None, "RPM changelog"), + ('icon=', None, "name of icon file"), + ('provides=', None, "capabilities provided by this package"), + ('requires=', None, "capabilities required by this package"), + ('conflicts=', None, "capabilities which conflict with this package"), + ('build-requires=', None, "capabilities required to build this package"), + ('obsoletes=', None, "capabilities made obsolete by this package"), + ('no-autoreq', None, "do not automatically calculate dependencies"), + # Actions to take when building RPM + ('keep-temp', 'k', "don't clean up RPM build directory"), + ('no-keep-temp', None, "clean up RPM build directory [default]"), + ( + 'use-rpm-opt-flags', + None, + "compile with RPM_OPT_FLAGS when building from source RPM", + ), + ('no-rpm-opt-flags', None, "do not pass any RPM CFLAGS to compiler"), + ('rpm3-mode', None, "RPM 3 compatibility mode (default)"), + ('rpm2-mode', None, "RPM 2 compatibility mode"), + # Add the hooks necessary for specifying custom scripts + ('prep-script=', None, "Specify a script for the PREP phase of RPM building"), + ('build-script=', None, "Specify a script for the BUILD phase of RPM building"), + ( + 'pre-install=', + None, + "Specify a script for the pre-INSTALL phase of RPM building", + ), + ( + 'install-script=', + None, + "Specify a script for the INSTALL phase of RPM building", + ), + ( + 'post-install=', + None, + "Specify a script for the post-INSTALL phase of RPM building", + ), + ( + 'pre-uninstall=', + None, + "Specify a script for the pre-UNINSTALL phase of RPM building", + ), + ( + 'post-uninstall=', + None, + "Specify a script for the post-UNINSTALL phase of RPM building", + ), + ('clean-script=', None, "Specify a script for the CLEAN phase of RPM building"), + ( + 'verify-script=', + None, + "Specify a script for the VERIFY phase of the RPM build", + ), + # Allow a packager to explicitly force an architecture + ('force-arch=', None, "Force an architecture onto the RPM build process"), + ('quiet', 'q', "Run the INSTALL phase of RPM building in quiet mode"), + ] + + boolean_options: ClassVar[list[str]] = [ + 'keep-temp', + 'use-rpm-opt-flags', + 'rpm3-mode', + 'no-autoreq', + 'quiet', + ] + + negative_opt: ClassVar[dict[str, str]] = { + 'no-keep-temp': 'keep-temp', + 'no-rpm-opt-flags': 'use-rpm-opt-flags', + 'rpm2-mode': 'rpm3-mode', + } + + def initialize_options(self): + self.bdist_base = None + self.rpm_base = None + self.dist_dir = None + self.python = None + self.fix_python = None + self.spec_only = None + self.binary_only = None + self.source_only = None + self.use_bzip2 = None + + self.distribution_name = None + self.group = None + self.release = None + self.serial = None + self.vendor = None + self.packager = None + self.doc_files = None + self.changelog = None + self.icon = None + + self.prep_script = None + self.build_script = None + self.install_script = None + self.clean_script = None + self.verify_script = None + self.pre_install = None + self.post_install = None + self.pre_uninstall = None + self.post_uninstall = None + self.prep = None + self.provides = None + self.requires = None + self.conflicts = None + self.build_requires = None + self.obsoletes = None + + self.keep_temp = False + self.use_rpm_opt_flags = True + self.rpm3_mode = True + self.no_autoreq = False + + self.force_arch = None + self.quiet = False + + def finalize_options(self) -> None: + self.set_undefined_options('bdist', ('bdist_base', 'bdist_base')) + if self.rpm_base is None: + if not self.rpm3_mode: + raise DistutilsOptionError("you must specify --rpm-base in RPM 2 mode") + self.rpm_base = os.path.join(self.bdist_base, "rpm") + + if self.python is None: + if self.fix_python: + self.python = sys.executable + else: + self.python = "python3" + elif self.fix_python: + raise DistutilsOptionError( + "--python and --fix-python are mutually exclusive options" + ) + + if os.name != 'posix': + raise DistutilsPlatformError( + f"don't know how to create RPM distributions on platform {os.name}" + ) + if self.binary_only and self.source_only: + raise DistutilsOptionError( + "cannot supply both '--source-only' and '--binary-only'" + ) + + # don't pass CFLAGS to pure python distributions + if not self.distribution.has_ext_modules(): + self.use_rpm_opt_flags = False + + self.set_undefined_options('bdist', ('dist_dir', 'dist_dir')) + self.finalize_package_data() + + def finalize_package_data(self) -> None: + self.ensure_string('group', "Development/Libraries") + self.ensure_string( + 'vendor', + f"{self.distribution.get_contact()} <{self.distribution.get_contact_email()}>", + ) + self.ensure_string('packager') + self.ensure_string_list('doc_files') + if isinstance(self.doc_files, list): + for readme in ('README', 'README.txt'): + if os.path.exists(readme) and readme not in self.doc_files: + self.doc_files.append(readme) + + self.ensure_string('release', "1") + self.ensure_string('serial') # should it be an int? + + self.ensure_string('distribution_name') + + self.ensure_string('changelog') + # Format changelog correctly + self.changelog = self._format_changelog(self.changelog) + + self.ensure_filename('icon') + + self.ensure_filename('prep_script') + self.ensure_filename('build_script') + self.ensure_filename('install_script') + self.ensure_filename('clean_script') + self.ensure_filename('verify_script') + self.ensure_filename('pre_install') + self.ensure_filename('post_install') + self.ensure_filename('pre_uninstall') + self.ensure_filename('post_uninstall') + + # XXX don't forget we punted on summaries and descriptions -- they + # should be handled here eventually! + + # Now *this* is some meta-data that belongs in the setup script... + self.ensure_string_list('provides') + self.ensure_string_list('requires') + self.ensure_string_list('conflicts') + self.ensure_string_list('build_requires') + self.ensure_string_list('obsoletes') + + self.ensure_string('force_arch') + + def run(self) -> None: # noqa: C901 + if DEBUG: + print("before _get_package_data():") + print("vendor =", self.vendor) + print("packager =", self.packager) + print("doc_files =", self.doc_files) + print("changelog =", self.changelog) + + # make directories + if self.spec_only: + spec_dir = self.dist_dir + self.mkpath(spec_dir) + else: + rpm_dir = {} + for d in ('SOURCES', 'SPECS', 'BUILD', 'RPMS', 'SRPMS'): + rpm_dir[d] = os.path.join(self.rpm_base, d) + self.mkpath(rpm_dir[d]) + spec_dir = rpm_dir['SPECS'] + + # Spec file goes into 'dist_dir' if '--spec-only specified', + # build/rpm. otherwise. + spec_path = os.path.join(spec_dir, f"{self.distribution.get_name()}.spec") + self.execute( + write_file, (spec_path, self._make_spec_file()), f"writing '{spec_path}'" + ) + + if self.spec_only: # stop if requested + return + + # Make a source distribution and copy to SOURCES directory with + # optional icon. + saved_dist_files = self.distribution.dist_files[:] + sdist = self.reinitialize_command('sdist') + if self.use_bzip2: + sdist.formats = ['bztar'] + else: + sdist.formats = ['gztar'] + self.run_command('sdist') + self.distribution.dist_files = saved_dist_files + + source = sdist.get_archive_files()[0] + source_dir = rpm_dir['SOURCES'] + self.copy_file(source, source_dir) + + if self.icon: + if os.path.exists(self.icon): + self.copy_file(self.icon, source_dir) + else: + raise DistutilsFileError(f"icon file '{self.icon}' does not exist") + + # build package + log.info("building RPMs") + rpm_cmd = ['rpmbuild'] + + if self.source_only: # what kind of RPMs? + rpm_cmd.append('-bs') + elif self.binary_only: + rpm_cmd.append('-bb') + else: + rpm_cmd.append('-ba') + rpm_cmd.extend(['--define', f'__python {self.python}']) + if self.rpm3_mode: + rpm_cmd.extend(['--define', f'_topdir {os.path.abspath(self.rpm_base)}']) + if not self.keep_temp: + rpm_cmd.append('--clean') + + if self.quiet: + rpm_cmd.append('--quiet') + + rpm_cmd.append(spec_path) + # Determine the binary rpm names that should be built out of this spec + # file + # Note that some of these may not be really built (if the file + # list is empty) + nvr_string = "%{name}-%{version}-%{release}" + src_rpm = nvr_string + ".src.rpm" + non_src_rpm = "%{arch}/" + nvr_string + ".%{arch}.rpm" + q_cmd = rf"rpm -q --qf '{src_rpm} {non_src_rpm}\n' --specfile '{spec_path}'" + + out = os.popen(q_cmd) + try: + binary_rpms = [] + source_rpm = None + while True: + line = out.readline() + if not line: + break + ell = line.strip().split() + assert len(ell) == 2 + binary_rpms.append(ell[1]) + # The source rpm is named after the first entry in the spec file + if source_rpm is None: + source_rpm = ell[0] + + status = out.close() + if status: + raise DistutilsExecError(f"Failed to execute: {q_cmd!r}") + + finally: + out.close() + + self.spawn(rpm_cmd) + + if self.distribution.has_ext_modules(): + pyversion = get_python_version() + else: + pyversion = 'any' + + if not self.binary_only: + srpm = os.path.join(rpm_dir['SRPMS'], source_rpm) + assert os.path.exists(srpm) + self.move_file(srpm, self.dist_dir) + filename = os.path.join(self.dist_dir, source_rpm) + self.distribution.dist_files.append(('bdist_rpm', pyversion, filename)) + + if not self.source_only: + for rpm in binary_rpms: + rpm = os.path.join(rpm_dir['RPMS'], rpm) + if os.path.exists(rpm): + self.move_file(rpm, self.dist_dir) + filename = os.path.join(self.dist_dir, os.path.basename(rpm)) + self.distribution.dist_files.append(( + 'bdist_rpm', + pyversion, + filename, + )) + + def _dist_path(self, path): + return os.path.join(self.dist_dir, os.path.basename(path)) + + def _make_spec_file(self): # noqa: C901 + """Generate the text of an RPM spec file and return it as a + list of strings (one per line). + """ + # definitions and headers + spec_file = [ + '%define name ' + self.distribution.get_name(), + '%define version ' + self.distribution.get_version().replace('-', '_'), + '%define unmangled_version ' + self.distribution.get_version(), + '%define release ' + self.release.replace('-', '_'), + '', + 'Summary: ' + (self.distribution.get_description() or "UNKNOWN"), + ] + + # Workaround for #14443 which affects some RPM based systems such as + # RHEL6 (and probably derivatives) + vendor_hook = subprocess.getoutput('rpm --eval %{__os_install_post}') + # Generate a potential replacement value for __os_install_post (whilst + # normalizing the whitespace to simplify the test for whether the + # invocation of brp-python-bytecompile passes in __python): + vendor_hook = '\n'.join([ + f' {line.strip()} \\' for line in vendor_hook.splitlines() + ]) + problem = "brp-python-bytecompile \\\n" + fixed = "brp-python-bytecompile %{__python} \\\n" + fixed_hook = vendor_hook.replace(problem, fixed) + if fixed_hook != vendor_hook: + spec_file.append('# Workaround for https://bugs.python.org/issue14443') + spec_file.append('%define __os_install_post ' + fixed_hook + '\n') + + # put locale summaries into spec file + # XXX not supported for now (hard to put a dictionary + # in a config file -- arg!) + # for locale in self.summaries.keys(): + # spec_file.append('Summary(%s): %s' % (locale, + # self.summaries[locale])) + + spec_file.extend([ + 'Name: %{name}', + 'Version: %{version}', + 'Release: %{release}', + ]) + + # XXX yuck! this filename is available from the "sdist" command, + # but only after it has run: and we create the spec file before + # running "sdist", in case of --spec-only. + if self.use_bzip2: + spec_file.append('Source0: %{name}-%{unmangled_version}.tar.bz2') + else: + spec_file.append('Source0: %{name}-%{unmangled_version}.tar.gz') + + spec_file.extend([ + 'License: ' + (self.distribution.get_license() or "UNKNOWN"), + 'Group: ' + self.group, + 'BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-buildroot', + 'Prefix: %{_prefix}', + ]) + + if not self.force_arch: + # noarch if no extension modules + if not self.distribution.has_ext_modules(): + spec_file.append('BuildArch: noarch') + else: + spec_file.append(f'BuildArch: {self.force_arch}') + + for field in ( + 'Vendor', + 'Packager', + 'Provides', + 'Requires', + 'Conflicts', + 'Obsoletes', + ): + val = getattr(self, field.lower()) + if isinstance(val, list): + spec_file.append('{}: {}'.format(field, ' '.join(val))) + elif val is not None: + spec_file.append(f'{field}: {val}') + + if self.distribution.get_url(): + spec_file.append('Url: ' + self.distribution.get_url()) + + if self.distribution_name: + spec_file.append('Distribution: ' + self.distribution_name) + + if self.build_requires: + spec_file.append('BuildRequires: ' + ' '.join(self.build_requires)) + + if self.icon: + spec_file.append('Icon: ' + os.path.basename(self.icon)) + + if self.no_autoreq: + spec_file.append('AutoReq: 0') + + spec_file.extend([ + '', + '%description', + self.distribution.get_long_description() or "", + ]) + + # put locale descriptions into spec file + # XXX again, suppressed because config file syntax doesn't + # easily support this ;-( + # for locale in self.descriptions.keys(): + # spec_file.extend([ + # '', + # '%description -l ' + locale, + # self.descriptions[locale], + # ]) + + # rpm scripts + # figure out default build script + def_setup_call = f"{self.python} {os.path.basename(sys.argv[0])}" + def_build = f"{def_setup_call} build" + if self.use_rpm_opt_flags: + def_build = 'env CFLAGS="$RPM_OPT_FLAGS" ' + def_build + + # insert contents of files + + # XXX this is kind of misleading: user-supplied options are files + # that we open and interpolate into the spec file, but the defaults + # are just text that we drop in as-is. Hmmm. + + install_cmd = f'{def_setup_call} install -O1 --root=$RPM_BUILD_ROOT --record=INSTALLED_FILES' + + script_options = [ + ('prep', 'prep_script', "%setup -n %{name}-%{unmangled_version}"), + ('build', 'build_script', def_build), + ('install', 'install_script', install_cmd), + ('clean', 'clean_script', "rm -rf $RPM_BUILD_ROOT"), + ('verifyscript', 'verify_script', None), + ('pre', 'pre_install', None), + ('post', 'post_install', None), + ('preun', 'pre_uninstall', None), + ('postun', 'post_uninstall', None), + ] + + for rpm_opt, attr, default in script_options: + # Insert contents of file referred to, if no file is referred to + # use 'default' as contents of script + val = getattr(self, attr) + if val or default: + spec_file.extend([ + '', + '%' + rpm_opt, + ]) + if val: + with open(val) as f: + spec_file.extend(f.read().split('\n')) + else: + spec_file.append(default) + + # files section + spec_file.extend([ + '', + '%files -f INSTALLED_FILES', + '%defattr(-,root,root)', + ]) + + if self.doc_files: + spec_file.append('%doc ' + ' '.join(self.doc_files)) + + if self.changelog: + spec_file.extend([ + '', + '%changelog', + ]) + spec_file.extend(self.changelog) + + return spec_file + + def _format_changelog(self, changelog): + """Format the changelog correctly and convert it to a list of strings""" + if not changelog: + return changelog + new_changelog = [] + for line in changelog.strip().split('\n'): + line = line.strip() + if line[0] == '*': + new_changelog.extend(['', line]) + elif line[0] == '-': + new_changelog.append(line) + else: + new_changelog.append(' ' + line) + + # strip trailing newline inserted by first changelog entry + if not new_changelog[0]: + del new_changelog[0] + + return new_changelog diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/build.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/build.py new file mode 100644 index 0000000000000000000000000000000000000000..6a8303a954ea705c547e2014dc6b51d9d987a532 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/build.py @@ -0,0 +1,156 @@ +"""distutils.command.build + +Implements the Distutils 'build' command.""" + +from __future__ import annotations + +import os +import sys +import sysconfig +from collections.abc import Callable +from typing import ClassVar + +from ..ccompiler import show_compilers +from ..core import Command +from ..errors import DistutilsOptionError +from ..util import get_platform + + +class build(Command): + description = "build everything needed to install" + + user_options = [ + ('build-base=', 'b', "base directory for build library"), + ('build-purelib=', None, "build directory for platform-neutral distributions"), + ('build-platlib=', None, "build directory for platform-specific distributions"), + ( + 'build-lib=', + None, + "build directory for all distribution (defaults to either build-purelib or build-platlib", + ), + ('build-scripts=', None, "build directory for scripts"), + ('build-temp=', 't', "temporary build directory"), + ( + 'plat-name=', + 'p', + f"platform name to build for, if supported [default: {get_platform()}]", + ), + ('compiler=', 'c', "specify the compiler type"), + ('parallel=', 'j', "number of parallel build jobs"), + ('debug', 'g', "compile extensions and libraries with debugging information"), + ('force', 'f', "forcibly build everything (ignore file timestamps)"), + ('executable=', 'e', "specify final destination interpreter path (build.py)"), + ] + + boolean_options: ClassVar[list[str]] = ['debug', 'force'] + + help_options: ClassVar[list[tuple[str, str | None, str, Callable[[], object]]]] = [ + ('help-compiler', None, "list available compilers", show_compilers), + ] + + def initialize_options(self): + self.build_base = 'build' + # these are decided only after 'build_base' has its final value + # (unless overridden by the user or client) + self.build_purelib = None + self.build_platlib = None + self.build_lib = None + self.build_temp = None + self.build_scripts = None + self.compiler = None + self.plat_name = None + self.debug = None + self.force = False + self.executable = None + self.parallel = None + + def finalize_options(self) -> None: # noqa: C901 + if self.plat_name is None: + self.plat_name = get_platform() + else: + # plat-name only supported for windows (other platforms are + # supported via ./configure flags, if at all). Avoid misleading + # other platforms. + if os.name != 'nt': + raise DistutilsOptionError( + "--plat-name only supported on Windows (try " + "using './configure --help' on your platform)" + ) + + plat_specifier = f".{self.plat_name}-{sys.implementation.cache_tag}" + + # Python 3.13+ with --disable-gil shouldn't share build directories + if sysconfig.get_config_var('Py_GIL_DISABLED'): + plat_specifier += 't' + + # Make it so Python 2.x and Python 2.x with --with-pydebug don't + # share the same build directories. Doing so confuses the build + # process for C modules + if hasattr(sys, 'gettotalrefcount'): + plat_specifier += '-pydebug' + + # 'build_purelib' and 'build_platlib' just default to 'lib' and + # 'lib.' under the base build directory. We only use one of + # them for a given distribution, though -- + if self.build_purelib is None: + self.build_purelib = os.path.join(self.build_base, 'lib') + if self.build_platlib is None: + self.build_platlib = os.path.join(self.build_base, 'lib' + plat_specifier) + + # 'build_lib' is the actual directory that we will use for this + # particular module distribution -- if user didn't supply it, pick + # one of 'build_purelib' or 'build_platlib'. + if self.build_lib is None: + if self.distribution.has_ext_modules(): + self.build_lib = self.build_platlib + else: + self.build_lib = self.build_purelib + + # 'build_temp' -- temporary directory for compiler turds, + # "build/temp." + if self.build_temp is None: + self.build_temp = os.path.join(self.build_base, 'temp' + plat_specifier) + if self.build_scripts is None: + self.build_scripts = os.path.join( + self.build_base, + f'scripts-{sys.version_info.major}.{sys.version_info.minor}', + ) + + if self.executable is None and sys.executable: + self.executable = os.path.normpath(sys.executable) + + if isinstance(self.parallel, str): + try: + self.parallel = int(self.parallel) + except ValueError: + raise DistutilsOptionError("parallel should be an integer") + + def run(self) -> None: + # Run all relevant sub-commands. This will be some subset of: + # - build_py - pure Python modules + # - build_clib - standalone C libraries + # - build_ext - Python extensions + # - build_scripts - (Python) scripts + for cmd_name in self.get_sub_commands(): + self.run_command(cmd_name) + + # -- Predicates for the sub-command list --------------------------- + + def has_pure_modules(self): + return self.distribution.has_pure_modules() + + def has_c_libraries(self): + return self.distribution.has_c_libraries() + + def has_ext_modules(self): + return self.distribution.has_ext_modules() + + def has_scripts(self): + return self.distribution.has_scripts() + + sub_commands = [ + ('build_py', has_pure_modules), + ('build_clib', has_c_libraries), + ('build_ext', has_ext_modules), + ('build_scripts', has_scripts), + ] diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/build_clib.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/build_clib.py new file mode 100644 index 0000000000000000000000000000000000000000..8de5df239c793ac74265d5aac6b113c99b1934fd --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/build_clib.py @@ -0,0 +1,199 @@ +"""distutils.command.build_clib + +Implements the Distutils 'build_clib' command, to build a C/C++ library +that is included in the module distribution and needed by an extension +module.""" + +# XXX this module has *lots* of code ripped-off quite transparently from +# build_ext.py -- not surprisingly really, as the work required to build +# a static library from a collection of C source files is not really all +# that different from what's required to build a shared object file from +# a collection of C source files. Nevertheless, I haven't done the +# necessary refactoring to account for the overlap in code between the +# two modules, mainly because a number of subtle details changed in the +# cut 'n paste. Sigh. +from __future__ import annotations + +import os +from collections.abc import Callable +from distutils._log import log +from typing import ClassVar + +from ..ccompiler import new_compiler, show_compilers +from ..core import Command +from ..errors import DistutilsSetupError +from ..sysconfig import customize_compiler + + +class build_clib(Command): + description = "build C/C++ libraries used by Python extensions" + + user_options: ClassVar[list[tuple[str, str, str]]] = [ + ('build-clib=', 'b', "directory to build C/C++ libraries to"), + ('build-temp=', 't', "directory to put temporary build by-products"), + ('debug', 'g', "compile with debugging information"), + ('force', 'f', "forcibly build everything (ignore file timestamps)"), + ('compiler=', 'c', "specify the compiler type"), + ] + + boolean_options: ClassVar[list[str]] = ['debug', 'force'] + + help_options: ClassVar[list[tuple[str, str | None, str, Callable[[], object]]]] = [ + ('help-compiler', None, "list available compilers", show_compilers), + ] + + def initialize_options(self): + self.build_clib = None + self.build_temp = None + + # List of libraries to build + self.libraries = None + + # Compilation options for all libraries + self.include_dirs = None + self.define = None + self.undef = None + self.debug = None + self.force = False + self.compiler = None + + def finalize_options(self) -> None: + # This might be confusing: both build-clib and build-temp default + # to build-temp as defined by the "build" command. This is because + # I think that C libraries are really just temporary build + # by-products, at least from the point of view of building Python + # extensions -- but I want to keep my options open. + self.set_undefined_options( + 'build', + ('build_temp', 'build_clib'), + ('build_temp', 'build_temp'), + ('compiler', 'compiler'), + ('debug', 'debug'), + ('force', 'force'), + ) + + self.libraries = self.distribution.libraries + if self.libraries: + self.check_library_list(self.libraries) + + if self.include_dirs is None: + self.include_dirs = self.distribution.include_dirs or [] + if isinstance(self.include_dirs, str): + self.include_dirs = self.include_dirs.split(os.pathsep) + + # XXX same as for build_ext -- what about 'self.define' and + # 'self.undef' ? + + def run(self) -> None: + if not self.libraries: + return + + self.compiler = new_compiler(compiler=self.compiler, force=self.force) + customize_compiler(self.compiler) + + if self.include_dirs is not None: + self.compiler.set_include_dirs(self.include_dirs) + if self.define is not None: + # 'define' option is a list of (name,value) tuples + for name, value in self.define: + self.compiler.define_macro(name, value) + if self.undef is not None: + for macro in self.undef: + self.compiler.undefine_macro(macro) + + self.build_libraries(self.libraries) + + def check_library_list(self, libraries) -> None: + """Ensure that the list of libraries is valid. + + `library` is presumably provided as a command option 'libraries'. + This method checks that it is a list of 2-tuples, where the tuples + are (library_name, build_info_dict). + + Raise DistutilsSetupError if the structure is invalid anywhere; + just returns otherwise. + """ + if not isinstance(libraries, list): + raise DistutilsSetupError("'libraries' option must be a list of tuples") + + for lib in libraries: + if not isinstance(lib, tuple) and len(lib) != 2: + raise DistutilsSetupError("each element of 'libraries' must a 2-tuple") + + name, build_info = lib + + if not isinstance(name, str): + raise DistutilsSetupError( + "first element of each tuple in 'libraries' " + "must be a string (the library name)" + ) + + if '/' in name or (os.sep != '/' and os.sep in name): + raise DistutilsSetupError( + f"bad library name '{lib[0]}': may not contain directory separators" + ) + + if not isinstance(build_info, dict): + raise DistutilsSetupError( + "second element of each tuple in 'libraries' " + "must be a dictionary (build info)" + ) + + def get_library_names(self): + # Assume the library list is valid -- 'check_library_list()' is + # called from 'finalize_options()', so it should be! + if not self.libraries: + return None + + lib_names = [] + for lib_name, _build_info in self.libraries: + lib_names.append(lib_name) + return lib_names + + def get_source_files(self): + self.check_library_list(self.libraries) + filenames = [] + for lib_name, build_info in self.libraries: + sources = build_info.get('sources') + if sources is None or not isinstance(sources, (list, tuple)): + raise DistutilsSetupError( + f"in 'libraries' option (library '{lib_name}'), " + "'sources' must be present and must be " + "a list of source filenames" + ) + + filenames.extend(sources) + return filenames + + def build_libraries(self, libraries) -> None: + for lib_name, build_info in libraries: + sources = build_info.get('sources') + if sources is None or not isinstance(sources, (list, tuple)): + raise DistutilsSetupError( + f"in 'libraries' option (library '{lib_name}'), " + "'sources' must be present and must be " + "a list of source filenames" + ) + sources = list(sources) + + log.info("building '%s' library", lib_name) + + # First, compile the source code to object files in the library + # directory. (This should probably change to putting object + # files in a temporary build directory.) + macros = build_info.get('macros') + include_dirs = build_info.get('include_dirs') + objects = self.compiler.compile( + sources, + output_dir=self.build_temp, + macros=macros, + include_dirs=include_dirs, + debug=self.debug, + ) + + # Now "link" the object files together into a static library. + # (On Unix at least, this isn't really linking -- it just + # builds an archive. Whatever.) + self.compiler.create_static_lib( + objects, lib_name, output_dir=self.build_clib, debug=self.debug + ) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/build_ext.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/build_ext.py new file mode 100644 index 0000000000000000000000000000000000000000..df623d7e0ef2f667bfce329283256513621eacf7 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/build_ext.py @@ -0,0 +1,811 @@ +"""distutils.command.build_ext + +Implements the Distutils 'build_ext' command, for building extension +modules (currently limited to C extensions, should accommodate C++ +extensions ASAP).""" + +from __future__ import annotations + +import contextlib +import os +import re +import sys +from collections.abc import Callable +from distutils._log import log +from site import USER_BASE +from typing import ClassVar + +from .._modified import newer_group +from ..ccompiler import new_compiler, show_compilers +from ..core import Command +from ..errors import ( + CCompilerError, + CompileError, + DistutilsError, + DistutilsOptionError, + DistutilsPlatformError, + DistutilsSetupError, +) +from ..extension import Extension +from ..sysconfig import customize_compiler, get_config_h_filename, get_python_version +from ..util import get_platform, is_freethreaded, is_mingw + +# An extension name is just a dot-separated list of Python NAMEs (ie. +# the same as a fully-qualified module name). +extension_name_re = re.compile(r'^[a-zA-Z_][a-zA-Z_0-9]*(\.[a-zA-Z_][a-zA-Z_0-9]*)*$') + + +class build_ext(Command): + description = "build C/C++ extensions (compile/link to build directory)" + + # XXX thoughts on how to deal with complex command-line options like + # these, i.e. how to make it so fancy_getopt can suck them off the + # command line and make it look like setup.py defined the appropriate + # lists of tuples of what-have-you. + # - each command needs a callback to process its command-line options + # - Command.__init__() needs access to its share of the whole + # command line (must ultimately come from + # Distribution.parse_command_line()) + # - it then calls the current command class' option-parsing + # callback to deal with weird options like -D, which have to + # parse the option text and churn out some custom data + # structure + # - that data structure (in this case, a list of 2-tuples) + # will then be present in the command object by the time + # we get to finalize_options() (i.e. the constructor + # takes care of both command-line and client options + # in between initialize_options() and finalize_options()) + + sep_by = f" (separated by '{os.pathsep}')" + user_options = [ + ('build-lib=', 'b', "directory for compiled extension modules"), + ('build-temp=', 't', "directory for temporary files (build by-products)"), + ( + 'plat-name=', + 'p', + "platform name to cross-compile for, if supported " + f"[default: {get_platform()}]", + ), + ( + 'inplace', + 'i', + "ignore build-lib and put compiled extensions into the source " + "directory alongside your pure Python modules", + ), + ( + 'include-dirs=', + 'I', + "list of directories to search for header files" + sep_by, + ), + ('define=', 'D', "C preprocessor macros to define"), + ('undef=', 'U', "C preprocessor macros to undefine"), + ('libraries=', 'l', "external C libraries to link with"), + ( + 'library-dirs=', + 'L', + "directories to search for external C libraries" + sep_by, + ), + ('rpath=', 'R', "directories to search for shared C libraries at runtime"), + ('link-objects=', 'O', "extra explicit link objects to include in the link"), + ('debug', 'g', "compile/link with debugging information"), + ('force', 'f', "forcibly build everything (ignore file timestamps)"), + ('compiler=', 'c', "specify the compiler type"), + ('parallel=', 'j', "number of parallel build jobs"), + ('swig-cpp', None, "make SWIG create C++ files (default is C)"), + ('swig-opts=', None, "list of SWIG command line options"), + ('swig=', None, "path to the SWIG executable"), + ('user', None, "add user include, library and rpath"), + ] + + boolean_options: ClassVar[list[str]] = [ + 'inplace', + 'debug', + 'force', + 'swig-cpp', + 'user', + ] + + help_options: ClassVar[list[tuple[str, str | None, str, Callable[[], object]]]] = [ + ('help-compiler', None, "list available compilers", show_compilers), + ] + + def initialize_options(self): + self.extensions = None + self.build_lib = None + self.plat_name = None + self.build_temp = None + self.inplace = False + self.package = None + + self.include_dirs = None + self.define = None + self.undef = None + self.libraries = None + self.library_dirs = None + self.rpath = None + self.link_objects = None + self.debug = None + self.force = None + self.compiler = None + self.swig = None + self.swig_cpp = None + self.swig_opts = None + self.user = None + self.parallel = None + + @staticmethod + def _python_lib_dir(sysconfig): + """ + Resolve Python's library directory for building extensions + that rely on a shared Python library. + + See python/cpython#44264 and python/cpython#48686 + """ + if not sysconfig.get_config_var('Py_ENABLE_SHARED'): + return + + if sysconfig.python_build: + yield '.' + return + + if sys.platform == 'zos': + # On z/OS, a user is not required to install Python to + # a predetermined path, but can use Python portably + installed_dir = sysconfig.get_config_var('base') + lib_dir = sysconfig.get_config_var('platlibdir') + yield os.path.join(installed_dir, lib_dir) + else: + # building third party extensions + yield sysconfig.get_config_var('LIBDIR') + + def finalize_options(self) -> None: # noqa: C901 + from distutils import sysconfig + + self.set_undefined_options( + 'build', + ('build_lib', 'build_lib'), + ('build_temp', 'build_temp'), + ('compiler', 'compiler'), + ('debug', 'debug'), + ('force', 'force'), + ('parallel', 'parallel'), + ('plat_name', 'plat_name'), + ) + + if self.package is None: + self.package = self.distribution.ext_package + + self.extensions = self.distribution.ext_modules + + # Make sure Python's include directories (for Python.h, pyconfig.h, + # etc.) are in the include search path. + py_include = sysconfig.get_python_inc() + plat_py_include = sysconfig.get_python_inc(plat_specific=True) + if self.include_dirs is None: + self.include_dirs = self.distribution.include_dirs or [] + if isinstance(self.include_dirs, str): + self.include_dirs = self.include_dirs.split(os.pathsep) + + # If in a virtualenv, add its include directory + # Issue 16116 + if sys.exec_prefix != sys.base_exec_prefix: + self.include_dirs.append(os.path.join(sys.exec_prefix, 'include')) + + # Put the Python "system" include dir at the end, so that + # any local include dirs take precedence. + self.include_dirs.extend(py_include.split(os.path.pathsep)) + if plat_py_include != py_include: + self.include_dirs.extend(plat_py_include.split(os.path.pathsep)) + + self.ensure_string_list('libraries') + self.ensure_string_list('link_objects') + + # Life is easier if we're not forever checking for None, so + # simplify these options to empty lists if unset + if self.libraries is None: + self.libraries = [] + if self.library_dirs is None: + self.library_dirs = [] + elif isinstance(self.library_dirs, str): + self.library_dirs = self.library_dirs.split(os.pathsep) + + if self.rpath is None: + self.rpath = [] + elif isinstance(self.rpath, str): + self.rpath = self.rpath.split(os.pathsep) + + # for extensions under windows use different directories + # for Release and Debug builds. + # also Python's library directory must be appended to library_dirs + if os.name == 'nt' and not is_mingw(): + # the 'libs' directory is for binary installs - we assume that + # must be the *native* platform. But we don't really support + # cross-compiling via a binary install anyway, so we let it go. + self.library_dirs.append(os.path.join(sys.exec_prefix, 'libs')) + if sys.base_exec_prefix != sys.prefix: # Issue 16116 + self.library_dirs.append(os.path.join(sys.base_exec_prefix, 'libs')) + if self.debug: + self.build_temp = os.path.join(self.build_temp, "Debug") + else: + self.build_temp = os.path.join(self.build_temp, "Release") + + # Append the source distribution include and library directories, + # this allows distutils on windows to work in the source tree + self.include_dirs.append(os.path.dirname(get_config_h_filename())) + self.library_dirs.append(sys.base_exec_prefix) + + # Use the .lib files for the correct architecture + if self.plat_name == 'win32': + suffix = 'win32' + else: + # win-amd64 + suffix = self.plat_name[4:] + new_lib = os.path.join(sys.exec_prefix, 'PCbuild') + if suffix: + new_lib = os.path.join(new_lib, suffix) + self.library_dirs.append(new_lib) + + # For extensions under Cygwin, Python's library directory must be + # appended to library_dirs + if sys.platform[:6] == 'cygwin': + if not sysconfig.python_build: + # building third party extensions + self.library_dirs.append( + os.path.join( + sys.prefix, "lib", "python" + get_python_version(), "config" + ) + ) + else: + # building python standard extensions + self.library_dirs.append('.') + + self.library_dirs.extend(self._python_lib_dir(sysconfig)) + + # The argument parsing will result in self.define being a string, but + # it has to be a list of 2-tuples. All the preprocessor symbols + # specified by the 'define' option will be set to '1'. Multiple + # symbols can be separated with commas. + + if self.define: + defines = self.define.split(',') + self.define = [(symbol, '1') for symbol in defines] + + # The option for macros to undefine is also a string from the + # option parsing, but has to be a list. Multiple symbols can also + # be separated with commas here. + if self.undef: + self.undef = self.undef.split(',') + + if self.swig_opts is None: + self.swig_opts = [] + else: + self.swig_opts = self.swig_opts.split(' ') + + # Finally add the user include and library directories if requested + if self.user: + user_include = os.path.join(USER_BASE, "include") + user_lib = os.path.join(USER_BASE, "lib") + if os.path.isdir(user_include): + self.include_dirs.append(user_include) + if os.path.isdir(user_lib): + self.library_dirs.append(user_lib) + self.rpath.append(user_lib) + + if isinstance(self.parallel, str): + try: + self.parallel = int(self.parallel) + except ValueError: + raise DistutilsOptionError("parallel should be an integer") + + def run(self) -> None: # noqa: C901 + # 'self.extensions', as supplied by setup.py, is a list of + # Extension instances. See the documentation for Extension (in + # distutils.extension) for details. + # + # For backwards compatibility with Distutils 0.8.2 and earlier, we + # also allow the 'extensions' list to be a list of tuples: + # (ext_name, build_info) + # where build_info is a dictionary containing everything that + # Extension instances do except the name, with a few things being + # differently named. We convert these 2-tuples to Extension + # instances as needed. + + if not self.extensions: + return + + # If we were asked to build any C/C++ libraries, make sure that the + # directory where we put them is in the library search path for + # linking extensions. + if self.distribution.has_c_libraries(): + build_clib = self.get_finalized_command('build_clib') + self.libraries.extend(build_clib.get_library_names() or []) + self.library_dirs.append(build_clib.build_clib) + + # Setup the CCompiler object that we'll use to do all the + # compiling and linking + self.compiler = new_compiler( + compiler=self.compiler, + verbose=self.verbose, + force=self.force, + ) + customize_compiler(self.compiler) + # If we are cross-compiling, init the compiler now (if we are not + # cross-compiling, init would not hurt, but people may rely on + # late initialization of compiler even if they shouldn't...) + if os.name == 'nt' and self.plat_name != get_platform(): + self.compiler.initialize(self.plat_name) + + # The official Windows free threaded Python installer doesn't set + # Py_GIL_DISABLED because its pyconfig.h is shared with the + # default build, so define it here (pypa/setuptools#4662). + if os.name == 'nt' and is_freethreaded(): + self.compiler.define_macro('Py_GIL_DISABLED', '1') + + # And make sure that any compile/link-related options (which might + # come from the command-line or from the setup script) are set in + # that CCompiler object -- that way, they automatically apply to + # all compiling and linking done here. + if self.include_dirs is not None: + self.compiler.set_include_dirs(self.include_dirs) + if self.define is not None: + # 'define' option is a list of (name,value) tuples + for name, value in self.define: + self.compiler.define_macro(name, value) + if self.undef is not None: + for macro in self.undef: + self.compiler.undefine_macro(macro) + if self.libraries is not None: + self.compiler.set_libraries(self.libraries) + if self.library_dirs is not None: + self.compiler.set_library_dirs(self.library_dirs) + if self.rpath is not None: + self.compiler.set_runtime_library_dirs(self.rpath) + if self.link_objects is not None: + self.compiler.set_link_objects(self.link_objects) + + # Now actually compile and link everything. + self.build_extensions() + + def check_extensions_list(self, extensions) -> None: # noqa: C901 + """Ensure that the list of extensions (presumably provided as a + command option 'extensions') is valid, i.e. it is a list of + Extension objects. We also support the old-style list of 2-tuples, + where the tuples are (ext_name, build_info), which are converted to + Extension instances here. + + Raise DistutilsSetupError if the structure is invalid anywhere; + just returns otherwise. + """ + if not isinstance(extensions, list): + raise DistutilsSetupError( + "'ext_modules' option must be a list of Extension instances" + ) + + for i, ext in enumerate(extensions): + if isinstance(ext, Extension): + continue # OK! (assume type-checking done + # by Extension constructor) + + if not isinstance(ext, tuple) or len(ext) != 2: + raise DistutilsSetupError( + "each element of 'ext_modules' option must be an " + "Extension instance or 2-tuple" + ) + + ext_name, build_info = ext + + log.warning( + "old-style (ext_name, build_info) tuple found in " + "ext_modules for extension '%s' " + "-- please convert to Extension instance", + ext_name, + ) + + if not (isinstance(ext_name, str) and extension_name_re.match(ext_name)): + raise DistutilsSetupError( + "first element of each tuple in 'ext_modules' " + "must be the extension name (a string)" + ) + + if not isinstance(build_info, dict): + raise DistutilsSetupError( + "second element of each tuple in 'ext_modules' " + "must be a dictionary (build info)" + ) + + # OK, the (ext_name, build_info) dict is type-safe: convert it + # to an Extension instance. + ext = Extension(ext_name, build_info['sources']) + + # Easy stuff: one-to-one mapping from dict elements to + # instance attributes. + for key in ( + 'include_dirs', + 'library_dirs', + 'libraries', + 'extra_objects', + 'extra_compile_args', + 'extra_link_args', + ): + val = build_info.get(key) + if val is not None: + setattr(ext, key, val) + + # Medium-easy stuff: same syntax/semantics, different names. + ext.runtime_library_dirs = build_info.get('rpath') + if 'def_file' in build_info: + log.warning("'def_file' element of build info dict no longer supported") + + # Non-trivial stuff: 'macros' split into 'define_macros' + # and 'undef_macros'. + macros = build_info.get('macros') + if macros: + ext.define_macros = [] + ext.undef_macros = [] + for macro in macros: + if not (isinstance(macro, tuple) and len(macro) in (1, 2)): + raise DistutilsSetupError( + "'macros' element of build info dict must be 1- or 2-tuple" + ) + if len(macro) == 1: + ext.undef_macros.append(macro[0]) + elif len(macro) == 2: + ext.define_macros.append(macro) + + extensions[i] = ext + + def get_source_files(self): + self.check_extensions_list(self.extensions) + filenames = [] + + # Wouldn't it be neat if we knew the names of header files too... + for ext in self.extensions: + filenames.extend(ext.sources) + return filenames + + def get_outputs(self): + # Sanity check the 'extensions' list -- can't assume this is being + # done in the same run as a 'build_extensions()' call (in fact, we + # can probably assume that it *isn't*!). + self.check_extensions_list(self.extensions) + + # And build the list of output (built) filenames. Note that this + # ignores the 'inplace' flag, and assumes everything goes in the + # "build" tree. + return [self.get_ext_fullpath(ext.name) for ext in self.extensions] + + def build_extensions(self) -> None: + # First, sanity-check the 'extensions' list + self.check_extensions_list(self.extensions) + if self.parallel: + self._build_extensions_parallel() + else: + self._build_extensions_serial() + + def _build_extensions_parallel(self): + workers = self.parallel + if self.parallel is True: + workers = os.cpu_count() # may return None + try: + from concurrent.futures import ThreadPoolExecutor + except ImportError: + workers = None + + if workers is None: + self._build_extensions_serial() + return + + with ThreadPoolExecutor(max_workers=workers) as executor: + futures = [ + executor.submit(self.build_extension, ext) for ext in self.extensions + ] + for ext, fut in zip(self.extensions, futures): + with self._filter_build_errors(ext): + fut.result() + + def _build_extensions_serial(self): + for ext in self.extensions: + with self._filter_build_errors(ext): + self.build_extension(ext) + + @contextlib.contextmanager + def _filter_build_errors(self, ext): + try: + yield + except (CCompilerError, DistutilsError, CompileError) as e: + if not ext.optional: + raise + self.warn(f'building extension "{ext.name}" failed: {e}') + + def build_extension(self, ext) -> None: + sources = ext.sources + if sources is None or not isinstance(sources, (list, tuple)): + raise DistutilsSetupError( + f"in 'ext_modules' option (extension '{ext.name}'), " + "'sources' must be present and must be " + "a list of source filenames" + ) + # sort to make the resulting .so file build reproducible + sources = sorted(sources) + + ext_path = self.get_ext_fullpath(ext.name) + depends = sources + ext.depends + if not (self.force or newer_group(depends, ext_path, 'newer')): + log.debug("skipping '%s' extension (up-to-date)", ext.name) + return + else: + log.info("building '%s' extension", ext.name) + + # First, scan the sources for SWIG definition files (.i), run + # SWIG on 'em to create .c files, and modify the sources list + # accordingly. + sources = self.swig_sources(sources, ext) + + # Next, compile the source code to object files. + + # XXX not honouring 'define_macros' or 'undef_macros' -- the + # CCompiler API needs to change to accommodate this, and I + # want to do one thing at a time! + + # Two possible sources for extra compiler arguments: + # - 'extra_compile_args' in Extension object + # - CFLAGS environment variable (not particularly + # elegant, but people seem to expect it and I + # guess it's useful) + # The environment variable should take precedence, and + # any sensible compiler will give precedence to later + # command line args. Hence we combine them in order: + extra_args = ext.extra_compile_args or [] + + macros = ext.define_macros[:] + for undef in ext.undef_macros: + macros.append((undef,)) + + objects = self.compiler.compile( + sources, + output_dir=self.build_temp, + macros=macros, + include_dirs=ext.include_dirs, + debug=self.debug, + extra_postargs=extra_args, + depends=ext.depends, + ) + + # XXX outdated variable, kept here in case third-part code + # needs it. + self._built_objects = objects[:] + + # Now link the object files together into a "shared object" -- + # of course, first we have to figure out all the other things + # that go into the mix. + if ext.extra_objects: + objects.extend(ext.extra_objects) + extra_args = ext.extra_link_args or [] + + # Detect target language, if not provided + language = ext.language or self.compiler.detect_language(sources) + + self.compiler.link_shared_object( + objects, + ext_path, + libraries=self.get_libraries(ext), + library_dirs=ext.library_dirs, + runtime_library_dirs=ext.runtime_library_dirs, + extra_postargs=extra_args, + export_symbols=self.get_export_symbols(ext), + debug=self.debug, + build_temp=self.build_temp, + target_lang=language, + ) + + def swig_sources(self, sources, extension): + """Walk the list of source files in 'sources', looking for SWIG + interface (.i) files. Run SWIG on all that are found, and + return a modified 'sources' list with SWIG source files replaced + by the generated C (or C++) files. + """ + new_sources = [] + swig_sources = [] + swig_targets = {} + + # XXX this drops generated C/C++ files into the source tree, which + # is fine for developers who want to distribute the generated + # source -- but there should be an option to put SWIG output in + # the temp dir. + + if self.swig_cpp: + log.warning("--swig-cpp is deprecated - use --swig-opts=-c++") + + if ( + self.swig_cpp + or ('-c++' in self.swig_opts) + or ('-c++' in extension.swig_opts) + ): + target_ext = '.cpp' + else: + target_ext = '.c' + + for source in sources: + (base, ext) = os.path.splitext(source) + if ext == ".i": # SWIG interface file + new_sources.append(base + '_wrap' + target_ext) + swig_sources.append(source) + swig_targets[source] = new_sources[-1] + else: + new_sources.append(source) + + if not swig_sources: + return new_sources + + swig = self.swig or self.find_swig() + swig_cmd = [swig, "-python"] + swig_cmd.extend(self.swig_opts) + if self.swig_cpp: + swig_cmd.append("-c++") + + # Do not override commandline arguments + if not self.swig_opts: + swig_cmd.extend(extension.swig_opts) + + for source in swig_sources: + target = swig_targets[source] + log.info("swigging %s to %s", source, target) + self.spawn(swig_cmd + ["-o", target, source]) + + return new_sources + + def find_swig(self): + """Return the name of the SWIG executable. On Unix, this is + just "swig" -- it should be in the PATH. Tries a bit harder on + Windows. + """ + if os.name == "posix": + return "swig" + elif os.name == "nt": + # Look for SWIG in its standard installation directory on + # Windows (or so I presume!). If we find it there, great; + # if not, act like Unix and assume it's in the PATH. + for vers in ("1.3", "1.2", "1.1"): + fn = os.path.join(f"c:\\swig{vers}", "swig.exe") + if os.path.isfile(fn): + return fn + else: + return "swig.exe" + else: + raise DistutilsPlatformError( + f"I don't know how to find (much less run) SWIG on platform '{os.name}'" + ) + + # -- Name generators ----------------------------------------------- + # (extension names, filenames, whatever) + def get_ext_fullpath(self, ext_name: str) -> str: + """Returns the path of the filename for a given extension. + + The file is located in `build_lib` or directly in the package + (inplace option). + """ + fullname = self.get_ext_fullname(ext_name) + modpath = fullname.split('.') + filename = self.get_ext_filename(modpath[-1]) + + if not self.inplace: + # no further work needed + # returning : + # build_dir/package/path/filename + filename = os.path.join(*modpath[:-1] + [filename]) + return os.path.join(self.build_lib, filename) + + # the inplace option requires to find the package directory + # using the build_py command for that + package = '.'.join(modpath[0:-1]) + build_py = self.get_finalized_command('build_py') + package_dir = os.path.abspath(build_py.get_package_dir(package)) + + # returning + # package_dir/filename + return os.path.join(package_dir, filename) + + def get_ext_fullname(self, ext_name: str) -> str: + """Returns the fullname of a given extension name. + + Adds the `package.` prefix""" + if self.package is None: + return ext_name + else: + return self.package + '.' + ext_name + + def get_ext_filename(self, ext_name: str) -> str: + r"""Convert the name of an extension (eg. "foo.bar") into the name + of the file from which it will be loaded (eg. "foo/bar.so", or + "foo\bar.pyd"). + """ + from ..sysconfig import get_config_var + + ext_path = ext_name.split('.') + ext_suffix = get_config_var('EXT_SUFFIX') + return os.path.join(*ext_path) + ext_suffix + + def get_export_symbols(self, ext: Extension) -> list[str]: + """Return the list of symbols that a shared extension has to + export. This either uses 'ext.export_symbols' or, if it's not + provided, "PyInit_" + module_name. Only relevant on Windows, where + the .pyd file (DLL) must export the module "PyInit_" function. + """ + name = self._get_module_name_for_symbol(ext) + try: + # Unicode module name support as defined in PEP-489 + # https://peps.python.org/pep-0489/#export-hook-name + name.encode('ascii') + except UnicodeEncodeError: + suffix = 'U_' + name.encode('punycode').replace(b'-', b'_').decode('ascii') + else: + suffix = "_" + name + + initfunc_name = "PyInit" + suffix + if initfunc_name not in ext.export_symbols: + ext.export_symbols.append(initfunc_name) + return ext.export_symbols + + def _get_module_name_for_symbol(self, ext): + # Package name should be used for `__init__` modules + # https://github.com/python/cpython/issues/80074 + # https://github.com/pypa/setuptools/issues/4826 + parts = ext.name.split(".") + if parts[-1] == "__init__" and len(parts) >= 2: + return parts[-2] + return parts[-1] + + def get_libraries(self, ext: Extension) -> list[str]: # noqa: C901 + """Return the list of libraries to link against when building a + shared extension. On most platforms, this is just 'ext.libraries'; + on Windows, we add the Python library (eg. python20.dll). + """ + # The python library is always needed on Windows. For MSVC, this + # is redundant, since the library is mentioned in a pragma in + # pyconfig.h that MSVC groks. The other Windows compilers all seem + # to need it mentioned explicitly, though, so that's what we do. + # Append '_d' to the python import library on debug builds. + if sys.platform == "win32" and not is_mingw(): + from .._msvccompiler import MSVCCompiler + + if not isinstance(self.compiler, MSVCCompiler): + template = "python%d%d" + if self.debug: + template = template + '_d' + pythonlib = template % ( + sys.hexversion >> 24, + (sys.hexversion >> 16) & 0xFF, + ) + # don't extend ext.libraries, it may be shared with other + # extensions, it is a reference to the original list + return ext.libraries + [pythonlib] + else: + # On Android only the main executable and LD_PRELOADs are considered + # to be RTLD_GLOBAL, all the dependencies of the main executable + # remain RTLD_LOCAL and so the shared libraries must be linked with + # libpython when python is built with a shared python library (issue + # bpo-21536). + # On Cygwin (and if required, other POSIX-like platforms based on + # Windows like MinGW) it is simply necessary that all symbols in + # shared libraries are resolved at link time. + from ..sysconfig import get_config_var + + link_libpython = False + if get_config_var('Py_ENABLE_SHARED'): + # A native build on an Android device or on Cygwin + if hasattr(sys, 'getandroidapilevel'): + link_libpython = True + elif sys.platform == 'cygwin' or is_mingw(): + link_libpython = True + elif '_PYTHON_HOST_PLATFORM' in os.environ: + # We are cross-compiling for one of the relevant platforms + if get_config_var('ANDROID_API_LEVEL') != 0: + link_libpython = True + elif get_config_var('MACHDEP') == 'cygwin': + link_libpython = True + + if link_libpython: + ldversion = get_config_var('LDVERSION') + return ext.libraries + ['python' + ldversion] + + return ext.libraries diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/build_py.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/build_py.py new file mode 100644 index 0000000000000000000000000000000000000000..d6ec7d10d2a807e02f1856fcacf488057ec69081 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/build_py.py @@ -0,0 +1,404 @@ +"""distutils.command.build_py + +Implements the Distutils 'build_py' command.""" + +import glob +import importlib.util +import os +import sys +from distutils._log import log +from typing import ClassVar + +from ..core import Command +from ..errors import DistutilsFileError, DistutilsOptionError +from ..util import convert_path + + +class build_py(Command): + description = "\"build\" pure Python modules (copy to build directory)" + + user_options = [ + ('build-lib=', 'd', "directory to \"build\" (copy) to"), + ('compile', 'c', "compile .py to .pyc"), + ('no-compile', None, "don't compile .py files [default]"), + ( + 'optimize=', + 'O', + "also compile with optimization: -O1 for \"python -O\", " + "-O2 for \"python -OO\", and -O0 to disable [default: -O0]", + ), + ('force', 'f', "forcibly build everything (ignore file timestamps)"), + ] + + boolean_options: ClassVar[list[str]] = ['compile', 'force'] + negative_opt: ClassVar[dict[str, str]] = {'no-compile': 'compile'} + + def initialize_options(self): + self.build_lib = None + self.py_modules = None + self.package = None + self.package_data = None + self.package_dir = None + self.compile = False + self.optimize = 0 + self.force = None + + def finalize_options(self) -> None: + self.set_undefined_options( + 'build', ('build_lib', 'build_lib'), ('force', 'force') + ) + + # Get the distribution options that are aliases for build_py + # options -- list of packages and list of modules. + self.packages = self.distribution.packages + self.py_modules = self.distribution.py_modules + self.package_data = self.distribution.package_data + self.package_dir = {} + if self.distribution.package_dir: + for name, path in self.distribution.package_dir.items(): + self.package_dir[name] = convert_path(path) + self.data_files = self.get_data_files() + + # Ick, copied straight from install_lib.py (fancy_getopt needs a + # type system! Hell, *everything* needs a type system!!!) + if not isinstance(self.optimize, int): + try: + self.optimize = int(self.optimize) + assert 0 <= self.optimize <= 2 + except (ValueError, AssertionError): + raise DistutilsOptionError("optimize must be 0, 1, or 2") + + def run(self) -> None: + # XXX copy_file by default preserves atime and mtime. IMHO this is + # the right thing to do, but perhaps it should be an option -- in + # particular, a site administrator might want installed files to + # reflect the time of installation rather than the last + # modification time before the installed release. + + # XXX copy_file by default preserves mode, which appears to be the + # wrong thing to do: if a file is read-only in the working + # directory, we want it to be installed read/write so that the next + # installation of the same module distribution can overwrite it + # without problems. (This might be a Unix-specific issue.) Thus + # we turn off 'preserve_mode' when copying to the build directory, + # since the build directory is supposed to be exactly what the + # installation will look like (ie. we preserve mode when + # installing). + + # Two options control which modules will be installed: 'packages' + # and 'py_modules'. The former lets us work with whole packages, not + # specifying individual modules at all; the latter is for + # specifying modules one-at-a-time. + + if self.py_modules: + self.build_modules() + if self.packages: + self.build_packages() + self.build_package_data() + + self.byte_compile(self.get_outputs(include_bytecode=False)) + + def get_data_files(self): + """Generate list of '(package,src_dir,build_dir,filenames)' tuples""" + data = [] + if not self.packages: + return data + for package in self.packages: + # Locate package source directory + src_dir = self.get_package_dir(package) + + # Compute package build directory + build_dir = os.path.join(*([self.build_lib] + package.split('.'))) + + # Length of path to strip from found files + plen = 0 + if src_dir: + plen = len(src_dir) + 1 + + # Strip directory from globbed filenames + filenames = [file[plen:] for file in self.find_data_files(package, src_dir)] + data.append((package, src_dir, build_dir, filenames)) + return data + + def find_data_files(self, package, src_dir): + """Return filenames for package's data files in 'src_dir'""" + globs = self.package_data.get('', []) + self.package_data.get(package, []) + files = [] + for pattern in globs: + # Each pattern has to be converted to a platform-specific path + filelist = glob.glob( + os.path.join(glob.escape(src_dir), convert_path(pattern)) + ) + # Files that match more than one pattern are only added once + files.extend([ + fn for fn in filelist if fn not in files and os.path.isfile(fn) + ]) + return files + + def build_package_data(self) -> None: + """Copy data files into build directory""" + for _package, src_dir, build_dir, filenames in self.data_files: + for filename in filenames: + target = os.path.join(build_dir, filename) + self.mkpath(os.path.dirname(target)) + self.copy_file( + os.path.join(src_dir, filename), target, preserve_mode=False + ) + + def get_package_dir(self, package): + """Return the directory, relative to the top of the source + distribution, where package 'package' should be found + (at least according to the 'package_dir' option, if any).""" + path = package.split('.') + + if not self.package_dir: + if path: + return os.path.join(*path) + else: + return '' + else: + tail = [] + while path: + try: + pdir = self.package_dir['.'.join(path)] + except KeyError: + tail.insert(0, path[-1]) + del path[-1] + else: + tail.insert(0, pdir) + return os.path.join(*tail) + else: + # Oops, got all the way through 'path' without finding a + # match in package_dir. If package_dir defines a directory + # for the root (nameless) package, then fallback on it; + # otherwise, we might as well have not consulted + # package_dir at all, as we just use the directory implied + # by 'tail' (which should be the same as the original value + # of 'path' at this point). + pdir = self.package_dir.get('') + if pdir is not None: + tail.insert(0, pdir) + + if tail: + return os.path.join(*tail) + else: + return '' + + def check_package(self, package, package_dir): + # Empty dir name means current directory, which we can probably + # assume exists. Also, os.path.exists and isdir don't know about + # my "empty string means current dir" convention, so we have to + # circumvent them. + if package_dir != "": + if not os.path.exists(package_dir): + raise DistutilsFileError( + f"package directory '{package_dir}' does not exist" + ) + if not os.path.isdir(package_dir): + raise DistutilsFileError( + f"supposed package directory '{package_dir}' exists, " + "but is not a directory" + ) + + # Directories without __init__.py are namespace packages (PEP 420). + if package: + init_py = os.path.join(package_dir, "__init__.py") + if os.path.isfile(init_py): + return init_py + + # Either not in a package at all (__init__.py not expected), or + # __init__.py doesn't exist -- so don't return the filename. + return None + + def check_module(self, module, module_file): + if not os.path.isfile(module_file): + log.warning("file %s (for module %s) not found", module_file, module) + return False + else: + return True + + def find_package_modules(self, package, package_dir): + self.check_package(package, package_dir) + module_files = glob.glob(os.path.join(glob.escape(package_dir), "*.py")) + modules = [] + setup_script = os.path.abspath(self.distribution.script_name) + + for f in module_files: + abs_f = os.path.abspath(f) + if abs_f != setup_script: + module = os.path.splitext(os.path.basename(f))[0] + modules.append((package, module, f)) + else: + self.debug_print(f"excluding {setup_script}") + return modules + + def find_modules(self): + """Finds individually-specified Python modules, ie. those listed by + module name in 'self.py_modules'. Returns a list of tuples (package, + module_base, filename): 'package' is a tuple of the path through + package-space to the module; 'module_base' is the bare (no + packages, no dots) module name, and 'filename' is the path to the + ".py" file (relative to the distribution root) that implements the + module. + """ + # Map package names to tuples of useful info about the package: + # (package_dir, checked) + # package_dir - the directory where we'll find source files for + # this package + # checked - true if we have checked that the package directory + # is valid (exists, contains __init__.py, ... ?) + packages = {} + + # List of (package, module, filename) tuples to return + modules = [] + + # We treat modules-in-packages almost the same as toplevel modules, + # just the "package" for a toplevel is empty (either an empty + # string or empty list, depending on context). Differences: + # - don't check for __init__.py in directory for empty package + for module in self.py_modules: + path = module.split('.') + package = '.'.join(path[0:-1]) + module_base = path[-1] + + try: + (package_dir, checked) = packages[package] + except KeyError: + package_dir = self.get_package_dir(package) + checked = False + + if not checked: + init_py = self.check_package(package, package_dir) + packages[package] = (package_dir, 1) + if init_py: + modules.append((package, "__init__", init_py)) + + # XXX perhaps we should also check for just .pyc files + # (so greedy closed-source bastards can distribute Python + # modules too) + module_file = os.path.join(package_dir, module_base + ".py") + if not self.check_module(module, module_file): + continue + + modules.append((package, module_base, module_file)) + + return modules + + def find_all_modules(self): + """Compute the list of all modules that will be built, whether + they are specified one-module-at-a-time ('self.py_modules') or + by whole packages ('self.packages'). Return a list of tuples + (package, module, module_file), just like 'find_modules()' and + 'find_package_modules()' do.""" + modules = [] + if self.py_modules: + modules.extend(self.find_modules()) + if self.packages: + for package in self.packages: + package_dir = self.get_package_dir(package) + m = self.find_package_modules(package, package_dir) + modules.extend(m) + return modules + + def get_source_files(self): + return [module[-1] for module in self.find_all_modules()] + + def get_module_outfile(self, build_dir, package, module): + outfile_path = [build_dir] + list(package) + [module + ".py"] + return os.path.join(*outfile_path) + + def get_outputs(self, include_bytecode: bool = True) -> list[str]: + modules = self.find_all_modules() + outputs = [] + for package, module, _module_file in modules: + package = package.split('.') + filename = self.get_module_outfile(self.build_lib, package, module) + outputs.append(filename) + if include_bytecode: + if self.compile: + outputs.append( + importlib.util.cache_from_source(filename, optimization='') + ) + if self.optimize > 0: + outputs.append( + importlib.util.cache_from_source( + filename, optimization=self.optimize + ) + ) + + outputs += [ + os.path.join(build_dir, filename) + for package, src_dir, build_dir, filenames in self.data_files + for filename in filenames + ] + + return outputs + + def build_module(self, module, module_file, package): + if isinstance(package, str): + package = package.split('.') + elif not isinstance(package, (list, tuple)): + raise TypeError( + "'package' must be a string (dot-separated), list, or tuple" + ) + + # Now put the module source file into the "build" area -- this is + # easy, we just copy it somewhere under self.build_lib (the build + # directory for Python source). + outfile = self.get_module_outfile(self.build_lib, package, module) + dir = os.path.dirname(outfile) + self.mkpath(dir) + return self.copy_file(module_file, outfile, preserve_mode=False) + + def build_modules(self) -> None: + modules = self.find_modules() + for package, module, module_file in modules: + # Now "build" the module -- ie. copy the source file to + # self.build_lib (the build directory for Python source). + # (Actually, it gets copied to the directory for this package + # under self.build_lib.) + self.build_module(module, module_file, package) + + def build_packages(self) -> None: + for package in self.packages: + # Get list of (package, module, module_file) tuples based on + # scanning the package directory. 'package' is only included + # in the tuple so that 'find_modules()' and + # 'find_package_tuples()' have a consistent interface; it's + # ignored here (apart from a sanity check). Also, 'module' is + # the *unqualified* module name (ie. no dots, no package -- we + # already know its package!), and 'module_file' is the path to + # the .py file, relative to the current directory + # (ie. including 'package_dir'). + package_dir = self.get_package_dir(package) + modules = self.find_package_modules(package, package_dir) + + # Now loop over the modules we found, "building" each one (just + # copy it to self.build_lib). + for package_, module, module_file in modules: + assert package == package_ + self.build_module(module, module_file, package) + + def byte_compile(self, files) -> None: + if sys.dont_write_bytecode: + self.warn('byte-compiling is disabled, skipping.') + return + + from ..util import byte_compile + + prefix = self.build_lib + if prefix[-1] != os.sep: + prefix = prefix + os.sep + + # XXX this code is essentially the same as the 'byte_compile() + # method of the "install_lib" command, except for the determination + # of the 'prefix' string. Hmmm. + if self.compile: + byte_compile(files, optimize=0, force=self.force, prefix=prefix) + if self.optimize > 0: + byte_compile( + files, + optimize=self.optimize, + force=self.force, + prefix=prefix, + ) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/build_scripts.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/build_scripts.py new file mode 100644 index 0000000000000000000000000000000000000000..0b551d11be0200b4e9c620d1af387ff7c2752096 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/build_scripts.py @@ -0,0 +1,150 @@ +"""distutils.command.build_scripts + +Implements the Distutils 'build_scripts' command.""" + +import os +import re +import tokenize +from distutils._log import log +from stat import ST_MODE +from typing import ClassVar + +from .._modified import newer +from ..core import Command +from ..util import convert_path + +shebang_pattern = re.compile('^#!.*python[0-9.]*([ \t].*)?$') +""" +Pattern matching a Python interpreter indicated in first line of a script. +""" + +# for Setuptools compatibility +first_line_re = shebang_pattern + + +class build_scripts(Command): + description = "\"build\" scripts (copy and fixup #! line)" + + user_options: ClassVar[list[tuple[str, str, str]]] = [ + ('build-dir=', 'd', "directory to \"build\" (copy) to"), + ('force', 'f', "forcibly build everything (ignore file timestamps"), + ('executable=', 'e', "specify final destination interpreter path"), + ] + + boolean_options: ClassVar[list[str]] = ['force'] + + def initialize_options(self): + self.build_dir = None + self.scripts = None + self.force = None + self.executable = None + + def finalize_options(self): + self.set_undefined_options( + 'build', + ('build_scripts', 'build_dir'), + ('force', 'force'), + ('executable', 'executable'), + ) + self.scripts = self.distribution.scripts + + def get_source_files(self): + return self.scripts + + def run(self): + if not self.scripts: + return + self.copy_scripts() + + def copy_scripts(self): + """ + Copy each script listed in ``self.scripts``. + + If a script is marked as a Python script (first line matches + 'shebang_pattern', i.e. starts with ``#!`` and contains + "python"), then adjust in the copy the first line to refer to + the current Python interpreter. + """ + self.mkpath(self.build_dir) + outfiles = [] + updated_files = [] + for script in self.scripts: + self._copy_script(script, outfiles, updated_files) + + self._change_modes(outfiles) + + return outfiles, updated_files + + def _copy_script(self, script, outfiles, updated_files): + shebang_match = None + script = convert_path(script) + outfile = os.path.join(self.build_dir, os.path.basename(script)) + outfiles.append(outfile) + + if not self.force and not newer(script, outfile): + log.debug("not copying %s (up-to-date)", script) + return + + # Always open the file, but ignore failures in dry-run mode + # in order to attempt to copy directly. + f = tokenize.open(script) + + first_line = f.readline() + if not first_line: + self.warn(f"{script} is an empty file (skipping)") + return + + shebang_match = shebang_pattern.match(first_line) + + updated_files.append(outfile) + if shebang_match: + log.info("copying and adjusting %s -> %s", script, self.build_dir) + post_interp = shebang_match.group(1) or '' + shebang = "#!" + self.executable + post_interp + "\n" + self._validate_shebang(shebang, f.encoding) + with open(outfile, "w", encoding=f.encoding) as outf: + outf.write(shebang) + outf.writelines(f.readlines()) + if f: + f.close() + else: + if f: + f.close() + self.copy_file(script, outfile) + + def _change_modes(self, outfiles): + if os.name != 'posix': + return + + for file in outfiles: + self._change_mode(file) + + def _change_mode(self, file): + oldmode = os.stat(file)[ST_MODE] & 0o7777 + newmode = (oldmode | 0o555) & 0o7777 + if newmode != oldmode: + log.info("changing mode of %s from %o to %o", file, oldmode, newmode) + os.chmod(file, newmode) + + @staticmethod + def _validate_shebang(shebang, encoding): + # Python parser starts to read a script using UTF-8 until + # it gets a #coding:xxx cookie. The shebang has to be the + # first line of a file, the #coding:xxx cookie cannot be + # written before. So the shebang has to be encodable to + # UTF-8. + try: + shebang.encode('utf-8') + except UnicodeEncodeError: + raise ValueError(f"The shebang ({shebang!r}) is not encodable to utf-8") + + # If the script is encoded to a custom encoding (use a + # #coding:xxx cookie), the shebang has to be encodable to + # the script encoding too. + try: + shebang.encode(encoding) + except UnicodeEncodeError: + raise ValueError( + f"The shebang ({shebang!r}) is not encodable " + f"to the script encoding ({encoding})" + ) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/check.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/check.py new file mode 100644 index 0000000000000000000000000000000000000000..58a823dd3904cf105ed432e458a45d94948fbb4c --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/check.py @@ -0,0 +1,152 @@ +"""distutils.command.check + +Implements the Distutils 'check' command. +""" + +import contextlib +from typing import ClassVar + +from ..core import Command +from ..errors import DistutilsSetupError + +with contextlib.suppress(ImportError): + import docutils.frontend + import docutils.nodes + import docutils.parsers.rst + import docutils.utils + + class SilentReporter(docutils.utils.Reporter): + def __init__( + self, + source, + report_level, + halt_level, + stream=None, + debug=False, + encoding='ascii', + error_handler='replace', + ): + self.messages = [] + super().__init__( + source, report_level, halt_level, stream, debug, encoding, error_handler + ) + + def system_message(self, level, message, *children, **kwargs): + self.messages.append((level, message, children, kwargs)) + return docutils.nodes.system_message( + message, *children, level=level, type=self.levels[level], **kwargs + ) + + +class check(Command): + """This command checks the meta-data of the package.""" + + description = "perform some checks on the package" + user_options: ClassVar[list[tuple[str, str, str]]] = [ + ('metadata', 'm', 'Verify meta-data'), + ( + 'restructuredtext', + 'r', + 'Checks if long string meta-data syntax are reStructuredText-compliant', + ), + ('strict', 's', 'Will exit with an error if a check fails'), + ] + + boolean_options: ClassVar[list[str]] = ['metadata', 'restructuredtext', 'strict'] + + def initialize_options(self): + """Sets default values for options.""" + self.restructuredtext = False + self.metadata = 1 + self.strict = False + self._warnings = 0 + + def finalize_options(self): + pass + + def warn(self, msg): + """Counts the number of warnings that occurs.""" + self._warnings += 1 + return Command.warn(self, msg) + + def run(self): + """Runs the command.""" + # perform the various tests + if self.metadata: + self.check_metadata() + if self.restructuredtext: + if 'docutils' in globals(): + try: + self.check_restructuredtext() + except TypeError as exc: + raise DistutilsSetupError(str(exc)) + elif self.strict: + raise DistutilsSetupError('The docutils package is needed.') + + # let's raise an error in strict mode, if we have at least + # one warning + if self.strict and self._warnings > 0: + raise DistutilsSetupError('Please correct your package.') + + def check_metadata(self): + """Ensures that all required elements of meta-data are supplied. + + Required fields: + name, version + + Warns if any are missing. + """ + metadata = self.distribution.metadata + + missing = [ + attr for attr in ('name', 'version') if not getattr(metadata, attr, None) + ] + + if missing: + self.warn("missing required meta-data: {}".format(', '.join(missing))) + + def check_restructuredtext(self): + """Checks if the long string fields are reST-compliant.""" + data = self.distribution.get_long_description() + for warning in self._check_rst_data(data): + line = warning[-1].get('line') + if line is None: + warning = warning[1] + else: + warning = f'{warning[1]} (line {line})' + self.warn(warning) + + def _check_rst_data(self, data): + """Returns warnings when the provided data doesn't compile.""" + # the include and csv_table directives need this to be a path + source_path = self.distribution.script_name or 'setup.py' + parser = docutils.parsers.rst.Parser() + settings = docutils.frontend.OptionParser( + components=(docutils.parsers.rst.Parser,) + ).get_default_values() + settings.tab_width = 4 + settings.pep_references = None + settings.rfc_references = None + reporter = SilentReporter( + source_path, + settings.report_level, + settings.halt_level, + stream=settings.warning_stream, + debug=settings.debug, + encoding=settings.error_encoding, + error_handler=settings.error_encoding_error_handler, + ) + + document = docutils.nodes.document(settings, reporter, source=source_path) + document.note_source(source_path, -1) + try: + parser.parse(data, document) + except (AttributeError, TypeError) as e: + reporter.messages.append(( + -1, + f'Could not finish the parsing: {e}.', + '', + {}, + )) + + return reporter.messages diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/clean.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/clean.py new file mode 100644 index 0000000000000000000000000000000000000000..fc1711be8ef51e2bcd5fe2742588f95a65bcd153 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/clean.py @@ -0,0 +1,76 @@ +"""distutils.command.clean + +Implements the Distutils 'clean' command.""" + +# contributed by Bastian Kleineidam , added 2000-03-18 + +import os +from distutils._log import log +from typing import ClassVar + +from ..core import Command +from ..dir_util import remove_tree + + +class clean(Command): + description = "clean up temporary files from 'build' command" + user_options = [ + ('build-base=', 'b', "base build directory [default: 'build.build-base']"), + ( + 'build-lib=', + None, + "build directory for all modules [default: 'build.build-lib']", + ), + ('build-temp=', 't', "temporary build directory [default: 'build.build-temp']"), + ( + 'build-scripts=', + None, + "build directory for scripts [default: 'build.build-scripts']", + ), + ('bdist-base=', None, "temporary directory for built distributions"), + ('all', 'a', "remove all build output, not just temporary by-products"), + ] + + boolean_options: ClassVar[list[str]] = ['all'] + + def initialize_options(self): + self.build_base = None + self.build_lib = None + self.build_temp = None + self.build_scripts = None + self.bdist_base = None + self.all = None + + def finalize_options(self): + self.set_undefined_options( + 'build', + ('build_base', 'build_base'), + ('build_lib', 'build_lib'), + ('build_scripts', 'build_scripts'), + ('build_temp', 'build_temp'), + ) + self.set_undefined_options('bdist', ('bdist_base', 'bdist_base')) + + def run(self): + # remove the build/temp. directory (unless it's already + # gone) + if os.path.exists(self.build_temp): + remove_tree(self.build_temp) + else: + log.debug("'%s' does not exist -- can't clean it", self.build_temp) + + if self.all: + # remove build directories + for directory in (self.build_lib, self.bdist_base, self.build_scripts): + if os.path.exists(directory): + remove_tree(directory) + else: + log.warning("'%s' does not exist -- can't clean it", directory) + + # just for the heck of it, try to remove the base build directory: + # we might have emptied it right now, but if not we don't care + try: + os.rmdir(self.build_base) + log.info("removing '%s'", self.build_base) + except OSError: + pass diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/config.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/config.py new file mode 100644 index 0000000000000000000000000000000000000000..9818418f2675125631e7d9d1ad74c30487e9dd5b --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/config.py @@ -0,0 +1,348 @@ +"""distutils.command.config + +Implements the Distutils 'config' command, a (mostly) empty command class +that exists mainly to be sub-classed by specific module distributions and +applications. The idea is that while every "config" command is different, +at least they're all named the same, and users always see "config" in the +list of standard commands. Also, this is a good place to put common +configure-like tasks: "try to compile this C code", or "figure out where +this header file lives". +""" + +from __future__ import annotations + +import os +import pathlib +import re +from collections.abc import Sequence +from distutils._log import log + +from ..ccompiler import CCompiler, CompileError, LinkError, new_compiler +from ..core import Command +from ..errors import DistutilsExecError +from ..sysconfig import customize_compiler + +LANG_EXT = {"c": ".c", "c++": ".cxx"} + + +class config(Command): + description = "prepare to build" + + user_options = [ + ('compiler=', None, "specify the compiler type"), + ('cc=', None, "specify the compiler executable"), + ('include-dirs=', 'I', "list of directories to search for header files"), + ('define=', 'D', "C preprocessor macros to define"), + ('undef=', 'U', "C preprocessor macros to undefine"), + ('libraries=', 'l', "external C libraries to link with"), + ('library-dirs=', 'L', "directories to search for external C libraries"), + ('noisy', None, "show every action (compile, link, run, ...) taken"), + ( + 'dump-source', + None, + "dump generated source files before attempting to compile them", + ), + ] + + # The three standard command methods: since the "config" command + # does nothing by default, these are empty. + + def initialize_options(self): + self.compiler = None + self.cc = None + self.include_dirs = None + self.libraries = None + self.library_dirs = None + + # maximal output for now + self.noisy = 1 + self.dump_source = 1 + + # list of temporary files generated along-the-way that we have + # to clean at some point + self.temp_files = [] + + def finalize_options(self): + if self.include_dirs is None: + self.include_dirs = self.distribution.include_dirs or [] + elif isinstance(self.include_dirs, str): + self.include_dirs = self.include_dirs.split(os.pathsep) + + if self.libraries is None: + self.libraries = [] + elif isinstance(self.libraries, str): + self.libraries = [self.libraries] + + if self.library_dirs is None: + self.library_dirs = [] + elif isinstance(self.library_dirs, str): + self.library_dirs = self.library_dirs.split(os.pathsep) + + def run(self): + pass + + # Utility methods for actual "config" commands. The interfaces are + # loosely based on Autoconf macros of similar names. Sub-classes + # may use these freely. + + def _check_compiler(self): + """Check that 'self.compiler' really is a CCompiler object; + if not, make it one. + """ + if not isinstance(self.compiler, CCompiler): + self.compiler = new_compiler(compiler=self.compiler, force=True) + customize_compiler(self.compiler) + if self.include_dirs: + self.compiler.set_include_dirs(self.include_dirs) + if self.libraries: + self.compiler.set_libraries(self.libraries) + if self.library_dirs: + self.compiler.set_library_dirs(self.library_dirs) + + def _gen_temp_sourcefile(self, body, headers, lang): + filename = "_configtest" + LANG_EXT[lang] + with open(filename, "w", encoding='utf-8') as file: + if headers: + for header in headers: + file.write(f"#include <{header}>\n") + file.write("\n") + file.write(body) + if body[-1] != "\n": + file.write("\n") + return filename + + def _preprocess(self, body, headers, include_dirs, lang): + src = self._gen_temp_sourcefile(body, headers, lang) + out = "_configtest.i" + self.temp_files.extend([src, out]) + self.compiler.preprocess(src, out, include_dirs=include_dirs) + return (src, out) + + def _compile(self, body, headers, include_dirs, lang): + src = self._gen_temp_sourcefile(body, headers, lang) + if self.dump_source: + dump_file(src, f"compiling '{src}':") + (obj,) = self.compiler.object_filenames([src]) + self.temp_files.extend([src, obj]) + self.compiler.compile([src], include_dirs=include_dirs) + return (src, obj) + + def _link(self, body, headers, include_dirs, libraries, library_dirs, lang): + (src, obj) = self._compile(body, headers, include_dirs, lang) + prog = os.path.splitext(os.path.basename(src))[0] + self.compiler.link_executable( + [obj], + prog, + libraries=libraries, + library_dirs=library_dirs, + target_lang=lang, + ) + + if self.compiler.exe_extension is not None: + prog = prog + self.compiler.exe_extension + self.temp_files.append(prog) + + return (src, obj, prog) + + def _clean(self, *filenames): + if not filenames: + filenames = self.temp_files + self.temp_files = [] + log.info("removing: %s", ' '.join(filenames)) + for filename in filenames: + try: + os.remove(filename) + except OSError: + pass + + # XXX need access to the header search path and maybe default macros. + + def try_cpp(self, body=None, headers=None, include_dirs=None, lang="c"): + """Construct a source file from 'body' (a string containing lines + of C/C++ code) and 'headers' (a list of header files to include) + and run it through the preprocessor. Return true if the + preprocessor succeeded, false if there were any errors. + ('body' probably isn't of much use, but what the heck.) + """ + self._check_compiler() + ok = True + try: + self._preprocess(body, headers, include_dirs, lang) + except CompileError: + ok = False + + self._clean() + return ok + + def search_cpp(self, pattern, body=None, headers=None, include_dirs=None, lang="c"): + """Construct a source file (just like 'try_cpp()'), run it through + the preprocessor, and return true if any line of the output matches + 'pattern'. 'pattern' should either be a compiled regex object or a + string containing a regex. If both 'body' and 'headers' are None, + preprocesses an empty file -- which can be useful to determine the + symbols the preprocessor and compiler set by default. + """ + self._check_compiler() + src, out = self._preprocess(body, headers, include_dirs, lang) + + if isinstance(pattern, str): + pattern = re.compile(pattern) + + with open(out, encoding='utf-8') as file: + match = any(pattern.search(line) for line in file) + + self._clean() + return match + + def try_compile(self, body, headers=None, include_dirs=None, lang="c"): + """Try to compile a source file built from 'body' and 'headers'. + Return true on success, false otherwise. + """ + self._check_compiler() + try: + self._compile(body, headers, include_dirs, lang) + ok = True + except CompileError: + ok = False + + log.info(ok and "success!" or "failure.") + self._clean() + return ok + + def try_link( + self, + body, + headers=None, + include_dirs=None, + libraries=None, + library_dirs=None, + lang="c", + ): + """Try to compile and link a source file, built from 'body' and + 'headers', to executable form. Return true on success, false + otherwise. + """ + self._check_compiler() + try: + self._link(body, headers, include_dirs, libraries, library_dirs, lang) + ok = True + except (CompileError, LinkError): + ok = False + + log.info(ok and "success!" or "failure.") + self._clean() + return ok + + def try_run( + self, + body, + headers=None, + include_dirs=None, + libraries=None, + library_dirs=None, + lang="c", + ): + """Try to compile, link to an executable, and run a program + built from 'body' and 'headers'. Return true on success, false + otherwise. + """ + self._check_compiler() + try: + src, obj, exe = self._link( + body, headers, include_dirs, libraries, library_dirs, lang + ) + self.spawn([exe]) + ok = True + except (CompileError, LinkError, DistutilsExecError): + ok = False + + log.info(ok and "success!" or "failure.") + self._clean() + return ok + + # -- High-level methods -------------------------------------------- + # (these are the ones that are actually likely to be useful + # when implementing a real-world config command!) + + def check_func( + self, + func, + headers=None, + include_dirs=None, + libraries=None, + library_dirs=None, + decl=False, + call=False, + ): + """Determine if function 'func' is available by constructing a + source file that refers to 'func', and compiles and links it. + If everything succeeds, returns true; otherwise returns false. + + The constructed source file starts out by including the header + files listed in 'headers'. If 'decl' is true, it then declares + 'func' (as "int func()"); you probably shouldn't supply 'headers' + and set 'decl' true in the same call, or you might get errors about + a conflicting declarations for 'func'. Finally, the constructed + 'main()' function either references 'func' or (if 'call' is true) + calls it. 'libraries' and 'library_dirs' are used when + linking. + """ + self._check_compiler() + body = [] + if decl: + body.append(f"int {func} ();") + body.append("int main () {") + if call: + body.append(f" {func}();") + else: + body.append(f" {func};") + body.append("}") + body = "\n".join(body) + "\n" + + return self.try_link(body, headers, include_dirs, libraries, library_dirs) + + def check_lib( + self, + library, + library_dirs=None, + headers=None, + include_dirs=None, + other_libraries: Sequence[str] = [], + ): + """Determine if 'library' is available to be linked against, + without actually checking that any particular symbols are provided + by it. 'headers' will be used in constructing the source file to + be compiled, but the only effect of this is to check if all the + header files listed are available. Any libraries listed in + 'other_libraries' will be included in the link, in case 'library' + has symbols that depend on other libraries. + """ + self._check_compiler() + return self.try_link( + "int main (void) { }", + headers, + include_dirs, + [library] + list(other_libraries), + library_dirs, + ) + + def check_header(self, header, include_dirs=None, library_dirs=None, lang="c"): + """Determine if the system header file named by 'header_file' + exists and can be found by the preprocessor; return true if so, + false otherwise. + """ + return self.try_cpp( + body="/* No body */", headers=[header], include_dirs=include_dirs + ) + + +def dump_file(filename, head=None): + """Dumps a file content into log.info. + + If head is not None, will be dumped before the file content. + """ + if head is None: + log.info('%s', filename) + else: + log.info(head) + log.info(pathlib.Path(filename).read_text(encoding='utf-8')) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/install.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/install.py new file mode 100644 index 0000000000000000000000000000000000000000..dc17e56a8070b26f0e3d09c82250e006f1aed826 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/install.py @@ -0,0 +1,805 @@ +"""distutils.command.install + +Implements the Distutils 'install' command.""" + +from __future__ import annotations + +import collections +import contextlib +import itertools +import os +import sys +import sysconfig +from distutils._log import log +from site import USER_BASE, USER_SITE +from typing import ClassVar + +from ..core import Command +from ..debug import DEBUG +from ..errors import DistutilsOptionError, DistutilsPlatformError +from ..file_util import write_file +from ..sysconfig import get_config_vars +from ..util import change_root, convert_path, get_platform, subst_vars +from . import _framework_compat as fw + +HAS_USER_SITE = True + +WINDOWS_SCHEME = { + 'purelib': '{base}/Lib/site-packages', + 'platlib': '{base}/Lib/site-packages', + 'headers': '{base}/Include/{dist_name}', + 'scripts': '{base}/Scripts', + 'data': '{base}', +} + +INSTALL_SCHEMES = { + 'posix_prefix': { + 'purelib': '{base}/lib/{implementation_lower}{py_version_short}/site-packages', + 'platlib': '{platbase}/{platlibdir}/{implementation_lower}' + '{py_version_short}/site-packages', + 'headers': '{base}/include/{implementation_lower}' + '{py_version_short}{abiflags}/{dist_name}', + 'scripts': '{base}/bin', + 'data': '{base}', + }, + 'posix_home': { + 'purelib': '{base}/lib/{implementation_lower}', + 'platlib': '{base}/{platlibdir}/{implementation_lower}', + 'headers': '{base}/include/{implementation_lower}/{dist_name}', + 'scripts': '{base}/bin', + 'data': '{base}', + }, + 'nt': WINDOWS_SCHEME, + 'pypy': { + 'purelib': '{base}/site-packages', + 'platlib': '{base}/site-packages', + 'headers': '{base}/include/{dist_name}', + 'scripts': '{base}/bin', + 'data': '{base}', + }, + 'pypy_nt': { + 'purelib': '{base}/site-packages', + 'platlib': '{base}/site-packages', + 'headers': '{base}/include/{dist_name}', + 'scripts': '{base}/Scripts', + 'data': '{base}', + }, +} + +# user site schemes +if HAS_USER_SITE: + INSTALL_SCHEMES['nt_user'] = { + 'purelib': '{usersite}', + 'platlib': '{usersite}', + 'headers': '{userbase}/{implementation}{py_version_nodot_plat}' + '/Include/{dist_name}', + 'scripts': '{userbase}/{implementation}{py_version_nodot_plat}/Scripts', + 'data': '{userbase}', + } + + INSTALL_SCHEMES['posix_user'] = { + 'purelib': '{usersite}', + 'platlib': '{usersite}', + 'headers': '{userbase}/include/{implementation_lower}' + '{py_version_short}{abiflags}/{dist_name}', + 'scripts': '{userbase}/bin', + 'data': '{userbase}', + } + + +INSTALL_SCHEMES.update(fw.schemes) + + +# The keys to an installation scheme; if any new types of files are to be +# installed, be sure to add an entry to every installation scheme above, +# and to SCHEME_KEYS here. +SCHEME_KEYS = ('purelib', 'platlib', 'headers', 'scripts', 'data') + + +def _load_sysconfig_schemes(): + with contextlib.suppress(AttributeError): + return { + scheme: sysconfig.get_paths(scheme, expand=False) + for scheme in sysconfig.get_scheme_names() + } + + +def _load_schemes(): + """ + Extend default schemes with schemes from sysconfig. + """ + + sysconfig_schemes = _load_sysconfig_schemes() or {} + + return { + scheme: { + **INSTALL_SCHEMES.get(scheme, {}), + **sysconfig_schemes.get(scheme, {}), + } + for scheme in set(itertools.chain(INSTALL_SCHEMES, sysconfig_schemes)) + } + + +def _get_implementation(): + if hasattr(sys, 'pypy_version_info'): + return 'PyPy' + else: + return 'Python' + + +def _select_scheme(ob, name): + scheme = _inject_headers(name, _load_scheme(_resolve_scheme(name))) + vars(ob).update(_remove_set(ob, _scheme_attrs(scheme))) + + +def _remove_set(ob, attrs): + """ + Include only attrs that are None in ob. + """ + return {key: value for key, value in attrs.items() if getattr(ob, key) is None} + + +def _resolve_scheme(name): + os_name, sep, key = name.partition('_') + try: + resolved = sysconfig.get_preferred_scheme(key) + except Exception: + resolved = fw.scheme(name) + return resolved + + +def _load_scheme(name): + return _load_schemes()[name] + + +def _inject_headers(name, scheme): + """ + Given a scheme name and the resolved scheme, + if the scheme does not include headers, resolve + the fallback scheme for the name and use headers + from it. pypa/distutils#88 + """ + # Bypass the preferred scheme, which may not + # have defined headers. + fallback = _load_scheme(name) + scheme.setdefault('headers', fallback['headers']) + return scheme + + +def _scheme_attrs(scheme): + """Resolve install directories by applying the install schemes.""" + return {f'install_{key}': scheme[key] for key in SCHEME_KEYS} + + +class install(Command): + description = "install everything from build directory" + + user_options = [ + # Select installation scheme and set base director(y|ies) + ('prefix=', None, "installation prefix"), + ('exec-prefix=', None, "(Unix only) prefix for platform-specific files"), + ('home=', None, "(Unix only) home directory to install under"), + # Or, just set the base director(y|ies) + ( + 'install-base=', + None, + "base installation directory (instead of --prefix or --home)", + ), + ( + 'install-platbase=', + None, + "base installation directory for platform-specific files (instead of --exec-prefix or --home)", + ), + ('root=', None, "install everything relative to this alternate root directory"), + # Or, explicitly set the installation scheme + ( + 'install-purelib=', + None, + "installation directory for pure Python module distributions", + ), + ( + 'install-platlib=', + None, + "installation directory for non-pure module distributions", + ), + ( + 'install-lib=', + None, + "installation directory for all module distributions (overrides --install-purelib and --install-platlib)", + ), + ('install-headers=', None, "installation directory for C/C++ headers"), + ('install-scripts=', None, "installation directory for Python scripts"), + ('install-data=', None, "installation directory for data files"), + # Byte-compilation options -- see install_lib.py for details, as + # these are duplicated from there (but only install_lib does + # anything with them). + ('compile', 'c', "compile .py to .pyc [default]"), + ('no-compile', None, "don't compile .py files"), + ( + 'optimize=', + 'O', + "also compile with optimization: -O1 for \"python -O\", " + "-O2 for \"python -OO\", and -O0 to disable [default: -O0]", + ), + # Miscellaneous control options + ('force', 'f', "force installation (overwrite any existing files)"), + ('skip-build', None, "skip rebuilding everything (for testing/debugging)"), + # Where to install documentation (eventually!) + # ('doc-format=', None, "format of documentation to generate"), + # ('install-man=', None, "directory for Unix man pages"), + # ('install-html=', None, "directory for HTML documentation"), + # ('install-info=', None, "directory for GNU info files"), + ('record=', None, "filename in which to record list of installed files"), + ] + + boolean_options: ClassVar[list[str]] = ['compile', 'force', 'skip-build'] + + if HAS_USER_SITE: + user_options.append(( + 'user', + None, + f"install in user site-package '{USER_SITE}'", + )) + boolean_options.append('user') + + negative_opt: ClassVar[dict[str, str]] = {'no-compile': 'compile'} + + def initialize_options(self) -> None: + """Initializes options.""" + # High-level options: these select both an installation base + # and scheme. + self.prefix: str | None = None + self.exec_prefix: str | None = None + self.home: str | None = None + self.user = False + + # These select only the installation base; it's up to the user to + # specify the installation scheme (currently, that means supplying + # the --install-{platlib,purelib,scripts,data} options). + self.install_base = None + self.install_platbase = None + self.root: str | None = None + + # These options are the actual installation directories; if not + # supplied by the user, they are filled in using the installation + # scheme implied by prefix/exec-prefix/home and the contents of + # that installation scheme. + self.install_purelib = None # for pure module distributions + self.install_platlib = None # non-pure (dists w/ extensions) + self.install_headers = None # for C/C++ headers + self.install_lib: str | None = None # set to either purelib or platlib + self.install_scripts = None + self.install_data = None + self.install_userbase = USER_BASE + self.install_usersite = USER_SITE + + self.compile = None + self.optimize = None + + # Deprecated + # These two are for putting non-packagized distributions into their + # own directory and creating a .pth file if it makes sense. + # 'extra_path' comes from the setup file; 'install_path_file' can + # be turned off if it makes no sense to install a .pth file. (But + # better to install it uselessly than to guess wrong and not + # install it when it's necessary and would be used!) Currently, + # 'install_path_file' is always true unless some outsider meddles + # with it. + self.extra_path = None + self.install_path_file = True + + # 'force' forces installation, even if target files are not + # out-of-date. 'skip_build' skips running the "build" command, + # handy if you know it's not necessary. 'warn_dir' (which is *not* + # a user option, it's just there so the bdist_* commands can turn + # it off) determines whether we warn about installing to a + # directory not in sys.path. + self.force = False + self.skip_build = False + self.warn_dir = True + + # These are only here as a conduit from the 'build' command to the + # 'install_*' commands that do the real work. ('build_base' isn't + # actually used anywhere, but it might be useful in future.) They + # are not user options, because if the user told the install + # command where the build directory is, that wouldn't affect the + # build command. + self.build_base = None + self.build_lib = None + + # Not defined yet because we don't know anything about + # documentation yet. + # self.install_man = None + # self.install_html = None + # self.install_info = None + + self.record = None + + # -- Option finalizing methods ------------------------------------- + # (This is rather more involved than for most commands, + # because this is where the policy for installing third- + # party Python modules on various platforms given a wide + # array of user input is decided. Yes, it's quite complex!) + + def finalize_options(self) -> None: # noqa: C901 + """Finalizes options.""" + # This method (and its helpers, like 'finalize_unix()', + # 'finalize_other()', and 'select_scheme()') is where the default + # installation directories for modules, extension modules, and + # anything else we care to install from a Python module + # distribution. Thus, this code makes a pretty important policy + # statement about how third-party stuff is added to a Python + # installation! Note that the actual work of installation is done + # by the relatively simple 'install_*' commands; they just take + # their orders from the installation directory options determined + # here. + + # Check for errors/inconsistencies in the options; first, stuff + # that's wrong on any platform. + + if (self.prefix or self.exec_prefix or self.home) and ( + self.install_base or self.install_platbase + ): + raise DistutilsOptionError( + "must supply either prefix/exec-prefix/home or install-base/install-platbase -- not both" + ) + + if self.home and (self.prefix or self.exec_prefix): + raise DistutilsOptionError( + "must supply either home or prefix/exec-prefix -- not both" + ) + + if self.user and ( + self.prefix + or self.exec_prefix + or self.home + or self.install_base + or self.install_platbase + ): + raise DistutilsOptionError( + "can't combine user with prefix, " + "exec_prefix/home, or install_(plat)base" + ) + + # Next, stuff that's wrong (or dubious) only on certain platforms. + if os.name != "posix": + if self.exec_prefix: + self.warn("exec-prefix option ignored on this platform") + self.exec_prefix = None + + # Now the interesting logic -- so interesting that we farm it out + # to other methods. The goal of these methods is to set the final + # values for the install_{lib,scripts,data,...} options, using as + # input a heady brew of prefix, exec_prefix, home, install_base, + # install_platbase, user-supplied versions of + # install_{purelib,platlib,lib,scripts,data,...}, and the + # install schemes. Phew! + + self.dump_dirs("pre-finalize_{unix,other}") + + if os.name == 'posix': + self.finalize_unix() + else: + self.finalize_other() + + self.dump_dirs("post-finalize_{unix,other}()") + + # Expand configuration variables, tilde, etc. in self.install_base + # and self.install_platbase -- that way, we can use $base or + # $platbase in the other installation directories and not worry + # about needing recursive variable expansion (shudder). + + py_version = sys.version.split()[0] + (prefix, exec_prefix) = get_config_vars('prefix', 'exec_prefix') + try: + abiflags = sys.abiflags + except AttributeError: + # sys.abiflags may not be defined on all platforms. + abiflags = '' + local_vars = { + 'dist_name': self.distribution.get_name(), + 'dist_version': self.distribution.get_version(), + 'dist_fullname': self.distribution.get_fullname(), + 'py_version': py_version, + 'py_version_short': f'{sys.version_info.major}.{sys.version_info.minor}', + 'py_version_nodot': f'{sys.version_info.major}{sys.version_info.minor}', + 'sys_prefix': prefix, + 'prefix': prefix, + 'sys_exec_prefix': exec_prefix, + 'exec_prefix': exec_prefix, + 'abiflags': abiflags, + 'platlibdir': getattr(sys, 'platlibdir', 'lib'), + 'implementation_lower': _get_implementation().lower(), + 'implementation': _get_implementation(), + } + + # vars for compatibility on older Pythons + compat_vars = dict( + # Python 3.9 and earlier + py_version_nodot_plat=getattr(sys, 'winver', '').replace('.', ''), + ) + + if HAS_USER_SITE: + local_vars['userbase'] = self.install_userbase + local_vars['usersite'] = self.install_usersite + + self.config_vars = collections.ChainMap( + local_vars, + sysconfig.get_config_vars(), + compat_vars, + fw.vars(), + ) + + self.expand_basedirs() + + self.dump_dirs("post-expand_basedirs()") + + # Now define config vars for the base directories so we can expand + # everything else. + local_vars['base'] = self.install_base + local_vars['platbase'] = self.install_platbase + + if DEBUG: + from pprint import pprint + + print("config vars:") + pprint(dict(self.config_vars)) + + # Expand "~" and configuration variables in the installation + # directories. + self.expand_dirs() + + self.dump_dirs("post-expand_dirs()") + + # Create directories in the home dir: + if self.user: + self.create_home_path() + + # Pick the actual directory to install all modules to: either + # install_purelib or install_platlib, depending on whether this + # module distribution is pure or not. Of course, if the user + # already specified install_lib, use their selection. + if self.install_lib is None: + if self.distribution.has_ext_modules(): # has extensions: non-pure + self.install_lib = self.install_platlib + else: + self.install_lib = self.install_purelib + + # Convert directories from Unix /-separated syntax to the local + # convention. + self.convert_paths( + 'lib', + 'purelib', + 'platlib', + 'scripts', + 'data', + 'headers', + 'userbase', + 'usersite', + ) + + # Deprecated + # Well, we're not actually fully completely finalized yet: we still + # have to deal with 'extra_path', which is the hack for allowing + # non-packagized module distributions (hello, Numerical Python!) to + # get their own directories. + self.handle_extra_path() + self.install_libbase = self.install_lib # needed for .pth file + self.install_lib = os.path.join(self.install_lib, self.extra_dirs) + + # If a new root directory was supplied, make all the installation + # dirs relative to it. + if self.root is not None: + self.change_roots( + 'libbase', 'lib', 'purelib', 'platlib', 'scripts', 'data', 'headers' + ) + + self.dump_dirs("after prepending root") + + # Find out the build directories, ie. where to install from. + self.set_undefined_options( + 'build', ('build_base', 'build_base'), ('build_lib', 'build_lib') + ) + + # Punt on doc directories for now -- after all, we're punting on + # documentation completely! + + def dump_dirs(self, msg) -> None: + """Dumps the list of user options.""" + if not DEBUG: + return + from ..fancy_getopt import longopt_xlate + + log.debug(msg + ":") + for opt in self.user_options: + opt_name = opt[0] + if opt_name[-1] == "=": + opt_name = opt_name[0:-1] + if opt_name in self.negative_opt: + opt_name = self.negative_opt[opt_name] + opt_name = opt_name.translate(longopt_xlate) + val = not getattr(self, opt_name) + else: + opt_name = opt_name.translate(longopt_xlate) + val = getattr(self, opt_name) + log.debug(" %s: %s", opt_name, val) + + def finalize_unix(self) -> None: + """Finalizes options for posix platforms.""" + if self.install_base is not None or self.install_platbase is not None: + incomplete_scheme = ( + ( + self.install_lib is None + and self.install_purelib is None + and self.install_platlib is None + ) + or self.install_headers is None + or self.install_scripts is None + or self.install_data is None + ) + if incomplete_scheme: + raise DistutilsOptionError( + "install-base or install-platbase supplied, but " + "installation scheme is incomplete" + ) + return + + if self.user: + if self.install_userbase is None: + raise DistutilsPlatformError("User base directory is not specified") + self.install_base = self.install_platbase = self.install_userbase + self.select_scheme("posix_user") + elif self.home is not None: + self.install_base = self.install_platbase = self.home + self.select_scheme("posix_home") + else: + if self.prefix is None: + if self.exec_prefix is not None: + raise DistutilsOptionError( + "must not supply exec-prefix without prefix" + ) + + # Allow Fedora to add components to the prefix + _prefix_addition = getattr(sysconfig, '_prefix_addition', "") + + self.prefix = os.path.normpath(sys.prefix) + _prefix_addition + self.exec_prefix = os.path.normpath(sys.exec_prefix) + _prefix_addition + + else: + if self.exec_prefix is None: + self.exec_prefix = self.prefix + + self.install_base = self.prefix + self.install_platbase = self.exec_prefix + self.select_scheme("posix_prefix") + + def finalize_other(self) -> None: + """Finalizes options for non-posix platforms""" + if self.user: + if self.install_userbase is None: + raise DistutilsPlatformError("User base directory is not specified") + self.install_base = self.install_platbase = self.install_userbase + self.select_scheme(os.name + "_user") + elif self.home is not None: + self.install_base = self.install_platbase = self.home + self.select_scheme("posix_home") + else: + if self.prefix is None: + self.prefix = os.path.normpath(sys.prefix) + + self.install_base = self.install_platbase = self.prefix + try: + self.select_scheme(os.name) + except KeyError: + raise DistutilsPlatformError( + f"I don't know how to install stuff on '{os.name}'" + ) + + def select_scheme(self, name) -> None: + _select_scheme(self, name) + + def _expand_attrs(self, attrs): + for attr in attrs: + val = getattr(self, attr) + if val is not None: + if os.name in ('posix', 'nt'): + val = os.path.expanduser(val) + val = subst_vars(val, self.config_vars) + setattr(self, attr, val) + + def expand_basedirs(self) -> None: + """Calls `os.path.expanduser` on install_base, install_platbase and + root.""" + self._expand_attrs(['install_base', 'install_platbase', 'root']) + + def expand_dirs(self) -> None: + """Calls `os.path.expanduser` on install dirs.""" + self._expand_attrs([ + 'install_purelib', + 'install_platlib', + 'install_lib', + 'install_headers', + 'install_scripts', + 'install_data', + ]) + + def convert_paths(self, *names) -> None: + """Call `convert_path` over `names`.""" + for name in names: + attr = "install_" + name + setattr(self, attr, convert_path(getattr(self, attr))) + + def handle_extra_path(self) -> None: + """Set `path_file` and `extra_dirs` using `extra_path`.""" + if self.extra_path is None: + self.extra_path = self.distribution.extra_path + + if self.extra_path is not None: + log.warning( + "Distribution option extra_path is deprecated. " + "See issue27919 for details." + ) + if isinstance(self.extra_path, str): + self.extra_path = self.extra_path.split(',') + + if len(self.extra_path) == 1: + path_file = extra_dirs = self.extra_path[0] + elif len(self.extra_path) == 2: + path_file, extra_dirs = self.extra_path + else: + raise DistutilsOptionError( + "'extra_path' option must be a list, tuple, or " + "comma-separated string with 1 or 2 elements" + ) + + # convert to local form in case Unix notation used (as it + # should be in setup scripts) + extra_dirs = convert_path(extra_dirs) + else: + path_file = None + extra_dirs = '' + + # XXX should we warn if path_file and not extra_dirs? (in which + # case the path file would be harmless but pointless) + self.path_file = path_file + self.extra_dirs = extra_dirs + + def change_roots(self, *names) -> None: + """Change the install directories pointed by name using root.""" + for name in names: + attr = "install_" + name + setattr(self, attr, change_root(self.root, getattr(self, attr))) + + def create_home_path(self) -> None: + """Create directories under ~.""" + if not self.user: + return + home = convert_path(os.path.expanduser("~")) + for path in self.config_vars.values(): + if str(path).startswith(home) and not os.path.isdir(path): + self.debug_print(f"os.makedirs('{path}', 0o700)") + os.makedirs(path, 0o700) + + # -- Command execution methods ------------------------------------- + + def run(self): + """Runs the command.""" + # Obviously have to build before we can install + if not self.skip_build: + self.run_command('build') + # If we built for any other platform, we can't install. + build_plat = self.distribution.get_command_obj('build').plat_name + # check warn_dir - it is a clue that the 'install' is happening + # internally, and not to sys.path, so we don't check the platform + # matches what we are running. + if self.warn_dir and build_plat != get_platform(): + raise DistutilsPlatformError("Can't install when cross-compiling") + + # Run all sub-commands (at least those that need to be run) + for cmd_name in self.get_sub_commands(): + self.run_command(cmd_name) + + if self.path_file: + self.create_path_file() + + # write list of installed files, if requested. + if self.record: + outputs = self.get_outputs() + if self.root: # strip any package prefix + root_len = len(self.root) + for counter in range(len(outputs)): + outputs[counter] = outputs[counter][root_len:] + self.execute( + write_file, + (self.record, outputs), + f"writing list of installed files to '{self.record}'", + ) + + sys_path = map(os.path.normpath, sys.path) + sys_path = map(os.path.normcase, sys_path) + install_lib = os.path.normcase(os.path.normpath(self.install_lib)) + if ( + self.warn_dir + and not (self.path_file and self.install_path_file) + and install_lib not in sys_path + ): + log.debug( + ( + "modules installed to '%s', which is not in " + "Python's module search path (sys.path) -- " + "you'll have to change the search path yourself" + ), + self.install_lib, + ) + + def create_path_file(self): + """Creates the .pth file""" + filename = os.path.join(self.install_libbase, self.path_file + ".pth") + if self.install_path_file: + self.execute( + write_file, (filename, [self.extra_dirs]), f"creating {filename}" + ) + else: + self.warn(f"path file '{filename}' not created") + + # -- Reporting methods --------------------------------------------- + + def get_outputs(self): + """Assembles the outputs of all the sub-commands.""" + outputs = [] + for cmd_name in self.get_sub_commands(): + cmd = self.get_finalized_command(cmd_name) + # Add the contents of cmd.get_outputs(), ensuring + # that outputs doesn't contain duplicate entries + for filename in cmd.get_outputs(): + if filename not in outputs: + outputs.append(filename) + + if self.path_file and self.install_path_file: + outputs.append(os.path.join(self.install_libbase, self.path_file + ".pth")) + + return outputs + + def get_inputs(self): + """Returns the inputs of all the sub-commands""" + # XXX gee, this looks familiar ;-( + inputs = [] + for cmd_name in self.get_sub_commands(): + cmd = self.get_finalized_command(cmd_name) + inputs.extend(cmd.get_inputs()) + + return inputs + + # -- Predicates for sub-command list ------------------------------- + + def has_lib(self): + """Returns true if the current distribution has any Python + modules to install.""" + return ( + self.distribution.has_pure_modules() or self.distribution.has_ext_modules() + ) + + def has_headers(self): + """Returns true if the current distribution has any headers to + install.""" + return self.distribution.has_headers() + + def has_scripts(self): + """Returns true if the current distribution has any scripts to. + install.""" + return self.distribution.has_scripts() + + def has_data(self): + """Returns true if the current distribution has any data to. + install.""" + return self.distribution.has_data_files() + + # 'sub_commands': a list of commands this command might have to run to + # get its work done. See cmd.py for more info. + sub_commands = [ + ('install_lib', has_lib), + ('install_headers', has_headers), + ('install_scripts', has_scripts), + ('install_data', has_data), + ('install_egg_info', lambda self: True), + ] diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/install_data.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/install_data.py new file mode 100644 index 0000000000000000000000000000000000000000..4ad186e8ec61b92967ea1c12cdca51d00e82dd15 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/install_data.py @@ -0,0 +1,94 @@ +"""distutils.command.install_data + +Implements the Distutils 'install_data' command, for installing +platform-independent data files.""" + +# contributed by Bastian Kleineidam + +from __future__ import annotations + +import functools +import os +from collections.abc import Iterable +from typing import ClassVar + +from ..core import Command +from ..util import change_root, convert_path + + +class install_data(Command): + description = "install data files" + + user_options = [ + ( + 'install-dir=', + 'd', + "base directory for installing data files [default: installation base dir]", + ), + ('root=', None, "install everything relative to this alternate root directory"), + ('force', 'f', "force installation (overwrite existing files)"), + ] + + boolean_options: ClassVar[list[str]] = ['force'] + + def initialize_options(self): + self.install_dir = None + self.outfiles = [] + self.root = None + self.force = False + self.data_files = self.distribution.data_files + self.warn_dir = True + + def finalize_options(self) -> None: + self.set_undefined_options( + 'install', + ('install_data', 'install_dir'), + ('root', 'root'), + ('force', 'force'), + ) + + def run(self) -> None: + self.mkpath(self.install_dir) + for f in self.data_files: + self._copy(f) + + @functools.singledispatchmethod + def _copy(self, f: tuple[str | os.PathLike, Iterable[str | os.PathLike]]): + # it's a tuple with path to install to and a list of files + dir = convert_path(f[0]) + if not os.path.isabs(dir): + dir = os.path.join(self.install_dir, dir) + elif self.root: + dir = change_root(self.root, dir) + self.mkpath(dir) + + if f[1] == []: + # If there are no files listed, the user must be + # trying to create an empty directory, so add the + # directory to the list of output files. + self.outfiles.append(dir) + else: + # Copy files, adding them to the list of output files. + for data in f[1]: + data = convert_path(data) + (out, _) = self.copy_file(data, dir) + self.outfiles.append(out) + + @_copy.register(str) + @_copy.register(os.PathLike) + def _(self, f: str | os.PathLike): + # it's a simple file, so copy it + f = convert_path(f) + if self.warn_dir: + self.warn( + "setup script did not provide a directory for " + f"'{f}' -- installing right in '{self.install_dir}'" + ) + (out, _) = self.copy_file(f, self.install_dir) + self.outfiles.append(out) + + def get_inputs(self): + return self.data_files or [] + + def get_outputs(self): + return self.outfiles diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/install_egg_info.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/install_egg_info.py new file mode 100644 index 0000000000000000000000000000000000000000..6840b34ec2b5e2a3f9514cda5e940bc6cd90c731 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/install_egg_info.py @@ -0,0 +1,90 @@ +""" +distutils.command.install_egg_info + +Implements the Distutils 'install_egg_info' command, for installing +a package's PKG-INFO metadata. +""" + +import os +import re +import sys +from typing import ClassVar + +from .. import dir_util +from .._log import log +from ..cmd import Command + + +class install_egg_info(Command): + """Install an .egg-info file for the package""" + + description = "Install package's PKG-INFO metadata as an .egg-info file" + user_options: ClassVar[list[tuple[str, str, str]]] = [ + ('install-dir=', 'd', "directory to install to"), + ] + + def initialize_options(self): + self.install_dir = None + + @property + def basename(self): + """ + Allow basename to be overridden by child class. + Ref pypa/distutils#2. + """ + name = to_filename(safe_name(self.distribution.get_name())) + version = to_filename(safe_version(self.distribution.get_version())) + return f"{name}-{version}-py{sys.version_info.major}.{sys.version_info.minor}.egg-info" + + def finalize_options(self): + self.set_undefined_options('install_lib', ('install_dir', 'install_dir')) + self.target = os.path.join(self.install_dir, self.basename) + self.outputs = [self.target] + + def run(self): + target = self.target + if os.path.isdir(target) and not os.path.islink(target): + dir_util.remove_tree(target) + elif os.path.exists(target): + self.execute(os.unlink, (self.target,), "Removing " + target) + elif not os.path.isdir(self.install_dir): + self.execute( + os.makedirs, (self.install_dir,), "Creating " + self.install_dir + ) + log.info("Writing %s", target) + with open(target, 'w', encoding='UTF-8') as f: + self.distribution.metadata.write_pkg_file(f) + + def get_outputs(self): + return self.outputs + + +# The following routines are taken from setuptools' pkg_resources module and +# can be replaced by importing them from pkg_resources once it is included +# in the stdlib. + + +def safe_name(name): + """Convert an arbitrary string to a standard distribution name + + Any runs of non-alphanumeric/. characters are replaced with a single '-'. + """ + return re.sub('[^A-Za-z0-9.]+', '-', name) + + +def safe_version(version): + """Convert an arbitrary string to a standard version string + + Spaces become dots, and all other non-alphanumeric characters become + dashes, with runs of multiple dashes condensed to a single dash. + """ + version = version.replace(' ', '.') + return re.sub('[^A-Za-z0-9.]+', '-', version) + + +def to_filename(name): + """Convert a project or version name to its filename-escaped form + + Any '-' characters are currently replaced with '_'. + """ + return name.replace('-', '_') diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/install_headers.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/install_headers.py new file mode 100644 index 0000000000000000000000000000000000000000..97af1371efcc73423e9b91d7b3ced684ff936377 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/install_headers.py @@ -0,0 +1,46 @@ +"""distutils.command.install_headers + +Implements the Distutils 'install_headers' command, to install C/C++ header +files to the Python include directory.""" + +from typing import ClassVar + +from ..core import Command + + +# XXX force is never used +class install_headers(Command): + description = "install C/C++ header files" + + user_options: ClassVar[list[tuple[str, str, str]]] = [ + ('install-dir=', 'd', "directory to install header files to"), + ('force', 'f', "force installation (overwrite existing files)"), + ] + + boolean_options: ClassVar[list[str]] = ['force'] + + def initialize_options(self): + self.install_dir = None + self.force = False + self.outfiles = [] + + def finalize_options(self): + self.set_undefined_options( + 'install', ('install_headers', 'install_dir'), ('force', 'force') + ) + + def run(self): + headers = self.distribution.headers + if not headers: + return + + self.mkpath(self.install_dir) + for header in headers: + (out, _) = self.copy_file(header, self.install_dir) + self.outfiles.append(out) + + def get_inputs(self): + return self.distribution.headers or [] + + def get_outputs(self): + return self.outfiles diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/install_lib.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/install_lib.py new file mode 100644 index 0000000000000000000000000000000000000000..9909a61762bd658f837057f07fa1d1200fe4e6ac --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/install_lib.py @@ -0,0 +1,236 @@ +"""distutils.command.install_lib + +Implements the Distutils 'install_lib' command +(install all Python modules).""" + +from __future__ import annotations + +import importlib.util +import os +import sys +from typing import Any, ClassVar + +from ..core import Command +from ..errors import DistutilsOptionError + +# Extension for Python source files. +PYTHON_SOURCE_EXTENSION = ".py" + + +class install_lib(Command): + description = "install all Python modules (extensions and pure Python)" + + # The byte-compilation options are a tad confusing. Here are the + # possible scenarios: + # 1) no compilation at all (--no-compile --no-optimize) + # 2) compile .pyc only (--compile --no-optimize; default) + # 3) compile .pyc and "opt-1" .pyc (--compile --optimize) + # 4) compile "opt-1" .pyc only (--no-compile --optimize) + # 5) compile .pyc and "opt-2" .pyc (--compile --optimize-more) + # 6) compile "opt-2" .pyc only (--no-compile --optimize-more) + # + # The UI for this is two options, 'compile' and 'optimize'. + # 'compile' is strictly boolean, and only decides whether to + # generate .pyc files. 'optimize' is three-way (0, 1, or 2), and + # decides both whether to generate .pyc files and what level of + # optimization to use. + + user_options = [ + ('install-dir=', 'd', "directory to install to"), + ('build-dir=', 'b', "build directory (where to install from)"), + ('force', 'f', "force installation (overwrite existing files)"), + ('compile', 'c', "compile .py to .pyc [default]"), + ('no-compile', None, "don't compile .py files"), + ( + 'optimize=', + 'O', + "also compile with optimization: -O1 for \"python -O\", " + "-O2 for \"python -OO\", and -O0 to disable [default: -O0]", + ), + ('skip-build', None, "skip the build steps"), + ] + + boolean_options: ClassVar[list[str]] = ['force', 'compile', 'skip-build'] + negative_opt: ClassVar[dict[str, str]] = {'no-compile': 'compile'} + + def initialize_options(self): + # let the 'install' command dictate our installation directory + self.install_dir = None + self.build_dir = None + self.force = False + self.compile = None + self.optimize = None + self.skip_build = None + + def finalize_options(self) -> None: + # Get all the information we need to install pure Python modules + # from the umbrella 'install' command -- build (source) directory, + # install (target) directory, and whether to compile .py files. + self.set_undefined_options( + 'install', + ('build_lib', 'build_dir'), + ('install_lib', 'install_dir'), + ('force', 'force'), + ('compile', 'compile'), + ('optimize', 'optimize'), + ('skip_build', 'skip_build'), + ) + + if self.compile is None: + self.compile = True + if self.optimize is None: + self.optimize = False + + if not isinstance(self.optimize, int): + try: + self.optimize = int(self.optimize) + except ValueError: + pass + if self.optimize not in (0, 1, 2): + raise DistutilsOptionError("optimize must be 0, 1, or 2") + + def run(self) -> None: + # Make sure we have built everything we need first + self.build() + + # Install everything: simply dump the entire contents of the build + # directory to the installation directory (that's the beauty of + # having a build directory!) + outfiles = self.install() + + # (Optionally) compile .py to .pyc + if outfiles is not None and self.distribution.has_pure_modules(): + self.byte_compile(outfiles) + + # -- Top-level worker functions ------------------------------------ + # (called from 'run()') + + def build(self) -> None: + if not self.skip_build: + if self.distribution.has_pure_modules(): + self.run_command('build_py') + if self.distribution.has_ext_modules(): + self.run_command('build_ext') + + # Any: https://typing.readthedocs.io/en/latest/guides/writing_stubs.html#the-any-trick + def install(self) -> list[str] | Any: + if os.path.isdir(self.build_dir): + outfiles = self.copy_tree(self.build_dir, self.install_dir) + else: + self.warn( + f"'{self.build_dir}' does not exist -- no Python modules to install" + ) + return + return outfiles + + def byte_compile(self, files) -> None: + if sys.dont_write_bytecode: + self.warn('byte-compiling is disabled, skipping.') + return + + from ..util import byte_compile + + # Get the "--root" directory supplied to the "install" command, + # and use it as a prefix to strip off the purported filename + # encoded in bytecode files. This is far from complete, but it + # should at least generate usable bytecode in RPM distributions. + install_root = self.get_finalized_command('install').root + + if self.compile: + byte_compile( + files, + optimize=0, + force=self.force, + prefix=install_root, + ) + if self.optimize > 0: + byte_compile( + files, + optimize=self.optimize, + force=self.force, + prefix=install_root, + verbose=self.verbose, + ) + + # -- Utility methods ----------------------------------------------- + + def _mutate_outputs(self, has_any, build_cmd, cmd_option, output_dir): + if not has_any: + return [] + + build_cmd = self.get_finalized_command(build_cmd) + build_files = build_cmd.get_outputs() + build_dir = getattr(build_cmd, cmd_option) + + prefix_len = len(build_dir) + len(os.sep) + outputs = [os.path.join(output_dir, file[prefix_len:]) for file in build_files] + + return outputs + + def _bytecode_filenames(self, py_filenames): + bytecode_files = [] + for py_file in py_filenames: + # Since build_py handles package data installation, the + # list of outputs can contain more than just .py files. + # Make sure we only report bytecode for the .py files. + ext = os.path.splitext(os.path.normcase(py_file))[1] + if ext != PYTHON_SOURCE_EXTENSION: + continue + if self.compile: + bytecode_files.append( + importlib.util.cache_from_source(py_file, optimization='') + ) + if self.optimize > 0: + bytecode_files.append( + importlib.util.cache_from_source( + py_file, optimization=self.optimize + ) + ) + + return bytecode_files + + # -- External interface -------------------------------------------- + # (called by outsiders) + + def get_outputs(self): + """Return the list of files that would be installed if this command + were actually run. Not affected by the "dry-run" flag or whether + modules have actually been built yet. + """ + pure_outputs = self._mutate_outputs( + self.distribution.has_pure_modules(), + 'build_py', + 'build_lib', + self.install_dir, + ) + if self.compile: + bytecode_outputs = self._bytecode_filenames(pure_outputs) + else: + bytecode_outputs = [] + + ext_outputs = self._mutate_outputs( + self.distribution.has_ext_modules(), + 'build_ext', + 'build_lib', + self.install_dir, + ) + + return pure_outputs + bytecode_outputs + ext_outputs + + def get_inputs(self): + """Get the list of files that are input to this command, ie. the + files that get installed as they are named in the build tree. + The files in this list correspond one-to-one to the output + filenames returned by 'get_outputs()'. + """ + inputs = [] + + if self.distribution.has_pure_modules(): + build_py = self.get_finalized_command('build_py') + inputs.extend(build_py.get_outputs()) + + if self.distribution.has_ext_modules(): + build_ext = self.get_finalized_command('build_ext') + inputs.extend(build_ext.get_outputs()) + + return inputs diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/install_scripts.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/install_scripts.py new file mode 100644 index 0000000000000000000000000000000000000000..33d235d976e39db426aaff628b8b9bb5b832dcb6 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/install_scripts.py @@ -0,0 +1,59 @@ +"""distutils.command.install_scripts + +Implements the Distutils 'install_scripts' command, for installing +Python scripts.""" + +# contributed by Bastian Kleineidam + +import os +from distutils._log import log +from stat import ST_MODE +from typing import ClassVar + +from ..core import Command + + +class install_scripts(Command): + description = "install scripts (Python or otherwise)" + + user_options = [ + ('install-dir=', 'd', "directory to install scripts to"), + ('build-dir=', 'b', "build directory (where to install from)"), + ('force', 'f', "force installation (overwrite existing files)"), + ('skip-build', None, "skip the build steps"), + ] + + boolean_options: ClassVar[list[str]] = ['force', 'skip-build'] + + def initialize_options(self): + self.install_dir = None + self.force = False + self.build_dir = None + self.skip_build = None + + def finalize_options(self) -> None: + self.set_undefined_options('build', ('build_scripts', 'build_dir')) + self.set_undefined_options( + 'install', + ('install_scripts', 'install_dir'), + ('force', 'force'), + ('skip_build', 'skip_build'), + ) + + def run(self) -> None: + if not self.skip_build: + self.run_command('build_scripts') + self.outfiles = self.copy_tree(self.build_dir, self.install_dir) + if os.name == 'posix': + # Set the executable bits (owner, group, and world) on + # all the scripts we just installed. + for file in self.get_outputs(): + mode = ((os.stat(file)[ST_MODE]) | 0o555) & 0o7777 + log.info("changing mode of %s to %o", file, mode) + os.chmod(file, mode) + + def get_inputs(self): + return self.distribution.scripts or [] + + def get_outputs(self): + return self.outfiles or [] diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/sdist.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/sdist.py new file mode 100644 index 0000000000000000000000000000000000000000..e64cc82902ac292fa391a219ff8eae117b252fe7 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/command/sdist.py @@ -0,0 +1,521 @@ +"""distutils.command.sdist + +Implements the Distutils 'sdist' command (create a source distribution).""" + +from __future__ import annotations + +import os +import sys +from collections.abc import Callable +from distutils import archive_util, dir_util, file_util +from distutils._log import log +from glob import glob +from itertools import filterfalse +from typing import ClassVar + +from ..core import Command +from ..errors import DistutilsOptionError, DistutilsTemplateError +from ..filelist import FileList +from ..text_file import TextFile +from ..util import convert_path + + +def show_formats(): + """Print all possible values for the 'formats' option (used by + the "--help-formats" command-line option). + """ + from ..archive_util import ARCHIVE_FORMATS + from ..fancy_getopt import FancyGetopt + + formats = sorted( + ("formats=" + format, None, ARCHIVE_FORMATS[format][2]) + for format in ARCHIVE_FORMATS.keys() + ) + FancyGetopt(formats).print_help("List of available source distribution formats:") + + +class sdist(Command): + description = "create a source distribution (tarball, zip file, etc.)" + + def checking_metadata(self) -> bool: + """Callable used for the check sub-command. + + Placed here so user_options can view it""" + return self.metadata_check + + user_options = [ + ('template=', 't', "name of manifest template file [default: MANIFEST.in]"), + ('manifest=', 'm', "name of manifest file [default: MANIFEST]"), + ( + 'use-defaults', + None, + "include the default file set in the manifest " + "[default; disable with --no-defaults]", + ), + ('no-defaults', None, "don't include the default file set"), + ( + 'prune', + None, + "specifically exclude files/directories that should not be " + "distributed (build tree, RCS/CVS dirs, etc.) " + "[default; disable with --no-prune]", + ), + ('no-prune', None, "don't automatically exclude anything"), + ( + 'manifest-only', + 'o', + "just regenerate the manifest and then stop (implies --force-manifest)", + ), + ( + 'force-manifest', + 'f', + "forcibly regenerate the manifest and carry on as usual. " + "Deprecated: now the manifest is always regenerated.", + ), + ('formats=', None, "formats for source distribution (comma-separated list)"), + ( + 'keep-temp', + 'k', + "keep the distribution tree around after creating " + "archive file(s)", + ), + ( + 'dist-dir=', + 'd', + "directory to put the source distribution archive(s) in [default: dist]", + ), + ( + 'metadata-check', + None, + "Ensure that all required elements of meta-data " + "are supplied. Warn if any missing. [default]", + ), + ( + 'owner=', + 'u', + "Owner name used when creating a tar file [default: current user]", + ), + ( + 'group=', + 'g', + "Group name used when creating a tar file [default: current group]", + ), + ] + + boolean_options: ClassVar[list[str]] = [ + 'use-defaults', + 'prune', + 'manifest-only', + 'force-manifest', + 'keep-temp', + 'metadata-check', + ] + + help_options: ClassVar[list[tuple[str, str | None, str, Callable[[], object]]]] = [ + ('help-formats', None, "list available distribution formats", show_formats), + ] + + negative_opt: ClassVar[dict[str, str]] = { + 'no-defaults': 'use-defaults', + 'no-prune': 'prune', + } + + sub_commands = [('check', checking_metadata)] + + READMES: ClassVar[tuple[str, ...]] = ('README', 'README.txt', 'README.rst') + + def initialize_options(self): + # 'template' and 'manifest' are, respectively, the names of + # the manifest template and manifest file. + self.template = None + self.manifest = None + + # 'use_defaults': if true, we will include the default file set + # in the manifest + self.use_defaults = True + self.prune = True + + self.manifest_only = False + self.force_manifest = False + + self.formats = ['gztar'] + self.keep_temp = False + self.dist_dir = None + + self.archive_files = None + self.metadata_check = True + self.owner = None + self.group = None + + def finalize_options(self) -> None: + if self.manifest is None: + self.manifest = "MANIFEST" + if self.template is None: + self.template = "MANIFEST.in" + + self.ensure_string_list('formats') + + bad_format = archive_util.check_archive_formats(self.formats) + if bad_format: + raise DistutilsOptionError(f"unknown archive format '{bad_format}'") + + if self.dist_dir is None: + self.dist_dir = "dist" + + def run(self) -> None: + # 'filelist' contains the list of files that will make up the + # manifest + self.filelist = FileList() + + # Run sub commands + for cmd_name in self.get_sub_commands(): + self.run_command(cmd_name) + + # Do whatever it takes to get the list of files to process + # (process the manifest template, read an existing manifest, + # whatever). File list is accumulated in 'self.filelist'. + self.get_file_list() + + # If user just wanted us to regenerate the manifest, stop now. + if self.manifest_only: + return + + # Otherwise, go ahead and create the source distribution tarball, + # or zipfile, or whatever. + self.make_distribution() + + def get_file_list(self) -> None: + """Figure out the list of files to include in the source + distribution, and put it in 'self.filelist'. This might involve + reading the manifest template (and writing the manifest), or just + reading the manifest, or just using the default file set -- it all + depends on the user's options. + """ + # new behavior when using a template: + # the file list is recalculated every time because + # even if MANIFEST.in or setup.py are not changed + # the user might have added some files in the tree that + # need to be included. + # + # This makes --force the default and only behavior with templates. + template_exists = os.path.isfile(self.template) + if not template_exists and self._manifest_is_not_generated(): + self.read_manifest() + self.filelist.sort() + self.filelist.remove_duplicates() + return + + if not template_exists: + self.warn( + ("manifest template '%s' does not exist " + "(using default file list)") + % self.template + ) + self.filelist.findall() + + if self.use_defaults: + self.add_defaults() + + if template_exists: + self.read_template() + + if self.prune: + self.prune_file_list() + + self.filelist.sort() + self.filelist.remove_duplicates() + self.write_manifest() + + def add_defaults(self) -> None: + """Add all the default files to self.filelist: + - README or README.txt + - setup.py + - tests/test*.py and test/test*.py + - all pure Python modules mentioned in setup script + - all files pointed by package_data (build_py) + - all files defined in data_files. + - all files defined as scripts. + - all C sources listed as part of extensions or C libraries + in the setup script (doesn't catch C headers!) + Warns if (README or README.txt) or setup.py are missing; everything + else is optional. + """ + self._add_defaults_standards() + self._add_defaults_optional() + self._add_defaults_python() + self._add_defaults_data_files() + self._add_defaults_ext() + self._add_defaults_c_libs() + self._add_defaults_scripts() + + @staticmethod + def _cs_path_exists(fspath): + """ + Case-sensitive path existence check + + >>> sdist._cs_path_exists(__file__) + True + >>> sdist._cs_path_exists(__file__.upper()) + False + """ + if not os.path.exists(fspath): + return False + # make absolute so we always have a directory + abspath = os.path.abspath(fspath) + directory, filename = os.path.split(abspath) + return filename in os.listdir(directory) + + def _add_defaults_standards(self): + standards = [self.READMES, self.distribution.script_name] + for fn in standards: + if isinstance(fn, tuple): + alts = fn + got_it = False + for fn in alts: + if self._cs_path_exists(fn): + got_it = True + self.filelist.append(fn) + break + + if not got_it: + self.warn( + "standard file not found: should have one of " + ', '.join(alts) + ) + else: + if self._cs_path_exists(fn): + self.filelist.append(fn) + else: + self.warn(f"standard file '{fn}' not found") + + def _add_defaults_optional(self): + optional = ['tests/test*.py', 'test/test*.py', 'setup.cfg'] + for pattern in optional: + files = filter(os.path.isfile, glob(pattern)) + self.filelist.extend(files) + + def _add_defaults_python(self): + # build_py is used to get: + # - python modules + # - files defined in package_data + build_py = self.get_finalized_command('build_py') + + # getting python files + if self.distribution.has_pure_modules(): + self.filelist.extend(build_py.get_source_files()) + + # getting package_data files + # (computed in build_py.data_files by build_py.finalize_options) + for _pkg, src_dir, _build_dir, filenames in build_py.data_files: + for filename in filenames: + self.filelist.append(os.path.join(src_dir, filename)) + + def _add_defaults_data_files(self): + # getting distribution.data_files + if self.distribution.has_data_files(): + for item in self.distribution.data_files: + if isinstance(item, str): + # plain file + item = convert_path(item) + if os.path.isfile(item): + self.filelist.append(item) + else: + # a (dirname, filenames) tuple + dirname, filenames = item + for f in filenames: + f = convert_path(f) + if os.path.isfile(f): + self.filelist.append(f) + + def _add_defaults_ext(self): + if self.distribution.has_ext_modules(): + build_ext = self.get_finalized_command('build_ext') + self.filelist.extend(build_ext.get_source_files()) + + def _add_defaults_c_libs(self): + if self.distribution.has_c_libraries(): + build_clib = self.get_finalized_command('build_clib') + self.filelist.extend(build_clib.get_source_files()) + + def _add_defaults_scripts(self): + if self.distribution.has_scripts(): + build_scripts = self.get_finalized_command('build_scripts') + self.filelist.extend(build_scripts.get_source_files()) + + def read_template(self) -> None: + """Read and parse manifest template file named by self.template. + + (usually "MANIFEST.in") The parsing and processing is done by + 'self.filelist', which updates itself accordingly. + """ + log.info("reading manifest template '%s'", self.template) + template = TextFile( + self.template, + strip_comments=True, + skip_blanks=True, + join_lines=True, + lstrip_ws=True, + rstrip_ws=True, + collapse_join=True, + ) + + try: + while True: + line = template.readline() + if line is None: # end of file + break + + try: + self.filelist.process_template_line(line) + # the call above can raise a DistutilsTemplateError for + # malformed lines, or a ValueError from the lower-level + # convert_path function + except (DistutilsTemplateError, ValueError) as msg: + self.warn( + f"{template.filename}, line {int(template.current_line)}: {msg}" + ) + finally: + template.close() + + def prune_file_list(self) -> None: + """Prune off branches that might slip into the file list as created + by 'read_template()', but really don't belong there: + * the build tree (typically "build") + * the release tree itself (only an issue if we ran "sdist" + previously with --keep-temp, or it aborted) + * any RCS, CVS, .svn, .hg, .git, .bzr, _darcs directories + """ + build = self.get_finalized_command('build') + base_dir = self.distribution.get_fullname() + + self.filelist.exclude_pattern(None, prefix=os.fspath(build.build_base)) + self.filelist.exclude_pattern(None, prefix=base_dir) + + if sys.platform == 'win32': + seps = r'/|\\' + else: + seps = '/' + + vcs_dirs = ['RCS', 'CVS', r'\.svn', r'\.hg', r'\.git', r'\.bzr', '_darcs'] + vcs_ptrn = r'(^|{})({})({}).*'.format(seps, '|'.join(vcs_dirs), seps) + self.filelist.exclude_pattern(vcs_ptrn, is_regex=True) + + def write_manifest(self) -> None: + """Write the file list in 'self.filelist' (presumably as filled in + by 'add_defaults()' and 'read_template()') to the manifest file + named by 'self.manifest'. + """ + if self._manifest_is_not_generated(): + log.info( + f"not writing to manually maintained manifest file '{self.manifest}'" + ) + return + + content = self.filelist.files[:] + content.insert(0, '# file GENERATED by distutils, do NOT edit') + self.execute( + file_util.write_file, + (self.manifest, content), + f"writing manifest file '{self.manifest}'", + ) + + def _manifest_is_not_generated(self): + # check for special comment used in 3.1.3 and higher + if not os.path.isfile(self.manifest): + return False + + with open(self.manifest, encoding='utf-8') as fp: + first_line = next(fp) + return first_line != '# file GENERATED by distutils, do NOT edit\n' + + def read_manifest(self) -> None: + """Read the manifest file (named by 'self.manifest') and use it to + fill in 'self.filelist', the list of files to include in the source + distribution. + """ + log.info("reading manifest file '%s'", self.manifest) + with open(self.manifest, encoding='utf-8') as lines: + self.filelist.extend( + # ignore comments and blank lines + filter(None, filterfalse(is_comment, map(str.strip, lines))) + ) + + def make_release_tree(self, base_dir, files) -> None: + """Create the directory tree that will become the source + distribution archive. All directories implied by the filenames in + 'files' are created under 'base_dir', and then we hard link or copy + (if hard linking is unavailable) those files into place. + Essentially, this duplicates the developer's source tree, but in a + directory named after the distribution, containing only the files + to be distributed. + """ + # Create all the directories under 'base_dir' necessary to + # put 'files' there; the 'mkpath()' is just so we don't die + # if the manifest happens to be empty. + self.mkpath(base_dir) + dir_util.create_tree(base_dir, files) + + # And walk over the list of files, either making a hard link (if + # os.link exists) to each one that doesn't already exist in its + # corresponding location under 'base_dir', or copying each file + # that's out-of-date in 'base_dir'. (Usually, all files will be + # out-of-date, because by default we blow away 'base_dir' when + # we're done making the distribution archives.) + + if hasattr(os, 'link'): # can make hard links on this system + link = 'hard' + msg = f"making hard links in {base_dir}..." + else: # nope, have to copy + link = None + msg = f"copying files to {base_dir}..." + + if not files: + log.warning("no files to distribute -- empty manifest?") + else: + log.info(msg) + for file in files: + if not os.path.isfile(file): + log.warning("'%s' not a regular file -- skipping", file) + else: + dest = os.path.join(base_dir, file) + self.copy_file(file, dest, link=link) + + self.distribution.metadata.write_pkg_info(base_dir) + + def make_distribution(self) -> None: + """Create the source distribution(s). First, we create the release + tree with 'make_release_tree()'; then, we create all required + archive files (according to 'self.formats') from the release tree. + Finally, we clean up by blowing away the release tree (unless + 'self.keep_temp' is true). The list of archive files created is + stored so it can be retrieved later by 'get_archive_files()'. + """ + # Don't warn about missing meta-data here -- should be (and is!) + # done elsewhere. + base_dir = self.distribution.get_fullname() + base_name = os.path.join(self.dist_dir, base_dir) + + self.make_release_tree(base_dir, self.filelist.files) + archive_files = [] # remember names of files we create + # tar archive must be created last to avoid overwrite and remove + if 'tar' in self.formats: + self.formats.append(self.formats.pop(self.formats.index('tar'))) + + for fmt in self.formats: + file = self.make_archive( + base_name, fmt, base_dir=base_dir, owner=self.owner, group=self.group + ) + archive_files.append(file) + self.distribution.dist_files.append(('sdist', '', file)) + + self.archive_files = archive_files + + if not self.keep_temp: + dir_util.remove_tree(base_dir) + + def get_archive_files(self): + """Return the list of archive files created when the command + was run, or None if the command hasn't run yet. + """ + return self.archive_files + + +def is_comment(line: str) -> bool: + return line.startswith('#') diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compat/__init__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compat/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2c43729b09ea5e5bf9d8c0708e63c69b5114a279 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compat/__init__.py @@ -0,0 +1,18 @@ +from __future__ import annotations + +from collections.abc import Iterable +from typing import TypeVar + +_IterableT = TypeVar("_IterableT", bound="Iterable[str]") + + +def consolidate_linker_args(args: _IterableT) -> _IterableT | str: + """ + Ensure the return value is a string for backward compatibility. + + Retain until at least 2025-04-31. See pypa/distutils#246 + """ + + if not all(arg.startswith('-Wl,') for arg in args): + return args + return '-Wl,' + ','.join(arg.removeprefix('-Wl,') for arg in args) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compat/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compat/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ede35cd8e2e18102ddcb705c85cae7715da648a3 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compat/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compat/__pycache__/numpy.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compat/__pycache__/numpy.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1042e0b64757867e8370d1e0c4daa6cbf8e2b35b Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compat/__pycache__/numpy.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compat/__pycache__/py39.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compat/__pycache__/py39.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..07f2b8a69ae90330161704f60d6f7a695e122603 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compat/__pycache__/py39.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compat/numpy.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compat/numpy.py new file mode 100644 index 0000000000000000000000000000000000000000..73eca7acb103b7c7ca8e7a9f7f2d772a64aa344b --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compat/numpy.py @@ -0,0 +1,2 @@ +# required for older numpy versions on Pythons prior to 3.12; see pypa/setuptools#4876 +from ..compilers.C.base import _default_compilers, compiler_class # noqa: F401 diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compat/py39.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compat/py39.py new file mode 100644 index 0000000000000000000000000000000000000000..1b436d76586cbcf38164548f3fc849ce1a3ff600 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compat/py39.py @@ -0,0 +1,66 @@ +import functools +import itertools +import platform +import sys + + +def add_ext_suffix_39(vars): + """ + Ensure vars contains 'EXT_SUFFIX'. pypa/distutils#130 + """ + import _imp + + ext_suffix = _imp.extension_suffixes()[0] + vars.update( + EXT_SUFFIX=ext_suffix, + # sysconfig sets SO to match EXT_SUFFIX, so maintain + # that expectation. + # https://github.com/python/cpython/blob/785cc6770588de087d09e89a69110af2542be208/Lib/sysconfig.py#L671-L673 + SO=ext_suffix, + ) + + +needs_ext_suffix = sys.version_info < (3, 10) and platform.system() == 'Windows' +add_ext_suffix = add_ext_suffix_39 if needs_ext_suffix else lambda vars: None + + +# from more_itertools +class UnequalIterablesError(ValueError): + def __init__(self, details=None): + msg = 'Iterables have different lengths' + if details is not None: + msg += (': index 0 has length {}; index {} has length {}').format(*details) + + super().__init__(msg) + + +# from more_itertools +def _zip_equal_generator(iterables): + _marker = object() + for combo in itertools.zip_longest(*iterables, fillvalue=_marker): + for val in combo: + if val is _marker: + raise UnequalIterablesError() + yield combo + + +# from more_itertools +def _zip_equal(*iterables): + # Check whether the iterables are all the same size. + try: + first_size = len(iterables[0]) + for i, it in enumerate(iterables[1:], 1): + size = len(it) + if size != first_size: + raise UnequalIterablesError(details=(first_size, i, size)) + # All sizes are equal, we can use the built-in zip. + return zip(*iterables) + # If any one of the iterables didn't have a length, start reading + # them until one runs out. + except TypeError: + return _zip_equal_generator(iterables) + + +zip_strict = ( + _zip_equal if sys.version_info < (3, 10) else functools.partial(zip, strict=True) +) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/base.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/base.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1a64fa7ff7ff54826f2347ec1edc513f951d3aea Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/base.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/cygwin.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/cygwin.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4bcace5837d1b6eb9114baeff2aef3c44574377e Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/cygwin.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/errors.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/errors.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6d4f8bcc6aca49be582ed446e978790d34f6164c Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/errors.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/msvc.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/msvc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a000700eac6968b205b909ee7acd8d8c898ab9d6 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/msvc.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/unix.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/unix.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2301e9eea8316a8fd8f6640dd8752603b4ca1f28 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/unix.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/zos.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/zos.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f1083b669906d7df06decd9120aa39038a181e24 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/zos.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/base.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/base.py new file mode 100644 index 0000000000000000000000000000000000000000..ea6b5458ef2b1d0c936cbfd9aaea19f5e41bbea9 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/base.py @@ -0,0 +1,1386 @@ +"""distutils.ccompiler + +Contains Compiler, an abstract base class that defines the interface +for the Distutils compiler abstraction model.""" + +from __future__ import annotations + +import os +import pathlib +import re +import sys +import warnings +from collections.abc import Callable, Iterable, MutableSequence, Sequence +from typing import ( + TYPE_CHECKING, + ClassVar, + Literal, + TypeVar, + Union, + overload, +) + +from more_itertools import always_iterable + +from ..._log import log +from ..._modified import newer_group +from ...dir_util import mkpath +from ...errors import ( + DistutilsModuleError, + DistutilsPlatformError, +) +from ...file_util import move_file +from ...spawn import spawn +from ...util import execute, is_mingw, split_quoted +from .errors import ( + CompileError, + LinkError, + UnknownFileType, +) + +if TYPE_CHECKING: + from typing_extensions import TypeAlias, TypeVarTuple, Unpack + + _Ts = TypeVarTuple("_Ts") + +_Macro: TypeAlias = Union[tuple[str], tuple[str, Union[str, None]]] +_StrPathT = TypeVar("_StrPathT", bound="str | os.PathLike[str]") +_BytesPathT = TypeVar("_BytesPathT", bound="bytes | os.PathLike[bytes]") + + +class Compiler: + """Abstract base class to define the interface that must be implemented + by real compiler classes. Also has some utility methods used by + several compiler classes. + + The basic idea behind a compiler abstraction class is that each + instance can be used for all the compile/link steps in building a + single project. Thus, attributes common to all of those compile and + link steps -- include directories, macros to define, libraries to link + against, etc. -- are attributes of the compiler instance. To allow for + variability in how individual files are treated, most of those + attributes may be varied on a per-compilation or per-link basis. + """ + + # 'compiler_type' is a class attribute that identifies this class. It + # keeps code that wants to know what kind of compiler it's dealing with + # from having to import all possible compiler classes just to do an + # 'isinstance'. In concrete CCompiler subclasses, 'compiler_type' + # should really, really be one of the keys of the 'compiler_class' + # dictionary (see below -- used by the 'new_compiler()' factory + # function) -- authors of new compiler interface classes are + # responsible for updating 'compiler_class'! + compiler_type: ClassVar[str] = None # type: ignore[assignment] + + # XXX things not handled by this compiler abstraction model: + # * client can't provide additional options for a compiler, + # e.g. warning, optimization, debugging flags. Perhaps this + # should be the domain of concrete compiler abstraction classes + # (UnixCCompiler, MSVCCompiler, etc.) -- or perhaps the base + # class should have methods for the common ones. + # * can't completely override the include or library searchg + # path, ie. no "cc -I -Idir1 -Idir2" or "cc -L -Ldir1 -Ldir2". + # I'm not sure how widely supported this is even by Unix + # compilers, much less on other platforms. And I'm even less + # sure how useful it is; maybe for cross-compiling, but + # support for that is a ways off. (And anyways, cross + # compilers probably have a dedicated binary with the + # right paths compiled in. I hope.) + # * can't do really freaky things with the library list/library + # dirs, e.g. "-Ldir1 -lfoo -Ldir2 -lfoo" to link against + # different versions of libfoo.a in different locations. I + # think this is useless without the ability to null out the + # library search path anyways. + + executables: ClassVar[dict] + + # Subclasses that rely on the standard filename generation methods + # implemented below should override these; see the comment near + # those methods ('object_filenames()' et. al.) for details: + src_extensions: ClassVar[list[str] | None] = None + obj_extension: ClassVar[str | None] = None + static_lib_extension: ClassVar[str | None] = None + shared_lib_extension: ClassVar[str | None] = None + static_lib_format: ClassVar[str | None] = None # format string + shared_lib_format: ClassVar[str | None] = None # prob. same as static_lib_format + exe_extension: ClassVar[str | None] = None + + # Default language settings. language_map is used to detect a source + # file or Extension target language, checking source filenames. + # language_order is used to detect the language precedence, when deciding + # what language to use when mixing source types. For example, if some + # extension has two files with ".c" extension, and one with ".cpp", it + # is still linked as c++. + language_map: ClassVar[dict[str, str]] = { + ".c": "c", + ".cc": "c++", + ".cpp": "c++", + ".cxx": "c++", + ".m": "objc", + } + language_order: ClassVar[list[str]] = ["c++", "objc", "c"] + + include_dirs: list[str] = [] + """ + include dirs specific to this compiler class + """ + + library_dirs: list[str] = [] + """ + library dirs specific to this compiler class + """ + + def __init__(self, verbose: bool = False, force: bool = False) -> None: + self.force = force + self.verbose = verbose + + # 'output_dir': a common output directory for object, library, + # shared object, and shared library files + self.output_dir: str | None = None + + # 'macros': a list of macro definitions (or undefinitions). A + # macro definition is a 2-tuple (name, value), where the value is + # either a string or None (no explicit value). A macro + # undefinition is a 1-tuple (name,). + self.macros: list[_Macro] = [] + + # 'include_dirs': a list of directories to search for include files + self.include_dirs = [] + + # 'libraries': a list of libraries to include in any link + # (library names, not filenames: eg. "foo" not "libfoo.a") + self.libraries: list[str] = [] + + # 'library_dirs': a list of directories to search for libraries + self.library_dirs = [] + + # 'runtime_library_dirs': a list of directories to search for + # shared libraries/objects at runtime + self.runtime_library_dirs: list[str] = [] + + # 'objects': a list of object files (or similar, such as explicitly + # named library files) to include on any link + self.objects: list[str] = [] + + for key in self.executables.keys(): + self.set_executable(key, self.executables[key]) + + def set_executables(self, **kwargs: str) -> None: + """Define the executables (and options for them) that will be run + to perform the various stages of compilation. The exact set of + executables that may be specified here depends on the compiler + class (via the 'executables' class attribute), but most will have: + compiler the C/C++ compiler + linker_so linker used to create shared objects and libraries + linker_exe linker used to create binary executables + archiver static library creator + + On platforms with a command-line (Unix, DOS/Windows), each of these + is a string that will be split into executable name and (optional) + list of arguments. (Splitting the string is done similarly to how + Unix shells operate: words are delimited by spaces, but quotes and + backslashes can override this. See + 'distutils.util.split_quoted()'.) + """ + + # Note that some CCompiler implementation classes will define class + # attributes 'cpp', 'cc', etc. with hard-coded executable names; + # this is appropriate when a compiler class is for exactly one + # compiler/OS combination (eg. MSVCCompiler). Other compiler + # classes (UnixCCompiler, in particular) are driven by information + # discovered at run-time, since there are many different ways to do + # basically the same things with Unix C compilers. + + for key in kwargs: + if key not in self.executables: + raise ValueError( + f"unknown executable '{key}' for class {self.__class__.__name__}" + ) + self.set_executable(key, kwargs[key]) + + def set_executable(self, key, value): + if isinstance(value, str): + setattr(self, key, split_quoted(value)) + else: + setattr(self, key, value) + + def _find_macro(self, name): + i = 0 + for defn in self.macros: + if defn[0] == name: + return i + i += 1 + return None + + def _check_macro_definitions(self, definitions): + """Ensure that every element of 'definitions' is valid.""" + for defn in definitions: + self._check_macro_definition(*defn) + + def _check_macro_definition(self, defn): + """ + Raise a TypeError if defn is not valid. + + A valid definition is either a (name, value) 2-tuple or a (name,) tuple. + """ + if not isinstance(defn, tuple) or not self._is_valid_macro(*defn): + raise TypeError( + f"invalid macro definition '{defn}': " + "must be tuple (string,), (string, string), or (string, None)" + ) + + @staticmethod + def _is_valid_macro(name, value=None): + """ + A valid macro is a ``name : str`` and a ``value : str | None``. + + >>> Compiler._is_valid_macro('foo', None) + True + """ + return isinstance(name, str) and isinstance(value, (str, type(None))) + + # -- Bookkeeping methods ------------------------------------------- + + def define_macro(self, name: str, value: str | None = None) -> None: + """Define a preprocessor macro for all compilations driven by this + compiler object. The optional parameter 'value' should be a + string; if it is not supplied, then the macro will be defined + without an explicit value and the exact outcome depends on the + compiler used (XXX true? does ANSI say anything about this?) + """ + # Delete from the list of macro definitions/undefinitions if + # already there (so that this one will take precedence). + i = self._find_macro(name) + if i is not None: + del self.macros[i] + + self.macros.append((name, value)) + + def undefine_macro(self, name: str) -> None: + """Undefine a preprocessor macro for all compilations driven by + this compiler object. If the same macro is defined by + 'define_macro()' and undefined by 'undefine_macro()' the last call + takes precedence (including multiple redefinitions or + undefinitions). If the macro is redefined/undefined on a + per-compilation basis (ie. in the call to 'compile()'), then that + takes precedence. + """ + # Delete from the list of macro definitions/undefinitions if + # already there (so that this one will take precedence). + i = self._find_macro(name) + if i is not None: + del self.macros[i] + + undefn = (name,) + self.macros.append(undefn) + + def add_include_dir(self, dir: str) -> None: + """Add 'dir' to the list of directories that will be searched for + header files. The compiler is instructed to search directories in + the order in which they are supplied by successive calls to + 'add_include_dir()'. + """ + self.include_dirs.append(dir) + + def set_include_dirs(self, dirs: list[str]) -> None: + """Set the list of directories that will be searched to 'dirs' (a + list of strings). Overrides any preceding calls to + 'add_include_dir()'; subsequence calls to 'add_include_dir()' add + to the list passed to 'set_include_dirs()'. This does not affect + any list of standard include directories that the compiler may + search by default. + """ + self.include_dirs = dirs[:] + + def add_library(self, libname: str) -> None: + """Add 'libname' to the list of libraries that will be included in + all links driven by this compiler object. Note that 'libname' + should *not* be the name of a file containing a library, but the + name of the library itself: the actual filename will be inferred by + the linker, the compiler, or the compiler class (depending on the + platform). + + The linker will be instructed to link against libraries in the + order they were supplied to 'add_library()' and/or + 'set_libraries()'. It is perfectly valid to duplicate library + names; the linker will be instructed to link against libraries as + many times as they are mentioned. + """ + self.libraries.append(libname) + + def set_libraries(self, libnames: list[str]) -> None: + """Set the list of libraries to be included in all links driven by + this compiler object to 'libnames' (a list of strings). This does + not affect any standard system libraries that the linker may + include by default. + """ + self.libraries = libnames[:] + + def add_library_dir(self, dir: str) -> None: + """Add 'dir' to the list of directories that will be searched for + libraries specified to 'add_library()' and 'set_libraries()'. The + linker will be instructed to search for libraries in the order they + are supplied to 'add_library_dir()' and/or 'set_library_dirs()'. + """ + self.library_dirs.append(dir) + + def set_library_dirs(self, dirs: list[str]) -> None: + """Set the list of library search directories to 'dirs' (a list of + strings). This does not affect any standard library search path + that the linker may search by default. + """ + self.library_dirs = dirs[:] + + def add_runtime_library_dir(self, dir: str) -> None: + """Add 'dir' to the list of directories that will be searched for + shared libraries at runtime. + """ + self.runtime_library_dirs.append(dir) + + def set_runtime_library_dirs(self, dirs: list[str]) -> None: + """Set the list of directories to search for shared libraries at + runtime to 'dirs' (a list of strings). This does not affect any + standard search path that the runtime linker may search by + default. + """ + self.runtime_library_dirs = dirs[:] + + def add_link_object(self, object: str) -> None: + """Add 'object' to the list of object files (or analogues, such as + explicitly named library files or the output of "resource + compilers") to be included in every link driven by this compiler + object. + """ + self.objects.append(object) + + def set_link_objects(self, objects: list[str]) -> None: + """Set the list of object files (or analogues) to be included in + every link to 'objects'. This does not affect any standard object + files that the linker may include by default (such as system + libraries). + """ + self.objects = objects[:] + + # -- Private utility methods -------------------------------------- + # (here for the convenience of subclasses) + + # Helper method to prep compiler in subclass compile() methods + + def _setup_compile( + self, + outdir: str | None, + macros: list[_Macro] | None, + incdirs: list[str] | tuple[str, ...] | None, + sources, + depends, + extra, + ): + """Process arguments and decide which source files to compile.""" + outdir, macros, incdirs = self._fix_compile_args(outdir, macros, incdirs) + + if extra is None: + extra = [] + + # Get the list of expected output (object) files + objects = self.object_filenames(sources, strip_dir=False, output_dir=outdir) + assert len(objects) == len(sources) + + pp_opts = gen_preprocess_options(macros, incdirs) + + build = {} + for i in range(len(sources)): + src = sources[i] + obj = objects[i] + ext = os.path.splitext(src)[1] + self.mkpath(os.path.dirname(obj)) + build[obj] = (src, ext) + + return macros, objects, extra, pp_opts, build + + def _get_cc_args(self, pp_opts, debug, before): + # works for unixccompiler, cygwinccompiler + cc_args = pp_opts + ['-c'] + if debug: + cc_args[:0] = ['-g'] + if before: + cc_args[:0] = before + return cc_args + + def _fix_compile_args( + self, + output_dir: str | None, + macros: list[_Macro] | None, + include_dirs: list[str] | tuple[str, ...] | None, + ) -> tuple[str, list[_Macro], list[str]]: + """Typecheck and fix-up some of the arguments to the 'compile()' + method, and return fixed-up values. Specifically: if 'output_dir' + is None, replaces it with 'self.output_dir'; ensures that 'macros' + is a list, and augments it with 'self.macros'; ensures that + 'include_dirs' is a list, and augments it with 'self.include_dirs'. + Guarantees that the returned values are of the correct type, + i.e. for 'output_dir' either string or None, and for 'macros' and + 'include_dirs' either list or None. + """ + if output_dir is None: + output_dir = self.output_dir + elif not isinstance(output_dir, str): + raise TypeError("'output_dir' must be a string or None") + + if macros is None: + macros = list(self.macros) + elif isinstance(macros, list): + macros = macros + (self.macros or []) + else: + raise TypeError("'macros' (if supplied) must be a list of tuples") + + if include_dirs is None: + include_dirs = list(self.include_dirs) + elif isinstance(include_dirs, (list, tuple)): + include_dirs = list(include_dirs) + (self.include_dirs or []) + else: + raise TypeError("'include_dirs' (if supplied) must be a list of strings") + + # add include dirs for class + include_dirs += self.__class__.include_dirs + + return output_dir, macros, include_dirs + + def _prep_compile(self, sources, output_dir, depends=None): + """Decide which source files must be recompiled. + + Determine the list of object files corresponding to 'sources', + and figure out which ones really need to be recompiled. + Return a list of all object files and a dictionary telling + which source files can be skipped. + """ + # Get the list of expected output (object) files + objects = self.object_filenames(sources, output_dir=output_dir) + assert len(objects) == len(sources) + + # Return an empty dict for the "which source files can be skipped" + # return value to preserve API compatibility. + return objects, {} + + def _fix_object_args( + self, objects: list[str] | tuple[str, ...], output_dir: str | None + ) -> tuple[list[str], str]: + """Typecheck and fix up some arguments supplied to various methods. + Specifically: ensure that 'objects' is a list; if output_dir is + None, replace with self.output_dir. Return fixed versions of + 'objects' and 'output_dir'. + """ + if not isinstance(objects, (list, tuple)): + raise TypeError("'objects' must be a list or tuple of strings") + objects = list(objects) + + if output_dir is None: + output_dir = self.output_dir + elif not isinstance(output_dir, str): + raise TypeError("'output_dir' must be a string or None") + + return (objects, output_dir) + + def _fix_lib_args( + self, + libraries: list[str] | tuple[str, ...] | None, + library_dirs: list[str] | tuple[str, ...] | None, + runtime_library_dirs: list[str] | tuple[str, ...] | None, + ) -> tuple[list[str], list[str], list[str]]: + """Typecheck and fix up some of the arguments supplied to the + 'link_*' methods. Specifically: ensure that all arguments are + lists, and augment them with their permanent versions + (eg. 'self.libraries' augments 'libraries'). Return a tuple with + fixed versions of all arguments. + """ + if libraries is None: + libraries = list(self.libraries) + elif isinstance(libraries, (list, tuple)): + libraries = list(libraries) + (self.libraries or []) + else: + raise TypeError("'libraries' (if supplied) must be a list of strings") + + if library_dirs is None: + library_dirs = list(self.library_dirs) + elif isinstance(library_dirs, (list, tuple)): + library_dirs = list(library_dirs) + (self.library_dirs or []) + else: + raise TypeError("'library_dirs' (if supplied) must be a list of strings") + + # add library dirs for class + library_dirs += self.__class__.library_dirs + + if runtime_library_dirs is None: + runtime_library_dirs = list(self.runtime_library_dirs) + elif isinstance(runtime_library_dirs, (list, tuple)): + runtime_library_dirs = list(runtime_library_dirs) + ( + self.runtime_library_dirs or [] + ) + else: + raise TypeError( + "'runtime_library_dirs' (if supplied) must be a list of strings" + ) + + return (libraries, library_dirs, runtime_library_dirs) + + def _need_link(self, objects, output_file): + """Return true if we need to relink the files listed in 'objects' + to recreate 'output_file'. + """ + if self.force: + return True + newer = newer_group(objects, output_file) + return newer + + def detect_language(self, sources: str | list[str]) -> str | None: + """Detect the language of a given file, or list of files. Uses + language_map, and language_order to do the job. + """ + if not isinstance(sources, list): + sources = [sources] + lang = None + index = len(self.language_order) + for source in sources: + base, ext = os.path.splitext(source) + extlang = self.language_map.get(ext) + try: + extindex = self.language_order.index(extlang) + if extindex < index: + lang = extlang + index = extindex + except ValueError: + pass + return lang + + # -- Worker methods ------------------------------------------------ + # (must be implemented by subclasses) + + def preprocess( + self, + source: str | os.PathLike[str], + output_file: str | os.PathLike[str] | None = None, + macros: list[_Macro] | None = None, + include_dirs: list[str] | tuple[str, ...] | None = None, + extra_preargs: list[str] | None = None, + extra_postargs: Iterable[str] | None = None, + ): + """Preprocess a single C/C++ source file, named in 'source'. + Output will be written to file named 'output_file', or stdout if + 'output_file' not supplied. 'macros' is a list of macro + definitions as for 'compile()', which will augment the macros set + with 'define_macro()' and 'undefine_macro()'. 'include_dirs' is a + list of directory names that will be added to the default list. + + Raises PreprocessError on failure. + """ + pass + + def compile( + self, + sources: Sequence[str | os.PathLike[str]], + output_dir: str | None = None, + macros: list[_Macro] | None = None, + include_dirs: list[str] | tuple[str, ...] | None = None, + debug: bool = False, + extra_preargs: list[str] | None = None, + extra_postargs: list[str] | None = None, + depends: list[str] | tuple[str, ...] | None = None, + ) -> list[str]: + """Compile one or more source files. + + 'sources' must be a list of filenames, most likely C/C++ + files, but in reality anything that can be handled by a + particular compiler and compiler class (eg. MSVCCompiler can + handle resource files in 'sources'). Return a list of object + filenames, one per source filename in 'sources'. Depending on + the implementation, not all source files will necessarily be + compiled, but all corresponding object filenames will be + returned. + + If 'output_dir' is given, object files will be put under it, while + retaining their original path component. That is, "foo/bar.c" + normally compiles to "foo/bar.o" (for a Unix implementation); if + 'output_dir' is "build", then it would compile to + "build/foo/bar.o". + + 'macros', if given, must be a list of macro definitions. A macro + definition is either a (name, value) 2-tuple or a (name,) 1-tuple. + The former defines a macro; if the value is None, the macro is + defined without an explicit value. The 1-tuple case undefines a + macro. Later definitions/redefinitions/ undefinitions take + precedence. + + 'include_dirs', if given, must be a list of strings, the + directories to add to the default include file search path for this + compilation only. + + 'debug' is a boolean; if true, the compiler will be instructed to + output debug symbols in (or alongside) the object file(s). + + 'extra_preargs' and 'extra_postargs' are implementation- dependent. + On platforms that have the notion of a command-line (e.g. Unix, + DOS/Windows), they are most likely lists of strings: extra + command-line arguments to prepend/append to the compiler command + line. On other platforms, consult the implementation class + documentation. In any event, they are intended as an escape hatch + for those occasions when the abstract compiler framework doesn't + cut the mustard. + + 'depends', if given, is a list of filenames that all targets + depend on. If a source file is older than any file in + depends, then the source file will be recompiled. This + supports dependency tracking, but only at a coarse + granularity. + + Raises CompileError on failure. + """ + # A concrete compiler class can either override this method + # entirely or implement _compile(). + macros, objects, extra_postargs, pp_opts, build = self._setup_compile( + output_dir, macros, include_dirs, sources, depends, extra_postargs + ) + cc_args = self._get_cc_args(pp_opts, debug, extra_preargs) + + for obj in objects: + try: + src, ext = build[obj] + except KeyError: + continue + self._compile(obj, src, ext, cc_args, extra_postargs, pp_opts) + + # Return *all* object filenames, not just the ones we just built. + return objects + + def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts): + """Compile 'src' to product 'obj'.""" + # A concrete compiler class that does not override compile() + # should implement _compile(). + pass + + def create_static_lib( + self, + objects: list[str] | tuple[str, ...], + output_libname: str, + output_dir: str | None = None, + debug: bool = False, + target_lang: str | None = None, + ) -> None: + """Link a bunch of stuff together to create a static library file. + The "bunch of stuff" consists of the list of object files supplied + as 'objects', the extra object files supplied to + 'add_link_object()' and/or 'set_link_objects()', the libraries + supplied to 'add_library()' and/or 'set_libraries()', and the + libraries supplied as 'libraries' (if any). + + 'output_libname' should be a library name, not a filename; the + filename will be inferred from the library name. 'output_dir' is + the directory where the library file will be put. + + 'debug' is a boolean; if true, debugging information will be + included in the library (note that on most platforms, it is the + compile step where this matters: the 'debug' flag is included here + just for consistency). + + 'target_lang' is the target language for which the given objects + are being compiled. This allows specific linkage time treatment of + certain languages. + + Raises LibError on failure. + """ + pass + + # values for target_desc parameter in link() + SHARED_OBJECT = "shared_object" + SHARED_LIBRARY = "shared_library" + EXECUTABLE = "executable" + + def link( + self, + target_desc: str, + objects: list[str] | tuple[str, ...], + output_filename: str, + output_dir: str | None = None, + libraries: list[str] | tuple[str, ...] | None = None, + library_dirs: list[str] | tuple[str, ...] | None = None, + runtime_library_dirs: list[str] | tuple[str, ...] | None = None, + export_symbols: Iterable[str] | None = None, + debug: bool = False, + extra_preargs: list[str] | None = None, + extra_postargs: list[str] | None = None, + build_temp: str | os.PathLike[str] | None = None, + target_lang: str | None = None, + ): + """Link a bunch of stuff together to create an executable or + shared library file. + + The "bunch of stuff" consists of the list of object files supplied + as 'objects'. 'output_filename' should be a filename. If + 'output_dir' is supplied, 'output_filename' is relative to it + (i.e. 'output_filename' can provide directory components if + needed). + + 'libraries' is a list of libraries to link against. These are + library names, not filenames, since they're translated into + filenames in a platform-specific way (eg. "foo" becomes "libfoo.a" + on Unix and "foo.lib" on DOS/Windows). However, they can include a + directory component, which means the linker will look in that + specific directory rather than searching all the normal locations. + + 'library_dirs', if supplied, should be a list of directories to + search for libraries that were specified as bare library names + (ie. no directory component). These are on top of the system + default and those supplied to 'add_library_dir()' and/or + 'set_library_dirs()'. 'runtime_library_dirs' is a list of + directories that will be embedded into the shared library and used + to search for other shared libraries that *it* depends on at + run-time. (This may only be relevant on Unix.) + + 'export_symbols' is a list of symbols that the shared library will + export. (This appears to be relevant only on Windows.) + + 'debug' is as for 'compile()' and 'create_static_lib()', with the + slight distinction that it actually matters on most platforms (as + opposed to 'create_static_lib()', which includes a 'debug' flag + mostly for form's sake). + + 'extra_preargs' and 'extra_postargs' are as for 'compile()' (except + of course that they supply command-line arguments for the + particular linker being used). + + 'target_lang' is the target language for which the given objects + are being compiled. This allows specific linkage time treatment of + certain languages. + + Raises LinkError on failure. + """ + raise NotImplementedError + + # Old 'link_*()' methods, rewritten to use the new 'link()' method. + + def link_shared_lib( + self, + objects: list[str] | tuple[str, ...], + output_libname: str, + output_dir: str | None = None, + libraries: list[str] | tuple[str, ...] | None = None, + library_dirs: list[str] | tuple[str, ...] | None = None, + runtime_library_dirs: list[str] | tuple[str, ...] | None = None, + export_symbols: Iterable[str] | None = None, + debug: bool = False, + extra_preargs: list[str] | None = None, + extra_postargs: list[str] | None = None, + build_temp: str | os.PathLike[str] | None = None, + target_lang: str | None = None, + ): + self.link( + Compiler.SHARED_LIBRARY, + objects, + self.library_filename(output_libname, lib_type='shared'), + output_dir, + libraries, + library_dirs, + runtime_library_dirs, + export_symbols, + debug, + extra_preargs, + extra_postargs, + build_temp, + target_lang, + ) + + def link_shared_object( + self, + objects: list[str] | tuple[str, ...], + output_filename: str, + output_dir: str | None = None, + libraries: list[str] | tuple[str, ...] | None = None, + library_dirs: list[str] | tuple[str, ...] | None = None, + runtime_library_dirs: list[str] | tuple[str, ...] | None = None, + export_symbols: Iterable[str] | None = None, + debug: bool = False, + extra_preargs: list[str] | None = None, + extra_postargs: list[str] | None = None, + build_temp: str | os.PathLike[str] | None = None, + target_lang: str | None = None, + ): + self.link( + Compiler.SHARED_OBJECT, + objects, + output_filename, + output_dir, + libraries, + library_dirs, + runtime_library_dirs, + export_symbols, + debug, + extra_preargs, + extra_postargs, + build_temp, + target_lang, + ) + + def link_executable( + self, + objects: list[str] | tuple[str, ...], + output_progname: str, + output_dir: str | None = None, + libraries: list[str] | tuple[str, ...] | None = None, + library_dirs: list[str] | tuple[str, ...] | None = None, + runtime_library_dirs: list[str] | tuple[str, ...] | None = None, + debug: bool = False, + extra_preargs: list[str] | None = None, + extra_postargs: list[str] | None = None, + target_lang: str | None = None, + ): + self.link( + Compiler.EXECUTABLE, + objects, + self.executable_filename(output_progname), + output_dir, + libraries, + library_dirs, + runtime_library_dirs, + None, + debug, + extra_preargs, + extra_postargs, + None, + target_lang, + ) + + # -- Miscellaneous methods ----------------------------------------- + # These are all used by the 'gen_lib_options() function; there is + # no appropriate default implementation so subclasses should + # implement all of these. + + def library_dir_option(self, dir: str) -> str: + """Return the compiler option to add 'dir' to the list of + directories searched for libraries. + """ + raise NotImplementedError + + def runtime_library_dir_option(self, dir: str) -> str: + """Return the compiler option to add 'dir' to the list of + directories searched for runtime libraries. + """ + raise NotImplementedError + + def library_option(self, lib: str) -> str: + """Return the compiler option to add 'lib' to the list of libraries + linked into the shared library or executable. + """ + raise NotImplementedError + + def has_function( # noqa: C901 + self, + funcname: str, + includes: Iterable[str] | None = None, + include_dirs: list[str] | tuple[str, ...] | None = None, + libraries: list[str] | None = None, + library_dirs: list[str] | tuple[str, ...] | None = None, + ) -> bool: + """Return a boolean indicating whether funcname is provided as + a symbol on the current platform. The optional arguments can + be used to augment the compilation environment. + + The libraries argument is a list of flags to be passed to the + linker to make additional symbol definitions available for + linking. + + The includes and include_dirs arguments are deprecated. + Usually, supplying include files with function declarations + will cause function detection to fail even in cases where the + symbol is available for linking. + + """ + # this can't be included at module scope because it tries to + # import math which might not be available at that point - maybe + # the necessary logic should just be inlined? + import tempfile + + if includes is None: + includes = [] + else: + warnings.warn("includes is deprecated", DeprecationWarning) + if include_dirs is None: + include_dirs = [] + else: + warnings.warn("include_dirs is deprecated", DeprecationWarning) + if libraries is None: + libraries = [] + if library_dirs is None: + library_dirs = [] + fd, fname = tempfile.mkstemp(".c", funcname, text=True) + with os.fdopen(fd, "w", encoding='utf-8') as f: + for incl in includes: + f.write(f"""#include "{incl}"\n""") + if not includes: + # Use "char func(void);" as the prototype to follow + # what autoconf does. This prototype does not match + # any well-known function the compiler might recognize + # as a builtin, so this ends up as a true link test. + # Without a fake prototype, the test would need to + # know the exact argument types, and the has_function + # interface does not provide that level of information. + f.write( + f"""\ +#ifdef __cplusplus +extern "C" +#endif +char {funcname}(void); +""" + ) + f.write( + f"""\ +int main (int argc, char **argv) {{ + {funcname}(); + return 0; +}} +""" + ) + + try: + objects = self.compile([fname], include_dirs=include_dirs) + except CompileError: + return False + finally: + os.remove(fname) + + try: + self.link_executable( + objects, "a.out", libraries=libraries, library_dirs=library_dirs + ) + except (LinkError, TypeError): + return False + else: + os.remove( + self.executable_filename("a.out", output_dir=self.output_dir or '') + ) + finally: + for fn in objects: + os.remove(fn) + return True + + def find_library_file( + self, dirs: Iterable[str], lib: str, debug: bool = False + ) -> str | None: + """Search the specified list of directories for a static or shared + library file 'lib' and return the full path to that file. If + 'debug' true, look for a debugging version (if that makes sense on + the current platform). Return None if 'lib' wasn't found in any of + the specified directories. + """ + raise NotImplementedError + + # -- Filename generation methods ----------------------------------- + + # The default implementation of the filename generating methods are + # prejudiced towards the Unix/DOS/Windows view of the world: + # * object files are named by replacing the source file extension + # (eg. .c/.cpp -> .o/.obj) + # * library files (shared or static) are named by plugging the + # library name and extension into a format string, eg. + # "lib%s.%s" % (lib_name, ".a") for Unix static libraries + # * executables are named by appending an extension (possibly + # empty) to the program name: eg. progname + ".exe" for + # Windows + # + # To reduce redundant code, these methods expect to find + # several attributes in the current object (presumably defined + # as class attributes): + # * src_extensions - + # list of C/C++ source file extensions, eg. ['.c', '.cpp'] + # * obj_extension - + # object file extension, eg. '.o' or '.obj' + # * static_lib_extension - + # extension for static library files, eg. '.a' or '.lib' + # * shared_lib_extension - + # extension for shared library/object files, eg. '.so', '.dll' + # * static_lib_format - + # format string for generating static library filenames, + # eg. 'lib%s.%s' or '%s.%s' + # * shared_lib_format + # format string for generating shared library filenames + # (probably same as static_lib_format, since the extension + # is one of the intended parameters to the format string) + # * exe_extension - + # extension for executable files, eg. '' or '.exe' + + def object_filenames( + self, + source_filenames: Iterable[str | os.PathLike[str]], + strip_dir: bool = False, + output_dir: str | os.PathLike[str] | None = '', + ) -> list[str]: + if output_dir is None: + output_dir = '' + return list( + self._make_out_path(output_dir, strip_dir, src_name) + for src_name in source_filenames + ) + + @property + def out_extensions(self): + return dict.fromkeys(self.src_extensions, self.obj_extension) + + def _make_out_path(self, output_dir, strip_dir, src_name): + return self._make_out_path_exts( + output_dir, strip_dir, src_name, self.out_extensions + ) + + @classmethod + def _make_out_path_exts(cls, output_dir, strip_dir, src_name, extensions): + r""" + >>> exts = {'.c': '.o'} + >>> Compiler._make_out_path_exts('.', False, '/foo/bar.c', exts).replace('\\', '/') + './foo/bar.o' + >>> Compiler._make_out_path_exts('.', True, '/foo/bar.c', exts).replace('\\', '/') + './bar.o' + """ + src = pathlib.PurePath(src_name) + # Ensure base is relative to honor output_dir (python/cpython#37775). + base = cls._make_relative(src) + try: + new_ext = extensions[src.suffix] + except LookupError: + raise UnknownFileType(f"unknown file type '{src.suffix}' (from '{src}')") + if strip_dir: + base = pathlib.PurePath(base.name) + return os.path.join(output_dir, base.with_suffix(new_ext)) + + @staticmethod + def _make_relative(base: pathlib.Path): + return base.relative_to(base.anchor) + + @overload + def shared_object_filename( + self, + basename: str, + strip_dir: Literal[False] = False, + output_dir: str | os.PathLike[str] = "", + ) -> str: ... + @overload + def shared_object_filename( + self, + basename: str | os.PathLike[str], + strip_dir: Literal[True], + output_dir: str | os.PathLike[str] = "", + ) -> str: ... + def shared_object_filename( + self, + basename: str | os.PathLike[str], + strip_dir: bool = False, + output_dir: str | os.PathLike[str] = '', + ) -> str: + assert output_dir is not None + if strip_dir: + basename = os.path.basename(basename) + return os.path.join(output_dir, basename + self.shared_lib_extension) + + @overload + def executable_filename( + self, + basename: str, + strip_dir: Literal[False] = False, + output_dir: str | os.PathLike[str] = "", + ) -> str: ... + @overload + def executable_filename( + self, + basename: str | os.PathLike[str], + strip_dir: Literal[True], + output_dir: str | os.PathLike[str] = "", + ) -> str: ... + def executable_filename( + self, + basename: str | os.PathLike[str], + strip_dir: bool = False, + output_dir: str | os.PathLike[str] = '', + ) -> str: + assert output_dir is not None + if strip_dir: + basename = os.path.basename(basename) + return os.path.join(output_dir, basename + (self.exe_extension or '')) + + def library_filename( + self, + libname: str, + lib_type: str = "static", + strip_dir: bool = False, + output_dir: str | os.PathLike[str] = "", # or 'shared' + ): + assert output_dir is not None + expected = '"static", "shared", "dylib", "xcode_stub"' + if lib_type not in eval(expected): + raise ValueError(f"'lib_type' must be {expected}") + fmt = getattr(self, lib_type + "_lib_format") + ext = getattr(self, lib_type + "_lib_extension") + + dir, base = os.path.split(libname) + filename = fmt % (base, ext) + if strip_dir: + dir = '' + + return os.path.join(output_dir, dir, filename) + + # -- Utility methods ----------------------------------------------- + + def announce(self, msg: object, level: int = 1) -> None: + log.debug(msg) + + def debug_print(self, msg: object) -> None: + from distutils.debug import DEBUG + + if DEBUG: + print(msg) + + def warn(self, msg: object) -> None: + sys.stderr.write(f"warning: {msg}\n") + + def execute( + self, + func: Callable[[Unpack[_Ts]], object], + args: tuple[Unpack[_Ts]], + msg: object = None, + level: int = 1, + ) -> None: + execute(func, args, msg) + + def spawn( + self, cmd: MutableSequence[bytes | str | os.PathLike[str]], **kwargs + ) -> None: + spawn(cmd, **kwargs) + + @overload + def move_file( + self, src: str | os.PathLike[str], dst: _StrPathT + ) -> _StrPathT | str: ... + @overload + def move_file( + self, src: bytes | os.PathLike[bytes], dst: _BytesPathT + ) -> _BytesPathT | bytes: ... + def move_file( + self, + src: str | os.PathLike[str] | bytes | os.PathLike[bytes], + dst: str | os.PathLike[str] | bytes | os.PathLike[bytes], + ) -> str | os.PathLike[str] | bytes | os.PathLike[bytes]: + return move_file(src, dst) + + def mkpath(self, name, mode=0o777): + mkpath(name, mode) + + +# Map a sys.platform/os.name ('posix', 'nt') to the default compiler +# type for that platform. Keys are interpreted as re match +# patterns. Order is important; platform mappings are preferred over +# OS names. +_default_compilers = ( + # Platform string mappings + # on a cygwin built python we can use gcc like an ordinary UNIXish + # compiler + ('cygwin.*', 'unix'), + ('zos', 'zos'), + # OS name mappings + ('posix', 'unix'), + ('nt', 'msvc'), +) + + +def get_default_compiler(osname: str | None = None, platform: str | None = None) -> str: + """Determine the default compiler to use for the given platform. + + osname should be one of the standard Python OS names (i.e. the + ones returned by os.name) and platform the common value + returned by sys.platform for the platform in question. + + The default values are os.name and sys.platform in case the + parameters are not given. + """ + if osname is None: + osname = os.name + if platform is None: + platform = sys.platform + # Mingw is a special case where sys.platform is 'win32' but we + # want to use the 'mingw32' compiler, so check it first + if is_mingw(): + return 'mingw32' + for pattern, compiler in _default_compilers: + if ( + re.match(pattern, platform) is not None + or re.match(pattern, osname) is not None + ): + return compiler + # Default to Unix compiler + return 'unix' + + +# Map compiler types to (module_name, class_name) pairs -- ie. where to +# find the code that implements an interface to this compiler. (The module +# is assumed to be in the 'distutils' package.) +compiler_class = { + 'unix': ('unixccompiler', 'UnixCCompiler', "standard UNIX-style compiler"), + 'msvc': ('_msvccompiler', 'MSVCCompiler', "Microsoft Visual C++"), + 'cygwin': ( + 'cygwinccompiler', + 'CygwinCCompiler', + "Cygwin port of GNU C Compiler for Win32", + ), + 'mingw32': ( + 'cygwinccompiler', + 'Mingw32CCompiler', + "Mingw32 port of GNU C Compiler for Win32", + ), + 'bcpp': ('bcppcompiler', 'BCPPCompiler', "Borland C++ Compiler"), + 'zos': ('zosccompiler', 'zOSCCompiler', 'IBM XL C/C++ Compilers'), +} + + +def show_compilers() -> None: + """Print list of available compilers (used by the "--help-compiler" + options to "build", "build_ext", "build_clib"). + """ + # XXX this "knows" that the compiler option it's describing is + # "--compiler", which just happens to be the case for the three + # commands that use it. + from distutils.fancy_getopt import FancyGetopt + + compilers = sorted( + ("compiler=" + compiler, None, compiler_class[compiler][2]) + for compiler in compiler_class.keys() + ) + pretty_printer = FancyGetopt(compilers) + pretty_printer.print_help("List of available compilers:") + + +def new_compiler( + plat: str | None = None, + compiler: str | None = None, + verbose: bool = False, + force: bool = False, +) -> Compiler: + """Generate an instance of some CCompiler subclass for the supplied + platform/compiler combination. 'plat' defaults to 'os.name' + (eg. 'posix', 'nt'), and 'compiler' defaults to the default compiler + for that platform. Currently only 'posix' and 'nt' are supported, and + the default compilers are "traditional Unix interface" (UnixCCompiler + class) and Visual C++ (MSVCCompiler class). Note that it's perfectly + possible to ask for a Unix compiler object under Windows, and a + Microsoft compiler object under Unix -- if you supply a value for + 'compiler', 'plat' is ignored. + """ + if plat is None: + plat = os.name + + try: + if compiler is None: + compiler = get_default_compiler(plat) + + (module_name, class_name, long_description) = compiler_class[compiler] + except KeyError: + msg = f"don't know how to compile C/C++ code on platform '{plat}'" + if compiler is not None: + msg = msg + f" with '{compiler}' compiler" + raise DistutilsPlatformError(msg) + + try: + module_name = "distutils." + module_name + __import__(module_name) + module = sys.modules[module_name] + klass = vars(module)[class_name] + except ImportError: + raise DistutilsModuleError( + f"can't compile C/C++ code: unable to load module '{module_name}'" + ) + except KeyError: + raise DistutilsModuleError( + f"can't compile C/C++ code: unable to find class '{class_name}' " + f"in module '{module_name}'" + ) + + # XXX The None is necessary to preserve backwards compatibility + # with classes that expect verbose to be the first positional + # argument. + return klass(None, force=force) + + +def gen_preprocess_options( + macros: Iterable[_Macro], include_dirs: Iterable[str] +) -> list[str]: + """Generate C pre-processor options (-D, -U, -I) as used by at least + two types of compilers: the typical Unix compiler and Visual C++. + 'macros' is the usual thing, a list of 1- or 2-tuples, where (name,) + means undefine (-U) macro 'name', and (name,value) means define (-D) + macro 'name' to 'value'. 'include_dirs' is just a list of directory + names to be added to the header file search path (-I). Returns a list + of command-line options suitable for either Unix compilers or Visual + C++. + """ + # XXX it would be nice (mainly aesthetic, and so we don't generate + # stupid-looking command lines) to go over 'macros' and eliminate + # redundant definitions/undefinitions (ie. ensure that only the + # latest mention of a particular macro winds up on the command + # line). I don't think it's essential, though, since most (all?) + # Unix C compilers only pay attention to the latest -D or -U + # mention of a macro on their command line. Similar situation for + # 'include_dirs'. I'm punting on both for now. Anyways, weeding out + # redundancies like this should probably be the province of + # CCompiler, since the data structures used are inherited from it + # and therefore common to all CCompiler classes. + pp_opts = [] + for macro in macros: + if not (isinstance(macro, tuple) and 1 <= len(macro) <= 2): + raise TypeError( + f"bad macro definition '{macro}': " + "each element of 'macros' list must be a 1- or 2-tuple" + ) + + if len(macro) == 1: # undefine this macro + pp_opts.append(f"-U{macro[0]}") + elif len(macro) == 2: + if macro[1] is None: # define with no explicit value + pp_opts.append(f"-D{macro[0]}") + else: + # XXX *don't* need to be clever about quoting the + # macro value here, because we're going to avoid the + # shell at all costs when we spawn the command! + pp_opts.append("-D{}={}".format(*macro)) + + pp_opts.extend(f"-I{dir}" for dir in include_dirs) + return pp_opts + + +def gen_lib_options( + compiler: Compiler, + library_dirs: Iterable[str], + runtime_library_dirs: Iterable[str], + libraries: Iterable[str], +) -> list[str]: + """Generate linker options for searching library directories and + linking with specific libraries. 'libraries' and 'library_dirs' are, + respectively, lists of library names (not filenames!) and search + directories. Returns a list of command-line options suitable for use + with some compiler (depending on the two format strings passed in). + """ + lib_opts = [compiler.library_dir_option(dir) for dir in library_dirs] + + for dir in runtime_library_dirs: + lib_opts.extend(always_iterable(compiler.runtime_library_dir_option(dir))) + + # XXX it's important that we *not* remove redundant library mentions! + # sometimes you really do have to say "-lfoo -lbar -lfoo" in order to + # resolve all symbols. I just hope we never have to say "-lfoo obj.o + # -lbar" to get things to work -- that's certainly a possibility, but a + # pretty nasty way to arrange your C code. + + for lib in libraries: + (lib_dir, lib_name) = os.path.split(lib) + if lib_dir: + lib_file = compiler.find_library_file([lib_dir], lib_name) + if lib_file: + lib_opts.append(lib_file) + else: + compiler.warn( + f"no library file corresponding to '{lib}' found (skipping)" + ) + else: + lib_opts.append(compiler.library_option(lib)) + return lib_opts diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/cygwin.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/cygwin.py new file mode 100644 index 0000000000000000000000000000000000000000..f349e9decd083ad60a9b9d1181b57e1bbcce2c98 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/cygwin.py @@ -0,0 +1,340 @@ +"""distutils.cygwinccompiler + +Provides the CygwinCCompiler class, a subclass of UnixCCompiler that +handles the Cygwin port of the GNU C compiler to Windows. It also contains +the Mingw32CCompiler class which handles the mingw32 port of GCC (same as +cygwin in no-cygwin mode). +""" + +import copy +import os +import pathlib +import shlex +import sys +import warnings +from subprocess import check_output + +from ...errors import ( + DistutilsExecError, + DistutilsPlatformError, +) +from ...file_util import write_file +from ...sysconfig import get_config_vars +from ...version import LooseVersion, suppress_known_deprecation +from . import unix +from .errors import ( + CompileError, + Error, +) + + +def get_msvcr(): + """No longer needed, but kept for backward compatibility.""" + return [] + + +_runtime_library_dirs_msg = ( + "Unable to set runtime library search path on Windows, " + "usually indicated by `runtime_library_dirs` parameter to Extension" +) + + +class Compiler(unix.Compiler): + """Handles the Cygwin port of the GNU C compiler to Windows.""" + + compiler_type = 'cygwin' + obj_extension = ".o" + static_lib_extension = ".a" + shared_lib_extension = ".dll.a" + dylib_lib_extension = ".dll" + static_lib_format = "lib%s%s" + shared_lib_format = "lib%s%s" + dylib_lib_format = "cyg%s%s" + exe_extension = ".exe" + + def __init__(self, verbose=False, force=False): + super().__init__(verbose, force=force) + + status, details = check_config_h() + self.debug_print(f"Python's GCC status: {status} (details: {details})") + if status is not CONFIG_H_OK: + self.warn( + "Python's pyconfig.h doesn't seem to support your compiler. " + f"Reason: {details}. " + "Compiling may fail because of undefined preprocessor macros." + ) + + self.cc, self.cxx = get_config_vars('CC', 'CXX') + + # Override 'CC' and 'CXX' environment variables for + # building using MINGW compiler for MSVC python. + self.cc = os.environ.get('CC', self.cc or 'gcc') + self.cxx = os.environ.get('CXX', self.cxx or 'g++') + + self.linker_dll = self.cc + self.linker_dll_cxx = self.cxx + shared_option = "-shared" + + self.set_executables( + compiler=f'{self.cc} -mcygwin -O -Wall', + compiler_so=f'{self.cc} -mcygwin -mdll -O -Wall', + compiler_cxx=f'{self.cxx} -mcygwin -O -Wall', + compiler_so_cxx=f'{self.cxx} -mcygwin -mdll -O -Wall', + linker_exe=f'{self.cc} -mcygwin', + linker_so=f'{self.linker_dll} -mcygwin {shared_option}', + linker_exe_cxx=f'{self.cxx} -mcygwin', + linker_so_cxx=f'{self.linker_dll_cxx} -mcygwin {shared_option}', + ) + + self.dll_libraries = get_msvcr() + + @property + def gcc_version(self): + # Older numpy depended on this existing to check for ancient + # gcc versions. This doesn't make much sense with clang etc so + # just hardcode to something recent. + # https://github.com/numpy/numpy/pull/20333 + warnings.warn( + "gcc_version attribute of CygwinCCompiler is deprecated. " + "Instead of returning actual gcc version a fixed value 11.2.0 is returned.", + DeprecationWarning, + stacklevel=2, + ) + with suppress_known_deprecation(): + return LooseVersion("11.2.0") + + def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts): + """Compiles the source by spawning GCC and windres if needed.""" + if ext in ('.rc', '.res'): + # gcc needs '.res' and '.rc' compiled to object files !!! + try: + self.spawn(["windres", "-i", src, "-o", obj]) + except DistutilsExecError as msg: + raise CompileError(msg) + else: # for other files use the C-compiler + try: + if self.detect_language(src) == 'c++': + self.spawn( + self.compiler_so_cxx + + cc_args + + [src, '-o', obj] + + extra_postargs + ) + else: + self.spawn( + self.compiler_so + cc_args + [src, '-o', obj] + extra_postargs + ) + except DistutilsExecError as msg: + raise CompileError(msg) + + def link( + self, + target_desc, + objects, + output_filename, + output_dir=None, + libraries=None, + library_dirs=None, + runtime_library_dirs=None, + export_symbols=None, + debug=False, + extra_preargs=None, + extra_postargs=None, + build_temp=None, + target_lang=None, + ): + """Link the objects.""" + # use separate copies, so we can modify the lists + extra_preargs = copy.copy(extra_preargs or []) + libraries = copy.copy(libraries or []) + objects = copy.copy(objects or []) + + if runtime_library_dirs: + self.warn(_runtime_library_dirs_msg) + + # Additional libraries + libraries.extend(self.dll_libraries) + + # handle export symbols by creating a def-file + # with executables this only works with gcc/ld as linker + if (export_symbols is not None) and ( + target_desc != self.EXECUTABLE or self.linker_dll == "gcc" + ): + # (The linker doesn't do anything if output is up-to-date. + # So it would probably better to check if we really need this, + # but for this we had to insert some unchanged parts of + # UnixCCompiler, and this is not what we want.) + + # we want to put some files in the same directory as the + # object files are, build_temp doesn't help much + # where are the object files + temp_dir = os.path.dirname(objects[0]) + # name of dll to give the helper files the same base name + (dll_name, dll_extension) = os.path.splitext( + os.path.basename(output_filename) + ) + + # generate the filenames for these files + def_file = os.path.join(temp_dir, dll_name + ".def") + + # Generate .def file + contents = [f"LIBRARY {os.path.basename(output_filename)}", "EXPORTS"] + contents.extend(export_symbols) + self.execute(write_file, (def_file, contents), f"writing {def_file}") + + # next add options for def-file + + # for gcc/ld the def-file is specified as any object files + objects.append(def_file) + + # end: if ((export_symbols is not None) and + # (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")): + + # who wants symbols and a many times larger output file + # should explicitly switch the debug mode on + # otherwise we let ld strip the output file + # (On my machine: 10KiB < stripped_file < ??100KiB + # unstripped_file = stripped_file + XXX KiB + # ( XXX=254 for a typical python extension)) + if not debug: + extra_preargs.append("-s") + + super().link( + target_desc, + objects, + output_filename, + output_dir, + libraries, + library_dirs, + runtime_library_dirs, + None, # export_symbols, we do this in our def-file + debug, + extra_preargs, + extra_postargs, + build_temp, + target_lang, + ) + + def runtime_library_dir_option(self, dir): + # cygwin doesn't support rpath. While in theory we could error + # out like MSVC does, code might expect it to work like on Unix, so + # just warn and hope for the best. + self.warn(_runtime_library_dirs_msg) + return [] + + # -- Miscellaneous methods ----------------------------------------- + + def _make_out_path(self, output_dir, strip_dir, src_name): + # use normcase to make sure '.rc' is really '.rc' and not '.RC' + norm_src_name = os.path.normcase(src_name) + return super()._make_out_path(output_dir, strip_dir, norm_src_name) + + @property + def out_extensions(self): + """ + Add support for rc and res files. + """ + return { + **super().out_extensions, + **{ext: ext + self.obj_extension for ext in ('.res', '.rc')}, + } + + +# the same as cygwin plus some additional parameters +class MinGW32Compiler(Compiler): + """Handles the Mingw32 port of the GNU C compiler to Windows.""" + + compiler_type = 'mingw32' + + def __init__(self, verbose=False, force=False): + super().__init__(verbose, force) + + shared_option = "-shared" + + if is_cygwincc(self.cc): + raise Error('Cygwin gcc cannot be used with --compiler=mingw32') + + self.set_executables( + compiler=f'{self.cc} -O -Wall', + compiler_so=f'{self.cc} -shared -O -Wall', + compiler_so_cxx=f'{self.cxx} -shared -O -Wall', + compiler_cxx=f'{self.cxx} -O -Wall', + linker_exe=f'{self.cc}', + linker_so=f'{self.linker_dll} {shared_option}', + linker_exe_cxx=f'{self.cxx}', + linker_so_cxx=f'{self.linker_dll_cxx} {shared_option}', + ) + + def runtime_library_dir_option(self, dir): + raise DistutilsPlatformError(_runtime_library_dirs_msg) + + +# Because these compilers aren't configured in Python's pyconfig.h file by +# default, we should at least warn the user if he is using an unmodified +# version. + +CONFIG_H_OK = "ok" +CONFIG_H_NOTOK = "not ok" +CONFIG_H_UNCERTAIN = "uncertain" + + +def check_config_h(): + """Check if the current Python installation appears amenable to building + extensions with GCC. + + Returns a tuple (status, details), where 'status' is one of the following + constants: + + - CONFIG_H_OK: all is well, go ahead and compile + - CONFIG_H_NOTOK: doesn't look good + - CONFIG_H_UNCERTAIN: not sure -- unable to read pyconfig.h + + 'details' is a human-readable string explaining the situation. + + Note there are two ways to conclude "OK": either 'sys.version' contains + the string "GCC" (implying that this Python was built with GCC), or the + installed "pyconfig.h" contains the string "__GNUC__". + """ + + # XXX since this function also checks sys.version, it's not strictly a + # "pyconfig.h" check -- should probably be renamed... + + from distutils import sysconfig + + # if sys.version contains GCC then python was compiled with GCC, and the + # pyconfig.h file should be OK + if "GCC" in sys.version: + return CONFIG_H_OK, "sys.version mentions 'GCC'" + + # Clang would also work + if "Clang" in sys.version: + return CONFIG_H_OK, "sys.version mentions 'Clang'" + + # let's see if __GNUC__ is mentioned in python.h + fn = sysconfig.get_config_h_filename() + try: + config_h = pathlib.Path(fn).read_text(encoding='utf-8') + except OSError as exc: + return (CONFIG_H_UNCERTAIN, f"couldn't read '{fn}': {exc.strerror}") + else: + substring = '__GNUC__' + if substring in config_h: + code = CONFIG_H_OK + mention_inflected = 'mentions' + else: + code = CONFIG_H_NOTOK + mention_inflected = 'does not mention' + return code, f"{fn!r} {mention_inflected} {substring!r}" + + +def is_cygwincc(cc): + """Try to determine if the compiler that would be used is from cygwin.""" + out_string = check_output(shlex.split(cc) + ['-dumpmachine']) + return out_string.strip().endswith(b'cygwin') + + +get_versions = None +""" +A stand-in for the previous get_versions() function to prevent failures +when monkeypatched. See pypa/setuptools#2969. +""" diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/errors.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/errors.py new file mode 100644 index 0000000000000000000000000000000000000000..01328592b2dad80f4d16c55cd9db9829b3c650f1 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/errors.py @@ -0,0 +1,24 @@ +class Error(Exception): + """Some compile/link operation failed.""" + + +class PreprocessError(Error): + """Failure to preprocess one or more C/C++ files.""" + + +class CompileError(Error): + """Failure to compile one or more C/C++ source files.""" + + +class LibError(Error): + """Failure to create a static library from one or more C/C++ object + files.""" + + +class LinkError(Error): + """Failure to link one or more C/C++ object files into an executable + or shared library file.""" + + +class UnknownFileType(Error): + """Attempt to process an unknown file type.""" diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/msvc.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/msvc.py new file mode 100644 index 0000000000000000000000000000000000000000..1f50fa50880e02ea7adf64e94a234af25f8284c7 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/msvc.py @@ -0,0 +1,614 @@ +"""distutils._msvccompiler + +Contains MSVCCompiler, an implementation of the abstract CCompiler class +for Microsoft Visual Studio 2015. + +This module requires VS 2015 or later. +""" + +# Written by Perry Stoll +# hacked by Robin Becker and Thomas Heller to do a better job of +# finding DevStudio (through the registry) +# ported to VS 2005 and VS 2008 by Christian Heimes +# ported to VS 2015 by Steve Dower +from __future__ import annotations + +import contextlib +import os +import subprocess +import unittest.mock as mock +import warnings +from collections.abc import Iterable + +with contextlib.suppress(ImportError): + import winreg + +from itertools import count + +from ..._log import log +from ...errors import ( + DistutilsExecError, + DistutilsPlatformError, +) +from ...util import get_host_platform, get_platform +from . import base +from .base import gen_lib_options +from .errors import ( + CompileError, + LibError, + LinkError, +) + + +def _find_vc2015(): + try: + key = winreg.OpenKeyEx( + winreg.HKEY_LOCAL_MACHINE, + r"Software\Microsoft\VisualStudio\SxS\VC7", + access=winreg.KEY_READ | winreg.KEY_WOW64_32KEY, + ) + except OSError: + log.debug("Visual C++ is not registered") + return None, None + + best_version = 0 + best_dir = None + with key: + for i in count(): + try: + v, vc_dir, vt = winreg.EnumValue(key, i) + except OSError: + break + if v and vt == winreg.REG_SZ and os.path.isdir(vc_dir): + try: + version = int(float(v)) + except (ValueError, TypeError): + continue + if version >= 14 and version > best_version: + best_version, best_dir = version, vc_dir + return best_version, best_dir + + +def _find_vc2017(): + """Returns "15, path" based on the result of invoking vswhere.exe + If no install is found, returns "None, None" + + The version is returned to avoid unnecessarily changing the function + result. It may be ignored when the path is not None. + + If vswhere.exe is not available, by definition, VS 2017 is not + installed. + """ + root = os.environ.get("ProgramFiles(x86)") or os.environ.get("ProgramFiles") + if not root: + return None, None + + variant = 'arm64' if get_platform() == 'win-arm64' else 'x86.x64' + suitable_components = ( + f"Microsoft.VisualStudio.Component.VC.Tools.{variant}", + "Microsoft.VisualStudio.Workload.WDExpress", + ) + + for component in suitable_components: + # Workaround for `-requiresAny` (only available on VS 2017 > 15.6) + with contextlib.suppress( + subprocess.CalledProcessError, OSError, UnicodeDecodeError + ): + path = ( + subprocess.check_output([ + os.path.join( + root, "Microsoft Visual Studio", "Installer", "vswhere.exe" + ), + "-latest", + "-prerelease", + "-requires", + component, + "-property", + "installationPath", + "-products", + "*", + ]) + .decode(encoding="mbcs", errors="strict") + .strip() + ) + + path = os.path.join(path, "VC", "Auxiliary", "Build") + if os.path.isdir(path): + return 15, path + + return None, None # no suitable component found + + +PLAT_SPEC_TO_RUNTIME = { + 'x86': 'x86', + 'x86_amd64': 'x64', + 'x86_arm': 'arm', + 'x86_arm64': 'arm64', +} + + +def _find_vcvarsall(plat_spec): + # bpo-38597: Removed vcruntime return value + _, best_dir = _find_vc2017() + + if not best_dir: + best_version, best_dir = _find_vc2015() + + if not best_dir: + log.debug("No suitable Visual C++ version found") + return None, None + + vcvarsall = os.path.join(best_dir, "vcvarsall.bat") + if not os.path.isfile(vcvarsall): + log.debug("%s cannot be found", vcvarsall) + return None, None + + return vcvarsall, None + + +def _get_vc_env(plat_spec): + if os.getenv("DISTUTILS_USE_SDK"): + return {key.lower(): value for key, value in os.environ.items()} + + vcvarsall, _ = _find_vcvarsall(plat_spec) + if not vcvarsall: + raise DistutilsPlatformError( + 'Microsoft Visual C++ 14.0 or greater is required. ' + 'Get it with "Microsoft C++ Build Tools": ' + 'https://visualstudio.microsoft.com/visual-cpp-build-tools/' + ) + + try: + out = subprocess.check_output( + f'cmd /u /c "{vcvarsall}" {plat_spec} && set', + stderr=subprocess.STDOUT, + ).decode('utf-16le', errors='replace') + except subprocess.CalledProcessError as exc: + log.error(exc.output) + raise DistutilsPlatformError(f"Error executing {exc.cmd}") + + env = { + key.lower(): value + for key, _, value in (line.partition('=') for line in out.splitlines()) + if key and value + } + + return env + + +def _find_exe(exe, paths=None): + """Return path to an MSVC executable program. + + Tries to find the program in several places: first, one of the + MSVC program search paths from the registry; next, the directories + in the PATH environment variable. If any of those work, return an + absolute path that is known to exist. If none of them work, just + return the original program name, 'exe'. + """ + if not paths: + paths = os.getenv('path').split(os.pathsep) + for p in paths: + fn = os.path.join(os.path.abspath(p), exe) + if os.path.isfile(fn): + return fn + return exe + + +_vcvars_names = { + 'win32': 'x86', + 'win-amd64': 'amd64', + 'win-arm32': 'arm', + 'win-arm64': 'arm64', +} + + +def _get_vcvars_spec(host_platform, platform): + """ + Given a host platform and platform, determine the spec for vcvarsall. + + Uses the native MSVC host if the host platform would need expensive + emulation for x86. + + >>> _get_vcvars_spec('win-arm64', 'win32') + 'arm64_x86' + >>> _get_vcvars_spec('win-arm64', 'win-amd64') + 'arm64_amd64' + + Otherwise, always cross-compile from x86 to work with the + lighter-weight MSVC installs that do not include native 64-bit tools. + + >>> _get_vcvars_spec('win32', 'win32') + 'x86' + >>> _get_vcvars_spec('win-arm32', 'win-arm32') + 'x86_arm' + >>> _get_vcvars_spec('win-amd64', 'win-arm64') + 'x86_arm64' + """ + if host_platform != 'win-arm64': + host_platform = 'win32' + vc_hp = _vcvars_names[host_platform] + vc_plat = _vcvars_names[platform] + return vc_hp if vc_hp == vc_plat else f'{vc_hp}_{vc_plat}' + + +class Compiler(base.Compiler): + """Concrete class that implements an interface to Microsoft Visual C++, + as defined by the CCompiler abstract class.""" + + compiler_type = 'msvc' + + # Just set this so CCompiler's constructor doesn't barf. We currently + # don't use the 'set_executables()' bureaucracy provided by CCompiler, + # as it really isn't necessary for this sort of single-compiler class. + # Would be nice to have a consistent interface with UnixCCompiler, + # though, so it's worth thinking about. + executables = {} + + # Private class data (need to distinguish C from C++ source for compiler) + _c_extensions = ['.c'] + _cpp_extensions = ['.cc', '.cpp', '.cxx'] + _rc_extensions = ['.rc'] + _mc_extensions = ['.mc'] + + # Needed for the filename generation methods provided by the + # base class, CCompiler. + src_extensions = _c_extensions + _cpp_extensions + _rc_extensions + _mc_extensions + res_extension = '.res' + obj_extension = '.obj' + static_lib_extension = '.lib' + shared_lib_extension = '.dll' + static_lib_format = shared_lib_format = '%s%s' + exe_extension = '.exe' + + def __init__(self, verbose=False, force=False) -> None: + super().__init__(verbose, force=force) + # target platform (.plat_name is consistent with 'bdist') + self.plat_name = None + self.initialized = False + + @classmethod + def _configure(cls, vc_env): + """ + Set class-level include/lib dirs. + """ + cls.include_dirs = cls._parse_path(vc_env.get('include', '')) + cls.library_dirs = cls._parse_path(vc_env.get('lib', '')) + + @staticmethod + def _parse_path(val): + return [dir.rstrip(os.sep) for dir in val.split(os.pathsep) if dir] + + def initialize(self, plat_name: str | None = None) -> None: + # multi-init means we would need to check platform same each time... + assert not self.initialized, "don't init multiple times" + if plat_name is None: + plat_name = get_platform() + # sanity check for platforms to prevent obscure errors later. + if plat_name not in _vcvars_names: + raise DistutilsPlatformError( + f"--plat-name must be one of {tuple(_vcvars_names)}" + ) + + plat_spec = _get_vcvars_spec(get_host_platform(), plat_name) + + vc_env = _get_vc_env(plat_spec) + if not vc_env: + raise DistutilsPlatformError( + "Unable to find a compatible Visual Studio installation." + ) + self._configure(vc_env) + + self._paths = vc_env.get('path', '') + paths = self._paths.split(os.pathsep) + self.cc = _find_exe("cl.exe", paths) + self.linker = _find_exe("link.exe", paths) + self.lib = _find_exe("lib.exe", paths) + self.rc = _find_exe("rc.exe", paths) # resource compiler + self.mc = _find_exe("mc.exe", paths) # message compiler + self.mt = _find_exe("mt.exe", paths) # message compiler + + self.preprocess_options = None + # bpo-38597: Always compile with dynamic linking + # Future releases of Python 3.x will include all past + # versions of vcruntime*.dll for compatibility. + self.compile_options = ['/nologo', '/O2', '/W3', '/GL', '/DNDEBUG', '/MD'] + + self.compile_options_debug = [ + '/nologo', + '/Od', + '/MDd', + '/Zi', + '/W3', + '/D_DEBUG', + ] + + ldflags = ['/nologo', '/INCREMENTAL:NO', '/LTCG'] + + ldflags_debug = ['/nologo', '/INCREMENTAL:NO', '/LTCG', '/DEBUG:FULL'] + + self.ldflags_exe = [*ldflags, '/MANIFEST:EMBED,ID=1'] + self.ldflags_exe_debug = [*ldflags_debug, '/MANIFEST:EMBED,ID=1'] + self.ldflags_shared = [ + *ldflags, + '/DLL', + '/MANIFEST:EMBED,ID=2', + '/MANIFESTUAC:NO', + ] + self.ldflags_shared_debug = [ + *ldflags_debug, + '/DLL', + '/MANIFEST:EMBED,ID=2', + '/MANIFESTUAC:NO', + ] + self.ldflags_static = [*ldflags] + self.ldflags_static_debug = [*ldflags_debug] + + self._ldflags = { + (base.Compiler.EXECUTABLE, None): self.ldflags_exe, + (base.Compiler.EXECUTABLE, False): self.ldflags_exe, + (base.Compiler.EXECUTABLE, True): self.ldflags_exe_debug, + (base.Compiler.SHARED_OBJECT, None): self.ldflags_shared, + (base.Compiler.SHARED_OBJECT, False): self.ldflags_shared, + (base.Compiler.SHARED_OBJECT, True): self.ldflags_shared_debug, + (base.Compiler.SHARED_LIBRARY, None): self.ldflags_static, + (base.Compiler.SHARED_LIBRARY, False): self.ldflags_static, + (base.Compiler.SHARED_LIBRARY, True): self.ldflags_static_debug, + } + + self.initialized = True + + # -- Worker methods ------------------------------------------------ + + @property + def out_extensions(self) -> dict[str, str]: + return { + **super().out_extensions, + **{ + ext: self.res_extension + for ext in self._rc_extensions + self._mc_extensions + }, + } + + def compile( # noqa: C901 + self, + sources, + output_dir=None, + macros=None, + include_dirs=None, + debug=False, + extra_preargs=None, + extra_postargs=None, + depends=None, + ): + if not self.initialized: + self.initialize() + compile_info = self._setup_compile( + output_dir, macros, include_dirs, sources, depends, extra_postargs + ) + macros, objects, extra_postargs, pp_opts, build = compile_info + + compile_opts = extra_preargs or [] + compile_opts.append('/c') + if debug: + compile_opts.extend(self.compile_options_debug) + else: + compile_opts.extend(self.compile_options) + + add_cpp_opts = False + + for obj in objects: + try: + src, ext = build[obj] + except KeyError: + continue + if debug: + # pass the full pathname to MSVC in debug mode, + # this allows the debugger to find the source file + # without asking the user to browse for it + src = os.path.abspath(src) + + if ext in self._c_extensions: + input_opt = f"/Tc{src}" + elif ext in self._cpp_extensions: + input_opt = f"/Tp{src}" + add_cpp_opts = True + elif ext in self._rc_extensions: + # compile .RC to .RES file + input_opt = src + output_opt = "/fo" + obj + try: + self.spawn([self.rc] + pp_opts + [output_opt, input_opt]) + except DistutilsExecError as msg: + raise CompileError(msg) + continue + elif ext in self._mc_extensions: + # Compile .MC to .RC file to .RES file. + # * '-h dir' specifies the directory for the + # generated include file + # * '-r dir' specifies the target directory of the + # generated RC file and the binary message resource + # it includes + # + # For now (since there are no options to change this), + # we use the source-directory for the include file and + # the build directory for the RC file and message + # resources. This works at least for win32all. + h_dir = os.path.dirname(src) + rc_dir = os.path.dirname(obj) + try: + # first compile .MC to .RC and .H file + self.spawn([self.mc, '-h', h_dir, '-r', rc_dir, src]) + base, _ = os.path.splitext(os.path.basename(src)) + rc_file = os.path.join(rc_dir, base + '.rc') + # then compile .RC to .RES file + self.spawn([self.rc, "/fo" + obj, rc_file]) + + except DistutilsExecError as msg: + raise CompileError(msg) + continue + else: + # how to handle this file? + raise CompileError(f"Don't know how to compile {src} to {obj}") + + args = [self.cc] + compile_opts + pp_opts + if add_cpp_opts: + args.append('/EHsc') + args.extend((input_opt, "/Fo" + obj)) + args.extend(extra_postargs) + + try: + self.spawn(args) + except DistutilsExecError as msg: + raise CompileError(msg) + + return objects + + def create_static_lib( + self, + objects: list[str] | tuple[str, ...], + output_libname: str, + output_dir: str | None = None, + debug: bool = False, + target_lang: str | None = None, + ) -> None: + if not self.initialized: + self.initialize() + objects, output_dir = self._fix_object_args(objects, output_dir) + output_filename = self.library_filename(output_libname, output_dir=output_dir) + + if self._need_link(objects, output_filename): + lib_args = objects + ['/OUT:' + output_filename] + if debug: + pass # XXX what goes here? + try: + log.debug('Executing "%s" %s', self.lib, ' '.join(lib_args)) + self.spawn([self.lib] + lib_args) + except DistutilsExecError as msg: + raise LibError(msg) + else: + log.debug("skipping %s (up-to-date)", output_filename) + + def link( + self, + target_desc: str, + objects: list[str] | tuple[str, ...], + output_filename: str, + output_dir: str | None = None, + libraries: list[str] | tuple[str, ...] | None = None, + library_dirs: list[str] | tuple[str, ...] | None = None, + runtime_library_dirs: list[str] | tuple[str, ...] | None = None, + export_symbols: Iterable[str] | None = None, + debug: bool = False, + extra_preargs: list[str] | None = None, + extra_postargs: Iterable[str] | None = None, + build_temp: str | os.PathLike[str] | None = None, + target_lang: str | None = None, + ) -> None: + if not self.initialized: + self.initialize() + objects, output_dir = self._fix_object_args(objects, output_dir) + fixed_args = self._fix_lib_args(libraries, library_dirs, runtime_library_dirs) + libraries, library_dirs, runtime_library_dirs = fixed_args + + if runtime_library_dirs: + self.warn( + "I don't know what to do with 'runtime_library_dirs': " + + str(runtime_library_dirs) + ) + + lib_opts = gen_lib_options(self, library_dirs, runtime_library_dirs, libraries) + if output_dir is not None: + output_filename = os.path.join(output_dir, output_filename) + + if self._need_link(objects, output_filename): + ldflags = self._ldflags[target_desc, debug] + + export_opts = ["/EXPORT:" + sym for sym in (export_symbols or [])] + + ld_args = ( + ldflags + lib_opts + export_opts + objects + ['/OUT:' + output_filename] + ) + + # The MSVC linker generates .lib and .exp files, which cannot be + # suppressed by any linker switches. The .lib files may even be + # needed! Make sure they are generated in the temporary build + # directory. Since they have different names for debug and release + # builds, they can go into the same directory. + build_temp = os.path.dirname(objects[0]) + if export_symbols is not None: + (dll_name, dll_ext) = os.path.splitext( + os.path.basename(output_filename) + ) + implib_file = os.path.join(build_temp, self.library_filename(dll_name)) + ld_args.append('/IMPLIB:' + implib_file) + + if extra_preargs: + ld_args[:0] = extra_preargs + if extra_postargs: + ld_args.extend(extra_postargs) + + output_dir = os.path.dirname(os.path.abspath(output_filename)) + self.mkpath(output_dir) + try: + log.debug('Executing "%s" %s', self.linker, ' '.join(ld_args)) + self.spawn([self.linker] + ld_args) + except DistutilsExecError as msg: + raise LinkError(msg) + else: + log.debug("skipping %s (up-to-date)", output_filename) + + def spawn(self, cmd): + env = dict(os.environ, PATH=self._paths) + with self._fallback_spawn(cmd, env) as fallback: + return super().spawn(cmd, env=env) + return fallback.value + + @contextlib.contextmanager + def _fallback_spawn(self, cmd, env): + """ + Discovered in pypa/distutils#15, some tools monkeypatch the compiler, + so the 'env' kwarg causes a TypeError. Detect this condition and + restore the legacy, unsafe behavior. + """ + bag = type('Bag', (), {})() + try: + yield bag + except TypeError as exc: + if "unexpected keyword argument 'env'" not in str(exc): + raise + else: + return + warnings.warn("Fallback spawn triggered. Please update distutils monkeypatch.") + with mock.patch.dict('os.environ', env): + bag.value = super().spawn(cmd) + + # -- Miscellaneous methods ----------------------------------------- + # These are all used by the 'gen_lib_options() function, in + # ccompiler.py. + + def library_dir_option(self, dir): + return "/LIBPATH:" + dir + + def runtime_library_dir_option(self, dir): + raise DistutilsPlatformError( + "don't know how to set runtime library search path for MSVC" + ) + + def library_option(self, lib): + return self.library_filename(lib) + + def find_library_file(self, dirs, lib, debug=False): + # Prefer a debugging library if found (and requested), but deal + # with it if we don't have one. + if debug: + try_names = [lib + "_d", lib] + else: + try_names = [lib] + for dir in dirs: + for name in try_names: + libfile = os.path.join(dir, self.library_filename(name)) + if os.path.isfile(libfile): + return libfile + else: + # Oops, didn't find it in *any* of 'dirs' + return None diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_base.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_base.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c9c0c129dfc704cba4c4da4ab717c4d62fbe6547 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_base.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_cygwin.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_cygwin.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..085774b9625c2a68aa85e6875c0e9105bcd51e44 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_cygwin.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_mingw.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_mingw.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9a3cd00bc2126a5752ba9ba208f97407f7894529 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_mingw.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_msvc.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_msvc.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..215afd22bf3a5d4df2e388b0486a86d802aad362 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_msvc.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_unix.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_unix.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9c7a3ec0cb415d334d05b8259eda8342013c0e18 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_unix.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_base.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_base.py new file mode 100644 index 0000000000000000000000000000000000000000..a762e2b649d7977ef42f4d35854eab26bd54e9e7 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_base.py @@ -0,0 +1,83 @@ +import platform +import sysconfig +import textwrap + +import pytest + +from .. import base + +pytestmark = pytest.mark.usefixtures('suppress_path_mangle') + + +@pytest.fixture +def c_file(tmp_path): + c_file = tmp_path / 'foo.c' + gen_headers = ('Python.h',) + is_windows = platform.system() == "Windows" + plat_headers = ('windows.h',) * is_windows + all_headers = gen_headers + plat_headers + headers = '\n'.join(f'#include <{header}>\n' for header in all_headers) + payload = ( + textwrap.dedent( + """ + #headers + void PyInit_foo(void) {} + """ + ) + .lstrip() + .replace('#headers', headers) + ) + c_file.write_text(payload, encoding='utf-8') + return c_file + + +def test_set_include_dirs(c_file): + """ + Extensions should build even if set_include_dirs is invoked. + In particular, compiler-specific paths should not be overridden. + """ + compiler = base.new_compiler() + python = sysconfig.get_paths()['include'] + compiler.set_include_dirs([python]) + compiler.compile([c_file]) + + # do it again, setting include dirs after any initialization + compiler.set_include_dirs([python]) + compiler.compile([c_file]) + + +def test_has_function_prototype(): + # Issue https://github.com/pypa/setuptools/issues/3648 + # Test prototype-generating behavior. + + compiler = base.new_compiler() + + # Every C implementation should have these. + assert compiler.has_function('abort') + assert compiler.has_function('exit') + with pytest.deprecated_call(match='includes is deprecated'): + # abort() is a valid expression with the prototype. + assert compiler.has_function('abort', includes=['stdlib.h']) + with pytest.deprecated_call(match='includes is deprecated'): + # But exit() is not valid with the actual prototype in scope. + assert not compiler.has_function('exit', includes=['stdlib.h']) + # And setuptools_does_not_exist is not declared or defined at all. + assert not compiler.has_function('setuptools_does_not_exist') + with pytest.deprecated_call(match='includes is deprecated'): + assert not compiler.has_function( + 'setuptools_does_not_exist', includes=['stdio.h'] + ) + + +def test_include_dirs_after_multiple_compile_calls(c_file): + """ + Calling compile multiple times should not change the include dirs + (regression test for setuptools issue #3591). + """ + compiler = base.new_compiler() + python = sysconfig.get_paths()['include'] + compiler.set_include_dirs([python]) + compiler.compile([c_file]) + assert compiler.include_dirs == [python] + compiler.compile([c_file]) + assert compiler.include_dirs == [python] diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_cygwin.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_cygwin.py new file mode 100644 index 0000000000000000000000000000000000000000..9adf6b8ebf165b4fe92a52d8a14aed21aebba539 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_cygwin.py @@ -0,0 +1,76 @@ +"""Tests for distutils.cygwinccompiler.""" + +import os +import sys +from distutils import sysconfig +from distutils.tests import support + +import pytest + +from .. import cygwin + + +@pytest.fixture(autouse=True) +def stuff(request, monkeypatch, distutils_managed_tempdir): + self = request.instance + self.python_h = os.path.join(self.mkdtemp(), 'python.h') + monkeypatch.setattr(sysconfig, 'get_config_h_filename', self._get_config_h_filename) + monkeypatch.setattr(sys, 'version', sys.version) + + +class TestCygwinCCompiler(support.TempdirManager): + def _get_config_h_filename(self): + return self.python_h + + @pytest.mark.skipif('sys.platform != "cygwin"') + @pytest.mark.skipif('not os.path.exists("/usr/lib/libbash.dll.a")') + def test_find_library_file(self): + from distutils.cygwinccompiler import CygwinCCompiler + + compiler = CygwinCCompiler() + link_name = "bash" + linkable_file = compiler.find_library_file(["/usr/lib"], link_name) + assert linkable_file is not None + assert os.path.exists(linkable_file) + assert linkable_file == f"/usr/lib/lib{link_name:s}.dll.a" + + @pytest.mark.skipif('sys.platform != "cygwin"') + def test_runtime_library_dir_option(self): + from distutils.cygwinccompiler import CygwinCCompiler + + compiler = CygwinCCompiler() + assert compiler.runtime_library_dir_option('/foo') == [] + + def test_check_config_h(self): + # check_config_h looks for "GCC" in sys.version first + # returns CONFIG_H_OK if found + sys.version = ( + '2.6.1 (r261:67515, Dec 6 2008, 16:42:21) \n[GCC ' + '4.0.1 (Apple Computer, Inc. build 5370)]' + ) + + assert cygwin.check_config_h()[0] == cygwin.CONFIG_H_OK + + # then it tries to see if it can find "__GNUC__" in pyconfig.h + sys.version = 'something without the *CC word' + + # if the file doesn't exist it returns CONFIG_H_UNCERTAIN + assert cygwin.check_config_h()[0] == cygwin.CONFIG_H_UNCERTAIN + + # if it exists but does not contain __GNUC__, it returns CONFIG_H_NOTOK + self.write_file(self.python_h, 'xxx') + assert cygwin.check_config_h()[0] == cygwin.CONFIG_H_NOTOK + + # and CONFIG_H_OK if __GNUC__ is found + self.write_file(self.python_h, 'xxx __GNUC__ xxx') + assert cygwin.check_config_h()[0] == cygwin.CONFIG_H_OK + + def test_get_msvcr(self): + assert cygwin.get_msvcr() == [] + + @pytest.mark.skipif('sys.platform != "cygwin"') + def test_dll_libraries_not_none(self): + from distutils.cygwinccompiler import CygwinCCompiler + + compiler = CygwinCCompiler() + assert compiler.dll_libraries is not None diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_mingw.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_mingw.py new file mode 100644 index 0000000000000000000000000000000000000000..dc45687a917808edbf692ced18b0c99183d21e2d --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_mingw.py @@ -0,0 +1,48 @@ +from distutils import sysconfig +from distutils.errors import DistutilsPlatformError +from distutils.util import is_mingw, split_quoted + +import pytest + +from .. import cygwin, errors + + +class TestMinGW32Compiler: + @pytest.mark.skipif(not is_mingw(), reason='not on mingw') + def test_compiler_type(self): + compiler = cygwin.MinGW32Compiler() + assert compiler.compiler_type == 'mingw32' + + @pytest.mark.skipif(not is_mingw(), reason='not on mingw') + def test_set_executables(self, monkeypatch): + monkeypatch.setenv('CC', 'cc') + monkeypatch.setenv('CXX', 'c++') + + compiler = cygwin.MinGW32Compiler() + + assert compiler.compiler == split_quoted('cc -O -Wall') + assert compiler.compiler_so == split_quoted('cc -shared -O -Wall') + assert compiler.compiler_cxx == split_quoted('c++ -O -Wall') + assert compiler.linker_exe == split_quoted('cc') + assert compiler.linker_so == split_quoted('cc -shared') + + @pytest.mark.skipif(not is_mingw(), reason='not on mingw') + def test_runtime_library_dir_option(self): + compiler = cygwin.MinGW32Compiler() + with pytest.raises(DistutilsPlatformError): + compiler.runtime_library_dir_option('/usr/lib') + + @pytest.mark.skipif(not is_mingw(), reason='not on mingw') + def test_cygwincc_error(self, monkeypatch): + monkeypatch.setattr(cygwin, 'is_cygwincc', lambda _: True) + + with pytest.raises(errors.Error): + cygwin.MinGW32Compiler() + + @pytest.mark.skipif('sys.platform == "cygwin"') + def test_customize_compiler_with_msvc_python(self): + # In case we have an MSVC Python build, but still want to use + # MinGW32Compiler, then customize_compiler() shouldn't fail at least. + # https://github.com/pypa/setuptools/issues/4456 + compiler = cygwin.MinGW32Compiler() + sysconfig.customize_compiler(compiler) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_msvc.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_msvc.py new file mode 100644 index 0000000000000000000000000000000000000000..eca831996adcb07f05560581fe4285cdb29392d3 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_msvc.py @@ -0,0 +1,136 @@ +import os +import sys +import sysconfig +import threading +import unittest.mock as mock +from distutils.errors import DistutilsPlatformError +from distutils.tests import support +from distutils.util import get_platform + +import pytest + +from .. import msvc + +needs_winreg = pytest.mark.skipif('not hasattr(msvc, "winreg")') + + +class Testmsvccompiler(support.TempdirManager): + def test_no_compiler(self, monkeypatch): + # makes sure query_vcvarsall raises + # a DistutilsPlatformError if the compiler + # is not found + def _find_vcvarsall(plat_spec): + return None, None + + monkeypatch.setattr(msvc, '_find_vcvarsall', _find_vcvarsall) + + with pytest.raises(DistutilsPlatformError): + msvc._get_vc_env( + 'wont find this version', + ) + + @pytest.mark.skipif( + not sysconfig.get_platform().startswith("win"), + reason="Only run test for non-mingw Windows platforms", + ) + @pytest.mark.parametrize( + "plat_name, expected", + [ + ("win-arm64", "win-arm64"), + ("win-amd64", "win-amd64"), + (None, get_platform()), + ], + ) + def test_cross_platform_compilation_paths(self, monkeypatch, plat_name, expected): + """ + Ensure a specified target platform is passed to _get_vcvars_spec. + """ + compiler = msvc.Compiler() + + def _get_vcvars_spec(host_platform, platform): + assert platform == expected + + monkeypatch.setattr(msvc, '_get_vcvars_spec', _get_vcvars_spec) + compiler.initialize(plat_name) + + @needs_winreg + def test_get_vc_env_unicode(self): + test_var = 'ṰḖṤṪ┅ṼẨṜ' + test_value = '₃⁴₅' + + # Ensure we don't early exit from _get_vc_env + old_distutils_use_sdk = os.environ.pop('DISTUTILS_USE_SDK', None) + os.environ[test_var] = test_value + try: + env = msvc._get_vc_env('x86') + assert test_var.lower() in env + assert test_value == env[test_var.lower()] + finally: + os.environ.pop(test_var) + if old_distutils_use_sdk: + os.environ['DISTUTILS_USE_SDK'] = old_distutils_use_sdk + + @needs_winreg + @pytest.mark.parametrize('ver', (2015, 2017)) + def test_get_vc(self, ver): + # This function cannot be mocked, so pass if VC is found + # and skip otherwise. + lookup = getattr(msvc, f'_find_vc{ver}') + expected_version = {2015: 14, 2017: 15}[ver] + version, path = lookup() + if not version: + pytest.skip(f"VS {ver} is not installed") + assert version >= expected_version + assert os.path.isdir(path) + + +class CheckThread(threading.Thread): + exc_info = None + + def run(self): + try: + super().run() + except Exception: + self.exc_info = sys.exc_info() + + def __bool__(self): + return not self.exc_info + + +class TestSpawn: + def test_concurrent_safe(self): + """ + Concurrent calls to spawn should have consistent results. + """ + compiler = msvc.Compiler() + compiler._paths = "expected" + inner_cmd = 'import os; assert os.environ["PATH"] == "expected"' + command = [sys.executable, '-c', inner_cmd] + + threads = [ + CheckThread(target=compiler.spawn, args=[command]) for n in range(100) + ] + for thread in threads: + thread.start() + for thread in threads: + thread.join() + assert all(threads) + + def test_concurrent_safe_fallback(self): + """ + If CCompiler.spawn has been monkey-patched without support + for an env, it should still execute. + """ + from distutils import ccompiler + + compiler = msvc.Compiler() + compiler._paths = "expected" + + def CCompiler_spawn(self, cmd): + "A spawn without an env argument." + assert os.environ["PATH"] == "expected" + + with mock.patch.object(ccompiler.CCompiler, 'spawn', CCompiler_spawn): + compiler.spawn(["n/a"]) + + assert os.environ.get("PATH") != "expected" diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_unix.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_unix.py new file mode 100644 index 0000000000000000000000000000000000000000..35b6b0e050c654bd9eff711ec3b94bea9adff2af --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_unix.py @@ -0,0 +1,413 @@ +"""Tests for distutils.unixccompiler.""" + +import os +import sys +import unittest.mock as mock +from distutils import sysconfig +from distutils.compat import consolidate_linker_args +from distutils.errors import DistutilsPlatformError +from distutils.tests import support +from distutils.tests.compat.py39 import EnvironmentVarGuard +from distutils.util import _clear_cached_macosx_ver + +import pytest + +from .. import unix + + +@pytest.fixture(autouse=True) +def save_values(monkeypatch): + monkeypatch.setattr(sys, 'platform', sys.platform) + monkeypatch.setattr(sysconfig, 'get_config_var', sysconfig.get_config_var) + monkeypatch.setattr(sysconfig, 'get_config_vars', sysconfig.get_config_vars) + + +@pytest.fixture(autouse=True) +def compiler_wrapper(request): + class CompilerWrapper(unix.Compiler): + def rpath_foo(self): + return self.runtime_library_dir_option('/foo') + + request.instance.cc = CompilerWrapper() + + +class TestUnixCCompiler(support.TempdirManager): + @pytest.mark.skipif('platform.system == "Windows"') + def test_runtime_libdir_option(self): # noqa: C901 + # Issue #5900; GitHub Issue #37 + # + # Ensure RUNPATH is added to extension modules with RPATH if + # GNU ld is used + + # darwin + sys.platform = 'darwin' + darwin_ver_var = 'MACOSX_DEPLOYMENT_TARGET' + darwin_rpath_flag = '-Wl,-rpath,/foo' + darwin_lib_flag = '-L/foo' + + # (macOS version from syscfg, macOS version from env var) -> flag + # Version value of None generates two tests: as None and as empty string + # Expected flag value of None means an mismatch exception is expected + darwin_test_cases = [ + ((None, None), darwin_lib_flag), + ((None, '11'), darwin_rpath_flag), + (('10', None), darwin_lib_flag), + (('10.3', None), darwin_lib_flag), + (('10.3.1', None), darwin_lib_flag), + (('10.5', None), darwin_rpath_flag), + (('10.5.1', None), darwin_rpath_flag), + (('10.3', '10.3'), darwin_lib_flag), + (('10.3', '10.5'), darwin_rpath_flag), + (('10.5', '10.3'), darwin_lib_flag), + (('10.5', '11'), darwin_rpath_flag), + (('10.4', '10'), None), + ] + + def make_darwin_gcv(syscfg_macosx_ver): + def gcv(var): + if var == darwin_ver_var: + return syscfg_macosx_ver + return "xxx" + + return gcv + + def do_darwin_test(syscfg_macosx_ver, env_macosx_ver, expected_flag): + env = os.environ + msg = f"macOS version = (sysconfig={syscfg_macosx_ver!r}, env={env_macosx_ver!r})" + + # Save + old_gcv = sysconfig.get_config_var + old_env_macosx_ver = env.get(darwin_ver_var) + + # Setup environment + _clear_cached_macosx_ver() + sysconfig.get_config_var = make_darwin_gcv(syscfg_macosx_ver) + if env_macosx_ver is not None: + env[darwin_ver_var] = env_macosx_ver + elif darwin_ver_var in env: + env.pop(darwin_ver_var) + + # Run the test + if expected_flag is not None: + assert self.cc.rpath_foo() == expected_flag, msg + else: + with pytest.raises( + DistutilsPlatformError, match=darwin_ver_var + r' mismatch' + ): + self.cc.rpath_foo() + + # Restore + if old_env_macosx_ver is not None: + env[darwin_ver_var] = old_env_macosx_ver + elif darwin_ver_var in env: + env.pop(darwin_ver_var) + sysconfig.get_config_var = old_gcv + _clear_cached_macosx_ver() + + for macosx_vers, expected_flag in darwin_test_cases: + syscfg_macosx_ver, env_macosx_ver = macosx_vers + do_darwin_test(syscfg_macosx_ver, env_macosx_ver, expected_flag) + # Bonus test cases with None interpreted as empty string + if syscfg_macosx_ver is None: + do_darwin_test("", env_macosx_ver, expected_flag) + if env_macosx_ver is None: + do_darwin_test(syscfg_macosx_ver, "", expected_flag) + if syscfg_macosx_ver is None and env_macosx_ver is None: + do_darwin_test("", "", expected_flag) + + old_gcv = sysconfig.get_config_var + + # hp-ux + sys.platform = 'hp-ux' + + def gcv(v): + return 'xxx' + + sysconfig.get_config_var = gcv + assert self.cc.rpath_foo() == ['+s', '-L/foo'] + + def gcv(v): + return 'gcc' + + sysconfig.get_config_var = gcv + assert self.cc.rpath_foo() == ['-Wl,+s', '-L/foo'] + + def gcv(v): + return 'g++' + + sysconfig.get_config_var = gcv + assert self.cc.rpath_foo() == ['-Wl,+s', '-L/foo'] + + sysconfig.get_config_var = old_gcv + + # GCC GNULD + sys.platform = 'bar' + + def gcv(v): + if v == 'CC': + return 'gcc' + elif v == 'GNULD': + return 'yes' + + sysconfig.get_config_var = gcv + assert self.cc.rpath_foo() == consolidate_linker_args([ + '-Wl,--enable-new-dtags', + '-Wl,-rpath,/foo', + ]) + + def gcv(v): + if v == 'CC': + return 'gcc -pthread -B /bar' + elif v == 'GNULD': + return 'yes' + + sysconfig.get_config_var = gcv + assert self.cc.rpath_foo() == consolidate_linker_args([ + '-Wl,--enable-new-dtags', + '-Wl,-rpath,/foo', + ]) + + # GCC non-GNULD + sys.platform = 'bar' + + def gcv(v): + if v == 'CC': + return 'gcc' + elif v == 'GNULD': + return 'no' + + sysconfig.get_config_var = gcv + assert self.cc.rpath_foo() == '-Wl,-R/foo' + + # GCC GNULD with fully qualified configuration prefix + # see #7617 + sys.platform = 'bar' + + def gcv(v): + if v == 'CC': + return 'x86_64-pc-linux-gnu-gcc-4.4.2' + elif v == 'GNULD': + return 'yes' + + sysconfig.get_config_var = gcv + assert self.cc.rpath_foo() == consolidate_linker_args([ + '-Wl,--enable-new-dtags', + '-Wl,-rpath,/foo', + ]) + + # non-GCC GNULD + sys.platform = 'bar' + + def gcv(v): + if v == 'CC': + return 'cc' + elif v == 'GNULD': + return 'yes' + + sysconfig.get_config_var = gcv + assert self.cc.rpath_foo() == consolidate_linker_args([ + '-Wl,--enable-new-dtags', + '-Wl,-rpath,/foo', + ]) + + # non-GCC non-GNULD + sys.platform = 'bar' + + def gcv(v): + if v == 'CC': + return 'cc' + elif v == 'GNULD': + return 'no' + + sysconfig.get_config_var = gcv + assert self.cc.rpath_foo() == '-Wl,-R/foo' + + @pytest.mark.skipif('platform.system == "Windows"') + def test_cc_overrides_ldshared(self): + # Issue #18080: + # ensure that setting CC env variable also changes default linker + def gcv(v): + if v == 'LDSHARED': + return 'gcc-4.2 -bundle -undefined dynamic_lookup ' + return 'gcc-4.2' + + def gcvs(*args, _orig=sysconfig.get_config_vars): + if args: + return list(map(sysconfig.get_config_var, args)) + return _orig() + + sysconfig.get_config_var = gcv + sysconfig.get_config_vars = gcvs + with EnvironmentVarGuard() as env: + env['CC'] = 'my_cc' + del env['LDSHARED'] + sysconfig.customize_compiler(self.cc) + assert self.cc.linker_so[0] == 'my_cc' + + @pytest.mark.skipif('platform.system == "Windows"') + def test_cxx_commands_used_are_correct(self): + def gcv(v): + if v == 'LDSHARED': + return 'ccache gcc-4.2 -bundle -undefined dynamic_lookup' + elif v == 'LDCXXSHARED': + return 'ccache g++-4.2 -bundle -undefined dynamic_lookup' + elif v == 'CXX': + return 'ccache g++-4.2' + elif v == 'CC': + return 'ccache gcc-4.2' + return '' + + def gcvs(*args, _orig=sysconfig.get_config_vars): + if args: + return list(map(sysconfig.get_config_var, args)) + return _orig() # pragma: no cover + + sysconfig.get_config_var = gcv + sysconfig.get_config_vars = gcvs + with ( + mock.patch.object(self.cc, 'spawn', return_value=None) as mock_spawn, + mock.patch.object(self.cc, '_need_link', return_value=True), + mock.patch.object(self.cc, 'mkpath', return_value=None), + EnvironmentVarGuard() as env, + ): + # override environment overrides in case they're specified by CI + del env['CXX'] + del env['LDCXXSHARED'] + + sysconfig.customize_compiler(self.cc) + assert self.cc.linker_so_cxx[0:2] == ['ccache', 'g++-4.2'] + assert self.cc.linker_exe_cxx[0:2] == ['ccache', 'g++-4.2'] + self.cc.link(None, [], 'a.out', target_lang='c++') + call_args = mock_spawn.call_args[0][0] + expected = ['ccache', 'g++-4.2', '-bundle', '-undefined', 'dynamic_lookup'] + assert call_args[:5] == expected + + self.cc.link_executable([], 'a.out', target_lang='c++') + call_args = mock_spawn.call_args[0][0] + expected = ['ccache', 'g++-4.2', '-o', self.cc.executable_filename('a.out')] + assert call_args[:4] == expected + + env['LDCXXSHARED'] = 'wrapper g++-4.2 -bundle -undefined dynamic_lookup' + env['CXX'] = 'wrapper g++-4.2' + sysconfig.customize_compiler(self.cc) + assert self.cc.linker_so_cxx[0:2] == ['wrapper', 'g++-4.2'] + assert self.cc.linker_exe_cxx[0:2] == ['wrapper', 'g++-4.2'] + self.cc.link(None, [], 'a.out', target_lang='c++') + call_args = mock_spawn.call_args[0][0] + expected = ['wrapper', 'g++-4.2', '-bundle', '-undefined', 'dynamic_lookup'] + assert call_args[:5] == expected + + self.cc.link_executable([], 'a.out', target_lang='c++') + call_args = mock_spawn.call_args[0][0] + expected = [ + 'wrapper', + 'g++-4.2', + '-o', + self.cc.executable_filename('a.out'), + ] + assert call_args[:4] == expected + + @pytest.mark.skipif('platform.system == "Windows"') + @pytest.mark.usefixtures('disable_macos_customization') + def test_cc_overrides_ldshared_for_cxx_correctly(self): + """ + Ensure that setting CC env variable also changes default linker + correctly when building C++ extensions. + + pypa/distutils#126 + """ + + def gcv(v): + if v == 'LDSHARED': + return 'gcc-4.2 -bundle -undefined dynamic_lookup ' + elif v == 'LDCXXSHARED': + return 'g++-4.2 -bundle -undefined dynamic_lookup ' + elif v == 'CXX': + return 'g++-4.2' + elif v == 'CC': + return 'gcc-4.2' + return '' + + def gcvs(*args, _orig=sysconfig.get_config_vars): + if args: + return list(map(sysconfig.get_config_var, args)) + return _orig() + + sysconfig.get_config_var = gcv + sysconfig.get_config_vars = gcvs + with ( + mock.patch.object(self.cc, 'spawn', return_value=None) as mock_spawn, + mock.patch.object(self.cc, '_need_link', return_value=True), + mock.patch.object(self.cc, 'mkpath', return_value=None), + EnvironmentVarGuard() as env, + ): + env['CC'] = 'ccache my_cc' + env['CXX'] = 'my_cxx' + del env['LDSHARED'] + sysconfig.customize_compiler(self.cc) + assert self.cc.linker_so[0:2] == ['ccache', 'my_cc'] + self.cc.link(None, [], 'a.out', target_lang='c++') + call_args = mock_spawn.call_args[0][0] + expected = ['my_cxx', '-bundle', '-undefined', 'dynamic_lookup'] + assert call_args[:4] == expected + + @pytest.mark.skipif('platform.system == "Windows"') + def test_explicit_ldshared(self): + # Issue #18080: + # ensure that setting CC env variable does not change + # explicit LDSHARED setting for linker + def gcv(v): + if v == 'LDSHARED': + return 'gcc-4.2 -bundle -undefined dynamic_lookup ' + return 'gcc-4.2' + + def gcvs(*args, _orig=sysconfig.get_config_vars): + if args: + return list(map(sysconfig.get_config_var, args)) + return _orig() + + sysconfig.get_config_var = gcv + sysconfig.get_config_vars = gcvs + with EnvironmentVarGuard() as env: + env['CC'] = 'my_cc' + env['LDSHARED'] = 'my_ld -bundle -dynamic' + sysconfig.customize_compiler(self.cc) + assert self.cc.linker_so[0] == 'my_ld' + + def test_has_function(self): + # Issue https://github.com/pypa/distutils/issues/64: + # ensure that setting output_dir does not raise + # FileNotFoundError: [Errno 2] No such file or directory: 'a.out' + self.cc.output_dir = 'scratch' + os.chdir(self.mkdtemp()) + self.cc.has_function('abort') + + def test_find_library_file(self, monkeypatch): + compiler = unix.Compiler() + compiler._library_root = lambda dir: dir + monkeypatch.setattr(os.path, 'exists', lambda d: 'existing' in d) + + libname = 'libabc.dylib' if sys.platform != 'cygwin' else 'cygabc.dll' + dirs = ('/foo/bar/missing', '/foo/bar/existing') + assert ( + compiler.find_library_file(dirs, 'abc').replace('\\', '/') + == f'/foo/bar/existing/{libname}' + ) + assert ( + compiler.find_library_file(reversed(dirs), 'abc').replace('\\', '/') + == f'/foo/bar/existing/{libname}' + ) + + monkeypatch.setattr( + os.path, + 'exists', + lambda d: 'existing' in d and '.a' in d and '.dll.a' not in d, + ) + assert ( + compiler.find_library_file(dirs, 'abc').replace('\\', '/') + == '/foo/bar/existing/libabc.a' + ) + assert ( + compiler.find_library_file(reversed(dirs), 'abc').replace('\\', '/') + == '/foo/bar/existing/libabc.a' + ) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/unix.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/unix.py new file mode 100644 index 0000000000000000000000000000000000000000..1231b32d20fc0524ea50f6a70d7e017211c69e9b --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/unix.py @@ -0,0 +1,422 @@ +"""distutils.unixccompiler + +Contains the UnixCCompiler class, a subclass of CCompiler that handles +the "typical" Unix-style command-line C compiler: + * macros defined with -Dname[=value] + * macros undefined with -Uname + * include search directories specified with -Idir + * libraries specified with -lllib + * library search directories specified with -Ldir + * compile handled by 'cc' (or similar) executable with -c option: + compiles .c to .o + * link static library handled by 'ar' command (possibly with 'ranlib') + * link shared library handled by 'cc -shared' +""" + +from __future__ import annotations + +import itertools +import os +import re +import shlex +import sys +from collections.abc import Iterable + +from ... import sysconfig +from ..._log import log +from ..._macos_compat import compiler_fixup +from ..._modified import newer +from ...compat import consolidate_linker_args +from ...errors import DistutilsExecError +from . import base +from .base import _Macro, gen_lib_options, gen_preprocess_options +from .errors import ( + CompileError, + LibError, + LinkError, +) + +# XXX Things not currently handled: +# * optimization/debug/warning flags; we just use whatever's in Python's +# Makefile and live with it. Is this adequate? If not, we might +# have to have a bunch of subclasses GNUCCompiler, SGICCompiler, +# SunCCompiler, and I suspect down that road lies madness. +# * even if we don't know a warning flag from an optimization flag, +# we need some way for outsiders to feed preprocessor/compiler/linker +# flags in to us -- eg. a sysadmin might want to mandate certain flags +# via a site config file, or a user might want to set something for +# compiling this module distribution only via the setup.py command +# line, whatever. As long as these options come from something on the +# current system, they can be as system-dependent as they like, and we +# should just happily stuff them into the preprocessor/compiler/linker +# options and carry on. + + +def _split_env(cmd): + """ + For macOS, split command into 'env' portion (if any) + and the rest of the linker command. + + >>> _split_env(['a', 'b', 'c']) + ([], ['a', 'b', 'c']) + >>> _split_env(['/usr/bin/env', 'A=3', 'gcc']) + (['/usr/bin/env', 'A=3'], ['gcc']) + """ + pivot = 0 + if os.path.basename(cmd[0]) == "env": + pivot = 1 + while '=' in cmd[pivot]: + pivot += 1 + return cmd[:pivot], cmd[pivot:] + + +def _split_aix(cmd): + """ + AIX platforms prefix the compiler with the ld_so_aix + script, so split that from the linker command. + + >>> _split_aix(['a', 'b', 'c']) + ([], ['a', 'b', 'c']) + >>> _split_aix(['/bin/foo/ld_so_aix', 'gcc']) + (['/bin/foo/ld_so_aix'], ['gcc']) + """ + pivot = os.path.basename(cmd[0]) == 'ld_so_aix' + return cmd[:pivot], cmd[pivot:] + + +def _linker_params(linker_cmd, compiler_cmd): + """ + The linker command usually begins with the compiler + command (possibly multiple elements), followed by zero or more + params for shared library building. + + If the LDSHARED env variable overrides the linker command, + however, the commands may not match. + + Return the best guess of the linker parameters by stripping + the linker command. If the compiler command does not + match the linker command, assume the linker command is + just the first element. + + >>> _linker_params('gcc foo bar'.split(), ['gcc']) + ['foo', 'bar'] + >>> _linker_params('gcc foo bar'.split(), ['other']) + ['foo', 'bar'] + >>> _linker_params('ccache gcc foo bar'.split(), 'ccache gcc'.split()) + ['foo', 'bar'] + >>> _linker_params(['gcc'], ['gcc']) + [] + """ + c_len = len(compiler_cmd) + pivot = c_len if linker_cmd[:c_len] == compiler_cmd else 1 + return linker_cmd[pivot:] + + +class Compiler(base.Compiler): + compiler_type = 'unix' + + # These are used by CCompiler in two places: the constructor sets + # instance attributes 'preprocessor', 'compiler', etc. from them, and + # 'set_executable()' allows any of these to be set. The defaults here + # are pretty generic; they will probably have to be set by an outsider + # (eg. using information discovered by the sysconfig about building + # Python extensions). + executables = { + 'preprocessor': None, + 'compiler': ["cc"], + 'compiler_so': ["cc"], + 'compiler_cxx': ["c++"], + 'compiler_so_cxx': ["c++"], + 'linker_so': ["cc", "-shared"], + 'linker_so_cxx': ["c++", "-shared"], + 'linker_exe': ["cc"], + 'linker_exe_cxx': ["c++", "-shared"], + 'archiver': ["ar", "-cr"], + 'ranlib': None, + } + + if sys.platform[:6] == "darwin": + executables['ranlib'] = ["ranlib"] + + # Needed for the filename generation methods provided by the base + # class, CCompiler. NB. whoever instantiates/uses a particular + # UnixCCompiler instance should set 'shared_lib_ext' -- we set a + # reasonable common default here, but it's not necessarily used on all + # Unices! + + src_extensions = [".c", ".C", ".cc", ".cxx", ".cpp", ".m"] + obj_extension = ".o" + static_lib_extension = ".a" + shared_lib_extension = ".so" + dylib_lib_extension = ".dylib" + xcode_stub_lib_extension = ".tbd" + static_lib_format = shared_lib_format = dylib_lib_format = "lib%s%s" + xcode_stub_lib_format = dylib_lib_format + if sys.platform == "cygwin": + exe_extension = ".exe" + shared_lib_extension = ".dll.a" + dylib_lib_extension = ".dll" + dylib_lib_format = "cyg%s%s" + + def _fix_lib_args(self, libraries, library_dirs, runtime_library_dirs): + """Remove standard library path from rpath""" + libraries, library_dirs, runtime_library_dirs = super()._fix_lib_args( + libraries, library_dirs, runtime_library_dirs + ) + libdir = sysconfig.get_config_var('LIBDIR') + if ( + runtime_library_dirs + and libdir.startswith("/usr/lib") + and (libdir in runtime_library_dirs) + ): + runtime_library_dirs.remove(libdir) + return libraries, library_dirs, runtime_library_dirs + + def preprocess( + self, + source: str | os.PathLike[str], + output_file: str | os.PathLike[str] | None = None, + macros: list[_Macro] | None = None, + include_dirs: list[str] | tuple[str, ...] | None = None, + extra_preargs: list[str] | None = None, + extra_postargs: Iterable[str] | None = None, + ): + fixed_args = self._fix_compile_args(None, macros, include_dirs) + ignore, macros, include_dirs = fixed_args + pp_opts = gen_preprocess_options(macros, include_dirs) + pp_args = self.preprocessor + pp_opts + if output_file: + pp_args.extend(['-o', output_file]) + if extra_preargs: + pp_args[:0] = extra_preargs + if extra_postargs: + pp_args.extend(extra_postargs) + pp_args.append(source) + + # reasons to preprocess: + # - force is indicated + # - output is directed to stdout + # - source file is newer than the target + preprocess = self.force or output_file is None or newer(source, output_file) + if not preprocess: + return + + if output_file: + self.mkpath(os.path.dirname(output_file)) + + try: + self.spawn(pp_args) + except DistutilsExecError as msg: + raise CompileError(msg) + + def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts): + compiler_so = compiler_fixup(self.compiler_so, cc_args + extra_postargs) + compiler_so_cxx = compiler_fixup(self.compiler_so_cxx, cc_args + extra_postargs) + try: + if self.detect_language(src) == 'c++': + self.spawn( + compiler_so_cxx + cc_args + [src, '-o', obj] + extra_postargs + ) + else: + self.spawn(compiler_so + cc_args + [src, '-o', obj] + extra_postargs) + except DistutilsExecError as msg: + raise CompileError(msg) + + def create_static_lib( + self, objects, output_libname, output_dir=None, debug=False, target_lang=None + ): + objects, output_dir = self._fix_object_args(objects, output_dir) + + output_filename = self.library_filename(output_libname, output_dir=output_dir) + + if self._need_link(objects, output_filename): + self.mkpath(os.path.dirname(output_filename)) + self.spawn(self.archiver + [output_filename] + objects + self.objects) + + # Not many Unices required ranlib anymore -- SunOS 4.x is, I + # think the only major Unix that does. Maybe we need some + # platform intelligence here to skip ranlib if it's not + # needed -- or maybe Python's configure script took care of + # it for us, hence the check for leading colon. + if self.ranlib: + try: + self.spawn(self.ranlib + [output_filename]) + except DistutilsExecError as msg: + raise LibError(msg) + else: + log.debug("skipping %s (up-to-date)", output_filename) + + def link( + self, + target_desc, + objects: list[str] | tuple[str, ...], + output_filename, + output_dir: str | None = None, + libraries: list[str] | tuple[str, ...] | None = None, + library_dirs: list[str] | tuple[str, ...] | None = None, + runtime_library_dirs: list[str] | tuple[str, ...] | None = None, + export_symbols=None, + debug=False, + extra_preargs=None, + extra_postargs=None, + build_temp=None, + target_lang=None, + ): + objects, output_dir = self._fix_object_args(objects, output_dir) + fixed_args = self._fix_lib_args(libraries, library_dirs, runtime_library_dirs) + libraries, library_dirs, runtime_library_dirs = fixed_args + + lib_opts = gen_lib_options(self, library_dirs, runtime_library_dirs, libraries) + if not isinstance(output_dir, (str, type(None))): + raise TypeError("'output_dir' must be a string or None") + if output_dir is not None: + output_filename = os.path.join(output_dir, output_filename) + + if self._need_link(objects, output_filename): + ld_args = objects + self.objects + lib_opts + ['-o', output_filename] + if debug: + ld_args[:0] = ['-g'] + if extra_preargs: + ld_args[:0] = extra_preargs + if extra_postargs: + ld_args.extend(extra_postargs) + self.mkpath(os.path.dirname(output_filename)) + try: + # Select a linker based on context: linker_exe when + # building an executable or linker_so (with shared options) + # when building a shared library. + building_exe = target_desc == base.Compiler.EXECUTABLE + target_cxx = target_lang == "c++" + linker = ( + (self.linker_exe_cxx if target_cxx else self.linker_exe) + if building_exe + else (self.linker_so_cxx if target_cxx else self.linker_so) + )[:] + + if target_cxx and self.compiler_cxx: + env, linker_ne = _split_env(linker) + aix, linker_na = _split_aix(linker_ne) + _, compiler_cxx_ne = _split_env(self.compiler_cxx) + _, linker_exe_ne = _split_env(self.linker_exe_cxx) + + params = _linker_params(linker_na, linker_exe_ne) + linker = env + aix + compiler_cxx_ne + params + + linker = compiler_fixup(linker, ld_args) + + self.spawn(linker + ld_args) + except DistutilsExecError as msg: + raise LinkError(msg) + else: + log.debug("skipping %s (up-to-date)", output_filename) + + # -- Miscellaneous methods ----------------------------------------- + # These are all used by the 'gen_lib_options() function, in + # ccompiler.py. + + def library_dir_option(self, dir): + return "-L" + dir + + def _is_gcc(self): + cc_var = sysconfig.get_config_var("CC") + compiler = os.path.basename(shlex.split(cc_var)[0]) + return "gcc" in compiler or "g++" in compiler + + def runtime_library_dir_option(self, dir: str) -> str | list[str]: # type: ignore[override] # Fixed in pypa/distutils#339 + # XXX Hackish, at the very least. See Python bug #445902: + # https://bugs.python.org/issue445902 + # Linkers on different platforms need different options to + # specify that directories need to be added to the list of + # directories searched for dependencies when a dynamic library + # is sought. GCC on GNU systems (Linux, FreeBSD, ...) has to + # be told to pass the -R option through to the linker, whereas + # other compilers and gcc on other systems just know this. + # Other compilers may need something slightly different. At + # this time, there's no way to determine this information from + # the configuration data stored in the Python installation, so + # we use this hack. + if sys.platform[:6] == "darwin": + from distutils.util import get_macosx_target_ver, split_version + + macosx_target_ver = get_macosx_target_ver() + if macosx_target_ver and split_version(macosx_target_ver) >= [10, 5]: + return "-Wl,-rpath," + dir + else: # no support for -rpath on earlier macOS versions + return "-L" + dir + elif sys.platform[:7] == "freebsd": + return "-Wl,-rpath=" + dir + elif sys.platform[:5] == "hp-ux": + return [ + "-Wl,+s" if self._is_gcc() else "+s", + "-L" + dir, + ] + + # For all compilers, `-Wl` is the presumed way to pass a + # compiler option to the linker + if sysconfig.get_config_var("GNULD") == "yes": + return consolidate_linker_args([ + # Force RUNPATH instead of RPATH + "-Wl,--enable-new-dtags", + "-Wl,-rpath," + dir, + ]) + else: + return "-Wl,-R" + dir + + def library_option(self, lib): + return "-l" + lib + + @staticmethod + def _library_root(dir): + """ + macOS users can specify an alternate SDK using'-isysroot'. + Calculate the SDK root if it is specified. + + Note that, as of Xcode 7, Apple SDKs may contain textual stub + libraries with .tbd extensions rather than the normal .dylib + shared libraries installed in /. The Apple compiler tool + chain handles this transparently but it can cause problems + for programs that are being built with an SDK and searching + for specific libraries. Callers of find_library_file need to + keep in mind that the base filename of the returned SDK library + file might have a different extension from that of the library + file installed on the running system, for example: + /Applications/Xcode.app/Contents/Developer/Platforms/ + MacOSX.platform/Developer/SDKs/MacOSX10.11.sdk/ + usr/lib/libedit.tbd + vs + /usr/lib/libedit.dylib + """ + cflags = sysconfig.get_config_var('CFLAGS') + match = re.search(r'-isysroot\s*(\S+)', cflags) + + apply_root = ( + sys.platform == 'darwin' + and match + and ( + dir.startswith('/System/') + or (dir.startswith('/usr/') and not dir.startswith('/usr/local/')) + ) + ) + + return os.path.join(match.group(1), dir[1:]) if apply_root else dir + + def find_library_file(self, dirs, lib, debug=False): + """ + Second-guess the linker with not much hard + data to go on: GCC seems to prefer the shared library, so + assume that *all* Unix C compilers do, + ignoring even GCC's "-static" option. + """ + lib_names = ( + self.library_filename(lib, lib_type=type) + for type in 'dylib xcode_stub shared static'.split() + ) + + roots = map(self._library_root, dirs) + + searched = itertools.starmap(os.path.join, itertools.product(roots, lib_names)) + + found = filter(os.path.exists, searched) + + # Return None if it could not be found in any dir. + return next(found, None) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/zos.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/zos.py new file mode 100644 index 0000000000000000000000000000000000000000..681c63166be8dfea8ec3f621586b901220abe1c5 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/zos.py @@ -0,0 +1,230 @@ +"""distutils.zosccompiler + +Contains the selection of the c & c++ compilers on z/OS. There are several +different c compilers on z/OS, all of them are optional, so the correct +one needs to be chosen based on the users input. This is compatible with +the following compilers: + +IBM C/C++ For Open Enterprise Languages on z/OS 2.0 +IBM Open XL C/C++ 1.1 for z/OS +IBM XL C/C++ V2.4.1 for z/OS 2.4 and 2.5 +IBM z/OS XL C/C++ +""" + +import os + +from ... import sysconfig +from ...errors import DistutilsExecError +from . import unix +from .errors import CompileError + +_cc_args = { + 'ibm-openxl': [ + '-m64', + '-fvisibility=default', + '-fzos-le-char-mode=ascii', + '-fno-short-enums', + ], + 'ibm-xlclang': [ + '-q64', + '-qexportall', + '-qascii', + '-qstrict', + '-qnocsect', + '-Wa,asa,goff', + '-Wa,xplink', + '-qgonumber', + '-qenum=int', + '-Wc,DLL', + ], + 'ibm-xlc': [ + '-q64', + '-qexportall', + '-qascii', + '-qstrict', + '-qnocsect', + '-Wa,asa,goff', + '-Wa,xplink', + '-qgonumber', + '-qenum=int', + '-Wc,DLL', + '-qlanglvl=extc99', + ], +} + +_cxx_args = { + 'ibm-openxl': [ + '-m64', + '-fvisibility=default', + '-fzos-le-char-mode=ascii', + '-fno-short-enums', + ], + 'ibm-xlclang': [ + '-q64', + '-qexportall', + '-qascii', + '-qstrict', + '-qnocsect', + '-Wa,asa,goff', + '-Wa,xplink', + '-qgonumber', + '-qenum=int', + '-Wc,DLL', + ], + 'ibm-xlc': [ + '-q64', + '-qexportall', + '-qascii', + '-qstrict', + '-qnocsect', + '-Wa,asa,goff', + '-Wa,xplink', + '-qgonumber', + '-qenum=int', + '-Wc,DLL', + '-qlanglvl=extended0x', + ], +} + +_asm_args = { + 'ibm-openxl': ['-fasm', '-fno-integrated-as', '-Wa,--ASA', '-Wa,--GOFF'], + 'ibm-xlclang': [], + 'ibm-xlc': [], +} + +_ld_args = { + 'ibm-openxl': [], + 'ibm-xlclang': ['-Wl,dll', '-q64'], + 'ibm-xlc': ['-Wl,dll', '-q64'], +} + + +# Python on z/OS is built with no compiler specific options in it's CFLAGS. +# But each compiler requires it's own specific options to build successfully, +# though some of the options are common between them +class Compiler(unix.Compiler): + src_extensions = ['.c', '.C', '.cc', '.cxx', '.cpp', '.m', '.s'] + _cpp_extensions = ['.cc', '.cpp', '.cxx', '.C'] + _asm_extensions = ['.s'] + + def _get_zos_compiler_name(self): + zos_compiler_names = [ + os.path.basename(binary) + for envvar in ('CC', 'CXX', 'LDSHARED') + if (binary := os.environ.get(envvar, None)) + ] + if len(zos_compiler_names) == 0: + return 'ibm-openxl' + + zos_compilers = {} + for compiler in ( + 'ibm-clang', + 'ibm-clang64', + 'ibm-clang++', + 'ibm-clang++64', + 'clang', + 'clang++', + 'clang-14', + ): + zos_compilers[compiler] = 'ibm-openxl' + + for compiler in ('xlclang', 'xlclang++', 'njsc', 'njsc++'): + zos_compilers[compiler] = 'ibm-xlclang' + + for compiler in ('xlc', 'xlC', 'xlc++'): + zos_compilers[compiler] = 'ibm-xlc' + + return zos_compilers.get(zos_compiler_names[0], 'ibm-openxl') + + def __init__(self, verbose=False, force=False): + super().__init__(verbose, force=force) + self.zos_compiler = self._get_zos_compiler_name() + sysconfig.customize_compiler(self) + + def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts): + local_args = [] + if ext in self._cpp_extensions: + compiler = self.compiler_cxx + local_args.extend(_cxx_args[self.zos_compiler]) + elif ext in self._asm_extensions: + compiler = self.compiler_so + local_args.extend(_cc_args[self.zos_compiler]) + local_args.extend(_asm_args[self.zos_compiler]) + else: + compiler = self.compiler_so + local_args.extend(_cc_args[self.zos_compiler]) + local_args.extend(cc_args) + + try: + self.spawn(compiler + local_args + [src, '-o', obj] + extra_postargs) + except DistutilsExecError as msg: + raise CompileError(msg) + + def runtime_library_dir_option(self, dir): + return '-L' + dir + + def link( + self, + target_desc, + objects, + output_filename, + output_dir=None, + libraries=None, + library_dirs=None, + runtime_library_dirs=None, + export_symbols=None, + debug=False, + extra_preargs=None, + extra_postargs=None, + build_temp=None, + target_lang=None, + ): + # For a built module to use functions from cpython, it needs to use Pythons + # side deck file. The side deck is located beside the libpython3.xx.so + ldversion = sysconfig.get_config_var('LDVERSION') + if sysconfig.python_build: + side_deck_path = os.path.join( + sysconfig.get_config_var('abs_builddir'), + f'libpython{ldversion}.x', + ) + else: + side_deck_path = os.path.join( + sysconfig.get_config_var('installed_base'), + sysconfig.get_config_var('platlibdir'), + f'libpython{ldversion}.x', + ) + + if os.path.exists(side_deck_path): + if extra_postargs: + extra_postargs.append(side_deck_path) + else: + extra_postargs = [side_deck_path] + + # Check and replace libraries included side deck files + if runtime_library_dirs: + for dir in runtime_library_dirs: + for library in libraries[:]: + library_side_deck = os.path.join(dir, f'{library}.x') + if os.path.exists(library_side_deck): + libraries.remove(library) + extra_postargs.append(library_side_deck) + break + + # Any required ld args for the given compiler + extra_postargs.extend(_ld_args[self.zos_compiler]) + + super().link( + target_desc, + objects, + output_filename, + output_dir, + libraries, + library_dirs, + runtime_library_dirs, + export_symbols, + debug, + extra_preargs, + extra_postargs, + build_temp, + target_lang, + ) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/core.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/core.py new file mode 100644 index 0000000000000000000000000000000000000000..bd62546bdd9d35dcc46e0b46a46b0c61a43fd0ba --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/core.py @@ -0,0 +1,289 @@ +"""distutils.core + +The only module that needs to be imported to use the Distutils; provides +the 'setup' function (which is to be called from the setup script). Also +indirectly provides the Distribution and Command classes, although they are +really defined in distutils.dist and distutils.cmd. +""" + +from __future__ import annotations + +import os +import sys +import tokenize +from collections.abc import Iterable + +from .cmd import Command +from .debug import DEBUG + +# Mainly import these so setup scripts can "from distutils.core import" them. +from .dist import Distribution +from .errors import ( + CCompilerError, + DistutilsArgError, + DistutilsError, + DistutilsSetupError, +) +from .extension import Extension + +__all__ = ['Distribution', 'Command', 'Extension', 'setup'] + +# This is a barebones help message generated displayed when the user +# runs the setup script with no arguments at all. More useful help +# is generated with various --help options: global help, list commands, +# and per-command help. +USAGE = """\ +usage: %(script)s [global_opts] cmd1 [cmd1_opts] [cmd2 [cmd2_opts] ...] + or: %(script)s --help [cmd1 cmd2 ...] + or: %(script)s --help-commands + or: %(script)s cmd --help +""" + + +def gen_usage(script_name): + script = os.path.basename(script_name) + return USAGE % locals() + + +# Some mild magic to control the behaviour of 'setup()' from 'run_setup()'. +_setup_stop_after = None +_setup_distribution = None + +# Legal keyword arguments for the setup() function +setup_keywords = ( + 'distclass', + 'script_name', + 'script_args', + 'options', + 'name', + 'version', + 'author', + 'author_email', + 'maintainer', + 'maintainer_email', + 'url', + 'license', + 'description', + 'long_description', + 'keywords', + 'platforms', + 'classifiers', + 'download_url', + 'requires', + 'provides', + 'obsoletes', +) + +# Legal keyword arguments for the Extension constructor +extension_keywords = ( + 'name', + 'sources', + 'include_dirs', + 'define_macros', + 'undef_macros', + 'library_dirs', + 'libraries', + 'runtime_library_dirs', + 'extra_objects', + 'extra_compile_args', + 'extra_link_args', + 'swig_opts', + 'export_symbols', + 'depends', + 'language', +) + + +def setup(**attrs): # noqa: C901 + """The gateway to the Distutils: do everything your setup script needs + to do, in a highly flexible and user-driven way. Briefly: create a + Distribution instance; find and parse config files; parse the command + line; run each Distutils command found there, customized by the options + supplied to 'setup()' (as keyword arguments), in config files, and on + the command line. + + The Distribution instance might be an instance of a class supplied via + the 'distclass' keyword argument to 'setup'; if no such class is + supplied, then the Distribution class (in dist.py) is instantiated. + All other arguments to 'setup' (except for 'cmdclass') are used to set + attributes of the Distribution instance. + + The 'cmdclass' argument, if supplied, is a dictionary mapping command + names to command classes. Each command encountered on the command line + will be turned into a command class, which is in turn instantiated; any + class found in 'cmdclass' is used in place of the default, which is + (for command 'foo_bar') class 'foo_bar' in module + 'distutils.command.foo_bar'. The command class must provide a + 'user_options' attribute which is a list of option specifiers for + 'distutils.fancy_getopt'. Any command-line options between the current + and the next command are used to set attributes of the current command + object. + + When the entire command-line has been successfully parsed, calls the + 'run()' method on each command object in turn. This method will be + driven entirely by the Distribution object (which each command object + has a reference to, thanks to its constructor), and the + command-specific options that became attributes of each command + object. + """ + + global _setup_stop_after, _setup_distribution + + # Determine the distribution class -- either caller-supplied or + # our Distribution (see below). + klass = attrs.get('distclass') + if klass: + attrs.pop('distclass') + else: + klass = Distribution + + if 'script_name' not in attrs: + attrs['script_name'] = os.path.basename(sys.argv[0]) + if 'script_args' not in attrs: + attrs['script_args'] = sys.argv[1:] + + # Create the Distribution instance, using the remaining arguments + # (ie. everything except distclass) to initialize it + try: + _setup_distribution = dist = klass(attrs) + except DistutilsSetupError as msg: + if 'name' not in attrs: + raise SystemExit(f"error in setup command: {msg}") + else: + raise SystemExit("error in {} setup command: {}".format(attrs['name'], msg)) + + if _setup_stop_after == "init": + return dist + + # Find and parse the config file(s): they will override options from + # the setup script, but be overridden by the command line. + dist.parse_config_files() + + if DEBUG: + print("options (after parsing config files):") + dist.dump_option_dicts() + + if _setup_stop_after == "config": + return dist + + # Parse the command line and override config files; any + # command-line errors are the end user's fault, so turn them into + # SystemExit to suppress tracebacks. + try: + ok = dist.parse_command_line() + except DistutilsArgError as msg: + raise SystemExit(gen_usage(dist.script_name) + f"\nerror: {msg}") + + if DEBUG: + print("options (after parsing command line):") + dist.dump_option_dicts() + + if _setup_stop_after == "commandline": + return dist + + # And finally, run all the commands found on the command line. + if ok: + return run_commands(dist) + + return dist + + +# setup () + + +def run_commands(dist): + """Given a Distribution object run all the commands, + raising ``SystemExit`` errors in the case of failure. + + This function assumes that either ``sys.argv`` or ``dist.script_args`` + is already set accordingly. + """ + try: + dist.run_commands() + except KeyboardInterrupt: + raise SystemExit("interrupted") + except OSError as exc: + if DEBUG: + sys.stderr.write(f"error: {exc}\n") + raise + else: + raise SystemExit(f"error: {exc}") + + except (DistutilsError, CCompilerError) as msg: + if DEBUG: + raise + else: + raise SystemExit("error: " + str(msg)) + + return dist + + +def run_setup(script_name, script_args: Iterable[str] | None = None, stop_after="run"): + """Run a setup script in a somewhat controlled environment, and + return the Distribution instance that drives things. This is useful + if you need to find out the distribution meta-data (passed as + keyword args from 'script' to 'setup()', or the contents of the + config files or command-line. + + 'script_name' is a file that will be read and run with 'exec()'; + 'sys.argv[0]' will be replaced with 'script' for the duration of the + call. 'script_args' is a list of strings; if supplied, + 'sys.argv[1:]' will be replaced by 'script_args' for the duration of + the call. + + 'stop_after' tells 'setup()' when to stop processing; possible + values: + init + stop after the Distribution instance has been created and + populated with the keyword arguments to 'setup()' + config + stop after config files have been parsed (and their data + stored in the Distribution instance) + commandline + stop after the command-line ('sys.argv[1:]' or 'script_args') + have been parsed (and the data stored in the Distribution) + run [default] + stop after all commands have been run (the same as if 'setup()' + had been called in the usual way + + Returns the Distribution instance, which provides all information + used to drive the Distutils. + """ + if stop_after not in ('init', 'config', 'commandline', 'run'): + raise ValueError(f"invalid value for 'stop_after': {stop_after!r}") + + global _setup_stop_after, _setup_distribution + _setup_stop_after = stop_after + + save_argv = sys.argv.copy() + g = {'__file__': script_name, '__name__': '__main__'} + try: + try: + sys.argv[0] = script_name + if script_args is not None: + sys.argv[1:] = script_args + # tokenize.open supports automatic encoding detection + with tokenize.open(script_name) as f: + code = f.read().replace(r'\r\n', r'\n') + exec(code, g) + finally: + sys.argv = save_argv + _setup_stop_after = None + except SystemExit: + # Hmm, should we do something if exiting with a non-zero code + # (ie. error)? + pass + + if _setup_distribution is None: + raise RuntimeError( + "'distutils.core.setup()' was never called -- " + f"perhaps '{script_name}' is not a Distutils setup script?" + ) + + # I wonder if the setup script's namespace -- g and l -- would be of + # any interest to callers? + # print "_setup_distribution:", _setup_distribution + return _setup_distribution + + +# run_setup () diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/cygwinccompiler.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/cygwinccompiler.py new file mode 100644 index 0000000000000000000000000000000000000000..de89e3cd8402c9b7048c9e456ff67601934f972b --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/cygwinccompiler.py @@ -0,0 +1,31 @@ +from .compilers.C import cygwin +from .compilers.C.cygwin import ( + CONFIG_H_NOTOK, + CONFIG_H_OK, + CONFIG_H_UNCERTAIN, + check_config_h, + get_msvcr, + is_cygwincc, +) + +__all__ = [ + 'CONFIG_H_NOTOK', + 'CONFIG_H_OK', + 'CONFIG_H_UNCERTAIN', + 'CygwinCCompiler', + 'Mingw32CCompiler', + 'check_config_h', + 'get_msvcr', + 'is_cygwincc', +] + + +CygwinCCompiler = cygwin.Compiler +Mingw32CCompiler = cygwin.MinGW32Compiler + + +get_versions = None +""" +A stand-in for the previous get_versions() function to prevent failures +when monkeypatched. See pypa/setuptools#2969. +""" diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/debug.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/debug.py new file mode 100644 index 0000000000000000000000000000000000000000..daf1660f0d821143e388d37532a39ddfd2ca0347 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/debug.py @@ -0,0 +1,5 @@ +import os + +# If DISTUTILS_DEBUG is anything other than the empty string, we run in +# debug mode. +DEBUG = os.environ.get('DISTUTILS_DEBUG') diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/dep_util.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/dep_util.py new file mode 100644 index 0000000000000000000000000000000000000000..09a8a2e126c8bb009dbbe61c5c4bd5e358744996 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/dep_util.py @@ -0,0 +1,14 @@ +import warnings + +from . import _modified + + +def __getattr__(name): + if name not in ['newer', 'newer_group', 'newer_pairwise']: + raise AttributeError(name) + warnings.warn( + "dep_util is Deprecated. Use functions from setuptools instead.", + DeprecationWarning, + stacklevel=2, + ) + return getattr(_modified, name) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/dir_util.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/dir_util.py new file mode 100644 index 0000000000000000000000000000000000000000..61b4575aa0318029c103f40af179cab20ed179b2 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/dir_util.py @@ -0,0 +1,232 @@ +"""distutils.dir_util + +Utility functions for manipulating directories and directory trees.""" + +import functools +import itertools +import os +import pathlib + +from . import file_util +from ._log import log +from .errors import DistutilsFileError, DistutilsInternalError + + +class SkipRepeatAbsolutePaths(set): + """ + Cache for mkpath. + + In addition to cheapening redundant calls, eliminates redundant + "creating /foo/bar/baz" messages in dry-run mode. + """ + + def __init__(self): + SkipRepeatAbsolutePaths.instance = self + + @classmethod + def clear(cls): + super(cls, cls.instance).clear() + + def wrap(self, func): + @functools.wraps(func) + def wrapper(path, *args, **kwargs): + if path.absolute() in self: + return + result = func(path, *args, **kwargs) + self.add(path.absolute()) + return result + + return wrapper + + +# Python 3.8 compatibility +wrapper = SkipRepeatAbsolutePaths().wrap + + +@functools.singledispatch +@wrapper +def mkpath(name: pathlib.Path, mode=0o777, verbose=True) -> None: + """Create a directory and any missing ancestor directories. + + If the directory already exists (or if 'name' is the empty string, which + means the current directory, which of course exists), then do nothing. + Raise DistutilsFileError if unable to create some directory along the way + (eg. some sub-path exists, but is a file rather than a directory). + If 'verbose' is true, log the directory created. + """ + if verbose and not name.is_dir(): + log.info("creating %s", name) + + try: + name.mkdir(mode=mode, parents=True, exist_ok=True) + except OSError as exc: + raise DistutilsFileError(f"could not create '{name}': {exc.args[-1]}") + + +@mkpath.register +def _(name: str, *args, **kwargs): + return mkpath(pathlib.Path(name), *args, **kwargs) + + +@mkpath.register +def _(name: None, *args, **kwargs): + """ + Detect a common bug -- name is None. + """ + raise DistutilsInternalError(f"mkpath: 'name' must be a string (got {name!r})") + + +def create_tree(base_dir, files, mode=0o777, verbose=True): + """Create all the empty directories under 'base_dir' needed to put 'files' + there. + + 'base_dir' is just the name of a directory which doesn't necessarily + exist yet; 'files' is a list of filenames to be interpreted relative to + 'base_dir'. 'base_dir' + the directory portion of every file in 'files' + will be created if it doesn't already exist. 'mode' and 'verbose' + flags are as for 'mkpath()'. + """ + # First get the list of directories to create + need_dir = set(os.path.join(base_dir, os.path.dirname(file)) for file in files) + + # Now create them + for dir in sorted(need_dir): + mkpath(dir, mode, verbose=verbose) + + +def copy_tree( + src, + dst, + preserve_mode=True, + preserve_times=True, + preserve_symlinks=False, + update=False, + verbose=True, +): + """Copy an entire directory tree 'src' to a new location 'dst'. + + Both 'src' and 'dst' must be directory names. If 'src' is not a + directory, raise DistutilsFileError. If 'dst' does not exist, it is + created with 'mkpath()'. The end result of the copy is that every + file in 'src' is copied to 'dst', and directories under 'src' are + recursively copied to 'dst'. Return the list of files that were + copied or might have been copied, using their output name. The + return value is unaffected by 'update': it is simply + the list of all files under 'src', with the names changed to be + under 'dst'. + + 'preserve_mode' and 'preserve_times' are the same as for + 'copy_file'; note that they only apply to regular files, not to + directories. If 'preserve_symlinks' is true, symlinks will be + copied as symlinks (on platforms that support them!); otherwise + (the default), the destination of the symlink will be copied. + 'update' and 'verbose' are the same as for 'copy_file'. + """ + if not os.path.isdir(src): + raise DistutilsFileError(f"cannot copy tree '{src}': not a directory") + try: + names = os.listdir(src) + except OSError as e: + raise DistutilsFileError(f"error listing files in '{src}': {e.strerror}") + + mkpath(dst, verbose=verbose) + + copy_one = functools.partial( + _copy_one, + src=src, + dst=dst, + preserve_symlinks=preserve_symlinks, + verbose=verbose, + preserve_mode=preserve_mode, + preserve_times=preserve_times, + update=update, + ) + return list(itertools.chain.from_iterable(map(copy_one, names))) + + +def _copy_one( + name, + *, + src, + dst, + preserve_symlinks, + verbose, + preserve_mode, + preserve_times, + update, +): + src_name = os.path.join(src, name) + dst_name = os.path.join(dst, name) + + if name.startswith('.nfs'): + # skip NFS rename files + return + + if preserve_symlinks and os.path.islink(src_name): + link_dest = os.readlink(src_name) + if verbose >= 1: + log.info("linking %s -> %s", dst_name, link_dest) + os.symlink(link_dest, dst_name) + yield dst_name + + elif os.path.isdir(src_name): + yield from copy_tree( + src_name, + dst_name, + preserve_mode, + preserve_times, + preserve_symlinks, + update, + verbose=verbose, + ) + else: + file_util.copy_file( + src_name, + dst_name, + preserve_mode, + preserve_times, + update, + verbose=verbose, + ) + yield dst_name + + +def _build_cmdtuple(path, cmdtuples): + """Helper for remove_tree().""" + for f in os.listdir(path): + real_f = os.path.join(path, f) + if os.path.isdir(real_f) and not os.path.islink(real_f): + _build_cmdtuple(real_f, cmdtuples) + else: + cmdtuples.append((os.remove, real_f)) + cmdtuples.append((os.rmdir, path)) + + +def remove_tree(directory, verbose=True): + """Recursively remove an entire directory tree. + + Any errors are ignored (apart from being reported to stdout if 'verbose' + is true). + """ + if verbose >= 1: + log.info("removing '%s' (and everything under it)", directory) + cmdtuples = [] + _build_cmdtuple(directory, cmdtuples) + for cmd in cmdtuples: + try: + cmd[0](cmd[1]) + # Clear the cache + SkipRepeatAbsolutePaths.clear() + except OSError as exc: + log.warning("error removing %s: %s", directory, exc) + + +def ensure_relative(path): + """Take the full path 'path', and make it a relative path. + + This is useful to make 'path' the second argument to os.path.join(). + """ + drive, path = os.path.splitdrive(path) + if path[0:1] == os.sep: + path = drive + path[1:] + return path diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/dist.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/dist.py new file mode 100644 index 0000000000000000000000000000000000000000..e04e487b58bd75b5b50ccb005c2c3de4cf5038af --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/dist.py @@ -0,0 +1,1384 @@ +"""distutils.dist + +Provides the Distribution class, which represents the module distribution +being built/installed/distributed. +""" + +from __future__ import annotations + +import contextlib +import logging +import os +import pathlib +import re +import sys +import warnings +from collections.abc import Iterable, MutableMapping +from email import message_from_file +from typing import ( + IO, + TYPE_CHECKING, + Any, + ClassVar, + Literal, + TypeVar, + Union, + overload, +) + +from packaging.utils import canonicalize_name, canonicalize_version + +from ._log import log +from .debug import DEBUG +from .errors import ( + DistutilsArgError, + DistutilsClassError, + DistutilsModuleError, + DistutilsOptionError, +) +from .fancy_getopt import FancyGetopt, translate_longopt +from .util import check_environ, rfc822_escape, strtobool + +if TYPE_CHECKING: + from _typeshed import SupportsWrite + from typing_extensions import TypeAlias + + # type-only import because of mutual dependence between these modules + from .cmd import Command + +_CommandT = TypeVar("_CommandT", bound="Command") +_OptionsList: TypeAlias = list[ + Union[tuple[str, Union[str, None], str, int], tuple[str, Union[str, None], str]] +] + + +# Regex to define acceptable Distutils command names. This is not *quite* +# the same as a Python NAME -- I don't allow leading underscores. The fact +# that they're very similar is no coincidence; the default naming scheme is +# to look for a Python module named after the command. +command_re = re.compile(r'^[a-zA-Z]([a-zA-Z0-9_]*)$') + + +def _ensure_list(value: str | Iterable[str], fieldname) -> str | list[str]: + if isinstance(value, str): + # a string containing comma separated values is okay. It will + # be converted to a list by Distribution.finalize_options(). + pass + elif not isinstance(value, list): + # passing a tuple or an iterator perhaps, warn and convert + typename = type(value).__name__ + msg = "Warning: '{fieldname}' should be a list, got type '{typename}'" + msg = msg.format(**locals()) + log.warning(msg) + value = list(value) + return value + + +class Distribution: + """The core of the Distutils. Most of the work hiding behind 'setup' + is really done within a Distribution instance, which farms the work out + to the Distutils commands specified on the command line. + + Setup scripts will almost never instantiate Distribution directly, + unless the 'setup()' function is totally inadequate to their needs. + However, it is conceivable that a setup script might wish to subclass + Distribution for some specialized purpose, and then pass the subclass + to 'setup()' as the 'distclass' keyword argument. If so, it is + necessary to respect the expectations that 'setup' has of Distribution. + See the code for 'setup()', in core.py, for details. + """ + + # 'global_options' describes the command-line options that may be + # supplied to the setup script prior to any actual commands. + # Eg. "./setup.py -n" or "./setup.py --quiet" both take advantage of + # these global options. This list should be kept to a bare minimum, + # since every global option is also valid as a command option -- and we + # don't want to pollute the commands with too many options that they + # have minimal control over. + # The fourth entry for verbose means that it can be repeated. + global_options: ClassVar[_OptionsList] = [ + ('verbose', 'v', "run verbosely (default)", 1), + ('quiet', 'q', "run quietly (turns verbosity off)"), + ('help', 'h', "show detailed help message"), + ('no-user-cfg', None, 'ignore pydistutils.cfg in your home directory'), + ] + + # 'common_usage' is a short (2-3 line) string describing the common + # usage of the setup script. + common_usage: ClassVar[str] = """\ +Common commands: (see '--help-commands' for more) + + setup.py build will build the package underneath 'build/' + setup.py install will install the package +""" + + # options that are not propagated to the commands + display_options: ClassVar[_OptionsList] = [ + ('help-commands', None, "list all available commands"), + ('name', None, "print package name"), + ('version', 'V', "print package version"), + ('fullname', None, "print -"), + ('author', None, "print the author's name"), + ('author-email', None, "print the author's email address"), + ('maintainer', None, "print the maintainer's name"), + ('maintainer-email', None, "print the maintainer's email address"), + ('contact', None, "print the maintainer's name if known, else the author's"), + ( + 'contact-email', + None, + "print the maintainer's email address if known, else the author's", + ), + ('url', None, "print the URL for this package"), + ('license', None, "print the license of the package"), + ('licence', None, "alias for --license"), + ('description', None, "print the package description"), + ('long-description', None, "print the long package description"), + ('platforms', None, "print the list of platforms"), + ('classifiers', None, "print the list of classifiers"), + ('keywords', None, "print the list of keywords"), + ('provides', None, "print the list of packages/modules provided"), + ('requires', None, "print the list of packages/modules required"), + ('obsoletes', None, "print the list of packages/modules made obsolete"), + ] + display_option_names: ClassVar[list[str]] = [ + translate_longopt(x[0]) for x in display_options + ] + + # negative options are options that exclude other options + negative_opt: ClassVar[dict[str, str]] = {'quiet': 'verbose'} + + # -- Creation/initialization methods ------------------------------- + + # Can't Unpack a TypedDict with optional properties, so using Any instead + def __init__(self, attrs: MutableMapping[str, Any] | None = None) -> None: # noqa: C901 + """Construct a new Distribution instance: initialize all the + attributes of a Distribution, and then use 'attrs' (a dictionary + mapping attribute names to values) to assign some of those + attributes their "real" values. (Any attributes not mentioned in + 'attrs' will be assigned to some null value: 0, None, an empty list + or dictionary, etc.) Most importantly, initialize the + 'command_obj' attribute to the empty dictionary; this will be + filled in with real command objects by 'parse_command_line()'. + """ + + # Default values for our command-line options + self.verbose = True + self.help = False + for attr in self.display_option_names: + setattr(self, attr, False) + + # Store the distribution meta-data (name, version, author, and so + # forth) in a separate object -- we're getting to have enough + # information here (and enough command-line options) that it's + # worth it. Also delegate 'get_XXX()' methods to the 'metadata' + # object in a sneaky and underhanded (but efficient!) way. + self.metadata = DistributionMetadata() + for basename in self.metadata._METHOD_BASENAMES: + method_name = "get_" + basename + setattr(self, method_name, getattr(self.metadata, method_name)) + + # 'cmdclass' maps command names to class objects, so we + # can 1) quickly figure out which class to instantiate when + # we need to create a new command object, and 2) have a way + # for the setup script to override command classes + self.cmdclass: dict[str, type[Command]] = {} + + # 'command_packages' is a list of packages in which commands + # are searched for. The factory for command 'foo' is expected + # to be named 'foo' in the module 'foo' in one of the packages + # named here. This list is searched from the left; an error + # is raised if no named package provides the command being + # searched for. (Always access using get_command_packages().) + self.command_packages: str | list[str] | None = None + + # 'script_name' and 'script_args' are usually set to sys.argv[0] + # and sys.argv[1:], but they can be overridden when the caller is + # not necessarily a setup script run from the command-line. + self.script_name: str | os.PathLike[str] | None = None + self.script_args: list[str] | None = None + + # 'command_options' is where we store command options between + # parsing them (from config files, the command-line, etc.) and when + # they are actually needed -- ie. when the command in question is + # instantiated. It is a dictionary of dictionaries of 2-tuples: + # command_options = { command_name : { option : (source, value) } } + self.command_options: dict[str, dict[str, tuple[str, str]]] = {} + + # 'dist_files' is the list of (command, pyversion, file) that + # have been created by any dist commands run so far. This is + # filled regardless of whether the run is dry or not. pyversion + # gives sysconfig.get_python_version() if the dist file is + # specific to a Python version, 'any' if it is good for all + # Python versions on the target platform, and '' for a source + # file. pyversion should not be used to specify minimum or + # maximum required Python versions; use the metainfo for that + # instead. + self.dist_files: list[tuple[str, str, str]] = [] + + # These options are really the business of various commands, rather + # than of the Distribution itself. We provide aliases for them in + # Distribution as a convenience to the developer. + self.packages = None + self.package_data: dict[str, list[str]] = {} + self.package_dir = None + self.py_modules = None + self.libraries = None + self.headers = None + self.ext_modules = None + self.ext_package = None + self.include_dirs = None + self.extra_path = None + self.scripts = None + self.data_files = None + self.password = '' + + # And now initialize bookkeeping stuff that can't be supplied by + # the caller at all. 'command_obj' maps command names to + # Command instances -- that's how we enforce that every command + # class is a singleton. + self.command_obj: dict[str, Command] = {} + + # 'have_run' maps command names to boolean values; it keeps track + # of whether we have actually run a particular command, to make it + # cheap to "run" a command whenever we think we might need to -- if + # it's already been done, no need for expensive filesystem + # operations, we just check the 'have_run' dictionary and carry on. + # It's only safe to query 'have_run' for a command class that has + # been instantiated -- a false value will be inserted when the + # command object is created, and replaced with a true value when + # the command is successfully run. Thus it's probably best to use + # '.get()' rather than a straight lookup. + self.have_run: dict[str, bool] = {} + + # Now we'll use the attrs dictionary (ultimately, keyword args from + # the setup script) to possibly override any or all of these + # distribution options. + + if attrs: + # Pull out the set of command options and work on them + # specifically. Note that this order guarantees that aliased + # command options will override any supplied redundantly + # through the general options dictionary. + options = attrs.get('options') + if options is not None: + del attrs['options'] + for command, cmd_options in options.items(): + opt_dict = self.get_option_dict(command) + for opt, val in cmd_options.items(): + opt_dict[opt] = ("setup script", val) + + if 'licence' in attrs: + attrs['license'] = attrs['licence'] + del attrs['licence'] + msg = "'licence' distribution option is deprecated; use 'license'" + warnings.warn(msg) + + # Now work on the rest of the attributes. Any attribute that's + # not already defined is invalid! + for key, val in attrs.items(): + if hasattr(self.metadata, "set_" + key): + getattr(self.metadata, "set_" + key)(val) + elif hasattr(self.metadata, key): + setattr(self.metadata, key, val) + elif hasattr(self, key): + setattr(self, key, val) + else: + msg = f"Unknown distribution option: {key!r}" + warnings.warn(msg) + + # no-user-cfg is handled before other command line args + # because other args override the config files, and this + # one is needed before we can load the config files. + # If attrs['script_args'] wasn't passed, assume false. + # + # This also make sure we just look at the global options + self.want_user_cfg = True + + if self.script_args is not None: + # Coerce any possible iterable from attrs into a list + self.script_args = list(self.script_args) + for arg in self.script_args: + if not arg.startswith('-'): + break + if arg == '--no-user-cfg': + self.want_user_cfg = False + break + + self.finalize_options() + + def get_option_dict(self, command): + """Get the option dictionary for a given command. If that + command's option dictionary hasn't been created yet, then create it + and return the new dictionary; otherwise, return the existing + option dictionary. + """ + dict = self.command_options.get(command) + if dict is None: + dict = self.command_options[command] = {} + return dict + + def dump_option_dicts(self, header=None, commands=None, indent: str = "") -> None: + from pprint import pformat + + if commands is None: # dump all command option dicts + commands = sorted(self.command_options.keys()) + + if header is not None: + self.announce(indent + header) + indent = indent + " " + + if not commands: + self.announce(indent + "no commands known yet") + return + + for cmd_name in commands: + opt_dict = self.command_options.get(cmd_name) + if opt_dict is None: + self.announce(indent + f"no option dict for '{cmd_name}' command") + else: + self.announce(indent + f"option dict for '{cmd_name}' command:") + out = pformat(opt_dict) + for line in out.split('\n'): + self.announce(indent + " " + line) + + # -- Config file finding/parsing methods --------------------------- + + def find_config_files(self): + """Find as many configuration files as should be processed for this + platform, and return a list of filenames in the order in which they + should be parsed. The filenames returned are guaranteed to exist + (modulo nasty race conditions). + + There are multiple possible config files: + - distutils.cfg in the Distutils installation directory (i.e. + where the top-level Distutils __inst__.py file lives) + - a file in the user's home directory named .pydistutils.cfg + on Unix and pydistutils.cfg on Windows/Mac; may be disabled + with the ``--no-user-cfg`` option + - setup.cfg in the current directory + - a file named by an environment variable + """ + check_environ() + files = [str(path) for path in self._gen_paths() if os.path.isfile(path)] + + if DEBUG: + self.announce("using config files: {}".format(', '.join(files))) + + return files + + def _gen_paths(self): + # The system-wide Distutils config file + sys_dir = pathlib.Path(sys.modules['distutils'].__file__).parent + yield sys_dir / "distutils.cfg" + + # The per-user config file + prefix = '.' * (os.name == 'posix') + filename = prefix + 'pydistutils.cfg' + if self.want_user_cfg: + with contextlib.suppress(RuntimeError): + yield pathlib.Path('~').expanduser() / filename + + # All platforms support local setup.cfg + yield pathlib.Path('setup.cfg') + + # Additional config indicated in the environment + with contextlib.suppress(TypeError): + yield pathlib.Path(os.getenv("DIST_EXTRA_CONFIG")) + + def parse_config_files(self, filenames=None): # noqa: C901 + from configparser import ConfigParser + + # Ignore install directory options if we have a venv + if sys.prefix != sys.base_prefix: + ignore_options = [ + 'install-base', + 'install-platbase', + 'install-lib', + 'install-platlib', + 'install-purelib', + 'install-headers', + 'install-scripts', + 'install-data', + 'prefix', + 'exec-prefix', + 'home', + 'user', + 'root', + ] + else: + ignore_options = [] + + ignore_options = frozenset(ignore_options) + + if filenames is None: + filenames = self.find_config_files() + + if DEBUG: + self.announce("Distribution.parse_config_files():") + + parser = ConfigParser() + for filename in filenames: + if DEBUG: + self.announce(f" reading {filename}") + parser.read(filename, encoding='utf-8') + for section in parser.sections(): + options = parser.options(section) + opt_dict = self.get_option_dict(section) + + for opt in options: + if opt != '__name__' and opt not in ignore_options: + val = parser.get(section, opt) + opt = opt.replace('-', '_') + opt_dict[opt] = (filename, val) + + # Make the ConfigParser forget everything (so we retain + # the original filenames that options come from) + parser.__init__() + + # If there was a "global" section in the config file, use it + # to set Distribution options. + + if 'global' in self.command_options: + for opt, (_src, val) in self.command_options['global'].items(): + alias = self.negative_opt.get(opt) + try: + if alias: + setattr(self, alias, not strtobool(val)) + elif opt in ('verbose',): # ugh! + setattr(self, opt, strtobool(val)) + else: + setattr(self, opt, val) + except ValueError as msg: + raise DistutilsOptionError(msg) + + # -- Command-line parsing methods ---------------------------------- + + def parse_command_line(self): + """Parse the setup script's command line, taken from the + 'script_args' instance attribute (which defaults to 'sys.argv[1:]' + -- see 'setup()' in core.py). This list is first processed for + "global options" -- options that set attributes of the Distribution + instance. Then, it is alternately scanned for Distutils commands + and options for that command. Each new command terminates the + options for the previous command. The allowed options for a + command are determined by the 'user_options' attribute of the + command class -- thus, we have to be able to load command classes + in order to parse the command line. Any error in that 'options' + attribute raises DistutilsGetoptError; any error on the + command-line raises DistutilsArgError. If no Distutils commands + were found on the command line, raises DistutilsArgError. Return + true if command-line was successfully parsed and we should carry + on with executing commands; false if no errors but we shouldn't + execute commands (currently, this only happens if user asks for + help). + """ + # + # We now have enough information to show the Macintosh dialog + # that allows the user to interactively specify the "command line". + # + toplevel_options = self._get_toplevel_options() + + # We have to parse the command line a bit at a time -- global + # options, then the first command, then its options, and so on -- + # because each command will be handled by a different class, and + # the options that are valid for a particular class aren't known + # until we have loaded the command class, which doesn't happen + # until we know what the command is. + + self.commands = [] + parser = FancyGetopt(toplevel_options + self.display_options) + parser.set_negative_aliases(self.negative_opt) + parser.set_aliases({'licence': 'license'}) + args = parser.getopt(args=self.script_args, object=self) + option_order = parser.get_option_order() + logging.getLogger().setLevel(logging.WARN - 10 * self.verbose) + + # for display options we return immediately + if self.handle_display_options(option_order): + return + while args: + args = self._parse_command_opts(parser, args) + if args is None: # user asked for help (and got it) + return + + # Handle the cases of --help as a "global" option, ie. + # "setup.py --help" and "setup.py --help command ...". For the + # former, we show global options (--verbose, --dry-run, etc.) + # and display-only options (--name, --version, etc.); for the + # latter, we omit the display-only options and show help for + # each command listed on the command line. + if self.help: + self._show_help( + parser, display_options=len(self.commands) == 0, commands=self.commands + ) + return + + # Oops, no commands found -- an end-user error + if not self.commands: + raise DistutilsArgError("no commands supplied") + + # All is well: return true + return True + + def _get_toplevel_options(self): + """Return the non-display options recognized at the top level. + + This includes options that are recognized *only* at the top + level as well as options recognized for commands. + """ + return self.global_options + [ + ( + "command-packages=", + None, + "list of packages that provide distutils commands", + ), + ] + + def _parse_command_opts(self, parser, args): # noqa: C901 + """Parse the command-line options for a single command. + 'parser' must be a FancyGetopt instance; 'args' must be the list + of arguments, starting with the current command (whose options + we are about to parse). Returns a new version of 'args' with + the next command at the front of the list; will be the empty + list if there are no more commands on the command line. Returns + None if the user asked for help on this command. + """ + # late import because of mutual dependence between these modules + from distutils.cmd import Command + + # Pull the current command from the head of the command line + command = args[0] + if not command_re.match(command): + raise SystemExit(f"invalid command name '{command}'") + self.commands.append(command) + + # Dig up the command class that implements this command, so we + # 1) know that it's a valid command, and 2) know which options + # it takes. + try: + cmd_class = self.get_command_class(command) + except DistutilsModuleError as msg: + raise DistutilsArgError(msg) + + # Require that the command class be derived from Command -- want + # to be sure that the basic "command" interface is implemented. + if not issubclass(cmd_class, Command): + raise DistutilsClassError( + f"command class {cmd_class} must subclass Command" + ) + + # Also make sure that the command object provides a list of its + # known options. + if not ( + hasattr(cmd_class, 'user_options') + and isinstance(cmd_class.user_options, list) + ): + msg = ( + "command class %s must provide " + "'user_options' attribute (a list of tuples)" + ) + raise DistutilsClassError(msg % cmd_class) + + # If the command class has a list of negative alias options, + # merge it in with the global negative aliases. + negative_opt = self.negative_opt + if hasattr(cmd_class, 'negative_opt'): + negative_opt = negative_opt.copy() + negative_opt.update(cmd_class.negative_opt) + + # Check for help_options in command class. They have a different + # format (tuple of four) so we need to preprocess them here. + if hasattr(cmd_class, 'help_options') and isinstance( + cmd_class.help_options, list + ): + help_options = fix_help_options(cmd_class.help_options) + else: + help_options = [] + + # All commands support the global options too, just by adding + # in 'global_options'. + parser.set_option_table( + self.global_options + cmd_class.user_options + help_options + ) + parser.set_negative_aliases(negative_opt) + (args, opts) = parser.getopt(args[1:]) + if hasattr(opts, 'help') and opts.help: + self._show_help(parser, display_options=False, commands=[cmd_class]) + return + + if hasattr(cmd_class, 'help_options') and isinstance( + cmd_class.help_options, list + ): + help_option_found = 0 + for help_option, _short, _desc, func in cmd_class.help_options: + if hasattr(opts, parser.get_attr_name(help_option)): + help_option_found = 1 + if callable(func): + func() + else: + raise DistutilsClassError( + f"invalid help function {func!r} for help option '{help_option}': " + "must be a callable object (function, etc.)" + ) + + if help_option_found: + return + + # Put the options from the command-line into their official + # holding pen, the 'command_options' dictionary. + opt_dict = self.get_option_dict(command) + for name, value in vars(opts).items(): + opt_dict[name] = ("command line", value) + + return args + + def finalize_options(self) -> None: + """Set final values for all the options on the Distribution + instance, analogous to the .finalize_options() method of Command + objects. + """ + for attr in ('keywords', 'platforms'): + value = getattr(self.metadata, attr) + if value is None: + continue + if isinstance(value, str): + value = [elm.strip() for elm in value.split(',')] + setattr(self.metadata, attr, value) + + def _show_help( + self, parser, global_options=True, display_options=True, commands: Iterable = () + ): + """Show help for the setup script command-line in the form of + several lists of command-line options. 'parser' should be a + FancyGetopt instance; do not expect it to be returned in the + same state, as its option table will be reset to make it + generate the correct help text. + + If 'global_options' is true, lists the global options: + --verbose, --dry-run, etc. If 'display_options' is true, lists + the "display-only" options: --name, --version, etc. Finally, + lists per-command help for every command name or command class + in 'commands'. + """ + # late import because of mutual dependence between these modules + from distutils.cmd import Command + from distutils.core import gen_usage + + if global_options: + if display_options: + options = self._get_toplevel_options() + else: + options = self.global_options + parser.set_option_table(options) + parser.print_help(self.common_usage + "\nGlobal options:") + print() + + if display_options: + parser.set_option_table(self.display_options) + parser.print_help( + "Information display options (just display information, ignore any commands)" + ) + print() + + for command in commands: + if isinstance(command, type) and issubclass(command, Command): + klass = command + else: + klass = self.get_command_class(command) + if hasattr(klass, 'help_options') and isinstance(klass.help_options, list): + parser.set_option_table( + klass.user_options + fix_help_options(klass.help_options) + ) + else: + parser.set_option_table(klass.user_options) + parser.print_help(f"Options for '{klass.__name__}' command:") + print() + + print(gen_usage(self.script_name)) + + def handle_display_options(self, option_order): + """If there were any non-global "display-only" options + (--help-commands or the metadata display options) on the command + line, display the requested info and return true; else return + false. + """ + from distutils.core import gen_usage + + # User just wants a list of commands -- we'll print it out and stop + # processing now (ie. if they ran "setup --help-commands foo bar", + # we ignore "foo bar"). + if self.help_commands: + self.print_commands() + print() + print(gen_usage(self.script_name)) + return 1 + + # If user supplied any of the "display metadata" options, then + # display that metadata in the order in which the user supplied the + # metadata options. + any_display_options = 0 + is_display_option = set() + for option in self.display_options: + is_display_option.add(option[0]) + + for opt, val in option_order: + if val and opt in is_display_option: + opt = translate_longopt(opt) + value = getattr(self.metadata, "get_" + opt)() + if opt in ('keywords', 'platforms'): + print(','.join(value)) + elif opt in ('classifiers', 'provides', 'requires', 'obsoletes'): + print('\n'.join(value)) + else: + print(value) + any_display_options = 1 + + return any_display_options + + def print_command_list(self, commands, header, max_length) -> None: + """Print a subset of the list of all commands -- used by + 'print_commands()'. + """ + print(header + ":") + + for cmd in commands: + klass = self.cmdclass.get(cmd) + if not klass: + klass = self.get_command_class(cmd) + try: + description = klass.description + except AttributeError: + description = "(no description available)" + + print(f" {cmd:<{max_length}} {description}") + + def print_commands(self) -> None: + """Print out a help message listing all available commands with a + description of each. The list is divided into "standard commands" + (listed in distutils.command.__all__) and "extra commands" + (mentioned in self.cmdclass, but not a standard command). The + descriptions come from the command class attribute + 'description'. + """ + import distutils.command + + std_commands = distutils.command.__all__ + is_std = set(std_commands) + + extra_commands = [cmd for cmd in self.cmdclass.keys() if cmd not in is_std] + + max_length = 0 + for cmd in std_commands + extra_commands: + if len(cmd) > max_length: + max_length = len(cmd) + + self.print_command_list(std_commands, "Standard commands", max_length) + if extra_commands: + print() + self.print_command_list(extra_commands, "Extra commands", max_length) + + def get_command_list(self): + """Get a list of (command, description) tuples. + The list is divided into "standard commands" (listed in + distutils.command.__all__) and "extra commands" (mentioned in + self.cmdclass, but not a standard command). The descriptions come + from the command class attribute 'description'. + """ + # Currently this is only used on Mac OS, for the Mac-only GUI + # Distutils interface (by Jack Jansen) + import distutils.command + + std_commands = distutils.command.__all__ + is_std = set(std_commands) + + extra_commands = [cmd for cmd in self.cmdclass.keys() if cmd not in is_std] + + rv = [] + for cmd in std_commands + extra_commands: + klass = self.cmdclass.get(cmd) + if not klass: + klass = self.get_command_class(cmd) + try: + description = klass.description + except AttributeError: + description = "(no description available)" + rv.append((cmd, description)) + return rv + + # -- Command class/object methods ---------------------------------- + + def get_command_packages(self): + """Return a list of packages from which commands are loaded.""" + pkgs = self.command_packages + if not isinstance(pkgs, list): + if pkgs is None: + pkgs = '' + pkgs = [pkg.strip() for pkg in pkgs.split(',') if pkg != ''] + if "distutils.command" not in pkgs: + pkgs.insert(0, "distutils.command") + self.command_packages = pkgs + return pkgs + + def get_command_class(self, command: str) -> type[Command]: + """Return the class that implements the Distutils command named by + 'command'. First we check the 'cmdclass' dictionary; if the + command is mentioned there, we fetch the class object from the + dictionary and return it. Otherwise we load the command module + ("distutils.command." + command) and fetch the command class from + the module. The loaded class is also stored in 'cmdclass' + to speed future calls to 'get_command_class()'. + + Raises DistutilsModuleError if the expected module could not be + found, or if that module does not define the expected class. + """ + klass = self.cmdclass.get(command) + if klass: + return klass + + for pkgname in self.get_command_packages(): + module_name = f"{pkgname}.{command}" + klass_name = command + + try: + __import__(module_name) + module = sys.modules[module_name] + except ImportError: + continue + + try: + klass = getattr(module, klass_name) + except AttributeError: + raise DistutilsModuleError( + f"invalid command '{command}' (no class '{klass_name}' in module '{module_name}')" + ) + + self.cmdclass[command] = klass + return klass + + raise DistutilsModuleError(f"invalid command '{command}'") + + @overload + def get_command_obj( + self, command: str, create: Literal[True] = True + ) -> Command: ... + @overload + def get_command_obj( + self, command: str, create: Literal[False] + ) -> Command | None: ... + def get_command_obj(self, command: str, create: bool = True) -> Command | None: + """Return the command object for 'command'. Normally this object + is cached on a previous call to 'get_command_obj()'; if no command + object for 'command' is in the cache, then we either create and + return it (if 'create' is true) or return None. + """ + cmd_obj = self.command_obj.get(command) + if not cmd_obj and create: + if DEBUG: + self.announce( + "Distribution.get_command_obj(): " + f"creating '{command}' command object" + ) + + klass = self.get_command_class(command) + cmd_obj = self.command_obj[command] = klass(self) + self.have_run[command] = False + + # Set any options that were supplied in config files + # or on the command line. (NB. support for error + # reporting is lame here: any errors aren't reported + # until 'finalize_options()' is called, which means + # we won't report the source of the error.) + options = self.command_options.get(command) + if options: + self._set_command_options(cmd_obj, options) + + return cmd_obj + + def _set_command_options(self, command_obj, option_dict=None): # noqa: C901 + """Set the options for 'command_obj' from 'option_dict'. Basically + this means copying elements of a dictionary ('option_dict') to + attributes of an instance ('command'). + + 'command_obj' must be a Command instance. If 'option_dict' is not + supplied, uses the standard option dictionary for this command + (from 'self.command_options'). + """ + command_name = command_obj.get_command_name() + if option_dict is None: + option_dict = self.get_option_dict(command_name) + + if DEBUG: + self.announce(f" setting options for '{command_name}' command:") + for option, (source, value) in option_dict.items(): + if DEBUG: + self.announce(f" {option} = {value} (from {source})") + try: + bool_opts = [translate_longopt(o) for o in command_obj.boolean_options] + except AttributeError: + bool_opts = [] + try: + neg_opt = command_obj.negative_opt + except AttributeError: + neg_opt = {} + + try: + is_string = isinstance(value, str) + if option in neg_opt and is_string: + setattr(command_obj, neg_opt[option], not strtobool(value)) + elif option in bool_opts and is_string: + setattr(command_obj, option, strtobool(value)) + elif hasattr(command_obj, option): + setattr(command_obj, option, value) + else: + raise DistutilsOptionError( + f"error in {source}: command '{command_name}' has no such option '{option}'" + ) + except ValueError as msg: + raise DistutilsOptionError(msg) + + @overload + def reinitialize_command( + self, command: str, reinit_subcommands: bool = False + ) -> Command: ... + @overload + def reinitialize_command( + self, command: _CommandT, reinit_subcommands: bool = False + ) -> _CommandT: ... + def reinitialize_command( + self, command: str | Command, reinit_subcommands=False + ) -> Command: + """Reinitializes a command to the state it was in when first + returned by 'get_command_obj()': ie., initialized but not yet + finalized. This provides the opportunity to sneak option + values in programmatically, overriding or supplementing + user-supplied values from the config files and command line. + You'll have to re-finalize the command object (by calling + 'finalize_options()' or 'ensure_finalized()') before using it for + real. + + 'command' should be a command name (string) or command object. If + 'reinit_subcommands' is true, also reinitializes the command's + sub-commands, as declared by the 'sub_commands' class attribute (if + it has one). See the "install" command for an example. Only + reinitializes the sub-commands that actually matter, ie. those + whose test predicates return true. + + Returns the reinitialized command object. + """ + from distutils.cmd import Command + + if not isinstance(command, Command): + command_name = command + command = self.get_command_obj(command_name) + else: + command_name = command.get_command_name() + + if not command.finalized: + return command + command.initialize_options() + command.finalized = False + self.have_run[command_name] = False + self._set_command_options(command) + + if reinit_subcommands: + for sub in command.get_sub_commands(): + self.reinitialize_command(sub, reinit_subcommands) + + return command + + # -- Methods that operate on the Distribution ---------------------- + + def announce(self, msg, level: int = logging.INFO) -> None: + log.log(level, msg) + + def run_commands(self) -> None: + """Run each command that was seen on the setup script command line. + Uses the list of commands found and cache of command objects + created by 'get_command_obj()'. + """ + for cmd in self.commands: + self.run_command(cmd) + + # -- Methods that operate on its Commands -------------------------- + + def run_command(self, command: str) -> None: + """Do whatever it takes to run a command (including nothing at all, + if the command has already been run). Specifically: if we have + already created and run the command named by 'command', return + silently without doing anything. If the command named by 'command' + doesn't even have a command object yet, create one. Then invoke + 'run()' on that command object (or an existing one). + """ + # Already been here, done that? then return silently. + if self.have_run.get(command): + return + + log.info("running %s", command) + cmd_obj = self.get_command_obj(command) + cmd_obj.ensure_finalized() + cmd_obj.run() + self.have_run[command] = True + + # -- Distribution query methods ------------------------------------ + + def has_pure_modules(self) -> bool: + return len(self.packages or self.py_modules or []) > 0 + + def has_ext_modules(self) -> bool: + return self.ext_modules and len(self.ext_modules) > 0 + + def has_c_libraries(self) -> bool: + return self.libraries and len(self.libraries) > 0 + + def has_modules(self) -> bool: + return self.has_pure_modules() or self.has_ext_modules() + + def has_headers(self) -> bool: + return self.headers and len(self.headers) > 0 + + def has_scripts(self) -> bool: + return self.scripts and len(self.scripts) > 0 + + def has_data_files(self) -> bool: + return self.data_files and len(self.data_files) > 0 + + def is_pure(self) -> bool: + return ( + self.has_pure_modules() + and not self.has_ext_modules() + and not self.has_c_libraries() + ) + + # -- Metadata query methods ---------------------------------------- + + # If you're looking for 'get_name()', 'get_version()', and so forth, + # they are defined in a sneaky way: the constructor binds self.get_XXX + # to self.metadata.get_XXX. The actual code is in the + # DistributionMetadata class, below. + if TYPE_CHECKING: + # Unfortunately this means we need to specify them manually or not expose statically + def _(self) -> None: + self.get_name = self.metadata.get_name + self.get_version = self.metadata.get_version + self.get_fullname = self.metadata.get_fullname + self.get_author = self.metadata.get_author + self.get_author_email = self.metadata.get_author_email + self.get_maintainer = self.metadata.get_maintainer + self.get_maintainer_email = self.metadata.get_maintainer_email + self.get_contact = self.metadata.get_contact + self.get_contact_email = self.metadata.get_contact_email + self.get_url = self.metadata.get_url + self.get_license = self.metadata.get_license + self.get_licence = self.metadata.get_licence + self.get_description = self.metadata.get_description + self.get_long_description = self.metadata.get_long_description + self.get_keywords = self.metadata.get_keywords + self.get_platforms = self.metadata.get_platforms + self.get_classifiers = self.metadata.get_classifiers + self.get_download_url = self.metadata.get_download_url + self.get_requires = self.metadata.get_requires + self.get_provides = self.metadata.get_provides + self.get_obsoletes = self.metadata.get_obsoletes + + # Default attributes generated in __init__ from self.display_option_names + help_commands: bool + name: str | Literal[False] + version: str | Literal[False] + fullname: str | Literal[False] + author: str | Literal[False] + author_email: str | Literal[False] + maintainer: str | Literal[False] + maintainer_email: str | Literal[False] + contact: str | Literal[False] + contact_email: str | Literal[False] + url: str | Literal[False] + license: str | Literal[False] + licence: str | Literal[False] + description: str | Literal[False] + long_description: str | Literal[False] + platforms: str | list[str] | Literal[False] + classifiers: str | list[str] | Literal[False] + keywords: str | list[str] | Literal[False] + provides: list[str] | Literal[False] + requires: list[str] | Literal[False] + obsoletes: list[str] | Literal[False] + + +class DistributionMetadata: + """Dummy class to hold the distribution meta-data: name, version, + author, and so forth. + """ + + _METHOD_BASENAMES = ( + "name", + "version", + "author", + "author_email", + "maintainer", + "maintainer_email", + "url", + "license", + "description", + "long_description", + "keywords", + "platforms", + "fullname", + "contact", + "contact_email", + "classifiers", + "download_url", + # PEP 314 + "provides", + "requires", + "obsoletes", + ) + + def __init__( + self, path: str | bytes | os.PathLike[str] | os.PathLike[bytes] | None = None + ) -> None: + if path is not None: + self.read_pkg_file(open(path)) + else: + self.name: str | None = None + self.version: str | None = None + self.author: str | None = None + self.author_email: str | None = None + self.maintainer: str | None = None + self.maintainer_email: str | None = None + self.url: str | None = None + self.license: str | None = None + self.description: str | None = None + self.long_description: str | None = None + self.keywords: str | list[str] | None = None + self.platforms: str | list[str] | None = None + self.classifiers: str | list[str] | None = None + self.download_url: str | None = None + # PEP 314 + self.provides: str | list[str] | None = None + self.requires: str | list[str] | None = None + self.obsoletes: str | list[str] | None = None + + def read_pkg_file(self, file: IO[str]) -> None: + """Reads the metadata values from a file object.""" + msg = message_from_file(file) + + def _read_field(name: str) -> str | None: + value = msg[name] + if value and value != "UNKNOWN": + return value + return None + + def _read_list(name): + values = msg.get_all(name, None) + if values == []: + return None + return values + + metadata_version = msg['metadata-version'] + self.name = _read_field('name') + self.version = _read_field('version') + self.description = _read_field('summary') + # we are filling author only. + self.author = _read_field('author') + self.maintainer = None + self.author_email = _read_field('author-email') + self.maintainer_email = None + self.url = _read_field('home-page') + self.license = _read_field('license') + + if 'download-url' in msg: + self.download_url = _read_field('download-url') + else: + self.download_url = None + + self.long_description = _read_field('description') + self.description = _read_field('summary') + + if 'keywords' in msg: + self.keywords = _read_field('keywords').split(',') + + self.platforms = _read_list('platform') + self.classifiers = _read_list('classifier') + + # PEP 314 - these fields only exist in 1.1 + if metadata_version == '1.1': + self.requires = _read_list('requires') + self.provides = _read_list('provides') + self.obsoletes = _read_list('obsoletes') + else: + self.requires = None + self.provides = None + self.obsoletes = None + + def write_pkg_info(self, base_dir: str | os.PathLike[str]) -> None: + """Write the PKG-INFO file into the release tree.""" + with open( + os.path.join(base_dir, 'PKG-INFO'), 'w', encoding='UTF-8' + ) as pkg_info: + self.write_pkg_file(pkg_info) + + def write_pkg_file(self, file: SupportsWrite[str]) -> None: + """Write the PKG-INFO format data to a file object.""" + version = '1.0' + if ( + self.provides + or self.requires + or self.obsoletes + or self.classifiers + or self.download_url + ): + version = '1.1' + + # required fields + file.write(f'Metadata-Version: {version}\n') + file.write(f'Name: {self.get_name()}\n') + file.write(f'Version: {self.get_version()}\n') + + def maybe_write(header, val): + if val: + file.write(f"{header}: {val}\n") + + # optional fields + maybe_write("Summary", self.get_description()) + maybe_write("Home-page", self.get_url()) + maybe_write("Author", self.get_contact()) + maybe_write("Author-email", self.get_contact_email()) + maybe_write("License", self.get_license()) + maybe_write("Download-URL", self.download_url) + maybe_write("Description", rfc822_escape(self.get_long_description() or "")) + maybe_write("Keywords", ",".join(self.get_keywords())) + + self._write_list(file, 'Platform', self.get_platforms()) + self._write_list(file, 'Classifier', self.get_classifiers()) + + # PEP 314 + self._write_list(file, 'Requires', self.get_requires()) + self._write_list(file, 'Provides', self.get_provides()) + self._write_list(file, 'Obsoletes', self.get_obsoletes()) + + def _write_list(self, file, name, values): + values = values or [] + for value in values: + file.write(f'{name}: {value}\n') + + # -- Metadata query methods ---------------------------------------- + + def get_name(self) -> str: + return self.name or "UNKNOWN" + + def get_version(self) -> str: + return self.version or "0.0.0" + + def get_fullname(self) -> str: + return self._fullname(self.get_name(), self.get_version()) + + @staticmethod + def _fullname(name: str, version: str) -> str: + """ + >>> DistributionMetadata._fullname('setup.tools', '1.0-2') + 'setup_tools-1.0.post2' + >>> DistributionMetadata._fullname('setup-tools', '1.2post2') + 'setup_tools-1.2.post2' + >>> DistributionMetadata._fullname('setup-tools', '1.0-r2') + 'setup_tools-1.0.post2' + >>> DistributionMetadata._fullname('setup.tools', '1.0.post') + 'setup_tools-1.0.post0' + >>> DistributionMetadata._fullname('setup.tools', '1.0+ubuntu-1') + 'setup_tools-1.0+ubuntu.1' + """ + return "{}-{}".format( + canonicalize_name(name).replace('-', '_'), + canonicalize_version(version, strip_trailing_zero=False), + ) + + def get_author(self) -> str | None: + return self.author + + def get_author_email(self) -> str | None: + return self.author_email + + def get_maintainer(self) -> str | None: + return self.maintainer + + def get_maintainer_email(self) -> str | None: + return self.maintainer_email + + def get_contact(self) -> str | None: + return self.maintainer or self.author + + def get_contact_email(self) -> str | None: + return self.maintainer_email or self.author_email + + def get_url(self) -> str | None: + return self.url + + def get_license(self) -> str | None: + return self.license + + get_licence = get_license + + def get_description(self) -> str | None: + return self.description + + def get_long_description(self) -> str | None: + return self.long_description + + def get_keywords(self) -> str | list[str]: + return self.keywords or [] + + def set_keywords(self, value: str | Iterable[str]) -> None: + self.keywords = _ensure_list(value, 'keywords') + + def get_platforms(self) -> str | list[str] | None: + return self.platforms + + def set_platforms(self, value: str | Iterable[str]) -> None: + self.platforms = _ensure_list(value, 'platforms') + + def get_classifiers(self) -> str | list[str]: + return self.classifiers or [] + + def set_classifiers(self, value: str | Iterable[str]) -> None: + self.classifiers = _ensure_list(value, 'classifiers') + + def get_download_url(self) -> str | None: + return self.download_url + + # PEP 314 + def get_requires(self) -> str | list[str]: + return self.requires or [] + + def set_requires(self, value: Iterable[str]) -> None: + import distutils.versionpredicate + + for v in value: + distutils.versionpredicate.VersionPredicate(v) + self.requires = list(value) + + def get_provides(self) -> str | list[str]: + return self.provides or [] + + def set_provides(self, value: Iterable[str]) -> None: + value = [v.strip() for v in value] + for v in value: + import distutils.versionpredicate + + distutils.versionpredicate.split_provision(v) + self.provides = value + + def get_obsoletes(self) -> str | list[str]: + return self.obsoletes or [] + + def set_obsoletes(self, value: Iterable[str]) -> None: + import distutils.versionpredicate + + for v in value: + distutils.versionpredicate.VersionPredicate(v) + self.obsoletes = list(value) + + +def fix_help_options(options): + """Convert a 4-tuple 'help_options' list as found in various command + classes to the 3-tuple form required by FancyGetopt. + """ + return [opt[0:3] for opt in options] diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/errors.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/errors.py new file mode 100644 index 0000000000000000000000000000000000000000..409d21faa2caeb8a53fed10e4266f7cccc764d23 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/errors.py @@ -0,0 +1,108 @@ +""" +Exceptions used by the Distutils modules. + +Distutils modules may raise these or standard exceptions, +including :exc:`SystemExit`. +""" + +# compiler exceptions aliased for compatibility +from .compilers.C.errors import CompileError as CompileError +from .compilers.C.errors import Error as _Error +from .compilers.C.errors import LibError as LibError +from .compilers.C.errors import LinkError as LinkError +from .compilers.C.errors import PreprocessError as PreprocessError +from .compilers.C.errors import UnknownFileType as _UnknownFileType + +CCompilerError = _Error +UnknownFileError = _UnknownFileType + + +class DistutilsError(Exception): + """The root of all Distutils evil.""" + + pass + + +class DistutilsModuleError(DistutilsError): + """Unable to load an expected module, or to find an expected class + within some module (in particular, command modules and classes).""" + + pass + + +class DistutilsClassError(DistutilsError): + """Some command class (or possibly distribution class, if anyone + feels a need to subclass Distribution) is found not to be holding + up its end of the bargain, ie. implementing some part of the + "command "interface.""" + + pass + + +class DistutilsGetoptError(DistutilsError): + """The option table provided to 'fancy_getopt()' is bogus.""" + + pass + + +class DistutilsArgError(DistutilsError): + """Raised by fancy_getopt in response to getopt.error -- ie. an + error in the command line usage.""" + + pass + + +class DistutilsFileError(DistutilsError): + """Any problems in the filesystem: expected file not found, etc. + Typically this is for problems that we detect before OSError + could be raised.""" + + pass + + +class DistutilsOptionError(DistutilsError): + """Syntactic/semantic errors in command options, such as use of + mutually conflicting options, or inconsistent options, + badly-spelled values, etc. No distinction is made between option + values originating in the setup script, the command line, config + files, or what-have-you -- but if we *know* something originated in + the setup script, we'll raise DistutilsSetupError instead.""" + + pass + + +class DistutilsSetupError(DistutilsError): + """For errors that can be definitely blamed on the setup script, + such as invalid keyword arguments to 'setup()'.""" + + pass + + +class DistutilsPlatformError(DistutilsError): + """We don't know how to do something on the current platform (but + we do know how to do it on some platform) -- eg. trying to compile + C files on a platform not supported by a CCompiler subclass.""" + + pass + + +class DistutilsExecError(DistutilsError): + """Any problems executing an external program (such as the C + compiler, when compiling C files).""" + + pass + + +class DistutilsInternalError(DistutilsError): + """Internal inconsistencies or impossibilities (obviously, this + should never be seen if the code is working!).""" + + pass + + +class DistutilsTemplateError(DistutilsError): + """Syntax error in a file list template.""" + + +class DistutilsByteCompileError(DistutilsError): + """Byte compile error.""" diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/extension.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/extension.py new file mode 100644 index 0000000000000000000000000000000000000000..f51411266e4047275280d883b75e7103af21faef --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/extension.py @@ -0,0 +1,258 @@ +"""distutils.extension + +Provides the Extension class, used to describe C/C++ extension +modules in setup scripts.""" + +from __future__ import annotations + +import os +import warnings +from collections.abc import Iterable + +# This class is really only used by the "build_ext" command, so it might +# make sense to put it in distutils.command.build_ext. However, that +# module is already big enough, and I want to make this class a bit more +# complex to simplify some common cases ("foo" module in "foo.c") and do +# better error-checking ("foo.c" actually exists). +# +# Also, putting this in build_ext.py means every setup script would have to +# import that large-ish module (indirectly, through distutils.core) in +# order to do anything. + + +class Extension: + """Just a collection of attributes that describes an extension + module and everything needed to build it (hopefully in a portable + way, but there are hooks that let you be as unportable as you need). + + Instance attributes: + name : string + the full name of the extension, including any packages -- ie. + *not* a filename or pathname, but Python dotted name + sources : Iterable[string | os.PathLike] + iterable of source filenames (except strings, which could be misinterpreted + as a single filename), relative to the distribution root (where the setup + script lives), in Unix form (slash-separated) for portability. Can be any + non-string iterable (list, tuple, set, etc.) containing strings or + PathLike objects. Source files may be C, C++, SWIG (.i), platform-specific + resource files, or whatever else is recognized by the "build_ext" command + as source for a Python extension. + include_dirs : [string] + list of directories to search for C/C++ header files (in Unix + form for portability) + define_macros : [(name : string, value : string|None)] + list of macros to define; each macro is defined using a 2-tuple, + where 'value' is either the string to define it to or None to + define it without a particular value (equivalent of "#define + FOO" in source or -DFOO on Unix C compiler command line) + undef_macros : [string] + list of macros to undefine explicitly + library_dirs : [string] + list of directories to search for C/C++ libraries at link time + libraries : [string] + list of library names (not filenames or paths) to link against + runtime_library_dirs : [string] + list of directories to search for C/C++ libraries at run time + (for shared extensions, this is when the extension is loaded) + extra_objects : [string] + list of extra files to link with (eg. object files not implied + by 'sources', static library that must be explicitly specified, + binary resource files, etc.) + extra_compile_args : [string] + any extra platform- and compiler-specific information to use + when compiling the source files in 'sources'. For platforms and + compilers where "command line" makes sense, this is typically a + list of command-line arguments, but for other platforms it could + be anything. + extra_link_args : [string] + any extra platform- and compiler-specific information to use + when linking object files together to create the extension (or + to create a new static Python interpreter). Similar + interpretation as for 'extra_compile_args'. + export_symbols : [string] + list of symbols to be exported from a shared extension. Not + used on all platforms, and not generally necessary for Python + extensions, which typically export exactly one symbol: "init" + + extension_name. + swig_opts : [string] + any extra options to pass to SWIG if a source file has the .i + extension. + depends : [string] + list of files that the extension depends on + language : string + extension language (i.e. "c", "c++", "objc"). Will be detected + from the source extensions if not provided. + optional : boolean + specifies that a build failure in the extension should not abort the + build process, but simply not install the failing extension. + """ + + # When adding arguments to this constructor, be sure to update + # setup_keywords in core.py. + def __init__( + self, + name: str, + sources: Iterable[str | os.PathLike[str]], + include_dirs: list[str] | None = None, + define_macros: list[tuple[str, str | None]] | None = None, + undef_macros: list[str] | None = None, + library_dirs: list[str] | None = None, + libraries: list[str] | None = None, + runtime_library_dirs: list[str] | None = None, + extra_objects: list[str] | None = None, + extra_compile_args: list[str] | None = None, + extra_link_args: list[str] | None = None, + export_symbols: list[str] | None = None, + swig_opts: list[str] | None = None, + depends: list[str] | None = None, + language: str | None = None, + optional: bool | None = None, + **kw, # To catch unknown keywords + ): + if not isinstance(name, str): + raise TypeError("'name' must be a string") + + # handle the string case first; since strings are iterable, disallow them + if isinstance(sources, str): + raise TypeError( + "'sources' must be an iterable of strings or PathLike objects, not a string" + ) + + # now we check if it's iterable and contains valid types + try: + self.sources = list(map(os.fspath, sources)) + except TypeError: + raise TypeError( + "'sources' must be an iterable of strings or PathLike objects" + ) + + self.name = name + self.include_dirs = include_dirs or [] + self.define_macros = define_macros or [] + self.undef_macros = undef_macros or [] + self.library_dirs = library_dirs or [] + self.libraries = libraries or [] + self.runtime_library_dirs = runtime_library_dirs or [] + self.extra_objects = extra_objects or [] + self.extra_compile_args = extra_compile_args or [] + self.extra_link_args = extra_link_args or [] + self.export_symbols = export_symbols or [] + self.swig_opts = swig_opts or [] + self.depends = depends or [] + self.language = language + self.optional = optional + + # If there are unknown keyword options, warn about them + if len(kw) > 0: + options = [repr(option) for option in kw] + options = ', '.join(sorted(options)) + msg = f"Unknown Extension options: {options}" + warnings.warn(msg) + + def __repr__(self): + return f'<{self.__class__.__module__}.{self.__class__.__qualname__}({self.name!r}) at {id(self):#x}>' + + +def read_setup_file(filename): # noqa: C901 + """Reads a Setup file and returns Extension instances.""" + from distutils.sysconfig import _variable_rx, expand_makefile_vars, parse_makefile + from distutils.text_file import TextFile + from distutils.util import split_quoted + + # First pass over the file to gather "VAR = VALUE" assignments. + vars = parse_makefile(filename) + + # Second pass to gobble up the real content: lines of the form + # ... [ ...] [ ...] [ ...] + file = TextFile( + filename, + strip_comments=True, + skip_blanks=True, + join_lines=True, + lstrip_ws=True, + rstrip_ws=True, + ) + try: + extensions = [] + + while True: + line = file.readline() + if line is None: # eof + break + if _variable_rx.match(line): # VAR=VALUE, handled in first pass + continue + + if line[0] == line[-1] == "*": + file.warn(f"'{line}' lines not handled yet") + continue + + line = expand_makefile_vars(line, vars) + words = split_quoted(line) + + # NB. this parses a slightly different syntax than the old + # makesetup script: here, there must be exactly one extension per + # line, and it must be the first word of the line. I have no idea + # why the old syntax supported multiple extensions per line, as + # they all wind up being the same. + + module = words[0] + ext = Extension(module, []) + append_next_word = None + + for word in words[1:]: + if append_next_word is not None: + append_next_word.append(word) + append_next_word = None + continue + + suffix = os.path.splitext(word)[1] + switch = word[0:2] + value = word[2:] + + if suffix in (".c", ".cc", ".cpp", ".cxx", ".c++", ".m", ".mm"): + # hmm, should we do something about C vs. C++ sources? + # or leave it up to the CCompiler implementation to + # worry about? + ext.sources.append(word) + elif switch == "-I": + ext.include_dirs.append(value) + elif switch == "-D": + equals = value.find("=") + if equals == -1: # bare "-DFOO" -- no value + ext.define_macros.append((value, None)) + else: # "-DFOO=blah" + ext.define_macros.append((value[0:equals], value[equals + 2 :])) + elif switch == "-U": + ext.undef_macros.append(value) + elif switch == "-C": # only here 'cause makesetup has it! + ext.extra_compile_args.append(word) + elif switch == "-l": + ext.libraries.append(value) + elif switch == "-L": + ext.library_dirs.append(value) + elif switch == "-R": + ext.runtime_library_dirs.append(value) + elif word == "-rpath": + append_next_word = ext.runtime_library_dirs + elif word == "-Xlinker": + append_next_word = ext.extra_link_args + elif word == "-Xcompiler": + append_next_word = ext.extra_compile_args + elif switch == "-u": + ext.extra_link_args.append(word) + if not value: + append_next_word = ext.extra_link_args + elif suffix in (".a", ".so", ".sl", ".o", ".dylib"): + # NB. a really faithful emulation of makesetup would + # append a .o file to extra_objects only if it + # had a slash in it; otherwise, it would s/.o/.c/ + # and append it to sources. Hmmmm. + ext.extra_objects.append(word) + else: + file.warn(f"unrecognized argument '{word}'") + + extensions.append(ext) + finally: + file.close() + + return extensions diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/fancy_getopt.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/fancy_getopt.py new file mode 100644 index 0000000000000000000000000000000000000000..1a1d3a05da544b98ff84d03ecbee1185b2eb45f7 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/fancy_getopt.py @@ -0,0 +1,471 @@ +"""distutils.fancy_getopt + +Wrapper around the standard getopt module that provides the following +additional features: + * short and long options are tied together + * options have help strings, so fancy_getopt could potentially + create a complete usage summary + * options set attributes of a passed-in object +""" + +from __future__ import annotations + +import getopt +import re +import string +import sys +from collections.abc import Sequence +from typing import Any + +from .errors import DistutilsArgError, DistutilsGetoptError + +# Much like command_re in distutils.core, this is close to but not quite +# the same as a Python NAME -- except, in the spirit of most GNU +# utilities, we use '-' in place of '_'. (The spirit of LISP lives on!) +# The similarities to NAME are again not a coincidence... +longopt_pat = r'[a-zA-Z](?:[a-zA-Z0-9-]*)' +longopt_re = re.compile(rf'^{longopt_pat}$') + +# For recognizing "negative alias" options, eg. "quiet=!verbose" +neg_alias_re = re.compile(f"^({longopt_pat})=!({longopt_pat})$") + +# This is used to translate long options to legitimate Python identifiers +# (for use as attributes of some object). +longopt_xlate = str.maketrans('-', '_') + + +class FancyGetopt: + """Wrapper around the standard 'getopt()' module that provides some + handy extra functionality: + * short and long options are tied together + * options have help strings, and help text can be assembled + from them + * options set attributes of a passed-in object + * boolean options can have "negative aliases" -- eg. if + --quiet is the "negative alias" of --verbose, then "--quiet" + on the command line sets 'verbose' to false + """ + + def __init__(self, option_table=None): + # The option table is (currently) a list of tuples. The + # tuples may have 3 or four values: + # (long_option, short_option, help_string [, repeatable]) + # if an option takes an argument, its long_option should have '=' + # appended; short_option should just be a single character, no ':' + # in any case. If a long_option doesn't have a corresponding + # short_option, short_option should be None. All option tuples + # must have long options. + self.option_table = option_table + + # 'option_index' maps long option names to entries in the option + # table (ie. those 3-tuples). + self.option_index = {} + if self.option_table: + self._build_index() + + # 'alias' records (duh) alias options; {'foo': 'bar'} means + # --foo is an alias for --bar + self.alias = {} + + # 'negative_alias' keeps track of options that are the boolean + # opposite of some other option + self.negative_alias = {} + + # These keep track of the information in the option table. We + # don't actually populate these structures until we're ready to + # parse the command-line, since the 'option_table' passed in here + # isn't necessarily the final word. + self.short_opts = [] + self.long_opts = [] + self.short2long = {} + self.attr_name = {} + self.takes_arg = {} + + # And 'option_order' is filled up in 'getopt()'; it records the + # original order of options (and their values) on the command-line, + # but expands short options, converts aliases, etc. + self.option_order = [] + + def _build_index(self): + self.option_index.clear() + for option in self.option_table: + self.option_index[option[0]] = option + + def set_option_table(self, option_table): + self.option_table = option_table + self._build_index() + + def add_option(self, long_option, short_option=None, help_string=None): + if long_option in self.option_index: + raise DistutilsGetoptError( + f"option conflict: already an option '{long_option}'" + ) + else: + option = (long_option, short_option, help_string) + self.option_table.append(option) + self.option_index[long_option] = option + + def has_option(self, long_option): + """Return true if the option table for this parser has an + option with long name 'long_option'.""" + return long_option in self.option_index + + def get_attr_name(self, long_option): + """Translate long option name 'long_option' to the form it + has as an attribute of some object: ie., translate hyphens + to underscores.""" + return long_option.translate(longopt_xlate) + + def _check_alias_dict(self, aliases, what): + assert isinstance(aliases, dict) + for alias, opt in aliases.items(): + if alias not in self.option_index: + raise DistutilsGetoptError( + f"invalid {what} '{alias}': option '{alias}' not defined" + ) + if opt not in self.option_index: + raise DistutilsGetoptError( + f"invalid {what} '{alias}': aliased option '{opt}' not defined" + ) + + def set_aliases(self, alias): + """Set the aliases for this option parser.""" + self._check_alias_dict(alias, "alias") + self.alias = alias + + def set_negative_aliases(self, negative_alias): + """Set the negative aliases for this option parser. + 'negative_alias' should be a dictionary mapping option names to + option names, both the key and value must already be defined + in the option table.""" + self._check_alias_dict(negative_alias, "negative alias") + self.negative_alias = negative_alias + + def _grok_option_table(self): # noqa: C901 + """Populate the various data structures that keep tabs on the + option table. Called by 'getopt()' before it can do anything + worthwhile. + """ + self.long_opts = [] + self.short_opts = [] + self.short2long.clear() + self.repeat = {} + + for option in self.option_table: + if len(option) == 3: + long, short, help = option + repeat = 0 + elif len(option) == 4: + long, short, help, repeat = option + else: + # the option table is part of the code, so simply + # assert that it is correct + raise ValueError(f"invalid option tuple: {option!r}") + + # Type- and value-check the option names + if not isinstance(long, str) or len(long) < 2: + raise DistutilsGetoptError( + f"invalid long option '{long}': must be a string of length >= 2" + ) + + if not ((short is None) or (isinstance(short, str) and len(short) == 1)): + raise DistutilsGetoptError( + f"invalid short option '{short}': must a single character or None" + ) + + self.repeat[long] = repeat + self.long_opts.append(long) + + if long[-1] == '=': # option takes an argument? + if short: + short = short + ':' + long = long[0:-1] + self.takes_arg[long] = True + else: + # Is option is a "negative alias" for some other option (eg. + # "quiet" == "!verbose")? + alias_to = self.negative_alias.get(long) + if alias_to is not None: + if self.takes_arg[alias_to]: + raise DistutilsGetoptError( + f"invalid negative alias '{long}': " + f"aliased option '{alias_to}' takes a value" + ) + + self.long_opts[-1] = long # XXX redundant?! + self.takes_arg[long] = False + + # If this is an alias option, make sure its "takes arg" flag is + # the same as the option it's aliased to. + alias_to = self.alias.get(long) + if alias_to is not None: + if self.takes_arg[long] != self.takes_arg[alias_to]: + raise DistutilsGetoptError( + f"invalid alias '{long}': inconsistent with " + f"aliased option '{alias_to}' (one of them takes a value, " + "the other doesn't" + ) + + # Now enforce some bondage on the long option name, so we can + # later translate it to an attribute name on some object. Have + # to do this a bit late to make sure we've removed any trailing + # '='. + if not longopt_re.match(long): + raise DistutilsGetoptError( + f"invalid long option name '{long}' " + "(must be letters, numbers, hyphens only" + ) + + self.attr_name[long] = self.get_attr_name(long) + if short: + self.short_opts.append(short) + self.short2long[short[0]] = long + + def getopt(self, args: Sequence[str] | None = None, object=None): # noqa: C901 + """Parse command-line options in args. Store as attributes on object. + + If 'args' is None or not supplied, uses 'sys.argv[1:]'. If + 'object' is None or not supplied, creates a new OptionDummy + object, stores option values there, and returns a tuple (args, + object). If 'object' is supplied, it is modified in place and + 'getopt()' just returns 'args'; in both cases, the returned + 'args' is a modified copy of the passed-in 'args' list, which + is left untouched. + """ + if args is None: + args = sys.argv[1:] + if object is None: + object = OptionDummy() + created_object = True + else: + created_object = False + + self._grok_option_table() + + short_opts = ' '.join(self.short_opts) + try: + opts, args = getopt.getopt(args, short_opts, self.long_opts) + except getopt.error as msg: + raise DistutilsArgError(msg) + + for opt, val in opts: + if len(opt) == 2 and opt[0] == '-': # it's a short option + opt = self.short2long[opt[1]] + else: + assert len(opt) > 2 and opt[:2] == '--' + opt = opt[2:] + + alias = self.alias.get(opt) + if alias: + opt = alias + + if not self.takes_arg[opt]: # boolean option? + assert val == '', "boolean option can't have value" + alias = self.negative_alias.get(opt) + if alias: + opt = alias + val = 0 + else: + val = 1 + + attr = self.attr_name[opt] + # The only repeating option at the moment is 'verbose'. + # It has a negative option -q quiet, which should set verbose = False. + if val and self.repeat.get(attr) is not None: + val = getattr(object, attr, 0) + 1 + setattr(object, attr, val) + self.option_order.append((opt, val)) + + # for opts + if created_object: + return args, object + else: + return args + + def get_option_order(self): + """Returns the list of (option, value) tuples processed by the + previous run of 'getopt()'. Raises RuntimeError if + 'getopt()' hasn't been called yet. + """ + if self.option_order is None: + raise RuntimeError("'getopt()' hasn't been called yet") + else: + return self.option_order + + def generate_help(self, header=None): # noqa: C901 + """Generate help text (a list of strings, one per suggested line of + output) from the option table for this FancyGetopt object. + """ + # Blithely assume the option table is good: probably wouldn't call + # 'generate_help()' unless you've already called 'getopt()'. + + # First pass: determine maximum length of long option names + max_opt = 0 + for option in self.option_table: + long = option[0] + short = option[1] + ell = len(long) + if long[-1] == '=': + ell = ell - 1 + if short is not None: + ell = ell + 5 # " (-x)" where short == 'x' + if ell > max_opt: + max_opt = ell + + opt_width = max_opt + 2 + 2 + 2 # room for indent + dashes + gutter + + # Typical help block looks like this: + # --foo controls foonabulation + # Help block for longest option looks like this: + # --flimflam set the flim-flam level + # and with wrapped text: + # --flimflam set the flim-flam level (must be between + # 0 and 100, except on Tuesdays) + # Options with short names will have the short name shown (but + # it doesn't contribute to max_opt): + # --foo (-f) controls foonabulation + # If adding the short option would make the left column too wide, + # we push the explanation off to the next line + # --flimflam (-l) + # set the flim-flam level + # Important parameters: + # - 2 spaces before option block start lines + # - 2 dashes for each long option name + # - min. 2 spaces between option and explanation (gutter) + # - 5 characters (incl. space) for short option name + + # Now generate lines of help text. (If 80 columns were good enough + # for Jesus, then 78 columns are good enough for me!) + line_width = 78 + text_width = line_width - opt_width + big_indent = ' ' * opt_width + if header: + lines = [header] + else: + lines = ['Option summary:'] + + for option in self.option_table: + long, short, help = option[:3] + text = wrap_text(help, text_width) + if long[-1] == '=': + long = long[0:-1] + + # Case 1: no short option at all (makes life easy) + if short is None: + if text: + lines.append(f" --{long:<{max_opt}} {text[0]}") + else: + lines.append(f" --{long:<{max_opt}}") + + # Case 2: we have a short option, so we have to include it + # just after the long option + else: + opt_names = f"{long} (-{short})" + if text: + lines.append(f" --{opt_names:<{max_opt}} {text[0]}") + else: + lines.append(f" --{opt_names:<{max_opt}}") + + for ell in text[1:]: + lines.append(big_indent + ell) + return lines + + def print_help(self, header=None, file=None): + if file is None: + file = sys.stdout + for line in self.generate_help(header): + file.write(line + "\n") + + +def fancy_getopt(options, negative_opt, object, args: Sequence[str] | None): + parser = FancyGetopt(options) + parser.set_negative_aliases(negative_opt) + return parser.getopt(args, object) + + +WS_TRANS = {ord(_wschar): ' ' for _wschar in string.whitespace} + + +def wrap_text(text, width): + """wrap_text(text : string, width : int) -> [string] + + Split 'text' into multiple lines of no more than 'width' characters + each, and return the list of strings that results. + """ + if text is None: + return [] + if len(text) <= width: + return [text] + + text = text.expandtabs() + text = text.translate(WS_TRANS) + chunks = re.split(r'( +|-+)', text) + chunks = [ch for ch in chunks if ch] # ' - ' results in empty strings + lines = [] + + while chunks: + cur_line = [] # list of chunks (to-be-joined) + cur_len = 0 # length of current line + + while chunks: + ell = len(chunks[0]) + if cur_len + ell <= width: # can squeeze (at least) this chunk in + cur_line.append(chunks[0]) + del chunks[0] + cur_len = cur_len + ell + else: # this line is full + # drop last chunk if all space + if cur_line and cur_line[-1][0] == ' ': + del cur_line[-1] + break + + if chunks: # any chunks left to process? + # if the current line is still empty, then we had a single + # chunk that's too big too fit on a line -- so we break + # down and break it up at the line width + if cur_len == 0: + cur_line.append(chunks[0][0:width]) + chunks[0] = chunks[0][width:] + + # all-whitespace chunks at the end of a line can be discarded + # (and we know from the re.split above that if a chunk has + # *any* whitespace, it is *all* whitespace) + if chunks[0][0] == ' ': + del chunks[0] + + # and store this line in the list-of-all-lines -- as a single + # string, of course! + lines.append(''.join(cur_line)) + + return lines + + +def translate_longopt(opt): + """Convert a long option name to a valid Python identifier by + changing "-" to "_". + """ + return opt.translate(longopt_xlate) + + +class OptionDummy: + """Dummy class just used as a place to hold command-line option + values as instance attributes.""" + + def __init__(self, options: Sequence[Any] = []): + """Create a new OptionDummy instance. The attributes listed in + 'options' will be initialized to None.""" + for opt in options: + setattr(self, opt, None) + + +if __name__ == "__main__": + text = """\ +Tra-la-la, supercalifragilisticexpialidocious. +How *do* you spell that odd word, anyways? +(Someone ask Mary -- she'll know [or she'll +say, "How should I know?"].)""" + + for w in (10, 20, 30, 40): + print(f"width: {w}") + print("\n".join(wrap_text(text, w))) + print() diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/file_util.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/file_util.py new file mode 100644 index 0000000000000000000000000000000000000000..a9724b1779703543aaacc7b4a5872b68911d2144 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/file_util.py @@ -0,0 +1,228 @@ +"""distutils.file_util + +Utility functions for operating on single files. +""" + +import os + +from ._log import log +from .errors import DistutilsFileError + +# for generating verbose output in 'copy_file()' +_copy_action = {None: 'copying', 'hard': 'hard linking', 'sym': 'symbolically linking'} + + +def _copy_file_contents(src, dst, buffer_size=16 * 1024): # noqa: C901 + """Copy the file 'src' to 'dst'; both must be filenames. Any error + opening either file, reading from 'src', or writing to 'dst', raises + DistutilsFileError. Data is read/written in chunks of 'buffer_size' + bytes (default 16k). No attempt is made to handle anything apart from + regular files. + """ + # Stolen from shutil module in the standard library, but with + # custom error-handling added. + fsrc = None + fdst = None + try: + try: + fsrc = open(src, 'rb') + except OSError as e: + raise DistutilsFileError(f"could not open '{src}': {e.strerror}") + + if os.path.exists(dst): + try: + os.unlink(dst) + except OSError as e: + raise DistutilsFileError(f"could not delete '{dst}': {e.strerror}") + + try: + fdst = open(dst, 'wb') + except OSError as e: + raise DistutilsFileError(f"could not create '{dst}': {e.strerror}") + + while True: + try: + buf = fsrc.read(buffer_size) + except OSError as e: + raise DistutilsFileError(f"could not read from '{src}': {e.strerror}") + + if not buf: + break + + try: + fdst.write(buf) + except OSError as e: + raise DistutilsFileError(f"could not write to '{dst}': {e.strerror}") + finally: + if fdst: + fdst.close() + if fsrc: + fsrc.close() + + +def copy_file( # noqa: C901 + src, + dst, + preserve_mode=True, + preserve_times=True, + update=False, + link=None, + verbose=True, +): + """Copy a file 'src' to 'dst'. If 'dst' is a directory, then 'src' is + copied there with the same name; otherwise, it must be a filename. (If + the file exists, it will be ruthlessly clobbered.) If 'preserve_mode' + is true (the default), the file's mode (type and permission bits, or + whatever is analogous on the current platform) is copied. If + 'preserve_times' is true (the default), the last-modified and + last-access times are copied as well. If 'update' is true, 'src' will + only be copied if 'dst' does not exist, or if 'dst' does exist but is + older than 'src'. + + 'link' allows you to make hard links (os.link) or symbolic links + (os.symlink) instead of copying: set it to "hard" or "sym"; if it is + None (the default), files are copied. Don't set 'link' on systems that + don't support it: 'copy_file()' doesn't check if hard or symbolic + linking is available. If hardlink fails, falls back to + _copy_file_contents(). + + Under Mac OS, uses the native file copy function in macostools; on + other systems, uses '_copy_file_contents()' to copy file contents. + + Return a tuple (dest_name, copied): 'dest_name' is the actual name of + the output file, and 'copied' is true if the file was copied. + """ + # XXX if the destination file already exists, we clobber it if + # copying, but blow up if linking. Hmmm. And I don't know what + # macostools.copyfile() does. Should definitely be consistent, and + # should probably blow up if destination exists and we would be + # changing it (ie. it's not already a hard/soft link to src OR + # (not update) and (src newer than dst). + + from distutils._modified import newer + from stat import S_IMODE, ST_ATIME, ST_MODE, ST_MTIME + + if not os.path.isfile(src): + raise DistutilsFileError( + f"can't copy '{src}': doesn't exist or not a regular file" + ) + + if os.path.isdir(dst): + dir = dst + dst = os.path.join(dst, os.path.basename(src)) + else: + dir = os.path.dirname(dst) + + if update and not newer(src, dst): + if verbose >= 1: + log.debug("not copying %s (output up-to-date)", src) + return (dst, False) + + try: + action = _copy_action[link] + except KeyError: + raise ValueError(f"invalid value '{link}' for 'link' argument") + + if verbose >= 1: + if os.path.basename(dst) == os.path.basename(src): + log.info("%s %s -> %s", action, src, dir) + else: + log.info("%s %s -> %s", action, src, dst) + + # If linking (hard or symbolic), use the appropriate system call + # (Unix only, of course, but that's the caller's responsibility) + if link == 'hard': + if not (os.path.exists(dst) and os.path.samefile(src, dst)): + try: + os.link(src, dst) + except OSError: + # If hard linking fails, fall back on copying file + # (some special filesystems don't support hard linking + # even under Unix, see issue #8876). + pass + else: + return (dst, True) + elif link == 'sym': + if not (os.path.exists(dst) and os.path.samefile(src, dst)): + os.symlink(src, dst) + return (dst, True) + + # Otherwise (non-Mac, not linking), copy the file contents and + # (optionally) copy the times and mode. + _copy_file_contents(src, dst) + if preserve_mode or preserve_times: + st = os.stat(src) + + # According to David Ascher , utime() should be done + # before chmod() (at least under NT). + if preserve_times: + os.utime(dst, (st[ST_ATIME], st[ST_MTIME])) + if preserve_mode: + os.chmod(dst, S_IMODE(st[ST_MODE])) + + return (dst, True) + + +# XXX I suspect this is Unix-specific -- need porting help! +def move_file(src, dst, verbose=True): # noqa: C901 + """Move a file 'src' to 'dst'. If 'dst' is a directory, the file will + be moved into it with the same name; otherwise, 'src' is just renamed + to 'dst'. Return the new full name of the file. + + Handles cross-device moves on Unix using 'copy_file()'. What about + other systems??? + """ + import errno + from os.path import basename, dirname, exists, isdir, isfile + + if verbose >= 1: + log.info("moving %s -> %s", src, dst) + + if not isfile(src): + raise DistutilsFileError(f"can't move '{src}': not a regular file") + + if isdir(dst): + dst = os.path.join(dst, basename(src)) + elif exists(dst): + raise DistutilsFileError( + f"can't move '{src}': destination '{dst}' already exists" + ) + + if not isdir(dirname(dst)): + raise DistutilsFileError( + f"can't move '{src}': destination '{dst}' not a valid path" + ) + + copy_it = False + try: + os.rename(src, dst) + except OSError as e: + (num, msg) = e.args + if num == errno.EXDEV: + copy_it = True + else: + raise DistutilsFileError(f"couldn't move '{src}' to '{dst}': {msg}") + + if copy_it: + copy_file(src, dst, verbose=verbose) + try: + os.unlink(src) + except OSError as e: + (num, msg) = e.args + try: + os.unlink(dst) + except OSError: + pass + raise DistutilsFileError( + f"couldn't move '{src}' to '{dst}' by copy/delete: " + f"delete '{src}' failed: {msg}" + ) + return dst + + +def write_file(filename, contents): + """Create a file with the specified name and write 'contents' (a + sequence of strings without line terminators) to it. + """ + with open(filename, 'w', encoding='utf-8') as f: + f.writelines(line + '\n' for line in contents) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/filelist.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/filelist.py new file mode 100644 index 0000000000000000000000000000000000000000..70dc0fdebc3f4200245aa1c6280ab39861dcf8b0 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/filelist.py @@ -0,0 +1,431 @@ +"""distutils.filelist + +Provides the FileList class, used for poking about the filesystem +and building lists of files. +""" + +from __future__ import annotations + +import fnmatch +import functools +import os +import re +from collections.abc import Iterable +from typing import Literal, overload + +from ._log import log +from .errors import DistutilsInternalError, DistutilsTemplateError +from .util import convert_path + + +class FileList: + """A list of files built by on exploring the filesystem and filtered by + applying various patterns to what we find there. + + Instance attributes: + dir + directory from which files will be taken -- only used if + 'allfiles' not supplied to constructor + files + list of filenames currently being built/filtered/manipulated + allfiles + complete list of files under consideration (ie. without any + filtering applied) + """ + + def __init__(self, warn: object = None, debug_print: object = None) -> None: + # ignore argument to FileList, but keep them for backwards + # compatibility + self.allfiles: Iterable[str] | None = None + self.files: list[str] = [] + + def set_allfiles(self, allfiles: Iterable[str]) -> None: + self.allfiles = allfiles + + def findall(self, dir: str | os.PathLike[str] = os.curdir) -> None: + self.allfiles = findall(dir) + + def debug_print(self, msg: object) -> None: + """Print 'msg' to stdout if the global DEBUG (taken from the + DISTUTILS_DEBUG environment variable) flag is true. + """ + from distutils.debug import DEBUG + + if DEBUG: + print(msg) + + # Collection methods + + def append(self, item: str) -> None: + self.files.append(item) + + def extend(self, items: Iterable[str]) -> None: + self.files.extend(items) + + def sort(self) -> None: + # Not a strict lexical sort! + sortable_files = sorted(map(os.path.split, self.files)) + self.files = [] + for sort_tuple in sortable_files: + self.files.append(os.path.join(*sort_tuple)) + + # Other miscellaneous utility methods + + def remove_duplicates(self) -> None: + # Assumes list has been sorted! + for i in range(len(self.files) - 1, 0, -1): + if self.files[i] == self.files[i - 1]: + del self.files[i] + + # "File template" methods + + def _parse_template_line(self, line): + words = line.split() + action = words[0] + + patterns = dir = dir_pattern = None + + if action in ('include', 'exclude', 'global-include', 'global-exclude'): + if len(words) < 2: + raise DistutilsTemplateError( + f"'{action}' expects ..." + ) + patterns = [convert_path(w) for w in words[1:]] + elif action in ('recursive-include', 'recursive-exclude'): + if len(words) < 3: + raise DistutilsTemplateError( + f"'{action}' expects ..." + ) + dir = convert_path(words[1]) + patterns = [convert_path(w) for w in words[2:]] + elif action in ('graft', 'prune'): + if len(words) != 2: + raise DistutilsTemplateError( + f"'{action}' expects a single " + ) + dir_pattern = convert_path(words[1]) + else: + raise DistutilsTemplateError(f"unknown action '{action}'") + + return (action, patterns, dir, dir_pattern) + + def process_template_line(self, line: str) -> None: # noqa: C901 + # Parse the line: split it up, make sure the right number of words + # is there, and return the relevant words. 'action' is always + # defined: it's the first word of the line. Which of the other + # three are defined depends on the action; it'll be either + # patterns, (dir and patterns), or (dir_pattern). + (action, patterns, dir, dir_pattern) = self._parse_template_line(line) + + # OK, now we know that the action is valid and we have the + # right number of words on the line for that action -- so we + # can proceed with minimal error-checking. + if action == 'include': + self.debug_print("include " + ' '.join(patterns)) + for pattern in patterns: + if not self.include_pattern(pattern, anchor=True): + log.warning("warning: no files found matching '%s'", pattern) + + elif action == 'exclude': + self.debug_print("exclude " + ' '.join(patterns)) + for pattern in patterns: + if not self.exclude_pattern(pattern, anchor=True): + log.warning( + "warning: no previously-included files found matching '%s'", + pattern, + ) + + elif action == 'global-include': + self.debug_print("global-include " + ' '.join(patterns)) + for pattern in patterns: + if not self.include_pattern(pattern, anchor=False): + log.warning( + ( + "warning: no files found matching '%s' " + "anywhere in distribution" + ), + pattern, + ) + + elif action == 'global-exclude': + self.debug_print("global-exclude " + ' '.join(patterns)) + for pattern in patterns: + if not self.exclude_pattern(pattern, anchor=False): + log.warning( + ( + "warning: no previously-included files matching " + "'%s' found anywhere in distribution" + ), + pattern, + ) + + elif action == 'recursive-include': + self.debug_print("recursive-include {} {}".format(dir, ' '.join(patterns))) + for pattern in patterns: + if not self.include_pattern(pattern, prefix=dir): + msg = "warning: no files found matching '%s' under directory '%s'" + log.warning(msg, pattern, dir) + + elif action == 'recursive-exclude': + self.debug_print("recursive-exclude {} {}".format(dir, ' '.join(patterns))) + for pattern in patterns: + if not self.exclude_pattern(pattern, prefix=dir): + log.warning( + ( + "warning: no previously-included files matching " + "'%s' found under directory '%s'" + ), + pattern, + dir, + ) + + elif action == 'graft': + self.debug_print("graft " + dir_pattern) + if not self.include_pattern(None, prefix=dir_pattern): + log.warning("warning: no directories found matching '%s'", dir_pattern) + + elif action == 'prune': + self.debug_print("prune " + dir_pattern) + if not self.exclude_pattern(None, prefix=dir_pattern): + log.warning( + ("no previously-included directories found matching '%s'"), + dir_pattern, + ) + else: + raise DistutilsInternalError( + f"this cannot happen: invalid action '{action}'" + ) + + # Filtering/selection methods + @overload + def include_pattern( + self, + pattern: str, + anchor: bool = True, + prefix: str | None = None, + is_regex: Literal[False] = False, + ) -> bool: ... + @overload + def include_pattern( + self, + pattern: str | re.Pattern[str], + anchor: bool = True, + prefix: str | None = None, + *, + is_regex: Literal[True], + ) -> bool: ... + @overload + def include_pattern( + self, + pattern: str | re.Pattern[str], + anchor: bool, + prefix: str | None, + is_regex: Literal[True], + ) -> bool: ... + def include_pattern( + self, + pattern: str | re.Pattern, + anchor: bool = True, + prefix: str | None = None, + is_regex: bool = False, + ) -> bool: + """Select strings (presumably filenames) from 'self.files' that + match 'pattern', a Unix-style wildcard (glob) pattern. Patterns + are not quite the same as implemented by the 'fnmatch' module: '*' + and '?' match non-special characters, where "special" is platform- + dependent: slash on Unix; colon, slash, and backslash on + DOS/Windows; and colon on Mac OS. + + If 'anchor' is true (the default), then the pattern match is more + stringent: "*.py" will match "foo.py" but not "foo/bar.py". If + 'anchor' is false, both of these will match. + + If 'prefix' is supplied, then only filenames starting with 'prefix' + (itself a pattern) and ending with 'pattern', with anything in between + them, will match. 'anchor' is ignored in this case. + + If 'is_regex' is true, 'anchor' and 'prefix' are ignored, and + 'pattern' is assumed to be either a string containing a regex or a + regex object -- no translation is done, the regex is just compiled + and used as-is. + + Selected strings will be added to self.files. + + Return True if files are found, False otherwise. + """ + # XXX docstring lying about what the special chars are? + files_found = False + pattern_re = translate_pattern(pattern, anchor, prefix, is_regex) + self.debug_print(f"include_pattern: applying regex r'{pattern_re.pattern}'") + + # delayed loading of allfiles list + if self.allfiles is None: + self.findall() + + for name in self.allfiles: + if pattern_re.search(name): + self.debug_print(" adding " + name) + self.files.append(name) + files_found = True + return files_found + + @overload + def exclude_pattern( + self, + pattern: str, + anchor: bool = True, + prefix: str | None = None, + is_regex: Literal[False] = False, + ) -> bool: ... + @overload + def exclude_pattern( + self, + pattern: str | re.Pattern[str], + anchor: bool = True, + prefix: str | None = None, + *, + is_regex: Literal[True], + ) -> bool: ... + @overload + def exclude_pattern( + self, + pattern: str | re.Pattern[str], + anchor: bool, + prefix: str | None, + is_regex: Literal[True], + ) -> bool: ... + def exclude_pattern( + self, + pattern: str | re.Pattern, + anchor: bool = True, + prefix: str | None = None, + is_regex: bool = False, + ) -> bool: + """Remove strings (presumably filenames) from 'files' that match + 'pattern'. Other parameters are the same as for + 'include_pattern()', above. + The list 'self.files' is modified in place. + Return True if files are found, False otherwise. + """ + files_found = False + pattern_re = translate_pattern(pattern, anchor, prefix, is_regex) + self.debug_print(f"exclude_pattern: applying regex r'{pattern_re.pattern}'") + for i in range(len(self.files) - 1, -1, -1): + if pattern_re.search(self.files[i]): + self.debug_print(" removing " + self.files[i]) + del self.files[i] + files_found = True + return files_found + + +# Utility functions + + +def _find_all_simple(path): + """ + Find all files under 'path' + """ + all_unique = _UniqueDirs.filter(os.walk(path, followlinks=True)) + results = ( + os.path.join(base, file) for base, dirs, files in all_unique for file in files + ) + return filter(os.path.isfile, results) + + +class _UniqueDirs(set): + """ + Exclude previously-seen dirs from walk results, + avoiding infinite recursion. + Ref https://bugs.python.org/issue44497. + """ + + def __call__(self, walk_item): + """ + Given an item from an os.walk result, determine + if the item represents a unique dir for this instance + and if not, prevent further traversal. + """ + base, dirs, files = walk_item + stat = os.stat(base) + candidate = stat.st_dev, stat.st_ino + found = candidate in self + if found: + del dirs[:] + self.add(candidate) + return not found + + @classmethod + def filter(cls, items): + return filter(cls(), items) + + +def findall(dir: str | os.PathLike[str] = os.curdir): + """ + Find all files under 'dir' and return the list of full filenames. + Unless dir is '.', return full filenames with dir prepended. + """ + files = _find_all_simple(dir) + if dir == os.curdir: + make_rel = functools.partial(os.path.relpath, start=dir) + files = map(make_rel, files) + return list(files) + + +def glob_to_re(pattern): + """Translate a shell-like glob pattern to a regular expression; return + a string containing the regex. Differs from 'fnmatch.translate()' in + that '*' does not match "special characters" (which are + platform-specific). + """ + pattern_re = fnmatch.translate(pattern) + + # '?' and '*' in the glob pattern become '.' and '.*' in the RE, which + # IMHO is wrong -- '?' and '*' aren't supposed to match slash in Unix, + # and by extension they shouldn't match such "special characters" under + # any OS. So change all non-escaped dots in the RE to match any + # character except the special characters (currently: just os.sep). + sep = os.sep + if os.sep == '\\': + # we're using a regex to manipulate a regex, so we need + # to escape the backslash twice + sep = r'\\\\' + escaped = rf'\1[^{sep}]' + pattern_re = re.sub(r'((?= 2: + set_threshold(logging.DEBUG) + + +class Log(logging.Logger): + """distutils.log.Log is deprecated, please use an alternative from `logging`.""" + + def __init__(self, threshold=WARN): + warnings.warn(Log.__doc__) # avoid DeprecationWarning to ensure warn is shown + super().__init__(__name__, level=threshold) + + @property + def threshold(self): + return self.level + + @threshold.setter + def threshold(self, level): + self.setLevel(level) + + warn = logging.Logger.warning diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/spawn.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/spawn.py new file mode 100644 index 0000000000000000000000000000000000000000..e47f1d19272cdd5fb8daa67eff3e52c8c435cfde --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/spawn.py @@ -0,0 +1,130 @@ +"""distutils.spawn + +Provides the 'spawn()' function, a front-end to various platform- +specific functions for launching another program in a sub-process. +""" + +from __future__ import annotations + +import os +import platform +import shutil +import subprocess +import sys +import warnings +from collections.abc import Mapping, MutableSequence +from typing import TYPE_CHECKING, TypeVar, overload + +from ._log import log +from .debug import DEBUG +from .errors import DistutilsExecError + +if TYPE_CHECKING: + from subprocess import _ENV + + +_MappingT = TypeVar("_MappingT", bound=Mapping) + + +def _debug(cmd): + """ + Render a subprocess command differently depending on DEBUG. + """ + return cmd if DEBUG else cmd[0] + + +def _inject_macos_ver(env: _MappingT | None) -> _MappingT | dict[str, str | int] | None: + if platform.system() != 'Darwin': + return env + + from .util import MACOSX_VERSION_VAR, get_macosx_target_ver + + target_ver = get_macosx_target_ver() + update = {MACOSX_VERSION_VAR: target_ver} if target_ver else {} + return {**_resolve(env), **update} + + +@overload +def _resolve(env: None) -> os._Environ[str]: ... +@overload +def _resolve(env: _MappingT) -> _MappingT: ... +def _resolve(env: _MappingT | None) -> _MappingT | os._Environ[str]: + return os.environ if env is None else env + + +def spawn( + cmd: MutableSequence[bytes | str | os.PathLike[str]], + search_path: bool = True, + verbose: bool = False, + env: _ENV | None = None, +) -> None: + """Run another program, specified as a command list 'cmd', in a new process. + + 'cmd' is just the argument list for the new process, ie. + cmd[0] is the program to run and cmd[1:] are the rest of its arguments. + There is no way to run a program with a name different from that of its + executable. + + If 'search_path' is true (the default), the system's executable + search path will be used to find the program; otherwise, cmd[0] + must be the exact path to the executable. + + Raise DistutilsExecError if running the program fails in any way; just + return on success. + """ + log.info(subprocess.list2cmdline(cmd)) + + if search_path: + executable = shutil.which(cmd[0]) + if executable is not None: + cmd[0] = executable + + try: + subprocess.check_call(cmd, env=_inject_macos_ver(env)) + except OSError as exc: + raise DistutilsExecError( + f"command {_debug(cmd)!r} failed: {exc.args[-1]}" + ) from exc + except subprocess.CalledProcessError as err: + raise DistutilsExecError( + f"command {_debug(cmd)!r} failed with exit code {err.returncode}" + ) from err + + +def find_executable(executable: str, path: str | None = None) -> str | None: + """Tries to find 'executable' in the directories listed in 'path'. + + A string listing directories separated by 'os.pathsep'; defaults to + os.environ['PATH']. Returns the complete filename or None if not found. + """ + warnings.warn( + 'Use shutil.which instead of find_executable', DeprecationWarning, stacklevel=2 + ) + _, ext = os.path.splitext(executable) + if (sys.platform == 'win32') and (ext != '.exe'): + executable = executable + '.exe' + + if os.path.isfile(executable): + return executable + + if path is None: + path = os.environ.get('PATH', None) + # bpo-35755: Don't fall through if PATH is the empty string + if path is None: + try: + path = os.confstr("CS_PATH") + except (AttributeError, ValueError): + # os.confstr() or CS_PATH is not available + path = os.defpath + + # PATH='' doesn't match, whereas PATH=':' looks in the current directory + if not path: + return None + + paths = path.split(os.pathsep) + for p in paths: + f = os.path.join(p, executable) + if os.path.isfile(f): + # the file exists, we have a shot at spawn working + return f + return None diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/sysconfig.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/sysconfig.py new file mode 100644 index 0000000000000000000000000000000000000000..7ddc869ab5603d691a8863988da89ec84689de84 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/sysconfig.py @@ -0,0 +1,598 @@ +"""Provide access to Python's configuration information. The specific +configuration variables available depend heavily on the platform and +configuration. The values may be retrieved using +get_config_var(name), and the list of variables is available via +get_config_vars().keys(). Additional convenience functions are also +available. + +Written by: Fred L. Drake, Jr. +Email: +""" + +from __future__ import annotations + +import functools +import os +import pathlib +import re +import sys +import sysconfig +from typing import TYPE_CHECKING, Literal, overload + +from jaraco.functools import pass_none + +from .ccompiler import CCompiler +from .compat import py39 +from .errors import DistutilsPlatformError +from .util import is_mingw + +if TYPE_CHECKING: + from typing_extensions import deprecated +else: + + def deprecated(message): + return lambda fn: fn + + +IS_PYPY = '__pypy__' in sys.builtin_module_names + +# These are needed in a couple of spots, so just compute them once. +PREFIX = os.path.normpath(sys.prefix) +EXEC_PREFIX = os.path.normpath(sys.exec_prefix) +BASE_PREFIX = os.path.normpath(sys.base_prefix) +BASE_EXEC_PREFIX = os.path.normpath(sys.base_exec_prefix) + +# Path to the base directory of the project. On Windows the binary may +# live in project/PCbuild/win32 or project/PCbuild/amd64. +# set for cross builds +if "_PYTHON_PROJECT_BASE" in os.environ: + project_base = os.path.abspath(os.environ["_PYTHON_PROJECT_BASE"]) +else: + if sys.executable: + project_base = os.path.dirname(os.path.abspath(sys.executable)) + else: + # sys.executable can be empty if argv[0] has been changed and Python is + # unable to retrieve the real program name + project_base = os.getcwd() + + +def _is_python_source_dir(d): + """ + Return True if the target directory appears to point to an + un-installed Python. + """ + modules = pathlib.Path(d).joinpath('Modules') + return any(modules.joinpath(fn).is_file() for fn in ('Setup', 'Setup.local')) + + +_sys_home = getattr(sys, '_home', None) + + +def _is_parent(dir_a, dir_b): + """ + Return True if a is a parent of b. + """ + return os.path.normcase(dir_a).startswith(os.path.normcase(dir_b)) + + +if os.name == 'nt': + + @pass_none + def _fix_pcbuild(d): + # In a venv, sys._home will be inside BASE_PREFIX rather than PREFIX. + prefixes = PREFIX, BASE_PREFIX + matched = ( + prefix + for prefix in prefixes + if _is_parent(d, os.path.join(prefix, "PCbuild")) + ) + return next(matched, d) + + project_base = _fix_pcbuild(project_base) + _sys_home = _fix_pcbuild(_sys_home) + + +def _python_build(): + if _sys_home: + return _is_python_source_dir(_sys_home) + return _is_python_source_dir(project_base) + + +python_build = _python_build() + + +# Calculate the build qualifier flags if they are defined. Adding the flags +# to the include and lib directories only makes sense for an installation, not +# an in-source build. +build_flags = '' +try: + if not python_build: + build_flags = sys.abiflags +except AttributeError: + # It's not a configure-based build, so the sys module doesn't have + # this attribute, which is fine. + pass + + +def get_python_version(): + """Return a string containing the major and minor Python version, + leaving off the patchlevel. Sample return values could be '1.5' + or '2.2'. + """ + return f'{sys.version_info.major}.{sys.version_info.minor}' + + +def get_python_inc(plat_specific: bool = False, prefix: str | None = None) -> str: + """Return the directory containing installed Python header files. + + If 'plat_specific' is false (the default), this is the path to the + non-platform-specific header files, i.e. Python.h and so on; + otherwise, this is the path to platform-specific header files + (namely pyconfig.h). + + If 'prefix' is supplied, use it instead of sys.base_prefix or + sys.base_exec_prefix -- i.e., ignore 'plat_specific'. + """ + default_prefix = BASE_EXEC_PREFIX if plat_specific else BASE_PREFIX + resolved_prefix = prefix if prefix is not None else default_prefix + # MinGW imitates posix like layout, but os.name != posix + os_name = "posix" if is_mingw() else os.name + try: + getter = globals()[f'_get_python_inc_{os_name}'] + except KeyError: + raise DistutilsPlatformError( + "I don't know where Python installs its C header files " + f"on platform '{os.name}'" + ) + return getter(resolved_prefix, prefix, plat_specific) + + +@pass_none +def _extant(path): + """ + Replace path with None if it doesn't exist. + """ + return path if os.path.exists(path) else None + + +def _get_python_inc_posix(prefix, spec_prefix, plat_specific): + return ( + _get_python_inc_posix_python(plat_specific) + or _extant(_get_python_inc_from_config(plat_specific, spec_prefix)) + or _get_python_inc_posix_prefix(prefix) + ) + + +def _get_python_inc_posix_python(plat_specific): + """ + Assume the executable is in the build directory. The + pyconfig.h file should be in the same directory. Since + the build directory may not be the source directory, + use "srcdir" from the makefile to find the "Include" + directory. + """ + if not python_build: + return + if plat_specific: + return _sys_home or project_base + incdir = os.path.join(get_config_var('srcdir'), 'Include') + return os.path.normpath(incdir) + + +def _get_python_inc_from_config(plat_specific, spec_prefix): + """ + If no prefix was explicitly specified, provide the include + directory from the config vars. Useful when + cross-compiling, since the config vars may come from + the host + platform Python installation, while the current Python + executable is from the build platform installation. + + >>> monkeypatch = getfixture('monkeypatch') + >>> gpifc = _get_python_inc_from_config + >>> monkeypatch.setitem(gpifc.__globals__, 'get_config_var', str.lower) + >>> gpifc(False, '/usr/bin/') + >>> gpifc(False, '') + >>> gpifc(False, None) + 'includepy' + >>> gpifc(True, None) + 'confincludepy' + """ + if spec_prefix is None: + return get_config_var('CONF' * plat_specific + 'INCLUDEPY') + + +def _get_python_inc_posix_prefix(prefix): + implementation = 'pypy' if IS_PYPY else 'python' + python_dir = implementation + get_python_version() + build_flags + return os.path.join(prefix, "include", python_dir) + + +def _get_python_inc_nt(prefix, spec_prefix, plat_specific): + if python_build: + # Include both include dirs to ensure we can find pyconfig.h + return ( + os.path.join(prefix, "include") + + os.path.pathsep + + os.path.dirname(sysconfig.get_config_h_filename()) + ) + return os.path.join(prefix, "include") + + +# allow this behavior to be monkey-patched. Ref pypa/distutils#2. +def _posix_lib(standard_lib, libpython, early_prefix, prefix): + if standard_lib: + return libpython + else: + return os.path.join(libpython, "site-packages") + + +def get_python_lib( + plat_specific: bool = False, standard_lib: bool = False, prefix: str | None = None +) -> str: + """Return the directory containing the Python library (standard or + site additions). + + If 'plat_specific' is true, return the directory containing + platform-specific modules, i.e. any module from a non-pure-Python + module distribution; otherwise, return the platform-shared library + directory. If 'standard_lib' is true, return the directory + containing standard Python library modules; otherwise, return the + directory for site-specific modules. + + If 'prefix' is supplied, use it instead of sys.base_prefix or + sys.base_exec_prefix -- i.e., ignore 'plat_specific'. + """ + + early_prefix = prefix + + if prefix is None: + if standard_lib: + prefix = plat_specific and BASE_EXEC_PREFIX or BASE_PREFIX + else: + prefix = plat_specific and EXEC_PREFIX or PREFIX + + if os.name == "posix" or is_mingw(): + if plat_specific or standard_lib: + # Platform-specific modules (any module from a non-pure-Python + # module distribution) or standard Python library modules. + libdir = getattr(sys, "platlibdir", "lib") + else: + # Pure Python + libdir = "lib" + implementation = 'pypy' if IS_PYPY else 'python' + libpython = os.path.join(prefix, libdir, implementation + get_python_version()) + return _posix_lib(standard_lib, libpython, early_prefix, prefix) + elif os.name == "nt": + if standard_lib: + return os.path.join(prefix, "Lib") + else: + return os.path.join(prefix, "Lib", "site-packages") + else: + raise DistutilsPlatformError( + f"I don't know where Python installs its library on platform '{os.name}'" + ) + + +@functools.lru_cache +def _customize_macos(): + """ + Perform first-time customization of compiler-related + config vars on macOS. Use after a compiler is known + to be needed. This customization exists primarily to support Pythons + from binary installers. The kind and paths to build tools on + the user system may vary significantly from the system + that Python itself was built on. Also the user OS + version and build tools may not support the same set + of CPU architectures for universal builds. + """ + + sys.platform == "darwin" and __import__('_osx_support').customize_compiler( + get_config_vars() + ) + + +def customize_compiler(compiler: CCompiler) -> None: + """Do any platform-specific customization of a CCompiler instance. + + Mainly needed on Unix, so we can plug in the information that + varies across Unices and is stored in Python's Makefile. + """ + if compiler.compiler_type in ["unix", "cygwin"] or ( + compiler.compiler_type == "mingw32" and is_mingw() + ): + _customize_macos() + + ( + cc, + cxx, + cflags, + ccshared, + ldshared, + ldcxxshared, + shlib_suffix, + ar, + ar_flags, + ) = get_config_vars( + 'CC', + 'CXX', + 'CFLAGS', + 'CCSHARED', + 'LDSHARED', + 'LDCXXSHARED', + 'SHLIB_SUFFIX', + 'AR', + 'ARFLAGS', + ) + + cxxflags = cflags + + if 'CC' in os.environ: + newcc = os.environ['CC'] + if 'LDSHARED' not in os.environ and ldshared.startswith(cc): + # If CC is overridden, use that as the default + # command for LDSHARED as well + ldshared = newcc + ldshared[len(cc) :] + cc = newcc + cxx = os.environ.get('CXX', cxx) + ldshared = os.environ.get('LDSHARED', ldshared) + ldcxxshared = os.environ.get('LDCXXSHARED', ldcxxshared) + cpp = os.environ.get( + 'CPP', + cc + " -E", # not always + ) + + ldshared = _add_flags(ldshared, 'LD') + ldcxxshared = _add_flags(ldcxxshared, 'LD') + cflags = os.environ.get('CFLAGS', cflags) + ldshared = _add_flags(ldshared, 'C') + cxxflags = os.environ.get('CXXFLAGS', cxxflags) + ldcxxshared = _add_flags(ldcxxshared, 'CXX') + cpp = _add_flags(cpp, 'CPP') + cflags = _add_flags(cflags, 'CPP') + cxxflags = _add_flags(cxxflags, 'CPP') + ldshared = _add_flags(ldshared, 'CPP') + ldcxxshared = _add_flags(ldcxxshared, 'CPP') + + ar = os.environ.get('AR', ar) + + archiver = ar + ' ' + os.environ.get('ARFLAGS', ar_flags) + cc_cmd = cc + ' ' + cflags + cxx_cmd = cxx + ' ' + cxxflags + + compiler.set_executables( + preprocessor=cpp, + compiler=cc_cmd, + compiler_so=cc_cmd + ' ' + ccshared, + compiler_cxx=cxx_cmd, + compiler_so_cxx=cxx_cmd + ' ' + ccshared, + linker_so=ldshared, + linker_so_cxx=ldcxxshared, + linker_exe=cc, + linker_exe_cxx=cxx, + archiver=archiver, + ) + + if 'RANLIB' in os.environ and compiler.executables.get('ranlib', None): + compiler.set_executables(ranlib=os.environ['RANLIB']) + + compiler.shared_lib_extension = shlib_suffix + + +def get_config_h_filename() -> str: + """Return full pathname of installed pyconfig.h file.""" + return sysconfig.get_config_h_filename() + + +def get_makefile_filename() -> str: + """Return full pathname of installed Makefile from the Python build.""" + return sysconfig.get_makefile_filename() + + +def parse_config_h(fp, g=None): + """Parse a config.h-style file. + + A dictionary containing name/value pairs is returned. If an + optional dictionary is passed in as the second argument, it is + used instead of a new dictionary. + """ + return sysconfig.parse_config_h(fp, vars=g) + + +# Regexes needed for parsing Makefile (and similar syntaxes, +# like old-style Setup files). +_variable_rx = re.compile(r"([a-zA-Z][a-zA-Z0-9_]+)\s*=\s*(.*)") +_findvar1_rx = re.compile(r"\$\(([A-Za-z][A-Za-z0-9_]*)\)") +_findvar2_rx = re.compile(r"\${([A-Za-z][A-Za-z0-9_]*)}") + + +def parse_makefile(fn, g=None): # noqa: C901 + """Parse a Makefile-style file. + + A dictionary containing name/value pairs is returned. If an + optional dictionary is passed in as the second argument, it is + used instead of a new dictionary. + """ + from distutils.text_file import TextFile + + fp = TextFile( + fn, + strip_comments=True, + skip_blanks=True, + join_lines=True, + errors="surrogateescape", + ) + + if g is None: + g = {} + done = {} + notdone = {} + + while True: + line = fp.readline() + if line is None: # eof + break + m = _variable_rx.match(line) + if m: + n, v = m.group(1, 2) + v = v.strip() + # `$$' is a literal `$' in make + tmpv = v.replace('$$', '') + + if "$" in tmpv: + notdone[n] = v + else: + try: + v = int(v) + except ValueError: + # insert literal `$' + done[n] = v.replace('$$', '$') + else: + done[n] = v + + # Variables with a 'PY_' prefix in the makefile. These need to + # be made available without that prefix through sysconfig. + # Special care is needed to ensure that variable expansion works, even + # if the expansion uses the name without a prefix. + renamed_variables = ('CFLAGS', 'LDFLAGS', 'CPPFLAGS') + + # do variable interpolation here + while notdone: + for name in list(notdone): + value = notdone[name] + m = _findvar1_rx.search(value) or _findvar2_rx.search(value) + if m: + n = m.group(1) + found = True + if n in done: + item = str(done[n]) + elif n in notdone: + # get it on a subsequent round + found = False + elif n in os.environ: + # do it like make: fall back to environment + item = os.environ[n] + + elif n in renamed_variables: + if name.startswith('PY_') and name[3:] in renamed_variables: + item = "" + + elif 'PY_' + n in notdone: + found = False + + else: + item = str(done['PY_' + n]) + else: + done[n] = item = "" + if found: + after = value[m.end() :] + value = value[: m.start()] + item + after + if "$" in after: + notdone[name] = value + else: + try: + value = int(value) + except ValueError: + done[name] = value.strip() + else: + done[name] = value + del notdone[name] + + if name.startswith('PY_') and name[3:] in renamed_variables: + name = name[3:] + if name not in done: + done[name] = value + else: + # bogus variable reference; just drop it since we can't deal + del notdone[name] + + fp.close() + + # strip spurious spaces + for k, v in done.items(): + if isinstance(v, str): + done[k] = v.strip() + + # save the results in the global dictionary + g.update(done) + return g + + +def expand_makefile_vars(s, vars): + """Expand Makefile-style variables -- "${foo}" or "$(foo)" -- in + 'string' according to 'vars' (a dictionary mapping variable names to + values). Variables not present in 'vars' are silently expanded to the + empty string. The variable values in 'vars' should not contain further + variable expansions; if 'vars' is the output of 'parse_makefile()', + you're fine. Returns a variable-expanded version of 's'. + """ + + # This algorithm does multiple expansion, so if vars['foo'] contains + # "${bar}", it will expand ${foo} to ${bar}, and then expand + # ${bar}... and so forth. This is fine as long as 'vars' comes from + # 'parse_makefile()', which takes care of such expansions eagerly, + # according to make's variable expansion semantics. + + while True: + m = _findvar1_rx.search(s) or _findvar2_rx.search(s) + if m: + (beg, end) = m.span() + s = s[0:beg] + vars.get(m.group(1)) + s[end:] + else: + break + return s + + +_config_vars = None + + +@overload +def get_config_vars() -> dict[str, str | int]: ... +@overload +def get_config_vars(arg: str, /, *args: str) -> list[str | int]: ... +def get_config_vars(*args: str) -> list[str | int] | dict[str, str | int]: + """With no arguments, return a dictionary of all configuration + variables relevant for the current platform. Generally this includes + everything needed to build extensions and install both pure modules and + extensions. On Unix, this means every variable defined in Python's + installed Makefile; on Windows it's a much smaller set. + + With arguments, return a list of values that result from looking up + each argument in the configuration variable dictionary. + """ + global _config_vars + if _config_vars is None: + _config_vars = sysconfig.get_config_vars().copy() + py39.add_ext_suffix(_config_vars) + + return [_config_vars.get(name) for name in args] if args else _config_vars + + +@overload +@deprecated( + "SO is deprecated, use EXT_SUFFIX. Support will be removed when this module is synchronized with stdlib Python 3.11" +) +def get_config_var(name: Literal["SO"]) -> int | str | None: ... +@overload +def get_config_var(name: str) -> int | str | None: ... +def get_config_var(name: str) -> int | str | None: + """Return the value of a single variable using the dictionary + returned by 'get_config_vars()'. Equivalent to + get_config_vars().get(name) + """ + if name == 'SO': + import warnings + + warnings.warn('SO is deprecated, use EXT_SUFFIX', DeprecationWarning, 2) + return get_config_vars().get(name) + + +@pass_none +def _add_flags(value: str, type: str) -> str: + """ + Add any flags from the environment for the given type. + + type is the prefix to FLAGS in the environment key (e.g. "C" for "CFLAGS"). + """ + flags = os.environ.get(f'{type}FLAGS') + return f'{value} {flags}' if flags else value diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__init__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5a8ab061009f1cd87a53ce51eff3bc9e9a632273 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__init__.py @@ -0,0 +1,42 @@ +""" +Test suite for distutils. + +Tests for the command classes in the distutils.command package are +included in distutils.tests as well, instead of using a separate +distutils.command.tests package, since command identification is done +by import rather than matching pre-defined names. +""" + +import shutil +from collections.abc import Sequence + + +def missing_compiler_executable(cmd_names: Sequence[str] = []): # pragma: no cover + """Check if the compiler components used to build the interpreter exist. + + Check for the existence of the compiler executables whose names are listed + in 'cmd_names' or all the compiler executables when 'cmd_names' is empty + and return the first missing executable or None when none is found + missing. + + """ + from distutils import ccompiler, errors, sysconfig + + compiler = ccompiler.new_compiler() + sysconfig.customize_compiler(compiler) + if compiler.compiler_type == "msvc": + # MSVC has no executables, so check whether initialization succeeds + try: + compiler.initialize() + except errors.DistutilsPlatformError: + return "msvc" + for name in compiler.executables: + if cmd_names and name not in cmd_names: + continue + cmd = getattr(compiler, name) + if cmd_names: + assert cmd is not None, f"the '{name}' executable is not configured" + elif not cmd: + continue + if shutil.which(cmd[0]) is None: + return cmd[0] diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b10c7287cc737bd606d815ddc4938b9ff27c8e67 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/support.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/support.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..698814e44421e125cb33947cee281c8ff887c26c Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/support.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_archive_util.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_archive_util.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..80ce423bfa6f8fe4eb43827916ea6193ca7f6285 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_archive_util.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_bdist.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_bdist.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fdd51ec5a198b147ad726b036b5b4ecc89d77d7c Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_bdist.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_bdist_dumb.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_bdist_dumb.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5929da39a48c8d14ce587bf8b94a1f11d3675b9f Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_bdist_dumb.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_bdist_rpm.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_bdist_rpm.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6fcd61298f1fe416f75761c1677898a7e86c9dfe Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_bdist_rpm.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_build.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_build.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dc9ebf762ac838e94facbd50c1df15fccc0339da Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_build.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_build_clib.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_build_clib.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f51de8a0238c95a990b424499c9aaf3ea014f071 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_build_clib.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_build_ext.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_build_ext.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..64c311d3fa224f987688b8c9430717d9d09d409d Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_build_ext.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_build_py.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_build_py.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8d7584b9312ff71d09cda0643248fff8035af181 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_build_py.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_build_scripts.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_build_scripts.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bea277fb994c8fd5e1c6c75ac5b7c9d3f209d7e4 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_build_scripts.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_check.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_check.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..75c782d4a1fa70c40fdef4a3f0c16bee77ee3c43 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_check.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_clean.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_clean.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c6c893a3584ce0e72eb69dd0b5099a91089b53fb Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_clean.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_cmd.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_cmd.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fc3e1ef2e7589a7903c0da54dbc807f3ad40ada4 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_cmd.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_config_cmd.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_config_cmd.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..44891b19bacf383e7e88eaaa27205c9b4c810464 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_config_cmd.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_core.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_core.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7f21ffd580d7845d28a34ae65607246baf722ad2 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_core.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_dir_util.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_dir_util.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..040b52d16d8c6f9006e84d89dba0e281f3bb4cb0 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_dir_util.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_dist.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_dist.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..da827884ae64664e7decb3a63d5ac2c7e88838a4 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_dist.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_extension.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_extension.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..55f117580aa40c0b1880e6d25a6d2ba0eea28d31 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_extension.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_file_util.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_file_util.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cebb7b9586b884343faf56b80f7429a7a9e1e73b Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_file_util.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_filelist.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_filelist.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..751adb055c19b009ce84436df066d083efb17822 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_filelist.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_install.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_install.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3fa2b6e6f1eb1fa4b7f4a08a3d1bae69b8434692 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_install.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_install_data.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_install_data.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e2c3d0b1a239da0472dc2d8e4506ee097e8a3e54 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_install_data.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_install_headers.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_install_headers.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b83f3302efb5b9cb3e71fcd304dc5bca0f62080b Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_install_headers.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_install_lib.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_install_lib.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c22df20369bec2c6f7a9eec830ac8d34aa2afc0f Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_install_lib.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_install_scripts.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_install_scripts.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..08d4203881016979e3753fd9b4e2129fdf8b3a86 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_install_scripts.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_log.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_log.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..57d0c0b8822b34f4df07ac097ee8a1723c815ebf Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_log.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_modified.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_modified.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..57746600135162380ec7bc6716e4df6cf2453656 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_modified.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_sdist.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_sdist.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..46b11bb033914bfbc9b4a6e11a8d15924ddd5be2 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_sdist.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_spawn.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_spawn.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a9f5dae1fa5e8d4c7d2af46452494175ef09b358 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_spawn.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_sysconfig.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_sysconfig.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..758c5f638c0f7d9bff74d72a3838734b7f18dd8c Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_sysconfig.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_text_file.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_text_file.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..484543a56884a58658326ac4ebaefa2d2b245b12 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_text_file.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_util.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_util.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ef4a7ba5eb67fd931eda2293f742b1159a6841b6 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_util.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_version.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_version.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ce531bb40f933032051d3e0b0b8e095f6178db9d Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_version.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_versionpredicate.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_versionpredicate.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f234108fba5ed8bee2cc0fbb841c2fcc9dd02db6 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_versionpredicate.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/unix_compat.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/unix_compat.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..072851723f6b80d4f55e5078fb4452d5f2311734 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/unix_compat.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/compat/__init__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/compat/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/compat/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/compat/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..27bea4359e202e41df9067b7c9f1e27a9256916e Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/compat/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/compat/__pycache__/py39.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/compat/__pycache__/py39.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..74e095b79df658815a26116571d9a026e19506bf Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/compat/__pycache__/py39.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/compat/py39.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/compat/py39.py new file mode 100644 index 0000000000000000000000000000000000000000..aca3939a0cea90dd0a90d7f36fcf83a5167cbfc4 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/compat/py39.py @@ -0,0 +1,40 @@ +import sys + +if sys.version_info >= (3, 10): + from test.support.import_helper import ( + CleanImport as CleanImport, + ) + from test.support.import_helper import ( + DirsOnSysPath as DirsOnSysPath, + ) + from test.support.os_helper import ( + EnvironmentVarGuard as EnvironmentVarGuard, + ) + from test.support.os_helper import ( + rmtree as rmtree, + ) + from test.support.os_helper import ( + skip_unless_symlink as skip_unless_symlink, + ) + from test.support.os_helper import ( + unlink as unlink, + ) +else: + from test.support import ( + CleanImport as CleanImport, + ) + from test.support import ( + DirsOnSysPath as DirsOnSysPath, + ) + from test.support import ( + EnvironmentVarGuard as EnvironmentVarGuard, + ) + from test.support import ( + rmtree as rmtree, + ) + from test.support import ( + skip_unless_symlink as skip_unless_symlink, + ) + from test.support import ( + unlink as unlink, + ) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/support.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/support.py new file mode 100644 index 0000000000000000000000000000000000000000..9cd2b8a9eedbb9f11a3ed793af57b3290c5febef --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/support.py @@ -0,0 +1,134 @@ +"""Support code for distutils test cases.""" + +import itertools +import os +import pathlib +import shutil +import sys +import sysconfig +import tempfile +from distutils.core import Distribution + +import pytest +from more_itertools import always_iterable + + +@pytest.mark.usefixtures('distutils_managed_tempdir') +class TempdirManager: + """ + Mix-in class that handles temporary directories for test cases. + """ + + def mkdtemp(self): + """Create a temporary directory that will be cleaned up. + + Returns the path of the directory. + """ + d = tempfile.mkdtemp() + self.tempdirs.append(d) + return d + + def write_file(self, path, content='xxx'): + """Writes a file in the given path. + + path can be a string or a sequence. + """ + pathlib.Path(*always_iterable(path)).write_text(content, encoding='utf-8') + + def create_dist(self, pkg_name='foo', **kw): + """Will generate a test environment. + + This function creates: + - a Distribution instance using keywords + - a temporary directory with a package structure + + It returns the package directory and the distribution + instance. + """ + tmp_dir = self.mkdtemp() + pkg_dir = os.path.join(tmp_dir, pkg_name) + os.mkdir(pkg_dir) + dist = Distribution(attrs=kw) + + return pkg_dir, dist + + +class DummyCommand: + """Class to store options for retrieval via set_undefined_options().""" + + def __init__(self, **kwargs): + vars(self).update(kwargs) + + def ensure_finalized(self): + pass + + +def copy_xxmodule_c(directory): + """Helper for tests that need the xxmodule.c source file. + + Example use: + + def test_compile(self): + copy_xxmodule_c(self.tmpdir) + self.assertIn('xxmodule.c', os.listdir(self.tmpdir)) + + If the source file can be found, it will be copied to *directory*. If not, + the test will be skipped. Errors during copy are not caught. + """ + shutil.copy(_get_xxmodule_path(), os.path.join(directory, 'xxmodule.c')) + + +def _get_xxmodule_path(): + source_name = 'xxmodule.c' if sys.version_info > (3, 9) else 'xxmodule-3.8.c' + return os.path.join(os.path.dirname(__file__), source_name) + + +def fixup_build_ext(cmd): + """Function needed to make build_ext tests pass. + + When Python was built with --enable-shared on Unix, -L. is not enough to + find libpython.so, because regrtest runs in a tempdir, not in the + source directory where the .so lives. + + When Python was built with in debug mode on Windows, build_ext commands + need their debug attribute set, and it is not done automatically for + some reason. + + This function handles both of these things. Example use: + + cmd = build_ext(dist) + support.fixup_build_ext(cmd) + cmd.ensure_finalized() + + Unlike most other Unix platforms, Mac OS X embeds absolute paths + to shared libraries into executables, so the fixup is not needed there. + """ + if os.name == 'nt': + cmd.debug = sys.executable.endswith('_d.exe') + elif sysconfig.get_config_var('Py_ENABLE_SHARED'): + # To further add to the shared builds fun on Unix, we can't just add + # library_dirs to the Extension() instance because that doesn't get + # plumbed through to the final compiler command. + runshared = sysconfig.get_config_var('RUNSHARED') + if runshared is None: + cmd.library_dirs = ['.'] + else: + if sys.platform == 'darwin': + cmd.library_dirs = [] + else: + name, equals, value = runshared.partition('=') + cmd.library_dirs = [d for d in value.split(os.pathsep) if d] + + +def combine_markers(cls): + """ + pytest will honor markers as found on the class, but when + markers are on multiple subclasses, only one appears. Use + this decorator to combine those markers. + """ + cls.pytestmark = [ + mark + for base in itertools.chain([cls], cls.__bases__) + for mark in getattr(base, 'pytestmark', []) + ] + return cls diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_archive_util.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_archive_util.py new file mode 100644 index 0000000000000000000000000000000000000000..a9cc5eb00968ed9d5d77cac60ef543827c669539 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_archive_util.py @@ -0,0 +1,342 @@ +"""Tests for distutils.archive_util.""" + +import functools +import operator +import os +import pathlib +import sys +import tarfile +from distutils import archive_util +from distutils.archive_util import ( + ARCHIVE_FORMATS, + check_archive_formats, + make_archive, + make_tarball, + make_zipfile, +) +from distutils.spawn import spawn +from distutils.tests import support +from os.path import splitdrive + +import path +import pytest +from test.support import patch + +from .unix_compat import UID_0_SUPPORT, grp, pwd, require_uid_0, require_unix_id + + +def can_fs_encode(filename): + """ + Return True if the filename can be saved in the file system. + """ + if os.path.supports_unicode_filenames: + return True + try: + filename.encode(sys.getfilesystemencoding()) + except UnicodeEncodeError: + return False + return True + + +def all_equal(values): + return functools.reduce(operator.eq, values) + + +def same_drive(*paths): + return all_equal(pathlib.Path(path).drive for path in paths) + + +class ArchiveUtilTestCase(support.TempdirManager): + @pytest.mark.usefixtures('needs_zlib') + def test_make_tarball(self, name='archive'): + # creating something to tar + tmpdir = self._create_files() + self._make_tarball(tmpdir, name, '.tar.gz') + # trying an uncompressed one + self._make_tarball(tmpdir, name, '.tar', compress=None) + + @pytest.mark.usefixtures('needs_zlib') + def test_make_tarball_gzip(self): + tmpdir = self._create_files() + self._make_tarball(tmpdir, 'archive', '.tar.gz', compress='gzip') + + def test_make_tarball_bzip2(self): + pytest.importorskip('bz2') + tmpdir = self._create_files() + self._make_tarball(tmpdir, 'archive', '.tar.bz2', compress='bzip2') + + def test_make_tarball_xz(self): + pytest.importorskip('lzma') + tmpdir = self._create_files() + self._make_tarball(tmpdir, 'archive', '.tar.xz', compress='xz') + + @pytest.mark.skipif("not can_fs_encode('årchiv')") + def test_make_tarball_latin1(self): + """ + Mirror test_make_tarball, except filename contains latin characters. + """ + self.test_make_tarball('årchiv') # note this isn't a real word + + @pytest.mark.skipif("not can_fs_encode('のアーカイブ')") + def test_make_tarball_extended(self): + """ + Mirror test_make_tarball, except filename contains extended + characters outside the latin charset. + """ + self.test_make_tarball('のアーカイブ') # japanese for archive + + def _make_tarball(self, tmpdir, target_name, suffix, **kwargs): + tmpdir2 = self.mkdtemp() + if same_drive(tmpdir, tmpdir2): + pytest.skip("source and target should be on same drive") + + base_name = os.path.join(tmpdir2, target_name) + + # working with relative paths to avoid tar warnings + with path.Path(tmpdir): + make_tarball(splitdrive(base_name)[1], 'dist', **kwargs) + + # check if the compressed tarball was created + tarball = base_name + suffix + assert os.path.exists(tarball) + assert self._tarinfo(tarball) == self._created_files + + def _tarinfo(self, path): + tar = tarfile.open(path) + try: + names = tar.getnames() + names.sort() + return names + finally: + tar.close() + + _zip_created_files = [ + 'dist/', + 'dist/file1', + 'dist/file2', + 'dist/sub/', + 'dist/sub/file3', + 'dist/sub2/', + ] + _created_files = [p.rstrip('/') for p in _zip_created_files] + + def _create_files(self): + # creating something to tar + tmpdir = self.mkdtemp() + dist = os.path.join(tmpdir, 'dist') + os.mkdir(dist) + self.write_file([dist, 'file1'], 'xxx') + self.write_file([dist, 'file2'], 'xxx') + os.mkdir(os.path.join(dist, 'sub')) + self.write_file([dist, 'sub', 'file3'], 'xxx') + os.mkdir(os.path.join(dist, 'sub2')) + return tmpdir + + @pytest.mark.usefixtures('needs_zlib') + @pytest.mark.skipif("not (shutil.which('tar') and shutil.which('gzip'))") + def test_tarfile_vs_tar(self): + tmpdir = self._create_files() + tmpdir2 = self.mkdtemp() + base_name = os.path.join(tmpdir2, 'archive') + old_dir = os.getcwd() + os.chdir(tmpdir) + try: + make_tarball(base_name, 'dist') + finally: + os.chdir(old_dir) + + # check if the compressed tarball was created + tarball = base_name + '.tar.gz' + assert os.path.exists(tarball) + + # now create another tarball using `tar` + tarball2 = os.path.join(tmpdir, 'archive2.tar.gz') + tar_cmd = ['tar', '-cf', 'archive2.tar', 'dist'] + gzip_cmd = ['gzip', '-f', '-9', 'archive2.tar'] + old_dir = os.getcwd() + os.chdir(tmpdir) + try: + spawn(tar_cmd) + spawn(gzip_cmd) + finally: + os.chdir(old_dir) + + assert os.path.exists(tarball2) + # let's compare both tarballs + assert self._tarinfo(tarball) == self._created_files + assert self._tarinfo(tarball2) == self._created_files + + # trying an uncompressed one + base_name = os.path.join(tmpdir2, 'archive') + old_dir = os.getcwd() + os.chdir(tmpdir) + try: + make_tarball(base_name, 'dist', compress=None) + finally: + os.chdir(old_dir) + tarball = base_name + '.tar' + assert os.path.exists(tarball) + + @pytest.mark.usefixtures('needs_zlib') + def test_make_zipfile(self): + zipfile = pytest.importorskip('zipfile') + # creating something to tar + tmpdir = self._create_files() + base_name = os.path.join(self.mkdtemp(), 'archive') + with path.Path(tmpdir): + make_zipfile(base_name, 'dist') + + # check if the compressed tarball was created + tarball = base_name + '.zip' + assert os.path.exists(tarball) + with zipfile.ZipFile(tarball) as zf: + assert sorted(zf.namelist()) == self._zip_created_files + + def test_make_zipfile_no_zlib(self): + zipfile = pytest.importorskip('zipfile') + patch(self, archive_util.zipfile, 'zlib', None) # force zlib ImportError + + called = [] + zipfile_class = zipfile.ZipFile + + def fake_zipfile(*a, **kw): + if kw.get('compression', None) == zipfile.ZIP_STORED: + called.append((a, kw)) + return zipfile_class(*a, **kw) + + patch(self, archive_util.zipfile, 'ZipFile', fake_zipfile) + + # create something to tar and compress + tmpdir = self._create_files() + base_name = os.path.join(self.mkdtemp(), 'archive') + with path.Path(tmpdir): + make_zipfile(base_name, 'dist') + + tarball = base_name + '.zip' + assert called == [((tarball, "w"), {'compression': zipfile.ZIP_STORED})] + assert os.path.exists(tarball) + with zipfile.ZipFile(tarball) as zf: + assert sorted(zf.namelist()) == self._zip_created_files + + def test_check_archive_formats(self): + assert check_archive_formats(['gztar', 'xxx', 'zip']) == 'xxx' + assert ( + check_archive_formats(['gztar', 'bztar', 'xztar', 'ztar', 'tar', 'zip']) + is None + ) + + def test_make_archive(self): + tmpdir = self.mkdtemp() + base_name = os.path.join(tmpdir, 'archive') + with pytest.raises(ValueError): + make_archive(base_name, 'xxx') + + def test_make_archive_cwd(self): + current_dir = os.getcwd() + + def _breaks(*args, **kw): + raise RuntimeError() + + ARCHIVE_FORMATS['xxx'] = (_breaks, [], 'xxx file') + try: + try: + make_archive('xxx', 'xxx', root_dir=self.mkdtemp()) + except Exception: + pass + assert os.getcwd() == current_dir + finally: + ARCHIVE_FORMATS.pop('xxx') + + def test_make_archive_tar(self): + base_dir = self._create_files() + base_name = os.path.join(self.mkdtemp(), 'archive') + res = make_archive(base_name, 'tar', base_dir, 'dist') + assert os.path.exists(res) + assert os.path.basename(res) == 'archive.tar' + assert self._tarinfo(res) == self._created_files + + @pytest.mark.usefixtures('needs_zlib') + def test_make_archive_gztar(self): + base_dir = self._create_files() + base_name = os.path.join(self.mkdtemp(), 'archive') + res = make_archive(base_name, 'gztar', base_dir, 'dist') + assert os.path.exists(res) + assert os.path.basename(res) == 'archive.tar.gz' + assert self._tarinfo(res) == self._created_files + + def test_make_archive_bztar(self): + pytest.importorskip('bz2') + base_dir = self._create_files() + base_name = os.path.join(self.mkdtemp(), 'archive') + res = make_archive(base_name, 'bztar', base_dir, 'dist') + assert os.path.exists(res) + assert os.path.basename(res) == 'archive.tar.bz2' + assert self._tarinfo(res) == self._created_files + + def test_make_archive_xztar(self): + pytest.importorskip('lzma') + base_dir = self._create_files() + base_name = os.path.join(self.mkdtemp(), 'archive') + res = make_archive(base_name, 'xztar', base_dir, 'dist') + assert os.path.exists(res) + assert os.path.basename(res) == 'archive.tar.xz' + assert self._tarinfo(res) == self._created_files + + def test_make_archive_owner_group(self): + # testing make_archive with owner and group, with various combinations + # this works even if there's not gid/uid support + if UID_0_SUPPORT: + group = grp.getgrgid(0)[0] + owner = pwd.getpwuid(0)[0] + else: + group = owner = 'root' + + base_dir = self._create_files() + root_dir = self.mkdtemp() + base_name = os.path.join(self.mkdtemp(), 'archive') + res = make_archive( + base_name, 'zip', root_dir, base_dir, owner=owner, group=group + ) + assert os.path.exists(res) + + res = make_archive(base_name, 'zip', root_dir, base_dir) + assert os.path.exists(res) + + res = make_archive( + base_name, 'tar', root_dir, base_dir, owner=owner, group=group + ) + assert os.path.exists(res) + + res = make_archive( + base_name, 'tar', root_dir, base_dir, owner='kjhkjhkjg', group='oihohoh' + ) + assert os.path.exists(res) + + @pytest.mark.usefixtures('needs_zlib') + @require_unix_id + @require_uid_0 + def test_tarfile_root_owner(self): + tmpdir = self._create_files() + base_name = os.path.join(self.mkdtemp(), 'archive') + old_dir = os.getcwd() + os.chdir(tmpdir) + group = grp.getgrgid(0)[0] + owner = pwd.getpwuid(0)[0] + try: + archive_name = make_tarball( + base_name, 'dist', compress=None, owner=owner, group=group + ) + finally: + os.chdir(old_dir) + + # check if the compressed tarball was created + assert os.path.exists(archive_name) + + # now checks the rights + archive = tarfile.open(archive_name) + try: + for member in archive.getmembers(): + assert member.uid == 0 + assert member.gid == 0 + finally: + archive.close() diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_bdist.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_bdist.py new file mode 100644 index 0000000000000000000000000000000000000000..d5696fc3dcd8081335606dc92badd73a69ceac69 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_bdist.py @@ -0,0 +1,47 @@ +"""Tests for distutils.command.bdist.""" + +from distutils.command.bdist import bdist +from distutils.tests import support + + +class TestBuild(support.TempdirManager): + def test_formats(self): + # let's create a command and make sure + # we can set the format + dist = self.create_dist()[1] + cmd = bdist(dist) + cmd.formats = ['gztar'] + cmd.ensure_finalized() + assert cmd.formats == ['gztar'] + + # what formats does bdist offer? + formats = [ + 'bztar', + 'gztar', + 'rpm', + 'tar', + 'xztar', + 'zip', + 'ztar', + ] + found = sorted(cmd.format_commands) + assert found == formats + + def test_skip_build(self): + # bug #10946: bdist --skip-build should trickle down to subcommands + dist = self.create_dist()[1] + cmd = bdist(dist) + cmd.skip_build = True + cmd.ensure_finalized() + dist.command_obj['bdist'] = cmd + + names = [ + 'bdist_dumb', + ] # bdist_rpm does not support --skip-build + + for name in names: + subcmd = cmd.get_finalized_command(name) + if getattr(subcmd, '_unsupported', False): + # command is not supported on this build + continue + assert subcmd.skip_build, f'{name} should take --skip-build from bdist' diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_bdist_dumb.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_bdist_dumb.py new file mode 100644 index 0000000000000000000000000000000000000000..1fc51d244a78058329c56a618b092e466715e565 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_bdist_dumb.py @@ -0,0 +1,78 @@ +"""Tests for distutils.command.bdist_dumb.""" + +import os +import sys +import zipfile +from distutils.command.bdist_dumb import bdist_dumb +from distutils.core import Distribution +from distutils.tests import support + +import pytest + +SETUP_PY = """\ +from distutils.core import setup +import foo + +setup(name='foo', version='0.1', py_modules=['foo'], + url='xxx', author='xxx', author_email='xxx') + +""" + + +@support.combine_markers +@pytest.mark.usefixtures('save_env') +@pytest.mark.usefixtures('save_argv') +@pytest.mark.usefixtures('save_cwd') +class TestBuildDumb( + support.TempdirManager, +): + @pytest.mark.usefixtures('needs_zlib') + def test_simple_built(self): + # let's create a simple package + tmp_dir = self.mkdtemp() + pkg_dir = os.path.join(tmp_dir, 'foo') + os.mkdir(pkg_dir) + self.write_file((pkg_dir, 'setup.py'), SETUP_PY) + self.write_file((pkg_dir, 'foo.py'), '#') + self.write_file((pkg_dir, 'MANIFEST.in'), 'include foo.py') + self.write_file((pkg_dir, 'README'), '') + + dist = Distribution({ + 'name': 'foo', + 'version': '0.1', + 'py_modules': ['foo'], + 'url': 'xxx', + 'author': 'xxx', + 'author_email': 'xxx', + }) + dist.script_name = 'setup.py' + os.chdir(pkg_dir) + + sys.argv = ['setup.py'] + cmd = bdist_dumb(dist) + + # so the output is the same no matter + # what is the platform + cmd.format = 'zip' + + cmd.ensure_finalized() + cmd.run() + + # see what we have + dist_created = os.listdir(os.path.join(pkg_dir, 'dist')) + base = f"{dist.get_fullname()}.{cmd.plat_name}.zip" + + assert dist_created == [base] + + # now let's check what we have in the zip file + fp = zipfile.ZipFile(os.path.join('dist', base)) + try: + contents = fp.namelist() + finally: + fp.close() + + contents = sorted(filter(None, map(os.path.basename, contents))) + wanted = ['foo-0.1-py{}.{}.egg-info'.format(*sys.version_info[:2]), 'foo.py'] + if not sys.dont_write_bytecode: + wanted.append(f'foo.{sys.implementation.cache_tag}.pyc') + assert contents == sorted(wanted) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_bdist_rpm.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_bdist_rpm.py new file mode 100644 index 0000000000000000000000000000000000000000..75051430e224c8908e22601133a40f5f82ee455a --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_bdist_rpm.py @@ -0,0 +1,127 @@ +"""Tests for distutils.command.bdist_rpm.""" + +import os +import shutil # noqa: F401 +import sys +from distutils.command.bdist_rpm import bdist_rpm +from distutils.core import Distribution +from distutils.tests import support + +import pytest +from test.support import requires_zlib + +SETUP_PY = """\ +from distutils.core import setup +import foo + +setup(name='foo', version='0.1', py_modules=['foo'], + url='xxx', author='xxx', author_email='xxx') + +""" + + +@pytest.fixture(autouse=True) +def sys_executable_encodable(): + try: + sys.executable.encode('UTF-8') + except UnicodeEncodeError: + pytest.skip("sys.executable is not encodable to UTF-8") + + +mac_woes = pytest.mark.skipif( + "not sys.platform.startswith('linux')", + reason='spurious sdtout/stderr output under macOS', +) + + +@pytest.mark.usefixtures('save_env') +@pytest.mark.usefixtures('save_argv') +@pytest.mark.usefixtures('save_cwd') +class TestBuildRpm( + support.TempdirManager, +): + @mac_woes + @requires_zlib() + @pytest.mark.skipif("not shutil.which('rpm')") + @pytest.mark.skipif("not shutil.which('rpmbuild')") + def test_quiet(self): + # let's create a package + tmp_dir = self.mkdtemp() + os.environ['HOME'] = tmp_dir # to confine dir '.rpmdb' creation + pkg_dir = os.path.join(tmp_dir, 'foo') + os.mkdir(pkg_dir) + self.write_file((pkg_dir, 'setup.py'), SETUP_PY) + self.write_file((pkg_dir, 'foo.py'), '#') + self.write_file((pkg_dir, 'MANIFEST.in'), 'include foo.py') + self.write_file((pkg_dir, 'README'), '') + + dist = Distribution({ + 'name': 'foo', + 'version': '0.1', + 'py_modules': ['foo'], + 'url': 'xxx', + 'author': 'xxx', + 'author_email': 'xxx', + }) + dist.script_name = 'setup.py' + os.chdir(pkg_dir) + + sys.argv = ['setup.py'] + cmd = bdist_rpm(dist) + cmd.fix_python = True + + # running in quiet mode + cmd.quiet = True + cmd.ensure_finalized() + cmd.run() + + dist_created = os.listdir(os.path.join(pkg_dir, 'dist')) + assert 'foo-0.1-1.noarch.rpm' in dist_created + + # bug #2945: upload ignores bdist_rpm files + assert ('bdist_rpm', 'any', 'dist/foo-0.1-1.src.rpm') in dist.dist_files + assert ('bdist_rpm', 'any', 'dist/foo-0.1-1.noarch.rpm') in dist.dist_files + + @mac_woes + @requires_zlib() + # https://bugs.python.org/issue1533164 + @pytest.mark.skipif("not shutil.which('rpm')") + @pytest.mark.skipif("not shutil.which('rpmbuild')") + def test_no_optimize_flag(self): + # let's create a package that breaks bdist_rpm + tmp_dir = self.mkdtemp() + os.environ['HOME'] = tmp_dir # to confine dir '.rpmdb' creation + pkg_dir = os.path.join(tmp_dir, 'foo') + os.mkdir(pkg_dir) + self.write_file((pkg_dir, 'setup.py'), SETUP_PY) + self.write_file((pkg_dir, 'foo.py'), '#') + self.write_file((pkg_dir, 'MANIFEST.in'), 'include foo.py') + self.write_file((pkg_dir, 'README'), '') + + dist = Distribution({ + 'name': 'foo', + 'version': '0.1', + 'py_modules': ['foo'], + 'url': 'xxx', + 'author': 'xxx', + 'author_email': 'xxx', + }) + dist.script_name = 'setup.py' + os.chdir(pkg_dir) + + sys.argv = ['setup.py'] + cmd = bdist_rpm(dist) + cmd.fix_python = True + + cmd.quiet = True + cmd.ensure_finalized() + cmd.run() + + dist_created = os.listdir(os.path.join(pkg_dir, 'dist')) + assert 'foo-0.1-1.noarch.rpm' in dist_created + + # bug #2945: upload ignores bdist_rpm files + assert ('bdist_rpm', 'any', 'dist/foo-0.1-1.src.rpm') in dist.dist_files + assert ('bdist_rpm', 'any', 'dist/foo-0.1-1.noarch.rpm') in dist.dist_files + + os.remove(os.path.join(pkg_dir, 'dist', 'foo-0.1-1.noarch.rpm')) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build.py new file mode 100644 index 0000000000000000000000000000000000000000..f7fe69acd1ad39cf40d277afd6409648b18df146 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build.py @@ -0,0 +1,49 @@ +"""Tests for distutils.command.build.""" + +import os +import sys +from distutils.command.build import build +from distutils.tests import support +from sysconfig import get_config_var, get_platform + + +class TestBuild(support.TempdirManager): + def test_finalize_options(self): + pkg_dir, dist = self.create_dist() + cmd = build(dist) + cmd.finalize_options() + + # if not specified, plat_name gets the current platform + assert cmd.plat_name == get_platform() + + # build_purelib is build + lib + wanted = os.path.join(cmd.build_base, 'lib') + assert cmd.build_purelib == wanted + + # build_platlib is 'build/lib.platform-cache_tag[-pydebug]' + # examples: + # build/lib.macosx-10.3-i386-cpython39 + plat_spec = f'.{cmd.plat_name}-{sys.implementation.cache_tag}' + if get_config_var('Py_GIL_DISABLED'): + plat_spec += 't' + if hasattr(sys, 'gettotalrefcount'): + assert cmd.build_platlib.endswith('-pydebug') + plat_spec += '-pydebug' + wanted = os.path.join(cmd.build_base, 'lib' + plat_spec) + assert cmd.build_platlib == wanted + + # by default, build_lib = build_purelib + assert cmd.build_lib == cmd.build_purelib + + # build_temp is build/temp. + wanted = os.path.join(cmd.build_base, 'temp' + plat_spec) + assert cmd.build_temp == wanted + + # build_scripts is build/scripts-x.x + wanted = os.path.join( + cmd.build_base, f'scripts-{sys.version_info.major}.{sys.version_info.minor}' + ) + assert cmd.build_scripts == wanted + + # executable is os.path.normpath(sys.executable) + assert cmd.executable == os.path.normpath(sys.executable) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build_clib.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build_clib.py new file mode 100644 index 0000000000000000000000000000000000000000..f76f26bcea04ebeaeba20d3c65881198f841c9b5 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build_clib.py @@ -0,0 +1,134 @@ +"""Tests for distutils.command.build_clib.""" + +import os +from distutils.command.build_clib import build_clib +from distutils.errors import DistutilsSetupError +from distutils.tests import missing_compiler_executable, support + +import pytest + + +class TestBuildCLib(support.TempdirManager): + def test_check_library_dist(self): + pkg_dir, dist = self.create_dist() + cmd = build_clib(dist) + + # 'libraries' option must be a list + with pytest.raises(DistutilsSetupError): + cmd.check_library_list('foo') + + # each element of 'libraries' must a 2-tuple + with pytest.raises(DistutilsSetupError): + cmd.check_library_list(['foo1', 'foo2']) + + # first element of each tuple in 'libraries' + # must be a string (the library name) + with pytest.raises(DistutilsSetupError): + cmd.check_library_list([(1, 'foo1'), ('name', 'foo2')]) + + # library name may not contain directory separators + with pytest.raises(DistutilsSetupError): + cmd.check_library_list( + [('name', 'foo1'), ('another/name', 'foo2')], + ) + + # second element of each tuple must be a dictionary (build info) + with pytest.raises(DistutilsSetupError): + cmd.check_library_list( + [('name', {}), ('another', 'foo2')], + ) + + # those work + libs = [('name', {}), ('name', {'ok': 'good'})] + cmd.check_library_list(libs) + + def test_get_source_files(self): + pkg_dir, dist = self.create_dist() + cmd = build_clib(dist) + + # "in 'libraries' option 'sources' must be present and must be + # a list of source filenames + cmd.libraries = [('name', {})] + with pytest.raises(DistutilsSetupError): + cmd.get_source_files() + + cmd.libraries = [('name', {'sources': 1})] + with pytest.raises(DistutilsSetupError): + cmd.get_source_files() + + cmd.libraries = [('name', {'sources': ['a', 'b']})] + assert cmd.get_source_files() == ['a', 'b'] + + cmd.libraries = [('name', {'sources': ('a', 'b')})] + assert cmd.get_source_files() == ['a', 'b'] + + cmd.libraries = [ + ('name', {'sources': ('a', 'b')}), + ('name2', {'sources': ['c', 'd']}), + ] + assert cmd.get_source_files() == ['a', 'b', 'c', 'd'] + + def test_build_libraries(self): + pkg_dir, dist = self.create_dist() + cmd = build_clib(dist) + + class FakeCompiler: + def compile(*args, **kw): + pass + + create_static_lib = compile + + cmd.compiler = FakeCompiler() + + # build_libraries is also doing a bit of typo checking + lib = [('name', {'sources': 'notvalid'})] + with pytest.raises(DistutilsSetupError): + cmd.build_libraries(lib) + + lib = [('name', {'sources': list()})] + cmd.build_libraries(lib) + + lib = [('name', {'sources': tuple()})] + cmd.build_libraries(lib) + + def test_finalize_options(self): + pkg_dir, dist = self.create_dist() + cmd = build_clib(dist) + + cmd.include_dirs = 'one-dir' + cmd.finalize_options() + assert cmd.include_dirs == ['one-dir'] + + cmd.include_dirs = None + cmd.finalize_options() + assert cmd.include_dirs == [] + + cmd.distribution.libraries = 'WONTWORK' + with pytest.raises(DistutilsSetupError): + cmd.finalize_options() + + @pytest.mark.skipif('platform.system() == "Windows"') + def test_run(self): + pkg_dir, dist = self.create_dist() + cmd = build_clib(dist) + + foo_c = os.path.join(pkg_dir, 'foo.c') + self.write_file(foo_c, 'int main(void) { return 1;}\n') + cmd.libraries = [('foo', {'sources': [foo_c]})] + + build_temp = os.path.join(pkg_dir, 'build') + os.mkdir(build_temp) + cmd.build_temp = build_temp + cmd.build_clib = build_temp + + # Before we run the command, we want to make sure + # all commands are present on the system. + ccmd = missing_compiler_executable() + if ccmd is not None: + self.skipTest(f'The {ccmd!r} command is not found') + + # this should work + cmd.run() + + # let's check the result + assert 'libfoo.a' in os.listdir(build_temp) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build_ext.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build_ext.py new file mode 100644 index 0000000000000000000000000000000000000000..dab0507f3d3ec104fb4acfe5b15f92661ff33a37 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build_ext.py @@ -0,0 +1,628 @@ +import contextlib +import glob +import importlib +import os.path +import platform +import re +import shutil +import site +import subprocess +import sys +import tempfile +import textwrap +import time +from distutils import sysconfig +from distutils.command.build_ext import build_ext +from distutils.core import Distribution +from distutils.errors import ( + CompileError, + DistutilsPlatformError, + DistutilsSetupError, + UnknownFileError, +) +from distutils.extension import Extension +from distutils.tests import missing_compiler_executable +from distutils.tests.support import TempdirManager, copy_xxmodule_c, fixup_build_ext +from io import StringIO + +import jaraco.path +import path +import pytest +from test import support + +from .compat import py39 as import_helper + + +@pytest.fixture() +def user_site_dir(request): + self = request.instance + self.tmp_dir = self.mkdtemp() + self.tmp_path = path.Path(self.tmp_dir) + from distutils.command import build_ext + + orig_user_base = site.USER_BASE + + site.USER_BASE = self.mkdtemp() + build_ext.USER_BASE = site.USER_BASE + + # bpo-30132: On Windows, a .pdb file may be created in the current + # working directory. Create a temporary working directory to cleanup + # everything at the end of the test. + with self.tmp_path: + yield + + site.USER_BASE = orig_user_base + build_ext.USER_BASE = orig_user_base + + if sys.platform == 'cygwin': + time.sleep(1) + + +@contextlib.contextmanager +def safe_extension_import(name, path): + with import_helper.CleanImport(name): + with extension_redirect(name, path) as new_path: + with import_helper.DirsOnSysPath(new_path): + yield + + +@contextlib.contextmanager +def extension_redirect(mod, path): + """ + Tests will fail to tear down an extension module if it's been imported. + + Before importing, copy the file to a temporary directory that won't + be cleaned up. Yield the new path. + """ + if platform.system() != "Windows" and sys.platform != "cygwin": + yield path + return + with import_helper.DirsOnSysPath(path): + spec = importlib.util.find_spec(mod) + filename = os.path.basename(spec.origin) + trash_dir = tempfile.mkdtemp(prefix='deleteme') + dest = os.path.join(trash_dir, os.path.basename(filename)) + shutil.copy(spec.origin, dest) + yield trash_dir + # TODO: can the file be scheduled for deletion? + + +@pytest.mark.usefixtures('user_site_dir') +class TestBuildExt(TempdirManager): + def build_ext(self, *args, **kwargs): + return build_ext(*args, **kwargs) + + @pytest.mark.parametrize("copy_so", [False]) + def test_build_ext(self, copy_so): + missing_compiler_executable() + copy_xxmodule_c(self.tmp_dir) + xx_c = os.path.join(self.tmp_dir, 'xxmodule.c') + xx_ext = Extension('xx', [xx_c]) + if sys.platform != "win32": + if not copy_so: + xx_ext = Extension( + 'xx', + [xx_c], + library_dirs=['/usr/lib'], + libraries=['z'], + runtime_library_dirs=['/usr/lib'], + ) + elif sys.platform == 'linux': + libz_so = { + os.path.realpath(name) for name in glob.iglob('/usr/lib*/libz.so*') + } + libz_so = sorted(libz_so, key=lambda lib_path: len(lib_path)) + shutil.copyfile(libz_so[-1], '/tmp/libxx_z.so') + + xx_ext = Extension( + 'xx', + [xx_c], + library_dirs=['/tmp'], + libraries=['xx_z'], + runtime_library_dirs=['/tmp'], + ) + dist = Distribution({'name': 'xx', 'ext_modules': [xx_ext]}) + dist.package_dir = self.tmp_dir + cmd = self.build_ext(dist) + fixup_build_ext(cmd) + cmd.build_lib = self.tmp_dir + cmd.build_temp = self.tmp_dir + + old_stdout = sys.stdout + if not support.verbose: + # silence compiler output + sys.stdout = StringIO() + try: + cmd.ensure_finalized() + cmd.run() + finally: + sys.stdout = old_stdout + + with safe_extension_import('xx', self.tmp_dir): + self._test_xx(copy_so) + + if sys.platform == 'linux' and copy_so: + os.unlink('/tmp/libxx_z.so') + + @staticmethod + def _test_xx(copy_so): + import xx # type: ignore[import-not-found] # Module generated for tests + + for attr in ('error', 'foo', 'new', 'roj'): + assert hasattr(xx, attr) + + assert xx.foo(2, 5) == 7 + assert xx.foo(13, 15) == 28 + assert xx.new().demo() is None + if support.HAVE_DOCSTRINGS: + doc = 'This is a template module just for instruction.' + assert xx.__doc__ == doc + assert isinstance(xx.Null(), xx.Null) + assert isinstance(xx.Str(), xx.Str) + + if sys.platform == 'linux': + so_headers = subprocess.check_output( + ["readelf", "-d", xx.__file__], universal_newlines=True + ) + import pprint + + pprint.pprint(so_headers) + rpaths = [ + rpath + for line in so_headers.split("\n") + if "RPATH" in line or "RUNPATH" in line + for rpath in line.split()[2][1:-1].split(":") + ] + if not copy_so: + pprint.pprint(rpaths) + # Linked against a library in /usr/lib{,64} + assert "/usr/lib" not in rpaths and "/usr/lib64" not in rpaths + else: + # Linked against a library in /tmp + assert "/tmp" in rpaths + # The import is the real test here + + def test_solaris_enable_shared(self): + dist = Distribution({'name': 'xx'}) + cmd = self.build_ext(dist) + old = sys.platform + + sys.platform = 'sunos' # fooling finalize_options + from distutils.sysconfig import _config_vars + + old_var = _config_vars.get('Py_ENABLE_SHARED') + _config_vars['Py_ENABLE_SHARED'] = True + try: + cmd.ensure_finalized() + finally: + sys.platform = old + if old_var is None: + del _config_vars['Py_ENABLE_SHARED'] + else: + _config_vars['Py_ENABLE_SHARED'] = old_var + + # make sure we get some library dirs under solaris + assert len(cmd.library_dirs) > 0 + + def test_user_site(self): + import site + + dist = Distribution({'name': 'xx'}) + cmd = self.build_ext(dist) + + # making sure the user option is there + options = [name for name, short, label in cmd.user_options] + assert 'user' in options + + # setting a value + cmd.user = True + + # setting user based lib and include + lib = os.path.join(site.USER_BASE, 'lib') + incl = os.path.join(site.USER_BASE, 'include') + os.mkdir(lib) + os.mkdir(incl) + + # let's run finalize + cmd.ensure_finalized() + + # see if include_dirs and library_dirs + # were set + assert lib in cmd.library_dirs + assert lib in cmd.rpath + assert incl in cmd.include_dirs + + def test_optional_extension(self): + # this extension will fail, but let's ignore this failure + # with the optional argument. + modules = [Extension('foo', ['xxx'], optional=False)] + dist = Distribution({'name': 'xx', 'ext_modules': modules}) + cmd = self.build_ext(dist) + cmd.ensure_finalized() + with pytest.raises((UnknownFileError, CompileError)): + cmd.run() # should raise an error + + modules = [Extension('foo', ['xxx'], optional=True)] + dist = Distribution({'name': 'xx', 'ext_modules': modules}) + cmd = self.build_ext(dist) + cmd.ensure_finalized() + cmd.run() # should pass + + def test_finalize_options(self): + # Make sure Python's include directories (for Python.h, pyconfig.h, + # etc.) are in the include search path. + modules = [Extension('foo', ['xxx'], optional=False)] + dist = Distribution({'name': 'xx', 'ext_modules': modules}) + cmd = self.build_ext(dist) + cmd.finalize_options() + + py_include = sysconfig.get_python_inc() + for p in py_include.split(os.path.pathsep): + assert p in cmd.include_dirs + + plat_py_include = sysconfig.get_python_inc(plat_specific=True) + for p in plat_py_include.split(os.path.pathsep): + assert p in cmd.include_dirs + + # make sure cmd.libraries is turned into a list + # if it's a string + cmd = self.build_ext(dist) + cmd.libraries = 'my_lib, other_lib lastlib' + cmd.finalize_options() + assert cmd.libraries == ['my_lib', 'other_lib', 'lastlib'] + + # make sure cmd.library_dirs is turned into a list + # if it's a string + cmd = self.build_ext(dist) + cmd.library_dirs = f'my_lib_dir{os.pathsep}other_lib_dir' + cmd.finalize_options() + assert 'my_lib_dir' in cmd.library_dirs + assert 'other_lib_dir' in cmd.library_dirs + + # make sure rpath is turned into a list + # if it's a string + cmd = self.build_ext(dist) + cmd.rpath = f'one{os.pathsep}two' + cmd.finalize_options() + assert cmd.rpath == ['one', 'two'] + + # make sure cmd.link_objects is turned into a list + # if it's a string + cmd = build_ext(dist) + cmd.link_objects = 'one two,three' + cmd.finalize_options() + assert cmd.link_objects == ['one', 'two', 'three'] + + # XXX more tests to perform for win32 + + # make sure define is turned into 2-tuples + # strings if they are ','-separated strings + cmd = self.build_ext(dist) + cmd.define = 'one,two' + cmd.finalize_options() + assert cmd.define == [('one', '1'), ('two', '1')] + + # make sure undef is turned into a list of + # strings if they are ','-separated strings + cmd = self.build_ext(dist) + cmd.undef = 'one,two' + cmd.finalize_options() + assert cmd.undef == ['one', 'two'] + + # make sure swig_opts is turned into a list + cmd = self.build_ext(dist) + cmd.swig_opts = None + cmd.finalize_options() + assert cmd.swig_opts == [] + + cmd = self.build_ext(dist) + cmd.swig_opts = '1 2' + cmd.finalize_options() + assert cmd.swig_opts == ['1', '2'] + + def test_check_extensions_list(self): + dist = Distribution() + cmd = self.build_ext(dist) + cmd.finalize_options() + + # 'extensions' option must be a list of Extension instances + with pytest.raises(DistutilsSetupError): + cmd.check_extensions_list('foo') + + # each element of 'ext_modules' option must be an + # Extension instance or 2-tuple + exts = [('bar', 'foo', 'bar'), 'foo'] + with pytest.raises(DistutilsSetupError): + cmd.check_extensions_list(exts) + + # first element of each tuple in 'ext_modules' + # must be the extension name (a string) and match + # a python dotted-separated name + exts = [('foo-bar', '')] + with pytest.raises(DistutilsSetupError): + cmd.check_extensions_list(exts) + + # second element of each tuple in 'ext_modules' + # must be a dictionary (build info) + exts = [('foo.bar', '')] + with pytest.raises(DistutilsSetupError): + cmd.check_extensions_list(exts) + + # ok this one should pass + exts = [('foo.bar', {'sources': [''], 'libraries': 'foo', 'some': 'bar'})] + cmd.check_extensions_list(exts) + ext = exts[0] + assert isinstance(ext, Extension) + + # check_extensions_list adds in ext the values passed + # when they are in ('include_dirs', 'library_dirs', 'libraries' + # 'extra_objects', 'extra_compile_args', 'extra_link_args') + assert ext.libraries == 'foo' + assert not hasattr(ext, 'some') + + # 'macros' element of build info dict must be 1- or 2-tuple + exts = [ + ( + 'foo.bar', + { + 'sources': [''], + 'libraries': 'foo', + 'some': 'bar', + 'macros': [('1', '2', '3'), 'foo'], + }, + ) + ] + with pytest.raises(DistutilsSetupError): + cmd.check_extensions_list(exts) + + exts[0][1]['macros'] = [('1', '2'), ('3',)] + cmd.check_extensions_list(exts) + assert exts[0].undef_macros == ['3'] + assert exts[0].define_macros == [('1', '2')] + + def test_get_source_files(self): + modules = [Extension('foo', ['xxx'], optional=False)] + dist = Distribution({'name': 'xx', 'ext_modules': modules}) + cmd = self.build_ext(dist) + cmd.ensure_finalized() + assert cmd.get_source_files() == ['xxx'] + + def test_unicode_module_names(self): + modules = [ + Extension('foo', ['aaa'], optional=False), + Extension('föö', ['uuu'], optional=False), + ] + dist = Distribution({'name': 'xx', 'ext_modules': modules}) + cmd = self.build_ext(dist) + cmd.ensure_finalized() + assert re.search(r'foo(_d)?\..*', cmd.get_ext_filename(modules[0].name)) + assert re.search(r'föö(_d)?\..*', cmd.get_ext_filename(modules[1].name)) + assert cmd.get_export_symbols(modules[0]) == ['PyInit_foo'] + assert cmd.get_export_symbols(modules[1]) == ['PyInitU_f_1gaa'] + + def test_export_symbols__init__(self): + # https://github.com/python/cpython/issues/80074 + # https://github.com/pypa/setuptools/issues/4826 + modules = [ + Extension('foo.__init__', ['aaa']), + Extension('föö.__init__', ['uuu']), + ] + dist = Distribution({'name': 'xx', 'ext_modules': modules}) + cmd = self.build_ext(dist) + cmd.ensure_finalized() + assert cmd.get_export_symbols(modules[0]) == ['PyInit_foo'] + assert cmd.get_export_symbols(modules[1]) == ['PyInitU_f_1gaa'] + + def test_compiler_option(self): + # cmd.compiler is an option and + # should not be overridden by a compiler instance + # when the command is run + dist = Distribution() + cmd = self.build_ext(dist) + cmd.compiler = 'unix' + cmd.ensure_finalized() + cmd.run() + assert cmd.compiler == 'unix' + + def test_get_outputs(self): + missing_compiler_executable() + tmp_dir = self.mkdtemp() + c_file = os.path.join(tmp_dir, 'foo.c') + self.write_file(c_file, 'void PyInit_foo(void) {}\n') + ext = Extension('foo', [c_file], optional=False) + dist = Distribution({'name': 'xx', 'ext_modules': [ext]}) + cmd = self.build_ext(dist) + fixup_build_ext(cmd) + cmd.ensure_finalized() + assert len(cmd.get_outputs()) == 1 + + cmd.build_lib = os.path.join(self.tmp_dir, 'build') + cmd.build_temp = os.path.join(self.tmp_dir, 'tempt') + + # issue #5977 : distutils build_ext.get_outputs + # returns wrong result with --inplace + other_tmp_dir = os.path.realpath(self.mkdtemp()) + old_wd = os.getcwd() + os.chdir(other_tmp_dir) + try: + cmd.inplace = True + cmd.run() + so_file = cmd.get_outputs()[0] + finally: + os.chdir(old_wd) + assert os.path.exists(so_file) + ext_suffix = sysconfig.get_config_var('EXT_SUFFIX') + assert so_file.endswith(ext_suffix) + so_dir = os.path.dirname(so_file) + assert so_dir == other_tmp_dir + + cmd.inplace = False + cmd.compiler = None + cmd.run() + so_file = cmd.get_outputs()[0] + assert os.path.exists(so_file) + assert so_file.endswith(ext_suffix) + so_dir = os.path.dirname(so_file) + assert so_dir == cmd.build_lib + + # inplace = False, cmd.package = 'bar' + build_py = cmd.get_finalized_command('build_py') + build_py.package_dir = {'': 'bar'} + path = cmd.get_ext_fullpath('foo') + # checking that the last directory is the build_dir + path = os.path.split(path)[0] + assert path == cmd.build_lib + + # inplace = True, cmd.package = 'bar' + cmd.inplace = True + other_tmp_dir = os.path.realpath(self.mkdtemp()) + old_wd = os.getcwd() + os.chdir(other_tmp_dir) + try: + path = cmd.get_ext_fullpath('foo') + finally: + os.chdir(old_wd) + # checking that the last directory is bar + path = os.path.split(path)[0] + lastdir = os.path.split(path)[-1] + assert lastdir == 'bar' + + def test_ext_fullpath(self): + ext = sysconfig.get_config_var('EXT_SUFFIX') + # building lxml.etree inplace + # etree_c = os.path.join(self.tmp_dir, 'lxml.etree.c') + # etree_ext = Extension('lxml.etree', [etree_c]) + # dist = Distribution({'name': 'lxml', 'ext_modules': [etree_ext]}) + dist = Distribution() + cmd = self.build_ext(dist) + cmd.inplace = True + cmd.distribution.package_dir = {'': 'src'} + cmd.distribution.packages = ['lxml', 'lxml.html'] + curdir = os.getcwd() + wanted = os.path.join(curdir, 'src', 'lxml', 'etree' + ext) + path = cmd.get_ext_fullpath('lxml.etree') + assert wanted == path + + # building lxml.etree not inplace + cmd.inplace = False + cmd.build_lib = os.path.join(curdir, 'tmpdir') + wanted = os.path.join(curdir, 'tmpdir', 'lxml', 'etree' + ext) + path = cmd.get_ext_fullpath('lxml.etree') + assert wanted == path + + # building twisted.runner.portmap not inplace + build_py = cmd.get_finalized_command('build_py') + build_py.package_dir = {} + cmd.distribution.packages = ['twisted', 'twisted.runner.portmap'] + path = cmd.get_ext_fullpath('twisted.runner.portmap') + wanted = os.path.join(curdir, 'tmpdir', 'twisted', 'runner', 'portmap' + ext) + assert wanted == path + + # building twisted.runner.portmap inplace + cmd.inplace = True + path = cmd.get_ext_fullpath('twisted.runner.portmap') + wanted = os.path.join(curdir, 'twisted', 'runner', 'portmap' + ext) + assert wanted == path + + @pytest.mark.skipif('platform.system() != "Darwin"') + @pytest.mark.usefixtures('save_env') + def test_deployment_target_default(self): + # Issue 9516: Test that, in the absence of the environment variable, + # an extension module is compiled with the same deployment target as + # the interpreter. + self._try_compile_deployment_target('==', None) + + @pytest.mark.skipif('platform.system() != "Darwin"') + @pytest.mark.usefixtures('save_env') + def test_deployment_target_too_low(self): + # Issue 9516: Test that an extension module is not allowed to be + # compiled with a deployment target less than that of the interpreter. + with pytest.raises(DistutilsPlatformError): + self._try_compile_deployment_target('>', '10.1') + + @pytest.mark.skipif('platform.system() != "Darwin"') + @pytest.mark.usefixtures('save_env') + def test_deployment_target_higher_ok(self): # pragma: no cover + # Issue 9516: Test that an extension module can be compiled with a + # deployment target higher than that of the interpreter: the ext + # module may depend on some newer OS feature. + deptarget = sysconfig.get_config_var('MACOSX_DEPLOYMENT_TARGET') + if deptarget: + # increment the minor version number (i.e. 10.6 -> 10.7) + deptarget = [int(x) for x in deptarget.split('.')] + deptarget[-1] += 1 + deptarget = '.'.join(str(i) for i in deptarget) + self._try_compile_deployment_target('<', deptarget) + + def _try_compile_deployment_target(self, operator, target): # pragma: no cover + if target is None: + if os.environ.get('MACOSX_DEPLOYMENT_TARGET'): + del os.environ['MACOSX_DEPLOYMENT_TARGET'] + else: + os.environ['MACOSX_DEPLOYMENT_TARGET'] = target + + jaraco.path.build( + { + 'deptargetmodule.c': textwrap.dedent(f"""\ + #include + + int dummy; + + #if TARGET {operator} MAC_OS_X_VERSION_MIN_REQUIRED + #else + #error "Unexpected target" + #endif + + """), + }, + self.tmp_path, + ) + + # get the deployment target that the interpreter was built with + target = sysconfig.get_config_var('MACOSX_DEPLOYMENT_TARGET') + target = tuple(map(int, target.split('.')[0:2])) + # format the target value as defined in the Apple + # Availability Macros. We can't use the macro names since + # at least one value we test with will not exist yet. + if target[:2] < (10, 10): + # for 10.1 through 10.9.x -> "10n0" + tmpl = '{:02}{:01}0' + else: + # for 10.10 and beyond -> "10nn00" + if len(target) >= 2: + tmpl = '{:02}{:02}00' + else: + # 11 and later can have no minor version (11 instead of 11.0) + tmpl = '{:02}0000' + target = tmpl.format(*target) + deptarget_ext = Extension( + 'deptarget', + [self.tmp_path / 'deptargetmodule.c'], + extra_compile_args=[f'-DTARGET={target}'], + ) + dist = Distribution({'name': 'deptarget', 'ext_modules': [deptarget_ext]}) + dist.package_dir = self.tmp_dir + cmd = self.build_ext(dist) + cmd.build_lib = self.tmp_dir + cmd.build_temp = self.tmp_dir + + try: + old_stdout = sys.stdout + if not support.verbose: + # silence compiler output + sys.stdout = StringIO() + try: + cmd.ensure_finalized() + cmd.run() + finally: + sys.stdout = old_stdout + + except CompileError: + self.fail("Wrong deployment target during compilation") + + +class TestParallelBuildExt(TestBuildExt): + def build_ext(self, *args, **kwargs): + build_ext = super().build_ext(*args, **kwargs) + build_ext.parallel = True + return build_ext diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build_py.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build_py.py new file mode 100644 index 0000000000000000000000000000000000000000..b316ed43a11836210caeb7177bd8890a1f61d1bb --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build_py.py @@ -0,0 +1,196 @@ +"""Tests for distutils.command.build_py.""" + +import os +import sys +from distutils.command.build_py import build_py +from distutils.core import Distribution +from distutils.errors import DistutilsFileError +from distutils.tests import support + +import jaraco.path +import pytest + + +@support.combine_markers +class TestBuildPy(support.TempdirManager): + def test_package_data(self): + sources = self.mkdtemp() + jaraco.path.build( + { + '__init__.py': "# Pretend this is a package.", + 'README.txt': 'Info about this package', + }, + sources, + ) + + destination = self.mkdtemp() + + dist = Distribution({"packages": ["pkg"], "package_dir": {"pkg": sources}}) + # script_name need not exist, it just need to be initialized + dist.script_name = os.path.join(sources, "setup.py") + dist.command_obj["build"] = support.DummyCommand( + force=False, build_lib=destination + ) + dist.packages = ["pkg"] + dist.package_data = {"pkg": ["README.txt"]} + dist.package_dir = {"pkg": sources} + + cmd = build_py(dist) + cmd.compile = True + cmd.ensure_finalized() + assert cmd.package_data == dist.package_data + + cmd.run() + + # This makes sure the list of outputs includes byte-compiled + # files for Python modules but not for package data files + # (there shouldn't *be* byte-code files for those!). + assert len(cmd.get_outputs()) == 3 + pkgdest = os.path.join(destination, "pkg") + files = os.listdir(pkgdest) + pycache_dir = os.path.join(pkgdest, "__pycache__") + assert "__init__.py" in files + assert "README.txt" in files + if sys.dont_write_bytecode: + assert not os.path.exists(pycache_dir) + else: + pyc_files = os.listdir(pycache_dir) + assert f"__init__.{sys.implementation.cache_tag}.pyc" in pyc_files + + def test_empty_package_dir(self): + # See bugs #1668596/#1720897 + sources = self.mkdtemp() + jaraco.path.build({'__init__.py': '', 'doc': {'testfile': ''}}, sources) + + os.chdir(sources) + dist = Distribution({ + "packages": ["pkg"], + "package_dir": {"pkg": ""}, + "package_data": {"pkg": ["doc/*"]}, + }) + # script_name need not exist, it just need to be initialized + dist.script_name = os.path.join(sources, "setup.py") + dist.script_args = ["build"] + dist.parse_command_line() + + try: + dist.run_commands() + except DistutilsFileError: + self.fail("failed package_data test when package_dir is ''") + + @pytest.mark.skipif('sys.dont_write_bytecode') + def test_byte_compile(self): + project_dir, dist = self.create_dist(py_modules=['boiledeggs']) + os.chdir(project_dir) + self.write_file('boiledeggs.py', 'import antigravity') + cmd = build_py(dist) + cmd.compile = True + cmd.build_lib = 'here' + cmd.finalize_options() + cmd.run() + + found = os.listdir(cmd.build_lib) + assert sorted(found) == ['__pycache__', 'boiledeggs.py'] + found = os.listdir(os.path.join(cmd.build_lib, '__pycache__')) + assert found == [f'boiledeggs.{sys.implementation.cache_tag}.pyc'] + + @pytest.mark.skipif('sys.dont_write_bytecode') + def test_byte_compile_optimized(self): + project_dir, dist = self.create_dist(py_modules=['boiledeggs']) + os.chdir(project_dir) + self.write_file('boiledeggs.py', 'import antigravity') + cmd = build_py(dist) + cmd.compile = False + cmd.optimize = 1 + cmd.build_lib = 'here' + cmd.finalize_options() + cmd.run() + + found = os.listdir(cmd.build_lib) + assert sorted(found) == ['__pycache__', 'boiledeggs.py'] + found = os.listdir(os.path.join(cmd.build_lib, '__pycache__')) + expect = f'boiledeggs.{sys.implementation.cache_tag}.opt-1.pyc' + assert sorted(found) == [expect] + + def test_dir_in_package_data(self): + """ + A directory in package_data should not be added to the filelist. + """ + # See bug 19286 + sources = self.mkdtemp() + jaraco.path.build( + { + 'pkg': { + '__init__.py': '', + 'doc': { + 'testfile': '', + # create a directory that could be incorrectly detected as a file + 'otherdir': {}, + }, + } + }, + sources, + ) + + os.chdir(sources) + dist = Distribution({"packages": ["pkg"], "package_data": {"pkg": ["doc/*"]}}) + # script_name need not exist, it just need to be initialized + dist.script_name = os.path.join(sources, "setup.py") + dist.script_args = ["build"] + dist.parse_command_line() + + try: + dist.run_commands() + except DistutilsFileError: + self.fail("failed package_data when data dir includes a dir") + + def test_dont_write_bytecode(self, caplog): + # makes sure byte_compile is not used + dist = self.create_dist()[1] + cmd = build_py(dist) + cmd.compile = True + cmd.optimize = 1 + + old_dont_write_bytecode = sys.dont_write_bytecode + sys.dont_write_bytecode = True + try: + cmd.byte_compile([]) + finally: + sys.dont_write_bytecode = old_dont_write_bytecode + + assert 'byte-compiling is disabled' in caplog.records[0].message + + def test_namespace_package_does_not_warn(self, caplog): + """ + Originally distutils implementation did not account for PEP 420 + and included warns for package directories that did not contain + ``__init__.py`` files. + After the acceptance of PEP 420, these warnings don't make more sense + so we want to ensure there are not displayed to not confuse the users. + """ + # Create a fake project structure with a package namespace: + tmp = self.mkdtemp() + jaraco.path.build({'ns': {'pkg': {'module.py': ''}}}, tmp) + os.chdir(tmp) + + # Configure the package: + attrs = { + "name": "ns.pkg", + "packages": ["ns", "ns.pkg"], + "script_name": "setup.py", + } + dist = Distribution(attrs) + + # Run code paths that would trigger the trap: + cmd = dist.get_command_obj("build_py") + cmd.finalize_options() + modules = cmd.find_all_modules() + assert len(modules) == 1 + module_path = modules[0][-1] + assert module_path.replace(os.sep, "/") == "ns/pkg/module.py" + + cmd.run() + + assert not any( + "package init file" in msg and "not found" in msg for msg in caplog.messages + ) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build_scripts.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build_scripts.py new file mode 100644 index 0000000000000000000000000000000000000000..3582f691ef578a419555c6ffbba6a619310517a6 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build_scripts.py @@ -0,0 +1,96 @@ +"""Tests for distutils.command.build_scripts.""" + +import os +import textwrap +from distutils import sysconfig +from distutils.command.build_scripts import build_scripts +from distutils.core import Distribution +from distutils.tests import support + +import jaraco.path + + +class TestBuildScripts(support.TempdirManager): + def test_default_settings(self): + cmd = self.get_build_scripts_cmd("/foo/bar", []) + assert not cmd.force + assert cmd.build_dir is None + + cmd.finalize_options() + + assert cmd.force + assert cmd.build_dir == "/foo/bar" + + def test_build(self): + source = self.mkdtemp() + target = self.mkdtemp() + expected = self.write_sample_scripts(source) + + cmd = self.get_build_scripts_cmd( + target, [os.path.join(source, fn) for fn in expected] + ) + cmd.finalize_options() + cmd.run() + + built = os.listdir(target) + for name in expected: + assert name in built + + def get_build_scripts_cmd(self, target, scripts): + import sys + + dist = Distribution() + dist.scripts = scripts + dist.command_obj["build"] = support.DummyCommand( + build_scripts=target, force=True, executable=sys.executable + ) + return build_scripts(dist) + + @staticmethod + def write_sample_scripts(dir): + spec = { + 'script1.py': textwrap.dedent(""" + #! /usr/bin/env python2.3 + # bogus script w/ Python sh-bang + pass + """).lstrip(), + 'script2.py': textwrap.dedent(""" + #!/usr/bin/python + # bogus script w/ Python sh-bang + pass + """).lstrip(), + 'shell.sh': textwrap.dedent(""" + #!/bin/sh + # bogus shell script w/ sh-bang + exit 0 + """).lstrip(), + } + jaraco.path.build(spec, dir) + return list(spec) + + def test_version_int(self): + source = self.mkdtemp() + target = self.mkdtemp() + expected = self.write_sample_scripts(source) + + cmd = self.get_build_scripts_cmd( + target, [os.path.join(source, fn) for fn in expected] + ) + cmd.finalize_options() + + # https://bugs.python.org/issue4524 + # + # On linux-g++-32 with command line `./configure --enable-ipv6 + # --with-suffix=3`, python is compiled okay but the build scripts + # failed when writing the name of the executable + old = sysconfig.get_config_vars().get('VERSION') + sysconfig._config_vars['VERSION'] = 4 + try: + cmd.run() + finally: + if old is not None: + sysconfig._config_vars['VERSION'] = old + + built = os.listdir(target) + for name in expected: + assert name in built diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_check.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_check.py new file mode 100644 index 0000000000000000000000000000000000000000..b672b1f972b46f399eb5b2ef263da2548d52ef89 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_check.py @@ -0,0 +1,194 @@ +"""Tests for distutils.command.check.""" + +import os +import textwrap +from distutils.command.check import check +from distutils.errors import DistutilsSetupError +from distutils.tests import support + +import pytest + +try: + import pygments +except ImportError: + pygments = None + + +HERE = os.path.dirname(__file__) + + +@support.combine_markers +class TestCheck(support.TempdirManager): + def _run(self, metadata=None, cwd=None, **options): + if metadata is None: + metadata = {} + if cwd is not None: + old_dir = os.getcwd() + os.chdir(cwd) + pkg_info, dist = self.create_dist(**metadata) + cmd = check(dist) + cmd.initialize_options() + for name, value in options.items(): + setattr(cmd, name, value) + cmd.ensure_finalized() + cmd.run() + if cwd is not None: + os.chdir(old_dir) + return cmd + + def test_check_metadata(self): + # let's run the command with no metadata at all + # by default, check is checking the metadata + # should have some warnings + cmd = self._run() + assert cmd._warnings == 1 + + # now let's add the required fields + # and run it again, to make sure we don't get + # any warning anymore + metadata = { + 'url': 'xxx', + 'author': 'xxx', + 'author_email': 'xxx', + 'name': 'xxx', + 'version': 'xxx', + } + cmd = self._run(metadata) + assert cmd._warnings == 0 + + # now with the strict mode, we should + # get an error if there are missing metadata + with pytest.raises(DistutilsSetupError): + self._run({}, **{'strict': 1}) + + # and of course, no error when all metadata are present + cmd = self._run(metadata, strict=True) + assert cmd._warnings == 0 + + # now a test with non-ASCII characters + metadata = { + 'url': 'xxx', + 'author': '\u00c9ric', + 'author_email': 'xxx', + 'name': 'xxx', + 'version': 'xxx', + 'description': 'Something about esszet \u00df', + 'long_description': 'More things about esszet \u00df', + } + cmd = self._run(metadata) + assert cmd._warnings == 0 + + def test_check_author_maintainer(self): + for kind in ("author", "maintainer"): + # ensure no warning when author_email or maintainer_email is given + # (the spec allows these fields to take the form "Name ") + metadata = { + 'url': 'xxx', + kind + '_email': 'Name ', + 'name': 'xxx', + 'version': 'xxx', + } + cmd = self._run(metadata) + assert cmd._warnings == 0 + + # the check should not warn if only email is given + metadata[kind + '_email'] = 'name@email.com' + cmd = self._run(metadata) + assert cmd._warnings == 0 + + # the check should not warn if only the name is given + metadata[kind] = "Name" + del metadata[kind + '_email'] + cmd = self._run(metadata) + assert cmd._warnings == 0 + + def test_check_document(self): + pytest.importorskip('docutils') + pkg_info, dist = self.create_dist() + cmd = check(dist) + + # let's see if it detects broken rest + broken_rest = 'title\n===\n\ntest' + msgs = cmd._check_rst_data(broken_rest) + assert len(msgs) == 1 + + # and non-broken rest + rest = 'title\n=====\n\ntest' + msgs = cmd._check_rst_data(rest) + assert len(msgs) == 0 + + def test_check_restructuredtext(self): + pytest.importorskip('docutils') + # let's see if it detects broken rest in long_description + broken_rest = 'title\n===\n\ntest' + pkg_info, dist = self.create_dist(long_description=broken_rest) + cmd = check(dist) + cmd.check_restructuredtext() + assert cmd._warnings == 1 + + # let's see if we have an error with strict=True + metadata = { + 'url': 'xxx', + 'author': 'xxx', + 'author_email': 'xxx', + 'name': 'xxx', + 'version': 'xxx', + 'long_description': broken_rest, + } + with pytest.raises(DistutilsSetupError): + self._run(metadata, **{'strict': 1, 'restructuredtext': 1}) + + # and non-broken rest, including a non-ASCII character to test #12114 + metadata['long_description'] = 'title\n=====\n\ntest \u00df' + cmd = self._run(metadata, strict=True, restructuredtext=True) + assert cmd._warnings == 0 + + # check that includes work to test #31292 + metadata['long_description'] = 'title\n=====\n\n.. include:: includetest.rst' + cmd = self._run(metadata, cwd=HERE, strict=True, restructuredtext=True) + assert cmd._warnings == 0 + + def test_check_restructuredtext_with_syntax_highlight(self): + pytest.importorskip('docutils') + # Don't fail if there is a `code` or `code-block` directive + + example_rst_docs = [ + textwrap.dedent( + """\ + Here's some code: + + .. code:: python + + def foo(): + pass + """ + ), + textwrap.dedent( + """\ + Here's some code: + + .. code-block:: python + + def foo(): + pass + """ + ), + ] + + for rest_with_code in example_rst_docs: + pkg_info, dist = self.create_dist(long_description=rest_with_code) + cmd = check(dist) + cmd.check_restructuredtext() + msgs = cmd._check_rst_data(rest_with_code) + if pygments is not None: + assert len(msgs) == 0 + else: + assert len(msgs) == 1 + assert ( + str(msgs[0][1]) + == 'Cannot analyze code. Pygments package not found.' + ) + + def test_check_all(self): + with pytest.raises(DistutilsSetupError): + self._run({}, **{'strict': 1, 'restructuredtext': 1}) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_clean.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_clean.py new file mode 100644 index 0000000000000000000000000000000000000000..cc78f30f34b323845b977b9147c2153390774bd3 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_clean.py @@ -0,0 +1,45 @@ +"""Tests for distutils.command.clean.""" + +import os +from distutils.command.clean import clean +from distutils.tests import support + + +class TestClean(support.TempdirManager): + def test_simple_run(self): + pkg_dir, dist = self.create_dist() + cmd = clean(dist) + + # let's add some elements clean should remove + dirs = [ + (d, os.path.join(pkg_dir, d)) + for d in ( + 'build_temp', + 'build_lib', + 'bdist_base', + 'build_scripts', + 'build_base', + ) + ] + + for name, path in dirs: + os.mkdir(path) + setattr(cmd, name, path) + if name == 'build_base': + continue + for f in ('one', 'two', 'three'): + self.write_file(os.path.join(path, f)) + + # let's run the command + cmd.all = 1 + cmd.ensure_finalized() + cmd.run() + + # make sure the files where removed + for _name, path in dirs: + assert not os.path.exists(path), f'{path} was not removed' + + # let's run the command again (should spit warnings but succeed) + cmd.all = 1 + cmd.ensure_finalized() + cmd.run() diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_cmd.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_cmd.py new file mode 100644 index 0000000000000000000000000000000000000000..76e8f5989b3b102a32239436ff3b65f26e09e029 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_cmd.py @@ -0,0 +1,107 @@ +"""Tests for distutils.cmd.""" + +import os +from distutils import debug +from distutils.cmd import Command +from distutils.dist import Distribution +from distutils.errors import DistutilsOptionError + +import pytest + + +class MyCmd(Command): + def initialize_options(self): + pass + + +@pytest.fixture +def cmd(request): + return MyCmd(Distribution()) + + +class TestCommand: + def test_ensure_string_list(self, cmd): + cmd.not_string_list = ['one', 2, 'three'] + cmd.yes_string_list = ['one', 'two', 'three'] + cmd.not_string_list2 = object() + cmd.yes_string_list2 = 'ok' + cmd.ensure_string_list('yes_string_list') + cmd.ensure_string_list('yes_string_list2') + + with pytest.raises(DistutilsOptionError): + cmd.ensure_string_list('not_string_list') + + with pytest.raises(DistutilsOptionError): + cmd.ensure_string_list('not_string_list2') + + cmd.option1 = 'ok,dok' + cmd.ensure_string_list('option1') + assert cmd.option1 == ['ok', 'dok'] + + cmd.option2 = ['xxx', 'www'] + cmd.ensure_string_list('option2') + + cmd.option3 = ['ok', 2] + with pytest.raises(DistutilsOptionError): + cmd.ensure_string_list('option3') + + def test_make_file(self, cmd): + # making sure it raises when infiles is not a string or a list/tuple + with pytest.raises(TypeError): + cmd.make_file(infiles=True, outfile='', func='func', args=()) + + # making sure execute gets called properly + def _execute(func, args, exec_msg, level): + assert exec_msg == 'generating out from in' + + cmd.force = True + cmd.execute = _execute + cmd.make_file(infiles='in', outfile='out', func='func', args=()) + + def test_dump_options(self, cmd): + msgs = [] + + def _announce(msg, level): + msgs.append(msg) + + cmd.announce = _announce + cmd.option1 = 1 + cmd.option2 = 1 + cmd.user_options = [('option1', '', ''), ('option2', '', '')] + cmd.dump_options() + + wanted = ["command options for 'MyCmd':", ' option1 = 1', ' option2 = 1'] + assert msgs == wanted + + def test_ensure_string(self, cmd): + cmd.option1 = 'ok' + cmd.ensure_string('option1') + + cmd.option2 = None + cmd.ensure_string('option2', 'xxx') + assert hasattr(cmd, 'option2') + + cmd.option3 = 1 + with pytest.raises(DistutilsOptionError): + cmd.ensure_string('option3') + + def test_ensure_filename(self, cmd): + cmd.option1 = __file__ + cmd.ensure_filename('option1') + cmd.option2 = 'xxx' + with pytest.raises(DistutilsOptionError): + cmd.ensure_filename('option2') + + def test_ensure_dirname(self, cmd): + cmd.option1 = os.path.dirname(__file__) or os.curdir + cmd.ensure_dirname('option1') + cmd.option2 = 'xxx' + with pytest.raises(DistutilsOptionError): + cmd.ensure_dirname('option2') + + def test_debug_print(self, cmd, capsys, monkeypatch): + cmd.debug_print('xxx') + assert capsys.readouterr().out == '' + monkeypatch.setattr(debug, 'DEBUG', True) + cmd.debug_print('xxx') + assert capsys.readouterr().out == 'xxx\n' diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_config_cmd.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_config_cmd.py new file mode 100644 index 0000000000000000000000000000000000000000..ebee2ef93f0bc9d422984e2e4872665b1be3a1de --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_config_cmd.py @@ -0,0 +1,87 @@ +"""Tests for distutils.command.config.""" + +import os +import sys +from distutils._log import log +from distutils.command.config import config, dump_file +from distutils.tests import missing_compiler_executable, support + +import more_itertools +import path +import pytest + + +@pytest.fixture(autouse=True) +def info_log(request, monkeypatch): + self = request.instance + self._logs = [] + monkeypatch.setattr(log, 'info', self._info) + + +@support.combine_markers +class TestConfig(support.TempdirManager): + def _info(self, msg, *args): + for line in msg.splitlines(): + self._logs.append(line) + + def test_dump_file(self): + this_file = path.Path(__file__).with_suffix('.py') + with this_file.open(encoding='utf-8') as f: + numlines = more_itertools.ilen(f) + + dump_file(this_file, 'I am the header') + assert len(self._logs) == numlines + 1 + + @pytest.mark.skipif('platform.system() == "Windows"') + def test_search_cpp(self): + cmd = missing_compiler_executable(['preprocessor']) + if cmd is not None: + self.skipTest(f'The {cmd!r} command is not found') + pkg_dir, dist = self.create_dist() + cmd = config(dist) + cmd._check_compiler() + compiler = cmd.compiler + if sys.platform[:3] == "aix" and "xlc" in compiler.preprocessor[0].lower(): + self.skipTest( + 'xlc: The -E option overrides the -P, -o, and -qsyntaxonly options' + ) + + # simple pattern searches + match = cmd.search_cpp(pattern='xxx', body='/* xxx */') + assert match == 0 + + match = cmd.search_cpp(pattern='_configtest', body='/* xxx */') + assert match == 1 + + def test_finalize_options(self): + # finalize_options does a bit of transformation + # on options + pkg_dir, dist = self.create_dist() + cmd = config(dist) + cmd.include_dirs = f'one{os.pathsep}two' + cmd.libraries = 'one' + cmd.library_dirs = f'three{os.pathsep}four' + cmd.ensure_finalized() + + assert cmd.include_dirs == ['one', 'two'] + assert cmd.libraries == ['one'] + assert cmd.library_dirs == ['three', 'four'] + + def test_clean(self): + # _clean removes files + tmp_dir = self.mkdtemp() + f1 = os.path.join(tmp_dir, 'one') + f2 = os.path.join(tmp_dir, 'two') + + self.write_file(f1, 'xxx') + self.write_file(f2, 'xxx') + + for f in (f1, f2): + assert os.path.exists(f) + + pkg_dir, dist = self.create_dist() + cmd = config(dist) + cmd._clean(f1, f2) + + for f in (f1, f2): + assert not os.path.exists(f) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_core.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_core.py new file mode 100644 index 0000000000000000000000000000000000000000..bad3fb7e8318d3ee73ecabe20ed98c279f606a77 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_core.py @@ -0,0 +1,130 @@ +"""Tests for distutils.core.""" + +import distutils.core +import io +import os +import sys +from distutils.dist import Distribution + +import pytest + +# setup script that uses __file__ +setup_using___file__ = """\ + +__file__ + +from distutils.core import setup +setup() +""" + +setup_prints_cwd = """\ + +import os +print(os.getcwd()) + +from distutils.core import setup +setup() +""" + +setup_does_nothing = """\ +from distutils.core import setup +setup() +""" + + +setup_defines_subclass = """\ +from distutils.core import setup +from distutils.command.install import install as _install + +class install(_install): + sub_commands = _install.sub_commands + ['cmd'] + +setup(cmdclass={'install': install}) +""" + +setup_within_if_main = """\ +from distutils.core import setup + +def main(): + return setup(name="setup_within_if_main") + +if __name__ == "__main__": + main() +""" + + +@pytest.fixture(autouse=True) +def save_stdout(monkeypatch): + monkeypatch.setattr(sys, 'stdout', sys.stdout) + + +@pytest.fixture +def temp_file(tmp_path): + return tmp_path / 'file' + + +@pytest.mark.usefixtures('save_env') +@pytest.mark.usefixtures('save_argv') +class TestCore: + def test_run_setup_provides_file(self, temp_file): + # Make sure the script can use __file__; if that's missing, the test + # setup.py script will raise NameError. + temp_file.write_text(setup_using___file__, encoding='utf-8') + distutils.core.run_setup(temp_file) + + def test_run_setup_preserves_sys_argv(self, temp_file): + # Make sure run_setup does not clobber sys.argv + argv_copy = sys.argv.copy() + temp_file.write_text(setup_does_nothing, encoding='utf-8') + distutils.core.run_setup(temp_file) + assert sys.argv == argv_copy + + def test_run_setup_defines_subclass(self, temp_file): + # Make sure the script can use __file__; if that's missing, the test + # setup.py script will raise NameError. + temp_file.write_text(setup_defines_subclass, encoding='utf-8') + dist = distutils.core.run_setup(temp_file) + install = dist.get_command_obj('install') + assert 'cmd' in install.sub_commands + + def test_run_setup_uses_current_dir(self, tmp_path): + """ + Test that the setup script is run with the current directory + as its own current directory. + """ + sys.stdout = io.StringIO() + cwd = os.getcwd() + + # Create a directory and write the setup.py file there: + setup_py = tmp_path / 'setup.py' + setup_py.write_text(setup_prints_cwd, encoding='utf-8') + distutils.core.run_setup(setup_py) + + output = sys.stdout.getvalue() + if output.endswith("\n"): + output = output[:-1] + assert cwd == output + + def test_run_setup_within_if_main(self, temp_file): + temp_file.write_text(setup_within_if_main, encoding='utf-8') + dist = distutils.core.run_setup(temp_file, stop_after="config") + assert isinstance(dist, Distribution) + assert dist.get_name() == "setup_within_if_main" + + def test_run_commands(self, temp_file): + sys.argv = ['setup.py', 'build'] + temp_file.write_text(setup_within_if_main, encoding='utf-8') + dist = distutils.core.run_setup(temp_file, stop_after="commandline") + assert 'build' not in dist.have_run + distutils.core.run_commands(dist) + assert 'build' in dist.have_run + + def test_debug_mode(self, capsys, monkeypatch): + # this covers the code called when DEBUG is set + sys.argv = ['setup.py', '--name'] + distutils.core.setup(name='bar') + assert capsys.readouterr().out == 'bar\n' + monkeypatch.setattr(distutils.core, 'DEBUG', True) + distutils.core.setup(name='bar') + wanted = "options (after parsing config files):\n" + assert capsys.readouterr().out.startswith(wanted) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_dir_util.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_dir_util.py new file mode 100644 index 0000000000000000000000000000000000000000..326cb346145ec7e3a1dd0384c33d4125131feaae --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_dir_util.py @@ -0,0 +1,139 @@ +"""Tests for distutils.dir_util.""" + +import os +import pathlib +import stat +import sys +import unittest.mock as mock +from distutils import dir_util, errors +from distutils.dir_util import ( + copy_tree, + create_tree, + ensure_relative, + mkpath, + remove_tree, +) +from distutils.tests import support + +import jaraco.path +import path +import pytest + + +@pytest.fixture(autouse=True) +def stuff(request, monkeypatch, distutils_managed_tempdir): + self = request.instance + tmp_dir = self.mkdtemp() + self.root_target = os.path.join(tmp_dir, 'deep') + self.target = os.path.join(self.root_target, 'here') + self.target2 = os.path.join(tmp_dir, 'deep2') + + +class TestDirUtil(support.TempdirManager): + def test_mkpath_remove_tree_verbosity(self, caplog): + mkpath(self.target, verbose=False) + assert not caplog.records + remove_tree(self.root_target, verbose=False) + + mkpath(self.target, verbose=True) + wanted = [f'creating {self.target}'] + assert caplog.messages == wanted + caplog.clear() + + remove_tree(self.root_target, verbose=True) + wanted = [f"removing '{self.root_target}' (and everything under it)"] + assert caplog.messages == wanted + + @pytest.mark.skipif("platform.system() == 'Windows'") + def test_mkpath_with_custom_mode(self): + # Get and set the current umask value for testing mode bits. + umask = os.umask(0o002) + os.umask(umask) + mkpath(self.target, 0o700) + assert stat.S_IMODE(os.stat(self.target).st_mode) == 0o700 & ~umask + mkpath(self.target2, 0o555) + assert stat.S_IMODE(os.stat(self.target2).st_mode) == 0o555 & ~umask + + def test_create_tree_verbosity(self, caplog): + create_tree(self.root_target, ['one', 'two', 'three'], verbose=False) + assert caplog.messages == [] + remove_tree(self.root_target, verbose=False) + + wanted = [f'creating {self.root_target}'] + create_tree(self.root_target, ['one', 'two', 'three'], verbose=True) + assert caplog.messages == wanted + + remove_tree(self.root_target, verbose=False) + + def test_copy_tree_verbosity(self, caplog): + mkpath(self.target, verbose=False) + + copy_tree(self.target, self.target2, verbose=False) + assert caplog.messages == [] + + remove_tree(self.root_target, verbose=False) + + mkpath(self.target, verbose=False) + a_file = path.Path(self.target) / 'ok.txt' + jaraco.path.build({'ok.txt': 'some content'}, self.target) + + wanted = [f'copying {a_file} -> {self.target2}'] + copy_tree(self.target, self.target2, verbose=True) + assert caplog.messages == wanted + + remove_tree(self.root_target, verbose=False) + remove_tree(self.target2, verbose=False) + + def test_copy_tree_skips_nfs_temp_files(self): + mkpath(self.target, verbose=False) + + jaraco.path.build({'ok.txt': 'some content', '.nfs123abc': ''}, self.target) + + copy_tree(self.target, self.target2) + assert os.listdir(self.target2) == ['ok.txt'] + + remove_tree(self.root_target, verbose=False) + remove_tree(self.target2, verbose=False) + + def test_ensure_relative(self): + if os.sep == '/': + assert ensure_relative('/home/foo') == 'home/foo' + assert ensure_relative('some/path') == 'some/path' + else: # \\ + assert ensure_relative('c:\\home\\foo') == 'c:home\\foo' + assert ensure_relative('home\\foo') == 'home\\foo' + + def test_copy_tree_exception_in_listdir(self): + """ + An exception in listdir should raise a DistutilsFileError + """ + with ( + mock.patch("os.listdir", side_effect=OSError()), + pytest.raises(errors.DistutilsFileError), + ): + src = self.tempdirs[-1] + dir_util.copy_tree(src, None) + + def test_mkpath_exception_uncached(self, monkeypatch, tmp_path): + """ + Caching should not remember failed attempts. + + pypa/distutils#304 + """ + + class FailPath(pathlib.Path): + def mkdir(self, *args, **kwargs): + raise OSError("Failed to create directory") + + if sys.version_info < (3, 12): + _flavour = pathlib.Path()._flavour + + target = tmp_path / 'foodir' + + with pytest.raises(errors.DistutilsFileError): + mkpath(FailPath(target)) + + assert not target.exists() + + mkpath(target) + assert target.exists() diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_dist.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_dist.py new file mode 100644 index 0000000000000000000000000000000000000000..2c5beebe64eb9d747088cf117082a546330b29f3 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_dist.py @@ -0,0 +1,552 @@ +"""Tests for distutils.dist.""" + +import email +import email.generator +import email.policy +import functools +import io +import os +import sys +import textwrap +import unittest.mock as mock +import warnings +from distutils.cmd import Command +from distutils.dist import Distribution, fix_help_options +from distutils.tests import support +from typing import ClassVar + +import jaraco.path +import pytest + +pydistutils_cfg = '.' * (os.name == 'posix') + 'pydistutils.cfg' + + +class test_dist(Command): + """Sample distutils extension command.""" + + user_options: ClassVar[list[tuple[str, str, str]]] = [ + ("sample-option=", "S", "help text"), + ] + + def initialize_options(self): + self.sample_option = None + + +class TestDistribution(Distribution): + """Distribution subclasses that avoids the default search for + configuration files. + + The ._config_files attribute must be set before + .parse_config_files() is called. + """ + + def find_config_files(self): + return self._config_files + + +@pytest.fixture +def clear_argv(): + del sys.argv[1:] + + +@support.combine_markers +@pytest.mark.usefixtures('save_env') +@pytest.mark.usefixtures('save_argv') +class TestDistributionBehavior(support.TempdirManager): + def create_distribution(self, configfiles=()): + d = TestDistribution() + d._config_files = configfiles + d.parse_config_files() + d.parse_command_line() + return d + + def test_command_packages_unspecified(self, clear_argv): + sys.argv.append("build") + d = self.create_distribution() + assert d.get_command_packages() == ["distutils.command"] + + def test_command_packages_cmdline(self, clear_argv): + from distutils.tests.test_dist import test_dist + + sys.argv.extend([ + "--command-packages", + "foo.bar,distutils.tests", + "test_dist", + "-Ssometext", + ]) + d = self.create_distribution() + # let's actually try to load our test command: + assert d.get_command_packages() == [ + "distutils.command", + "foo.bar", + "distutils.tests", + ] + cmd = d.get_command_obj("test_dist") + assert isinstance(cmd, test_dist) + assert cmd.sample_option == "sometext" + + @pytest.mark.skipif( + 'distutils' not in Distribution.parse_config_files.__module__, + reason='Cannot test when virtualenv has monkey-patched Distribution', + ) + def test_venv_install_options(self, tmp_path, clear_argv): + sys.argv.append("install") + file = str(tmp_path / 'file') + + fakepath = '/somedir' + + jaraco.path.build({ + file: f""" + [install] + install-base = {fakepath} + install-platbase = {fakepath} + install-lib = {fakepath} + install-platlib = {fakepath} + install-purelib = {fakepath} + install-headers = {fakepath} + install-scripts = {fakepath} + install-data = {fakepath} + prefix = {fakepath} + exec-prefix = {fakepath} + home = {fakepath} + user = {fakepath} + root = {fakepath} + """, + }) + + # Base case: Not in a Virtual Environment + with mock.patch.multiple(sys, prefix='/a', base_prefix='/a'): + d = self.create_distribution([file]) + + option_tuple = (file, fakepath) + + result_dict = { + 'install_base': option_tuple, + 'install_platbase': option_tuple, + 'install_lib': option_tuple, + 'install_platlib': option_tuple, + 'install_purelib': option_tuple, + 'install_headers': option_tuple, + 'install_scripts': option_tuple, + 'install_data': option_tuple, + 'prefix': option_tuple, + 'exec_prefix': option_tuple, + 'home': option_tuple, + 'user': option_tuple, + 'root': option_tuple, + } + + assert sorted(d.command_options.get('install').keys()) == sorted( + result_dict.keys() + ) + + for key, value in d.command_options.get('install').items(): + assert value == result_dict[key] + + # Test case: In a Virtual Environment + with mock.patch.multiple(sys, prefix='/a', base_prefix='/b'): + d = self.create_distribution([file]) + + for key in result_dict.keys(): + assert key not in d.command_options.get('install', {}) + + def test_command_packages_configfile(self, tmp_path, clear_argv): + sys.argv.append("build") + file = str(tmp_path / "file") + jaraco.path.build({ + file: """ + [global] + command_packages = foo.bar, splat + """, + }) + + d = self.create_distribution([file]) + assert d.get_command_packages() == ["distutils.command", "foo.bar", "splat"] + + # ensure command line overrides config: + sys.argv[1:] = ["--command-packages", "spork", "build"] + d = self.create_distribution([file]) + assert d.get_command_packages() == ["distutils.command", "spork"] + + # Setting --command-packages to '' should cause the default to + # be used even if a config file specified something else: + sys.argv[1:] = ["--command-packages", "", "build"] + d = self.create_distribution([file]) + assert d.get_command_packages() == ["distutils.command"] + + def test_empty_options(self, request): + # an empty options dictionary should not stay in the + # list of attributes + + # catching warnings + warns = [] + + def _warn(msg): + warns.append(msg) + + request.addfinalizer( + functools.partial(setattr, warnings, 'warn', warnings.warn) + ) + warnings.warn = _warn + dist = Distribution( + attrs={ + 'author': 'xxx', + 'name': 'xxx', + 'version': 'xxx', + 'url': 'xxxx', + 'options': {}, + } + ) + + assert len(warns) == 0 + assert 'options' not in dir(dist) + + def test_finalize_options(self): + attrs = {'keywords': 'one,two', 'platforms': 'one,two'} + + dist = Distribution(attrs=attrs) + dist.finalize_options() + + # finalize_option splits platforms and keywords + assert dist.metadata.platforms == ['one', 'two'] + assert dist.metadata.keywords == ['one', 'two'] + + attrs = {'keywords': 'foo bar', 'platforms': 'foo bar'} + dist = Distribution(attrs=attrs) + dist.finalize_options() + assert dist.metadata.platforms == ['foo bar'] + assert dist.metadata.keywords == ['foo bar'] + + def test_get_command_packages(self): + dist = Distribution() + assert dist.command_packages is None + cmds = dist.get_command_packages() + assert cmds == ['distutils.command'] + assert dist.command_packages == ['distutils.command'] + + dist.command_packages = 'one,two' + cmds = dist.get_command_packages() + assert cmds == ['distutils.command', 'one', 'two'] + + def test_announce(self): + # make sure the level is known + dist = Distribution() + with pytest.raises(TypeError): + dist.announce('ok', level='ok2') + + def test_find_config_files_disable(self, temp_home): + # Ticket #1180: Allow user to disable their home config file. + jaraco.path.build({pydistutils_cfg: '[distutils]\n'}, temp_home) + + d = Distribution() + all_files = d.find_config_files() + + d = Distribution(attrs={'script_args': ['--no-user-cfg']}) + files = d.find_config_files() + + # make sure --no-user-cfg disables the user cfg file + assert len(all_files) - 1 == len(files) + + def test_script_args_list_coercion(self): + d = Distribution(attrs={'script_args': ('build', '--no-user-cfg')}) + + # make sure script_args is a list even if it started as a different iterable + assert d.script_args == ['build', '--no-user-cfg'] + + @pytest.mark.skipif( + 'platform.system() == "Windows"', + reason='Windows does not honor chmod 000', + ) + def test_find_config_files_permission_error(self, fake_home): + """ + Finding config files should not fail when directory is inaccessible. + """ + fake_home.joinpath(pydistutils_cfg).write_text('', encoding='utf-8') + fake_home.chmod(0o000) + Distribution().find_config_files() + + +@pytest.mark.usefixtures('save_env') +@pytest.mark.usefixtures('save_argv') +class TestMetadata(support.TempdirManager): + def format_metadata(self, dist): + sio = io.StringIO() + dist.metadata.write_pkg_file(sio) + return sio.getvalue() + + def test_simple_metadata(self): + attrs = {"name": "package", "version": "1.0"} + dist = Distribution(attrs) + meta = self.format_metadata(dist) + assert "Metadata-Version: 1.0" in meta + assert "provides:" not in meta.lower() + assert "requires:" not in meta.lower() + assert "obsoletes:" not in meta.lower() + + def test_provides(self): + attrs = { + "name": "package", + "version": "1.0", + "provides": ["package", "package.sub"], + } + dist = Distribution(attrs) + assert dist.metadata.get_provides() == ["package", "package.sub"] + assert dist.get_provides() == ["package", "package.sub"] + meta = self.format_metadata(dist) + assert "Metadata-Version: 1.1" in meta + assert "requires:" not in meta.lower() + assert "obsoletes:" not in meta.lower() + + def test_provides_illegal(self): + with pytest.raises(ValueError): + Distribution( + {"name": "package", "version": "1.0", "provides": ["my.pkg (splat)"]}, + ) + + def test_requires(self): + attrs = { + "name": "package", + "version": "1.0", + "requires": ["other", "another (==1.0)"], + } + dist = Distribution(attrs) + assert dist.metadata.get_requires() == ["other", "another (==1.0)"] + assert dist.get_requires() == ["other", "another (==1.0)"] + meta = self.format_metadata(dist) + assert "Metadata-Version: 1.1" in meta + assert "provides:" not in meta.lower() + assert "Requires: other" in meta + assert "Requires: another (==1.0)" in meta + assert "obsoletes:" not in meta.lower() + + def test_requires_illegal(self): + with pytest.raises(ValueError): + Distribution( + {"name": "package", "version": "1.0", "requires": ["my.pkg (splat)"]}, + ) + + def test_requires_to_list(self): + attrs = {"name": "package", "requires": iter(["other"])} + dist = Distribution(attrs) + assert isinstance(dist.metadata.requires, list) + + def test_obsoletes(self): + attrs = { + "name": "package", + "version": "1.0", + "obsoletes": ["other", "another (<1.0)"], + } + dist = Distribution(attrs) + assert dist.metadata.get_obsoletes() == ["other", "another (<1.0)"] + assert dist.get_obsoletes() == ["other", "another (<1.0)"] + meta = self.format_metadata(dist) + assert "Metadata-Version: 1.1" in meta + assert "provides:" not in meta.lower() + assert "requires:" not in meta.lower() + assert "Obsoletes: other" in meta + assert "Obsoletes: another (<1.0)" in meta + + def test_obsoletes_illegal(self): + with pytest.raises(ValueError): + Distribution( + {"name": "package", "version": "1.0", "obsoletes": ["my.pkg (splat)"]}, + ) + + def test_obsoletes_to_list(self): + attrs = {"name": "package", "obsoletes": iter(["other"])} + dist = Distribution(attrs) + assert isinstance(dist.metadata.obsoletes, list) + + def test_classifier(self): + attrs = { + 'name': 'Boa', + 'version': '3.0', + 'classifiers': ['Programming Language :: Python :: 3'], + } + dist = Distribution(attrs) + assert dist.get_classifiers() == ['Programming Language :: Python :: 3'] + meta = self.format_metadata(dist) + assert 'Metadata-Version: 1.1' in meta + + def test_classifier_invalid_type(self, caplog): + attrs = { + 'name': 'Boa', + 'version': '3.0', + 'classifiers': ('Programming Language :: Python :: 3',), + } + d = Distribution(attrs) + # should have warning about passing a non-list + assert 'should be a list' in caplog.messages[0] + # should be converted to a list + assert isinstance(d.metadata.classifiers, list) + assert d.metadata.classifiers == list(attrs['classifiers']) + + def test_keywords(self): + attrs = { + 'name': 'Monty', + 'version': '1.0', + 'keywords': ['spam', 'eggs', 'life of brian'], + } + dist = Distribution(attrs) + assert dist.get_keywords() == ['spam', 'eggs', 'life of brian'] + + def test_keywords_invalid_type(self, caplog): + attrs = { + 'name': 'Monty', + 'version': '1.0', + 'keywords': ('spam', 'eggs', 'life of brian'), + } + d = Distribution(attrs) + # should have warning about passing a non-list + assert 'should be a list' in caplog.messages[0] + # should be converted to a list + assert isinstance(d.metadata.keywords, list) + assert d.metadata.keywords == list(attrs['keywords']) + + def test_platforms(self): + attrs = { + 'name': 'Monty', + 'version': '1.0', + 'platforms': ['GNU/Linux', 'Some Evil Platform'], + } + dist = Distribution(attrs) + assert dist.get_platforms() == ['GNU/Linux', 'Some Evil Platform'] + + def test_platforms_invalid_types(self, caplog): + attrs = { + 'name': 'Monty', + 'version': '1.0', + 'platforms': ('GNU/Linux', 'Some Evil Platform'), + } + d = Distribution(attrs) + # should have warning about passing a non-list + assert 'should be a list' in caplog.messages[0] + # should be converted to a list + assert isinstance(d.metadata.platforms, list) + assert d.metadata.platforms == list(attrs['platforms']) + + def test_download_url(self): + attrs = { + 'name': 'Boa', + 'version': '3.0', + 'download_url': 'http://example.org/boa', + } + dist = Distribution(attrs) + meta = self.format_metadata(dist) + assert 'Metadata-Version: 1.1' in meta + + def test_long_description(self): + long_desc = textwrap.dedent( + """\ + example:: + We start here + and continue here + and end here.""" + ) + attrs = {"name": "package", "version": "1.0", "long_description": long_desc} + + dist = Distribution(attrs) + meta = self.format_metadata(dist) + meta = meta.replace('\n' + 8 * ' ', '\n') + assert long_desc in meta + + def test_custom_pydistutils(self, temp_home): + """ + pydistutils.cfg is found + """ + jaraco.path.build({pydistutils_cfg: ''}, temp_home) + config_path = temp_home / pydistutils_cfg + + assert str(config_path) in Distribution().find_config_files() + + def test_extra_pydistutils(self, monkeypatch, tmp_path): + jaraco.path.build({'overrides.cfg': ''}, tmp_path) + filename = tmp_path / 'overrides.cfg' + monkeypatch.setenv('DIST_EXTRA_CONFIG', str(filename)) + assert str(filename) in Distribution().find_config_files() + + def test_fix_help_options(self): + help_tuples = [('a', 'b', 'c', 'd'), (1, 2, 3, 4)] + fancy_options = fix_help_options(help_tuples) + assert fancy_options[0] == ('a', 'b', 'c') + assert fancy_options[1] == (1, 2, 3) + + def test_show_help(self, request, capsys): + # smoke test, just makes sure some help is displayed + dist = Distribution() + sys.argv = [] + dist.help = True + dist.script_name = 'setup.py' + dist.parse_command_line() + + output = [ + line for line in capsys.readouterr().out.split('\n') if line.strip() != '' + ] + assert output + + def test_read_metadata(self): + attrs = { + "name": "package", + "version": "1.0", + "long_description": "desc", + "description": "xxx", + "download_url": "http://example.com", + "keywords": ['one', 'two'], + "requires": ['foo'], + } + + dist = Distribution(attrs) + metadata = dist.metadata + + # write it then reloads it + PKG_INFO = io.StringIO() + metadata.write_pkg_file(PKG_INFO) + PKG_INFO.seek(0) + metadata.read_pkg_file(PKG_INFO) + + assert metadata.name == "package" + assert metadata.version == "1.0" + assert metadata.description == "xxx" + assert metadata.download_url == 'http://example.com' + assert metadata.keywords == ['one', 'two'] + assert metadata.platforms is None + assert metadata.obsoletes is None + assert metadata.requires == ['foo'] + + def test_round_trip_through_email_generator(self): + """ + In pypa/setuptools#4033, it was shown that once PKG-INFO is + re-generated using ``email.generator.Generator``, some control + characters might cause problems. + """ + # Given a PKG-INFO file ... + attrs = { + "name": "package", + "version": "1.0", + "long_description": "hello\x0b\nworld\n", + } + dist = Distribution(attrs) + metadata = dist.metadata + + with io.StringIO() as buffer: + metadata.write_pkg_file(buffer) + msg = buffer.getvalue() + + # ... when it is read and re-written using stdlib's email library, + orig = email.message_from_string(msg) + policy = email.policy.EmailPolicy( + utf8=True, + mangle_from_=False, + max_line_length=0, + ) + with io.StringIO() as buffer: + email.generator.Generator(buffer, policy=policy).flatten(orig) + + buffer.seek(0) + regen = email.message_from_file(buffer) + + # ... then it should be the same as the original + # (except for the specific line break characters) + orig_desc = set(orig["Description"].splitlines()) + regen_desc = set(regen["Description"].splitlines()) + assert regen_desc == orig_desc diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_extension.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_extension.py new file mode 100644 index 0000000000000000000000000000000000000000..5e8e768223ea40d7a629111db181a946cf8ca5b0 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_extension.py @@ -0,0 +1,117 @@ +"""Tests for distutils.extension.""" + +import os +import pathlib +import warnings +from distutils.extension import Extension, read_setup_file + +import pytest +from test.support.warnings_helper import check_warnings + + +class TestExtension: + def test_read_setup_file(self): + # trying to read a Setup file + # (sample extracted from the PyGame project) + setup = os.path.join(os.path.dirname(__file__), 'Setup.sample') + + exts = read_setup_file(setup) + names = [ext.name for ext in exts] + names.sort() + + # here are the extensions read_setup_file should have created + # out of the file + wanted = [ + '_arraysurfarray', + '_camera', + '_numericsndarray', + '_numericsurfarray', + 'base', + 'bufferproxy', + 'cdrom', + 'color', + 'constants', + 'display', + 'draw', + 'event', + 'fastevent', + 'font', + 'gfxdraw', + 'image', + 'imageext', + 'joystick', + 'key', + 'mask', + 'mixer', + 'mixer_music', + 'mouse', + 'movie', + 'overlay', + 'pixelarray', + 'pypm', + 'rect', + 'rwobject', + 'scrap', + 'surface', + 'surflock', + 'time', + 'transform', + ] + + assert names == wanted + + def test_extension_init(self): + # the first argument, which is the name, must be a string + with pytest.raises(TypeError): + Extension(1, []) + ext = Extension('name', []) + assert ext.name == 'name' + + # the second argument, which is the list of files, must + # be an iterable of strings or PathLike objects, and not a string + with pytest.raises(TypeError): + Extension('name', 'file') + with pytest.raises(TypeError): + Extension('name', ['file', 1]) + ext = Extension('name', ['file1', 'file2']) + assert ext.sources == ['file1', 'file2'] + ext = Extension('name', [pathlib.Path('file1'), pathlib.Path('file2')]) + assert ext.sources == ['file1', 'file2'] + + # any non-string iterable of strings or PathLike objects should work + ext = Extension('name', ('file1', 'file2')) # tuple + assert ext.sources == ['file1', 'file2'] + ext = Extension('name', {'file1', 'file2'}) # set + assert sorted(ext.sources) == ['file1', 'file2'] + ext = Extension('name', iter(['file1', 'file2'])) # iterator + assert ext.sources == ['file1', 'file2'] + ext = Extension('name', [pathlib.Path('file1'), 'file2']) # mixed types + assert ext.sources == ['file1', 'file2'] + + # others arguments have defaults + for attr in ( + 'include_dirs', + 'define_macros', + 'undef_macros', + 'library_dirs', + 'libraries', + 'runtime_library_dirs', + 'extra_objects', + 'extra_compile_args', + 'extra_link_args', + 'export_symbols', + 'swig_opts', + 'depends', + ): + assert getattr(ext, attr) == [] + + assert ext.language is None + assert ext.optional is None + + # if there are unknown keyword options, warn about them + with check_warnings() as w: + warnings.simplefilter('always') + ext = Extension('name', ['file1', 'file2'], chic=True) + + assert len(w.warnings) == 1 + assert str(w.warnings[0].message) == "Unknown Extension options: 'chic'" diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_file_util.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_file_util.py new file mode 100644 index 0000000000000000000000000000000000000000..a75d4a0317dc717c24f67127370aa87089eeba1a --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_file_util.py @@ -0,0 +1,95 @@ +"""Tests for distutils.file_util.""" + +import errno +import os +import unittest.mock as mock +from distutils.errors import DistutilsFileError +from distutils.file_util import copy_file, move_file + +import jaraco.path +import pytest + + +@pytest.fixture(autouse=True) +def stuff(request, tmp_path): + self = request.instance + self.source = tmp_path / 'f1' + self.target = tmp_path / 'f2' + self.target_dir = tmp_path / 'd1' + + +class TestFileUtil: + def test_move_file_verbosity(self, caplog): + jaraco.path.build({self.source: 'some content'}) + + move_file(self.source, self.target, verbose=False) + assert not caplog.messages + + # back to original state + move_file(self.target, self.source, verbose=False) + + move_file(self.source, self.target, verbose=True) + wanted = [f'moving {self.source} -> {self.target}'] + assert caplog.messages == wanted + + # back to original state + move_file(self.target, self.source, verbose=False) + + caplog.clear() + # now the target is a dir + os.mkdir(self.target_dir) + move_file(self.source, self.target_dir, verbose=True) + wanted = [f'moving {self.source} -> {self.target_dir}'] + assert caplog.messages == wanted + + def test_move_file_exception_unpacking_rename(self): + # see issue 22182 + with ( + mock.patch("os.rename", side_effect=OSError("wrong", 1)), + pytest.raises(DistutilsFileError), + ): + jaraco.path.build({self.source: 'spam eggs'}) + move_file(self.source, self.target, verbose=False) + + def test_move_file_exception_unpacking_unlink(self): + # see issue 22182 + with ( + mock.patch("os.rename", side_effect=OSError(errno.EXDEV, "wrong")), + mock.patch("os.unlink", side_effect=OSError("wrong", 1)), + pytest.raises(DistutilsFileError), + ): + jaraco.path.build({self.source: 'spam eggs'}) + move_file(self.source, self.target, verbose=False) + + def test_copy_file_hard_link(self): + jaraco.path.build({self.source: 'some content'}) + # Check first that copy_file() will not fall back on copying the file + # instead of creating the hard link. + try: + os.link(self.source, self.target) + except OSError as e: + self.skipTest(f'os.link: {e}') + else: + self.target.unlink() + st = os.stat(self.source) + copy_file(self.source, self.target, link='hard') + st2 = os.stat(self.source) + st3 = os.stat(self.target) + assert os.path.samestat(st, st2), (st, st2) + assert os.path.samestat(st2, st3), (st2, st3) + assert self.source.read_text(encoding='utf-8') == 'some content' + + def test_copy_file_hard_link_failure(self): + # If hard linking fails, copy_file() falls back on copying file + # (some special filesystems don't support hard linking even under + # Unix, see issue #8876). + jaraco.path.build({self.source: 'some content'}) + st = os.stat(self.source) + with mock.patch("os.link", side_effect=OSError(0, "linking unsupported")): + copy_file(self.source, self.target, link='hard') + st2 = os.stat(self.source) + st3 = os.stat(self.target) + assert os.path.samestat(st, st2), (st, st2) + assert not os.path.samestat(st2, st3), (st2, st3) + for fn in (self.source, self.target): + assert fn.read_text(encoding='utf-8') == 'some content' diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_filelist.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_filelist.py new file mode 100644 index 0000000000000000000000000000000000000000..130e6fb53b0bd9670bdcfe6d4bc7fcf8fd90416e --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_filelist.py @@ -0,0 +1,336 @@ +"""Tests for distutils.filelist.""" + +import logging +import os +import re +from distutils import debug, filelist +from distutils.errors import DistutilsTemplateError +from distutils.filelist import FileList, glob_to_re, translate_pattern + +import jaraco.path +import pytest + +from .compat import py39 as os_helper + +MANIFEST_IN = """\ +include ok +include xo +exclude xo +include foo.tmp +include buildout.cfg +global-include *.x +global-include *.txt +global-exclude *.tmp +recursive-include f *.oo +recursive-exclude global *.x +graft dir +prune dir3 +""" + + +def make_local_path(s): + """Converts '/' in a string to os.sep""" + return s.replace('/', os.sep) + + +class TestFileList: + def assertNoWarnings(self, caplog): + warnings = [rec for rec in caplog.records if rec.levelno == logging.WARNING] + assert not warnings + caplog.clear() + + def assertWarnings(self, caplog): + warnings = [rec for rec in caplog.records if rec.levelno == logging.WARNING] + assert warnings + caplog.clear() + + def test_glob_to_re(self): + sep = os.sep + if os.sep == '\\': + sep = re.escape(os.sep) + + for glob, regex in ( + # simple cases + ('foo*', r'(?s:foo[^%(sep)s]*)\Z'), + ('foo?', r'(?s:foo[^%(sep)s])\Z'), + ('foo??', r'(?s:foo[^%(sep)s][^%(sep)s])\Z'), + # special cases + (r'foo\\*', r'(?s:foo\\\\[^%(sep)s]*)\Z'), + (r'foo\\\*', r'(?s:foo\\\\\\[^%(sep)s]*)\Z'), + ('foo????', r'(?s:foo[^%(sep)s][^%(sep)s][^%(sep)s][^%(sep)s])\Z'), + (r'foo\\??', r'(?s:foo\\\\[^%(sep)s][^%(sep)s])\Z'), + ): + regex = regex % {'sep': sep} + assert glob_to_re(glob) == regex + + def test_process_template_line(self): + # testing all MANIFEST.in template patterns + file_list = FileList() + mlp = make_local_path + + # simulated file list + file_list.allfiles = [ + 'foo.tmp', + 'ok', + 'xo', + 'four.txt', + 'buildout.cfg', + # filelist does not filter out VCS directories, + # it's sdist that does + mlp('.hg/last-message.txt'), + mlp('global/one.txt'), + mlp('global/two.txt'), + mlp('global/files.x'), + mlp('global/here.tmp'), + mlp('f/o/f.oo'), + mlp('dir/graft-one'), + mlp('dir/dir2/graft2'), + mlp('dir3/ok'), + mlp('dir3/sub/ok.txt'), + ] + + for line in MANIFEST_IN.split('\n'): + if line.strip() == '': + continue + file_list.process_template_line(line) + + wanted = [ + 'ok', + 'buildout.cfg', + 'four.txt', + mlp('.hg/last-message.txt'), + mlp('global/one.txt'), + mlp('global/two.txt'), + mlp('f/o/f.oo'), + mlp('dir/graft-one'), + mlp('dir/dir2/graft2'), + ] + + assert file_list.files == wanted + + def test_debug_print(self, capsys, monkeypatch): + file_list = FileList() + file_list.debug_print('xxx') + assert capsys.readouterr().out == '' + + monkeypatch.setattr(debug, 'DEBUG', True) + file_list.debug_print('xxx') + assert capsys.readouterr().out == 'xxx\n' + + def test_set_allfiles(self): + file_list = FileList() + files = ['a', 'b', 'c'] + file_list.set_allfiles(files) + assert file_list.allfiles == files + + def test_remove_duplicates(self): + file_list = FileList() + file_list.files = ['a', 'b', 'a', 'g', 'c', 'g'] + # files must be sorted beforehand (sdist does it) + file_list.sort() + file_list.remove_duplicates() + assert file_list.files == ['a', 'b', 'c', 'g'] + + def test_translate_pattern(self): + # not regex + assert hasattr(translate_pattern('a', anchor=True, is_regex=False), 'search') + + # is a regex + regex = re.compile('a') + assert translate_pattern(regex, anchor=True, is_regex=True) == regex + + # plain string flagged as regex + assert hasattr(translate_pattern('a', anchor=True, is_regex=True), 'search') + + # glob support + assert translate_pattern('*.py', anchor=True, is_regex=False).search( + 'filelist.py' + ) + + def test_exclude_pattern(self): + # return False if no match + file_list = FileList() + assert not file_list.exclude_pattern('*.py') + + # return True if files match + file_list = FileList() + file_list.files = ['a.py', 'b.py'] + assert file_list.exclude_pattern('*.py') + + # test excludes + file_list = FileList() + file_list.files = ['a.py', 'a.txt'] + file_list.exclude_pattern('*.py') + assert file_list.files == ['a.txt'] + + def test_include_pattern(self): + # return False if no match + file_list = FileList() + file_list.set_allfiles([]) + assert not file_list.include_pattern('*.py') + + # return True if files match + file_list = FileList() + file_list.set_allfiles(['a.py', 'b.txt']) + assert file_list.include_pattern('*.py') + + # test * matches all files + file_list = FileList() + assert file_list.allfiles is None + file_list.set_allfiles(['a.py', 'b.txt']) + file_list.include_pattern('*') + assert file_list.allfiles == ['a.py', 'b.txt'] + + def test_process_template(self, caplog): + mlp = make_local_path + # invalid lines + file_list = FileList() + for action in ( + 'include', + 'exclude', + 'global-include', + 'global-exclude', + 'recursive-include', + 'recursive-exclude', + 'graft', + 'prune', + 'blarg', + ): + with pytest.raises(DistutilsTemplateError): + file_list.process_template_line(action) + + # include + file_list = FileList() + file_list.set_allfiles(['a.py', 'b.txt', mlp('d/c.py')]) + + file_list.process_template_line('include *.py') + assert file_list.files == ['a.py'] + self.assertNoWarnings(caplog) + + file_list.process_template_line('include *.rb') + assert file_list.files == ['a.py'] + self.assertWarnings(caplog) + + # exclude + file_list = FileList() + file_list.files = ['a.py', 'b.txt', mlp('d/c.py')] + + file_list.process_template_line('exclude *.py') + assert file_list.files == ['b.txt', mlp('d/c.py')] + self.assertNoWarnings(caplog) + + file_list.process_template_line('exclude *.rb') + assert file_list.files == ['b.txt', mlp('d/c.py')] + self.assertWarnings(caplog) + + # global-include + file_list = FileList() + file_list.set_allfiles(['a.py', 'b.txt', mlp('d/c.py')]) + + file_list.process_template_line('global-include *.py') + assert file_list.files == ['a.py', mlp('d/c.py')] + self.assertNoWarnings(caplog) + + file_list.process_template_line('global-include *.rb') + assert file_list.files == ['a.py', mlp('d/c.py')] + self.assertWarnings(caplog) + + # global-exclude + file_list = FileList() + file_list.files = ['a.py', 'b.txt', mlp('d/c.py')] + + file_list.process_template_line('global-exclude *.py') + assert file_list.files == ['b.txt'] + self.assertNoWarnings(caplog) + + file_list.process_template_line('global-exclude *.rb') + assert file_list.files == ['b.txt'] + self.assertWarnings(caplog) + + # recursive-include + file_list = FileList() + file_list.set_allfiles(['a.py', mlp('d/b.py'), mlp('d/c.txt'), mlp('d/d/e.py')]) + + file_list.process_template_line('recursive-include d *.py') + assert file_list.files == [mlp('d/b.py'), mlp('d/d/e.py')] + self.assertNoWarnings(caplog) + + file_list.process_template_line('recursive-include e *.py') + assert file_list.files == [mlp('d/b.py'), mlp('d/d/e.py')] + self.assertWarnings(caplog) + + # recursive-exclude + file_list = FileList() + file_list.files = ['a.py', mlp('d/b.py'), mlp('d/c.txt'), mlp('d/d/e.py')] + + file_list.process_template_line('recursive-exclude d *.py') + assert file_list.files == ['a.py', mlp('d/c.txt')] + self.assertNoWarnings(caplog) + + file_list.process_template_line('recursive-exclude e *.py') + assert file_list.files == ['a.py', mlp('d/c.txt')] + self.assertWarnings(caplog) + + # graft + file_list = FileList() + file_list.set_allfiles(['a.py', mlp('d/b.py'), mlp('d/d/e.py'), mlp('f/f.py')]) + + file_list.process_template_line('graft d') + assert file_list.files == [mlp('d/b.py'), mlp('d/d/e.py')] + self.assertNoWarnings(caplog) + + file_list.process_template_line('graft e') + assert file_list.files == [mlp('d/b.py'), mlp('d/d/e.py')] + self.assertWarnings(caplog) + + # prune + file_list = FileList() + file_list.files = ['a.py', mlp('d/b.py'), mlp('d/d/e.py'), mlp('f/f.py')] + + file_list.process_template_line('prune d') + assert file_list.files == ['a.py', mlp('f/f.py')] + self.assertNoWarnings(caplog) + + file_list.process_template_line('prune e') + assert file_list.files == ['a.py', mlp('f/f.py')] + self.assertWarnings(caplog) + + +class TestFindAll: + @os_helper.skip_unless_symlink + def test_missing_symlink(self, temp_cwd): + os.symlink('foo', 'bar') + assert filelist.findall() == [] + + def test_basic_discovery(self, temp_cwd): + """ + When findall is called with no parameters or with + '.' as the parameter, the dot should be omitted from + the results. + """ + jaraco.path.build({'foo': {'file1.txt': ''}, 'bar': {'file2.txt': ''}}) + file1 = os.path.join('foo', 'file1.txt') + file2 = os.path.join('bar', 'file2.txt') + expected = [file2, file1] + assert sorted(filelist.findall()) == expected + + def test_non_local_discovery(self, tmp_path): + """ + When findall is called with another path, the full + path name should be returned. + """ + jaraco.path.build({'file1.txt': ''}, tmp_path) + expected = [str(tmp_path / 'file1.txt')] + assert filelist.findall(tmp_path) == expected + + @os_helper.skip_unless_symlink + def test_symlink_loop(self, tmp_path): + jaraco.path.build( + { + 'link-to-parent': jaraco.path.Symlink('.'), + 'somefile': '', + }, + tmp_path, + ) + files = filelist.findall(tmp_path) + assert len(files) == 1 diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install.py new file mode 100644 index 0000000000000000000000000000000000000000..b3ffb2e668ac5a042c5a2889d7b51b5755b73157 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install.py @@ -0,0 +1,245 @@ +"""Tests for distutils.command.install.""" + +import logging +import os +import pathlib +import site +import sys +from distutils import sysconfig +from distutils.command import install as install_module +from distutils.command.build_ext import build_ext +from distutils.command.install import INSTALL_SCHEMES, install +from distutils.core import Distribution +from distutils.errors import DistutilsOptionError +from distutils.extension import Extension +from distutils.tests import missing_compiler_executable, support +from distutils.util import is_mingw + +import pytest + + +def _make_ext_name(modname): + return modname + sysconfig.get_config_var('EXT_SUFFIX') + + +@support.combine_markers +@pytest.mark.usefixtures('save_env') +class TestInstall( + support.TempdirManager, +): + @pytest.mark.xfail( + 'platform.system() == "Windows" and sys.version_info > (3, 11)', + reason="pypa/distutils#148", + ) + def test_home_installation_scheme(self): + # This ensure two things: + # - that --home generates the desired set of directory names + # - test --home is supported on all platforms + builddir = self.mkdtemp() + destination = os.path.join(builddir, "installation") + + dist = Distribution({"name": "foopkg"}) + # script_name need not exist, it just need to be initialized + dist.script_name = os.path.join(builddir, "setup.py") + dist.command_obj["build"] = support.DummyCommand( + build_base=builddir, + build_lib=os.path.join(builddir, "lib"), + ) + + cmd = install(dist) + cmd.home = destination + cmd.ensure_finalized() + + assert cmd.install_base == destination + assert cmd.install_platbase == destination + + def check_path(got, expected): + got = os.path.normpath(got) + expected = os.path.normpath(expected) + assert got == expected + + impl_name = sys.implementation.name.replace("cpython", "python") + libdir = os.path.join(destination, "lib", impl_name) + check_path(cmd.install_lib, libdir) + _platlibdir = getattr(sys, "platlibdir", "lib") + platlibdir = os.path.join(destination, _platlibdir, impl_name) + check_path(cmd.install_platlib, platlibdir) + check_path(cmd.install_purelib, libdir) + check_path( + cmd.install_headers, + os.path.join(destination, "include", impl_name, "foopkg"), + ) + check_path(cmd.install_scripts, os.path.join(destination, "bin")) + check_path(cmd.install_data, destination) + + def test_user_site(self, monkeypatch): + # test install with --user + # preparing the environment for the test + self.tmpdir = self.mkdtemp() + orig_site = site.USER_SITE + orig_base = site.USER_BASE + monkeypatch.setattr(site, 'USER_BASE', os.path.join(self.tmpdir, 'B')) + monkeypatch.setattr(site, 'USER_SITE', os.path.join(self.tmpdir, 'S')) + monkeypatch.setattr(install_module, 'USER_BASE', site.USER_BASE) + monkeypatch.setattr(install_module, 'USER_SITE', site.USER_SITE) + + def _expanduser(path): + if path.startswith('~'): + return os.path.normpath(self.tmpdir + path[1:]) + return path + + monkeypatch.setattr(os.path, 'expanduser', _expanduser) + + for key in ('nt_user', 'posix_user'): + assert key in INSTALL_SCHEMES + + dist = Distribution({'name': 'xx'}) + cmd = install(dist) + + # making sure the user option is there + options = [name for name, short, label in cmd.user_options] + assert 'user' in options + + # setting a value + cmd.user = True + + # user base and site shouldn't be created yet + assert not os.path.exists(site.USER_BASE) + assert not os.path.exists(site.USER_SITE) + + # let's run finalize + cmd.ensure_finalized() + + # now they should + assert os.path.exists(site.USER_BASE) + assert os.path.exists(site.USER_SITE) + + assert 'userbase' in cmd.config_vars + assert 'usersite' in cmd.config_vars + + actual_headers = os.path.relpath(cmd.install_headers, site.USER_BASE) + if os.name == 'nt' and not is_mingw(): + site_path = os.path.relpath(os.path.dirname(orig_site), orig_base) + include = os.path.join(site_path, 'Include') + else: + include = sysconfig.get_python_inc(0, '') + expect_headers = os.path.join(include, 'xx') + + assert os.path.normcase(actual_headers) == os.path.normcase(expect_headers) + + def test_handle_extra_path(self): + dist = Distribution({'name': 'xx', 'extra_path': 'path,dirs'}) + cmd = install(dist) + + # two elements + cmd.handle_extra_path() + assert cmd.extra_path == ['path', 'dirs'] + assert cmd.extra_dirs == 'dirs' + assert cmd.path_file == 'path' + + # one element + cmd.extra_path = ['path'] + cmd.handle_extra_path() + assert cmd.extra_path == ['path'] + assert cmd.extra_dirs == 'path' + assert cmd.path_file == 'path' + + # none + dist.extra_path = cmd.extra_path = None + cmd.handle_extra_path() + assert cmd.extra_path is None + assert cmd.extra_dirs == '' + assert cmd.path_file is None + + # three elements (no way !) + cmd.extra_path = 'path,dirs,again' + with pytest.raises(DistutilsOptionError): + cmd.handle_extra_path() + + def test_finalize_options(self): + dist = Distribution({'name': 'xx'}) + cmd = install(dist) + + # must supply either prefix/exec-prefix/home or + # install-base/install-platbase -- not both + cmd.prefix = 'prefix' + cmd.install_base = 'base' + with pytest.raises(DistutilsOptionError): + cmd.finalize_options() + + # must supply either home or prefix/exec-prefix -- not both + cmd.install_base = None + cmd.home = 'home' + with pytest.raises(DistutilsOptionError): + cmd.finalize_options() + + # can't combine user with prefix/exec_prefix/home or + # install_(plat)base + cmd.prefix = None + cmd.user = 'user' + with pytest.raises(DistutilsOptionError): + cmd.finalize_options() + + def test_record(self): + install_dir = self.mkdtemp() + project_dir, dist = self.create_dist(py_modules=['hello'], scripts=['sayhi']) + os.chdir(project_dir) + self.write_file('hello.py', "def main(): print('o hai')") + self.write_file('sayhi', 'from hello import main; main()') + + cmd = install(dist) + dist.command_obj['install'] = cmd + cmd.root = install_dir + cmd.record = os.path.join(project_dir, 'filelist') + cmd.ensure_finalized() + cmd.run() + + content = pathlib.Path(cmd.record).read_text(encoding='utf-8') + + found = [pathlib.Path(line).name for line in content.splitlines()] + expected = [ + 'hello.py', + f'hello.{sys.implementation.cache_tag}.pyc', + 'sayhi', + 'UNKNOWN-0.0.0-py{}.{}.egg-info'.format(*sys.version_info[:2]), + ] + assert found == expected + + def test_record_extensions(self): + cmd = missing_compiler_executable() + if cmd is not None: + pytest.skip(f'The {cmd!r} command is not found') + install_dir = self.mkdtemp() + project_dir, dist = self.create_dist( + ext_modules=[Extension('xx', ['xxmodule.c'])] + ) + os.chdir(project_dir) + support.copy_xxmodule_c(project_dir) + + buildextcmd = build_ext(dist) + support.fixup_build_ext(buildextcmd) + buildextcmd.ensure_finalized() + + cmd = install(dist) + dist.command_obj['install'] = cmd + dist.command_obj['build_ext'] = buildextcmd + cmd.root = install_dir + cmd.record = os.path.join(project_dir, 'filelist') + cmd.ensure_finalized() + cmd.run() + + content = pathlib.Path(cmd.record).read_text(encoding='utf-8') + + found = [pathlib.Path(line).name for line in content.splitlines()] + expected = [ + _make_ext_name('xx'), + 'UNKNOWN-0.0.0-py{}.{}.egg-info'.format(*sys.version_info[:2]), + ] + assert found == expected + + def test_debug_mode(self, caplog, monkeypatch): + # this covers the code called when DEBUG is set + monkeypatch.setattr(install_module, 'DEBUG', True) + caplog.set_level(logging.DEBUG) + self.test_record() + assert any(rec for rec in caplog.records if rec.levelno == logging.DEBUG) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install_data.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install_data.py new file mode 100644 index 0000000000000000000000000000000000000000..c800f86c645d86fcb11aa3bef1513325ef163132 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install_data.py @@ -0,0 +1,74 @@ +"""Tests for distutils.command.install_data.""" + +import os +import pathlib +from distutils.command.install_data import install_data +from distutils.tests import support + +import pytest + + +@pytest.mark.usefixtures('save_env') +class TestInstallData( + support.TempdirManager, +): + def test_simple_run(self): + pkg_dir, dist = self.create_dist() + cmd = install_data(dist) + cmd.install_dir = inst = os.path.join(pkg_dir, 'inst') + + # data_files can contain + # - simple files + # - a Path object + # - a tuple with a path, and a list of file + one = os.path.join(pkg_dir, 'one') + self.write_file(one, 'xxx') + inst2 = os.path.join(pkg_dir, 'inst2') + two = os.path.join(pkg_dir, 'two') + self.write_file(two, 'xxx') + three = pathlib.Path(pkg_dir) / 'three' + self.write_file(three, 'xxx') + + cmd.data_files = [one, (inst2, [two]), three] + assert cmd.get_inputs() == [one, (inst2, [two]), three] + + # let's run the command + cmd.ensure_finalized() + cmd.run() + + # let's check the result + assert len(cmd.get_outputs()) == 3 + rthree = os.path.split(one)[-1] + assert os.path.exists(os.path.join(inst, rthree)) + rtwo = os.path.split(two)[-1] + assert os.path.exists(os.path.join(inst2, rtwo)) + rone = os.path.split(one)[-1] + assert os.path.exists(os.path.join(inst, rone)) + cmd.outfiles = [] + + # let's try with warn_dir one + cmd.warn_dir = True + cmd.ensure_finalized() + cmd.run() + + # let's check the result + assert len(cmd.get_outputs()) == 3 + assert os.path.exists(os.path.join(inst, rthree)) + assert os.path.exists(os.path.join(inst2, rtwo)) + assert os.path.exists(os.path.join(inst, rone)) + cmd.outfiles = [] + + # now using root and empty dir + cmd.root = os.path.join(pkg_dir, 'root') + inst5 = os.path.join(pkg_dir, 'inst5') + four = os.path.join(cmd.install_dir, 'four') + self.write_file(four, 'xx') + cmd.data_files = [one, (inst2, [two]), three, ('inst5', [four]), (inst5, [])] + cmd.ensure_finalized() + cmd.run() + + # let's check the result + assert len(cmd.get_outputs()) == 5 + assert os.path.exists(os.path.join(inst, rthree)) + assert os.path.exists(os.path.join(inst2, rtwo)) + assert os.path.exists(os.path.join(inst, rone)) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install_headers.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install_headers.py new file mode 100644 index 0000000000000000000000000000000000000000..2c74f06b976f3c3ea977667a5c16c0e7f201a558 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install_headers.py @@ -0,0 +1,33 @@ +"""Tests for distutils.command.install_headers.""" + +import os +from distutils.command.install_headers import install_headers +from distutils.tests import support + +import pytest + + +@pytest.mark.usefixtures('save_env') +class TestInstallHeaders( + support.TempdirManager, +): + def test_simple_run(self): + # we have two headers + header_list = self.mkdtemp() + header1 = os.path.join(header_list, 'header1') + header2 = os.path.join(header_list, 'header2') + self.write_file(header1) + self.write_file(header2) + headers = [header1, header2] + + pkg_dir, dist = self.create_dist(headers=headers) + cmd = install_headers(dist) + assert cmd.get_inputs() == headers + + # let's run the command + cmd.install_dir = os.path.join(pkg_dir, 'inst') + cmd.ensure_finalized() + cmd.run() + + # let's check the results + assert len(cmd.get_outputs()) == 2 diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install_lib.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install_lib.py new file mode 100644 index 0000000000000000000000000000000000000000..f685a579560ea70bceea221de0e54485975ce180 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install_lib.py @@ -0,0 +1,110 @@ +"""Tests for distutils.command.install_data.""" + +import importlib.util +import os +import sys +from distutils.command.install_lib import install_lib +from distutils.errors import DistutilsOptionError +from distutils.extension import Extension +from distutils.tests import support + +import pytest + + +@support.combine_markers +@pytest.mark.usefixtures('save_env') +class TestInstallLib( + support.TempdirManager, +): + def test_finalize_options(self): + dist = self.create_dist()[1] + cmd = install_lib(dist) + + cmd.finalize_options() + assert cmd.compile == 1 + assert cmd.optimize == 0 + + # optimize must be 0, 1, or 2 + cmd.optimize = 'foo' + with pytest.raises(DistutilsOptionError): + cmd.finalize_options() + cmd.optimize = '4' + with pytest.raises(DistutilsOptionError): + cmd.finalize_options() + + cmd.optimize = '2' + cmd.finalize_options() + assert cmd.optimize == 2 + + @pytest.mark.skipif('sys.dont_write_bytecode') + def test_byte_compile(self): + project_dir, dist = self.create_dist() + os.chdir(project_dir) + cmd = install_lib(dist) + cmd.compile = cmd.optimize = 1 + + f = os.path.join(project_dir, 'foo.py') + self.write_file(f, '# python file') + cmd.byte_compile([f]) + pyc_file = importlib.util.cache_from_source('foo.py', optimization='') + pyc_opt_file = importlib.util.cache_from_source( + 'foo.py', optimization=cmd.optimize + ) + assert os.path.exists(pyc_file) + assert os.path.exists(pyc_opt_file) + + def test_get_outputs(self): + project_dir, dist = self.create_dist() + os.chdir(project_dir) + os.mkdir('spam') + cmd = install_lib(dist) + + # setting up a dist environment + cmd.compile = cmd.optimize = 1 + cmd.install_dir = self.mkdtemp() + f = os.path.join(project_dir, 'spam', '__init__.py') + self.write_file(f, '# python package') + cmd.distribution.ext_modules = [Extension('foo', ['xxx'])] + cmd.distribution.packages = ['spam'] + cmd.distribution.script_name = 'setup.py' + + # get_outputs should return 4 elements: spam/__init__.py and .pyc, + # foo.import-tag-abiflags.so / foo.pyd + outputs = cmd.get_outputs() + assert len(outputs) == 4, outputs + + def test_get_inputs(self): + project_dir, dist = self.create_dist() + os.chdir(project_dir) + os.mkdir('spam') + cmd = install_lib(dist) + + # setting up a dist environment + cmd.compile = cmd.optimize = 1 + cmd.install_dir = self.mkdtemp() + f = os.path.join(project_dir, 'spam', '__init__.py') + self.write_file(f, '# python package') + cmd.distribution.ext_modules = [Extension('foo', ['xxx'])] + cmd.distribution.packages = ['spam'] + cmd.distribution.script_name = 'setup.py' + + # get_inputs should return 2 elements: spam/__init__.py and + # foo.import-tag-abiflags.so / foo.pyd + inputs = cmd.get_inputs() + assert len(inputs) == 2, inputs + + def test_dont_write_bytecode(self, caplog): + # makes sure byte_compile is not used + dist = self.create_dist()[1] + cmd = install_lib(dist) + cmd.compile = True + cmd.optimize = 1 + + old_dont_write_bytecode = sys.dont_write_bytecode + sys.dont_write_bytecode = True + try: + cmd.byte_compile([]) + finally: + sys.dont_write_bytecode = old_dont_write_bytecode + + assert 'byte-compiling is disabled' in caplog.messages[0] diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install_scripts.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install_scripts.py new file mode 100644 index 0000000000000000000000000000000000000000..868b1c22521f23a5dd398e4636c94330d4c238ac --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install_scripts.py @@ -0,0 +1,52 @@ +"""Tests for distutils.command.install_scripts.""" + +import os +from distutils.command.install_scripts import install_scripts +from distutils.core import Distribution +from distutils.tests import support + +from . import test_build_scripts + + +class TestInstallScripts(support.TempdirManager): + def test_default_settings(self): + dist = Distribution() + dist.command_obj["build"] = support.DummyCommand(build_scripts="/foo/bar") + dist.command_obj["install"] = support.DummyCommand( + install_scripts="/splat/funk", + force=True, + skip_build=True, + ) + cmd = install_scripts(dist) + assert not cmd.force + assert not cmd.skip_build + assert cmd.build_dir is None + assert cmd.install_dir is None + + cmd.finalize_options() + + assert cmd.force + assert cmd.skip_build + assert cmd.build_dir == "/foo/bar" + assert cmd.install_dir == "/splat/funk" + + def test_installation(self): + source = self.mkdtemp() + + expected = test_build_scripts.TestBuildScripts.write_sample_scripts(source) + + target = self.mkdtemp() + dist = Distribution() + dist.command_obj["build"] = support.DummyCommand(build_scripts=source) + dist.command_obj["install"] = support.DummyCommand( + install_scripts=target, + force=True, + skip_build=True, + ) + cmd = install_scripts(dist) + cmd.finalize_options() + cmd.run() + + installed = os.listdir(target) + for name in expected: + assert name in installed diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_log.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_log.py new file mode 100644 index 0000000000000000000000000000000000000000..d67779fc9fa0f58a010929d5a456890c6dde3376 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_log.py @@ -0,0 +1,12 @@ +"""Tests for distutils.log""" + +import logging +from distutils._log import log + + +class TestLog: + def test_non_ascii(self, caplog): + caplog.set_level(logging.DEBUG) + log.debug('Dεbug\tMėssãge') + log.fatal('Fαtal\tÈrrōr') + assert caplog.messages == ['Dεbug\tMėssãge', 'Fαtal\tÈrrōr'] diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_modified.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_modified.py new file mode 100644 index 0000000000000000000000000000000000000000..e35cec2d6f1a8d27619e33c253f0a83f0f72a75d --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_modified.py @@ -0,0 +1,126 @@ +"""Tests for distutils._modified.""" + +import os +import types +from distutils._modified import newer, newer_group, newer_pairwise, newer_pairwise_group +from distutils.errors import DistutilsFileError +from distutils.tests import support + +import pytest + + +class TestDepUtil(support.TempdirManager): + def test_newer(self): + tmpdir = self.mkdtemp() + new_file = os.path.join(tmpdir, 'new') + old_file = os.path.abspath(__file__) + + # Raise DistutilsFileError if 'new_file' does not exist. + with pytest.raises(DistutilsFileError): + newer(new_file, old_file) + + # Return true if 'new_file' exists and is more recently modified than + # 'old_file', or if 'new_file' exists and 'old_file' doesn't. + self.write_file(new_file) + assert newer(new_file, 'I_dont_exist') + assert newer(new_file, old_file) + + # Return false if both exist and 'old_file' is the same age or younger + # than 'new_file'. + assert not newer(old_file, new_file) + + def _setup_1234(self): + tmpdir = self.mkdtemp() + sources = os.path.join(tmpdir, 'sources') + targets = os.path.join(tmpdir, 'targets') + os.mkdir(sources) + os.mkdir(targets) + one = os.path.join(sources, 'one') + two = os.path.join(sources, 'two') + three = os.path.abspath(__file__) # I am the old file + four = os.path.join(targets, 'four') + self.write_file(one) + self.write_file(two) + self.write_file(four) + return one, two, three, four + + def test_newer_pairwise(self): + one, two, three, four = self._setup_1234() + + assert newer_pairwise([one, two], [three, four]) == ([one], [three]) + + def test_newer_pairwise_mismatch(self): + one, two, three, four = self._setup_1234() + + with pytest.raises(ValueError): + newer_pairwise([one], [three, four]) + + with pytest.raises(ValueError): + newer_pairwise([one, two], [three]) + + def test_newer_pairwise_empty(self): + assert newer_pairwise([], []) == ([], []) + + def test_newer_pairwise_fresh(self): + one, two, three, four = self._setup_1234() + + assert newer_pairwise([one, three], [two, four]) == ([], []) + + def test_newer_group(self): + tmpdir = self.mkdtemp() + sources = os.path.join(tmpdir, 'sources') + os.mkdir(sources) + one = os.path.join(sources, 'one') + two = os.path.join(sources, 'two') + three = os.path.join(sources, 'three') + old_file = os.path.abspath(__file__) + + # return true if 'old_file' is out-of-date with respect to any file + # listed in 'sources'. + self.write_file(one) + self.write_file(two) + self.write_file(three) + assert newer_group([one, two, three], old_file) + assert not newer_group([one, two, old_file], three) + + # missing handling + os.remove(one) + with pytest.raises(OSError): + newer_group([one, two, old_file], three) + + assert not newer_group([one, two, old_file], three, missing='ignore') + + assert newer_group([one, two, old_file], three, missing='newer') + + +@pytest.fixture +def groups_target(tmp_path): + """ + Set up some older sources, a target, and newer sources. + + Returns a simple namespace with these values. + """ + filenames = ['older.c', 'older.h', 'target.o', 'newer.c', 'newer.h'] + paths = [tmp_path / name for name in filenames] + + for mtime, path in enumerate(paths): + path.write_text('', encoding='utf-8') + + # make sure modification times are sequential + os.utime(path, (mtime, mtime)) + + return types.SimpleNamespace(older=paths[:2], target=paths[2], newer=paths[3:]) + + +def test_newer_pairwise_group(groups_target): + older = newer_pairwise_group([groups_target.older], [groups_target.target]) + newer = newer_pairwise_group([groups_target.newer], [groups_target.target]) + assert older == ([], []) + assert newer == ([groups_target.newer], [groups_target.target]) + + +def test_newer_group_no_sources_no_target(tmp_path): + """ + Consider no sources and no target "newer". + """ + assert newer_group([], str(tmp_path / 'does-not-exist')) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_sdist.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_sdist.py new file mode 100644 index 0000000000000000000000000000000000000000..6b1a376b262162aa7c8d3d989709c05b38563d6c --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_sdist.py @@ -0,0 +1,470 @@ +"""Tests for distutils.command.sdist.""" + +import os +import pathlib +import shutil # noqa: F401 +import tarfile +import zipfile +from distutils.archive_util import ARCHIVE_FORMATS +from distutils.command.sdist import sdist, show_formats +from distutils.core import Distribution +from distutils.errors import DistutilsOptionError +from distutils.filelist import FileList +from os.path import join +from textwrap import dedent + +import jaraco.path +import path +import pytest +from more_itertools import ilen + +from . import support +from .unix_compat import grp, pwd, require_uid_0, require_unix_id + +SETUP_PY = """ +from distutils.core import setup +import somecode + +setup(name='fake') +""" + +MANIFEST = """\ +# file GENERATED by distutils, do NOT edit +README +buildout.cfg +inroot.txt +setup.py +data%(sep)sdata.dt +scripts%(sep)sscript.py +some%(sep)sfile.txt +some%(sep)sother_file.txt +somecode%(sep)s__init__.py +somecode%(sep)sdoc.dat +somecode%(sep)sdoc.txt +""" + + +@pytest.fixture(autouse=True) +def project_dir(request, distutils_managed_tempdir): + self = request.instance + self.tmp_dir = self.mkdtemp() + jaraco.path.build( + { + 'somecode': { + '__init__.py': '#', + }, + 'README': 'xxx', + 'setup.py': SETUP_PY, + }, + self.tmp_dir, + ) + with path.Path(self.tmp_dir): + yield + + +def clean_lines(filepath): + with pathlib.Path(filepath).open(encoding='utf-8') as f: + yield from filter(None, map(str.strip, f)) + + +class TestSDist(support.TempdirManager): + def get_cmd(self, metadata=None): + """Returns a cmd""" + if metadata is None: + metadata = { + 'name': 'ns.fake--pkg', + 'version': '1.0', + 'url': 'xxx', + 'author': 'xxx', + 'author_email': 'xxx', + } + dist = Distribution(metadata) + dist.script_name = 'setup.py' + dist.packages = ['somecode'] + dist.include_package_data = True + cmd = sdist(dist) + cmd.dist_dir = 'dist' + return dist, cmd + + @pytest.mark.usefixtures('needs_zlib') + def test_prune_file_list(self): + # this test creates a project with some VCS dirs and an NFS rename + # file, then launches sdist to check they get pruned on all systems + + # creating VCS directories with some files in them + os.mkdir(join(self.tmp_dir, 'somecode', '.svn')) + self.write_file((self.tmp_dir, 'somecode', '.svn', 'ok.py'), 'xxx') + + os.mkdir(join(self.tmp_dir, 'somecode', '.hg')) + self.write_file((self.tmp_dir, 'somecode', '.hg', 'ok'), 'xxx') + + os.mkdir(join(self.tmp_dir, 'somecode', '.git')) + self.write_file((self.tmp_dir, 'somecode', '.git', 'ok'), 'xxx') + + self.write_file((self.tmp_dir, 'somecode', '.nfs0001'), 'xxx') + + # now building a sdist + dist, cmd = self.get_cmd() + + # zip is available universally + # (tar might not be installed under win32) + cmd.formats = ['zip'] + + cmd.ensure_finalized() + cmd.run() + + # now let's check what we have + dist_folder = join(self.tmp_dir, 'dist') + files = os.listdir(dist_folder) + assert files == ['ns_fake_pkg-1.0.zip'] + + zip_file = zipfile.ZipFile(join(dist_folder, 'ns_fake_pkg-1.0.zip')) + try: + content = zip_file.namelist() + finally: + zip_file.close() + + # making sure everything has been pruned correctly + expected = [ + '', + 'PKG-INFO', + 'README', + 'setup.py', + 'somecode/', + 'somecode/__init__.py', + ] + assert sorted(content) == ['ns_fake_pkg-1.0/' + x for x in expected] + + @pytest.mark.usefixtures('needs_zlib') + @pytest.mark.skipif("not shutil.which('tar')") + @pytest.mark.skipif("not shutil.which('gzip')") + def test_make_distribution(self): + # now building a sdist + dist, cmd = self.get_cmd() + + # creating a gztar then a tar + cmd.formats = ['gztar', 'tar'] + cmd.ensure_finalized() + cmd.run() + + # making sure we have two files + dist_folder = join(self.tmp_dir, 'dist') + result = os.listdir(dist_folder) + result.sort() + assert result == ['ns_fake_pkg-1.0.tar', 'ns_fake_pkg-1.0.tar.gz'] + + os.remove(join(dist_folder, 'ns_fake_pkg-1.0.tar')) + os.remove(join(dist_folder, 'ns_fake_pkg-1.0.tar.gz')) + + # now trying a tar then a gztar + cmd.formats = ['tar', 'gztar'] + + cmd.ensure_finalized() + cmd.run() + + result = os.listdir(dist_folder) + result.sort() + assert result == ['ns_fake_pkg-1.0.tar', 'ns_fake_pkg-1.0.tar.gz'] + + @pytest.mark.usefixtures('needs_zlib') + def test_add_defaults(self): + # https://bugs.python.org/issue2279 + + # add_default should also include + # data_files and package_data + dist, cmd = self.get_cmd() + + # filling data_files by pointing files + # in package_data + dist.package_data = {'': ['*.cfg', '*.dat'], 'somecode': ['*.txt']} + self.write_file((self.tmp_dir, 'somecode', 'doc.txt'), '#') + self.write_file((self.tmp_dir, 'somecode', 'doc.dat'), '#') + + # adding some data in data_files + data_dir = join(self.tmp_dir, 'data') + os.mkdir(data_dir) + self.write_file((data_dir, 'data.dt'), '#') + some_dir = join(self.tmp_dir, 'some') + os.mkdir(some_dir) + # make sure VCS directories are pruned (#14004) + hg_dir = join(self.tmp_dir, '.hg') + os.mkdir(hg_dir) + self.write_file((hg_dir, 'last-message.txt'), '#') + # a buggy regex used to prevent this from working on windows (#6884) + self.write_file((self.tmp_dir, 'buildout.cfg'), '#') + self.write_file((self.tmp_dir, 'inroot.txt'), '#') + self.write_file((some_dir, 'file.txt'), '#') + self.write_file((some_dir, 'other_file.txt'), '#') + + dist.data_files = [ + ('data', ['data/data.dt', 'buildout.cfg', 'inroot.txt', 'notexisting']), + 'some/file.txt', + 'some/other_file.txt', + ] + + # adding a script + script_dir = join(self.tmp_dir, 'scripts') + os.mkdir(script_dir) + self.write_file((script_dir, 'script.py'), '#') + dist.scripts = [join('scripts', 'script.py')] + + cmd.formats = ['zip'] + cmd.use_defaults = True + + cmd.ensure_finalized() + cmd.run() + + # now let's check what we have + dist_folder = join(self.tmp_dir, 'dist') + files = os.listdir(dist_folder) + assert files == ['ns_fake_pkg-1.0.zip'] + + zip_file = zipfile.ZipFile(join(dist_folder, 'ns_fake_pkg-1.0.zip')) + try: + content = zip_file.namelist() + finally: + zip_file.close() + + # making sure everything was added + expected = [ + '', + 'PKG-INFO', + 'README', + 'buildout.cfg', + 'data/', + 'data/data.dt', + 'inroot.txt', + 'scripts/', + 'scripts/script.py', + 'setup.py', + 'some/', + 'some/file.txt', + 'some/other_file.txt', + 'somecode/', + 'somecode/__init__.py', + 'somecode/doc.dat', + 'somecode/doc.txt', + ] + assert sorted(content) == ['ns_fake_pkg-1.0/' + x for x in expected] + + # checking the MANIFEST + manifest = pathlib.Path(self.tmp_dir, 'MANIFEST').read_text(encoding='utf-8') + assert manifest == MANIFEST % {'sep': os.sep} + + @staticmethod + def warnings(messages, prefix='warning: '): + return [msg for msg in messages if msg.startswith(prefix)] + + @pytest.mark.usefixtures('needs_zlib') + def test_metadata_check_option(self, caplog): + # testing the `medata-check` option + dist, cmd = self.get_cmd(metadata={}) + + # this should raise some warnings ! + # with the `check` subcommand + cmd.ensure_finalized() + cmd.run() + assert len(self.warnings(caplog.messages, 'warning: check: ')) == 1 + + # trying with a complete set of metadata + caplog.clear() + dist, cmd = self.get_cmd() + cmd.ensure_finalized() + cmd.metadata_check = False + cmd.run() + assert len(self.warnings(caplog.messages, 'warning: check: ')) == 0 + + def test_show_formats(self, capsys): + show_formats() + + # the output should be a header line + one line per format + num_formats = len(ARCHIVE_FORMATS.keys()) + output = [ + line + for line in capsys.readouterr().out.split('\n') + if line.strip().startswith('--formats=') + ] + assert len(output) == num_formats + + def test_finalize_options(self): + dist, cmd = self.get_cmd() + cmd.finalize_options() + + # default options set by finalize + assert cmd.manifest == 'MANIFEST' + assert cmd.template == 'MANIFEST.in' + assert cmd.dist_dir == 'dist' + + # formats has to be a string splitable on (' ', ',') or + # a stringlist + cmd.formats = 1 + with pytest.raises(DistutilsOptionError): + cmd.finalize_options() + cmd.formats = ['zip'] + cmd.finalize_options() + + # formats has to be known + cmd.formats = 'supazipa' + with pytest.raises(DistutilsOptionError): + cmd.finalize_options() + + # the following tests make sure there is a nice error message instead + # of a traceback when parsing an invalid manifest template + + def _check_template(self, content, caplog): + dist, cmd = self.get_cmd() + os.chdir(self.tmp_dir) + self.write_file('MANIFEST.in', content) + cmd.ensure_finalized() + cmd.filelist = FileList() + cmd.read_template() + assert len(self.warnings(caplog.messages)) == 1 + + def test_invalid_template_unknown_command(self, caplog): + self._check_template('taunt knights *', caplog) + + def test_invalid_template_wrong_arguments(self, caplog): + # this manifest command takes one argument + self._check_template('prune', caplog) + + @pytest.mark.skipif("platform.system() != 'Windows'") + def test_invalid_template_wrong_path(self, caplog): + # on Windows, trailing slashes are not allowed + # this used to crash instead of raising a warning: #8286 + self._check_template('include examples/', caplog) + + @pytest.mark.usefixtures('needs_zlib') + def test_get_file_list(self): + # make sure MANIFEST is recalculated + dist, cmd = self.get_cmd() + + # filling data_files by pointing files in package_data + dist.package_data = {'somecode': ['*.txt']} + self.write_file((self.tmp_dir, 'somecode', 'doc.txt'), '#') + cmd.formats = ['gztar'] + cmd.ensure_finalized() + cmd.run() + + assert ilen(clean_lines(cmd.manifest)) == 5 + + # adding a file + self.write_file((self.tmp_dir, 'somecode', 'doc2.txt'), '#') + + # make sure build_py is reinitialized, like a fresh run + build_py = dist.get_command_obj('build_py') + build_py.finalized = False + build_py.ensure_finalized() + + cmd.run() + + manifest2 = list(clean_lines(cmd.manifest)) + + # do we have the new file in MANIFEST ? + assert len(manifest2) == 6 + assert 'doc2.txt' in manifest2[-1] + + @pytest.mark.usefixtures('needs_zlib') + def test_manifest_marker(self): + # check that autogenerated MANIFESTs have a marker + dist, cmd = self.get_cmd() + cmd.ensure_finalized() + cmd.run() + + assert ( + next(clean_lines(cmd.manifest)) + == '# file GENERATED by distutils, do NOT edit' + ) + + @pytest.mark.usefixtures('needs_zlib') + def test_manifest_comments(self): + # make sure comments don't cause exceptions or wrong includes + contents = dedent( + """\ + # bad.py + #bad.py + good.py + """ + ) + dist, cmd = self.get_cmd() + cmd.ensure_finalized() + self.write_file((self.tmp_dir, cmd.manifest), contents) + self.write_file((self.tmp_dir, 'good.py'), '# pick me!') + self.write_file((self.tmp_dir, 'bad.py'), "# don't pick me!") + self.write_file((self.tmp_dir, '#bad.py'), "# don't pick me!") + cmd.run() + assert cmd.filelist.files == ['good.py'] + + @pytest.mark.usefixtures('needs_zlib') + def test_manual_manifest(self): + # check that a MANIFEST without a marker is left alone + dist, cmd = self.get_cmd() + cmd.formats = ['gztar'] + cmd.ensure_finalized() + self.write_file((self.tmp_dir, cmd.manifest), 'README.manual') + self.write_file( + (self.tmp_dir, 'README.manual'), + 'This project maintains its MANIFEST file itself.', + ) + cmd.run() + assert cmd.filelist.files == ['README.manual'] + + assert list(clean_lines(cmd.manifest)) == ['README.manual'] + + archive_name = join(self.tmp_dir, 'dist', 'ns_fake_pkg-1.0.tar.gz') + archive = tarfile.open(archive_name) + try: + filenames = [tarinfo.name for tarinfo in archive] + finally: + archive.close() + assert sorted(filenames) == [ + 'ns_fake_pkg-1.0', + 'ns_fake_pkg-1.0/PKG-INFO', + 'ns_fake_pkg-1.0/README.manual', + ] + + @pytest.mark.usefixtures('needs_zlib') + @require_unix_id + @require_uid_0 + @pytest.mark.skipif("not shutil.which('tar')") + @pytest.mark.skipif("not shutil.which('gzip')") + def test_make_distribution_owner_group(self): + # now building a sdist + dist, cmd = self.get_cmd() + + # creating a gztar and specifying the owner+group + cmd.formats = ['gztar'] + cmd.owner = pwd.getpwuid(0)[0] + cmd.group = grp.getgrgid(0)[0] + cmd.ensure_finalized() + cmd.run() + + # making sure we have the good rights + archive_name = join(self.tmp_dir, 'dist', 'ns_fake_pkg-1.0.tar.gz') + archive = tarfile.open(archive_name) + try: + for member in archive.getmembers(): + assert member.uid == 0 + assert member.gid == 0 + finally: + archive.close() + + # building a sdist again + dist, cmd = self.get_cmd() + + # creating a gztar + cmd.formats = ['gztar'] + cmd.ensure_finalized() + cmd.run() + + # making sure we have the good rights + archive_name = join(self.tmp_dir, 'dist', 'ns_fake_pkg-1.0.tar.gz') + archive = tarfile.open(archive_name) + + # note that we are not testing the group ownership here + # because, depending on the platforms and the container + # rights (see #7408) + try: + for member in archive.getmembers(): + assert member.uid == os.getuid() + finally: + archive.close() diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_spawn.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_spawn.py new file mode 100644 index 0000000000000000000000000000000000000000..3b9fc926f6ffc41673630fbf5775e6f4ad638b18 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_spawn.py @@ -0,0 +1,141 @@ +"""Tests for distutils.spawn.""" + +import os +import stat +import sys +import unittest.mock as mock +from distutils.errors import DistutilsExecError +from distutils.spawn import find_executable, spawn +from distutils.tests import support + +import path +import pytest +from test.support import unix_shell + +from .compat import py39 as os_helper + + +class TestSpawn(support.TempdirManager): + @pytest.mark.skipif("os.name not in ('nt', 'posix')") + def test_spawn(self): + tmpdir = self.mkdtemp() + + # creating something executable + # through the shell that returns 1 + if sys.platform != 'win32': + exe = os.path.join(tmpdir, 'foo.sh') + self.write_file(exe, f'#!{unix_shell}\nexit 1') + else: + exe = os.path.join(tmpdir, 'foo.bat') + self.write_file(exe, 'exit 1') + + os.chmod(exe, 0o777) + with pytest.raises(DistutilsExecError): + spawn([exe]) + + # now something that works + if sys.platform != 'win32': + exe = os.path.join(tmpdir, 'foo.sh') + self.write_file(exe, f'#!{unix_shell}\nexit 0') + else: + exe = os.path.join(tmpdir, 'foo.bat') + self.write_file(exe, 'exit 0') + + os.chmod(exe, 0o777) + spawn([exe]) # should work without any error + + def test_find_executable(self, tmp_path): + program_path = self._make_executable(tmp_path, '.exe') + program = program_path.name + program_noeext = program_path.with_suffix('').name + filename = str(program_path) + tmp_dir = path.Path(tmp_path) + + # test path parameter + rv = find_executable(program, path=tmp_dir) + assert rv == filename + + if sys.platform == 'win32': + # test without ".exe" extension + rv = find_executable(program_noeext, path=tmp_dir) + assert rv == filename + + # test find in the current directory + with tmp_dir: + rv = find_executable(program) + assert rv == program + + # test non-existent program + dont_exist_program = "dontexist_" + program + rv = find_executable(dont_exist_program, path=tmp_dir) + assert rv is None + + # PATH='': no match, except in the current directory + with os_helper.EnvironmentVarGuard() as env: + env['PATH'] = '' + with ( + mock.patch( + 'distutils.spawn.os.confstr', return_value=tmp_dir, create=True + ), + mock.patch('distutils.spawn.os.defpath', tmp_dir), + ): + rv = find_executable(program) + assert rv is None + + # look in current directory + with tmp_dir: + rv = find_executable(program) + assert rv == program + + # PATH=':': explicitly looks in the current directory + with os_helper.EnvironmentVarGuard() as env: + env['PATH'] = os.pathsep + with ( + mock.patch('distutils.spawn.os.confstr', return_value='', create=True), + mock.patch('distutils.spawn.os.defpath', ''), + ): + rv = find_executable(program) + assert rv is None + + # look in current directory + with tmp_dir: + rv = find_executable(program) + assert rv == program + + # missing PATH: test os.confstr("CS_PATH") and os.defpath + with os_helper.EnvironmentVarGuard() as env: + env.pop('PATH', None) + + # without confstr + with ( + mock.patch( + 'distutils.spawn.os.confstr', side_effect=ValueError, create=True + ), + mock.patch('distutils.spawn.os.defpath', tmp_dir), + ): + rv = find_executable(program) + assert rv == filename + + # with confstr + with ( + mock.patch( + 'distutils.spawn.os.confstr', return_value=tmp_dir, create=True + ), + mock.patch('distutils.spawn.os.defpath', ''), + ): + rv = find_executable(program) + assert rv == filename + + @staticmethod + def _make_executable(tmp_path, ext): + # Give the temporary program a suffix regardless of platform. + # It's needed on Windows and not harmful on others. + program = tmp_path.joinpath('program').with_suffix(ext) + program.write_text("", encoding='utf-8') + program.chmod(stat.S_IXUSR) + return program + + def test_spawn_missing_exe(self): + with pytest.raises(DistutilsExecError) as ctx: + spawn(['does-not-exist']) + assert "command 'does-not-exist' failed" in str(ctx.value) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_sysconfig.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_sysconfig.py new file mode 100644 index 0000000000000000000000000000000000000000..43d77c23fad426be237b9f91a6d98d7c36233d84 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_sysconfig.py @@ -0,0 +1,319 @@ +"""Tests for distutils.sysconfig.""" + +import contextlib +import distutils +import os +import pathlib +import subprocess +import sys +from distutils import sysconfig +from distutils.ccompiler import new_compiler # noqa: F401 +from distutils.unixccompiler import UnixCCompiler + +import jaraco.envs +import path +import pytest +from jaraco.text import trim +from test.support import swap_item + + +def _gen_makefile(root, contents): + jaraco.path.build({'Makefile': trim(contents)}, root) + return root / 'Makefile' + + +@pytest.mark.usefixtures('save_env') +class TestSysconfig: + def test_get_config_h_filename(self): + config_h = sysconfig.get_config_h_filename() + assert os.path.isfile(config_h) + + @pytest.mark.skipif("platform.system() == 'Windows'") + @pytest.mark.skipif("sys.implementation.name != 'cpython'") + def test_get_makefile_filename(self): + makefile = sysconfig.get_makefile_filename() + assert os.path.isfile(makefile) + + def test_get_python_lib(self, tmp_path): + assert sysconfig.get_python_lib() != sysconfig.get_python_lib(prefix=tmp_path) + + def test_get_config_vars(self): + cvars = sysconfig.get_config_vars() + assert isinstance(cvars, dict) + assert cvars + + @pytest.mark.skipif('sysconfig.IS_PYPY') + @pytest.mark.skipif('sysconfig.python_build') + @pytest.mark.xfail('platform.system() == "Windows"') + def test_srcdir_simple(self): + # See #15364. + srcdir = pathlib.Path(sysconfig.get_config_var('srcdir')) + + assert srcdir.absolute() + assert srcdir.is_dir() + + makefile = pathlib.Path(sysconfig.get_makefile_filename()) + assert makefile.parent.samefile(srcdir) + + @pytest.mark.skipif('sysconfig.IS_PYPY') + @pytest.mark.skipif('not sysconfig.python_build') + def test_srcdir_python_build(self): + # See #15364. + srcdir = pathlib.Path(sysconfig.get_config_var('srcdir')) + + # The python executable has not been installed so srcdir + # should be a full source checkout. + Python_h = srcdir.joinpath('Include', 'Python.h') + assert Python_h.is_file() + assert sysconfig._is_python_source_dir(srcdir) + assert sysconfig._is_python_source_dir(str(srcdir)) + + def test_srcdir_independent_of_cwd(self): + """ + srcdir should be independent of the current working directory + """ + # See #15364. + srcdir = sysconfig.get_config_var('srcdir') + with path.Path('..'): + srcdir2 = sysconfig.get_config_var('srcdir') + assert srcdir == srcdir2 + + def customize_compiler(self): + # make sure AR gets caught + class compiler: + compiler_type = 'unix' + executables = UnixCCompiler.executables + + def __init__(self): + self.exes = {} + + def set_executables(self, **kw): + for k, v in kw.items(): + self.exes[k] = v + + sysconfig_vars = { + 'AR': 'sc_ar', + 'CC': 'sc_cc', + 'CXX': 'sc_cxx', + 'ARFLAGS': '--sc-arflags', + 'CFLAGS': '--sc-cflags', + 'CCSHARED': '--sc-ccshared', + 'LDSHARED': 'sc_ldshared', + 'SHLIB_SUFFIX': 'sc_shutil_suffix', + } + + comp = compiler() + with contextlib.ExitStack() as cm: + for key, value in sysconfig_vars.items(): + cm.enter_context(swap_item(sysconfig._config_vars, key, value)) + sysconfig.customize_compiler(comp) + + return comp + + @pytest.mark.skipif("not isinstance(new_compiler(), UnixCCompiler)") + @pytest.mark.usefixtures('disable_macos_customization') + def test_customize_compiler(self): + # Make sure that sysconfig._config_vars is initialized + sysconfig.get_config_vars() + + os.environ['AR'] = 'env_ar' + os.environ['CC'] = 'env_cc' + os.environ['CPP'] = 'env_cpp' + os.environ['CXX'] = 'env_cxx --env-cxx-flags' + os.environ['LDSHARED'] = 'env_ldshared' + os.environ['LDFLAGS'] = '--env-ldflags' + os.environ['ARFLAGS'] = '--env-arflags' + os.environ['CFLAGS'] = '--env-cflags' + os.environ['CPPFLAGS'] = '--env-cppflags' + os.environ['RANLIB'] = 'env_ranlib' + + comp = self.customize_compiler() + assert comp.exes['archiver'] == 'env_ar --env-arflags' + assert comp.exes['preprocessor'] == 'env_cpp --env-cppflags' + assert comp.exes['compiler'] == 'env_cc --env-cflags --env-cppflags' + assert comp.exes['compiler_so'] == ( + 'env_cc --env-cflags --env-cppflags --sc-ccshared' + ) + assert ( + comp.exes['compiler_cxx'] + == 'env_cxx --env-cxx-flags --sc-cflags --env-cppflags' + ) + assert comp.exes['linker_exe'] == 'env_cc' + assert comp.exes['linker_so'] == ( + 'env_ldshared --env-ldflags --env-cflags --env-cppflags' + ) + assert comp.shared_lib_extension == 'sc_shutil_suffix' + + if sys.platform == "darwin": + assert comp.exes['ranlib'] == 'env_ranlib' + else: + assert 'ranlib' not in comp.exes + + del os.environ['AR'] + del os.environ['CC'] + del os.environ['CPP'] + del os.environ['CXX'] + del os.environ['LDSHARED'] + del os.environ['LDFLAGS'] + del os.environ['ARFLAGS'] + del os.environ['CFLAGS'] + del os.environ['CPPFLAGS'] + del os.environ['RANLIB'] + + comp = self.customize_compiler() + assert comp.exes['archiver'] == 'sc_ar --sc-arflags' + assert comp.exes['preprocessor'] == 'sc_cc -E' + assert comp.exes['compiler'] == 'sc_cc --sc-cflags' + assert comp.exes['compiler_so'] == 'sc_cc --sc-cflags --sc-ccshared' + assert comp.exes['compiler_cxx'] == 'sc_cxx --sc-cflags' + assert comp.exes['linker_exe'] == 'sc_cc' + assert comp.exes['linker_so'] == 'sc_ldshared' + assert comp.shared_lib_extension == 'sc_shutil_suffix' + assert 'ranlib' not in comp.exes + + def test_parse_makefile_base(self, tmp_path): + makefile = _gen_makefile( + tmp_path, + """ + CONFIG_ARGS= '--arg1=optarg1' 'ENV=LIB' + VAR=$OTHER + OTHER=foo + """, + ) + d = sysconfig.parse_makefile(makefile) + assert d == {'CONFIG_ARGS': "'--arg1=optarg1' 'ENV=LIB'", 'OTHER': 'foo'} + + def test_parse_makefile_literal_dollar(self, tmp_path): + makefile = _gen_makefile( + tmp_path, + """ + CONFIG_ARGS= '--arg1=optarg1' 'ENV=\\$$LIB' + VAR=$OTHER + OTHER=foo + """, + ) + d = sysconfig.parse_makefile(makefile) + assert d == {'CONFIG_ARGS': r"'--arg1=optarg1' 'ENV=\$LIB'", 'OTHER': 'foo'} + + def test_sysconfig_module(self): + import sysconfig as global_sysconfig + + assert global_sysconfig.get_config_var('CFLAGS') == sysconfig.get_config_var( + 'CFLAGS' + ) + assert global_sysconfig.get_config_var('LDFLAGS') == sysconfig.get_config_var( + 'LDFLAGS' + ) + + # On macOS, binary installers support extension module building on + # various levels of the operating system with differing Xcode + # configurations, requiring customization of some of the + # compiler configuration directives to suit the environment on + # the installed machine. Some of these customizations may require + # running external programs and are thus deferred until needed by + # the first extension module build. Only + # the Distutils version of sysconfig is used for extension module + # builds, which happens earlier in the Distutils tests. This may + # cause the following tests to fail since no tests have caused + # the global version of sysconfig to call the customization yet. + # The solution for now is to simply skip this test in this case. + # The longer-term solution is to only have one version of sysconfig. + @pytest.mark.skipif("sysconfig.get_config_var('CUSTOMIZED_OSX_COMPILER')") + def test_sysconfig_compiler_vars(self): + import sysconfig as global_sysconfig + + if sysconfig.get_config_var('CUSTOMIZED_OSX_COMPILER'): + pytest.skip('compiler flags customized') + assert global_sysconfig.get_config_var('LDSHARED') == sysconfig.get_config_var( + 'LDSHARED' + ) + assert global_sysconfig.get_config_var('CC') == sysconfig.get_config_var('CC') + + @pytest.mark.skipif("not sysconfig.get_config_var('EXT_SUFFIX')") + def test_SO_deprecation(self): + with pytest.warns(DeprecationWarning): + sysconfig.get_config_var('SO') + + def test_customize_compiler_before_get_config_vars(self, tmp_path): + # Issue #21923: test that a Distribution compiler + # instance can be called without an explicit call to + # get_config_vars(). + jaraco.path.build( + { + 'file': trim(""" + from distutils.core import Distribution + config = Distribution().get_command_obj('config') + # try_compile may pass or it may fail if no compiler + # is found but it should not raise an exception. + rc = config.try_compile('int x;') + """) + }, + tmp_path, + ) + p = subprocess.Popen( + [sys.executable, tmp_path / 'file'], + stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, + universal_newlines=True, + encoding='utf-8', + ) + outs, errs = p.communicate() + assert 0 == p.returncode, "Subprocess failed: " + outs + + def test_parse_config_h(self): + config_h = sysconfig.get_config_h_filename() + input = {} + with open(config_h, encoding="utf-8") as f: + result = sysconfig.parse_config_h(f, g=input) + assert input is result + with open(config_h, encoding="utf-8") as f: + result = sysconfig.parse_config_h(f) + assert isinstance(result, dict) + + @pytest.mark.skipif("platform.system() != 'Windows'") + @pytest.mark.skipif("sys.implementation.name != 'cpython'") + def test_win_ext_suffix(self): + assert sysconfig.get_config_var("EXT_SUFFIX").endswith(".pyd") + assert sysconfig.get_config_var("EXT_SUFFIX") != ".pyd" + + @pytest.mark.skipif("platform.system() != 'Windows'") + @pytest.mark.skipif("sys.implementation.name != 'cpython'") + @pytest.mark.skipif( + '\\PCbuild\\'.casefold() not in sys.executable.casefold(), + reason='Need sys.executable to be in a source tree', + ) + def test_win_build_venv_from_source_tree(self, tmp_path): + """Ensure distutils.sysconfig detects venvs from source tree builds.""" + env = jaraco.envs.VEnv() + env.create_opts = env.clean_opts + env.root = tmp_path + env.ensure_env() + cmd = [ + env.exe(), + "-c", + "import distutils.sysconfig; print(distutils.sysconfig.python_build)", + ] + distutils_path = os.path.dirname(os.path.dirname(distutils.__file__)) + out = subprocess.check_output( + cmd, env={**os.environ, "PYTHONPATH": distutils_path} + ) + assert out == "True" + + def test_get_python_inc_missing_config_dir(self, monkeypatch): + """ + In portable Python installations, the sysconfig will be broken, + pointing to the directories where the installation was built and + not where it currently is. In this case, ensure that the missing + directory isn't used for get_python_inc. + + See pypa/distutils#178. + """ + + def override(name): + if name == 'INCLUDEPY': + return '/does-not-exist' + return sysconfig.get_config_var(name) + + monkeypatch.setattr(sysconfig, 'get_config_var', override) + + assert os.path.exists(sysconfig.get_python_inc()) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_text_file.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_text_file.py new file mode 100644 index 0000000000000000000000000000000000000000..f51115656135cd3f348a45d4a14f97eeee47fb98 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_text_file.py @@ -0,0 +1,127 @@ +"""Tests for distutils.text_file.""" + +from distutils.tests import support +from distutils.text_file import TextFile + +import jaraco.path +import path + +TEST_DATA = """# test file + +line 3 \\ +# intervening comment + continues on next line +""" + + +class TestTextFile(support.TempdirManager): + def test_class(self): + # old tests moved from text_file.__main__ + # so they are really called by the buildbots + + # result 1: no fancy options + result1 = [ + '# test file\n', + '\n', + 'line 3 \\\n', + '# intervening comment\n', + ' continues on next line\n', + ] + + # result 2: just strip comments + result2 = ["\n", "line 3 \\\n", " continues on next line\n"] + + # result 3: just strip blank lines + result3 = [ + "# test file\n", + "line 3 \\\n", + "# intervening comment\n", + " continues on next line\n", + ] + + # result 4: default, strip comments, blank lines, + # and trailing whitespace + result4 = ["line 3 \\", " continues on next line"] + + # result 5: strip comments and blanks, plus join lines (but don't + # "collapse" joined lines + result5 = ["line 3 continues on next line"] + + # result 6: strip comments and blanks, plus join lines (and + # "collapse" joined lines + result6 = ["line 3 continues on next line"] + + def test_input(count, description, file, expected_result): + result = file.readlines() + assert result == expected_result + + tmp_path = path.Path(self.mkdtemp()) + filename = tmp_path / 'test.txt' + jaraco.path.build({filename.name: TEST_DATA}, tmp_path) + + in_file = TextFile( + filename, + strip_comments=False, + skip_blanks=False, + lstrip_ws=False, + rstrip_ws=False, + ) + try: + test_input(1, "no processing", in_file, result1) + finally: + in_file.close() + + in_file = TextFile( + filename, + strip_comments=True, + skip_blanks=False, + lstrip_ws=False, + rstrip_ws=False, + ) + try: + test_input(2, "strip comments", in_file, result2) + finally: + in_file.close() + + in_file = TextFile( + filename, + strip_comments=False, + skip_blanks=True, + lstrip_ws=False, + rstrip_ws=False, + ) + try: + test_input(3, "strip blanks", in_file, result3) + finally: + in_file.close() + + in_file = TextFile(filename) + try: + test_input(4, "default processing", in_file, result4) + finally: + in_file.close() + + in_file = TextFile( + filename, + strip_comments=True, + skip_blanks=True, + join_lines=True, + rstrip_ws=True, + ) + try: + test_input(5, "join lines without collapsing", in_file, result5) + finally: + in_file.close() + + in_file = TextFile( + filename, + strip_comments=True, + skip_blanks=True, + join_lines=True, + rstrip_ws=True, + collapse_join=True, + ) + try: + test_input(6, "join lines with collapsing", in_file, result6) + finally: + in_file.close() diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_util.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_util.py new file mode 100644 index 0000000000000000000000000000000000000000..00c9743ed0a2664039060ef149d30f165bf2f465 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_util.py @@ -0,0 +1,243 @@ +"""Tests for distutils.util.""" + +import email +import email.generator +import email.policy +import io +import os +import pathlib +import sys +import sysconfig as stdlib_sysconfig +import unittest.mock as mock +from copy import copy +from distutils import sysconfig, util +from distutils.errors import DistutilsByteCompileError, DistutilsPlatformError +from distutils.util import ( + byte_compile, + change_root, + check_environ, + convert_path, + get_host_platform, + get_platform, + grok_environment_error, + rfc822_escape, + split_quoted, + strtobool, +) + +import pytest + + +@pytest.fixture(autouse=True) +def environment(monkeypatch): + monkeypatch.setattr(os, 'name', os.name) + monkeypatch.setattr(sys, 'platform', sys.platform) + monkeypatch.setattr(sys, 'version', sys.version) + monkeypatch.setattr(os, 'sep', os.sep) + monkeypatch.setattr(os.path, 'join', os.path.join) + monkeypatch.setattr(os.path, 'isabs', os.path.isabs) + monkeypatch.setattr(os.path, 'splitdrive', os.path.splitdrive) + monkeypatch.setattr(sysconfig, '_config_vars', copy(sysconfig._config_vars)) + + +@pytest.mark.usefixtures('save_env') +class TestUtil: + def test_get_host_platform(self): + with mock.patch('os.name', 'nt'): + with mock.patch('sys.version', '... [... (ARM64)]'): + assert get_host_platform() == 'win-arm64' + with mock.patch('sys.version', '... [... (ARM)]'): + assert get_host_platform() == 'win-arm32' + + with mock.patch('sys.version_info', (3, 9, 0, 'final', 0)): + assert get_host_platform() == stdlib_sysconfig.get_platform() + + def test_get_platform(self): + with mock.patch('os.name', 'nt'): + with mock.patch.dict('os.environ', {'VSCMD_ARG_TGT_ARCH': 'x86'}): + assert get_platform() == 'win32' + with mock.patch.dict('os.environ', {'VSCMD_ARG_TGT_ARCH': 'x64'}): + assert get_platform() == 'win-amd64' + with mock.patch.dict('os.environ', {'VSCMD_ARG_TGT_ARCH': 'arm'}): + assert get_platform() == 'win-arm32' + with mock.patch.dict('os.environ', {'VSCMD_ARG_TGT_ARCH': 'arm64'}): + assert get_platform() == 'win-arm64' + + def test_convert_path(self): + expected = os.sep.join(('', 'home', 'to', 'my', 'stuff')) + assert convert_path('/home/to/my/stuff') == expected + assert convert_path(pathlib.Path('/home/to/my/stuff')) == expected + assert convert_path('.') == os.curdir + + def test_change_root(self): + # linux/mac + os.name = 'posix' + + def _isabs(path): + return path[0] == '/' + + os.path.isabs = _isabs + + def _join(*path): + return '/'.join(path) + + os.path.join = _join + + assert change_root('/root', '/old/its/here') == '/root/old/its/here' + assert change_root('/root', 'its/here') == '/root/its/here' + + # windows + os.name = 'nt' + os.sep = '\\' + + def _isabs(path): + return path.startswith('c:\\') + + os.path.isabs = _isabs + + def _splitdrive(path): + if path.startswith('c:'): + return ('', path.replace('c:', '')) + return ('', path) + + os.path.splitdrive = _splitdrive + + def _join(*path): + return '\\'.join(path) + + os.path.join = _join + + assert ( + change_root('c:\\root', 'c:\\old\\its\\here') == 'c:\\root\\old\\its\\here' + ) + assert change_root('c:\\root', 'its\\here') == 'c:\\root\\its\\here' + + # BugsBunny os (it's a great os) + os.name = 'BugsBunny' + with pytest.raises(DistutilsPlatformError): + change_root('c:\\root', 'its\\here') + + # XXX platforms to be covered: mac + + def test_check_environ(self): + util.check_environ.cache_clear() + os.environ.pop('HOME', None) + + check_environ() + + assert os.environ['PLAT'] == get_platform() + + @pytest.mark.skipif("os.name != 'posix'") + def test_check_environ_getpwuid(self): + util.check_environ.cache_clear() + os.environ.pop('HOME', None) + + import pwd + + # only set pw_dir field, other fields are not used + result = pwd.struct_passwd(( + None, + None, + None, + None, + None, + '/home/distutils', + None, + )) + with mock.patch.object(pwd, 'getpwuid', return_value=result): + check_environ() + assert os.environ['HOME'] == '/home/distutils' + + util.check_environ.cache_clear() + os.environ.pop('HOME', None) + + # bpo-10496: Catch pwd.getpwuid() error + with mock.patch.object(pwd, 'getpwuid', side_effect=KeyError): + check_environ() + assert 'HOME' not in os.environ + + def test_split_quoted(self): + assert split_quoted('""one"" "two" \'three\' \\four') == [ + 'one', + 'two', + 'three', + 'four', + ] + + def test_strtobool(self): + yes = ('y', 'Y', 'yes', 'True', 't', 'true', 'True', 'On', 'on', '1') + no = ('n', 'no', 'f', 'false', 'off', '0', 'Off', 'No', 'N') + + for y in yes: + assert strtobool(y) + + for n in no: + assert not strtobool(n) + + indent = 8 * ' ' + + @pytest.mark.parametrize( + "given,wanted", + [ + # 0x0b, 0x0c, ..., etc are also considered a line break by Python + ("hello\x0b\nworld\n", f"hello\x0b{indent}\n{indent}world\n{indent}"), + ("hello\x1eworld", f"hello\x1e{indent}world"), + ("", ""), + ( + "I am a\npoor\nlonesome\nheader\n", + f"I am a\n{indent}poor\n{indent}lonesome\n{indent}header\n{indent}", + ), + ], + ) + def test_rfc822_escape(self, given, wanted): + """ + We want to ensure a multi-line header parses correctly. + + For interoperability, the escaped value should also "round-trip" over + `email.generator.Generator.flatten` and `email.message_from_*` + (see pypa/setuptools#4033). + + The main issue is that internally `email.policy.EmailPolicy` uses + `splitlines` which will split on some control chars. If all the new lines + are not prefixed with spaces, the parser will interrupt reading + the current header and produce an incomplete value, while + incorrectly interpreting the rest of the headers as part of the payload. + """ + res = rfc822_escape(given) + + policy = email.policy.EmailPolicy( + utf8=True, + mangle_from_=False, + max_line_length=0, + ) + with io.StringIO() as buffer: + raw = f"header: {res}\nother-header: 42\n\npayload\n" + orig = email.message_from_string(raw) + email.generator.Generator(buffer, policy=policy).flatten(orig) + buffer.seek(0) + regen = email.message_from_file(buffer) + + for msg in (orig, regen): + assert msg.get_payload() == "payload\n" + assert msg["other-header"] == "42" + # Generator may replace control chars with `\n` + assert set(msg["header"].splitlines()) == set(res.splitlines()) + + assert res == wanted + + def test_dont_write_bytecode(self): + # makes sure byte_compile raise a DistutilsError + # if sys.dont_write_bytecode is True + old_dont_write_bytecode = sys.dont_write_bytecode + sys.dont_write_bytecode = True + try: + with pytest.raises(DistutilsByteCompileError): + byte_compile([]) + finally: + sys.dont_write_bytecode = old_dont_write_bytecode + + def test_grok_environment_error(self): + # test obsolete function to ensure backward compat (#4931) + exc = OSError("Unable to find batch file") + msg = grok_environment_error(exc) + assert msg == "error: Unable to find batch file" diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_version.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_version.py new file mode 100644 index 0000000000000000000000000000000000000000..b68f0977249aa23aafbf31cf74a0e4127f777d05 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_version.py @@ -0,0 +1,80 @@ +"""Tests for distutils.version.""" + +import distutils +from distutils.version import LooseVersion, StrictVersion + +import pytest + + +@pytest.fixture(autouse=True) +def suppress_deprecation(): + with distutils.version.suppress_known_deprecation(): + yield + + +class TestVersion: + def test_prerelease(self): + version = StrictVersion('1.2.3a1') + assert version.version == (1, 2, 3) + assert version.prerelease == ('a', 1) + assert str(version) == '1.2.3a1' + + version = StrictVersion('1.2.0') + assert str(version) == '1.2' + + def test_cmp_strict(self): + versions = ( + ('1.5.1', '1.5.2b2', -1), + ('161', '3.10a', ValueError), + ('8.02', '8.02', 0), + ('3.4j', '1996.07.12', ValueError), + ('3.2.pl0', '3.1.1.6', ValueError), + ('2g6', '11g', ValueError), + ('0.9', '2.2', -1), + ('1.2.1', '1.2', 1), + ('1.1', '1.2.2', -1), + ('1.2', '1.1', 1), + ('1.2.1', '1.2.2', -1), + ('1.2.2', '1.2', 1), + ('1.2', '1.2.2', -1), + ('0.4.0', '0.4', 0), + ('1.13++', '5.5.kw', ValueError), + ) + + for v1, v2, wanted in versions: + try: + res = StrictVersion(v1)._cmp(StrictVersion(v2)) + except ValueError: + if wanted is ValueError: + continue + else: + raise AssertionError(f"cmp({v1}, {v2}) shouldn't raise ValueError") + assert res == wanted, f'cmp({v1}, {v2}) should be {wanted}, got {res}' + res = StrictVersion(v1)._cmp(v2) + assert res == wanted, f'cmp({v1}, {v2}) should be {wanted}, got {res}' + res = StrictVersion(v1)._cmp(object()) + assert res is NotImplemented, ( + f'cmp({v1}, {v2}) should be NotImplemented, got {res}' + ) + + def test_cmp(self): + versions = ( + ('1.5.1', '1.5.2b2', -1), + ('161', '3.10a', 1), + ('8.02', '8.02', 0), + ('3.4j', '1996.07.12', -1), + ('3.2.pl0', '3.1.1.6', 1), + ('2g6', '11g', -1), + ('0.960923', '2.2beta29', -1), + ('1.13++', '5.5.kw', -1), + ) + + for v1, v2, wanted in versions: + res = LooseVersion(v1)._cmp(LooseVersion(v2)) + assert res == wanted, f'cmp({v1}, {v2}) should be {wanted}, got {res}' + res = LooseVersion(v1)._cmp(v2) + assert res == wanted, f'cmp({v1}, {v2}) should be {wanted}, got {res}' + res = LooseVersion(v1)._cmp(object()) + assert res is NotImplemented, ( + f'cmp({v1}, {v2}) should be NotImplemented, got {res}' + ) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_versionpredicate.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/test_versionpredicate.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/unix_compat.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/unix_compat.py new file mode 100644 index 0000000000000000000000000000000000000000..a5d9ee45ccc639794d29ba0a5fd24f781ee5ecf5 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/tests/unix_compat.py @@ -0,0 +1,17 @@ +import sys + +try: + import grp + import pwd +except ImportError: + grp = pwd = None + +import pytest + +UNIX_ID_SUPPORT = grp and pwd +UID_0_SUPPORT = UNIX_ID_SUPPORT and sys.platform != "cygwin" + +require_unix_id = pytest.mark.skipif( + not UNIX_ID_SUPPORT, reason="Requires grp and pwd support" +) +require_uid_0 = pytest.mark.skipif(not UID_0_SUPPORT, reason="Requires UID 0 support") diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/text_file.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/text_file.py new file mode 100644 index 0000000000000000000000000000000000000000..89d9048d5902950516c3541ad212bff7b6cb2045 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/text_file.py @@ -0,0 +1,286 @@ +"""text_file + +provides the TextFile class, which gives an interface to text files +that (optionally) takes care of stripping comments, ignoring blank +lines, and joining lines with backslashes.""" + +import sys + + +class TextFile: + """Provides a file-like object that takes care of all the things you + commonly want to do when processing a text file that has some + line-by-line syntax: strip comments (as long as "#" is your + comment character), skip blank lines, join adjacent lines by + escaping the newline (ie. backslash at end of line), strip + leading and/or trailing whitespace. All of these are optional + and independently controllable. + + Provides a 'warn()' method so you can generate warning messages that + report physical line number, even if the logical line in question + spans multiple physical lines. Also provides 'unreadline()' for + implementing line-at-a-time lookahead. + + Constructor is called as: + + TextFile (filename=None, file=None, **options) + + It bombs (RuntimeError) if both 'filename' and 'file' are None; + 'filename' should be a string, and 'file' a file object (or + something that provides 'readline()' and 'close()' methods). It is + recommended that you supply at least 'filename', so that TextFile + can include it in warning messages. If 'file' is not supplied, + TextFile creates its own using 'io.open()'. + + The options are all boolean, and affect the value returned by + 'readline()': + strip_comments [default: true] + strip from "#" to end-of-line, as well as any whitespace + leading up to the "#" -- unless it is escaped by a backslash + lstrip_ws [default: false] + strip leading whitespace from each line before returning it + rstrip_ws [default: true] + strip trailing whitespace (including line terminator!) from + each line before returning it + skip_blanks [default: true} + skip lines that are empty *after* stripping comments and + whitespace. (If both lstrip_ws and rstrip_ws are false, + then some lines may consist of solely whitespace: these will + *not* be skipped, even if 'skip_blanks' is true.) + join_lines [default: false] + if a backslash is the last non-newline character on a line + after stripping comments and whitespace, join the following line + to it to form one "logical line"; if N consecutive lines end + with a backslash, then N+1 physical lines will be joined to + form one logical line. + collapse_join [default: false] + strip leading whitespace from lines that are joined to their + predecessor; only matters if (join_lines and not lstrip_ws) + errors [default: 'strict'] + error handler used to decode the file content + + Note that since 'rstrip_ws' can strip the trailing newline, the + semantics of 'readline()' must differ from those of the builtin file + object's 'readline()' method! In particular, 'readline()' returns + None for end-of-file: an empty string might just be a blank line (or + an all-whitespace line), if 'rstrip_ws' is true but 'skip_blanks' is + not.""" + + default_options = { + 'strip_comments': 1, + 'skip_blanks': 1, + 'lstrip_ws': 0, + 'rstrip_ws': 1, + 'join_lines': 0, + 'collapse_join': 0, + 'errors': 'strict', + } + + def __init__(self, filename=None, file=None, **options): + """Construct a new TextFile object. At least one of 'filename' + (a string) and 'file' (a file-like object) must be supplied. + They keyword argument options are described above and affect + the values returned by 'readline()'.""" + if filename is None and file is None: + raise RuntimeError( + "you must supply either or both of 'filename' and 'file'" + ) + + # set values for all options -- either from client option hash + # or fallback to default_options + for opt in self.default_options.keys(): + if opt in options: + setattr(self, opt, options[opt]) + else: + setattr(self, opt, self.default_options[opt]) + + # sanity check client option hash + for opt in options.keys(): + if opt not in self.default_options: + raise KeyError(f"invalid TextFile option '{opt}'") + + if file is None: + self.open(filename) + else: + self.filename = filename + self.file = file + self.current_line = 0 # assuming that file is at BOF! + + # 'linebuf' is a stack of lines that will be emptied before we + # actually read from the file; it's only populated by an + # 'unreadline()' operation + self.linebuf = [] + + def open(self, filename): + """Open a new file named 'filename'. This overrides both the + 'filename' and 'file' arguments to the constructor.""" + self.filename = filename + self.file = open(self.filename, errors=self.errors, encoding='utf-8') + self.current_line = 0 + + def close(self): + """Close the current file and forget everything we know about it + (filename, current line number).""" + file = self.file + self.file = None + self.filename = None + self.current_line = None + file.close() + + def gen_error(self, msg, line=None): + outmsg = [] + if line is None: + line = self.current_line + outmsg.append(self.filename + ", ") + if isinstance(line, (list, tuple)): + outmsg.append("lines {}-{}: ".format(*line)) + else: + outmsg.append(f"line {int(line)}: ") + outmsg.append(str(msg)) + return "".join(outmsg) + + def error(self, msg, line=None): + raise ValueError("error: " + self.gen_error(msg, line)) + + def warn(self, msg, line=None): + """Print (to stderr) a warning message tied to the current logical + line in the current file. If the current logical line in the + file spans multiple physical lines, the warning refers to the + whole range, eg. "lines 3-5". If 'line' supplied, it overrides + the current line number; it may be a list or tuple to indicate a + range of physical lines, or an integer for a single physical + line.""" + sys.stderr.write("warning: " + self.gen_error(msg, line) + "\n") + + def readline(self): # noqa: C901 + """Read and return a single logical line from the current file (or + from an internal buffer if lines have previously been "unread" + with 'unreadline()'). If the 'join_lines' option is true, this + may involve reading multiple physical lines concatenated into a + single string. Updates the current line number, so calling + 'warn()' after 'readline()' emits a warning about the physical + line(s) just read. Returns None on end-of-file, since the empty + string can occur if 'rstrip_ws' is true but 'strip_blanks' is + not.""" + # If any "unread" lines waiting in 'linebuf', return the top + # one. (We don't actually buffer read-ahead data -- lines only + # get put in 'linebuf' if the client explicitly does an + # 'unreadline()'. + if self.linebuf: + line = self.linebuf[-1] + del self.linebuf[-1] + return line + + buildup_line = '' + + while True: + # read the line, make it None if EOF + line = self.file.readline() + if line == '': + line = None + + if self.strip_comments and line: + # Look for the first "#" in the line. If none, never + # mind. If we find one and it's the first character, or + # is not preceded by "\", then it starts a comment -- + # strip the comment, strip whitespace before it, and + # carry on. Otherwise, it's just an escaped "#", so + # unescape it (and any other escaped "#"'s that might be + # lurking in there) and otherwise leave the line alone. + + pos = line.find("#") + if pos == -1: # no "#" -- no comments + pass + + # It's definitely a comment -- either "#" is the first + # character, or it's elsewhere and unescaped. + elif pos == 0 or line[pos - 1] != "\\": + # Have to preserve the trailing newline, because it's + # the job of a later step (rstrip_ws) to remove it -- + # and if rstrip_ws is false, we'd better preserve it! + # (NB. this means that if the final line is all comment + # and has no trailing newline, we will think that it's + # EOF; I think that's OK.) + eol = (line[-1] == '\n') and '\n' or '' + line = line[0:pos] + eol + + # If all that's left is whitespace, then skip line + # *now*, before we try to join it to 'buildup_line' -- + # that way constructs like + # hello \\ + # # comment that should be ignored + # there + # result in "hello there". + if line.strip() == "": + continue + else: # it's an escaped "#" + line = line.replace("\\#", "#") + + # did previous line end with a backslash? then accumulate + if self.join_lines and buildup_line: + # oops: end of file + if line is None: + self.warn("continuation line immediately precedes end-of-file") + return buildup_line + + if self.collapse_join: + line = line.lstrip() + line = buildup_line + line + + # careful: pay attention to line number when incrementing it + if isinstance(self.current_line, list): + self.current_line[1] = self.current_line[1] + 1 + else: + self.current_line = [self.current_line, self.current_line + 1] + # just an ordinary line, read it as usual + else: + if line is None: # eof + return None + + # still have to be careful about incrementing the line number! + if isinstance(self.current_line, list): + self.current_line = self.current_line[1] + 1 + else: + self.current_line = self.current_line + 1 + + # strip whitespace however the client wants (leading and + # trailing, or one or the other, or neither) + if self.lstrip_ws and self.rstrip_ws: + line = line.strip() + elif self.lstrip_ws: + line = line.lstrip() + elif self.rstrip_ws: + line = line.rstrip() + + # blank line (whether we rstrip'ed or not)? skip to next line + # if appropriate + if line in ('', '\n') and self.skip_blanks: + continue + + if self.join_lines: + if line[-1] == '\\': + buildup_line = line[:-1] + continue + + if line[-2:] == '\\\n': + buildup_line = line[0:-2] + '\n' + continue + + # well, I guess there's some actual content there: return it + return line + + def readlines(self): + """Read and return the list of all logical lines remaining in the + current file.""" + lines = [] + while True: + line = self.readline() + if line is None: + return lines + lines.append(line) + + def unreadline(self, line): + """Push 'line' (a string) onto an internal buffer that will be + checked by future 'readline()' calls. Handy for implementing + a parser with line-at-a-time lookahead.""" + self.linebuf.append(line) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/unixccompiler.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/unixccompiler.py new file mode 100644 index 0000000000000000000000000000000000000000..20b8ce6b9bba21bd709b77249bdcae5b4119e9ca --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/unixccompiler.py @@ -0,0 +1,9 @@ +import importlib + +from .compilers.C import unix + +UnixCCompiler = unix.Compiler + +# ensure import of unixccompiler implies ccompiler imported +# (pypa/setuptools#4871) +importlib.import_module('distutils.ccompiler') diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/util.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/util.py new file mode 100644 index 0000000000000000000000000000000000000000..47bb5af5e4b9c78c8b7e3657594562115750db8a --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/util.py @@ -0,0 +1,506 @@ +"""distutils.util + +Miscellaneous utility functions -- anything that doesn't fit into +one of the other *util.py modules. +""" + +from __future__ import annotations + +import functools +import importlib.util +import os +import pathlib +import re +import string +import subprocess +import sys +import sysconfig +import tempfile +from collections.abc import Callable, Iterable, Mapping +from typing import TYPE_CHECKING, AnyStr + +from jaraco.functools import pass_none + +from ._log import log +from ._modified import newer +from .errors import DistutilsByteCompileError, DistutilsPlatformError +from .spawn import spawn + +if TYPE_CHECKING: + from typing_extensions import TypeVarTuple, Unpack + + _Ts = TypeVarTuple("_Ts") + + +def get_host_platform() -> str: + """ + Return a string that identifies the current platform. Use this + function to distinguish platform-specific build directories and + platform-specific built distributions. + """ + + # This function initially exposed platforms as defined in Python 3.9 + # even with older Python versions when distutils was split out. + # Now it delegates to stdlib sysconfig. + + return sysconfig.get_platform() + + +def get_platform() -> str: + if os.name == 'nt': + TARGET_TO_PLAT = { + 'x86': 'win32', + 'x64': 'win-amd64', + 'arm': 'win-arm32', + 'arm64': 'win-arm64', + } + target = os.environ.get('VSCMD_ARG_TGT_ARCH') + return TARGET_TO_PLAT.get(target) or get_host_platform() + return get_host_platform() + + +if sys.platform == 'darwin': + _syscfg_macosx_ver = None # cache the version pulled from sysconfig +MACOSX_VERSION_VAR = 'MACOSX_DEPLOYMENT_TARGET' + + +def _clear_cached_macosx_ver(): + """For testing only. Do not call.""" + global _syscfg_macosx_ver + _syscfg_macosx_ver = None + + +def get_macosx_target_ver_from_syscfg(): + """Get the version of macOS latched in the Python interpreter configuration. + Returns the version as a string or None if can't obtain one. Cached.""" + global _syscfg_macosx_ver + if _syscfg_macosx_ver is None: + from distutils import sysconfig + + ver = sysconfig.get_config_var(MACOSX_VERSION_VAR) or '' + if ver: + _syscfg_macosx_ver = ver + return _syscfg_macosx_ver + + +def get_macosx_target_ver(): + """Return the version of macOS for which we are building. + + The target version defaults to the version in sysconfig latched at time + the Python interpreter was built, unless overridden by an environment + variable. If neither source has a value, then None is returned""" + + syscfg_ver = get_macosx_target_ver_from_syscfg() + env_ver = os.environ.get(MACOSX_VERSION_VAR) + + if env_ver: + # Validate overridden version against sysconfig version, if have both. + # Ensure that the deployment target of the build process is not less + # than 10.3 if the interpreter was built for 10.3 or later. This + # ensures extension modules are built with correct compatibility + # values, specifically LDSHARED which can use + # '-undefined dynamic_lookup' which only works on >= 10.3. + if ( + syscfg_ver + and split_version(syscfg_ver) >= [10, 3] + and split_version(env_ver) < [10, 3] + ): + my_msg = ( + '$' + MACOSX_VERSION_VAR + ' mismatch: ' + f'now "{env_ver}" but "{syscfg_ver}" during configure; ' + 'must use 10.3 or later' + ) + raise DistutilsPlatformError(my_msg) + return env_ver + return syscfg_ver + + +def split_version(s: str) -> list[int]: + """Convert a dot-separated string into a list of numbers for comparisons""" + return [int(n) for n in s.split('.')] + + +@pass_none +def convert_path(pathname: str | os.PathLike[str]) -> str: + r""" + Allow for pathlib.Path inputs, coax to a native path string. + + If None is passed, will just pass it through as + Setuptools relies on this behavior. + + >>> convert_path(None) is None + True + + Removes empty paths. + + >>> convert_path('foo/./bar').replace('\\', '/') + 'foo/bar' + """ + return os.fspath(pathlib.PurePath(pathname)) + + +def change_root( + new_root: AnyStr | os.PathLike[AnyStr], pathname: AnyStr | os.PathLike[AnyStr] +) -> AnyStr: + """Return 'pathname' with 'new_root' prepended. If 'pathname' is + relative, this is equivalent to "os.path.join(new_root,pathname)". + Otherwise, it requires making 'pathname' relative and then joining the + two, which is tricky on DOS/Windows and Mac OS. + """ + if os.name == 'posix': + if not os.path.isabs(pathname): + return os.path.join(new_root, pathname) + else: + return os.path.join(new_root, pathname[1:]) + + elif os.name == 'nt': + (drive, path) = os.path.splitdrive(pathname) + if path[0] == os.sep: + path = path[1:] + return os.path.join(new_root, path) + + raise DistutilsPlatformError(f"nothing known about platform '{os.name}'") + + +@functools.lru_cache +def check_environ() -> None: + """Ensure that 'os.environ' has all the environment variables we + guarantee that users can use in config files, command-line options, + etc. Currently this includes: + HOME - user's home directory (Unix only) + PLAT - description of the current platform, including hardware + and OS (see 'get_platform()') + """ + if os.name == 'posix' and 'HOME' not in os.environ: + try: + import pwd + + os.environ['HOME'] = pwd.getpwuid(os.getuid())[5] + except (ImportError, KeyError): + # bpo-10496: if the current user identifier doesn't exist in the + # password database, do nothing + pass + + if 'PLAT' not in os.environ: + os.environ['PLAT'] = get_platform() + + +def subst_vars(s, local_vars: Mapping[str, object]) -> str: + """ + Perform variable substitution on 'string'. + Variables are indicated by format-style braces ("{var}"). + Variable is substituted by the value found in the 'local_vars' + dictionary or in 'os.environ' if it's not in 'local_vars'. + 'os.environ' is first checked/augmented to guarantee that it contains + certain values: see 'check_environ()'. Raise ValueError for any + variables not found in either 'local_vars' or 'os.environ'. + """ + check_environ() + lookup = dict(os.environ) + lookup.update((name, str(value)) for name, value in local_vars.items()) + try: + return _subst_compat(s).format_map(lookup) + except KeyError as var: + raise ValueError(f"invalid variable {var}") + + +def _subst_compat(s): + """ + Replace shell/Perl-style variable substitution with + format-style. For compatibility. + """ + + def _subst(match): + return f'{{{match.group(1)}}}' + + repl = re.sub(r'\$([a-zA-Z_][a-zA-Z_0-9]*)', _subst, s) + if repl != s: + import warnings + + warnings.warn( + "shell/Perl-style substitutions are deprecated", + DeprecationWarning, + ) + return repl + + +def grok_environment_error(exc: object, prefix: str = "error: ") -> str: + # Function kept for backward compatibility. + # Used to try clever things with EnvironmentErrors, + # but nowadays str(exception) produces good messages. + return prefix + str(exc) + + +# Needed by 'split_quoted()' +_wordchars_re = _squote_re = _dquote_re = None + + +def _init_regex(): + global _wordchars_re, _squote_re, _dquote_re + _wordchars_re = re.compile(rf'[^\\\'\"{string.whitespace} ]*') + _squote_re = re.compile(r"'(?:[^'\\]|\\.)*'") + _dquote_re = re.compile(r'"(?:[^"\\]|\\.)*"') + + +def split_quoted(s: str) -> list[str]: + """Split a string up according to Unix shell-like rules for quotes and + backslashes. In short: words are delimited by spaces, as long as those + spaces are not escaped by a backslash, or inside a quoted string. + Single and double quotes are equivalent, and the quote characters can + be backslash-escaped. The backslash is stripped from any two-character + escape sequence, leaving only the escaped character. The quote + characters are stripped from any quoted string. Returns a list of + words. + """ + + # This is a nice algorithm for splitting up a single string, since it + # doesn't require character-by-character examination. It was a little + # bit of a brain-bender to get it working right, though... + if _wordchars_re is None: + _init_regex() + + s = s.strip() + words = [] + pos = 0 + + while s: + m = _wordchars_re.match(s, pos) + end = m.end() + if end == len(s): + words.append(s[:end]) + break + + if s[end] in string.whitespace: + # unescaped, unquoted whitespace: now + # we definitely have a word delimiter + words.append(s[:end]) + s = s[end:].lstrip() + pos = 0 + + elif s[end] == '\\': + # preserve whatever is being escaped; + # will become part of the current word + s = s[:end] + s[end + 1 :] + pos = end + 1 + + else: + if s[end] == "'": # slurp singly-quoted string + m = _squote_re.match(s, end) + elif s[end] == '"': # slurp doubly-quoted string + m = _dquote_re.match(s, end) + else: + raise RuntimeError(f"this can't happen (bad char '{s[end]}')") + + if m is None: + raise ValueError(f"bad string (mismatched {s[end]} quotes?)") + + (beg, end) = m.span() + s = s[:beg] + s[beg + 1 : end - 1] + s[end:] + pos = m.end() - 2 + + if pos >= len(s): + words.append(s) + break + + return words + + +# split_quoted () + + +def execute( + func: Callable[[Unpack[_Ts]], object], + args: tuple[Unpack[_Ts]], + msg: object = None, + verbose: bool = False, +) -> None: + """ + Perform some action that affects the outside world (e.g. by + writing to the filesystem). Was previously used to deal with + "dry run" operations, but now runs unconditionally. + """ + if msg is None: + msg = f"{func.__name__}{args!r}" + if msg[-2:] == ',)': # correct for singleton tuple + msg = msg[0:-2] + ')' + + log.info(msg) + func(*args) + + +def strtobool(val: str) -> bool: + """Convert a string representation of truth to true (1) or false (0). + + True values are 'y', 'yes', 't', 'true', 'on', and '1'; false values + are 'n', 'no', 'f', 'false', 'off', and '0'. Raises ValueError if + 'val' is anything else. + """ + val = val.lower() + if val in ('y', 'yes', 't', 'true', 'on', '1'): + return True + elif val in ('n', 'no', 'f', 'false', 'off', '0'): + return False + else: + raise ValueError(f"invalid truth value {val!r}") + + +def byte_compile( # noqa: C901 + py_files: Iterable[str], + optimize: int = 0, + force: bool = False, + prefix: str | None = None, + base_dir: str | None = None, + verbose: bool = True, + direct: bool | None = None, +) -> None: + """Byte-compile a collection of Python source files to .pyc + files in a __pycache__ subdirectory. 'py_files' is a list + of files to compile; any files that don't end in ".py" are silently + skipped. 'optimize' must be one of the following: + 0 - don't optimize + 1 - normal optimization (like "python -O") + 2 - extra optimization (like "python -OO") + If 'force' is true, all files are recompiled regardless of + timestamps. + + The source filename encoded in each bytecode file defaults to the + filenames listed in 'py_files'; you can modify these with 'prefix' and + 'basedir'. 'prefix' is a string that will be stripped off of each + source filename, and 'base_dir' is a directory name that will be + prepended (after 'prefix' is stripped). You can supply either or both + (or neither) of 'prefix' and 'base_dir', as you wish. + + Byte-compilation is either done directly in this interpreter process + with the standard py_compile module, or indirectly by writing a + temporary script and executing it. Normally, you should let + 'byte_compile()' figure out to use direct compilation or not (see + the source for details). The 'direct' flag is used by the script + generated in indirect mode; unless you know what you're doing, leave + it set to None. + """ + + # nothing is done if sys.dont_write_bytecode is True + if sys.dont_write_bytecode: + raise DistutilsByteCompileError('byte-compiling is disabled.') + + # First, if the caller didn't force us into direct or indirect mode, + # figure out which mode we should be in. We take a conservative + # approach: choose direct mode *only* if the current interpreter is + # in debug mode and optimize is 0. If we're not in debug mode (-O + # or -OO), we don't know which level of optimization this + # interpreter is running with, so we can't do direct + # byte-compilation and be certain that it's the right thing. Thus, + # always compile indirectly if the current interpreter is in either + # optimize mode, or if either optimization level was requested by + # the caller. + if direct is None: + direct = __debug__ and optimize == 0 + + # "Indirect" byte-compilation: write a temporary script and then + # run it with the appropriate flags. + if not direct: + (script_fd, script_name) = tempfile.mkstemp(".py") + log.info("writing byte-compilation script '%s'", script_name) + script = os.fdopen(script_fd, "w", encoding='utf-8') + + with script: + script.write( + """\ +from distutils.util import byte_compile +files = [ +""" + ) + + # XXX would be nice to write absolute filenames, just for + # safety's sake (script should be more robust in the face of + # chdir'ing before running it). But this requires abspath'ing + # 'prefix' as well, and that breaks the hack in build_lib's + # 'byte_compile()' method that carefully tacks on a trailing + # slash (os.sep really) to make sure the prefix here is "just + # right". This whole prefix business is rather delicate -- the + # problem is that it's really a directory, but I'm treating it + # as a dumb string, so trailing slashes and so forth matter. + + script.write(",\n".join(map(repr, py_files)) + "]\n") + script.write( + f""" +byte_compile(files, optimize={optimize!r}, force={force!r}, + prefix={prefix!r}, base_dir={base_dir!r}, + verbose={verbose!r}, + direct=True) +""" + ) + + cmd = [sys.executable] + cmd.extend(subprocess._optim_args_from_interpreter_flags()) + cmd.append(script_name) + spawn(cmd) + execute(os.remove, (script_name,), f"removing {script_name}") + + # "Direct" byte-compilation: use the py_compile module to compile + # right here, right now. Note that the script generated in indirect + # mode simply calls 'byte_compile()' in direct mode, a weird sort of + # cross-process recursion. Hey, it works! + else: + from py_compile import compile + + for file in py_files: + if file[-3:] != ".py": + # This lets us be lazy and not filter filenames in + # the "install_lib" command. + continue + + # Terminology from the py_compile module: + # cfile - byte-compiled file + # dfile - purported source filename (same as 'file' by default) + if optimize >= 0: + opt = '' if optimize == 0 else optimize + cfile = importlib.util.cache_from_source(file, optimization=opt) + else: + cfile = importlib.util.cache_from_source(file) + dfile = file + if prefix: + if file[: len(prefix)] != prefix: + raise ValueError( + f"invalid prefix: filename {file!r} doesn't start with {prefix!r}" + ) + dfile = dfile[len(prefix) :] + if base_dir: + dfile = os.path.join(base_dir, dfile) + + cfile_base = os.path.basename(cfile) + if direct: + if force or newer(file, cfile): + log.info("byte-compiling %s to %s", file, cfile_base) + compile(file, cfile, dfile) + else: + log.debug("skipping byte-compilation of %s to %s", file, cfile_base) + + +def rfc822_escape(header: str) -> str: + """Return a version of the string escaped for inclusion in an + RFC-822 header, by ensuring there are 8 spaces space after each newline. + """ + indent = 8 * " " + lines = header.splitlines(keepends=True) + + # Emulate the behaviour of `str.split` + # (the terminal line break in `splitlines` does not result in an extra line): + ends_in_newline = lines and lines[-1].splitlines()[0] != lines[-1] + suffix = indent if ends_in_newline else "" + + return indent.join(lines) + suffix + + +def is_mingw() -> bool: + """Returns True if the current platform is mingw. + + Python compiled with Mingw-w64 has sys.platform == 'win32' and + get_platform() starts with 'mingw'. + """ + return sys.platform == 'win32' and get_platform().startswith('mingw') + + +def is_freethreaded(): + """Return True if the Python interpreter is built with free threading support.""" + return bool(sysconfig.get_config_var('Py_GIL_DISABLED')) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/version.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/version.py new file mode 100644 index 0000000000000000000000000000000000000000..2223ee9c8cab2495034a57d4585625feb81a8330 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/version.py @@ -0,0 +1,348 @@ +# +# distutils/version.py +# +# Implements multiple version numbering conventions for the +# Python Module Distribution Utilities. +# +# $Id$ +# + +"""Provides classes to represent module version numbers (one class for +each style of version numbering). There are currently two such classes +implemented: StrictVersion and LooseVersion. + +Every version number class implements the following interface: + * the 'parse' method takes a string and parses it to some internal + representation; if the string is an invalid version number, + 'parse' raises a ValueError exception + * the class constructor takes an optional string argument which, + if supplied, is passed to 'parse' + * __str__ reconstructs the string that was passed to 'parse' (or + an equivalent string -- ie. one that will generate an equivalent + version number instance) + * __repr__ generates Python code to recreate the version number instance + * _cmp compares the current instance with either another instance + of the same class or a string (which will be parsed to an instance + of the same class, thus must follow the same rules) +""" + +import contextlib +import re +import warnings + + +@contextlib.contextmanager +def suppress_known_deprecation(): + with warnings.catch_warnings(record=True) as ctx: + warnings.filterwarnings( + action='default', + category=DeprecationWarning, + message="distutils Version classes are deprecated.", + ) + yield ctx + + +class Version: + """Abstract base class for version numbering classes. Just provides + constructor (__init__) and reproducer (__repr__), because those + seem to be the same for all version numbering classes; and route + rich comparisons to _cmp. + """ + + def __init__(self, vstring=None): + if vstring: + self.parse(vstring) + warnings.warn( + "distutils Version classes are deprecated. Use packaging.version instead.", + DeprecationWarning, + stacklevel=2, + ) + + def __repr__(self): + return f"{self.__class__.__name__} ('{self}')" + + def __eq__(self, other): + c = self._cmp(other) + if c is NotImplemented: + return c + return c == 0 + + def __lt__(self, other): + c = self._cmp(other) + if c is NotImplemented: + return c + return c < 0 + + def __le__(self, other): + c = self._cmp(other) + if c is NotImplemented: + return c + return c <= 0 + + def __gt__(self, other): + c = self._cmp(other) + if c is NotImplemented: + return c + return c > 0 + + def __ge__(self, other): + c = self._cmp(other) + if c is NotImplemented: + return c + return c >= 0 + + +# Interface for version-number classes -- must be implemented +# by the following classes (the concrete ones -- Version should +# be treated as an abstract class). +# __init__ (string) - create and take same action as 'parse' +# (string parameter is optional) +# parse (string) - convert a string representation to whatever +# internal representation is appropriate for +# this style of version numbering +# __str__ (self) - convert back to a string; should be very similar +# (if not identical to) the string supplied to parse +# __repr__ (self) - generate Python code to recreate +# the instance +# _cmp (self, other) - compare two version numbers ('other' may +# be an unparsed version string, or another +# instance of your version class) + + +class StrictVersion(Version): + """Version numbering for anal retentives and software idealists. + Implements the standard interface for version number classes as + described above. A version number consists of two or three + dot-separated numeric components, with an optional "pre-release" tag + on the end. The pre-release tag consists of the letter 'a' or 'b' + followed by a number. If the numeric components of two version + numbers are equal, then one with a pre-release tag will always + be deemed earlier (lesser) than one without. + + The following are valid version numbers (shown in the order that + would be obtained by sorting according to the supplied cmp function): + + 0.4 0.4.0 (these two are equivalent) + 0.4.1 + 0.5a1 + 0.5b3 + 0.5 + 0.9.6 + 1.0 + 1.0.4a3 + 1.0.4b1 + 1.0.4 + + The following are examples of invalid version numbers: + + 1 + 2.7.2.2 + 1.3.a4 + 1.3pl1 + 1.3c4 + + The rationale for this version numbering system will be explained + in the distutils documentation. + """ + + version_re = re.compile( + r'^(\d+) \. (\d+) (\. (\d+))? ([ab](\d+))?$', re.VERBOSE | re.ASCII + ) + + def parse(self, vstring): + match = self.version_re.match(vstring) + if not match: + raise ValueError(f"invalid version number '{vstring}'") + + (major, minor, patch, prerelease, prerelease_num) = match.group(1, 2, 4, 5, 6) + + if patch: + self.version = tuple(map(int, [major, minor, patch])) + else: + self.version = tuple(map(int, [major, minor])) + (0,) + + if prerelease: + self.prerelease = (prerelease[0], int(prerelease_num)) + else: + self.prerelease = None + + def __str__(self): + if self.version[2] == 0: + vstring = '.'.join(map(str, self.version[0:2])) + else: + vstring = '.'.join(map(str, self.version)) + + if self.prerelease: + vstring = vstring + self.prerelease[0] + str(self.prerelease[1]) + + return vstring + + def _cmp(self, other): + if isinstance(other, str): + with suppress_known_deprecation(): + other = StrictVersion(other) + elif not isinstance(other, StrictVersion): + return NotImplemented + + if self.version == other.version: + # versions match; pre-release drives the comparison + return self._cmp_prerelease(other) + + return -1 if self.version < other.version else 1 + + def _cmp_prerelease(self, other): + """ + case 1: self has prerelease, other doesn't; other is greater + case 2: self doesn't have prerelease, other does: self is greater + case 3: both or neither have prerelease: compare them! + """ + if self.prerelease and not other.prerelease: + return -1 + elif not self.prerelease and other.prerelease: + return 1 + + if self.prerelease == other.prerelease: + return 0 + elif self.prerelease < other.prerelease: + return -1 + else: + return 1 + + +# end class StrictVersion + + +# The rules according to Greg Stein: +# 1) a version number has 1 or more numbers separated by a period or by +# sequences of letters. If only periods, then these are compared +# left-to-right to determine an ordering. +# 2) sequences of letters are part of the tuple for comparison and are +# compared lexicographically +# 3) recognize the numeric components may have leading zeroes +# +# The LooseVersion class below implements these rules: a version number +# string is split up into a tuple of integer and string components, and +# comparison is a simple tuple comparison. This means that version +# numbers behave in a predictable and obvious way, but a way that might +# not necessarily be how people *want* version numbers to behave. There +# wouldn't be a problem if people could stick to purely numeric version +# numbers: just split on period and compare the numbers as tuples. +# However, people insist on putting letters into their version numbers; +# the most common purpose seems to be: +# - indicating a "pre-release" version +# ('alpha', 'beta', 'a', 'b', 'pre', 'p') +# - indicating a post-release patch ('p', 'pl', 'patch') +# but of course this can't cover all version number schemes, and there's +# no way to know what a programmer means without asking him. +# +# The problem is what to do with letters (and other non-numeric +# characters) in a version number. The current implementation does the +# obvious and predictable thing: keep them as strings and compare +# lexically within a tuple comparison. This has the desired effect if +# an appended letter sequence implies something "post-release": +# eg. "0.99" < "0.99pl14" < "1.0", and "5.001" < "5.001m" < "5.002". +# +# However, if letters in a version number imply a pre-release version, +# the "obvious" thing isn't correct. Eg. you would expect that +# "1.5.1" < "1.5.2a2" < "1.5.2", but under the tuple/lexical comparison +# implemented here, this just isn't so. +# +# Two possible solutions come to mind. The first is to tie the +# comparison algorithm to a particular set of semantic rules, as has +# been done in the StrictVersion class above. This works great as long +# as everyone can go along with bondage and discipline. Hopefully a +# (large) subset of Python module programmers will agree that the +# particular flavour of bondage and discipline provided by StrictVersion +# provides enough benefit to be worth using, and will submit their +# version numbering scheme to its domination. The free-thinking +# anarchists in the lot will never give in, though, and something needs +# to be done to accommodate them. +# +# Perhaps a "moderately strict" version class could be implemented that +# lets almost anything slide (syntactically), and makes some heuristic +# assumptions about non-digits in version number strings. This could +# sink into special-case-hell, though; if I was as talented and +# idiosyncratic as Larry Wall, I'd go ahead and implement a class that +# somehow knows that "1.2.1" < "1.2.2a2" < "1.2.2" < "1.2.2pl3", and is +# just as happy dealing with things like "2g6" and "1.13++". I don't +# think I'm smart enough to do it right though. +# +# In any case, I've coded the test suite for this module (see +# ../test/test_version.py) specifically to fail on things like comparing +# "1.2a2" and "1.2". That's not because the *code* is doing anything +# wrong, it's because the simple, obvious design doesn't match my +# complicated, hairy expectations for real-world version numbers. It +# would be a snap to fix the test suite to say, "Yep, LooseVersion does +# the Right Thing" (ie. the code matches the conception). But I'd rather +# have a conception that matches common notions about version numbers. + + +class LooseVersion(Version): + """Version numbering for anarchists and software realists. + Implements the standard interface for version number classes as + described above. A version number consists of a series of numbers, + separated by either periods or strings of letters. When comparing + version numbers, the numeric components will be compared + numerically, and the alphabetic components lexically. The following + are all valid version numbers, in no particular order: + + 1.5.1 + 1.5.2b2 + 161 + 3.10a + 8.02 + 3.4j + 1996.07.12 + 3.2.pl0 + 3.1.1.6 + 2g6 + 11g + 0.960923 + 2.2beta29 + 1.13++ + 5.5.kw + 2.0b1pl0 + + In fact, there is no such thing as an invalid version number under + this scheme; the rules for comparison are simple and predictable, + but may not always give the results you want (for some definition + of "want"). + """ + + component_re = re.compile(r'(\d+ | [a-z]+ | \.)', re.VERBOSE) + + def parse(self, vstring): + # I've given up on thinking I can reconstruct the version string + # from the parsed tuple -- so I just store the string here for + # use by __str__ + self.vstring = vstring + components = [x for x in self.component_re.split(vstring) if x and x != '.'] + for i, obj in enumerate(components): + try: + components[i] = int(obj) + except ValueError: + pass + + self.version = components + + def __str__(self): + return self.vstring + + def __repr__(self): + return f"LooseVersion ('{self}')" + + def _cmp(self, other): + if isinstance(other, str): + other = LooseVersion(other) + elif not isinstance(other, LooseVersion): + return NotImplemented + + if self.version == other.version: + return 0 + if self.version < other.version: + return -1 + if self.version > other.version: + return 1 + + +# end class LooseVersion diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/versionpredicate.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/versionpredicate.py new file mode 100644 index 0000000000000000000000000000000000000000..fe31b0ed8ef843080ea64df9f58a398d317434ad --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/versionpredicate.py @@ -0,0 +1,175 @@ +"""Module for parsing and testing package version predicate strings.""" + +import operator +import re + +from . import version + +re_validPackage = re.compile(r"(?i)^\s*([a-z_]\w*(?:\.[a-z_]\w*)*)(.*)", re.ASCII) +# (package) (rest) + +re_paren = re.compile(r"^\s*\((.*)\)\s*$") # (list) inside of parentheses +re_splitComparison = re.compile(r"^\s*(<=|>=|<|>|!=|==)\s*([^\s,]+)\s*$") +# (comp) (version) + + +def splitUp(pred): + """Parse a single version comparison. + + Return (comparison string, StrictVersion) + """ + res = re_splitComparison.match(pred) + if not res: + raise ValueError(f"bad package restriction syntax: {pred!r}") + comp, verStr = res.groups() + with version.suppress_known_deprecation(): + other = version.StrictVersion(verStr) + return (comp, other) + + +compmap = { + "<": operator.lt, + "<=": operator.le, + "==": operator.eq, + ">": operator.gt, + ">=": operator.ge, + "!=": operator.ne, +} + + +class VersionPredicate: + """Parse and test package version predicates. + + >>> v = VersionPredicate('pyepat.abc (>1.0, <3333.3a1, !=1555.1b3)') + + The `name` attribute provides the full dotted name that is given:: + + >>> v.name + 'pyepat.abc' + + The str() of a `VersionPredicate` provides a normalized + human-readable version of the expression:: + + >>> print(v) + pyepat.abc (> 1.0, < 3333.3a1, != 1555.1b3) + + The `satisfied_by()` method can be used to determine with a given + version number is included in the set described by the version + restrictions:: + + >>> v.satisfied_by('1.1') + True + >>> v.satisfied_by('1.4') + True + >>> v.satisfied_by('1.0') + False + >>> v.satisfied_by('4444.4') + False + >>> v.satisfied_by('1555.1b3') + False + + `VersionPredicate` is flexible in accepting extra whitespace:: + + >>> v = VersionPredicate(' pat( == 0.1 ) ') + >>> v.name + 'pat' + >>> v.satisfied_by('0.1') + True + >>> v.satisfied_by('0.2') + False + + If any version numbers passed in do not conform to the + restrictions of `StrictVersion`, a `ValueError` is raised:: + + >>> v = VersionPredicate('p1.p2.p3.p4(>=1.0, <=1.3a1, !=1.2zb3)') + Traceback (most recent call last): + ... + ValueError: invalid version number '1.2zb3' + + It the module or package name given does not conform to what's + allowed as a legal module or package name, `ValueError` is + raised:: + + >>> v = VersionPredicate('foo-bar') + Traceback (most recent call last): + ... + ValueError: expected parenthesized list: '-bar' + + >>> v = VersionPredicate('foo bar (12.21)') + Traceback (most recent call last): + ... + ValueError: expected parenthesized list: 'bar (12.21)' + + """ + + def __init__(self, versionPredicateStr): + """Parse a version predicate string.""" + # Fields: + # name: package name + # pred: list of (comparison string, StrictVersion) + + versionPredicateStr = versionPredicateStr.strip() + if not versionPredicateStr: + raise ValueError("empty package restriction") + match = re_validPackage.match(versionPredicateStr) + if not match: + raise ValueError(f"bad package name in {versionPredicateStr!r}") + self.name, paren = match.groups() + paren = paren.strip() + if paren: + match = re_paren.match(paren) + if not match: + raise ValueError(f"expected parenthesized list: {paren!r}") + str = match.groups()[0] + self.pred = [splitUp(aPred) for aPred in str.split(",")] + if not self.pred: + raise ValueError(f"empty parenthesized list in {versionPredicateStr!r}") + else: + self.pred = [] + + def __str__(self): + if self.pred: + seq = [cond + " " + str(ver) for cond, ver in self.pred] + return self.name + " (" + ", ".join(seq) + ")" + else: + return self.name + + def satisfied_by(self, version): + """True if version is compatible with all the predicates in self. + The parameter version must be acceptable to the StrictVersion + constructor. It may be either a string or StrictVersion. + """ + for cond, ver in self.pred: + if not compmap[cond](version, ver): + return False + return True + + +_provision_rx = None + + +def split_provision(value): + """Return the name and optional version number of a provision. + + The version number, if given, will be returned as a `StrictVersion` + instance, otherwise it will be `None`. + + >>> split_provision('mypkg') + ('mypkg', None) + >>> split_provision(' mypkg( 1.2 ) ') + ('mypkg', StrictVersion ('1.2')) + """ + global _provision_rx + if _provision_rx is None: + _provision_rx = re.compile( + r"([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)(?:\s*\(\s*([^)\s]+)\s*\))?$", re.ASCII + ) + value = value.strip() + m = _provision_rx.match(value) + if not m: + raise ValueError(f"illegal provides specification: {value!r}") + ver = m.group(2) or None + if ver: + with version.suppress_known_deprecation(): + ver = version.StrictVersion(ver) + return m.group(1), ver diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/zosccompiler.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/zosccompiler.py new file mode 100644 index 0000000000000000000000000000000000000000..e49630ac6ed8cad62c4d2ff8361758519e6dc83b --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_distutils/zosccompiler.py @@ -0,0 +1,3 @@ +from .compilers.C import zos + +zOSCCompiler = zos.Compiler diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/.lock b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/INSTALLER b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..5c69047b2eb8235994febeeae1da4a82365a240a --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/INSTALLER @@ -0,0 +1 @@ +uv \ No newline at end of file diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/LICENSE b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b49c3af060ce6326b8d91b9b73e76456ea0d9d2b --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/LICENSE @@ -0,0 +1,166 @@ +GNU LESSER GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + + This version of the GNU Lesser General Public License incorporates +the terms and conditions of version 3 of the GNU General Public +License, supplemented by the additional permissions listed below. + + 0. Additional Definitions. + + As used herein, "this License" refers to version 3 of the GNU Lesser +General Public License, and the "GNU GPL" refers to version 3 of the GNU +General Public License. + + "The Library" refers to a covered work governed by this License, +other than an Application or a Combined Work as defined below. + + An "Application" is any work that makes use of an interface provided +by the Library, but which is not otherwise based on the Library. +Defining a subclass of a class defined by the Library is deemed a mode +of using an interface provided by the Library. + + A "Combined Work" is a work produced by combining or linking an +Application with the Library. The particular version of the Library +with which the Combined Work was made is also called the "Linked +Version". + + The "Minimal Corresponding Source" for a Combined Work means the +Corresponding Source for the Combined Work, excluding any source code +for portions of the Combined Work that, considered in isolation, are +based on the Application, and not on the Linked Version. + + The "Corresponding Application Code" for a Combined Work means the +object code and/or source code for the Application, including any data +and utility programs needed for reproducing the Combined Work from the +Application, but excluding the System Libraries of the Combined Work. + + 1. Exception to Section 3 of the GNU GPL. + + You may convey a covered work under sections 3 and 4 of this License +without being bound by section 3 of the GNU GPL. + + 2. Conveying Modified Versions. + + If you modify a copy of the Library, and, in your modifications, a +facility refers to a function or data to be supplied by an Application +that uses the facility (other than as an argument passed when the +facility is invoked), then you may convey a copy of the modified +version: + + a) under this License, provided that you make a good faith effort to + ensure that, in the event an Application does not supply the + function or data, the facility still operates, and performs + whatever part of its purpose remains meaningful, or + + b) under the GNU GPL, with none of the additional permissions of + this License applicable to that copy. + + 3. Object Code Incorporating Material from Library Header Files. + + The object code form of an Application may incorporate material from +a header file that is part of the Library. You may convey such object +code under terms of your choice, provided that, if the incorporated +material is not limited to numerical parameters, data structure +layouts and accessors, or small macros, inline functions and templates +(ten or fewer lines in length), you do both of the following: + + a) Give prominent notice with each copy of the object code that the + Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the object code with a copy of the GNU GPL and this license + document. + + 4. Combined Works. + + You may convey a Combined Work under terms of your choice that, +taken together, effectively do not restrict modification of the +portions of the Library contained in the Combined Work and reverse +engineering for debugging such modifications, if you also do each of +the following: + + a) Give prominent notice with each copy of the Combined Work that + the Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the Combined Work with a copy of the GNU GPL and this license + document. + + c) For a Combined Work that displays copyright notices during + execution, include the copyright notice for the Library among + these notices, as well as a reference directing the user to the + copies of the GNU GPL and this license document. + + d) Do one of the following: + + 0) Convey the Minimal Corresponding Source under the terms of this + License, and the Corresponding Application Code in a form + suitable for, and under terms that permit, the user to + recombine or relink the Application with a modified version of + the Linked Version to produce a modified Combined Work, in the + manner specified by section 6 of the GNU GPL for conveying + Corresponding Source. + + 1) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (a) uses at run time + a copy of the Library already present on the user's computer + system, and (b) will operate properly with a modified version + of the Library that is interface-compatible with the Linked + Version. + + e) Provide Installation Information, but only if you would otherwise + be required to provide such information under section 6 of the + GNU GPL, and only to the extent that such information is + necessary to install and execute a modified version of the + Combined Work produced by recombining or relinking the + Application with a modified version of the Linked Version. (If + you use option 4d0, the Installation Information must accompany + the Minimal Corresponding Source and Corresponding Application + Code. If you use option 4d1, you must provide the Installation + Information in the manner specified by section 6 of the GNU GPL + for conveying Corresponding Source.) + + 5. Combined Libraries. + + You may place library facilities that are a work based on the +Library side by side in a single library together with other library +facilities that are not Applications and are not covered by this +License, and convey such a combined library under terms of your +choice, if you do both of the following: + + a) Accompany the combined library with a copy of the same work based + on the Library, uncombined with any other library facilities, + conveyed under the terms of this License. + + b) Give prominent notice with the combined library that part of it + is a work based on the Library, and explaining where to find the + accompanying uncombined form of the same work. + + 6. Revised Versions of the GNU Lesser General Public License. + + The Free Software Foundation may publish revised and/or new versions +of the GNU Lesser General Public License from time to time. Such new +versions will be similar in spirit to the present version, but may +differ in detail to address new problems or concerns. + + Each version is given a distinguishing version number. If the +Library as you received it specifies that a certain numbered version +of the GNU Lesser General Public License "or any later version" +applies to it, you have the option of following the terms and +conditions either of that published version or of any later version +published by the Free Software Foundation. If the Library as you +received it does not specify a version number of the GNU Lesser +General Public License, you may choose any version of the GNU Lesser +General Public License ever published by the Free Software Foundation. + + If the Library as you received it specifies that a proxy can decide +whether future versions of the GNU Lesser General Public License shall +apply, that proxy's public statement of acceptance of any version is +permanent authorization for you to choose that version for the +Library. + diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/METADATA b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..32214fb4400035788bfe5c0de42dad106a4f54f1 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/METADATA @@ -0,0 +1,420 @@ +Metadata-Version: 2.1 +Name: autocommand +Version: 2.2.2 +Summary: A library to create a command-line program from a function +Home-page: https://github.com/Lucretiel/autocommand +Author: Nathan West +License: LGPLv3 +Project-URL: Homepage, https://github.com/Lucretiel/autocommand +Project-URL: Bug Tracker, https://github.com/Lucretiel/autocommand/issues +Platform: any +Classifier: Development Status :: 6 - Mature +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3) +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Topic :: Software Development +Classifier: Topic :: Software Development :: Libraries +Classifier: Topic :: Software Development :: Libraries :: Python Modules +Requires-Python: >=3.7 +Description-Content-Type: text/markdown +License-File: LICENSE + +[![PyPI version](https://badge.fury.io/py/autocommand.svg)](https://badge.fury.io/py/autocommand) + +# autocommand + +A library to automatically generate and run simple argparse parsers from function signatures. + +## Installation + +Autocommand is installed via pip: + +``` +$ pip install autocommand +``` + +## Usage + +Autocommand turns a function into a command-line program. It converts the function's parameter signature into command-line arguments, and automatically runs the function if the module was called as `__main__`. In effect, it lets your create a smart main function. + +```python +from autocommand import autocommand + +# This program takes exactly one argument and echos it. +@autocommand(__name__) +def echo(thing): + print(thing) +``` + +``` +$ python echo.py hello +hello +$ python echo.py -h +usage: echo [-h] thing + +positional arguments: + thing + +optional arguments: + -h, --help show this help message and exit +$ python echo.py hello world # too many arguments +usage: echo.py [-h] thing +echo.py: error: unrecognized arguments: world +``` + +As you can see, autocommand converts the signature of the function into an argument spec. When you run the file as a program, autocommand collects the command-line arguments and turns them into function arguments. The function is executed with these arguments, and then the program exits with the return value of the function, via `sys.exit`. Autocommand also automatically creates a usage message, which can be invoked with `-h` or `--help`, and automatically prints an error message when provided with invalid arguments. + +### Types + +You can use a type annotation to give an argument a type. Any type (or in fact any callable) that returns an object when given a string argument can be used, though there are a few special cases that are described later. + +```python +@autocommand(__name__) +def net_client(host, port: int): + ... +``` + +Autocommand will catch `TypeErrors` raised by the type during argument parsing, so you can supply a callable and do some basic argument validation as well. + +### Trailing Arguments + +You can add a `*args` parameter to your function to give it trailing arguments. The command will collect 0 or more trailing arguments and supply them to `args` as a tuple. If a type annotation is supplied, the type is applied to each argument. + +```python +# Write the contents of each file, one by one +@autocommand(__name__) +def cat(*files): + for filename in files: + with open(filename) as file: + for line in file: + print(line.rstrip()) +``` + +``` +$ python cat.py -h +usage: ipython [-h] [file [file ...]] + +positional arguments: + file + +optional arguments: + -h, --help show this help message and exit +``` + +### Options + +To create `--option` switches, just assign a default. Autocommand will automatically create `--long` and `-s`hort switches. + +```python +@autocommand(__name__) +def do_with_config(argument, config='~/foo.conf'): + pass +``` + +``` +$ python example.py -h +usage: example.py [-h] [-c CONFIG] argument + +positional arguments: + argument + +optional arguments: + -h, --help show this help message and exit + -c CONFIG, --config CONFIG +``` + +The option's type is automatically deduced from the default, unless one is explicitly given in an annotation: + +```python +@autocommand(__name__) +def http_connect(host, port=80): + print('{}:{}'.format(host, port)) +``` + +``` +$ python http.py -h +usage: http.py [-h] [-p PORT] host + +positional arguments: + host + +optional arguments: + -h, --help show this help message and exit + -p PORT, --port PORT +$ python http.py localhost +localhost:80 +$ python http.py localhost -p 8080 +localhost:8080 +$ python http.py localhost -p blah +usage: http.py [-h] [-p PORT] host +http.py: error: argument -p/--port: invalid int value: 'blah' +``` + +#### None + +If an option is given a default value of `None`, it reads in a value as normal, but supplies `None` if the option isn't provided. + +#### Switches + +If an argument is given a default value of `True` or `False`, or +given an explicit `bool` type, it becomes an option switch. + +```python + @autocommand(__name__) + def example(verbose=False, quiet=False): + pass +``` + +``` +$ python example.py -h +usage: example.py [-h] [-v] [-q] + +optional arguments: + -h, --help show this help message and exit + -v, --verbose + -q, --quiet +``` + +Autocommand attempts to do the "correct thing" in these cases- if the default is `True`, then supplying the switch makes the argument `False`; if the type is `bool` and the default is some other `True` value, then supplying the switch makes the argument `False`, while not supplying the switch makes the argument the default value. + +Autocommand also supports the creation of switch inverters. Pass `add_nos=True` to `autocommand` to enable this. + +``` + @autocommand(__name__, add_nos=True) + def example(verbose=False): + pass +``` + +``` +$ python example.py -h +usage: ipython [-h] [-v] [--no-verbose] + +optional arguments: + -h, --help show this help message and exit + -v, --verbose + --no-verbose +``` + +Using the `--no-` version of a switch will pass the opposite value in as a function argument. If multiple switches are present, the last one takes precedence. + +#### Files + +If the default value is a file object, such as `sys.stdout`, then autocommand just looks for a string, for a file path. It doesn't do any special checking on the string, though (such as checking if the file exists); it's better to let the client decide how to handle errors in this case. Instead, it provides a special context manager called `smart_open`, which behaves exactly like `open` if a filename or other openable type is provided, but also lets you use already open files: + +```python +from autocommand import autocommand, smart_open +import sys + +# Write the contents of stdin, or a file, to stdout +@autocommand(__name__) +def write_out(infile=sys.stdin): + with smart_open(infile) as f: + for line in f: + print(line.rstrip()) + # If a file was opened, it is closed here. If it was just stdin, it is untouched. +``` + +``` +$ echo "Hello World!" | python write_out.py | tee hello.txt +Hello World! +$ python write_out.py --infile hello.txt +Hello World! +``` + +### Descriptions and docstrings + +The `autocommand` decorator accepts `description` and `epilog` kwargs, corresponding to the `description `_ and `epilog `_ of the `ArgumentParser`. If no description is given, but the decorated function has a docstring, then it is taken as the `description` for the `ArgumentParser`. You can also provide both the description and epilog in the docstring by splitting it into two sections with 4 or more - characters. + +```python +@autocommand(__name__) +def copy(infile=sys.stdin, outfile=sys.stdout): + ''' + Copy an the contents of a file (or stdin) to another file (or stdout) + ---------- + Some extra documentation in the epilog + ''' + with smart_open(infile) as istr: + with smart_open(outfile, 'w') as ostr: + for line in istr: + ostr.write(line) +``` + +``` +$ python copy.py -h +usage: copy.py [-h] [-i INFILE] [-o OUTFILE] + +Copy an the contents of a file (or stdin) to another file (or stdout) + +optional arguments: + -h, --help show this help message and exit + -i INFILE, --infile INFILE + -o OUTFILE, --outfile OUTFILE + +Some extra documentation in the epilog +$ echo "Hello World" | python copy.py --outfile hello.txt +$ python copy.py --infile hello.txt --outfile hello2.txt +$ python copy.py --infile hello2.txt +Hello World +``` + +### Parameter descriptions + +You can also attach description text to individual parameters in the annotation. To attach both a type and a description, supply them both in any order in a tuple + +```python +@autocommand(__name__) +def copy_net( + infile: 'The name of the file to send', + host: 'The host to send the file to', + port: (int, 'The port to connect to')): + + ''' + Copy a file over raw TCP to a remote destination. + ''' + # Left as an exercise to the reader +``` + +### Decorators and wrappers + +Autocommand automatically follows wrapper chains created by `@functools.wraps`. This means that you can apply other wrapping decorators to your main function, and autocommand will still correctly detect the signature. + +```python +from functools import wraps +from autocommand import autocommand + +def print_yielded(func): + ''' + Convert a generator into a function that prints all yielded elements + ''' + @wraps(func) + def wrapper(*args, **kwargs): + for thing in func(*args, **kwargs): + print(thing) + return wrapper + +@autocommand(__name__, + description= 'Print all the values from START to STOP, inclusive, in steps of STEP', + epilog= 'STOP and STEP default to 1') +@print_yielded +def seq(stop, start=1, step=1): + for i in range(start, stop + 1, step): + yield i +``` + +``` +$ seq.py -h +usage: seq.py [-h] [-s START] [-S STEP] stop + +Print all the values from START to STOP, inclusive, in steps of STEP + +positional arguments: + stop + +optional arguments: + -h, --help show this help message and exit + -s START, --start START + -S STEP, --step STEP + +STOP and STEP default to 1 +``` + +Even though autocommand is being applied to the `wrapper` returned by `print_yielded`, it still retreives the signature of the underlying `seq` function to create the argument parsing. + +### Custom Parser + +While autocommand's automatic parser generator is a powerful convenience, it doesn't cover all of the different features that argparse provides. If you need these features, you can provide your own parser as a kwarg to `autocommand`: + +```python +from argparse import ArgumentParser +from autocommand import autocommand + +parser = ArgumentParser() +# autocommand can't do optional positonal parameters +parser.add_argument('arg', nargs='?') +# or mutually exclusive options +group = parser.add_mutually_exclusive_group() +group.add_argument('-v', '--verbose', action='store_true') +group.add_argument('-q', '--quiet', action='store_true') + +@autocommand(__name__, parser=parser) +def main(arg, verbose, quiet): + print(arg, verbose, quiet) +``` + +``` +$ python parser.py -h +usage: write_file.py [-h] [-v | -q] [arg] + +positional arguments: + arg + +optional arguments: + -h, --help show this help message and exit + -v, --verbose + -q, --quiet +$ python parser.py +None False False +$ python parser.py hello +hello False False +$ python parser.py -v +None True False +$ python parser.py -q +None False True +$ python parser.py -vq +usage: parser.py [-h] [-v | -q] [arg] +parser.py: error: argument -q/--quiet: not allowed with argument -v/--verbose +``` + +Any parser should work fine, so long as each of the parser's arguments has a corresponding parameter in the decorated main function. The order of parameters doesn't matter, as long as they are all present. Note that when using a custom parser, autocommand doesn't modify the parser or the retrieved arguments. This means that no description/epilog will be added, and the function's type annotations and defaults (if present) will be ignored. + +## Testing and Library use + +The decorated function is only called and exited from if the first argument to `autocommand` is `'__main__'` or `True`. If it is neither of these values, or no argument is given, then a new main function is created by the decorator. This function has the signature `main(argv=None)`, and is intended to be called with arguments as if via `main(sys.argv[1:])`. The function has the attributes `parser` and `main`, which are the generated `ArgumentParser` and the original main function that was decorated. This is to facilitate testing and library use of your main. Calling the function triggers a `parse_args()` with the supplied arguments, and returns the result of the main function. Note that, while it returns instead of calling `sys.exit`, the `parse_args()` function will raise a `SystemExit` in the event of a parsing error or `-h/--help` argument. + +```python + @autocommand() + def test_prog(arg1, arg2: int, quiet=False, verbose=False): + if not quiet: + print(arg1, arg2) + if verbose: + print("LOUD NOISES") + + return 0 + + print(test_prog(['-v', 'hello', '80'])) +``` + +``` +$ python test_prog.py +hello 80 +LOUD NOISES +0 +``` + +If the function is called with no arguments, `sys.argv[1:]` is used. This is to allow the autocommand function to be used as a setuptools entry point. + +## Exceptions and limitations + +- There are a few possible exceptions that `autocommand` can raise. All of them derive from `autocommand.AutocommandError`. + + - If an invalid annotation is given (that is, it isn't a `type`, `str`, `(type, str)`, or `(str, type)`, an `AnnotationError` is raised. The `type` may be any callable, as described in the `Types`_ section. + - If the function has a `**kwargs` parameter, a `KWargError` is raised. + - If, somehow, the function has a positional-only parameter, a `PositionalArgError` is raised. This means that the argument doesn't have a name, which is currently not possible with a plain `def` or `lambda`, though many built-in functions have this kind of parameter. + +- There are a few argparse features that are not supported by autocommand. + + - It isn't possible to have an optional positional argument (as opposed to a `--option`). POSIX thinks this is bad form anyway. + - It isn't possible to have mutually exclusive arguments or options + - It isn't possible to have subcommands or subparsers, though I'm working on a few solutions involving classes or nested function definitions to allow this. + +## Development + +Autocommand cannot be important from the project root; this is to enforce separation of concerns and prevent accidental importing of `setup.py` or tests. To develop, install the project in editable mode: + +``` +$ python setup.py develop +``` + +This will create a link to the source files in the deployment directory, so that any source changes are reflected when it is imported. diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/RECORD b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..8cd7450980bb1cf4d7646611ae6d64b6a9853b35 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/RECORD @@ -0,0 +1,13 @@ +autocommand-2.2.2.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2 +autocommand-2.2.2.dist-info/LICENSE,sha256=reeNBJgtaZctREqOFKlPh6IzTdOFXMgDSOqOJAqg3y0,7634 +autocommand-2.2.2.dist-info/METADATA,sha256=OADZuR3O6iBlpu1ieTgzYul6w4uOVrk0P0BO5TGGAJk,15006 +autocommand-2.2.2.dist-info/RECORD,, +autocommand-2.2.2.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +autocommand-2.2.2.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92 +autocommand-2.2.2.dist-info/top_level.txt,sha256=AzfhgKKS8EdAwWUTSF8mgeVQbXOY9kokHB6kSqwwqu0,12 +autocommand/__init__.py,sha256=zko5Rnvolvb-UXjCx_2ArPTGBWwUK5QY4LIQIKYR7As,1037 +autocommand/autoasync.py,sha256=AMdyrxNS4pqWJfP_xuoOcImOHWD-qT7x06wmKN1Vp-U,5680 +autocommand/autocommand.py,sha256=hmkEmQ72HtL55gnURVjDOnsfYlGd5lLXbvT4KG496Qw,2505 +autocommand/automain.py,sha256=A2b8i754Mxc_DjU9WFr6vqYDWlhz0cn8miu8d8EsxV8,2076 +autocommand/autoparse.py,sha256=WVWmZJPcbzUKXP40raQw_0HD8qPJ2V9VG1eFFmmnFxw,11642 +autocommand/errors.py,sha256=7aa3roh9Herd6nIKpQHNWEslWE8oq7GiHYVUuRqORnA,886 diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/REQUESTED b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/WHEEL b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..57e3d840d59a650ac5bccbad5baeec47d155f0ad --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.38.4) +Root-Is-Purelib: true +Tag: py3-none-any + diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/top_level.txt b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..dda5158ff6d263927861b19ef5a5d183d2aa77ed --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/top_level.txt @@ -0,0 +1 @@ +autocommand diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/__init__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..73fbfca6b36927c6371839df3dfe733bebb2066f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/__init__.py @@ -0,0 +1,27 @@ +# Copyright 2014-2016 Nathan West +# +# This file is part of autocommand. +# +# autocommand is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# autocommand is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with autocommand. If not, see . + +# flake8 flags all these imports as unused, hence the NOQAs everywhere. + +from .automain import automain # NOQA +from .autoparse import autoparse, smart_open # NOQA +from .autocommand import autocommand # NOQA + +try: + from .autoasync import autoasync # NOQA +except ImportError: # pragma: no cover + pass diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..035d966ec0b33567dc3d6846e1958ddb67db9f25 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/__pycache__/autoasync.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/__pycache__/autoasync.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..25b631b165f34a4372f9aa6eee2050f4dbf7cb04 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/__pycache__/autoasync.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/__pycache__/autocommand.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/__pycache__/autocommand.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ff535bb1afc09d051f7a468c317d76b9a1bf15c8 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/__pycache__/autocommand.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/__pycache__/automain.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/__pycache__/automain.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a4c041b39437ba0622df8d0dcf8b4cb900f0188a Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/__pycache__/automain.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/__pycache__/autoparse.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/__pycache__/autoparse.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..da168df78b40d398234f147bf5d00cbfadb38bff Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/__pycache__/autoparse.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/__pycache__/errors.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/__pycache__/errors.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..706881a140f4611e3e21e281143b54c1975cfd92 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/__pycache__/errors.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/autoasync.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/autoasync.py new file mode 100644 index 0000000000000000000000000000000000000000..688f7e05544bb5b4914d290c9bfe73bb99f4e06a --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/autoasync.py @@ -0,0 +1,142 @@ +# Copyright 2014-2015 Nathan West +# +# This file is part of autocommand. +# +# autocommand is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# autocommand is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with autocommand. If not, see . + +from asyncio import get_event_loop, iscoroutine +from functools import wraps +from inspect import signature + + +async def _run_forever_coro(coro, args, kwargs, loop): + ''' + This helper function launches an async main function that was tagged with + forever=True. There are two possibilities: + + - The function is a normal function, which handles initializing the event + loop, which is then run forever + - The function is a coroutine, which needs to be scheduled in the event + loop, which is then run forever + - There is also the possibility that the function is a normal function + wrapping a coroutine function + + The function is therefore called unconditionally and scheduled in the event + loop if the return value is a coroutine object. + + The reason this is a separate function is to make absolutely sure that all + the objects created are garbage collected after all is said and done; we + do this to ensure that any exceptions raised in the tasks are collected + ASAP. + ''' + + # Personal note: I consider this an antipattern, as it relies on the use of + # unowned resources. The setup function dumps some stuff into the event + # loop where it just whirls in the ether without a well defined owner or + # lifetime. For this reason, there's a good chance I'll remove the + # forever=True feature from autoasync at some point in the future. + thing = coro(*args, **kwargs) + if iscoroutine(thing): + await thing + + +def autoasync(coro=None, *, loop=None, forever=False, pass_loop=False): + ''' + Convert an asyncio coroutine into a function which, when called, is + evaluted in an event loop, and the return value returned. This is intented + to make it easy to write entry points into asyncio coroutines, which + otherwise need to be explictly evaluted with an event loop's + run_until_complete. + + If `loop` is given, it is used as the event loop to run the coro in. If it + is None (the default), the loop is retreived using asyncio.get_event_loop. + This call is defered until the decorated function is called, so that + callers can install custom event loops or event loop policies after + @autoasync is applied. + + If `forever` is True, the loop is run forever after the decorated coroutine + is finished. Use this for servers created with asyncio.start_server and the + like. + + If `pass_loop` is True, the event loop object is passed into the coroutine + as the `loop` kwarg when the wrapper function is called. In this case, the + wrapper function's __signature__ is updated to remove this parameter, so + that autoparse can still be used on it without generating a parameter for + `loop`. + + This coroutine can be called with ( @autoasync(...) ) or without + ( @autoasync ) arguments. + + Examples: + + @autoasync + def get_file(host, port): + reader, writer = yield from asyncio.open_connection(host, port) + data = reader.read() + sys.stdout.write(data.decode()) + + get_file(host, port) + + @autoasync(forever=True, pass_loop=True) + def server(host, port, loop): + yield_from loop.create_server(Proto, host, port) + + server('localhost', 8899) + + ''' + if coro is None: + return lambda c: autoasync( + c, loop=loop, + forever=forever, + pass_loop=pass_loop) + + # The old and new signatures are required to correctly bind the loop + # parameter in 100% of cases, even if it's a positional parameter. + # NOTE: A future release will probably require the loop parameter to be + # a kwonly parameter. + if pass_loop: + old_sig = signature(coro) + new_sig = old_sig.replace(parameters=( + param for name, param in old_sig.parameters.items() + if name != "loop")) + + @wraps(coro) + def autoasync_wrapper(*args, **kwargs): + # Defer the call to get_event_loop so that, if a custom policy is + # installed after the autoasync decorator, it is respected at call time + local_loop = get_event_loop() if loop is None else loop + + # Inject the 'loop' argument. We have to use this signature binding to + # ensure it's injected in the correct place (positional, keyword, etc) + if pass_loop: + bound_args = old_sig.bind_partial() + bound_args.arguments.update( + loop=local_loop, + **new_sig.bind(*args, **kwargs).arguments) + args, kwargs = bound_args.args, bound_args.kwargs + + if forever: + local_loop.create_task(_run_forever_coro( + coro, args, kwargs, local_loop + )) + local_loop.run_forever() + else: + return local_loop.run_until_complete(coro(*args, **kwargs)) + + # Attach the updated signature. This allows 'pass_loop' to be used with + # autoparse + if pass_loop: + autoasync_wrapper.__signature__ = new_sig + + return autoasync_wrapper diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/autocommand.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/autocommand.py new file mode 100644 index 0000000000000000000000000000000000000000..097e86de0720126a1390d728f7e50a4f89cac77f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/autocommand.py @@ -0,0 +1,70 @@ +# Copyright 2014-2015 Nathan West +# +# This file is part of autocommand. +# +# autocommand is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# autocommand is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with autocommand. If not, see . + +from .autoparse import autoparse +from .automain import automain +try: + from .autoasync import autoasync +except ImportError: # pragma: no cover + pass + + +def autocommand( + module, *, + description=None, + epilog=None, + add_nos=False, + parser=None, + loop=None, + forever=False, + pass_loop=False): + + if callable(module): + raise TypeError('autocommand requires a module name argument') + + def autocommand_decorator(func): + # Step 1: if requested, run it all in an asyncio event loop. autoasync + # patches the __signature__ of the decorated function, so that in the + # event that pass_loop is True, the `loop` parameter of the original + # function will *not* be interpreted as a command-line argument by + # autoparse + if loop is not None or forever or pass_loop: + func = autoasync( + func, + loop=None if loop is True else loop, + pass_loop=pass_loop, + forever=forever) + + # Step 2: create parser. We do this second so that the arguments are + # parsed and passed *before* entering the asyncio event loop, if it + # exists. This simplifies the stack trace and ensures errors are + # reported earlier. It also ensures that errors raised during parsing & + # passing are still raised if `forever` is True. + func = autoparse( + func, + description=description, + epilog=epilog, + add_nos=add_nos, + parser=parser) + + # Step 3: call the function automatically if __name__ == '__main__' (or + # if True was provided) + func = automain(module)(func) + + return func + + return autocommand_decorator diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/automain.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/automain.py new file mode 100644 index 0000000000000000000000000000000000000000..6cc45db66a1c1dbf1bedb993683b0700d0510643 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/automain.py @@ -0,0 +1,59 @@ +# Copyright 2014-2015 Nathan West +# +# This file is part of autocommand. +# +# autocommand is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# autocommand is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with autocommand. If not, see . + +import sys +from .errors import AutocommandError + + +class AutomainRequiresModuleError(AutocommandError, TypeError): + pass + + +def automain(module, *, args=(), kwargs=None): + ''' + This decorator automatically invokes a function if the module is being run + as the "__main__" module. Optionally, provide args or kwargs with which to + call the function. If `module` is "__main__", the function is called, and + the program is `sys.exit`ed with the return value. You can also pass `True` + to cause the function to be called unconditionally. If the function is not + called, it is returned unchanged by the decorator. + + Usage: + + @automain(__name__) # Pass __name__ to check __name__=="__main__" + def main(): + ... + + If __name__ is "__main__" here, the main function is called, and then + sys.exit called with the return value. + ''' + + # Check that @automain(...) was called, rather than @automain + if callable(module): + raise AutomainRequiresModuleError(module) + + if module == '__main__' or module is True: + if kwargs is None: + kwargs = {} + + # Use a function definition instead of a lambda for a neater traceback + def automain_decorator(main): + sys.exit(main(*args, **kwargs)) + + return automain_decorator + else: + return lambda main: main diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/autoparse.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/autoparse.py new file mode 100644 index 0000000000000000000000000000000000000000..0276a3fae10eb367af326543bcd69e62432b2f7b --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/autoparse.py @@ -0,0 +1,333 @@ +# Copyright 2014-2015 Nathan West +# +# This file is part of autocommand. +# +# autocommand is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# autocommand is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with autocommand. If not, see . + +import sys +from re import compile as compile_regex +from inspect import signature, getdoc, Parameter +from argparse import ArgumentParser +from contextlib import contextmanager +from functools import wraps +from io import IOBase +from autocommand.errors import AutocommandError + + +_empty = Parameter.empty + + +class AnnotationError(AutocommandError): + '''Annotation error: annotation must be a string, type, or tuple of both''' + + +class PositionalArgError(AutocommandError): + ''' + Postional Arg Error: autocommand can't handle postional-only parameters + ''' + + +class KWArgError(AutocommandError): + '''kwarg Error: autocommand can't handle a **kwargs parameter''' + + +class DocstringError(AutocommandError): + '''Docstring error''' + + +class TooManySplitsError(DocstringError): + ''' + The docstring had too many ---- section splits. Currently we only support + using up to a single split, to split the docstring into description and + epilog parts. + ''' + + +def _get_type_description(annotation): + ''' + Given an annotation, return the (type, description) for the parameter. + If you provide an annotation that is somehow both a string and a callable, + the behavior is undefined. + ''' + if annotation is _empty: + return None, None + elif callable(annotation): + return annotation, None + elif isinstance(annotation, str): + return None, annotation + elif isinstance(annotation, tuple): + try: + arg1, arg2 = annotation + except ValueError as e: + raise AnnotationError(annotation) from e + else: + if callable(arg1) and isinstance(arg2, str): + return arg1, arg2 + elif isinstance(arg1, str) and callable(arg2): + return arg2, arg1 + + raise AnnotationError(annotation) + + +def _add_arguments(param, parser, used_char_args, add_nos): + ''' + Add the argument(s) to an ArgumentParser (using add_argument) for a given + parameter. used_char_args is the set of -short options currently already in + use, and is updated (if necessary) by this function. If add_nos is True, + this will also add an inverse switch for all boolean options. For + instance, for the boolean parameter "verbose", this will create --verbose + and --no-verbose. + ''' + + # Impl note: This function is kept separate from make_parser because it's + # already very long and I wanted to separate out as much as possible into + # its own call scope, to prevent even the possibility of suble mutation + # bugs. + if param.kind is param.POSITIONAL_ONLY: + raise PositionalArgError(param) + elif param.kind is param.VAR_KEYWORD: + raise KWArgError(param) + + # These are the kwargs for the add_argument function. + arg_spec = {} + is_option = False + + # Get the type and default from the annotation. + arg_type, description = _get_type_description(param.annotation) + + # Get the default value + default = param.default + + # If there is no explicit type, and the default is present and not None, + # infer the type from the default. + if arg_type is None and default not in {_empty, None}: + arg_type = type(default) + + # Add default. The presence of a default means this is an option, not an + # argument. + if default is not _empty: + arg_spec['default'] = default + is_option = True + + # Add the type + if arg_type is not None: + # Special case for bool: make it just a --switch + if arg_type is bool: + if not default or default is _empty: + arg_spec['action'] = 'store_true' + else: + arg_spec['action'] = 'store_false' + + # Switches are always options + is_option = True + + # Special case for file types: make it a string type, for filename + elif isinstance(default, IOBase): + arg_spec['type'] = str + + # TODO: special case for list type. + # - How to specificy type of list members? + # - param: [int] + # - param: int =[] + # - action='append' vs nargs='*' + + else: + arg_spec['type'] = arg_type + + # nargs: if the signature includes *args, collect them as trailing CLI + # arguments in a list. *args can't have a default value, so it can never be + # an option. + if param.kind is param.VAR_POSITIONAL: + # TODO: consider depluralizing metavar/name here. + arg_spec['nargs'] = '*' + + # Add description. + if description is not None: + arg_spec['help'] = description + + # Get the --flags + flags = [] + name = param.name + + if is_option: + # Add the first letter as a -short option. + for letter in name[0], name[0].swapcase(): + if letter not in used_char_args: + used_char_args.add(letter) + flags.append('-{}'.format(letter)) + break + + # If the parameter is a --long option, or is a -short option that + # somehow failed to get a flag, add it. + if len(name) > 1 or not flags: + flags.append('--{}'.format(name)) + + arg_spec['dest'] = name + else: + flags.append(name) + + parser.add_argument(*flags, **arg_spec) + + # Create the --no- version for boolean switches + if add_nos and arg_type is bool: + parser.add_argument( + '--no-{}'.format(name), + action='store_const', + dest=name, + const=default if default is not _empty else False) + + +def make_parser(func_sig, description, epilog, add_nos): + ''' + Given the signature of a function, create an ArgumentParser + ''' + parser = ArgumentParser(description=description, epilog=epilog) + + used_char_args = {'h'} + + # Arange the params so that single-character arguments are first. This + # esnures they don't have to get --long versions. sorted is stable, so the + # parameters will otherwise still be in relative order. + params = sorted( + func_sig.parameters.values(), + key=lambda param: len(param.name) > 1) + + for param in params: + _add_arguments(param, parser, used_char_args, add_nos) + + return parser + + +_DOCSTRING_SPLIT = compile_regex(r'\n\s*-{4,}\s*\n') + + +def parse_docstring(docstring): + ''' + Given a docstring, parse it into a description and epilog part + ''' + if docstring is None: + return '', '' + + parts = _DOCSTRING_SPLIT.split(docstring) + + if len(parts) == 1: + return docstring, '' + elif len(parts) == 2: + return parts[0], parts[1] + else: + raise TooManySplitsError() + + +def autoparse( + func=None, *, + description=None, + epilog=None, + add_nos=False, + parser=None): + ''' + This decorator converts a function that takes normal arguments into a + function which takes a single optional argument, argv, parses it using an + argparse.ArgumentParser, and calls the underlying function with the parsed + arguments. If it is not given, sys.argv[1:] is used. This is so that the + function can be used as a setuptools entry point, as well as a normal main + function. sys.argv[1:] is not evaluated until the function is called, to + allow injecting different arguments for testing. + + It uses the argument signature of the function to create an + ArgumentParser. Parameters without defaults become positional parameters, + while parameters *with* defaults become --options. Use annotations to set + the type of the parameter. + + The `desctiption` and `epilog` parameters corrospond to the same respective + argparse parameters. If no description is given, it defaults to the + decorated functions's docstring, if present. + + If add_nos is True, every boolean option (that is, every parameter with a + default of True/False or a type of bool) will have a --no- version created + as well, which inverts the option. For instance, the --verbose option will + have a --no-verbose counterpart. These are not mutually exclusive- + whichever one appears last in the argument list will have precedence. + + If a parser is given, it is used instead of one generated from the function + signature. In this case, no parser is created; instead, the given parser is + used to parse the argv argument. The parser's results' argument names must + match up with the parameter names of the decorated function. + + The decorated function is attached to the result as the `func` attribute, + and the parser is attached as the `parser` attribute. + ''' + + # If @autoparse(...) is used instead of @autoparse + if func is None: + return lambda f: autoparse( + f, description=description, + epilog=epilog, + add_nos=add_nos, + parser=parser) + + func_sig = signature(func) + + docstr_description, docstr_epilog = parse_docstring(getdoc(func)) + + if parser is None: + parser = make_parser( + func_sig, + description or docstr_description, + epilog or docstr_epilog, + add_nos) + + @wraps(func) + def autoparse_wrapper(argv=None): + if argv is None: + argv = sys.argv[1:] + + # Get empty argument binding, to fill with parsed arguments. This + # object does all the heavy lifting of turning named arguments into + # into correctly bound *args and **kwargs. + parsed_args = func_sig.bind_partial() + parsed_args.arguments.update(vars(parser.parse_args(argv))) + + return func(*parsed_args.args, **parsed_args.kwargs) + + # TODO: attach an updated __signature__ to autoparse_wrapper, just in case. + + # Attach the wrapped function and parser, and return the wrapper. + autoparse_wrapper.func = func + autoparse_wrapper.parser = parser + return autoparse_wrapper + + +@contextmanager +def smart_open(filename_or_file, *args, **kwargs): + ''' + This context manager allows you to open a filename, if you want to default + some already-existing file object, like sys.stdout, which shouldn't be + closed at the end of the context. If the filename argument is a str, bytes, + or int, the file object is created via a call to open with the given *args + and **kwargs, sent to the context, and closed at the end of the context, + just like "with open(filename) as f:". If it isn't one of the openable + types, the object simply sent to the context unchanged, and left unclosed + at the end of the context. Example: + + def work_with_file(name=sys.stdout): + with smart_open(name) as f: + # Works correctly if name is a str filename or sys.stdout + print("Some stuff", file=f) + # If it was a filename, f is closed at the end here. + ''' + if isinstance(filename_or_file, (str, bytes, int)): + with open(filename_or_file, *args, **kwargs) as file: + yield file + else: + yield filename_or_file diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/errors.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/errors.py new file mode 100644 index 0000000000000000000000000000000000000000..2570607399a3ae13cb92db65a9171d955d3248c6 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/autocommand/errors.py @@ -0,0 +1,23 @@ +# Copyright 2014-2016 Nathan West +# +# This file is part of autocommand. +# +# autocommand is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# autocommand is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with autocommand. If not, see . + + +class AutocommandError(Exception): + '''Base class for autocommand exceptions''' + pass + +# Individual modules will define errors specific to that module. diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/INSTALLER b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..5c69047b2eb8235994febeeae1da4a82365a240a --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/INSTALLER @@ -0,0 +1 @@ +uv \ No newline at end of file diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/LICENSE b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..1bb5a44356f00884a71ceeefd24ded6caaba2418 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/LICENSE @@ -0,0 +1,17 @@ +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. diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/METADATA b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..db0a2dcdbe5f55f5815b2eaa243c507d0bdad002 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/METADATA @@ -0,0 +1,46 @@ +Metadata-Version: 2.1 +Name: backports.tarfile +Version: 1.2.0 +Summary: Backport of CPython tarfile module +Author-email: "Jason R. Coombs" +Project-URL: Homepage, https://github.com/jaraco/backports.tarfile +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: MIT License +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3 :: Only +Requires-Python: >=3.8 +Description-Content-Type: text/x-rst +License-File: LICENSE +Provides-Extra: docs +Requires-Dist: sphinx >=3.5 ; extra == 'docs' +Requires-Dist: jaraco.packaging >=9.3 ; extra == 'docs' +Requires-Dist: rst.linker >=1.9 ; extra == 'docs' +Requires-Dist: furo ; extra == 'docs' +Requires-Dist: sphinx-lint ; extra == 'docs' +Provides-Extra: testing +Requires-Dist: pytest !=8.1.*,>=6 ; extra == 'testing' +Requires-Dist: pytest-checkdocs >=2.4 ; extra == 'testing' +Requires-Dist: pytest-cov ; extra == 'testing' +Requires-Dist: pytest-enabler >=2.2 ; extra == 'testing' +Requires-Dist: jaraco.test ; extra == 'testing' +Requires-Dist: pytest !=8.0.* ; extra == 'testing' + +.. image:: https://img.shields.io/pypi/v/backports.tarfile.svg + :target: https://pypi.org/project/backports.tarfile + +.. image:: https://img.shields.io/pypi/pyversions/backports.tarfile.svg + +.. image:: https://github.com/jaraco/backports.tarfile/actions/workflows/main.yml/badge.svg + :target: https://github.com/jaraco/backports.tarfile/actions?query=workflow%3A%22tests%22 + :alt: tests + +.. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json + :target: https://github.com/astral-sh/ruff + :alt: Ruff + +.. .. image:: https://readthedocs.org/projects/backportstarfile/badge/?version=latest +.. :target: https://backportstarfile.readthedocs.io/en/latest/?badge=latest + +.. image:: https://img.shields.io/badge/skeleton-2024-informational + :target: https://blog.jaraco.com/skeleton diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/RECORD b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..c7d2c25bc103c6b3b1f60b23337276d81f24b5c4 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/RECORD @@ -0,0 +1,12 @@ +backports.tarfile-1.2.0.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2 +backports.tarfile-1.2.0.dist-info/LICENSE,sha256=htoPAa6uRjSKPD1GUZXcHOzN55956HdppkuNoEsqR0E,1023 +backports.tarfile-1.2.0.dist-info/METADATA,sha256=ghXFTq132dxaEIolxr3HK1mZqm9iyUmaRANZQSr6WlE,2020 +backports.tarfile-1.2.0.dist-info/RECORD,, +backports.tarfile-1.2.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +backports.tarfile-1.2.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92 +backports.tarfile-1.2.0.dist-info/top_level.txt,sha256=cGjaLMOoBR1FK0ApojtzWVmViTtJ7JGIK_HwXiEsvtU,10 +backports/__init__.py,sha256=iOEMwnlORWezdO8-2vxBIPSR37D7JGjluZ8f55vzxls,81 +backports/tarfile/__init__.py,sha256=Pwf2qUIfB0SolJPCKcx3vz3UEu_aids4g4sAfxy94qg,108491 +backports/tarfile/__main__.py,sha256=Yw2oGT1afrz2eBskzdPYL8ReB_3liApmhFkN2EbDmc4,59 +backports/tarfile/compat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +backports/tarfile/compat/py38.py,sha256=iYkyt_gvWjLzGUTJD9TuTfMMjOk-ersXZmRlvQYN2qE,568 diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/REQUESTED b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/WHEEL b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..bab98d675883cc7567a79df485cd7b4f015e376f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.43.0) +Root-Is-Purelib: true +Tag: py3-none-any + diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/top_level.txt b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..99d2be5b64d7dc414f8ab9c002de06456b4bada2 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/top_level.txt @@ -0,0 +1 @@ +backports diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports/__init__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..0d1f7edf5dc6343538563a8caa7de6829752c4f9 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports/__init__.py @@ -0,0 +1 @@ +__path__ = __import__('pkgutil').extend_path(__path__, __name__) # type: ignore diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..434e3faa618d7b0aae6232472e322afe2f9a0312 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports/tarfile/__init__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports/tarfile/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8c16881cb3ae1ea6e729b62bb2e5d625faa3f5fe --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports/tarfile/__init__.py @@ -0,0 +1,2937 @@ +#------------------------------------------------------------------- +# tarfile.py +#------------------------------------------------------------------- +# Copyright (C) 2002 Lars Gustaebel +# All rights reserved. +# +# 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. +# +"""Read from and write to tar format archives. +""" + +version = "0.9.0" +__author__ = "Lars Gust\u00e4bel (lars@gustaebel.de)" +__credits__ = "Gustavo Niemeyer, Niels Gust\u00e4bel, Richard Townsend." + +#--------- +# Imports +#--------- +from builtins import open as bltn_open +import sys +import os +import io +import shutil +import stat +import time +import struct +import copy +import re + +from .compat.py38 import removesuffix + +try: + import pwd +except ImportError: + pwd = None +try: + import grp +except ImportError: + grp = None + +# os.symlink on Windows prior to 6.0 raises NotImplementedError +# OSError (winerror=1314) will be raised if the caller does not hold the +# SeCreateSymbolicLinkPrivilege privilege +symlink_exception = (AttributeError, NotImplementedError, OSError) + +# from tarfile import * +__all__ = ["TarFile", "TarInfo", "is_tarfile", "TarError", "ReadError", + "CompressionError", "StreamError", "ExtractError", "HeaderError", + "ENCODING", "USTAR_FORMAT", "GNU_FORMAT", "PAX_FORMAT", + "DEFAULT_FORMAT", "open","fully_trusted_filter", "data_filter", + "tar_filter", "FilterError", "AbsoluteLinkError", + "OutsideDestinationError", "SpecialFileError", "AbsolutePathError", + "LinkOutsideDestinationError"] + + +#--------------------------------------------------------- +# tar constants +#--------------------------------------------------------- +NUL = b"\0" # the null character +BLOCKSIZE = 512 # length of processing blocks +RECORDSIZE = BLOCKSIZE * 20 # length of records +GNU_MAGIC = b"ustar \0" # magic gnu tar string +POSIX_MAGIC = b"ustar\x0000" # magic posix tar string + +LENGTH_NAME = 100 # maximum length of a filename +LENGTH_LINK = 100 # maximum length of a linkname +LENGTH_PREFIX = 155 # maximum length of the prefix field + +REGTYPE = b"0" # regular file +AREGTYPE = b"\0" # regular file +LNKTYPE = b"1" # link (inside tarfile) +SYMTYPE = b"2" # symbolic link +CHRTYPE = b"3" # character special device +BLKTYPE = b"4" # block special device +DIRTYPE = b"5" # directory +FIFOTYPE = b"6" # fifo special device +CONTTYPE = b"7" # contiguous file + +GNUTYPE_LONGNAME = b"L" # GNU tar longname +GNUTYPE_LONGLINK = b"K" # GNU tar longlink +GNUTYPE_SPARSE = b"S" # GNU tar sparse file + +XHDTYPE = b"x" # POSIX.1-2001 extended header +XGLTYPE = b"g" # POSIX.1-2001 global header +SOLARIS_XHDTYPE = b"X" # Solaris extended header + +USTAR_FORMAT = 0 # POSIX.1-1988 (ustar) format +GNU_FORMAT = 1 # GNU tar format +PAX_FORMAT = 2 # POSIX.1-2001 (pax) format +DEFAULT_FORMAT = PAX_FORMAT + +#--------------------------------------------------------- +# tarfile constants +#--------------------------------------------------------- +# File types that tarfile supports: +SUPPORTED_TYPES = (REGTYPE, AREGTYPE, LNKTYPE, + SYMTYPE, DIRTYPE, FIFOTYPE, + CONTTYPE, CHRTYPE, BLKTYPE, + GNUTYPE_LONGNAME, GNUTYPE_LONGLINK, + GNUTYPE_SPARSE) + +# File types that will be treated as a regular file. +REGULAR_TYPES = (REGTYPE, AREGTYPE, + CONTTYPE, GNUTYPE_SPARSE) + +# File types that are part of the GNU tar format. +GNU_TYPES = (GNUTYPE_LONGNAME, GNUTYPE_LONGLINK, + GNUTYPE_SPARSE) + +# Fields from a pax header that override a TarInfo attribute. +PAX_FIELDS = ("path", "linkpath", "size", "mtime", + "uid", "gid", "uname", "gname") + +# Fields from a pax header that are affected by hdrcharset. +PAX_NAME_FIELDS = {"path", "linkpath", "uname", "gname"} + +# Fields in a pax header that are numbers, all other fields +# are treated as strings. +PAX_NUMBER_FIELDS = { + "atime": float, + "ctime": float, + "mtime": float, + "uid": int, + "gid": int, + "size": int +} + +#--------------------------------------------------------- +# initialization +#--------------------------------------------------------- +if os.name == "nt": + ENCODING = "utf-8" +else: + ENCODING = sys.getfilesystemencoding() + +#--------------------------------------------------------- +# Some useful functions +#--------------------------------------------------------- + +def stn(s, length, encoding, errors): + """Convert a string to a null-terminated bytes object. + """ + if s is None: + raise ValueError("metadata cannot contain None") + s = s.encode(encoding, errors) + return s[:length] + (length - len(s)) * NUL + +def nts(s, encoding, errors): + """Convert a null-terminated bytes object to a string. + """ + p = s.find(b"\0") + if p != -1: + s = s[:p] + return s.decode(encoding, errors) + +def nti(s): + """Convert a number field to a python number. + """ + # There are two possible encodings for a number field, see + # itn() below. + if s[0] in (0o200, 0o377): + n = 0 + for i in range(len(s) - 1): + n <<= 8 + n += s[i + 1] + if s[0] == 0o377: + n = -(256 ** (len(s) - 1) - n) + else: + try: + s = nts(s, "ascii", "strict") + n = int(s.strip() or "0", 8) + except ValueError: + raise InvalidHeaderError("invalid header") + return n + +def itn(n, digits=8, format=DEFAULT_FORMAT): + """Convert a python number to a number field. + """ + # POSIX 1003.1-1988 requires numbers to be encoded as a string of + # octal digits followed by a null-byte, this allows values up to + # (8**(digits-1))-1. GNU tar allows storing numbers greater than + # that if necessary. A leading 0o200 or 0o377 byte indicate this + # particular encoding, the following digits-1 bytes are a big-endian + # base-256 representation. This allows values up to (256**(digits-1))-1. + # A 0o200 byte indicates a positive number, a 0o377 byte a negative + # number. + original_n = n + n = int(n) + if 0 <= n < 8 ** (digits - 1): + s = bytes("%0*o" % (digits - 1, n), "ascii") + NUL + elif format == GNU_FORMAT and -256 ** (digits - 1) <= n < 256 ** (digits - 1): + if n >= 0: + s = bytearray([0o200]) + else: + s = bytearray([0o377]) + n = 256 ** digits + n + + for i in range(digits - 1): + s.insert(1, n & 0o377) + n >>= 8 + else: + raise ValueError("overflow in number field") + + return s + +def calc_chksums(buf): + """Calculate the checksum for a member's header by summing up all + characters except for the chksum field which is treated as if + it was filled with spaces. According to the GNU tar sources, + some tars (Sun and NeXT) calculate chksum with signed char, + which will be different if there are chars in the buffer with + the high bit set. So we calculate two checksums, unsigned and + signed. + """ + unsigned_chksum = 256 + sum(struct.unpack_from("148B8x356B", buf)) + signed_chksum = 256 + sum(struct.unpack_from("148b8x356b", buf)) + return unsigned_chksum, signed_chksum + +def copyfileobj(src, dst, length=None, exception=OSError, bufsize=None): + """Copy length bytes from fileobj src to fileobj dst. + If length is None, copy the entire content. + """ + bufsize = bufsize or 16 * 1024 + if length == 0: + return + if length is None: + shutil.copyfileobj(src, dst, bufsize) + return + + blocks, remainder = divmod(length, bufsize) + for b in range(blocks): + buf = src.read(bufsize) + if len(buf) < bufsize: + raise exception("unexpected end of data") + dst.write(buf) + + if remainder != 0: + buf = src.read(remainder) + if len(buf) < remainder: + raise exception("unexpected end of data") + dst.write(buf) + return + +def _safe_print(s): + encoding = getattr(sys.stdout, 'encoding', None) + if encoding is not None: + s = s.encode(encoding, 'backslashreplace').decode(encoding) + print(s, end=' ') + + +class TarError(Exception): + """Base exception.""" + pass +class ExtractError(TarError): + """General exception for extract errors.""" + pass +class ReadError(TarError): + """Exception for unreadable tar archives.""" + pass +class CompressionError(TarError): + """Exception for unavailable compression methods.""" + pass +class StreamError(TarError): + """Exception for unsupported operations on stream-like TarFiles.""" + pass +class HeaderError(TarError): + """Base exception for header errors.""" + pass +class EmptyHeaderError(HeaderError): + """Exception for empty headers.""" + pass +class TruncatedHeaderError(HeaderError): + """Exception for truncated headers.""" + pass +class EOFHeaderError(HeaderError): + """Exception for end of file headers.""" + pass +class InvalidHeaderError(HeaderError): + """Exception for invalid headers.""" + pass +class SubsequentHeaderError(HeaderError): + """Exception for missing and invalid extended headers.""" + pass + +#--------------------------- +# internal stream interface +#--------------------------- +class _LowLevelFile: + """Low-level file object. Supports reading and writing. + It is used instead of a regular file object for streaming + access. + """ + + def __init__(self, name, mode): + mode = { + "r": os.O_RDONLY, + "w": os.O_WRONLY | os.O_CREAT | os.O_TRUNC, + }[mode] + if hasattr(os, "O_BINARY"): + mode |= os.O_BINARY + self.fd = os.open(name, mode, 0o666) + + def close(self): + os.close(self.fd) + + def read(self, size): + return os.read(self.fd, size) + + def write(self, s): + os.write(self.fd, s) + +class _Stream: + """Class that serves as an adapter between TarFile and + a stream-like object. The stream-like object only + needs to have a read() or write() method that works with bytes, + and the method is accessed blockwise. + Use of gzip or bzip2 compression is possible. + A stream-like object could be for example: sys.stdin.buffer, + sys.stdout.buffer, a socket, a tape device etc. + + _Stream is intended to be used only internally. + """ + + def __init__(self, name, mode, comptype, fileobj, bufsize, + compresslevel): + """Construct a _Stream object. + """ + self._extfileobj = True + if fileobj is None: + fileobj = _LowLevelFile(name, mode) + self._extfileobj = False + + if comptype == '*': + # Enable transparent compression detection for the + # stream interface + fileobj = _StreamProxy(fileobj) + comptype = fileobj.getcomptype() + + self.name = name or "" + self.mode = mode + self.comptype = comptype + self.fileobj = fileobj + self.bufsize = bufsize + self.buf = b"" + self.pos = 0 + self.closed = False + + try: + if comptype == "gz": + try: + import zlib + except ImportError: + raise CompressionError("zlib module is not available") from None + self.zlib = zlib + self.crc = zlib.crc32(b"") + if mode == "r": + self.exception = zlib.error + self._init_read_gz() + else: + self._init_write_gz(compresslevel) + + elif comptype == "bz2": + try: + import bz2 + except ImportError: + raise CompressionError("bz2 module is not available") from None + if mode == "r": + self.dbuf = b"" + self.cmp = bz2.BZ2Decompressor() + self.exception = OSError + else: + self.cmp = bz2.BZ2Compressor(compresslevel) + + elif comptype == "xz": + try: + import lzma + except ImportError: + raise CompressionError("lzma module is not available") from None + if mode == "r": + self.dbuf = b"" + self.cmp = lzma.LZMADecompressor() + self.exception = lzma.LZMAError + else: + self.cmp = lzma.LZMACompressor() + + elif comptype != "tar": + raise CompressionError("unknown compression type %r" % comptype) + + except: + if not self._extfileobj: + self.fileobj.close() + self.closed = True + raise + + def __del__(self): + if hasattr(self, "closed") and not self.closed: + self.close() + + def _init_write_gz(self, compresslevel): + """Initialize for writing with gzip compression. + """ + self.cmp = self.zlib.compressobj(compresslevel, + self.zlib.DEFLATED, + -self.zlib.MAX_WBITS, + self.zlib.DEF_MEM_LEVEL, + 0) + timestamp = struct.pack(" self.bufsize: + self.fileobj.write(self.buf[:self.bufsize]) + self.buf = self.buf[self.bufsize:] + + def close(self): + """Close the _Stream object. No operation should be + done on it afterwards. + """ + if self.closed: + return + + self.closed = True + try: + if self.mode == "w" and self.comptype != "tar": + self.buf += self.cmp.flush() + + if self.mode == "w" and self.buf: + self.fileobj.write(self.buf) + self.buf = b"" + if self.comptype == "gz": + self.fileobj.write(struct.pack("= 0: + blocks, remainder = divmod(pos - self.pos, self.bufsize) + for i in range(blocks): + self.read(self.bufsize) + self.read(remainder) + else: + raise StreamError("seeking backwards is not allowed") + return self.pos + + def read(self, size): + """Return the next size number of bytes from the stream.""" + assert size is not None + buf = self._read(size) + self.pos += len(buf) + return buf + + def _read(self, size): + """Return size bytes from the stream. + """ + if self.comptype == "tar": + return self.__read(size) + + c = len(self.dbuf) + t = [self.dbuf] + while c < size: + # Skip underlying buffer to avoid unaligned double buffering. + if self.buf: + buf = self.buf + self.buf = b"" + else: + buf = self.fileobj.read(self.bufsize) + if not buf: + break + try: + buf = self.cmp.decompress(buf) + except self.exception as e: + raise ReadError("invalid compressed data") from e + t.append(buf) + c += len(buf) + t = b"".join(t) + self.dbuf = t[size:] + return t[:size] + + def __read(self, size): + """Return size bytes from stream. If internal buffer is empty, + read another block from the stream. + """ + c = len(self.buf) + t = [self.buf] + while c < size: + buf = self.fileobj.read(self.bufsize) + if not buf: + break + t.append(buf) + c += len(buf) + t = b"".join(t) + self.buf = t[size:] + return t[:size] +# class _Stream + +class _StreamProxy(object): + """Small proxy class that enables transparent compression + detection for the Stream interface (mode 'r|*'). + """ + + def __init__(self, fileobj): + self.fileobj = fileobj + self.buf = self.fileobj.read(BLOCKSIZE) + + def read(self, size): + self.read = self.fileobj.read + return self.buf + + def getcomptype(self): + if self.buf.startswith(b"\x1f\x8b\x08"): + return "gz" + elif self.buf[0:3] == b"BZh" and self.buf[4:10] == b"1AY&SY": + return "bz2" + elif self.buf.startswith((b"\x5d\x00\x00\x80", b"\xfd7zXZ")): + return "xz" + else: + return "tar" + + def close(self): + self.fileobj.close() +# class StreamProxy + +#------------------------ +# Extraction file object +#------------------------ +class _FileInFile(object): + """A thin wrapper around an existing file object that + provides a part of its data as an individual file + object. + """ + + def __init__(self, fileobj, offset, size, name, blockinfo=None): + self.fileobj = fileobj + self.offset = offset + self.size = size + self.position = 0 + self.name = name + self.closed = False + + if blockinfo is None: + blockinfo = [(0, size)] + + # Construct a map with data and zero blocks. + self.map_index = 0 + self.map = [] + lastpos = 0 + realpos = self.offset + for offset, size in blockinfo: + if offset > lastpos: + self.map.append((False, lastpos, offset, None)) + self.map.append((True, offset, offset + size, realpos)) + realpos += size + lastpos = offset + size + if lastpos < self.size: + self.map.append((False, lastpos, self.size, None)) + + def flush(self): + pass + + @property + def mode(self): + return 'rb' + + def readable(self): + return True + + def writable(self): + return False + + def seekable(self): + return self.fileobj.seekable() + + def tell(self): + """Return the current file position. + """ + return self.position + + def seek(self, position, whence=io.SEEK_SET): + """Seek to a position in the file. + """ + if whence == io.SEEK_SET: + self.position = min(max(position, 0), self.size) + elif whence == io.SEEK_CUR: + if position < 0: + self.position = max(self.position + position, 0) + else: + self.position = min(self.position + position, self.size) + elif whence == io.SEEK_END: + self.position = max(min(self.size + position, self.size), 0) + else: + raise ValueError("Invalid argument") + return self.position + + def read(self, size=None): + """Read data from the file. + """ + if size is None: + size = self.size - self.position + else: + size = min(size, self.size - self.position) + + buf = b"" + while size > 0: + while True: + data, start, stop, offset = self.map[self.map_index] + if start <= self.position < stop: + break + else: + self.map_index += 1 + if self.map_index == len(self.map): + self.map_index = 0 + length = min(size, stop - self.position) + if data: + self.fileobj.seek(offset + (self.position - start)) + b = self.fileobj.read(length) + if len(b) != length: + raise ReadError("unexpected end of data") + buf += b + else: + buf += NUL * length + size -= length + self.position += length + return buf + + def readinto(self, b): + buf = self.read(len(b)) + b[:len(buf)] = buf + return len(buf) + + def close(self): + self.closed = True +#class _FileInFile + +class ExFileObject(io.BufferedReader): + + def __init__(self, tarfile, tarinfo): + fileobj = _FileInFile(tarfile.fileobj, tarinfo.offset_data, + tarinfo.size, tarinfo.name, tarinfo.sparse) + super().__init__(fileobj) +#class ExFileObject + + +#----------------------------- +# extraction filters (PEP 706) +#----------------------------- + +class FilterError(TarError): + pass + +class AbsolutePathError(FilterError): + def __init__(self, tarinfo): + self.tarinfo = tarinfo + super().__init__(f'member {tarinfo.name!r} has an absolute path') + +class OutsideDestinationError(FilterError): + def __init__(self, tarinfo, path): + self.tarinfo = tarinfo + self._path = path + super().__init__(f'{tarinfo.name!r} would be extracted to {path!r}, ' + + 'which is outside the destination') + +class SpecialFileError(FilterError): + def __init__(self, tarinfo): + self.tarinfo = tarinfo + super().__init__(f'{tarinfo.name!r} is a special file') + +class AbsoluteLinkError(FilterError): + def __init__(self, tarinfo): + self.tarinfo = tarinfo + super().__init__(f'{tarinfo.name!r} is a link to an absolute path') + +class LinkOutsideDestinationError(FilterError): + def __init__(self, tarinfo, path): + self.tarinfo = tarinfo + self._path = path + super().__init__(f'{tarinfo.name!r} would link to {path!r}, ' + + 'which is outside the destination') + +def _get_filtered_attrs(member, dest_path, for_data=True): + new_attrs = {} + name = member.name + dest_path = os.path.realpath(dest_path) + # Strip leading / (tar's directory separator) from filenames. + # Include os.sep (target OS directory separator) as well. + if name.startswith(('/', os.sep)): + name = new_attrs['name'] = member.path.lstrip('/' + os.sep) + if os.path.isabs(name): + # Path is absolute even after stripping. + # For example, 'C:/foo' on Windows. + raise AbsolutePathError(member) + # Ensure we stay in the destination + target_path = os.path.realpath(os.path.join(dest_path, name)) + if os.path.commonpath([target_path, dest_path]) != dest_path: + raise OutsideDestinationError(member, target_path) + # Limit permissions (no high bits, and go-w) + mode = member.mode + if mode is not None: + # Strip high bits & group/other write bits + mode = mode & 0o755 + if for_data: + # For data, handle permissions & file types + if member.isreg() or member.islnk(): + if not mode & 0o100: + # Clear executable bits if not executable by user + mode &= ~0o111 + # Ensure owner can read & write + mode |= 0o600 + elif member.isdir() or member.issym(): + # Ignore mode for directories & symlinks + mode = None + else: + # Reject special files + raise SpecialFileError(member) + if mode != member.mode: + new_attrs['mode'] = mode + if for_data: + # Ignore ownership for 'data' + if member.uid is not None: + new_attrs['uid'] = None + if member.gid is not None: + new_attrs['gid'] = None + if member.uname is not None: + new_attrs['uname'] = None + if member.gname is not None: + new_attrs['gname'] = None + # Check link destination for 'data' + if member.islnk() or member.issym(): + if os.path.isabs(member.linkname): + raise AbsoluteLinkError(member) + if member.issym(): + target_path = os.path.join(dest_path, + os.path.dirname(name), + member.linkname) + else: + target_path = os.path.join(dest_path, + member.linkname) + target_path = os.path.realpath(target_path) + if os.path.commonpath([target_path, dest_path]) != dest_path: + raise LinkOutsideDestinationError(member, target_path) + return new_attrs + +def fully_trusted_filter(member, dest_path): + return member + +def tar_filter(member, dest_path): + new_attrs = _get_filtered_attrs(member, dest_path, False) + if new_attrs: + return member.replace(**new_attrs, deep=False) + return member + +def data_filter(member, dest_path): + new_attrs = _get_filtered_attrs(member, dest_path, True) + if new_attrs: + return member.replace(**new_attrs, deep=False) + return member + +_NAMED_FILTERS = { + "fully_trusted": fully_trusted_filter, + "tar": tar_filter, + "data": data_filter, +} + +#------------------ +# Exported Classes +#------------------ + +# Sentinel for replace() defaults, meaning "don't change the attribute" +_KEEP = object() + +class TarInfo(object): + """Informational class which holds the details about an + archive member given by a tar header block. + TarInfo objects are returned by TarFile.getmember(), + TarFile.getmembers() and TarFile.gettarinfo() and are + usually created internally. + """ + + __slots__ = dict( + name = 'Name of the archive member.', + mode = 'Permission bits.', + uid = 'User ID of the user who originally stored this member.', + gid = 'Group ID of the user who originally stored this member.', + size = 'Size in bytes.', + mtime = 'Time of last modification.', + chksum = 'Header checksum.', + type = ('File type. type is usually one of these constants: ' + 'REGTYPE, AREGTYPE, LNKTYPE, SYMTYPE, DIRTYPE, FIFOTYPE, ' + 'CONTTYPE, CHRTYPE, BLKTYPE, GNUTYPE_SPARSE.'), + linkname = ('Name of the target file name, which is only present ' + 'in TarInfo objects of type LNKTYPE and SYMTYPE.'), + uname = 'User name.', + gname = 'Group name.', + devmajor = 'Device major number.', + devminor = 'Device minor number.', + offset = 'The tar header starts here.', + offset_data = "The file's data starts here.", + pax_headers = ('A dictionary containing key-value pairs of an ' + 'associated pax extended header.'), + sparse = 'Sparse member information.', + _tarfile = None, + _sparse_structs = None, + _link_target = None, + ) + + def __init__(self, name=""): + """Construct a TarInfo object. name is the optional name + of the member. + """ + self.name = name # member name + self.mode = 0o644 # file permissions + self.uid = 0 # user id + self.gid = 0 # group id + self.size = 0 # file size + self.mtime = 0 # modification time + self.chksum = 0 # header checksum + self.type = REGTYPE # member type + self.linkname = "" # link name + self.uname = "" # user name + self.gname = "" # group name + self.devmajor = 0 # device major number + self.devminor = 0 # device minor number + + self.offset = 0 # the tar header starts here + self.offset_data = 0 # the file's data starts here + + self.sparse = None # sparse member information + self.pax_headers = {} # pax header information + + @property + def tarfile(self): + import warnings + warnings.warn( + 'The undocumented "tarfile" attribute of TarInfo objects ' + + 'is deprecated and will be removed in Python 3.16', + DeprecationWarning, stacklevel=2) + return self._tarfile + + @tarfile.setter + def tarfile(self, tarfile): + import warnings + warnings.warn( + 'The undocumented "tarfile" attribute of TarInfo objects ' + + 'is deprecated and will be removed in Python 3.16', + DeprecationWarning, stacklevel=2) + self._tarfile = tarfile + + @property + def path(self): + 'In pax headers, "name" is called "path".' + return self.name + + @path.setter + def path(self, name): + self.name = name + + @property + def linkpath(self): + 'In pax headers, "linkname" is called "linkpath".' + return self.linkname + + @linkpath.setter + def linkpath(self, linkname): + self.linkname = linkname + + def __repr__(self): + return "<%s %r at %#x>" % (self.__class__.__name__,self.name,id(self)) + + def replace(self, *, + name=_KEEP, mtime=_KEEP, mode=_KEEP, linkname=_KEEP, + uid=_KEEP, gid=_KEEP, uname=_KEEP, gname=_KEEP, + deep=True, _KEEP=_KEEP): + """Return a deep copy of self with the given attributes replaced. + """ + if deep: + result = copy.deepcopy(self) + else: + result = copy.copy(self) + if name is not _KEEP: + result.name = name + if mtime is not _KEEP: + result.mtime = mtime + if mode is not _KEEP: + result.mode = mode + if linkname is not _KEEP: + result.linkname = linkname + if uid is not _KEEP: + result.uid = uid + if gid is not _KEEP: + result.gid = gid + if uname is not _KEEP: + result.uname = uname + if gname is not _KEEP: + result.gname = gname + return result + + def get_info(self): + """Return the TarInfo's attributes as a dictionary. + """ + if self.mode is None: + mode = None + else: + mode = self.mode & 0o7777 + info = { + "name": self.name, + "mode": mode, + "uid": self.uid, + "gid": self.gid, + "size": self.size, + "mtime": self.mtime, + "chksum": self.chksum, + "type": self.type, + "linkname": self.linkname, + "uname": self.uname, + "gname": self.gname, + "devmajor": self.devmajor, + "devminor": self.devminor + } + + if info["type"] == DIRTYPE and not info["name"].endswith("/"): + info["name"] += "/" + + return info + + def tobuf(self, format=DEFAULT_FORMAT, encoding=ENCODING, errors="surrogateescape"): + """Return a tar header as a string of 512 byte blocks. + """ + info = self.get_info() + for name, value in info.items(): + if value is None: + raise ValueError("%s may not be None" % name) + + if format == USTAR_FORMAT: + return self.create_ustar_header(info, encoding, errors) + elif format == GNU_FORMAT: + return self.create_gnu_header(info, encoding, errors) + elif format == PAX_FORMAT: + return self.create_pax_header(info, encoding) + else: + raise ValueError("invalid format") + + def create_ustar_header(self, info, encoding, errors): + """Return the object as a ustar header block. + """ + info["magic"] = POSIX_MAGIC + + if len(info["linkname"].encode(encoding, errors)) > LENGTH_LINK: + raise ValueError("linkname is too long") + + if len(info["name"].encode(encoding, errors)) > LENGTH_NAME: + info["prefix"], info["name"] = self._posix_split_name(info["name"], encoding, errors) + + return self._create_header(info, USTAR_FORMAT, encoding, errors) + + def create_gnu_header(self, info, encoding, errors): + """Return the object as a GNU header block sequence. + """ + info["magic"] = GNU_MAGIC + + buf = b"" + if len(info["linkname"].encode(encoding, errors)) > LENGTH_LINK: + buf += self._create_gnu_long_header(info["linkname"], GNUTYPE_LONGLINK, encoding, errors) + + if len(info["name"].encode(encoding, errors)) > LENGTH_NAME: + buf += self._create_gnu_long_header(info["name"], GNUTYPE_LONGNAME, encoding, errors) + + return buf + self._create_header(info, GNU_FORMAT, encoding, errors) + + def create_pax_header(self, info, encoding): + """Return the object as a ustar header block. If it cannot be + represented this way, prepend a pax extended header sequence + with supplement information. + """ + info["magic"] = POSIX_MAGIC + pax_headers = self.pax_headers.copy() + + # Test string fields for values that exceed the field length or cannot + # be represented in ASCII encoding. + for name, hname, length in ( + ("name", "path", LENGTH_NAME), ("linkname", "linkpath", LENGTH_LINK), + ("uname", "uname", 32), ("gname", "gname", 32)): + + if hname in pax_headers: + # The pax header has priority. + continue + + # Try to encode the string as ASCII. + try: + info[name].encode("ascii", "strict") + except UnicodeEncodeError: + pax_headers[hname] = info[name] + continue + + if len(info[name]) > length: + pax_headers[hname] = info[name] + + # Test number fields for values that exceed the field limit or values + # that like to be stored as float. + for name, digits in (("uid", 8), ("gid", 8), ("size", 12), ("mtime", 12)): + needs_pax = False + + val = info[name] + val_is_float = isinstance(val, float) + val_int = round(val) if val_is_float else val + if not 0 <= val_int < 8 ** (digits - 1): + # Avoid overflow. + info[name] = 0 + needs_pax = True + elif val_is_float: + # Put rounded value in ustar header, and full + # precision value in pax header. + info[name] = val_int + needs_pax = True + + # The existing pax header has priority. + if needs_pax and name not in pax_headers: + pax_headers[name] = str(val) + + # Create a pax extended header if necessary. + if pax_headers: + buf = self._create_pax_generic_header(pax_headers, XHDTYPE, encoding) + else: + buf = b"" + + return buf + self._create_header(info, USTAR_FORMAT, "ascii", "replace") + + @classmethod + def create_pax_global_header(cls, pax_headers): + """Return the object as a pax global header block sequence. + """ + return cls._create_pax_generic_header(pax_headers, XGLTYPE, "utf-8") + + def _posix_split_name(self, name, encoding, errors): + """Split a name longer than 100 chars into a prefix + and a name part. + """ + components = name.split("/") + for i in range(1, len(components)): + prefix = "/".join(components[:i]) + name = "/".join(components[i:]) + if len(prefix.encode(encoding, errors)) <= LENGTH_PREFIX and \ + len(name.encode(encoding, errors)) <= LENGTH_NAME: + break + else: + raise ValueError("name is too long") + + return prefix, name + + @staticmethod + def _create_header(info, format, encoding, errors): + """Return a header block. info is a dictionary with file + information, format must be one of the *_FORMAT constants. + """ + has_device_fields = info.get("type") in (CHRTYPE, BLKTYPE) + if has_device_fields: + devmajor = itn(info.get("devmajor", 0), 8, format) + devminor = itn(info.get("devminor", 0), 8, format) + else: + devmajor = stn("", 8, encoding, errors) + devminor = stn("", 8, encoding, errors) + + # None values in metadata should cause ValueError. + # itn()/stn() do this for all fields except type. + filetype = info.get("type", REGTYPE) + if filetype is None: + raise ValueError("TarInfo.type must not be None") + + parts = [ + stn(info.get("name", ""), 100, encoding, errors), + itn(info.get("mode", 0) & 0o7777, 8, format), + itn(info.get("uid", 0), 8, format), + itn(info.get("gid", 0), 8, format), + itn(info.get("size", 0), 12, format), + itn(info.get("mtime", 0), 12, format), + b" ", # checksum field + filetype, + stn(info.get("linkname", ""), 100, encoding, errors), + info.get("magic", POSIX_MAGIC), + stn(info.get("uname", ""), 32, encoding, errors), + stn(info.get("gname", ""), 32, encoding, errors), + devmajor, + devminor, + stn(info.get("prefix", ""), 155, encoding, errors) + ] + + buf = struct.pack("%ds" % BLOCKSIZE, b"".join(parts)) + chksum = calc_chksums(buf[-BLOCKSIZE:])[0] + buf = buf[:-364] + bytes("%06o\0" % chksum, "ascii") + buf[-357:] + return buf + + @staticmethod + def _create_payload(payload): + """Return the string payload filled with zero bytes + up to the next 512 byte border. + """ + blocks, remainder = divmod(len(payload), BLOCKSIZE) + if remainder > 0: + payload += (BLOCKSIZE - remainder) * NUL + return payload + + @classmethod + def _create_gnu_long_header(cls, name, type, encoding, errors): + """Return a GNUTYPE_LONGNAME or GNUTYPE_LONGLINK sequence + for name. + """ + name = name.encode(encoding, errors) + NUL + + info = {} + info["name"] = "././@LongLink" + info["type"] = type + info["size"] = len(name) + info["magic"] = GNU_MAGIC + + # create extended header + name blocks. + return cls._create_header(info, USTAR_FORMAT, encoding, errors) + \ + cls._create_payload(name) + + @classmethod + def _create_pax_generic_header(cls, pax_headers, type, encoding): + """Return a POSIX.1-2008 extended or global header sequence + that contains a list of keyword, value pairs. The values + must be strings. + """ + # Check if one of the fields contains surrogate characters and thereby + # forces hdrcharset=BINARY, see _proc_pax() for more information. + binary = False + for keyword, value in pax_headers.items(): + try: + value.encode("utf-8", "strict") + except UnicodeEncodeError: + binary = True + break + + records = b"" + if binary: + # Put the hdrcharset field at the beginning of the header. + records += b"21 hdrcharset=BINARY\n" + + for keyword, value in pax_headers.items(): + keyword = keyword.encode("utf-8") + if binary: + # Try to restore the original byte representation of 'value'. + # Needless to say, that the encoding must match the string. + value = value.encode(encoding, "surrogateescape") + else: + value = value.encode("utf-8") + + l = len(keyword) + len(value) + 3 # ' ' + '=' + '\n' + n = p = 0 + while True: + n = l + len(str(p)) + if n == p: + break + p = n + records += bytes(str(p), "ascii") + b" " + keyword + b"=" + value + b"\n" + + # We use a hardcoded "././@PaxHeader" name like star does + # instead of the one that POSIX recommends. + info = {} + info["name"] = "././@PaxHeader" + info["type"] = type + info["size"] = len(records) + info["magic"] = POSIX_MAGIC + + # Create pax header + record blocks. + return cls._create_header(info, USTAR_FORMAT, "ascii", "replace") + \ + cls._create_payload(records) + + @classmethod + def frombuf(cls, buf, encoding, errors): + """Construct a TarInfo object from a 512 byte bytes object. + """ + if len(buf) == 0: + raise EmptyHeaderError("empty header") + if len(buf) != BLOCKSIZE: + raise TruncatedHeaderError("truncated header") + if buf.count(NUL) == BLOCKSIZE: + raise EOFHeaderError("end of file header") + + chksum = nti(buf[148:156]) + if chksum not in calc_chksums(buf): + raise InvalidHeaderError("bad checksum") + + obj = cls() + obj.name = nts(buf[0:100], encoding, errors) + obj.mode = nti(buf[100:108]) + obj.uid = nti(buf[108:116]) + obj.gid = nti(buf[116:124]) + obj.size = nti(buf[124:136]) + obj.mtime = nti(buf[136:148]) + obj.chksum = chksum + obj.type = buf[156:157] + obj.linkname = nts(buf[157:257], encoding, errors) + obj.uname = nts(buf[265:297], encoding, errors) + obj.gname = nts(buf[297:329], encoding, errors) + obj.devmajor = nti(buf[329:337]) + obj.devminor = nti(buf[337:345]) + prefix = nts(buf[345:500], encoding, errors) + + # Old V7 tar format represents a directory as a regular + # file with a trailing slash. + if obj.type == AREGTYPE and obj.name.endswith("/"): + obj.type = DIRTYPE + + # The old GNU sparse format occupies some of the unused + # space in the buffer for up to 4 sparse structures. + # Save them for later processing in _proc_sparse(). + if obj.type == GNUTYPE_SPARSE: + pos = 386 + structs = [] + for i in range(4): + try: + offset = nti(buf[pos:pos + 12]) + numbytes = nti(buf[pos + 12:pos + 24]) + except ValueError: + break + structs.append((offset, numbytes)) + pos += 24 + isextended = bool(buf[482]) + origsize = nti(buf[483:495]) + obj._sparse_structs = (structs, isextended, origsize) + + # Remove redundant slashes from directories. + if obj.isdir(): + obj.name = obj.name.rstrip("/") + + # Reconstruct a ustar longname. + if prefix and obj.type not in GNU_TYPES: + obj.name = prefix + "/" + obj.name + return obj + + @classmethod + def fromtarfile(cls, tarfile): + """Return the next TarInfo object from TarFile object + tarfile. + """ + buf = tarfile.fileobj.read(BLOCKSIZE) + obj = cls.frombuf(buf, tarfile.encoding, tarfile.errors) + obj.offset = tarfile.fileobj.tell() - BLOCKSIZE + return obj._proc_member(tarfile) + + #-------------------------------------------------------------------------- + # The following are methods that are called depending on the type of a + # member. The entry point is _proc_member() which can be overridden in a + # subclass to add custom _proc_*() methods. A _proc_*() method MUST + # implement the following + # operations: + # 1. Set self.offset_data to the position where the data blocks begin, + # if there is data that follows. + # 2. Set tarfile.offset to the position where the next member's header will + # begin. + # 3. Return self or another valid TarInfo object. + def _proc_member(self, tarfile): + """Choose the right processing method depending on + the type and call it. + """ + if self.type in (GNUTYPE_LONGNAME, GNUTYPE_LONGLINK): + return self._proc_gnulong(tarfile) + elif self.type == GNUTYPE_SPARSE: + return self._proc_sparse(tarfile) + elif self.type in (XHDTYPE, XGLTYPE, SOLARIS_XHDTYPE): + return self._proc_pax(tarfile) + else: + return self._proc_builtin(tarfile) + + def _proc_builtin(self, tarfile): + """Process a builtin type or an unknown type which + will be treated as a regular file. + """ + self.offset_data = tarfile.fileobj.tell() + offset = self.offset_data + if self.isreg() or self.type not in SUPPORTED_TYPES: + # Skip the following data blocks. + offset += self._block(self.size) + tarfile.offset = offset + + # Patch the TarInfo object with saved global + # header information. + self._apply_pax_info(tarfile.pax_headers, tarfile.encoding, tarfile.errors) + + # Remove redundant slashes from directories. This is to be consistent + # with frombuf(). + if self.isdir(): + self.name = self.name.rstrip("/") + + return self + + def _proc_gnulong(self, tarfile): + """Process the blocks that hold a GNU longname + or longlink member. + """ + buf = tarfile.fileobj.read(self._block(self.size)) + + # Fetch the next header and process it. + try: + next = self.fromtarfile(tarfile) + except HeaderError as e: + raise SubsequentHeaderError(str(e)) from None + + # Patch the TarInfo object from the next header with + # the longname information. + next.offset = self.offset + if self.type == GNUTYPE_LONGNAME: + next.name = nts(buf, tarfile.encoding, tarfile.errors) + elif self.type == GNUTYPE_LONGLINK: + next.linkname = nts(buf, tarfile.encoding, tarfile.errors) + + # Remove redundant slashes from directories. This is to be consistent + # with frombuf(). + if next.isdir(): + next.name = removesuffix(next.name, "/") + + return next + + def _proc_sparse(self, tarfile): + """Process a GNU sparse header plus extra headers. + """ + # We already collected some sparse structures in frombuf(). + structs, isextended, origsize = self._sparse_structs + del self._sparse_structs + + # Collect sparse structures from extended header blocks. + while isextended: + buf = tarfile.fileobj.read(BLOCKSIZE) + pos = 0 + for i in range(21): + try: + offset = nti(buf[pos:pos + 12]) + numbytes = nti(buf[pos + 12:pos + 24]) + except ValueError: + break + if offset and numbytes: + structs.append((offset, numbytes)) + pos += 24 + isextended = bool(buf[504]) + self.sparse = structs + + self.offset_data = tarfile.fileobj.tell() + tarfile.offset = self.offset_data + self._block(self.size) + self.size = origsize + return self + + def _proc_pax(self, tarfile): + """Process an extended or global header as described in + POSIX.1-2008. + """ + # Read the header information. + buf = tarfile.fileobj.read(self._block(self.size)) + + # A pax header stores supplemental information for either + # the following file (extended) or all following files + # (global). + if self.type == XGLTYPE: + pax_headers = tarfile.pax_headers + else: + pax_headers = tarfile.pax_headers.copy() + + # Check if the pax header contains a hdrcharset field. This tells us + # the encoding of the path, linkpath, uname and gname fields. Normally, + # these fields are UTF-8 encoded but since POSIX.1-2008 tar + # implementations are allowed to store them as raw binary strings if + # the translation to UTF-8 fails. + match = re.search(br"\d+ hdrcharset=([^\n]+)\n", buf) + if match is not None: + pax_headers["hdrcharset"] = match.group(1).decode("utf-8") + + # For the time being, we don't care about anything other than "BINARY". + # The only other value that is currently allowed by the standard is + # "ISO-IR 10646 2000 UTF-8" in other words UTF-8. + hdrcharset = pax_headers.get("hdrcharset") + if hdrcharset == "BINARY": + encoding = tarfile.encoding + else: + encoding = "utf-8" + + # Parse pax header information. A record looks like that: + # "%d %s=%s\n" % (length, keyword, value). length is the size + # of the complete record including the length field itself and + # the newline. keyword and value are both UTF-8 encoded strings. + regex = re.compile(br"(\d+) ([^=]+)=") + pos = 0 + while match := regex.match(buf, pos): + length, keyword = match.groups() + length = int(length) + if length == 0: + raise InvalidHeaderError("invalid header") + value = buf[match.end(2) + 1:match.start(1) + length - 1] + + # Normally, we could just use "utf-8" as the encoding and "strict" + # as the error handler, but we better not take the risk. For + # example, GNU tar <= 1.23 is known to store filenames it cannot + # translate to UTF-8 as raw strings (unfortunately without a + # hdrcharset=BINARY header). + # We first try the strict standard encoding, and if that fails we + # fall back on the user's encoding and error handler. + keyword = self._decode_pax_field(keyword, "utf-8", "utf-8", + tarfile.errors) + if keyword in PAX_NAME_FIELDS: + value = self._decode_pax_field(value, encoding, tarfile.encoding, + tarfile.errors) + else: + value = self._decode_pax_field(value, "utf-8", "utf-8", + tarfile.errors) + + pax_headers[keyword] = value + pos += length + + # Fetch the next header. + try: + next = self.fromtarfile(tarfile) + except HeaderError as e: + raise SubsequentHeaderError(str(e)) from None + + # Process GNU sparse information. + if "GNU.sparse.map" in pax_headers: + # GNU extended sparse format version 0.1. + self._proc_gnusparse_01(next, pax_headers) + + elif "GNU.sparse.size" in pax_headers: + # GNU extended sparse format version 0.0. + self._proc_gnusparse_00(next, pax_headers, buf) + + elif pax_headers.get("GNU.sparse.major") == "1" and pax_headers.get("GNU.sparse.minor") == "0": + # GNU extended sparse format version 1.0. + self._proc_gnusparse_10(next, pax_headers, tarfile) + + if self.type in (XHDTYPE, SOLARIS_XHDTYPE): + # Patch the TarInfo object with the extended header info. + next._apply_pax_info(pax_headers, tarfile.encoding, tarfile.errors) + next.offset = self.offset + + if "size" in pax_headers: + # If the extended header replaces the size field, + # we need to recalculate the offset where the next + # header starts. + offset = next.offset_data + if next.isreg() or next.type not in SUPPORTED_TYPES: + offset += next._block(next.size) + tarfile.offset = offset + + return next + + def _proc_gnusparse_00(self, next, pax_headers, buf): + """Process a GNU tar extended sparse header, version 0.0. + """ + offsets = [] + for match in re.finditer(br"\d+ GNU.sparse.offset=(\d+)\n", buf): + offsets.append(int(match.group(1))) + numbytes = [] + for match in re.finditer(br"\d+ GNU.sparse.numbytes=(\d+)\n", buf): + numbytes.append(int(match.group(1))) + next.sparse = list(zip(offsets, numbytes)) + + def _proc_gnusparse_01(self, next, pax_headers): + """Process a GNU tar extended sparse header, version 0.1. + """ + sparse = [int(x) for x in pax_headers["GNU.sparse.map"].split(",")] + next.sparse = list(zip(sparse[::2], sparse[1::2])) + + def _proc_gnusparse_10(self, next, pax_headers, tarfile): + """Process a GNU tar extended sparse header, version 1.0. + """ + fields = None + sparse = [] + buf = tarfile.fileobj.read(BLOCKSIZE) + fields, buf = buf.split(b"\n", 1) + fields = int(fields) + while len(sparse) < fields * 2: + if b"\n" not in buf: + buf += tarfile.fileobj.read(BLOCKSIZE) + number, buf = buf.split(b"\n", 1) + sparse.append(int(number)) + next.offset_data = tarfile.fileobj.tell() + next.sparse = list(zip(sparse[::2], sparse[1::2])) + + def _apply_pax_info(self, pax_headers, encoding, errors): + """Replace fields with supplemental information from a previous + pax extended or global header. + """ + for keyword, value in pax_headers.items(): + if keyword == "GNU.sparse.name": + setattr(self, "path", value) + elif keyword == "GNU.sparse.size": + setattr(self, "size", int(value)) + elif keyword == "GNU.sparse.realsize": + setattr(self, "size", int(value)) + elif keyword in PAX_FIELDS: + if keyword in PAX_NUMBER_FIELDS: + try: + value = PAX_NUMBER_FIELDS[keyword](value) + except ValueError: + value = 0 + if keyword == "path": + value = value.rstrip("/") + setattr(self, keyword, value) + + self.pax_headers = pax_headers.copy() + + def _decode_pax_field(self, value, encoding, fallback_encoding, fallback_errors): + """Decode a single field from a pax record. + """ + try: + return value.decode(encoding, "strict") + except UnicodeDecodeError: + return value.decode(fallback_encoding, fallback_errors) + + def _block(self, count): + """Round up a byte count by BLOCKSIZE and return it, + e.g. _block(834) => 1024. + """ + blocks, remainder = divmod(count, BLOCKSIZE) + if remainder: + blocks += 1 + return blocks * BLOCKSIZE + + def isreg(self): + 'Return True if the Tarinfo object is a regular file.' + return self.type in REGULAR_TYPES + + def isfile(self): + 'Return True if the Tarinfo object is a regular file.' + return self.isreg() + + def isdir(self): + 'Return True if it is a directory.' + return self.type == DIRTYPE + + def issym(self): + 'Return True if it is a symbolic link.' + return self.type == SYMTYPE + + def islnk(self): + 'Return True if it is a hard link.' + return self.type == LNKTYPE + + def ischr(self): + 'Return True if it is a character device.' + return self.type == CHRTYPE + + def isblk(self): + 'Return True if it is a block device.' + return self.type == BLKTYPE + + def isfifo(self): + 'Return True if it is a FIFO.' + return self.type == FIFOTYPE + + def issparse(self): + return self.sparse is not None + + def isdev(self): + 'Return True if it is one of character device, block device or FIFO.' + return self.type in (CHRTYPE, BLKTYPE, FIFOTYPE) +# class TarInfo + +class TarFile(object): + """The TarFile Class provides an interface to tar archives. + """ + + debug = 0 # May be set from 0 (no msgs) to 3 (all msgs) + + dereference = False # If true, add content of linked file to the + # tar file, else the link. + + ignore_zeros = False # If true, skips empty or invalid blocks and + # continues processing. + + errorlevel = 1 # If 0, fatal errors only appear in debug + # messages (if debug >= 0). If > 0, errors + # are passed to the caller as exceptions. + + format = DEFAULT_FORMAT # The format to use when creating an archive. + + encoding = ENCODING # Encoding for 8-bit character strings. + + errors = None # Error handler for unicode conversion. + + tarinfo = TarInfo # The default TarInfo class to use. + + fileobject = ExFileObject # The file-object for extractfile(). + + extraction_filter = None # The default filter for extraction. + + def __init__(self, name=None, mode="r", fileobj=None, format=None, + tarinfo=None, dereference=None, ignore_zeros=None, encoding=None, + errors="surrogateescape", pax_headers=None, debug=None, + errorlevel=None, copybufsize=None, stream=False): + """Open an (uncompressed) tar archive 'name'. 'mode' is either 'r' to + read from an existing archive, 'a' to append data to an existing + file or 'w' to create a new file overwriting an existing one. 'mode' + defaults to 'r'. + If 'fileobj' is given, it is used for reading or writing data. If it + can be determined, 'mode' is overridden by 'fileobj's mode. + 'fileobj' is not closed, when TarFile is closed. + """ + modes = {"r": "rb", "a": "r+b", "w": "wb", "x": "xb"} + if mode not in modes: + raise ValueError("mode must be 'r', 'a', 'w' or 'x'") + self.mode = mode + self._mode = modes[mode] + + if not fileobj: + if self.mode == "a" and not os.path.exists(name): + # Create nonexistent files in append mode. + self.mode = "w" + self._mode = "wb" + fileobj = bltn_open(name, self._mode) + self._extfileobj = False + else: + if (name is None and hasattr(fileobj, "name") and + isinstance(fileobj.name, (str, bytes))): + name = fileobj.name + if hasattr(fileobj, "mode"): + self._mode = fileobj.mode + self._extfileobj = True + self.name = os.path.abspath(name) if name else None + self.fileobj = fileobj + + self.stream = stream + + # Init attributes. + if format is not None: + self.format = format + if tarinfo is not None: + self.tarinfo = tarinfo + if dereference is not None: + self.dereference = dereference + if ignore_zeros is not None: + self.ignore_zeros = ignore_zeros + if encoding is not None: + self.encoding = encoding + self.errors = errors + + if pax_headers is not None and self.format == PAX_FORMAT: + self.pax_headers = pax_headers + else: + self.pax_headers = {} + + if debug is not None: + self.debug = debug + if errorlevel is not None: + self.errorlevel = errorlevel + + # Init datastructures. + self.copybufsize = copybufsize + self.closed = False + self.members = [] # list of members as TarInfo objects + self._loaded = False # flag if all members have been read + self.offset = self.fileobj.tell() + # current position in the archive file + self.inodes = {} # dictionary caching the inodes of + # archive members already added + + try: + if self.mode == "r": + self.firstmember = None + self.firstmember = self.next() + + if self.mode == "a": + # Move to the end of the archive, + # before the first empty block. + while True: + self.fileobj.seek(self.offset) + try: + tarinfo = self.tarinfo.fromtarfile(self) + self.members.append(tarinfo) + except EOFHeaderError: + self.fileobj.seek(self.offset) + break + except HeaderError as e: + raise ReadError(str(e)) from None + + if self.mode in ("a", "w", "x"): + self._loaded = True + + if self.pax_headers: + buf = self.tarinfo.create_pax_global_header(self.pax_headers.copy()) + self.fileobj.write(buf) + self.offset += len(buf) + except: + if not self._extfileobj: + self.fileobj.close() + self.closed = True + raise + + #-------------------------------------------------------------------------- + # Below are the classmethods which act as alternate constructors to the + # TarFile class. The open() method is the only one that is needed for + # public use; it is the "super"-constructor and is able to select an + # adequate "sub"-constructor for a particular compression using the mapping + # from OPEN_METH. + # + # This concept allows one to subclass TarFile without losing the comfort of + # the super-constructor. A sub-constructor is registered and made available + # by adding it to the mapping in OPEN_METH. + + @classmethod + def open(cls, name=None, mode="r", fileobj=None, bufsize=RECORDSIZE, **kwargs): + r"""Open a tar archive for reading, writing or appending. Return + an appropriate TarFile class. + + mode: + 'r' or 'r:\*' open for reading with transparent compression + 'r:' open for reading exclusively uncompressed + 'r:gz' open for reading with gzip compression + 'r:bz2' open for reading with bzip2 compression + 'r:xz' open for reading with lzma compression + 'a' or 'a:' open for appending, creating the file if necessary + 'w' or 'w:' open for writing without compression + 'w:gz' open for writing with gzip compression + 'w:bz2' open for writing with bzip2 compression + 'w:xz' open for writing with lzma compression + + 'x' or 'x:' create a tarfile exclusively without compression, raise + an exception if the file is already created + 'x:gz' create a gzip compressed tarfile, raise an exception + if the file is already created + 'x:bz2' create a bzip2 compressed tarfile, raise an exception + if the file is already created + 'x:xz' create an lzma compressed tarfile, raise an exception + if the file is already created + + 'r|\*' open a stream of tar blocks with transparent compression + 'r|' open an uncompressed stream of tar blocks for reading + 'r|gz' open a gzip compressed stream of tar blocks + 'r|bz2' open a bzip2 compressed stream of tar blocks + 'r|xz' open an lzma compressed stream of tar blocks + 'w|' open an uncompressed stream for writing + 'w|gz' open a gzip compressed stream for writing + 'w|bz2' open a bzip2 compressed stream for writing + 'w|xz' open an lzma compressed stream for writing + """ + + if not name and not fileobj: + raise ValueError("nothing to open") + + if mode in ("r", "r:*"): + # Find out which *open() is appropriate for opening the file. + def not_compressed(comptype): + return cls.OPEN_METH[comptype] == 'taropen' + error_msgs = [] + for comptype in sorted(cls.OPEN_METH, key=not_compressed): + func = getattr(cls, cls.OPEN_METH[comptype]) + if fileobj is not None: + saved_pos = fileobj.tell() + try: + return func(name, "r", fileobj, **kwargs) + except (ReadError, CompressionError) as e: + error_msgs.append(f'- method {comptype}: {e!r}') + if fileobj is not None: + fileobj.seek(saved_pos) + continue + error_msgs_summary = '\n'.join(error_msgs) + raise ReadError(f"file could not be opened successfully:\n{error_msgs_summary}") + + elif ":" in mode: + filemode, comptype = mode.split(":", 1) + filemode = filemode or "r" + comptype = comptype or "tar" + + # Select the *open() function according to + # given compression. + if comptype in cls.OPEN_METH: + func = getattr(cls, cls.OPEN_METH[comptype]) + else: + raise CompressionError("unknown compression type %r" % comptype) + return func(name, filemode, fileobj, **kwargs) + + elif "|" in mode: + filemode, comptype = mode.split("|", 1) + filemode = filemode or "r" + comptype = comptype or "tar" + + if filemode not in ("r", "w"): + raise ValueError("mode must be 'r' or 'w'") + + compresslevel = kwargs.pop("compresslevel", 9) + stream = _Stream(name, filemode, comptype, fileobj, bufsize, + compresslevel) + try: + t = cls(name, filemode, stream, **kwargs) + except: + stream.close() + raise + t._extfileobj = False + return t + + elif mode in ("a", "w", "x"): + return cls.taropen(name, mode, fileobj, **kwargs) + + raise ValueError("undiscernible mode") + + @classmethod + def taropen(cls, name, mode="r", fileobj=None, **kwargs): + """Open uncompressed tar archive name for reading or writing. + """ + if mode not in ("r", "a", "w", "x"): + raise ValueError("mode must be 'r', 'a', 'w' or 'x'") + return cls(name, mode, fileobj, **kwargs) + + @classmethod + def gzopen(cls, name, mode="r", fileobj=None, compresslevel=9, **kwargs): + """Open gzip compressed tar archive name for reading or writing. + Appending is not allowed. + """ + if mode not in ("r", "w", "x"): + raise ValueError("mode must be 'r', 'w' or 'x'") + + try: + from gzip import GzipFile + except ImportError: + raise CompressionError("gzip module is not available") from None + + try: + fileobj = GzipFile(name, mode + "b", compresslevel, fileobj) + except OSError as e: + if fileobj is not None and mode == 'r': + raise ReadError("not a gzip file") from e + raise + + try: + t = cls.taropen(name, mode, fileobj, **kwargs) + except OSError as e: + fileobj.close() + if mode == 'r': + raise ReadError("not a gzip file") from e + raise + except: + fileobj.close() + raise + t._extfileobj = False + return t + + @classmethod + def bz2open(cls, name, mode="r", fileobj=None, compresslevel=9, **kwargs): + """Open bzip2 compressed tar archive name for reading or writing. + Appending is not allowed. + """ + if mode not in ("r", "w", "x"): + raise ValueError("mode must be 'r', 'w' or 'x'") + + try: + from bz2 import BZ2File + except ImportError: + raise CompressionError("bz2 module is not available") from None + + fileobj = BZ2File(fileobj or name, mode, compresslevel=compresslevel) + + try: + t = cls.taropen(name, mode, fileobj, **kwargs) + except (OSError, EOFError) as e: + fileobj.close() + if mode == 'r': + raise ReadError("not a bzip2 file") from e + raise + except: + fileobj.close() + raise + t._extfileobj = False + return t + + @classmethod + def xzopen(cls, name, mode="r", fileobj=None, preset=None, **kwargs): + """Open lzma compressed tar archive name for reading or writing. + Appending is not allowed. + """ + if mode not in ("r", "w", "x"): + raise ValueError("mode must be 'r', 'w' or 'x'") + + try: + from lzma import LZMAFile, LZMAError + except ImportError: + raise CompressionError("lzma module is not available") from None + + fileobj = LZMAFile(fileobj or name, mode, preset=preset) + + try: + t = cls.taropen(name, mode, fileobj, **kwargs) + except (LZMAError, EOFError) as e: + fileobj.close() + if mode == 'r': + raise ReadError("not an lzma file") from e + raise + except: + fileobj.close() + raise + t._extfileobj = False + return t + + # All *open() methods are registered here. + OPEN_METH = { + "tar": "taropen", # uncompressed tar + "gz": "gzopen", # gzip compressed tar + "bz2": "bz2open", # bzip2 compressed tar + "xz": "xzopen" # lzma compressed tar + } + + #-------------------------------------------------------------------------- + # The public methods which TarFile provides: + + def close(self): + """Close the TarFile. In write-mode, two finishing zero blocks are + appended to the archive. + """ + if self.closed: + return + + self.closed = True + try: + if self.mode in ("a", "w", "x"): + self.fileobj.write(NUL * (BLOCKSIZE * 2)) + self.offset += (BLOCKSIZE * 2) + # fill up the end with zero-blocks + # (like option -b20 for tar does) + blocks, remainder = divmod(self.offset, RECORDSIZE) + if remainder > 0: + self.fileobj.write(NUL * (RECORDSIZE - remainder)) + finally: + if not self._extfileobj: + self.fileobj.close() + + def getmember(self, name): + """Return a TarInfo object for member 'name'. If 'name' can not be + found in the archive, KeyError is raised. If a member occurs more + than once in the archive, its last occurrence is assumed to be the + most up-to-date version. + """ + tarinfo = self._getmember(name.rstrip('/')) + if tarinfo is None: + raise KeyError("filename %r not found" % name) + return tarinfo + + def getmembers(self): + """Return the members of the archive as a list of TarInfo objects. The + list has the same order as the members in the archive. + """ + self._check() + if not self._loaded: # if we want to obtain a list of + self._load() # all members, we first have to + # scan the whole archive. + return self.members + + def getnames(self): + """Return the members of the archive as a list of their names. It has + the same order as the list returned by getmembers(). + """ + return [tarinfo.name for tarinfo in self.getmembers()] + + def gettarinfo(self, name=None, arcname=None, fileobj=None): + """Create a TarInfo object from the result of os.stat or equivalent + on an existing file. The file is either named by 'name', or + specified as a file object 'fileobj' with a file descriptor. If + given, 'arcname' specifies an alternative name for the file in the + archive, otherwise, the name is taken from the 'name' attribute of + 'fileobj', or the 'name' argument. The name should be a text + string. + """ + self._check("awx") + + # When fileobj is given, replace name by + # fileobj's real name. + if fileobj is not None: + name = fileobj.name + + # Building the name of the member in the archive. + # Backward slashes are converted to forward slashes, + # Absolute paths are turned to relative paths. + if arcname is None: + arcname = name + drv, arcname = os.path.splitdrive(arcname) + arcname = arcname.replace(os.sep, "/") + arcname = arcname.lstrip("/") + + # Now, fill the TarInfo object with + # information specific for the file. + tarinfo = self.tarinfo() + tarinfo._tarfile = self # To be removed in 3.16. + + # Use os.stat or os.lstat, depending on if symlinks shall be resolved. + if fileobj is None: + if not self.dereference: + statres = os.lstat(name) + else: + statres = os.stat(name) + else: + statres = os.fstat(fileobj.fileno()) + linkname = "" + + stmd = statres.st_mode + if stat.S_ISREG(stmd): + inode = (statres.st_ino, statres.st_dev) + if not self.dereference and statres.st_nlink > 1 and \ + inode in self.inodes and arcname != self.inodes[inode]: + # Is it a hardlink to an already + # archived file? + type = LNKTYPE + linkname = self.inodes[inode] + else: + # The inode is added only if its valid. + # For win32 it is always 0. + type = REGTYPE + if inode[0]: + self.inodes[inode] = arcname + elif stat.S_ISDIR(stmd): + type = DIRTYPE + elif stat.S_ISFIFO(stmd): + type = FIFOTYPE + elif stat.S_ISLNK(stmd): + type = SYMTYPE + linkname = os.readlink(name) + elif stat.S_ISCHR(stmd): + type = CHRTYPE + elif stat.S_ISBLK(stmd): + type = BLKTYPE + else: + return None + + # Fill the TarInfo object with all + # information we can get. + tarinfo.name = arcname + tarinfo.mode = stmd + tarinfo.uid = statres.st_uid + tarinfo.gid = statres.st_gid + if type == REGTYPE: + tarinfo.size = statres.st_size + else: + tarinfo.size = 0 + tarinfo.mtime = statres.st_mtime + tarinfo.type = type + tarinfo.linkname = linkname + if pwd: + try: + tarinfo.uname = pwd.getpwuid(tarinfo.uid)[0] + except KeyError: + pass + if grp: + try: + tarinfo.gname = grp.getgrgid(tarinfo.gid)[0] + except KeyError: + pass + + if type in (CHRTYPE, BLKTYPE): + if hasattr(os, "major") and hasattr(os, "minor"): + tarinfo.devmajor = os.major(statres.st_rdev) + tarinfo.devminor = os.minor(statres.st_rdev) + return tarinfo + + def list(self, verbose=True, *, members=None): + """Print a table of contents to sys.stdout. If 'verbose' is False, only + the names of the members are printed. If it is True, an 'ls -l'-like + output is produced. 'members' is optional and must be a subset of the + list returned by getmembers(). + """ + # Convert tarinfo type to stat type. + type2mode = {REGTYPE: stat.S_IFREG, SYMTYPE: stat.S_IFLNK, + FIFOTYPE: stat.S_IFIFO, CHRTYPE: stat.S_IFCHR, + DIRTYPE: stat.S_IFDIR, BLKTYPE: stat.S_IFBLK} + self._check() + + if members is None: + members = self + for tarinfo in members: + if verbose: + if tarinfo.mode is None: + _safe_print("??????????") + else: + modetype = type2mode.get(tarinfo.type, 0) + _safe_print(stat.filemode(modetype | tarinfo.mode)) + _safe_print("%s/%s" % (tarinfo.uname or tarinfo.uid, + tarinfo.gname or tarinfo.gid)) + if tarinfo.ischr() or tarinfo.isblk(): + _safe_print("%10s" % + ("%d,%d" % (tarinfo.devmajor, tarinfo.devminor))) + else: + _safe_print("%10d" % tarinfo.size) + if tarinfo.mtime is None: + _safe_print("????-??-?? ??:??:??") + else: + _safe_print("%d-%02d-%02d %02d:%02d:%02d" \ + % time.localtime(tarinfo.mtime)[:6]) + + _safe_print(tarinfo.name + ("/" if tarinfo.isdir() else "")) + + if verbose: + if tarinfo.issym(): + _safe_print("-> " + tarinfo.linkname) + if tarinfo.islnk(): + _safe_print("link to " + tarinfo.linkname) + print() + + def add(self, name, arcname=None, recursive=True, *, filter=None): + """Add the file 'name' to the archive. 'name' may be any type of file + (directory, fifo, symbolic link, etc.). If given, 'arcname' + specifies an alternative name for the file in the archive. + Directories are added recursively by default. This can be avoided by + setting 'recursive' to False. 'filter' is a function + that expects a TarInfo object argument and returns the changed + TarInfo object, if it returns None the TarInfo object will be + excluded from the archive. + """ + self._check("awx") + + if arcname is None: + arcname = name + + # Skip if somebody tries to archive the archive... + if self.name is not None and os.path.abspath(name) == self.name: + self._dbg(2, "tarfile: Skipped %r" % name) + return + + self._dbg(1, name) + + # Create a TarInfo object from the file. + tarinfo = self.gettarinfo(name, arcname) + + if tarinfo is None: + self._dbg(1, "tarfile: Unsupported type %r" % name) + return + + # Change or exclude the TarInfo object. + if filter is not None: + tarinfo = filter(tarinfo) + if tarinfo is None: + self._dbg(2, "tarfile: Excluded %r" % name) + return + + # Append the tar header and data to the archive. + if tarinfo.isreg(): + with bltn_open(name, "rb") as f: + self.addfile(tarinfo, f) + + elif tarinfo.isdir(): + self.addfile(tarinfo) + if recursive: + for f in sorted(os.listdir(name)): + self.add(os.path.join(name, f), os.path.join(arcname, f), + recursive, filter=filter) + + else: + self.addfile(tarinfo) + + def addfile(self, tarinfo, fileobj=None): + """Add the TarInfo object 'tarinfo' to the archive. If 'tarinfo' represents + a non zero-size regular file, the 'fileobj' argument should be a binary file, + and tarinfo.size bytes are read from it and added to the archive. + You can create TarInfo objects directly, or by using gettarinfo(). + """ + self._check("awx") + + if fileobj is None and tarinfo.isreg() and tarinfo.size != 0: + raise ValueError("fileobj not provided for non zero-size regular file") + + tarinfo = copy.copy(tarinfo) + + buf = tarinfo.tobuf(self.format, self.encoding, self.errors) + self.fileobj.write(buf) + self.offset += len(buf) + bufsize=self.copybufsize + # If there's data to follow, append it. + if fileobj is not None: + copyfileobj(fileobj, self.fileobj, tarinfo.size, bufsize=bufsize) + blocks, remainder = divmod(tarinfo.size, BLOCKSIZE) + if remainder > 0: + self.fileobj.write(NUL * (BLOCKSIZE - remainder)) + blocks += 1 + self.offset += blocks * BLOCKSIZE + + self.members.append(tarinfo) + + def _get_filter_function(self, filter): + if filter is None: + filter = self.extraction_filter + if filter is None: + import warnings + warnings.warn( + 'Python 3.14 will, by default, filter extracted tar ' + + 'archives and reject files or modify their metadata. ' + + 'Use the filter argument to control this behavior.', + DeprecationWarning, stacklevel=3) + return fully_trusted_filter + if isinstance(filter, str): + raise TypeError( + 'String names are not supported for ' + + 'TarFile.extraction_filter. Use a function such as ' + + 'tarfile.data_filter directly.') + return filter + if callable(filter): + return filter + try: + return _NAMED_FILTERS[filter] + except KeyError: + raise ValueError(f"filter {filter!r} not found") from None + + def extractall(self, path=".", members=None, *, numeric_owner=False, + filter=None): + """Extract all members from the archive to the current working + directory and set owner, modification time and permissions on + directories afterwards. 'path' specifies a different directory + to extract to. 'members' is optional and must be a subset of the + list returned by getmembers(). If 'numeric_owner' is True, only + the numbers for user/group names are used and not the names. + + The 'filter' function will be called on each member just + before extraction. + It can return a changed TarInfo or None to skip the member. + String names of common filters are accepted. + """ + directories = [] + + filter_function = self._get_filter_function(filter) + if members is None: + members = self + + for member in members: + tarinfo = self._get_extract_tarinfo(member, filter_function, path) + if tarinfo is None: + continue + if tarinfo.isdir(): + # For directories, delay setting attributes until later, + # since permissions can interfere with extraction and + # extracting contents can reset mtime. + directories.append(tarinfo) + self._extract_one(tarinfo, path, set_attrs=not tarinfo.isdir(), + numeric_owner=numeric_owner) + + # Reverse sort directories. + directories.sort(key=lambda a: a.name, reverse=True) + + # Set correct owner, mtime and filemode on directories. + for tarinfo in directories: + dirpath = os.path.join(path, tarinfo.name) + try: + self.chown(tarinfo, dirpath, numeric_owner=numeric_owner) + self.utime(tarinfo, dirpath) + self.chmod(tarinfo, dirpath) + except ExtractError as e: + self._handle_nonfatal_error(e) + + def extract(self, member, path="", set_attrs=True, *, numeric_owner=False, + filter=None): + """Extract a member from the archive to the current working directory, + using its full name. Its file information is extracted as accurately + as possible. 'member' may be a filename or a TarInfo object. You can + specify a different directory using 'path'. File attributes (owner, + mtime, mode) are set unless 'set_attrs' is False. If 'numeric_owner' + is True, only the numbers for user/group names are used and not + the names. + + The 'filter' function will be called before extraction. + It can return a changed TarInfo or None to skip the member. + String names of common filters are accepted. + """ + filter_function = self._get_filter_function(filter) + tarinfo = self._get_extract_tarinfo(member, filter_function, path) + if tarinfo is not None: + self._extract_one(tarinfo, path, set_attrs, numeric_owner) + + def _get_extract_tarinfo(self, member, filter_function, path): + """Get filtered TarInfo (or None) from member, which might be a str""" + if isinstance(member, str): + tarinfo = self.getmember(member) + else: + tarinfo = member + + unfiltered = tarinfo + try: + tarinfo = filter_function(tarinfo, path) + except (OSError, FilterError) as e: + self._handle_fatal_error(e) + except ExtractError as e: + self._handle_nonfatal_error(e) + if tarinfo is None: + self._dbg(2, "tarfile: Excluded %r" % unfiltered.name) + return None + # Prepare the link target for makelink(). + if tarinfo.islnk(): + tarinfo = copy.copy(tarinfo) + tarinfo._link_target = os.path.join(path, tarinfo.linkname) + return tarinfo + + def _extract_one(self, tarinfo, path, set_attrs, numeric_owner): + """Extract from filtered tarinfo to disk""" + self._check("r") + + try: + self._extract_member(tarinfo, os.path.join(path, tarinfo.name), + set_attrs=set_attrs, + numeric_owner=numeric_owner) + except OSError as e: + self._handle_fatal_error(e) + except ExtractError as e: + self._handle_nonfatal_error(e) + + def _handle_nonfatal_error(self, e): + """Handle non-fatal error (ExtractError) according to errorlevel""" + if self.errorlevel > 1: + raise + else: + self._dbg(1, "tarfile: %s" % e) + + def _handle_fatal_error(self, e): + """Handle "fatal" error according to self.errorlevel""" + if self.errorlevel > 0: + raise + elif isinstance(e, OSError): + if e.filename is None: + self._dbg(1, "tarfile: %s" % e.strerror) + else: + self._dbg(1, "tarfile: %s %r" % (e.strerror, e.filename)) + else: + self._dbg(1, "tarfile: %s %s" % (type(e).__name__, e)) + + def extractfile(self, member): + """Extract a member from the archive as a file object. 'member' may be + a filename or a TarInfo object. If 'member' is a regular file or + a link, an io.BufferedReader object is returned. For all other + existing members, None is returned. If 'member' does not appear + in the archive, KeyError is raised. + """ + self._check("r") + + if isinstance(member, str): + tarinfo = self.getmember(member) + else: + tarinfo = member + + if tarinfo.isreg() or tarinfo.type not in SUPPORTED_TYPES: + # Members with unknown types are treated as regular files. + return self.fileobject(self, tarinfo) + + elif tarinfo.islnk() or tarinfo.issym(): + if isinstance(self.fileobj, _Stream): + # A small but ugly workaround for the case that someone tries + # to extract a (sym)link as a file-object from a non-seekable + # stream of tar blocks. + raise StreamError("cannot extract (sym)link as file object") + else: + # A (sym)link's file object is its target's file object. + return self.extractfile(self._find_link_target(tarinfo)) + else: + # If there's no data associated with the member (directory, chrdev, + # blkdev, etc.), return None instead of a file object. + return None + + def _extract_member(self, tarinfo, targetpath, set_attrs=True, + numeric_owner=False): + """Extract the TarInfo object tarinfo to a physical + file called targetpath. + """ + # Fetch the TarInfo object for the given name + # and build the destination pathname, replacing + # forward slashes to platform specific separators. + targetpath = targetpath.rstrip("/") + targetpath = targetpath.replace("/", os.sep) + + # Create all upper directories. + upperdirs = os.path.dirname(targetpath) + if upperdirs and not os.path.exists(upperdirs): + # Create directories that are not part of the archive with + # default permissions. + os.makedirs(upperdirs, exist_ok=True) + + if tarinfo.islnk() or tarinfo.issym(): + self._dbg(1, "%s -> %s" % (tarinfo.name, tarinfo.linkname)) + else: + self._dbg(1, tarinfo.name) + + if tarinfo.isreg(): + self.makefile(tarinfo, targetpath) + elif tarinfo.isdir(): + self.makedir(tarinfo, targetpath) + elif tarinfo.isfifo(): + self.makefifo(tarinfo, targetpath) + elif tarinfo.ischr() or tarinfo.isblk(): + self.makedev(tarinfo, targetpath) + elif tarinfo.islnk() or tarinfo.issym(): + self.makelink(tarinfo, targetpath) + elif tarinfo.type not in SUPPORTED_TYPES: + self.makeunknown(tarinfo, targetpath) + else: + self.makefile(tarinfo, targetpath) + + if set_attrs: + self.chown(tarinfo, targetpath, numeric_owner) + if not tarinfo.issym(): + self.chmod(tarinfo, targetpath) + self.utime(tarinfo, targetpath) + + #-------------------------------------------------------------------------- + # Below are the different file methods. They are called via + # _extract_member() when extract() is called. They can be replaced in a + # subclass to implement other functionality. + + def makedir(self, tarinfo, targetpath): + """Make a directory called targetpath. + """ + try: + if tarinfo.mode is None: + # Use the system's default mode + os.mkdir(targetpath) + else: + # Use a safe mode for the directory, the real mode is set + # later in _extract_member(). + os.mkdir(targetpath, 0o700) + except FileExistsError: + if not os.path.isdir(targetpath): + raise + + def makefile(self, tarinfo, targetpath): + """Make a file called targetpath. + """ + source = self.fileobj + source.seek(tarinfo.offset_data) + bufsize = self.copybufsize + with bltn_open(targetpath, "wb") as target: + if tarinfo.sparse is not None: + for offset, size in tarinfo.sparse: + target.seek(offset) + copyfileobj(source, target, size, ReadError, bufsize) + target.seek(tarinfo.size) + target.truncate() + else: + copyfileobj(source, target, tarinfo.size, ReadError, bufsize) + + def makeunknown(self, tarinfo, targetpath): + """Make a file from a TarInfo object with an unknown type + at targetpath. + """ + self.makefile(tarinfo, targetpath) + self._dbg(1, "tarfile: Unknown file type %r, " \ + "extracted as regular file." % tarinfo.type) + + def makefifo(self, tarinfo, targetpath): + """Make a fifo called targetpath. + """ + if hasattr(os, "mkfifo"): + os.mkfifo(targetpath) + else: + raise ExtractError("fifo not supported by system") + + def makedev(self, tarinfo, targetpath): + """Make a character or block device called targetpath. + """ + if not hasattr(os, "mknod") or not hasattr(os, "makedev"): + raise ExtractError("special devices not supported by system") + + mode = tarinfo.mode + if mode is None: + # Use mknod's default + mode = 0o600 + if tarinfo.isblk(): + mode |= stat.S_IFBLK + else: + mode |= stat.S_IFCHR + + os.mknod(targetpath, mode, + os.makedev(tarinfo.devmajor, tarinfo.devminor)) + + def makelink(self, tarinfo, targetpath): + """Make a (symbolic) link called targetpath. If it cannot be created + (platform limitation), we try to make a copy of the referenced file + instead of a link. + """ + try: + # For systems that support symbolic and hard links. + if tarinfo.issym(): + if os.path.lexists(targetpath): + # Avoid FileExistsError on following os.symlink. + os.unlink(targetpath) + os.symlink(tarinfo.linkname, targetpath) + else: + if os.path.exists(tarinfo._link_target): + os.link(tarinfo._link_target, targetpath) + else: + self._extract_member(self._find_link_target(tarinfo), + targetpath) + except symlink_exception: + try: + self._extract_member(self._find_link_target(tarinfo), + targetpath) + except KeyError: + raise ExtractError("unable to resolve link inside archive") from None + + def chown(self, tarinfo, targetpath, numeric_owner): + """Set owner of targetpath according to tarinfo. If numeric_owner + is True, use .gid/.uid instead of .gname/.uname. If numeric_owner + is False, fall back to .gid/.uid when the search based on name + fails. + """ + if hasattr(os, "geteuid") and os.geteuid() == 0: + # We have to be root to do so. + g = tarinfo.gid + u = tarinfo.uid + if not numeric_owner: + try: + if grp and tarinfo.gname: + g = grp.getgrnam(tarinfo.gname)[2] + except KeyError: + pass + try: + if pwd and tarinfo.uname: + u = pwd.getpwnam(tarinfo.uname)[2] + except KeyError: + pass + if g is None: + g = -1 + if u is None: + u = -1 + try: + if tarinfo.issym() and hasattr(os, "lchown"): + os.lchown(targetpath, u, g) + else: + os.chown(targetpath, u, g) + except (OSError, OverflowError) as e: + # OverflowError can be raised if an ID doesn't fit in 'id_t' + raise ExtractError("could not change owner") from e + + def chmod(self, tarinfo, targetpath): + """Set file permissions of targetpath according to tarinfo. + """ + if tarinfo.mode is None: + return + try: + os.chmod(targetpath, tarinfo.mode) + except OSError as e: + raise ExtractError("could not change mode") from e + + def utime(self, tarinfo, targetpath): + """Set modification time of targetpath according to tarinfo. + """ + mtime = tarinfo.mtime + if mtime is None: + return + if not hasattr(os, 'utime'): + return + try: + os.utime(targetpath, (mtime, mtime)) + except OSError as e: + raise ExtractError("could not change modification time") from e + + #-------------------------------------------------------------------------- + def next(self): + """Return the next member of the archive as a TarInfo object, when + TarFile is opened for reading. Return None if there is no more + available. + """ + self._check("ra") + if self.firstmember is not None: + m = self.firstmember + self.firstmember = None + return m + + # Advance the file pointer. + if self.offset != self.fileobj.tell(): + if self.offset == 0: + return None + self.fileobj.seek(self.offset - 1) + if not self.fileobj.read(1): + raise ReadError("unexpected end of data") + + # Read the next block. + tarinfo = None + while True: + try: + tarinfo = self.tarinfo.fromtarfile(self) + except EOFHeaderError as e: + if self.ignore_zeros: + self._dbg(2, "0x%X: %s" % (self.offset, e)) + self.offset += BLOCKSIZE + continue + except InvalidHeaderError as e: + if self.ignore_zeros: + self._dbg(2, "0x%X: %s" % (self.offset, e)) + self.offset += BLOCKSIZE + continue + elif self.offset == 0: + raise ReadError(str(e)) from None + except EmptyHeaderError: + if self.offset == 0: + raise ReadError("empty file") from None + except TruncatedHeaderError as e: + if self.offset == 0: + raise ReadError(str(e)) from None + except SubsequentHeaderError as e: + raise ReadError(str(e)) from None + except Exception as e: + try: + import zlib + if isinstance(e, zlib.error): + raise ReadError(f'zlib error: {e}') from None + else: + raise e + except ImportError: + raise e + break + + if tarinfo is not None: + # if streaming the file we do not want to cache the tarinfo + if not self.stream: + self.members.append(tarinfo) + else: + self._loaded = True + + return tarinfo + + #-------------------------------------------------------------------------- + # Little helper methods: + + def _getmember(self, name, tarinfo=None, normalize=False): + """Find an archive member by name from bottom to top. + If tarinfo is given, it is used as the starting point. + """ + # Ensure that all members have been loaded. + members = self.getmembers() + + # Limit the member search list up to tarinfo. + skipping = False + if tarinfo is not None: + try: + index = members.index(tarinfo) + except ValueError: + # The given starting point might be a (modified) copy. + # We'll later skip members until we find an equivalent. + skipping = True + else: + # Happy fast path + members = members[:index] + + if normalize: + name = os.path.normpath(name) + + for member in reversed(members): + if skipping: + if tarinfo.offset == member.offset: + skipping = False + continue + if normalize: + member_name = os.path.normpath(member.name) + else: + member_name = member.name + + if name == member_name: + return member + + if skipping: + # Starting point was not found + raise ValueError(tarinfo) + + def _load(self): + """Read through the entire archive file and look for readable + members. This should not run if the file is set to stream. + """ + if not self.stream: + while self.next() is not None: + pass + self._loaded = True + + def _check(self, mode=None): + """Check if TarFile is still open, and if the operation's mode + corresponds to TarFile's mode. + """ + if self.closed: + raise OSError("%s is closed" % self.__class__.__name__) + if mode is not None and self.mode not in mode: + raise OSError("bad operation for mode %r" % self.mode) + + def _find_link_target(self, tarinfo): + """Find the target member of a symlink or hardlink member in the + archive. + """ + if tarinfo.issym(): + # Always search the entire archive. + linkname = "/".join(filter(None, (os.path.dirname(tarinfo.name), tarinfo.linkname))) + limit = None + else: + # Search the archive before the link, because a hard link is + # just a reference to an already archived file. + linkname = tarinfo.linkname + limit = tarinfo + + member = self._getmember(linkname, tarinfo=limit, normalize=True) + if member is None: + raise KeyError("linkname %r not found" % linkname) + return member + + def __iter__(self): + """Provide an iterator object. + """ + if self._loaded: + yield from self.members + return + + # Yield items using TarFile's next() method. + # When all members have been read, set TarFile as _loaded. + index = 0 + # Fix for SF #1100429: Under rare circumstances it can + # happen that getmembers() is called during iteration, + # which will have already exhausted the next() method. + if self.firstmember is not None: + tarinfo = self.next() + index += 1 + yield tarinfo + + while True: + if index < len(self.members): + tarinfo = self.members[index] + elif not self._loaded: + tarinfo = self.next() + if not tarinfo: + self._loaded = True + return + else: + return + index += 1 + yield tarinfo + + def _dbg(self, level, msg): + """Write debugging output to sys.stderr. + """ + if level <= self.debug: + print(msg, file=sys.stderr) + + def __enter__(self): + self._check() + return self + + def __exit__(self, type, value, traceback): + if type is None: + self.close() + else: + # An exception occurred. We must not call close() because + # it would try to write end-of-archive blocks and padding. + if not self._extfileobj: + self.fileobj.close() + self.closed = True + +#-------------------- +# exported functions +#-------------------- + +def is_tarfile(name): + """Return True if name points to a tar archive that we + are able to handle, else return False. + + 'name' should be a string, file, or file-like object. + """ + try: + if hasattr(name, "read"): + pos = name.tell() + t = open(fileobj=name) + name.seek(pos) + else: + t = open(name) + t.close() + return True + except TarError: + return False + +open = TarFile.open + + +def main(): + import argparse + + description = 'A simple command-line interface for tarfile module.' + parser = argparse.ArgumentParser(description=description) + parser.add_argument('-v', '--verbose', action='store_true', default=False, + help='Verbose output') + parser.add_argument('--filter', metavar='', + choices=_NAMED_FILTERS, + help='Filter for extraction') + + group = parser.add_mutually_exclusive_group(required=True) + group.add_argument('-l', '--list', metavar='', + help='Show listing of a tarfile') + group.add_argument('-e', '--extract', nargs='+', + metavar=('', ''), + help='Extract tarfile into target dir') + group.add_argument('-c', '--create', nargs='+', + metavar=('', ''), + help='Create tarfile from sources') + group.add_argument('-t', '--test', metavar='', + help='Test if a tarfile is valid') + + args = parser.parse_args() + + if args.filter and args.extract is None: + parser.exit(1, '--filter is only valid for extraction\n') + + if args.test is not None: + src = args.test + if is_tarfile(src): + with open(src, 'r') as tar: + tar.getmembers() + print(tar.getmembers(), file=sys.stderr) + if args.verbose: + print('{!r} is a tar archive.'.format(src)) + else: + parser.exit(1, '{!r} is not a tar archive.\n'.format(src)) + + elif args.list is not None: + src = args.list + if is_tarfile(src): + with TarFile.open(src, 'r:*') as tf: + tf.list(verbose=args.verbose) + else: + parser.exit(1, '{!r} is not a tar archive.\n'.format(src)) + + elif args.extract is not None: + if len(args.extract) == 1: + src = args.extract[0] + curdir = os.curdir + elif len(args.extract) == 2: + src, curdir = args.extract + else: + parser.exit(1, parser.format_help()) + + if is_tarfile(src): + with TarFile.open(src, 'r:*') as tf: + tf.extractall(path=curdir, filter=args.filter) + if args.verbose: + if curdir == '.': + msg = '{!r} file is extracted.'.format(src) + else: + msg = ('{!r} file is extracted ' + 'into {!r} directory.').format(src, curdir) + print(msg) + else: + parser.exit(1, '{!r} is not a tar archive.\n'.format(src)) + + elif args.create is not None: + tar_name = args.create.pop(0) + _, ext = os.path.splitext(tar_name) + compressions = { + # gz + '.gz': 'gz', + '.tgz': 'gz', + # xz + '.xz': 'xz', + '.txz': 'xz', + # bz2 + '.bz2': 'bz2', + '.tbz': 'bz2', + '.tbz2': 'bz2', + '.tb2': 'bz2', + } + tar_mode = 'w:' + compressions[ext] if ext in compressions else 'w' + tar_files = args.create + + with TarFile.open(tar_name, tar_mode) as tf: + for file_name in tar_files: + tf.add(file_name) + + if args.verbose: + print('{!r} file created.'.format(tar_name)) + +if __name__ == '__main__': + main() diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports/tarfile/__main__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports/tarfile/__main__.py new file mode 100644 index 0000000000000000000000000000000000000000..daf55090862ae43283b6552073549ac3ab2ad50a --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports/tarfile/__main__.py @@ -0,0 +1,5 @@ +from . import main + + +if __name__ == '__main__': + main() diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports/tarfile/__pycache__/__main__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports/tarfile/__pycache__/__main__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9e419ed335895289b58c3dd2c9ba690720840893 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports/tarfile/__pycache__/__main__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports/tarfile/compat/__init__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports/tarfile/compat/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports/tarfile/compat/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports/tarfile/compat/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1ba724fa1ba99d959e82ba2407d902d1bae671e5 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports/tarfile/compat/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports/tarfile/compat/__pycache__/py38.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports/tarfile/compat/__pycache__/py38.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ac220a1afeca40a568731efa15a8f3356da26cda Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports/tarfile/compat/__pycache__/py38.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports/tarfile/compat/py38.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports/tarfile/compat/py38.py new file mode 100644 index 0000000000000000000000000000000000000000..20fbbfc1c095baf9f8c72902b24296b50ad3ab9d --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/backports/tarfile/compat/py38.py @@ -0,0 +1,24 @@ +import sys + + +if sys.version_info < (3, 9): + + def removesuffix(self, suffix): + # suffix='' should not call self[:-0]. + if suffix and self.endswith(suffix): + return self[: -len(suffix)] + else: + return self[:] + + def removeprefix(self, prefix): + if self.startswith(prefix): + return self[len(prefix) :] + else: + return self[:] +else: + + def removesuffix(self, suffix): + return self.removesuffix(suffix) + + def removeprefix(self, prefix): + return self.removeprefix(prefix) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata-8.7.1.dist-info/INSTALLER b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata-8.7.1.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..5c69047b2eb8235994febeeae1da4a82365a240a --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata-8.7.1.dist-info/INSTALLER @@ -0,0 +1 @@ +uv \ No newline at end of file diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata-8.7.1.dist-info/METADATA b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata-8.7.1.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..9d894b433dc0e27e53d3be160edb861358db99fd --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata-8.7.1.dist-info/METADATA @@ -0,0 +1,133 @@ +Metadata-Version: 2.4 +Name: importlib_metadata +Version: 8.7.1 +Summary: Read metadata from Python packages +Author-email: "Jason R. Coombs" +License-Expression: Apache-2.0 +Project-URL: Source, https://github.com/python/importlib_metadata +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3 :: Only +Requires-Python: >=3.9 +Description-Content-Type: text/x-rst +License-File: LICENSE +Requires-Dist: zipp>=3.20 +Provides-Extra: test +Requires-Dist: pytest!=8.1.*,>=6; extra == "test" +Requires-Dist: packaging; extra == "test" +Requires-Dist: pyfakefs; extra == "test" +Requires-Dist: flufl.flake8; extra == "test" +Requires-Dist: pytest-perf>=0.9.2; extra == "test" +Requires-Dist: jaraco.test>=5.4; extra == "test" +Provides-Extra: doc +Requires-Dist: sphinx>=3.5; extra == "doc" +Requires-Dist: jaraco.packaging>=9.3; extra == "doc" +Requires-Dist: rst.linker>=1.9; extra == "doc" +Requires-Dist: furo; extra == "doc" +Requires-Dist: sphinx-lint; extra == "doc" +Requires-Dist: jaraco.tidelift>=1.4; extra == "doc" +Provides-Extra: perf +Requires-Dist: ipython; extra == "perf" +Provides-Extra: check +Requires-Dist: pytest-checkdocs>=2.4; extra == "check" +Requires-Dist: pytest-ruff>=0.2.1; sys_platform != "cygwin" and extra == "check" +Provides-Extra: cover +Requires-Dist: pytest-cov; extra == "cover" +Provides-Extra: enabler +Requires-Dist: pytest-enabler>=3.4; extra == "enabler" +Provides-Extra: type +Requires-Dist: pytest-mypy>=1.0.1; extra == "type" +Requires-Dist: mypy<1.19; platform_python_implementation == "PyPy" and extra == "type" +Dynamic: license-file + +.. image:: https://img.shields.io/pypi/v/importlib_metadata.svg + :target: https://pypi.org/project/importlib_metadata + +.. image:: https://img.shields.io/pypi/pyversions/importlib_metadata.svg + +.. image:: https://github.com/python/importlib_metadata/actions/workflows/main.yml/badge.svg + :target: https://github.com/python/importlib_metadata/actions?query=workflow%3A%22tests%22 + :alt: tests + +.. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json + :target: https://github.com/astral-sh/ruff + :alt: Ruff + +.. image:: https://readthedocs.org/projects/importlib-metadata/badge/?version=latest + :target: https://importlib-metadata.readthedocs.io/en/latest/?badge=latest + +.. image:: https://img.shields.io/badge/skeleton-2025-informational + :target: https://blog.jaraco.com/skeleton + +.. image:: https://tidelift.com/badges/package/pypi/importlib-metadata + :target: https://tidelift.com/subscription/pkg/pypi-importlib-metadata?utm_source=pypi-importlib-metadata&utm_medium=readme + +Library to access the metadata for a Python package. + +This package supplies third-party access to the functionality of +`importlib.metadata `_ +including improvements added to subsequent Python versions. + + +Compatibility +============= + +New features are introduced in this third-party library and later merged +into CPython. The following table indicates which versions of this library +were contributed to different versions in the standard library: + +.. list-table:: + :header-rows: 1 + + * - importlib_metadata + - stdlib + * - 7.0 + - 3.13 + * - 6.5 + - 3.12 + * - 4.13 + - 3.11 + * - 4.6 + - 3.10 + * - 1.4 + - 3.8 + + +Usage +===== + +See the `online documentation `_ +for usage details. + +`Finder authors +`_ can +also add support for custom package installers. See the above documentation +for details. + + +Caveats +======= + +This project primarily supports third-party packages installed by PyPA +tools (or other conforming packages). It does not support: + +- Packages in the stdlib. +- Packages installed without metadata. + +Project details +=============== + + * Project home: https://github.com/python/importlib_metadata + * Report bugs at: https://github.com/python/importlib_metadata/issues + * Code hosting: https://github.com/python/importlib_metadata + * Documentation: https://importlib-metadata.readthedocs.io/ + +For Enterprise +============== + +Available as part of the Tidelift Subscription. + +This project and the maintainers of thousands of other packages are working with Tidelift to deliver one enterprise subscription that covers all of the open source you use. + +`Learn more `_. diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata-8.7.1.dist-info/RECORD b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata-8.7.1.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..78aa761cab1c52d856213f18e2785001bdb02904 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata-8.7.1.dist-info/RECORD @@ -0,0 +1,21 @@ +importlib_metadata-8.7.1.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2 +importlib_metadata-8.7.1.dist-info/METADATA,sha256=o-OLnuQyYonUhkcE8w4pnudp4jCc6fSnXw3hpQrQo1Y,4670 +importlib_metadata-8.7.1.dist-info/RECORD,, +importlib_metadata-8.7.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +importlib_metadata-8.7.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91 +importlib_metadata-8.7.1.dist-info/licenses/LICENSE,sha256=RYUC4S2Xu_ZEOGBqIARKqF6wX7CoqAe7NdvsJT_R_AQ,10278 +importlib_metadata-8.7.1.dist-info/top_level.txt,sha256=CO3fD9yylANiXkrMo4qHLV_mqXL2sC5JFKgt1yWAT-A,19 +importlib_metadata/__init__.py,sha256=u7Ew4-UkpzNY-ka6k-WRkDhQZS1akkLMfWs2eEnUmGo,37734 +importlib_metadata/_adapters.py,sha256=r5i8XLrKT6xmrpoREZhZrfczOYDmrVZeJBW5u0HzIGU,3797 +importlib_metadata/_collections.py,sha256=CxAhzlF3g1rwu_fMiB53JtRQiUFh0RgiMpoOvmK_ocg,760 +importlib_metadata/_compat.py,sha256=VC5ZDLlT-BcshauCShdFJvMNLntJJfZzNK1meGa-enw,1313 +importlib_metadata/_functools.py,sha256=0pA2OoiVK6wnsGq8HvVIzgdkvLiZ0nfnfw7IsndjoHk,3510 +importlib_metadata/_itertools.py,sha256=nMvp9SfHAQ_JYwK4L2i64lr3GRXGlYlikGTVzWbys_E,5351 +importlib_metadata/_meta.py,sha256=EtHyiJ5kGzWFDfKyQ2XQp6Vu113CeadKW1Vf6aGc1B4,1765 +importlib_metadata/_text.py,sha256=HCsFksZpJLeTP3NEk_ngrAeXVRRtTrtyh9eOABoRP4A,2166 +importlib_metadata/_typing.py,sha256=EQKhhsEgz_Sa-FnePI-faC72rNOOQwopjA1i5pG8FDU,367 +importlib_metadata/compat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +importlib_metadata/compat/py311.py,sha256=uqm-K-uohyj1042TH4a9Er_I5o7667DvulcD-gC_fSA,608 +importlib_metadata/compat/py39.py,sha256=J3W7PUVRPNYMmcvT12RF8ndBU9e8_T0Ac4U87Bsrq70,1187 +importlib_metadata/diagnose.py,sha256=nkSRMiowlmkhLYhKhvCg9glmt_11Cox-EmLzEbqYTa8,379 +importlib_metadata/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata-8.7.1.dist-info/REQUESTED b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata-8.7.1.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata-8.7.1.dist-info/WHEEL b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata-8.7.1.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..e7fa31b6f3f78deb1022c1f7927f07d4d16da822 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata-8.7.1.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: setuptools (80.9.0) +Root-Is-Purelib: true +Tag: py3-none-any + diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata-8.7.1.dist-info/licenses/LICENSE b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata-8.7.1.dist-info/licenses/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..5c1d8bbc02a6624cf8e957c40e6f761c1575d180 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata-8.7.1.dist-info/licenses/LICENSE @@ -0,0 +1,73 @@ +Apache License +Version 2.0, January 2004 +http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + +"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. + +"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. + +"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. + +"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. + +"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. + +"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. + +"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). + +"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. + +"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." + +"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: + + (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. + + You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS + +APPENDIX: How to apply the Apache License to your work. + +To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. + +Copyright 2025 [name of copyright owner] + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata-8.7.1.dist-info/top_level.txt b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata-8.7.1.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..bbb07547a19c30031d13c45cf01cba61dc434e47 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata-8.7.1.dist-info/top_level.txt @@ -0,0 +1 @@ +importlib_metadata diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/__init__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..508b02e4fce3fa9463b7466138cca7414db0e9b9 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/__init__.py @@ -0,0 +1,1191 @@ +""" +APIs exposing metadata from third-party Python packages. + +This codebase is shared between importlib.metadata in the stdlib +and importlib_metadata in PyPI. See +https://github.com/python/importlib_metadata/wiki/Development-Methodology +for more detail. +""" + +from __future__ import annotations + +import abc +import collections +import email +import functools +import itertools +import operator +import os +import pathlib +import posixpath +import re +import sys +import textwrap +import types +from collections.abc import Iterable, Mapping +from contextlib import suppress +from importlib import import_module +from importlib.abc import MetaPathFinder +from itertools import starmap +from typing import Any + +from . import _meta +from ._collections import FreezableDefaultDict, Pair +from ._compat import ( + NullFinder, + install, +) +from ._functools import method_cache, noop, pass_none, passthrough +from ._itertools import always_iterable, bucket, unique_everseen +from ._meta import PackageMetadata, SimplePath +from ._typing import md_none +from .compat import py39, py311 + +__all__ = [ + 'Distribution', + 'DistributionFinder', + 'PackageMetadata', + 'PackageNotFoundError', + 'SimplePath', + 'distribution', + 'distributions', + 'entry_points', + 'files', + 'metadata', + 'packages_distributions', + 'requires', + 'version', +] + + +class PackageNotFoundError(ModuleNotFoundError): + """The package was not found.""" + + def __str__(self) -> str: + return f"No package metadata was found for {self.name}" + + @property + def name(self) -> str: # type: ignore[override] # make readonly + (name,) = self.args + return name + + +class Sectioned: + """ + A simple entry point config parser for performance + + >>> for item in Sectioned.read(Sectioned._sample): + ... print(item) + Pair(name='sec1', value='# comments ignored') + Pair(name='sec1', value='a = 1') + Pair(name='sec1', value='b = 2') + Pair(name='sec2', value='a = 2') + + >>> res = Sectioned.section_pairs(Sectioned._sample) + >>> item = next(res) + >>> item.name + 'sec1' + >>> item.value + Pair(name='a', value='1') + >>> item = next(res) + >>> item.value + Pair(name='b', value='2') + >>> item = next(res) + >>> item.name + 'sec2' + >>> item.value + Pair(name='a', value='2') + >>> list(res) + [] + """ + + _sample = textwrap.dedent( + """ + [sec1] + # comments ignored + a = 1 + b = 2 + + [sec2] + a = 2 + """ + ).lstrip() + + @classmethod + def section_pairs(cls, text): + return ( + section._replace(value=Pair.parse(section.value)) + for section in cls.read(text, filter_=cls.valid) + if section.name is not None + ) + + @staticmethod + def read(text, filter_=None): + lines = filter(filter_, map(str.strip, text.splitlines())) + name = None + for value in lines: + section_match = value.startswith('[') and value.endswith(']') + if section_match: + name = value.strip('[]') + continue + yield Pair(name, value) + + @staticmethod + def valid(line: str): + return line and not line.startswith('#') + + +class _EntryPointMatch(types.SimpleNamespace): + module: str + attr: str + extras: str + + +class EntryPoint: + """An entry point as defined by Python packaging conventions. + + See `the packaging docs on entry points + `_ + for more information. + + >>> ep = EntryPoint( + ... name=None, group=None, value='package.module:attr [extra1, extra2]') + >>> ep.module + 'package.module' + >>> ep.attr + 'attr' + >>> ep.extras + ['extra1', 'extra2'] + + If the value package or module are not valid identifiers, a + ValueError is raised on access. + + >>> EntryPoint(name=None, group=None, value='invalid-name').module + Traceback (most recent call last): + ... + ValueError: ('Invalid object reference...invalid-name... + >>> EntryPoint(name=None, group=None, value='invalid-name').attr + Traceback (most recent call last): + ... + ValueError: ('Invalid object reference...invalid-name... + >>> EntryPoint(name=None, group=None, value='invalid-name').extras + Traceback (most recent call last): + ... + ValueError: ('Invalid object reference...invalid-name... + + The same thing happens on construction. + + >>> EntryPoint(name=None, group=None, value='invalid-name') + Traceback (most recent call last): + ... + ValueError: ('Invalid object reference...invalid-name... + + """ + + pattern = re.compile( + r'(?P[\w.]+)\s*' + r'(:\s*(?P[\w.]+)\s*)?' + r'((?P\[.*\])\s*)?$' + ) + """ + A regular expression describing the syntax for an entry point, + which might look like: + + - module + - package.module + - package.module:attribute + - package.module:object.attribute + - package.module:attr [extra1, extra2] + + Other combinations are possible as well. + + The expression is lenient about whitespace around the ':', + following the attr, and following any extras. + """ + + name: str + value: str + group: str + + dist: Distribution | None = None + + def __init__(self, name: str, value: str, group: str) -> None: + vars(self).update(name=name, value=value, group=group) + self.module + + def load(self) -> Any: + """Load the entry point from its definition. If only a module + is indicated by the value, return that module. Otherwise, + return the named object. + """ + module = import_module(self.module) + attrs = filter(None, (self.attr or '').split('.')) + return functools.reduce(getattr, attrs, module) + + @property + def module(self) -> str: + return self._match.module + + @property + def attr(self) -> str: + return self._match.attr + + @property + def extras(self) -> list[str]: + return re.findall(r'\w+', self._match.extras or '') + + @functools.cached_property + def _match(self) -> _EntryPointMatch: + match = self.pattern.match(self.value) + if not match: + raise ValueError( + 'Invalid object reference. ' + 'See https://packaging.python.org' + '/en/latest/specifications/entry-points/#data-model', + self.value, + ) + return _EntryPointMatch(**match.groupdict()) + + def _for(self, dist): + vars(self).update(dist=dist) + return self + + def matches(self, **params): + """ + EntryPoint matches the given parameters. + + >>> ep = EntryPoint(group='foo', name='bar', value='bing:bong [extra1, extra2]') + >>> ep.matches(group='foo') + True + >>> ep.matches(name='bar', value='bing:bong [extra1, extra2]') + True + >>> ep.matches(group='foo', name='other') + False + >>> ep.matches() + True + >>> ep.matches(extras=['extra1', 'extra2']) + True + >>> ep.matches(module='bing') + True + >>> ep.matches(attr='bong') + True + """ + self._disallow_dist(params) + attrs = (getattr(self, param) for param in params) + return all(map(operator.eq, params.values(), attrs)) + + @staticmethod + def _disallow_dist(params): + """ + Querying by dist is not allowed (dist objects are not comparable). + >>> EntryPoint(name='fan', value='fav', group='fag').matches(dist='foo') + Traceback (most recent call last): + ... + ValueError: "dist" is not suitable for matching... + """ + if "dist" in params: + raise ValueError( + '"dist" is not suitable for matching. ' + "Instead, use Distribution.entry_points.select() on a " + "located distribution." + ) + + def _key(self): + return self.name, self.value, self.group + + def __lt__(self, other): + return self._key() < other._key() + + def __eq__(self, other): + return self._key() == other._key() + + def __setattr__(self, name, value): + raise AttributeError("EntryPoint objects are immutable.") + + def __repr__(self): + return ( + f'EntryPoint(name={self.name!r}, value={self.value!r}, ' + f'group={self.group!r})' + ) + + def __hash__(self) -> int: + return hash(self._key()) + + +class EntryPoints(tuple): + """ + An immutable collection of selectable EntryPoint objects. + """ + + __slots__ = () + + def __getitem__(self, name: str) -> EntryPoint: # type: ignore[override] # Work with str instead of int + """ + Get the EntryPoint in self matching name. + """ + try: + return next(iter(self.select(name=name))) + except StopIteration: + raise KeyError(name) + + def __repr__(self): + """ + Repr with classname and tuple constructor to + signal that we deviate from regular tuple behavior. + """ + return '%s(%r)' % (self.__class__.__name__, tuple(self)) + + def select(self, **params) -> EntryPoints: + """ + Select entry points from self that match the + given parameters (typically group and/or name). + """ + return EntryPoints(ep for ep in self if py39.ep_matches(ep, **params)) + + @property + def names(self) -> set[str]: + """ + Return the set of all names of all entry points. + """ + return {ep.name for ep in self} + + @property + def groups(self) -> set[str]: + """ + Return the set of all groups of all entry points. + """ + return {ep.group for ep in self} + + @classmethod + def _from_text_for(cls, text, dist): + return cls(ep._for(dist) for ep in cls._from_text(text)) + + @staticmethod + def _from_text(text): + return ( + EntryPoint(name=item.value.name, value=item.value.value, group=item.name) + for item in Sectioned.section_pairs(text or '') + ) + + +class PackagePath(pathlib.PurePosixPath): + """A reference to a path in a package""" + + hash: FileHash | None + size: int + dist: Distribution + + def read_text(self, encoding: str = 'utf-8') -> str: + return self.locate().read_text(encoding=encoding) + + def read_binary(self) -> bytes: + return self.locate().read_bytes() + + def locate(self) -> SimplePath: + """Return a path-like object for this path""" + return self.dist.locate_file(self) + + +class FileHash: + def __init__(self, spec: str) -> None: + self.mode, _, self.value = spec.partition('=') + + def __repr__(self) -> str: + return f'' + + +class Distribution(metaclass=abc.ABCMeta): + """ + An abstract Python distribution package. + + Custom providers may derive from this class and define + the abstract methods to provide a concrete implementation + for their environment. Some providers may opt to override + the default implementation of some properties to bypass + the file-reading mechanism. + """ + + @abc.abstractmethod + def read_text(self, filename) -> str | None: + """Attempt to load metadata file given by the name. + + Python distribution metadata is organized by blobs of text + typically represented as "files" in the metadata directory + (e.g. package-1.0.dist-info). These files include things + like: + + - METADATA: The distribution metadata including fields + like Name and Version and Description. + - entry_points.txt: A series of entry points as defined in + `the entry points spec `_. + - RECORD: A record of files according to + `this recording spec `_. + + A package may provide any set of files, including those + not listed here or none at all. + + :param filename: The name of the file in the distribution info. + :return: The text if found, otherwise None. + """ + + @abc.abstractmethod + def locate_file(self, path: str | os.PathLike[str]) -> SimplePath: + """ + Given a path to a file in this distribution, return a SimplePath + to it. + + This method is used by callers of ``Distribution.files()`` to + locate files within the distribution. If it's possible for a + Distribution to represent files in the distribution as + ``SimplePath`` objects, it should implement this method + to resolve such objects. + + Some Distribution providers may elect not to resolve SimplePath + objects within the distribution by raising a + NotImplementedError, but consumers of such a Distribution would + be unable to invoke ``Distribution.files()``. + """ + + @classmethod + def from_name(cls, name: str) -> Distribution: + """Return the Distribution for the given package name. + + :param name: The name of the distribution package to search for. + :return: The Distribution instance (or subclass thereof) for the named + package, if found. + :raises PackageNotFoundError: When the named package's distribution + metadata cannot be found. + :raises ValueError: When an invalid value is supplied for name. + """ + if not name: + raise ValueError("A distribution name is required.") + try: + return next(iter(cls._prefer_valid(cls.discover(name=name)))) + except StopIteration: + raise PackageNotFoundError(name) + + @classmethod + def discover( + cls, *, context: DistributionFinder.Context | None = None, **kwargs + ) -> Iterable[Distribution]: + """Return an iterable of Distribution objects for all packages. + + Pass a ``context`` or pass keyword arguments for constructing + a context. + + :context: A ``DistributionFinder.Context`` object. + :return: Iterable of Distribution objects for packages matching + the context. + """ + if context and kwargs: + raise ValueError("cannot accept context and kwargs") + context = context or DistributionFinder.Context(**kwargs) + return itertools.chain.from_iterable( + resolver(context) for resolver in cls._discover_resolvers() + ) + + @staticmethod + def _prefer_valid(dists: Iterable[Distribution]) -> Iterable[Distribution]: + """ + Prefer (move to the front) distributions that have metadata. + + Ref python/importlib_resources#489. + """ + buckets = bucket(dists, lambda dist: bool(dist.metadata)) + return itertools.chain(buckets[True], buckets[False]) + + @staticmethod + def at(path: str | os.PathLike[str]) -> Distribution: + """Return a Distribution for the indicated metadata path. + + :param path: a string or path-like object + :return: a concrete Distribution instance for the path + """ + return PathDistribution(pathlib.Path(path)) + + @staticmethod + def _discover_resolvers(): + """Search the meta_path for resolvers (MetadataPathFinders).""" + declared = ( + getattr(finder, 'find_distributions', None) for finder in sys.meta_path + ) + return filter(None, declared) + + @property + def metadata(self) -> _meta.PackageMetadata | None: + """Return the parsed metadata for this Distribution. + + The returned object will have keys that name the various bits of + metadata per the + `Core metadata specifications `_. + + Custom providers may provide the METADATA file or override this + property. + """ + + text = ( + self.read_text('METADATA') + or self.read_text('PKG-INFO') + # This last clause is here to support old egg-info files. Its + # effect is to just end up using the PathDistribution's self._path + # (which points to the egg-info file) attribute unchanged. + or self.read_text('') + ) + return self._assemble_message(text) + + @staticmethod + @pass_none + def _assemble_message(text: str) -> _meta.PackageMetadata: + # deferred for performance (python/cpython#109829) + from . import _adapters + + return _adapters.Message(email.message_from_string(text)) + + @property + def name(self) -> str: + """Return the 'Name' metadata for the distribution package.""" + return md_none(self.metadata)['Name'] + + @property + def _normalized_name(self): + """Return a normalized version of the name.""" + return Prepared.normalize(self.name) + + @property + def version(self) -> str: + """Return the 'Version' metadata for the distribution package.""" + return md_none(self.metadata)['Version'] + + @property + def entry_points(self) -> EntryPoints: + """ + Return EntryPoints for this distribution. + + Custom providers may provide the ``entry_points.txt`` file + or override this property. + """ + return EntryPoints._from_text_for(self.read_text('entry_points.txt'), self) + + @property + def files(self) -> list[PackagePath] | None: + """Files in this distribution. + + :return: List of PackagePath for this distribution or None + + Result is `None` if the metadata file that enumerates files + (i.e. RECORD for dist-info, or installed-files.txt or + SOURCES.txt for egg-info) is missing. + Result may be empty if the metadata exists but is empty. + + Custom providers are recommended to provide a "RECORD" file (in + ``read_text``) or override this property to allow for callers to be + able to resolve filenames provided by the package. + """ + + def make_file(name, hash=None, size_str=None): + result = PackagePath(name) + result.hash = FileHash(hash) if hash else None + result.size = int(size_str) if size_str else None + result.dist = self + return result + + @pass_none + def make_files(lines): + # Delay csv import, since Distribution.files is not as widely used + # as other parts of importlib.metadata + import csv + + return starmap(make_file, csv.reader(lines)) + + @pass_none + def skip_missing_files(package_paths): + return list(filter(lambda path: path.locate().exists(), package_paths)) + + return skip_missing_files( + make_files( + self._read_files_distinfo() + or self._read_files_egginfo_installed() + or self._read_files_egginfo_sources() + ) + ) + + def _read_files_distinfo(self): + """ + Read the lines of RECORD. + """ + text = self.read_text('RECORD') + return text and text.splitlines() + + def _read_files_egginfo_installed(self): + """ + Read installed-files.txt and return lines in a similar + CSV-parsable format as RECORD: each file must be placed + relative to the site-packages directory and must also be + quoted (since file names can contain literal commas). + + This file is written when the package is installed by pip, + but it might not be written for other installation methods. + Assume the file is accurate if it exists. + """ + text = self.read_text('installed-files.txt') + # Prepend the .egg-info/ subdir to the lines in this file. + # But this subdir is only available from PathDistribution's + # self._path. + subdir = getattr(self, '_path', None) + if not text or not subdir: + return + + paths = ( + py311 + .relative_fix((subdir / name).resolve()) + .relative_to(self.locate_file('').resolve(), walk_up=True) + .as_posix() + for name in text.splitlines() + ) + return map('"{}"'.format, paths) + + def _read_files_egginfo_sources(self): + """ + Read SOURCES.txt and return lines in a similar CSV-parsable + format as RECORD: each file name must be quoted (since it + might contain literal commas). + + Note that SOURCES.txt is not a reliable source for what + files are installed by a package. This file is generated + for a source archive, and the files that are present + there (e.g. setup.py) may not correctly reflect the files + that are present after the package has been installed. + """ + text = self.read_text('SOURCES.txt') + return text and map('"{}"'.format, text.splitlines()) + + @property + def requires(self) -> list[str] | None: + """Generated requirements specified for this Distribution""" + reqs = self._read_dist_info_reqs() or self._read_egg_info_reqs() + return reqs and list(reqs) + + def _read_dist_info_reqs(self): + return self.metadata.get_all('Requires-Dist') + + def _read_egg_info_reqs(self): + source = self.read_text('requires.txt') + return pass_none(self._deps_from_requires_text)(source) + + @classmethod + def _deps_from_requires_text(cls, source): + return cls._convert_egg_info_reqs_to_simple_reqs(Sectioned.read(source)) + + @staticmethod + def _convert_egg_info_reqs_to_simple_reqs(sections): + """ + Historically, setuptools would solicit and store 'extra' + requirements, including those with environment markers, + in separate sections. More modern tools expect each + dependency to be defined separately, with any relevant + extras and environment markers attached directly to that + requirement. This method converts the former to the + latter. See _test_deps_from_requires_text for an example. + """ + + def make_condition(name): + return name and f'extra == "{name}"' + + def quoted_marker(section): + section = section or '' + extra, sep, markers = section.partition(':') + if extra and markers: + markers = f'({markers})' + conditions = list(filter(None, [markers, make_condition(extra)])) + return '; ' + ' and '.join(conditions) if conditions else '' + + def url_req_space(req): + """ + PEP 508 requires a space between the url_spec and the quoted_marker. + Ref python/importlib_metadata#357. + """ + # '@' is uniquely indicative of a url_req. + return ' ' * ('@' in req) + + for section in sections: + space = url_req_space(section.value) + yield section.value + space + quoted_marker(section.name) + + @property + def origin(self): + return self._load_json('direct_url.json') + + def _load_json(self, filename): + # Deferred for performance (python/importlib_metadata#503) + import json + + return pass_none(json.loads)( + self.read_text(filename), + object_hook=lambda data: types.SimpleNamespace(**data), + ) + + +class DistributionFinder(MetaPathFinder): + """ + A MetaPathFinder capable of discovering installed distributions. + + Custom providers should implement this interface in order to + supply metadata. + """ + + class Context: + """ + Keyword arguments presented by the caller to + ``distributions()`` or ``Distribution.discover()`` + to narrow the scope of a search for distributions + in all DistributionFinders. + + Each DistributionFinder may expect any parameters + and should attempt to honor the canonical + parameters defined below when appropriate. + + This mechanism gives a custom provider a means to + solicit additional details from the caller beyond + "name" and "path" when searching distributions. + For example, imagine a provider that exposes suites + of packages in either a "public" or "private" ``realm``. + A caller may wish to query only for distributions in + a particular realm and could call + ``distributions(realm="private")`` to signal to the + custom provider to only include distributions from that + realm. + """ + + name = None + """ + Specific name for which a distribution finder should match. + A name of ``None`` matches all distributions. + """ + + def __init__(self, **kwargs): + vars(self).update(kwargs) + + @property + def path(self) -> list[str]: + """ + The sequence of directory path that a distribution finder + should search. + + Typically refers to Python installed package paths such as + "site-packages" directories and defaults to ``sys.path``. + """ + return vars(self).get('path', sys.path) + + @abc.abstractmethod + def find_distributions(self, context=Context()) -> Iterable[Distribution]: + """ + Find distributions. + + Return an iterable of all Distribution instances capable of + loading the metadata for packages matching the ``context``, + a DistributionFinder.Context instance. + """ + + +@passthrough +def _clear_after_fork(cached): + """Ensure ``func`` clears cached state after ``fork`` when supported. + + ``FastPath`` caches zip-backed ``pathlib.Path`` objects that retain a + reference to the parent's open ``ZipFile`` handle. Re-using a cached + instance in a forked child can therefore resurrect invalid file pointers + and trigger ``BadZipFile``/``OSError`` failures (python/importlib_metadata#520). + Registering ``cache_clear`` with ``os.register_at_fork`` keeps each process + on its own cache. + """ + getattr(os, 'register_at_fork', noop)(after_in_child=cached.cache_clear) + + +class FastPath: + """ + Micro-optimized class for searching a root for children. + + Root is a path on the file system that may contain metadata + directories either as natural directories or within a zip file. + + >>> FastPath('').children() + ['...'] + + FastPath objects are cached and recycled for any given root. + + >>> FastPath('foobar') is FastPath('foobar') + True + """ + + @_clear_after_fork # type: ignore[misc] + @functools.lru_cache() + def __new__(cls, root): + return super().__new__(cls) + + def __init__(self, root): + self.root = root + + def joinpath(self, child): + return pathlib.Path(self.root, child) + + def children(self): + with suppress(Exception): + return os.listdir(self.root or '.') + with suppress(Exception): + return self.zip_children() + return [] + + def zip_children(self): + # deferred for performance (python/importlib_metadata#502) + from zipp.compat.overlay import zipfile + + zip_path = zipfile.Path(self.root) + names = zip_path.root.namelist() + self.joinpath = zip_path.joinpath + + return dict.fromkeys(child.split(posixpath.sep, 1)[0] for child in names) + + def search(self, name): + return self.lookup(self.mtime).search(name) + + @property + def mtime(self): + with suppress(OSError): + return os.stat(self.root).st_mtime + self.lookup.cache_clear() + + @method_cache + def lookup(self, mtime): + return Lookup(self) + + +class Lookup: + """ + A micro-optimized class for searching a (fast) path for metadata. + """ + + def __init__(self, path: FastPath): + """ + Calculate all of the children representing metadata. + + From the children in the path, calculate early all of the + children that appear to represent metadata (infos) or legacy + metadata (eggs). + """ + + base = os.path.basename(path.root).lower() + base_is_egg = base.endswith(".egg") + self.infos = FreezableDefaultDict(list) + self.eggs = FreezableDefaultDict(list) + + for child in path.children(): + low = child.lower() + if low.endswith((".dist-info", ".egg-info")): + # rpartition is faster than splitext and suitable for this purpose. + name = low.rpartition(".")[0].partition("-")[0] + normalized = Prepared.normalize(name) + self.infos[normalized].append(path.joinpath(child)) + elif base_is_egg and low == "egg-info": + name = base.rpartition(".")[0].partition("-")[0] + legacy_normalized = Prepared.legacy_normalize(name) + self.eggs[legacy_normalized].append(path.joinpath(child)) + + self.infos.freeze() + self.eggs.freeze() + + def search(self, prepared: Prepared): + """ + Yield all infos and eggs matching the Prepared query. + """ + infos = ( + self.infos[prepared.normalized] + if prepared + else itertools.chain.from_iterable(self.infos.values()) + ) + eggs = ( + self.eggs[prepared.legacy_normalized] + if prepared + else itertools.chain.from_iterable(self.eggs.values()) + ) + return itertools.chain(infos, eggs) + + +class Prepared: + """ + A prepared search query for metadata on a possibly-named package. + + Pre-calculates the normalization to prevent repeated operations. + + >>> none = Prepared(None) + >>> none.normalized + >>> none.legacy_normalized + >>> bool(none) + False + >>> sample = Prepared('Sample__Pkg-name.foo') + >>> sample.normalized + 'sample_pkg_name_foo' + >>> sample.legacy_normalized + 'sample__pkg_name.foo' + >>> bool(sample) + True + """ + + normalized = None + legacy_normalized = None + + def __init__(self, name: str | None): + self.name = name + if name is None: + return + self.normalized = self.normalize(name) + self.legacy_normalized = self.legacy_normalize(name) + + @staticmethod + def normalize(name): + """ + PEP 503 normalization plus dashes as underscores. + """ + return re.sub(r"[-_.]+", "-", name).lower().replace('-', '_') + + @staticmethod + def legacy_normalize(name): + """ + Normalize the package name as found in the convention in + older packaging tools versions and specs. + """ + return name.lower().replace('-', '_') + + def __bool__(self): + return bool(self.name) + + +@install +class MetadataPathFinder(NullFinder, DistributionFinder): + """A degenerate finder for distribution packages on the file system. + + This finder supplies only a find_distributions() method for versions + of Python that do not have a PathFinder find_distributions(). + """ + + @classmethod + def find_distributions( + cls, context=DistributionFinder.Context() + ) -> Iterable[PathDistribution]: + """ + Find distributions. + + Return an iterable of all Distribution instances capable of + loading the metadata for packages matching ``context.name`` + (or all names if ``None`` indicated) along the paths in the list + of directories ``context.path``. + """ + found = cls._search_paths(context.name, context.path) + return map(PathDistribution, found) + + @classmethod + def _search_paths(cls, name, paths): + """Find metadata directories in paths heuristically.""" + prepared = Prepared(name) + return itertools.chain.from_iterable( + path.search(prepared) for path in map(FastPath, paths) + ) + + @classmethod + def invalidate_caches(cls) -> None: + FastPath.__new__.cache_clear() + + +class PathDistribution(Distribution): + def __init__(self, path: SimplePath) -> None: + """Construct a distribution. + + :param path: SimplePath indicating the metadata directory. + """ + self._path = path + + def read_text(self, filename: str | os.PathLike[str]) -> str | None: + with suppress( + FileNotFoundError, + IsADirectoryError, + KeyError, + NotADirectoryError, + PermissionError, + ): + return self._path.joinpath(filename).read_text(encoding='utf-8') + + return None + + read_text.__doc__ = Distribution.read_text.__doc__ + + def locate_file(self, path: str | os.PathLike[str]) -> SimplePath: + return self._path.parent / path + + @property + def _normalized_name(self): + """ + Performance optimization: where possible, resolve the + normalized name from the file system path. + """ + stem = os.path.basename(str(self._path)) + return ( + pass_none(Prepared.normalize)(self._name_from_stem(stem)) + or super()._normalized_name + ) + + @staticmethod + def _name_from_stem(stem): + """ + >>> PathDistribution._name_from_stem('foo-3.0.egg-info') + 'foo' + >>> PathDistribution._name_from_stem('CherryPy-3.0.dist-info') + 'CherryPy' + >>> PathDistribution._name_from_stem('face.egg-info') + 'face' + >>> PathDistribution._name_from_stem('foo.bar') + """ + filename, ext = os.path.splitext(stem) + if ext not in ('.dist-info', '.egg-info'): + return + name, sep, rest = filename.partition('-') + return name + + +def distribution(distribution_name: str) -> Distribution: + """Get the ``Distribution`` instance for the named package. + + :param distribution_name: The name of the distribution package as a string. + :return: A ``Distribution`` instance (or subclass thereof). + """ + return Distribution.from_name(distribution_name) + + +def distributions(**kwargs) -> Iterable[Distribution]: + """Get all ``Distribution`` instances in the current environment. + + :return: An iterable of ``Distribution`` instances. + """ + return Distribution.discover(**kwargs) + + +def metadata(distribution_name: str) -> _meta.PackageMetadata | None: + """Get the metadata for the named package. + + :param distribution_name: The name of the distribution package to query. + :return: A PackageMetadata containing the parsed metadata. + """ + return Distribution.from_name(distribution_name).metadata + + +def version(distribution_name: str) -> str: + """Get the version string for the named package. + + :param distribution_name: The name of the distribution package to query. + :return: The version string for the package as defined in the package's + "Version" metadata key. + """ + return distribution(distribution_name).version + + +_unique = functools.partial( + unique_everseen, + key=py39.normalized_name, +) +""" +Wrapper for ``distributions`` to return unique distributions by name. +""" + + +def entry_points(**params) -> EntryPoints: + """Return EntryPoint objects for all installed packages. + + Pass selection parameters (group or name) to filter the + result to entry points matching those properties (see + EntryPoints.select()). + + :return: EntryPoints for all installed packages. + """ + eps = itertools.chain.from_iterable( + dist.entry_points for dist in _unique(distributions()) + ) + return EntryPoints(eps).select(**params) + + +def files(distribution_name: str) -> list[PackagePath] | None: + """Return a list of files for the named package. + + :param distribution_name: The name of the distribution package to query. + :return: List of files composing the distribution. + """ + return distribution(distribution_name).files + + +def requires(distribution_name: str) -> list[str] | None: + """ + Return a list of requirements for the named package. + + :return: An iterable of requirements, suitable for + packaging.requirement.Requirement. + """ + return distribution(distribution_name).requires + + +def packages_distributions() -> Mapping[str, list[str]]: + """ + Return a mapping of top-level packages to their + distributions. + + >>> import collections.abc + >>> pkgs = packages_distributions() + >>> all(isinstance(dist, collections.abc.Sequence) for dist in pkgs.values()) + True + """ + pkg_to_dist = collections.defaultdict(list) + for dist in distributions(): + for pkg in _top_level_declared(dist) or _top_level_inferred(dist): + pkg_to_dist[pkg].append(md_none(dist.metadata)['Name']) + return dict(pkg_to_dist) + + +def _top_level_declared(dist): + return (dist.read_text('top_level.txt') or '').split() + + +def _topmost(name: PackagePath) -> str | None: + """ + Return the top-most parent as long as there is a parent. + """ + top, *rest = name.parts + return top if rest else None + + +def _get_toplevel_name(name: PackagePath) -> str: + """ + Infer a possibly importable module name from a name presumed on + sys.path. + + >>> _get_toplevel_name(PackagePath('foo.py')) + 'foo' + >>> _get_toplevel_name(PackagePath('foo')) + 'foo' + >>> _get_toplevel_name(PackagePath('foo.pyc')) + 'foo' + >>> _get_toplevel_name(PackagePath('foo/__init__.py')) + 'foo' + >>> _get_toplevel_name(PackagePath('foo.pth')) + 'foo.pth' + >>> _get_toplevel_name(PackagePath('foo.dist-info')) + 'foo.dist-info' + """ + # Defer import of inspect for performance (python/cpython#118761) + import inspect + + return _topmost(name) or inspect.getmodulename(name) or str(name) + + +def _top_level_inferred(dist): + opt_names = set(map(_get_toplevel_name, always_iterable(dist.files))) + + def importable_name(name): + return '.' not in name + + return filter(importable_name, opt_names) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/_adapters.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/_adapters.py new file mode 100644 index 0000000000000000000000000000000000000000..dede395d79a38bab322d56a66d916703af84f77b --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/_adapters.py @@ -0,0 +1,136 @@ +import email.message +import email.policy +import re +import textwrap + +from ._text import FoldedCase + + +class RawPolicy(email.policy.EmailPolicy): + def fold(self, name, value): + folded = self.linesep.join( + textwrap + .indent(value, prefix=' ' * 8, predicate=lambda line: True) + .lstrip() + .splitlines() + ) + return f'{name}: {folded}{self.linesep}' + + +class Message(email.message.Message): + r""" + Specialized Message subclass to handle metadata naturally. + + Reads values that may have newlines in them and converts the + payload to the Description. + + >>> msg_text = textwrap.dedent(''' + ... Name: Foo + ... Version: 3.0 + ... License: blah + ... de-blah + ... + ... First line of description. + ... Second line of description. + ... + ... Fourth line! + ... ''').lstrip().replace('', '') + >>> msg = Message(email.message_from_string(msg_text)) + >>> msg['Description'] + 'First line of description.\nSecond line of description.\n\nFourth line!\n' + + Message should render even if values contain newlines. + + >>> print(msg) + Name: Foo + Version: 3.0 + License: blah + de-blah + Description: First line of description. + Second line of description. + + Fourth line! + + + """ + + multiple_use_keys = set( + map( + FoldedCase, + [ + 'Classifier', + 'Obsoletes-Dist', + 'Platform', + 'Project-URL', + 'Provides-Dist', + 'Provides-Extra', + 'Requires-Dist', + 'Requires-External', + 'Supported-Platform', + 'Dynamic', + ], + ) + ) + """ + Keys that may be indicated multiple times per PEP 566. + """ + + def __new__(cls, orig: email.message.Message): + res = super().__new__(cls) + vars(res).update(vars(orig)) + return res + + def __init__(self, *args, **kwargs): + self._headers = self._repair_headers() + + # suppress spurious error from mypy + def __iter__(self): + return super().__iter__() + + def __getitem__(self, item): + """ + Override parent behavior to typical dict behavior. + + ``email.message.Message`` will emit None values for missing + keys. Typical mappings, including this ``Message``, will raise + a key error for missing keys. + + Ref python/importlib_metadata#371. + """ + res = super().__getitem__(item) + if res is None: + raise KeyError(item) + return res + + def _repair_headers(self): + def redent(value): + "Correct for RFC822 indentation" + indent = ' ' * 8 + if not value or '\n' + indent not in value: + return value + return textwrap.dedent(indent + value) + + headers = [(key, redent(value)) for key, value in vars(self)['_headers']] + if self._payload: + headers.append(('Description', self.get_payload())) + self.set_payload('') + return headers + + def as_string(self): + return super().as_string(policy=RawPolicy()) + + @property + def json(self): + """ + Convert PackageMetadata to a JSON-compatible format + per PEP 0566. + """ + + def transform(key): + value = self.get_all(key) if key in self.multiple_use_keys else self[key] + if key == 'Keywords': + value = re.split(r'\s+', value) + tk = key.lower().replace('-', '_') + return tk, value + + return dict(map(transform, map(FoldedCase, self))) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/_collections.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/_collections.py new file mode 100644 index 0000000000000000000000000000000000000000..fc5045d36be57251000393b32baba7baa9cd8c4f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/_collections.py @@ -0,0 +1,34 @@ +import collections +import typing + + +# from jaraco.collections 3.3 +class FreezableDefaultDict(collections.defaultdict): + """ + Often it is desirable to prevent the mutation of + a default dict after its initial construction, such + as to prevent mutation during iteration. + + >>> dd = FreezableDefaultDict(list) + >>> dd[0].append('1') + >>> dd.freeze() + >>> dd[1] + [] + >>> len(dd) + 1 + """ + + def __missing__(self, key): + return getattr(self, '_frozen', super().__missing__)(key) + + def freeze(self): + self._frozen = lambda key: self.default_factory() + + +class Pair(typing.NamedTuple): + name: str + value: str + + @classmethod + def parse(cls, text): + return cls(*map(str.strip, text.split("=", 1))) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/_compat.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/_compat.py new file mode 100644 index 0000000000000000000000000000000000000000..01356d69b97c95a6d41818e5c2c50a299146bef4 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/_compat.py @@ -0,0 +1,56 @@ +import platform +import sys + +__all__ = ['install', 'NullFinder'] + + +def install(cls): + """ + Class decorator for installation on sys.meta_path. + + Adds the backport DistributionFinder to sys.meta_path and + attempts to disable the finder functionality of the stdlib + DistributionFinder. + """ + sys.meta_path.append(cls()) + disable_stdlib_finder() + return cls + + +def disable_stdlib_finder(): + """ + Give the backport primacy for discovering path-based distributions + by monkey-patching the stdlib O_O. + + See #91 for more background for rationale on this sketchy + behavior. + """ + + def matches(finder): + return getattr( + finder, '__module__', None + ) == '_frozen_importlib_external' and hasattr(finder, 'find_distributions') + + for finder in filter(matches, sys.meta_path): # pragma: nocover + del finder.find_distributions + + +class NullFinder: + """ + A "Finder" (aka "MetaPathFinder") that never finds any modules, + but may find distributions. + """ + + @staticmethod + def find_spec(*args, **kwargs): + return None + + +def pypy_partial(val): + """ + Adjust for variable stacklevel on partial under PyPy. + + Workaround for #327. + """ + is_pypy = platform.python_implementation() == 'PyPy' + return val + is_pypy diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/_functools.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/_functools.py new file mode 100644 index 0000000000000000000000000000000000000000..b1fd04a84ab4c129b19f71a13f7489c37d1a9e9e --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/_functools.py @@ -0,0 +1,135 @@ +import functools +import types +from typing import Callable, TypeVar + + +# from jaraco.functools 3.3 +def method_cache(method, cache_wrapper=None): + """ + Wrap lru_cache to support storing the cache data in the object instances. + + Abstracts the common paradigm where the method explicitly saves an + underscore-prefixed protected property on first call and returns that + subsequently. + + >>> class MyClass: + ... calls = 0 + ... + ... @method_cache + ... def method(self, value): + ... self.calls += 1 + ... return value + + >>> a = MyClass() + >>> a.method(3) + 3 + >>> for x in range(75): + ... res = a.method(x) + >>> a.calls + 75 + + Note that the apparent behavior will be exactly like that of lru_cache + except that the cache is stored on each instance, so values in one + instance will not flush values from another, and when an instance is + deleted, so are the cached values for that instance. + + >>> b = MyClass() + >>> for x in range(35): + ... res = b.method(x) + >>> b.calls + 35 + >>> a.method(0) + 0 + >>> a.calls + 75 + + Note that if method had been decorated with ``functools.lru_cache()``, + a.calls would have been 76 (due to the cached value of 0 having been + flushed by the 'b' instance). + + Clear the cache with ``.cache_clear()`` + + >>> a.method.cache_clear() + + Same for a method that hasn't yet been called. + + >>> c = MyClass() + >>> c.method.cache_clear() + + Another cache wrapper may be supplied: + + >>> cache = functools.lru_cache(maxsize=2) + >>> MyClass.method2 = method_cache(lambda self: 3, cache_wrapper=cache) + >>> a = MyClass() + >>> a.method2() + 3 + + Caution - do not subsequently wrap the method with another decorator, such + as ``@property``, which changes the semantics of the function. + + See also + http://code.activestate.com/recipes/577452-a-memoize-decorator-for-instance-methods/ + for another implementation and additional justification. + """ + cache_wrapper = cache_wrapper or functools.lru_cache() + + def wrapper(self, *args, **kwargs): + # it's the first call, replace the method with a cached, bound method + bound_method = types.MethodType(method, self) + cached_method = cache_wrapper(bound_method) + setattr(self, method.__name__, cached_method) + return cached_method(*args, **kwargs) + + # Support cache clear even before cache has been created. + wrapper.cache_clear = lambda: None + + return wrapper + + +# From jaraco.functools 3.3 +def pass_none(func): + """ + Wrap func so it's not called if its first param is None + + >>> print_text = pass_none(print) + >>> print_text('text') + text + >>> print_text(None) + """ + + @functools.wraps(func) + def wrapper(param, *args, **kwargs): + if param is not None: + return func(param, *args, **kwargs) + + return wrapper + + +# From jaraco.functools 4.4 +def noop(*args, **kwargs): + """ + A no-operation function that does nothing. + + >>> noop(1, 2, three=3) + """ + + +_T = TypeVar('_T') + + +# From jaraco.functools 4.4 +def passthrough(func: Callable[..., object]) -> Callable[[_T], _T]: + """ + Wrap the function to always return the first parameter. + + >>> passthrough(print)('3') + 3 + '3' + """ + + @functools.wraps(func) + def wrapper(first: _T, *args, **kwargs) -> _T: + func(first, *args, **kwargs) + return first + + return wrapper # type: ignore[return-value] diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/_itertools.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/_itertools.py new file mode 100644 index 0000000000000000000000000000000000000000..79d37198ce7aff317873f6e4e84cd904a46a69de --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/_itertools.py @@ -0,0 +1,171 @@ +from collections import defaultdict, deque +from itertools import filterfalse + + +def unique_everseen(iterable, key=None): + "List unique elements, preserving order. Remember all elements ever seen." + # unique_everseen('AAAABBBCCDAABBB') --> A B C D + # unique_everseen('ABBCcAD', str.lower) --> A B C D + seen = set() + seen_add = seen.add + if key is None: + for element in filterfalse(seen.__contains__, iterable): + seen_add(element) + yield element + else: + for element in iterable: + k = key(element) + if k not in seen: + seen_add(k) + yield element + + +# copied from more_itertools 8.8 +def always_iterable(obj, base_type=(str, bytes)): + """If *obj* is iterable, return an iterator over its items:: + + >>> obj = (1, 2, 3) + >>> list(always_iterable(obj)) + [1, 2, 3] + + If *obj* is not iterable, return a one-item iterable containing *obj*:: + + >>> obj = 1 + >>> list(always_iterable(obj)) + [1] + + If *obj* is ``None``, return an empty iterable: + + >>> obj = None + >>> list(always_iterable(None)) + [] + + By default, binary and text strings are not considered iterable:: + + >>> obj = 'foo' + >>> list(always_iterable(obj)) + ['foo'] + + If *base_type* is set, objects for which ``isinstance(obj, base_type)`` + returns ``True`` won't be considered iterable. + + >>> obj = {'a': 1} + >>> list(always_iterable(obj)) # Iterate over the dict's keys + ['a'] + >>> list(always_iterable(obj, base_type=dict)) # Treat dicts as a unit + [{'a': 1}] + + Set *base_type* to ``None`` to avoid any special handling and treat objects + Python considers iterable as iterable: + + >>> obj = 'foo' + >>> list(always_iterable(obj, base_type=None)) + ['f', 'o', 'o'] + """ + if obj is None: + return iter(()) + + if (base_type is not None) and isinstance(obj, base_type): + return iter((obj,)) + + try: + return iter(obj) + except TypeError: + return iter((obj,)) + + +# Copied from more_itertools 10.3 +class bucket: + """Wrap *iterable* and return an object that buckets the iterable into + child iterables based on a *key* function. + + >>> iterable = ['a1', 'b1', 'c1', 'a2', 'b2', 'c2', 'b3'] + >>> s = bucket(iterable, key=lambda x: x[0]) # Bucket by 1st character + >>> sorted(list(s)) # Get the keys + ['a', 'b', 'c'] + >>> a_iterable = s['a'] + >>> next(a_iterable) + 'a1' + >>> next(a_iterable) + 'a2' + >>> list(s['b']) + ['b1', 'b2', 'b3'] + + The original iterable will be advanced and its items will be cached until + they are used by the child iterables. This may require significant storage. + + By default, attempting to select a bucket to which no items belong will + exhaust the iterable and cache all values. + If you specify a *validator* function, selected buckets will instead be + checked against it. + + >>> from itertools import count + >>> it = count(1, 2) # Infinite sequence of odd numbers + >>> key = lambda x: x % 10 # Bucket by last digit + >>> validator = lambda x: x in {1, 3, 5, 7, 9} # Odd digits only + >>> s = bucket(it, key=key, validator=validator) + >>> 2 in s + False + >>> list(s[2]) + [] + + """ + + def __init__(self, iterable, key, validator=None): + self._it = iter(iterable) + self._key = key + self._cache = defaultdict(deque) + self._validator = validator or (lambda x: True) + + def __contains__(self, value): + if not self._validator(value): + return False + + try: + item = next(self[value]) + except StopIteration: + return False + else: + self._cache[value].appendleft(item) + + return True + + def _get_values(self, value): + """ + Helper to yield items from the parent iterator that match *value*. + Items that don't match are stored in the local cache as they + are encountered. + """ + while True: + # If we've cached some items that match the target value, emit + # the first one and evict it from the cache. + if self._cache[value]: + yield self._cache[value].popleft() + # Otherwise we need to advance the parent iterator to search for + # a matching item, caching the rest. + else: + while True: + try: + item = next(self._it) + except StopIteration: + return + item_value = self._key(item) + if item_value == value: + yield item + break + elif self._validator(item_value): + self._cache[item_value].append(item) + + def __iter__(self): + for item in self._it: + item_value = self._key(item) + if self._validator(item_value): + self._cache[item_value].append(item) + + yield from self._cache.keys() + + def __getitem__(self, value): + if not self._validator(value): + return iter(()) + + return self._get_values(value) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/_meta.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/_meta.py new file mode 100644 index 0000000000000000000000000000000000000000..0c20eff3da75223a5ca76a1743b7c5b8fa1dc1f6 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/_meta.py @@ -0,0 +1,71 @@ +from __future__ import annotations + +import os +from collections.abc import Iterator +from typing import ( + Any, + Protocol, + TypeVar, + overload, +) + +_T = TypeVar("_T") + + +class PackageMetadata(Protocol): + def __len__(self) -> int: ... # pragma: no cover + + def __contains__(self, item: str) -> bool: ... # pragma: no cover + + def __getitem__(self, key: str) -> str: ... # pragma: no cover + + def __iter__(self) -> Iterator[str]: ... # pragma: no cover + + @overload + def get( + self, name: str, failobj: None = None + ) -> str | None: ... # pragma: no cover + + @overload + def get(self, name: str, failobj: _T) -> str | _T: ... # pragma: no cover + + # overload per python/importlib_metadata#435 + @overload + def get_all( + self, name: str, failobj: None = None + ) -> list[Any] | None: ... # pragma: no cover + + @overload + def get_all(self, name: str, failobj: _T) -> list[Any] | _T: + """ + Return all values associated with a possibly multi-valued key. + """ + + @property + def json(self) -> dict[str, str | list[str]]: + """ + A JSON-compatible form of the metadata. + """ + + +class SimplePath(Protocol): + """ + A minimal subset of pathlib.Path required by Distribution. + """ + + def joinpath( + self, other: str | os.PathLike[str] + ) -> SimplePath: ... # pragma: no cover + + def __truediv__( + self, other: str | os.PathLike[str] + ) -> SimplePath: ... # pragma: no cover + + @property + def parent(self) -> SimplePath: ... # pragma: no cover + + def read_text(self, encoding=None) -> str: ... # pragma: no cover + + def read_bytes(self) -> bytes: ... # pragma: no cover + + def exists(self) -> bool: ... # pragma: no cover diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/_text.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/_text.py new file mode 100644 index 0000000000000000000000000000000000000000..c88cfbb2349c6401336bc5ba6623f51afd1eb59d --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/_text.py @@ -0,0 +1,99 @@ +import re + +from ._functools import method_cache + + +# from jaraco.text 3.5 +class FoldedCase(str): + """ + A case insensitive string class; behaves just like str + except compares equal when the only variation is case. + + >>> s = FoldedCase('hello world') + + >>> s == 'Hello World' + True + + >>> 'Hello World' == s + True + + >>> s != 'Hello World' + False + + >>> s.index('O') + 4 + + >>> s.split('O') + ['hell', ' w', 'rld'] + + >>> sorted(map(FoldedCase, ['GAMMA', 'alpha', 'Beta'])) + ['alpha', 'Beta', 'GAMMA'] + + Sequence membership is straightforward. + + >>> "Hello World" in [s] + True + >>> s in ["Hello World"] + True + + You may test for set inclusion, but candidate and elements + must both be folded. + + >>> FoldedCase("Hello World") in {s} + True + >>> s in {FoldedCase("Hello World")} + True + + String inclusion works as long as the FoldedCase object + is on the right. + + >>> "hello" in FoldedCase("Hello World") + True + + But not if the FoldedCase object is on the left: + + >>> FoldedCase('hello') in 'Hello World' + False + + In that case, use in_: + + >>> FoldedCase('hello').in_('Hello World') + True + + >>> FoldedCase('hello') > FoldedCase('Hello') + False + """ + + def __lt__(self, other): + return self.lower() < other.lower() + + def __gt__(self, other): + return self.lower() > other.lower() + + def __eq__(self, other): + return self.lower() == other.lower() + + def __ne__(self, other): + return self.lower() != other.lower() + + def __hash__(self): + return hash(self.lower()) + + def __contains__(self, other): + return super().lower().__contains__(other.lower()) + + def in_(self, other): + "Does self appear in other?" + return self in FoldedCase(other) + + # cache lower since it's likely to be called frequently. + @method_cache + def lower(self): + return super().lower() + + def index(self, sub): + return self.lower().index(sub.lower()) + + def split(self, splitter=' ', maxsplit=0): + pattern = re.compile(re.escape(splitter), re.I) + return pattern.split(self, maxsplit) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/_typing.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/_typing.py new file mode 100644 index 0000000000000000000000000000000000000000..32b1d2b98ac987e8361f60362b8bdabcdc6fb1c8 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/_typing.py @@ -0,0 +1,15 @@ +import functools +import typing + +from ._meta import PackageMetadata + +md_none = functools.partial(typing.cast, PackageMetadata) +""" +Suppress type errors for optional metadata. + +Although Distribution.metadata can return None when metadata is corrupt +and thus None, allow callers to assume it's not None and crash if +that's the case. + +# python/importlib_metadata#493 +""" diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/diagnose.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/diagnose.py new file mode 100644 index 0000000000000000000000000000000000000000..e405471ac4d94371b1ee9b1622227ff76b337180 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/diagnose.py @@ -0,0 +1,21 @@ +import sys + +from . import Distribution + + +def inspect(path): + print("Inspecting", path) + dists = list(Distribution.discover(path=[path])) + if not dists: + return + print("Found", len(dists), "packages:", end=' ') + print(', '.join(dist.name for dist in dists)) + + +def run(): + for path in sys.path: + inspect(path) + + +if __name__ == '__main__': + run() diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/py.typed b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/importlib_metadata/py.typed new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco.text-4.0.0.dist-info/INSTALLER b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco.text-4.0.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..5c69047b2eb8235994febeeae1da4a82365a240a --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco.text-4.0.0.dist-info/INSTALLER @@ -0,0 +1 @@ +uv \ No newline at end of file diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco.text-4.0.0.dist-info/LICENSE b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco.text-4.0.0.dist-info/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..1bb5a44356f00884a71ceeefd24ded6caaba2418 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco.text-4.0.0.dist-info/LICENSE @@ -0,0 +1,17 @@ +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. diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco.text-4.0.0.dist-info/METADATA b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco.text-4.0.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..797b9da7334a85347e0439d48c11ee0d1b101f49 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco.text-4.0.0.dist-info/METADATA @@ -0,0 +1,96 @@ +Metadata-Version: 2.1 +Name: jaraco.text +Version: 4.0.0 +Summary: Module for text manipulation +Author-email: "Jason R. Coombs" +Project-URL: Source, https://github.com/jaraco/jaraco.text +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: MIT License +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3 :: Only +Requires-Python: >=3.8 +Description-Content-Type: text/x-rst +License-File: LICENSE +Requires-Dist: jaraco.functools +Requires-Dist: jaraco.context >=4.1 +Requires-Dist: autocommand +Requires-Dist: more-itertools +Requires-Dist: importlib-resources ; python_version < "3.9" +Provides-Extra: doc +Requires-Dist: sphinx >=3.5 ; extra == 'doc' +Requires-Dist: jaraco.packaging >=9.3 ; extra == 'doc' +Requires-Dist: rst.linker >=1.9 ; extra == 'doc' +Requires-Dist: furo ; extra == 'doc' +Requires-Dist: sphinx-lint ; extra == 'doc' +Requires-Dist: jaraco.tidelift >=1.4 ; extra == 'doc' +Provides-Extra: inflect +Requires-Dist: inflect ; extra == 'inflect' +Provides-Extra: test +Requires-Dist: pytest !=8.1.*,>=6 ; extra == 'test' +Requires-Dist: pytest-checkdocs >=2.4 ; extra == 'test' +Requires-Dist: pytest-cov ; extra == 'test' +Requires-Dist: pytest-mypy ; extra == 'test' +Requires-Dist: pytest-enabler >=2.2 ; extra == 'test' +Requires-Dist: pathlib2 ; (python_version < "3.10") and extra == 'test' +Requires-Dist: pytest-ruff >=0.2.1 ; (sys_platform != "cygwin") and extra == 'test' + +.. image:: https://img.shields.io/pypi/v/jaraco.text.svg + :target: https://pypi.org/project/jaraco.text + +.. image:: https://img.shields.io/pypi/pyversions/jaraco.text.svg + +.. image:: https://github.com/jaraco/jaraco.text/actions/workflows/main.yml/badge.svg + :target: https://github.com/jaraco/jaraco.text/actions?query=workflow%3A%22tests%22 + :alt: tests + +.. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json + :target: https://github.com/astral-sh/ruff + :alt: Ruff + +.. image:: https://readthedocs.org/projects/jaracotext/badge/?version=latest + :target: https://jaracotext.readthedocs.io/en/latest/?badge=latest + +.. image:: https://img.shields.io/badge/skeleton-2024-informational + :target: https://blog.jaraco.com/skeleton + +.. image:: https://tidelift.com/badges/package/pypi/jaraco.text + :target: https://tidelift.com/subscription/pkg/pypi-jaraco.text?utm_source=pypi-jaraco.text&utm_medium=readme + + +This package provides handy routines for dealing with text, such as +wrapping, substitution, trimming, stripping, prefix and suffix removal, +line continuation, indentation, comment processing, identifier processing, +values parsing, case insensitive comparison, and more. See the docs +(linked in the badge above) for the detailed documentation and examples. + +Layouts +======= + +One of the features of this package is the layouts module, which +provides a simple example of translating keystrokes from one keyboard +layout to another:: + + echo qwerty | python -m jaraco.text.to-dvorak + ',.pyf + echo "',.pyf" | python -m jaraco.text.to-qwerty + qwerty + +Newline Reporting +================= + +Need to know what newlines appear in a file? + +:: + + $ python -m jaraco.text.show-newlines README.rst + newline is '\n' + +For Enterprise +============== + +Available as part of the Tidelift Subscription. + +This project and the maintainers of thousands of other packages are working with Tidelift to deliver one enterprise subscription that covers all of the open source you use. + +`Learn more `_. diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco.text-4.0.0.dist-info/RECORD b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco.text-4.0.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..af65a9daa8caed85a09198e65f37278ec0532d91 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco.text-4.0.0.dist-info/RECORD @@ -0,0 +1,14 @@ +jaraco.text-4.0.0.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2 +jaraco.text-4.0.0.dist-info/LICENSE,sha256=htoPAa6uRjSKPD1GUZXcHOzN55956HdppkuNoEsqR0E,1023 +jaraco.text-4.0.0.dist-info/METADATA,sha256=XC_QkBLJVPE5sQYkl41TNaZUw0AUzQb29GbKaD28nFY,3731 +jaraco.text-4.0.0.dist-info/RECORD,, +jaraco.text-4.0.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +jaraco.text-4.0.0.dist-info/WHEEL,sha256=Wyh-_nZ0DJYolHNn1_hMa4lM7uDedD_RGVwbmTjyItk,91 +jaraco.text-4.0.0.dist-info/top_level.txt,sha256=0JnN3LfXH4LIRfXL-QFOGCJzQWZO3ELx4R1d_louoQM,7 +jaraco/text/Lorem ipsum.txt,sha256=N_7c_79zxOufBY9HZ3yzMgOkNv-TkOTTio4BydrSjgs,1335 +jaraco/text/__init__.py,sha256=lazNYXo8IhOR1bFigLAyGiiQao6jtO3KGWh8bZZPx3c,16762 +jaraco/text/layouts.py,sha256=HTC8aSTLZ7uXipyOXapRMC158juecjK6RVwitfmZ9_w,643 +jaraco/text/show-newlines.py,sha256=jT0vp4gLhG20hX2lTB-zKo_i3NgKzj79yRAdz4eMzIM,903 +jaraco/text/strip-prefix.py,sha256=NfVXV8JVNo6nqcuYASfMV7_y4Eo8zMQqlCOGvAnRIVw,412 +jaraco/text/to-dvorak.py,sha256=36nPPsiifwv6RfpAb--3zpgbIx8ohnnI1aR29IJTO9s,118 +jaraco/text/to-qwerty.py,sha256=IQoFY9v7vLTEybcput4KBYm_5GR35pmtgZ_xyrmdTgI,118 diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco.text-4.0.0.dist-info/REQUESTED b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco.text-4.0.0.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco.text-4.0.0.dist-info/WHEEL b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco.text-4.0.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..ecaf39f3c3df8b0075a2951da9b1a27fcb08a173 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco.text-4.0.0.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: setuptools (71.1.0) +Root-Is-Purelib: true +Tag: py3-none-any + diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco.text-4.0.0.dist-info/top_level.txt b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco.text-4.0.0.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..f6205a5f19a533fd30f90a433e610325ff02f989 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco.text-4.0.0.dist-info/top_level.txt @@ -0,0 +1 @@ +jaraco diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_context-6.1.0.dist-info/INSTALLER b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_context-6.1.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..5c69047b2eb8235994febeeae1da4a82365a240a --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_context-6.1.0.dist-info/INSTALLER @@ -0,0 +1 @@ +uv \ No newline at end of file diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_context-6.1.0.dist-info/METADATA b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_context-6.1.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..8fb5e53da3f958a6566c3c379b50f3e59c04320e --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_context-6.1.0.dist-info/METADATA @@ -0,0 +1,82 @@ +Metadata-Version: 2.4 +Name: jaraco.context +Version: 6.1.0 +Summary: Useful decorators and context managers +Author-email: "Jason R. Coombs" +License-Expression: MIT +Project-URL: Source, https://github.com/jaraco/jaraco.context +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3 :: Only +Requires-Python: >=3.9 +Description-Content-Type: text/x-rst +License-File: LICENSE +Requires-Dist: backports.tarfile; python_version < "3.12" +Provides-Extra: test +Requires-Dist: pytest!=8.1.*,>=6; extra == "test" +Requires-Dist: jaraco.test>=5.6.0; extra == "test" +Requires-Dist: portend; extra == "test" +Provides-Extra: doc +Requires-Dist: sphinx>=3.5; extra == "doc" +Requires-Dist: jaraco.packaging>=9.3; extra == "doc" +Requires-Dist: rst.linker>=1.9; extra == "doc" +Requires-Dist: furo; extra == "doc" +Requires-Dist: sphinx-lint; extra == "doc" +Requires-Dist: jaraco.tidelift>=1.4; extra == "doc" +Provides-Extra: check +Requires-Dist: pytest-checkdocs>=2.4; extra == "check" +Requires-Dist: pytest-ruff>=0.2.1; sys_platform != "cygwin" and extra == "check" +Provides-Extra: cover +Requires-Dist: pytest-cov; extra == "cover" +Provides-Extra: enabler +Requires-Dist: pytest-enabler>=3.4; extra == "enabler" +Provides-Extra: type +Requires-Dist: pytest-mypy>=1.0.1; extra == "type" +Requires-Dist: mypy<1.19; platform_python_implementation == "PyPy" and extra == "type" +Dynamic: license-file + +.. image:: https://img.shields.io/pypi/v/jaraco.context.svg + :target: https://pypi.org/project/jaraco.context + +.. image:: https://img.shields.io/pypi/pyversions/jaraco.context.svg + +.. image:: https://github.com/jaraco/jaraco.context/actions/workflows/main.yml/badge.svg + :target: https://github.com/jaraco/jaraco.context/actions?query=workflow%3A%22tests%22 + :alt: tests + +.. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json + :target: https://github.com/astral-sh/ruff + :alt: Ruff + +.. image:: https://readthedocs.org/projects/jaracocontext/badge/?version=latest + :target: https://jaracocontext.readthedocs.io/en/latest/?badge=latest + +.. image:: https://img.shields.io/badge/skeleton-2025-informational + :target: https://blog.jaraco.com/skeleton + +.. image:: https://tidelift.com/badges/package/pypi/jaraco.context + :target: https://tidelift.com/subscription/pkg/pypi-jaraco.context?utm_source=pypi-jaraco.context&utm_medium=readme + + +Highlights +========== + +See the docs linked from the badge above for the full details, but here are some features that may be of interest. + +- ``ExceptionTrap`` provides a general-purpose wrapper for trapping exceptions and then acting on the outcome. Includes ``passes`` and ``raises`` decorators to replace the result of a wrapped function by a boolean indicating the outcome of the exception trap. See `this keyring commit `_ for an example of it in production. +- ``suppress`` simply enables ``contextlib.suppress`` as a decorator. +- ``on_interrupt`` is a decorator used by CLI entry points to affect the handling of a ``KeyboardInterrupt``. Inspired by `Lucretiel/autocommand#18 `_. +- ``pushd`` is similar to pytest's ``monkeypatch.chdir`` or path's `default context `_, changes the current working directory for the duration of the context. +- ``tarball`` will download a tarball, extract it, change directory, yield, then clean up after. Convenient when working with web assets. +- ``null`` is there for those times when one code branch needs a context and the other doesn't; this null context provides symmetry across those branches. + + +For Enterprise +============== + +Available as part of the Tidelift Subscription. + +This project and the maintainers of thousands of other packages are working with Tidelift to deliver one enterprise subscription that covers all of the open source you use. + +`Learn more `_. diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_context-6.1.0.dist-info/RECORD b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_context-6.1.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..e5169f66596795d5883da25a272970be0e8acd50 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_context-6.1.0.dist-info/RECORD @@ -0,0 +1,9 @@ +jaraco/context/__init__.py,sha256=br1ydYGo1Xr_Pu1anuEdd-QrjUiz_EY5L_5E4C03L4w,9809 +jaraco/context/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +jaraco_context-6.1.0.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2 +jaraco_context-6.1.0.dist-info/METADATA,sha256=BDXr_FIFXFqZdO0gwXG2RUOD6vnbsVCIFLp62XxZ1xI,4270 +jaraco_context-6.1.0.dist-info/RECORD,, +jaraco_context-6.1.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +jaraco_context-6.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91 +jaraco_context-6.1.0.dist-info/licenses/LICENSE,sha256=l1WhhRlmbl8PTK49qtPXASvK5IpgCzEjfXXp_hNOZoM,1076 +jaraco_context-6.1.0.dist-info/top_level.txt,sha256=0JnN3LfXH4LIRfXL-QFOGCJzQWZO3ELx4R1d_louoQM,7 diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_context-6.1.0.dist-info/REQUESTED b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_context-6.1.0.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_context-6.1.0.dist-info/WHEEL b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_context-6.1.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..e7fa31b6f3f78deb1022c1f7927f07d4d16da822 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_context-6.1.0.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: setuptools (80.9.0) +Root-Is-Purelib: true +Tag: py3-none-any + diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_context-6.1.0.dist-info/licenses/LICENSE b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_context-6.1.0.dist-info/licenses/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..c891f411dc44c70ff121531af2ee189d3da4c871 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_context-6.1.0.dist-info/licenses/LICENSE @@ -0,0 +1,18 @@ +MIT License + +Copyright (c) 2026 + +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. diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_context-6.1.0.dist-info/top_level.txt b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_context-6.1.0.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..f6205a5f19a533fd30f90a433e610325ff02f989 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_context-6.1.0.dist-info/top_level.txt @@ -0,0 +1 @@ +jaraco diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_functools-4.4.0.dist-info/INSTALLER b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_functools-4.4.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..5c69047b2eb8235994febeeae1da4a82365a240a --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_functools-4.4.0.dist-info/INSTALLER @@ -0,0 +1 @@ +uv \ No newline at end of file diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_functools-4.4.0.dist-info/METADATA b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_functools-4.4.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..f2150dd88bea2b8701c2b6199bfc53b1fdb8f9a7 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_functools-4.4.0.dist-info/METADATA @@ -0,0 +1,69 @@ +Metadata-Version: 2.4 +Name: jaraco.functools +Version: 4.4.0 +Summary: Functools like those found in stdlib +Author-email: "Jason R. Coombs" +License-Expression: MIT +Project-URL: Source, https://github.com/jaraco/jaraco.functools +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3 :: Only +Requires-Python: >=3.9 +Description-Content-Type: text/x-rst +License-File: LICENSE +Requires-Dist: more_itertools +Provides-Extra: test +Requires-Dist: pytest!=8.1.*,>=6; extra == "test" +Requires-Dist: jaraco.classes; extra == "test" +Provides-Extra: doc +Requires-Dist: sphinx>=3.5; extra == "doc" +Requires-Dist: jaraco.packaging>=9.3; extra == "doc" +Requires-Dist: rst.linker>=1.9; extra == "doc" +Requires-Dist: furo; extra == "doc" +Requires-Dist: sphinx-lint; extra == "doc" +Requires-Dist: jaraco.tidelift>=1.4; extra == "doc" +Provides-Extra: check +Requires-Dist: pytest-checkdocs>=2.4; extra == "check" +Requires-Dist: pytest-ruff>=0.2.1; sys_platform != "cygwin" and extra == "check" +Provides-Extra: cover +Requires-Dist: pytest-cov; extra == "cover" +Provides-Extra: enabler +Requires-Dist: pytest-enabler>=3.4; extra == "enabler" +Provides-Extra: type +Requires-Dist: pytest-mypy>=1.0.1; extra == "type" +Requires-Dist: mypy<1.19; platform_python_implementation == "PyPy" and extra == "type" +Dynamic: license-file + +.. image:: https://img.shields.io/pypi/v/jaraco.functools.svg + :target: https://pypi.org/project/jaraco.functools + +.. image:: https://img.shields.io/pypi/pyversions/jaraco.functools.svg + +.. image:: https://github.com/jaraco/jaraco.functools/actions/workflows/main.yml/badge.svg + :target: https://github.com/jaraco/jaraco.functools/actions?query=workflow%3A%22tests%22 + :alt: tests + +.. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json + :target: https://github.com/astral-sh/ruff + :alt: Ruff + +.. image:: https://readthedocs.org/projects/jaracofunctools/badge/?version=latest + :target: https://jaracofunctools.readthedocs.io/en/latest/?badge=latest + +.. image:: https://img.shields.io/badge/skeleton-2025-informational + :target: https://blog.jaraco.com/skeleton + +.. image:: https://tidelift.com/badges/package/pypi/jaraco.functools + :target: https://tidelift.com/subscription/pkg/pypi-jaraco.functools?utm_source=pypi-jaraco.functools&utm_medium=readme + +Additional functools in the spirit of stdlib's functools. + +For Enterprise +============== + +Available as part of the Tidelift Subscription. + +This project and the maintainers of thousands of other packages are working with Tidelift to deliver one enterprise subscription that covers all of the open source you use. + +`Learn more `_. diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_functools-4.4.0.dist-info/RECORD b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_functools-4.4.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..3516c9f0396cc14d4ee246160a425447aad03abe --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_functools-4.4.0.dist-info/RECORD @@ -0,0 +1,10 @@ +jaraco/functools/__init__.py,sha256=ZJx9cMs2Nvk2xGUl8OjVGkpjdOaNlSzJrN4dGglgX2g,18599 +jaraco/functools/__init__.pyi,sha256=K4DcbnYIHE5QlMxqf9-cVp-WhycrhuTao4J7O7TMq4Y,3907 +jaraco/functools/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +jaraco_functools-4.4.0.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2 +jaraco_functools-4.4.0.dist-info/METADATA,sha256=LnnajcNGmSSr46yLIqP-tWkqeb-fR7vIa2U11hhkGEk,2960 +jaraco_functools-4.4.0.dist-info/RECORD,, +jaraco_functools-4.4.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +jaraco_functools-4.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91 +jaraco_functools-4.4.0.dist-info/licenses/LICENSE,sha256=WlfLTbheKi3YjCkGKJCK3VfjRRRJ4KmnH9-zh3b9dZ0,1076 +jaraco_functools-4.4.0.dist-info/top_level.txt,sha256=0JnN3LfXH4LIRfXL-QFOGCJzQWZO3ELx4R1d_louoQM,7 diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_functools-4.4.0.dist-info/REQUESTED b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_functools-4.4.0.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_functools-4.4.0.dist-info/WHEEL b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_functools-4.4.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..e7fa31b6f3f78deb1022c1f7927f07d4d16da822 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_functools-4.4.0.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: setuptools (80.9.0) +Root-Is-Purelib: true +Tag: py3-none-any + diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_functools-4.4.0.dist-info/licenses/LICENSE b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_functools-4.4.0.dist-info/licenses/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f60bd572013c6abcb3a82ba9b50d84935de6394f --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_functools-4.4.0.dist-info/licenses/LICENSE @@ -0,0 +1,18 @@ +MIT License + +Copyright (c) 2025 + +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. diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_functools-4.4.0.dist-info/top_level.txt b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_functools-4.4.0.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..f6205a5f19a533fd30f90a433e610325ff02f989 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/jaraco_functools-4.4.0.dist-info/top_level.txt @@ -0,0 +1 @@ +jaraco diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools-10.8.0.dist-info/INSTALLER b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools-10.8.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..5c69047b2eb8235994febeeae1da4a82365a240a --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools-10.8.0.dist-info/INSTALLER @@ -0,0 +1 @@ +uv \ No newline at end of file diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools-10.8.0.dist-info/METADATA b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools-10.8.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..bb7a3db109905db8cc7f1f2f5047e0b609aaf4ce --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools-10.8.0.dist-info/METADATA @@ -0,0 +1,283 @@ +Metadata-Version: 2.4 +Name: more-itertools +Version: 10.8.0 +Summary: More routines for operating on iterables, beyond itertools +Keywords: itertools,iterator,iteration,filter,peek,peekable,chunk,chunked +Author-email: Erik Rose +Requires-Python: >=3.9 +Description-Content-Type: text/x-rst +License-Expression: MIT +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: Natural Language :: English +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Programming Language :: Python :: Implementation :: CPython +Classifier: Programming Language :: Python :: Implementation :: PyPy +Classifier: Topic :: Software Development :: Libraries +License-File: LICENSE +Project-URL: Documentation, https://more-itertools.readthedocs.io/en/stable/ +Project-URL: Homepage, https://github.com/more-itertools/more-itertools + +============== +More Itertools +============== + +.. image:: https://readthedocs.org/projects/more-itertools/badge/?version=latest + :target: https://more-itertools.readthedocs.io/en/stable/ + +Python's ``itertools`` library is a gem - you can compose elegant solutions +for a variety of problems with the functions it provides. In ``more-itertools`` +we collect additional building blocks, recipes, and routines for working with +Python iterables. + ++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Grouping | `chunked `_, | +| | `ichunked `_, | +| | `chunked_even `_, | +| | `sliced `_, | +| | `constrained_batches `_, | +| | `distribute `_, | +| | `divide `_, | +| | `split_at `_, | +| | `split_before `_, | +| | `split_after `_, | +| | `split_into `_, | +| | `split_when `_, | +| | `bucket `_, | +| | `unzip `_, | +| | `batched `_, | +| | `grouper `_, | +| | `partition `_, | +| | `transpose `_ | ++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Lookahead and lookback | `spy `_, | +| | `peekable `_, | +| | `seekable `_ | ++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Windowing | `windowed `_, | +| | `substrings `_, | +| | `substrings_indexes `_, | +| | `stagger `_, | +| | `windowed_complete `_, | +| | `pairwise `_, | +| | `triplewise `_, | +| | `sliding_window `_, | +| | `subslices `_ | ++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Augmenting | `count_cycle `_, | +| | `intersperse `_, | +| | `padded `_, | +| | `repeat_each `_, | +| | `mark_ends `_, | +| | `repeat_last `_, | +| | `adjacent `_, | +| | `groupby_transform `_, | +| | `pad_none `_, | +| | `ncycles `_ | ++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Combining | `collapse `_, | +| | `sort_together `_, | +| | `interleave `_, | +| | `interleave_longest `_, | +| | `interleave_evenly `_, | +| | `interleave_randomly `_, | +| | `zip_offset `_, | +| | `zip_equal `_, | +| | `zip_broadcast `_, | +| | `flatten `_, | +| | `roundrobin `_, | +| | `prepend `_, | +| | `value_chain `_, | +| | `partial_product `_ | ++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Summarizing | `ilen `_, | +| | `unique_to_each `_, | +| | `sample `_, | +| | `consecutive_groups `_, | +| | `run_length `_, | +| | `map_reduce `_, | +| | `join_mappings `_, | +| | `exactly_n `_, | +| | `is_sorted `_, | +| | `all_equal `_, | +| | `all_unique `_, | +| | `argmin `_, | +| | `argmax `_, | +| | `minmax `_, | +| | `first_true `_, | +| | `quantify `_, | +| | `iequals `_ | ++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Selecting | `islice_extended `_, | +| | `first `_, | +| | `last `_, | +| | `one `_, | +| | `only `_, | +| | `strictly_n `_, | +| | `strip `_, | +| | `lstrip `_, | +| | `rstrip `_, | +| | `filter_except `_, | +| | `map_except `_, | +| | `filter_map `_, | +| | `iter_suppress `_, | +| | `nth_or_last `_, | +| | `extract `_, | +| | `unique_in_window `_, | +| | `before_and_after `_, | +| | `nth `_, | +| | `take `_, | +| | `tail `_, | +| | `unique_everseen `_, | +| | `unique_justseen `_, | +| | `unique `_, | +| | `duplicates_everseen `_, | +| | `duplicates_justseen `_, | +| | `classify_unique `_, | +| | `longest_common_prefix `_, | +| | `takewhile_inclusive `_ | ++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Math | `dft `_, | +| | `idft `_, | +| | `convolve `_, | +| | `dotproduct `_, | +| | `matmul `_, | +| | `polynomial_from_roots `_, | +| | `polynomial_derivative `_, | +| | `polynomial_eval `_, | +| | `sum_of_squares `_, | +| | `running_median `_, | +| | `totient `_ | ++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Integer math | `factor `_, | +| | `is_prime `_, | +| | `multinomial `_, | +| | `nth_prime `_, | +| | `sieve `_ | ++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Combinatorics | `circular_shifts `_, | +| | `derangements `_, | +| | `gray_product `_, | +| | `outer_product `_, | +| | `partitions `_, | +| | `set_partitions `_, | +| | `powerset `_, | +| | `powerset_of_sets `_ | +| +-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| | `distinct_combinations `_, | +| | `distinct_permutations `_ | +| +-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| | `combination_index `_, | +| | `combination_with_replacement_index `_, | +| | `permutation_index `_, | +| | `product_index `_ | +| +-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| | `nth_combination `_, | +| | `nth_combination_with_replacement `_, | +| | `nth_permutation `_, | +| | `nth_product `_ | +| +-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| | `random_combination `_, | +| | `random_combination_with_replacement `_, | +| | `random_permutation `_, | +| | `random_product `_ | ++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Wrapping | `always_iterable `_, | +| | `always_reversible `_, | +| | `countable `_, | +| | `consumer `_, | +| | `with_iter `_, | +| | `iter_except `_ | ++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| Others | `locate `_, | +| | `rlocate `_, | +| | `replace `_, | +| | `numeric_range `_, | +| | `side_effect `_, | +| | `iterate `_, | +| | `loops `_, | +| | `difference `_, | +| | `make_decorator `_, | +| | `SequenceView `_, | +| | `time_limited `_, | +| | `map_if `_, | +| | `iter_index `_, | +| | `consume `_, | +| | `tabulate `_, | +| | `repeatfunc `_, | +| | `reshape `_, | +| | `doublestarmap `_ | ++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ + + +Getting started +=============== + +To get started, install the library with `pip `_: + +.. code-block:: shell + + pip install more-itertools + +The recipes from the `itertools docs `_ +are included in the top-level package: + +.. code-block:: python + + >>> from more_itertools import flatten + >>> iterable = [(0, 1), (2, 3)] + >>> list(flatten(iterable)) + [0, 1, 2, 3] + +Several new recipes are available as well: + +.. code-block:: python + + >>> from more_itertools import chunked + >>> iterable = [0, 1, 2, 3, 4, 5, 6, 7, 8] + >>> list(chunked(iterable, 3)) + [[0, 1, 2], [3, 4, 5], [6, 7, 8]] + + >>> from more_itertools import spy + >>> iterable = (x * x for x in range(1, 6)) + >>> head, iterable = spy(iterable, n=3) + >>> list(head) + [1, 4, 9] + >>> list(iterable) + [1, 4, 9, 16, 25] + + + +For the full listing of functions, see the `API documentation `_. + + +Links elsewhere +=============== + +Blog posts about ``more-itertools``: + +* `Yo, I heard you like decorators `__ +* `Tour of Python Itertools `__ (`Alternate `__) +* `Real-World Python More Itertools `_ + + +Development +=========== + +``more-itertools`` is maintained by `@erikrose `_ +and `@bbayles `_, with help from `many others `_. +If you have a problem or suggestion, please file a bug or pull request in this +repository. Thanks for contributing! + + +Version History +=============== + +The version history can be found in `documentation `_. + diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools-10.8.0.dist-info/RECORD b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools-10.8.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..61ef7d6dd02d0a26d3373299cd2efa792fb23165 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools-10.8.0.dist-info/RECORD @@ -0,0 +1,13 @@ +more_itertools-10.8.0.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2 +more_itertools-10.8.0.dist-info/METADATA,sha256=arNRUUWr5YsGfwh8hnYxz0z11lP-2BuWQu4SCGw5BLg,39413 +more_itertools-10.8.0.dist-info/RECORD,, +more_itertools-10.8.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +more_itertools-10.8.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82 +more_itertools-10.8.0.dist-info/licenses/LICENSE,sha256=CfHIyelBrz5YTVlkHqm4fYPAyw_QB-te85Gn4mQ8GkY,1053 +more_itertools/__init__.py,sha256=5F7E_zpoGcEBW_T_3WE0WYYt8j-gJodIuiBcOJxrOv8,149 +more_itertools/__init__.pyi,sha256=5B3eTzON1BBuOLob1vCflyEb2lSd6usXQQ-Cv-hXkeA,43 +more_itertools/more.py,sha256=mNPKKu5UI7lRL460vgm0QTCWFiGMVCMosSPxVSdibos,163690 +more_itertools/more.pyi,sha256=fpEgNX3O66wY5cnT-s5VYDKNUpAcaCyU3iP84It3OOM,27119 +more_itertools/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +more_itertools/recipes.py,sha256=Ma-kuBNZDFhaQDbIJgRmnrG86WzaupbOyUV3v8je3xw,41811 +more_itertools/recipes.pyi,sha256=LNRwN-OL3nkMfQAqx-PPc1fBaetUObb_Z6mdePyzh1c,6226 diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools-10.8.0.dist-info/REQUESTED b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools-10.8.0.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools-10.8.0.dist-info/WHEEL b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools-10.8.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..d8b9936dad9ab2513fa6979f411560d3b6b57e37 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools-10.8.0.dist-info/WHEEL @@ -0,0 +1,4 @@ +Wheel-Version: 1.0 +Generator: flit 3.12.0 +Root-Is-Purelib: true +Tag: py3-none-any diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/__init__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..24216c5c1feb8b6017f71d096124e5db0aac5bd2 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/__init__.py @@ -0,0 +1,6 @@ +"""More routines for operating on iterables, beyond itertools""" + +from .more import * # noqa +from .recipes import * # noqa + +__version__ = '10.8.0' diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/__init__.pyi b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/__init__.pyi new file mode 100644 index 0000000000000000000000000000000000000000..96f6e36c7f4ac9ea0aebdcd9e11b8d1ff092d2ef --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/__init__.pyi @@ -0,0 +1,2 @@ +from .more import * +from .recipes import * diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..130e2affcb5d7989296d508e5fd1971832885d09 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/__pycache__/__init__.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/__pycache__/recipes.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/__pycache__/recipes.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2e84a7f498a58756abf648a64c4f6c5865009103 Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/__pycache__/recipes.cpython-312.pyc differ diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/more.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/more.py new file mode 100644 index 0000000000000000000000000000000000000000..bf501956ae6c77e7597948abdaede960ca259444 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/more.py @@ -0,0 +1,5303 @@ +import math +import warnings + +from collections import Counter, defaultdict, deque, abc +from collections.abc import Sequence +from contextlib import suppress +from functools import cached_property, partial, reduce, wraps +from heapq import heapify, heapreplace +from itertools import ( + chain, + combinations, + compress, + count, + cycle, + dropwhile, + groupby, + islice, + permutations, + repeat, + starmap, + takewhile, + tee, + zip_longest, + product, +) +from math import comb, e, exp, factorial, floor, fsum, log, log1p, perm, tau +from math import ceil +from queue import Empty, Queue +from random import random, randrange, shuffle, uniform +from operator import ( + attrgetter, + is_not, + itemgetter, + lt, + mul, + neg, + sub, + gt, +) +from sys import hexversion, maxsize +from time import monotonic + +from .recipes import ( + _marker, + _zip_equal, + UnequalIterablesError, + consume, + first_true, + flatten, + is_prime, + nth, + powerset, + sieve, + take, + unique_everseen, + all_equal, + batched, +) + +__all__ = [ + 'AbortThread', + 'SequenceView', + 'UnequalIterablesError', + 'adjacent', + 'all_unique', + 'always_iterable', + 'always_reversible', + 'argmax', + 'argmin', + 'bucket', + 'callback_iter', + 'chunked', + 'chunked_even', + 'circular_shifts', + 'collapse', + 'combination_index', + 'combination_with_replacement_index', + 'consecutive_groups', + 'constrained_batches', + 'consumer', + 'count_cycle', + 'countable', + 'derangements', + 'dft', + 'difference', + 'distinct_combinations', + 'distinct_permutations', + 'distribute', + 'divide', + 'doublestarmap', + 'duplicates_everseen', + 'duplicates_justseen', + 'classify_unique', + 'exactly_n', + 'extract', + 'filter_except', + 'filter_map', + 'first', + 'gray_product', + 'groupby_transform', + 'ichunked', + 'iequals', + 'idft', + 'ilen', + 'interleave', + 'interleave_evenly', + 'interleave_longest', + 'interleave_randomly', + 'intersperse', + 'is_sorted', + 'islice_extended', + 'iterate', + 'iter_suppress', + 'join_mappings', + 'last', + 'locate', + 'longest_common_prefix', + 'lstrip', + 'make_decorator', + 'map_except', + 'map_if', + 'map_reduce', + 'mark_ends', + 'minmax', + 'nth_or_last', + 'nth_permutation', + 'nth_prime', + 'nth_product', + 'nth_combination_with_replacement', + 'numeric_range', + 'one', + 'only', + 'outer_product', + 'padded', + 'partial_product', + 'partitions', + 'peekable', + 'permutation_index', + 'powerset_of_sets', + 'product_index', + 'raise_', + 'repeat_each', + 'repeat_last', + 'replace', + 'rlocate', + 'rstrip', + 'run_length', + 'sample', + 'seekable', + 'set_partitions', + 'side_effect', + 'sliced', + 'sort_together', + 'split_after', + 'split_at', + 'split_before', + 'split_into', + 'split_when', + 'spy', + 'stagger', + 'strip', + 'strictly_n', + 'substrings', + 'substrings_indexes', + 'takewhile_inclusive', + 'time_limited', + 'unique_in_window', + 'unique_to_each', + 'unzip', + 'value_chain', + 'windowed', + 'windowed_complete', + 'with_iter', + 'zip_broadcast', + 'zip_equal', + 'zip_offset', +] + +# math.sumprod is available for Python 3.12+ +try: + from math import sumprod as _fsumprod + +except ImportError: # pragma: no cover + # Extended precision algorithms from T. J. Dekker, + # "A Floating-Point Technique for Extending the Available Precision" + # https://csclub.uwaterloo.ca/~pbarfuss/dekker1971.pdf + # Formulas: (5.5) (5.6) and (5.8). Code: mul12() + + def dl_split(x: float): + "Split a float into two half-precision components." + t = x * 134217729.0 # Veltkamp constant = 2.0 ** 27 + 1 + hi = t - (t - x) + lo = x - hi + return hi, lo + + def dl_mul(x, y): + "Lossless multiplication." + xx_hi, xx_lo = dl_split(x) + yy_hi, yy_lo = dl_split(y) + p = xx_hi * yy_hi + q = xx_hi * yy_lo + xx_lo * yy_hi + z = p + q + zz = p - z + q + xx_lo * yy_lo + return z, zz + + def _fsumprod(p, q): + return fsum(chain.from_iterable(map(dl_mul, p, q))) + + +def chunked(iterable, n, strict=False): + """Break *iterable* into lists of length *n*: + + >>> list(chunked([1, 2, 3, 4, 5, 6], 3)) + [[1, 2, 3], [4, 5, 6]] + + By the default, the last yielded list will have fewer than *n* elements + if the length of *iterable* is not divisible by *n*: + + >>> list(chunked([1, 2, 3, 4, 5, 6, 7, 8], 3)) + [[1, 2, 3], [4, 5, 6], [7, 8]] + + To use a fill-in value instead, see the :func:`grouper` recipe. + + If the length of *iterable* is not divisible by *n* and *strict* is + ``True``, then ``ValueError`` will be raised before the last + list is yielded. + + """ + iterator = iter(partial(take, n, iter(iterable)), []) + if strict: + if n is None: + raise ValueError('n must not be None when using strict mode.') + + def ret(): + for chunk in iterator: + if len(chunk) != n: + raise ValueError('iterable is not divisible by n.') + yield chunk + + return ret() + else: + return iterator + + +def first(iterable, default=_marker): + """Return the first item of *iterable*, or *default* if *iterable* is + empty. + + >>> first([0, 1, 2, 3]) + 0 + >>> first([], 'some default') + 'some default' + + If *default* is not provided and there are no items in the iterable, + raise ``ValueError``. + + :func:`first` is useful when you have a generator of expensive-to-retrieve + values and want any arbitrary one. It is marginally shorter than + ``next(iter(iterable), default)``. + + """ + for item in iterable: + return item + if default is _marker: + raise ValueError( + 'first() was called on an empty iterable, ' + 'and no default value was provided.' + ) + return default + + +def last(iterable, default=_marker): + """Return the last item of *iterable*, or *default* if *iterable* is + empty. + + >>> last([0, 1, 2, 3]) + 3 + >>> last([], 'some default') + 'some default' + + If *default* is not provided and there are no items in the iterable, + raise ``ValueError``. + """ + try: + if isinstance(iterable, Sequence): + return iterable[-1] + # Work around https://bugs.python.org/issue38525 + if getattr(iterable, '__reversed__', None): + return next(reversed(iterable)) + return deque(iterable, maxlen=1)[-1] + except (IndexError, TypeError, StopIteration): + if default is _marker: + raise ValueError( + 'last() was called on an empty iterable, ' + 'and no default value was provided.' + ) + return default + + +def nth_or_last(iterable, n, default=_marker): + """Return the nth or the last item of *iterable*, + or *default* if *iterable* is empty. + + >>> nth_or_last([0, 1, 2, 3], 2) + 2 + >>> nth_or_last([0, 1], 2) + 1 + >>> nth_or_last([], 0, 'some default') + 'some default' + + If *default* is not provided and there are no items in the iterable, + raise ``ValueError``. + """ + return last(islice(iterable, n + 1), default=default) + + +class peekable: + """Wrap an iterator to allow lookahead and prepending elements. + + Call :meth:`peek` on the result to get the value that will be returned + by :func:`next`. This won't advance the iterator: + + >>> p = peekable(['a', 'b']) + >>> p.peek() + 'a' + >>> next(p) + 'a' + + Pass :meth:`peek` a default value to return that instead of raising + ``StopIteration`` when the iterator is exhausted. + + >>> p = peekable([]) + >>> p.peek('hi') + 'hi' + + peekables also offer a :meth:`prepend` method, which "inserts" items + at the head of the iterable: + + >>> p = peekable([1, 2, 3]) + >>> p.prepend(10, 11, 12) + >>> next(p) + 10 + >>> p.peek() + 11 + >>> list(p) + [11, 12, 1, 2, 3] + + peekables can be indexed. Index 0 is the item that will be returned by + :func:`next`, index 1 is the item after that, and so on: + The values up to the given index will be cached. + + >>> p = peekable(['a', 'b', 'c', 'd']) + >>> p[0] + 'a' + >>> p[1] + 'b' + >>> next(p) + 'a' + + Negative indexes are supported, but be aware that they will cache the + remaining items in the source iterator, which may require significant + storage. + + To check whether a peekable is exhausted, check its truth value: + + >>> p = peekable(['a', 'b']) + >>> if p: # peekable has items + ... list(p) + ['a', 'b'] + >>> if not p: # peekable is exhausted + ... list(p) + [] + + """ + + def __init__(self, iterable): + self._it = iter(iterable) + self._cache = deque() + + def __iter__(self): + return self + + def __bool__(self): + try: + self.peek() + except StopIteration: + return False + return True + + def peek(self, default=_marker): + """Return the item that will be next returned from ``next()``. + + Return ``default`` if there are no items left. If ``default`` is not + provided, raise ``StopIteration``. + + """ + if not self._cache: + try: + self._cache.append(next(self._it)) + except StopIteration: + if default is _marker: + raise + return default + return self._cache[0] + + def prepend(self, *items): + """Stack up items to be the next ones returned from ``next()`` or + ``self.peek()``. The items will be returned in + first in, first out order:: + + >>> p = peekable([1, 2, 3]) + >>> p.prepend(10, 11, 12) + >>> next(p) + 10 + >>> list(p) + [11, 12, 1, 2, 3] + + It is possible, by prepending items, to "resurrect" a peekable that + previously raised ``StopIteration``. + + >>> p = peekable([]) + >>> next(p) + Traceback (most recent call last): + ... + StopIteration + >>> p.prepend(1) + >>> next(p) + 1 + >>> next(p) + Traceback (most recent call last): + ... + StopIteration + + """ + self._cache.extendleft(reversed(items)) + + def __next__(self): + if self._cache: + return self._cache.popleft() + + return next(self._it) + + def _get_slice(self, index): + # Normalize the slice's arguments + step = 1 if (index.step is None) else index.step + if step > 0: + start = 0 if (index.start is None) else index.start + stop = maxsize if (index.stop is None) else index.stop + elif step < 0: + start = -1 if (index.start is None) else index.start + stop = (-maxsize - 1) if (index.stop is None) else index.stop + else: + raise ValueError('slice step cannot be zero') + + # If either the start or stop index is negative, we'll need to cache + # the rest of the iterable in order to slice from the right side. + if (start < 0) or (stop < 0): + self._cache.extend(self._it) + # Otherwise we'll need to find the rightmost index and cache to that + # point. + else: + n = min(max(start, stop) + 1, maxsize) + cache_len = len(self._cache) + if n >= cache_len: + self._cache.extend(islice(self._it, n - cache_len)) + + return list(self._cache)[index] + + def __getitem__(self, index): + if isinstance(index, slice): + return self._get_slice(index) + + cache_len = len(self._cache) + if index < 0: + self._cache.extend(self._it) + elif index >= cache_len: + self._cache.extend(islice(self._it, index + 1 - cache_len)) + + return self._cache[index] + + +def consumer(func): + """Decorator that automatically advances a PEP-342-style "reverse iterator" + to its first yield point so you don't have to call ``next()`` on it + manually. + + >>> @consumer + ... def tally(): + ... i = 0 + ... while True: + ... print('Thing number %s is %s.' % (i, (yield))) + ... i += 1 + ... + >>> t = tally() + >>> t.send('red') + Thing number 0 is red. + >>> t.send('fish') + Thing number 1 is fish. + + Without the decorator, you would have to call ``next(t)`` before + ``t.send()`` could be used. + + """ + + @wraps(func) + def wrapper(*args, **kwargs): + gen = func(*args, **kwargs) + next(gen) + return gen + + return wrapper + + +def ilen(iterable): + """Return the number of items in *iterable*. + + For example, there are 168 prime numbers below 1,000: + + >>> ilen(sieve(1000)) + 168 + + Equivalent to, but faster than:: + + def ilen(iterable): + count = 0 + for _ in iterable: + count += 1 + return count + + This fully consumes the iterable, so handle with care. + + """ + # This is the "most beautiful of the fast variants" of this function. + # If you think you can improve on it, please ensure that your version + # is both 10x faster and 10x more beautiful. + return sum(compress(repeat(1), zip(iterable))) + + +def iterate(func, start): + """Return ``start``, ``func(start)``, ``func(func(start))``, ... + + Produces an infinite iterator. To add a stopping condition, + use :func:`take`, ``takewhile``, or :func:`takewhile_inclusive`:. + + >>> take(10, iterate(lambda x: 2*x, 1)) + [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] + + >>> collatz = lambda x: 3*x + 1 if x%2==1 else x // 2 + >>> list(takewhile_inclusive(lambda x: x!=1, iterate(collatz, 10))) + [10, 5, 16, 8, 4, 2, 1] + + """ + with suppress(StopIteration): + while True: + yield start + start = func(start) + + +def with_iter(context_manager): + """Wrap an iterable in a ``with`` statement, so it closes once exhausted. + + For example, this will close the file when the iterator is exhausted:: + + upper_lines = (line.upper() for line in with_iter(open('foo'))) + + Any context manager which returns an iterable is a candidate for + ``with_iter``. + + """ + with context_manager as iterable: + yield from iterable + + +def one(iterable, too_short=None, too_long=None): + """Return the first item from *iterable*, which is expected to contain only + that item. Raise an exception if *iterable* is empty or has more than one + item. + + :func:`one` is useful for ensuring that an iterable contains only one item. + For example, it can be used to retrieve the result of a database query + that is expected to return a single row. + + If *iterable* is empty, ``ValueError`` will be raised. You may specify a + different exception with the *too_short* keyword: + + >>> it = [] + >>> one(it) # doctest: +IGNORE_EXCEPTION_DETAIL + Traceback (most recent call last): + ... + ValueError: too few items in iterable (expected 1)' + >>> too_short = IndexError('too few items') + >>> one(it, too_short=too_short) # doctest: +IGNORE_EXCEPTION_DETAIL + Traceback (most recent call last): + ... + IndexError: too few items + + Similarly, if *iterable* contains more than one item, ``ValueError`` will + be raised. You may specify a different exception with the *too_long* + keyword: + + >>> it = ['too', 'many'] + >>> one(it) # doctest: +IGNORE_EXCEPTION_DETAIL + Traceback (most recent call last): + ... + ValueError: Expected exactly one item in iterable, but got 'too', + 'many', and perhaps more. + >>> too_long = RuntimeError + >>> one(it, too_long=too_long) # doctest: +IGNORE_EXCEPTION_DETAIL + Traceback (most recent call last): + ... + RuntimeError + + Note that :func:`one` attempts to advance *iterable* twice to ensure there + is only one item. See :func:`spy` or :func:`peekable` to check iterable + contents less destructively. + + """ + iterator = iter(iterable) + for first in iterator: + for second in iterator: + msg = ( + f'Expected exactly one item in iterable, but got {first!r}, ' + f'{second!r}, and perhaps more.' + ) + raise too_long or ValueError(msg) + return first + raise too_short or ValueError('too few items in iterable (expected 1)') + + +def raise_(exception, *args): + raise exception(*args) + + +def strictly_n(iterable, n, too_short=None, too_long=None): + """Validate that *iterable* has exactly *n* items and return them if + it does. If it has fewer than *n* items, call function *too_short* + with the actual number of items. If it has more than *n* items, call function + *too_long* with the number ``n + 1``. + + >>> iterable = ['a', 'b', 'c', 'd'] + >>> n = 4 + >>> list(strictly_n(iterable, n)) + ['a', 'b', 'c', 'd'] + + Note that the returned iterable must be consumed in order for the check to + be made. + + By default, *too_short* and *too_long* are functions that raise + ``ValueError``. + + >>> list(strictly_n('ab', 3)) # doctest: +IGNORE_EXCEPTION_DETAIL + Traceback (most recent call last): + ... + ValueError: too few items in iterable (got 2) + + >>> list(strictly_n('abc', 2)) # doctest: +IGNORE_EXCEPTION_DETAIL + Traceback (most recent call last): + ... + ValueError: too many items in iterable (got at least 3) + + You can instead supply functions that do something else. + *too_short* will be called with the number of items in *iterable*. + *too_long* will be called with `n + 1`. + + >>> def too_short(item_count): + ... raise RuntimeError + >>> it = strictly_n('abcd', 6, too_short=too_short) + >>> list(it) # doctest: +IGNORE_EXCEPTION_DETAIL + Traceback (most recent call last): + ... + RuntimeError + + >>> def too_long(item_count): + ... print('The boss is going to hear about this') + >>> it = strictly_n('abcdef', 4, too_long=too_long) + >>> list(it) + The boss is going to hear about this + ['a', 'b', 'c', 'd'] + + """ + if too_short is None: + too_short = lambda item_count: raise_( + ValueError, + f'Too few items in iterable (got {item_count})', + ) + + if too_long is None: + too_long = lambda item_count: raise_( + ValueError, + f'Too many items in iterable (got at least {item_count})', + ) + + it = iter(iterable) + + sent = 0 + for item in islice(it, n): + yield item + sent += 1 + + if sent < n: + too_short(sent) + return + + for item in it: + too_long(n + 1) + return + + +def distinct_permutations(iterable, r=None): + """Yield successive distinct permutations of the elements in *iterable*. + + >>> sorted(distinct_permutations([1, 0, 1])) + [(0, 1, 1), (1, 0, 1), (1, 1, 0)] + + Equivalent to yielding from ``set(permutations(iterable))``, except + duplicates are not generated and thrown away. For larger input sequences + this is much more efficient. + + Duplicate permutations arise when there are duplicated elements in the + input iterable. The number of items returned is + `n! / (x_1! * x_2! * ... * x_n!)`, where `n` is the total number of + items input, and each `x_i` is the count of a distinct item in the input + sequence. The function :func:`multinomial` computes this directly. + + If *r* is given, only the *r*-length permutations are yielded. + + >>> sorted(distinct_permutations([1, 0, 1], r=2)) + [(0, 1), (1, 0), (1, 1)] + >>> sorted(distinct_permutations(range(3), r=2)) + [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)] + + *iterable* need not be sortable, but note that using equal (``x == y``) + but non-identical (``id(x) != id(y)``) elements may produce surprising + behavior. For example, ``1`` and ``True`` are equal but non-identical: + + >>> list(distinct_permutations([1, True, '3'])) # doctest: +SKIP + [ + (1, True, '3'), + (1, '3', True), + ('3', 1, True) + ] + >>> list(distinct_permutations([1, 2, '3'])) # doctest: +SKIP + [ + (1, 2, '3'), + (1, '3', 2), + (2, 1, '3'), + (2, '3', 1), + ('3', 1, 2), + ('3', 2, 1) + ] + """ + + # Algorithm: https://w.wiki/Qai + def _full(A): + while True: + # Yield the permutation we have + yield tuple(A) + + # Find the largest index i such that A[i] < A[i + 1] + for i in range(size - 2, -1, -1): + if A[i] < A[i + 1]: + break + # If no such index exists, this permutation is the last one + else: + return + + # Find the largest index j greater than j such that A[i] < A[j] + for j in range(size - 1, i, -1): + if A[i] < A[j]: + break + + # Swap the value of A[i] with that of A[j], then reverse the + # sequence from A[i + 1] to form the new permutation + A[i], A[j] = A[j], A[i] + A[i + 1 :] = A[: i - size : -1] # A[i + 1:][::-1] + + # Algorithm: modified from the above + def _partial(A, r): + # Split A into the first r items and the last r items + head, tail = A[:r], A[r:] + right_head_indexes = range(r - 1, -1, -1) + left_tail_indexes = range(len(tail)) + + while True: + # Yield the permutation we have + yield tuple(head) + + # Starting from the right, find the first index of the head with + # value smaller than the maximum value of the tail - call it i. + pivot = tail[-1] + for i in right_head_indexes: + if head[i] < pivot: + break + pivot = head[i] + else: + return + + # Starting from the left, find the first value of the tail + # with a value greater than head[i] and swap. + for j in left_tail_indexes: + if tail[j] > head[i]: + head[i], tail[j] = tail[j], head[i] + break + # If we didn't find one, start from the right and find the first + # index of the head with a value greater than head[i] and swap. + else: + for j in right_head_indexes: + if head[j] > head[i]: + head[i], head[j] = head[j], head[i] + break + + # Reverse head[i + 1:] and swap it with tail[:r - (i + 1)] + tail += head[: i - r : -1] # head[i + 1:][::-1] + i += 1 + head[i:], tail[:] = tail[: r - i], tail[r - i :] + + items = list(iterable) + + try: + items.sort() + sortable = True + except TypeError: + sortable = False + + indices_dict = defaultdict(list) + + for item in items: + indices_dict[items.index(item)].append(item) + + indices = [items.index(item) for item in items] + indices.sort() + + equivalent_items = {k: cycle(v) for k, v in indices_dict.items()} + + def permuted_items(permuted_indices): + return tuple( + next(equivalent_items[index]) for index in permuted_indices + ) + + size = len(items) + if r is None: + r = size + + # functools.partial(_partial, ... ) + algorithm = _full if (r == size) else partial(_partial, r=r) + + if 0 < r <= size: + if sortable: + return algorithm(items) + else: + return ( + permuted_items(permuted_indices) + for permuted_indices in algorithm(indices) + ) + + return iter(() if r else ((),)) + + +def derangements(iterable, r=None): + """Yield successive derangements of the elements in *iterable*. + + A derangement is a permutation in which no element appears at its original + index. In other words, a derangement is a permutation that has no fixed points. + + Suppose Alice, Bob, Carol, and Dave are playing Secret Santa. + The code below outputs all of the different ways to assign gift recipients + such that nobody is assigned to himself or herself: + + >>> for d in derangements(['Alice', 'Bob', 'Carol', 'Dave']): + ... print(', '.join(d)) + Bob, Alice, Dave, Carol + Bob, Carol, Dave, Alice + Bob, Dave, Alice, Carol + Carol, Alice, Dave, Bob + Carol, Dave, Alice, Bob + Carol, Dave, Bob, Alice + Dave, Alice, Bob, Carol + Dave, Carol, Alice, Bob + Dave, Carol, Bob, Alice + + If *r* is given, only the *r*-length derangements are yielded. + + >>> sorted(derangements(range(3), 2)) + [(1, 0), (1, 2), (2, 0)] + >>> sorted(derangements([0, 2, 3], 2)) + [(2, 0), (2, 3), (3, 0)] + + Elements are treated as unique based on their position, not on their value. + + Consider the Secret Santa example with two *different* people who have + the *same* name. Then there are two valid gift assignments even though + it might appear that a person is assigned to themselves: + + >>> names = ['Alice', 'Bob', 'Bob'] + >>> list(derangements(names)) + [('Bob', 'Bob', 'Alice'), ('Bob', 'Alice', 'Bob')] + + To avoid confusion, make the inputs distinct: + + >>> deduped = [f'{name}{index}' for index, name in enumerate(names)] + >>> list(derangements(deduped)) + [('Bob1', 'Bob2', 'Alice0'), ('Bob2', 'Alice0', 'Bob1')] + + The number of derangements of a set of size *n* is known as the + "subfactorial of n". For n > 0, the subfactorial is: + ``round(math.factorial(n) / math.e)``. + + References: + + * Article: https://www.numberanalytics.com/blog/ultimate-guide-to-derangements-in-combinatorics + * Sizes: https://oeis.org/A000166 + """ + xs = tuple(iterable) + ys = tuple(range(len(xs))) + return compress( + permutations(xs, r=r), + map(all, map(map, repeat(is_not), repeat(ys), permutations(ys, r=r))), + ) + + +def intersperse(e, iterable, n=1): + """Intersperse filler element *e* among the items in *iterable*, leaving + *n* items between each filler element. + + >>> list(intersperse('!', [1, 2, 3, 4, 5])) + [1, '!', 2, '!', 3, '!', 4, '!', 5] + + >>> list(intersperse(None, [1, 2, 3, 4, 5], n=2)) + [1, 2, None, 3, 4, None, 5] + + """ + if n == 0: + raise ValueError('n must be > 0') + elif n == 1: + # interleave(repeat(e), iterable) -> e, x_0, e, x_1, e, x_2... + # islice(..., 1, None) -> x_0, e, x_1, e, x_2... + return islice(interleave(repeat(e), iterable), 1, None) + else: + # interleave(filler, chunks) -> [e], [x_0, x_1], [e], [x_2, x_3]... + # islice(..., 1, None) -> [x_0, x_1], [e], [x_2, x_3]... + # flatten(...) -> x_0, x_1, e, x_2, x_3... + filler = repeat([e]) + chunks = chunked(iterable, n) + return flatten(islice(interleave(filler, chunks), 1, None)) + + +def unique_to_each(*iterables): + """Return the elements from each of the input iterables that aren't in the + other input iterables. + + For example, suppose you have a set of packages, each with a set of + dependencies:: + + {'pkg_1': {'A', 'B'}, 'pkg_2': {'B', 'C'}, 'pkg_3': {'B', 'D'}} + + If you remove one package, which dependencies can also be removed? + + If ``pkg_1`` is removed, then ``A`` is no longer necessary - it is not + associated with ``pkg_2`` or ``pkg_3``. Similarly, ``C`` is only needed for + ``pkg_2``, and ``D`` is only needed for ``pkg_3``:: + + >>> unique_to_each({'A', 'B'}, {'B', 'C'}, {'B', 'D'}) + [['A'], ['C'], ['D']] + + If there are duplicates in one input iterable that aren't in the others + they will be duplicated in the output. Input order is preserved:: + + >>> unique_to_each("mississippi", "missouri") + [['p', 'p'], ['o', 'u', 'r']] + + It is assumed that the elements of each iterable are hashable. + + """ + pool = [list(it) for it in iterables] + counts = Counter(chain.from_iterable(map(set, pool))) + uniques = {element for element in counts if counts[element] == 1} + return [list(filter(uniques.__contains__, it)) for it in pool] + + +def windowed(seq, n, fillvalue=None, step=1): + """Return a sliding window of width *n* over the given iterable. + + >>> all_windows = windowed([1, 2, 3, 4, 5], 3) + >>> list(all_windows) + [(1, 2, 3), (2, 3, 4), (3, 4, 5)] + + When the window is larger than the iterable, *fillvalue* is used in place + of missing values: + + >>> list(windowed([1, 2, 3], 4)) + [(1, 2, 3, None)] + + Each window will advance in increments of *step*: + + >>> list(windowed([1, 2, 3, 4, 5, 6], 3, fillvalue='!', step=2)) + [(1, 2, 3), (3, 4, 5), (5, 6, '!')] + + To slide into the iterable's items, use :func:`chain` to add filler items + to the left: + + >>> iterable = [1, 2, 3, 4] + >>> n = 3 + >>> padding = [None] * (n - 1) + >>> list(windowed(chain(padding, iterable), 3)) + [(None, None, 1), (None, 1, 2), (1, 2, 3), (2, 3, 4)] + """ + if n < 0: + raise ValueError('n must be >= 0') + if n == 0: + yield () + return + if step < 1: + raise ValueError('step must be >= 1') + + iterator = iter(seq) + + # Generate first window + window = deque(islice(iterator, n), maxlen=n) + + # Deal with the first window not being full + if not window: + return + if len(window) < n: + yield tuple(window) + ((fillvalue,) * (n - len(window))) + return + yield tuple(window) + + # Create the filler for the next windows. The padding ensures + # we have just enough elements to fill the last window. + padding = (fillvalue,) * (n - 1 if step >= n else step - 1) + filler = map(window.append, chain(iterator, padding)) + + # Generate the rest of the windows + for _ in islice(filler, step - 1, None, step): + yield tuple(window) + + +def substrings(iterable): + """Yield all of the substrings of *iterable*. + + >>> [''.join(s) for s in substrings('more')] + ['m', 'o', 'r', 'e', 'mo', 'or', 're', 'mor', 'ore', 'more'] + + Note that non-string iterables can also be subdivided. + + >>> list(substrings([0, 1, 2])) + [(0,), (1,), (2,), (0, 1), (1, 2), (0, 1, 2)] + + """ + # The length-1 substrings + seq = [] + for item in iterable: + seq.append(item) + yield (item,) + seq = tuple(seq) + item_count = len(seq) + + # And the rest + for n in range(2, item_count + 1): + for i in range(item_count - n + 1): + yield seq[i : i + n] + + +def substrings_indexes(seq, reverse=False): + """Yield all substrings and their positions in *seq* + + The items yielded will be a tuple of the form ``(substr, i, j)``, where + ``substr == seq[i:j]``. + + This function only works for iterables that support slicing, such as + ``str`` objects. + + >>> for item in substrings_indexes('more'): + ... print(item) + ('m', 0, 1) + ('o', 1, 2) + ('r', 2, 3) + ('e', 3, 4) + ('mo', 0, 2) + ('or', 1, 3) + ('re', 2, 4) + ('mor', 0, 3) + ('ore', 1, 4) + ('more', 0, 4) + + Set *reverse* to ``True`` to yield the same items in the opposite order. + + + """ + r = range(1, len(seq) + 1) + if reverse: + r = reversed(r) + return ( + (seq[i : i + L], i, i + L) for L in r for i in range(len(seq) - L + 1) + ) + + +class bucket: + """Wrap *iterable* and return an object that buckets the iterable into + child iterables based on a *key* function. + + >>> iterable = ['a1', 'b1', 'c1', 'a2', 'b2', 'c2', 'b3'] + >>> s = bucket(iterable, key=lambda x: x[0]) # Bucket by 1st character + >>> sorted(list(s)) # Get the keys + ['a', 'b', 'c'] + >>> a_iterable = s['a'] + >>> next(a_iterable) + 'a1' + >>> next(a_iterable) + 'a2' + >>> list(s['b']) + ['b1', 'b2', 'b3'] + + The original iterable will be advanced and its items will be cached until + they are used by the child iterables. This may require significant storage. + + By default, attempting to select a bucket to which no items belong will + exhaust the iterable and cache all values. + If you specify a *validator* function, selected buckets will instead be + checked against it. + + >>> from itertools import count + >>> it = count(1, 2) # Infinite sequence of odd numbers + >>> key = lambda x: x % 10 # Bucket by last digit + >>> validator = lambda x: x in {1, 3, 5, 7, 9} # Odd digits only + >>> s = bucket(it, key=key, validator=validator) + >>> 2 in s + False + >>> list(s[2]) + [] + + """ + + def __init__(self, iterable, key, validator=None): + self._it = iter(iterable) + self._key = key + self._cache = defaultdict(deque) + self._validator = validator or (lambda x: True) + + def __contains__(self, value): + if not self._validator(value): + return False + + try: + item = next(self[value]) + except StopIteration: + return False + else: + self._cache[value].appendleft(item) + + return True + + def _get_values(self, value): + """ + Helper to yield items from the parent iterator that match *value*. + Items that don't match are stored in the local cache as they + are encountered. + """ + while True: + # If we've cached some items that match the target value, emit + # the first one and evict it from the cache. + if self._cache[value]: + yield self._cache[value].popleft() + # Otherwise we need to advance the parent iterator to search for + # a matching item, caching the rest. + else: + while True: + try: + item = next(self._it) + except StopIteration: + return + item_value = self._key(item) + if item_value == value: + yield item + break + elif self._validator(item_value): + self._cache[item_value].append(item) + + def __iter__(self): + for item in self._it: + item_value = self._key(item) + if self._validator(item_value): + self._cache[item_value].append(item) + + return iter(self._cache) + + def __getitem__(self, value): + if not self._validator(value): + return iter(()) + + return self._get_values(value) + + +def spy(iterable, n=1): + """Return a 2-tuple with a list containing the first *n* elements of + *iterable*, and an iterator with the same items as *iterable*. + This allows you to "look ahead" at the items in the iterable without + advancing it. + + There is one item in the list by default: + + >>> iterable = 'abcdefg' + >>> head, iterable = spy(iterable) + >>> head + ['a'] + >>> list(iterable) + ['a', 'b', 'c', 'd', 'e', 'f', 'g'] + + You may use unpacking to retrieve items instead of lists: + + >>> (head,), iterable = spy('abcdefg') + >>> head + 'a' + >>> (first, second), iterable = spy('abcdefg', 2) + >>> first + 'a' + >>> second + 'b' + + The number of items requested can be larger than the number of items in + the iterable: + + >>> iterable = [1, 2, 3, 4, 5] + >>> head, iterable = spy(iterable, 10) + >>> head + [1, 2, 3, 4, 5] + >>> list(iterable) + [1, 2, 3, 4, 5] + + """ + p, q = tee(iterable) + return take(n, q), p + + +def interleave(*iterables): + """Return a new iterable yielding from each iterable in turn, + until the shortest is exhausted. + + >>> list(interleave([1, 2, 3], [4, 5], [6, 7, 8])) + [1, 4, 6, 2, 5, 7] + + For a version that doesn't terminate after the shortest iterable is + exhausted, see :func:`interleave_longest`. + + """ + return chain.from_iterable(zip(*iterables)) + + +def interleave_longest(*iterables): + """Return a new iterable yielding from each iterable in turn, + skipping any that are exhausted. + + >>> list(interleave_longest([1, 2, 3], [4, 5], [6, 7, 8])) + [1, 4, 6, 2, 5, 7, 3, 8] + + This function produces the same output as :func:`roundrobin`, but may + perform better for some inputs (in particular when the number of iterables + is large). + + """ + for xs in zip_longest(*iterables, fillvalue=_marker): + for x in xs: + if x is not _marker: + yield x + + +def interleave_evenly(iterables, lengths=None): + """ + Interleave multiple iterables so that their elements are evenly distributed + throughout the output sequence. + + >>> iterables = [1, 2, 3, 4, 5], ['a', 'b'] + >>> list(interleave_evenly(iterables)) + [1, 2, 'a', 3, 4, 'b', 5] + + >>> iterables = [[1, 2, 3], [4, 5], [6, 7, 8]] + >>> list(interleave_evenly(iterables)) + [1, 6, 4, 2, 7, 3, 8, 5] + + This function requires iterables of known length. Iterables without + ``__len__()`` can be used by manually specifying lengths with *lengths*: + + >>> from itertools import combinations, repeat + >>> iterables = [combinations(range(4), 2), ['a', 'b', 'c']] + >>> lengths = [4 * (4 - 1) // 2, 3] + >>> list(interleave_evenly(iterables, lengths=lengths)) + [(0, 1), (0, 2), 'a', (0, 3), (1, 2), 'b', (1, 3), (2, 3), 'c'] + + Based on Bresenham's algorithm. + """ + if lengths is None: + try: + lengths = [len(it) for it in iterables] + except TypeError: + raise ValueError( + 'Iterable lengths could not be determined automatically. ' + 'Specify them with the lengths keyword.' + ) + elif len(iterables) != len(lengths): + raise ValueError('Mismatching number of iterables and lengths.') + + dims = len(lengths) + + # sort iterables by length, descending + lengths_permute = sorted( + range(dims), key=lambda i: lengths[i], reverse=True + ) + lengths_desc = [lengths[i] for i in lengths_permute] + iters_desc = [iter(iterables[i]) for i in lengths_permute] + + # the longest iterable is the primary one (Bresenham: the longest + # distance along an axis) + delta_primary, deltas_secondary = lengths_desc[0], lengths_desc[1:] + iter_primary, iters_secondary = iters_desc[0], iters_desc[1:] + errors = [delta_primary // dims] * len(deltas_secondary) + + to_yield = sum(lengths) + while to_yield: + yield next(iter_primary) + to_yield -= 1 + # update errors for each secondary iterable + errors = [e - delta for e, delta in zip(errors, deltas_secondary)] + + # those iterables for which the error is negative are yielded + # ("diagonal step" in Bresenham) + for i, e_ in enumerate(errors): + if e_ < 0: + yield next(iters_secondary[i]) + to_yield -= 1 + errors[i] += delta_primary + + +def interleave_randomly(*iterables): + """Repeatedly select one of the input *iterables* at random and yield the next + item from it. + + >>> iterables = [1, 2, 3], 'abc', (True, False, None) + >>> list(interleave_randomly(*iterables)) # doctest: +SKIP + ['a', 'b', 1, 'c', True, False, None, 2, 3] + + The relative order of the items in each input iterable will preserved. Note the + sequences of items with this property are not equally likely to be generated. + + """ + iterators = [iter(e) for e in iterables] + while iterators: + idx = randrange(len(iterators)) + try: + yield next(iterators[idx]) + except StopIteration: + # equivalent to `list.pop` but slightly faster + iterators[idx] = iterators[-1] + del iterators[-1] + + +def collapse(iterable, base_type=None, levels=None): + """Flatten an iterable with multiple levels of nesting (e.g., a list of + lists of tuples) into non-iterable types. + + >>> iterable = [(1, 2), ([3, 4], [[5], [6]])] + >>> list(collapse(iterable)) + [1, 2, 3, 4, 5, 6] + + Binary and text strings are not considered iterable and + will not be collapsed. + + To avoid collapsing other types, specify *base_type*: + + >>> iterable = ['ab', ('cd', 'ef'), ['gh', 'ij']] + >>> list(collapse(iterable, base_type=tuple)) + ['ab', ('cd', 'ef'), 'gh', 'ij'] + + Specify *levels* to stop flattening after a certain level: + + >>> iterable = [('a', ['b']), ('c', ['d'])] + >>> list(collapse(iterable)) # Fully flattened + ['a', 'b', 'c', 'd'] + >>> list(collapse(iterable, levels=1)) # Only one level flattened + ['a', ['b'], 'c', ['d']] + + """ + stack = deque() + # Add our first node group, treat the iterable as a single node + stack.appendleft((0, repeat(iterable, 1))) + + while stack: + node_group = stack.popleft() + level, nodes = node_group + + # Check if beyond max level + if levels is not None and level > levels: + yield from nodes + continue + + for node in nodes: + # Check if done iterating + if isinstance(node, (str, bytes)) or ( + (base_type is not None) and isinstance(node, base_type) + ): + yield node + # Otherwise try to create child nodes + else: + try: + tree = iter(node) + except TypeError: + yield node + else: + # Save our current location + stack.appendleft(node_group) + # Append the new child node + stack.appendleft((level + 1, tree)) + # Break to process child node + break + + +def side_effect(func, iterable, chunk_size=None, before=None, after=None): + """Invoke *func* on each item in *iterable* (or on each *chunk_size* group + of items) before yielding the item. + + `func` must be a function that takes a single argument. Its return value + will be discarded. + + *before* and *after* are optional functions that take no arguments. They + will be executed before iteration starts and after it ends, respectively. + + `side_effect` can be used for logging, updating progress bars, or anything + that is not functionally "pure." + + Emitting a status message: + + >>> from more_itertools import consume + >>> func = lambda item: print('Received {}'.format(item)) + >>> consume(side_effect(func, range(2))) + Received 0 + Received 1 + + Operating on chunks of items: + + >>> pair_sums = [] + >>> func = lambda chunk: pair_sums.append(sum(chunk)) + >>> list(side_effect(func, [0, 1, 2, 3, 4, 5], 2)) + [0, 1, 2, 3, 4, 5] + >>> list(pair_sums) + [1, 5, 9] + + Writing to a file-like object: + + >>> from io import StringIO + >>> from more_itertools import consume + >>> f = StringIO() + >>> func = lambda x: print(x, file=f) + >>> before = lambda: print(u'HEADER', file=f) + >>> after = f.close + >>> it = [u'a', u'b', u'c'] + >>> consume(side_effect(func, it, before=before, after=after)) + >>> f.closed + True + + """ + try: + if before is not None: + before() + + if chunk_size is None: + for item in iterable: + func(item) + yield item + else: + for chunk in chunked(iterable, chunk_size): + func(chunk) + yield from chunk + finally: + if after is not None: + after() + + +def sliced(seq, n, strict=False): + """Yield slices of length *n* from the sequence *seq*. + + >>> list(sliced((1, 2, 3, 4, 5, 6), 3)) + [(1, 2, 3), (4, 5, 6)] + + By the default, the last yielded slice will have fewer than *n* elements + if the length of *seq* is not divisible by *n*: + + >>> list(sliced((1, 2, 3, 4, 5, 6, 7, 8), 3)) + [(1, 2, 3), (4, 5, 6), (7, 8)] + + If the length of *seq* is not divisible by *n* and *strict* is + ``True``, then ``ValueError`` will be raised before the last + slice is yielded. + + This function will only work for iterables that support slicing. + For non-sliceable iterables, see :func:`chunked`. + + """ + iterator = takewhile(len, (seq[i : i + n] for i in count(0, n))) + if strict: + + def ret(): + for _slice in iterator: + if len(_slice) != n: + raise ValueError("seq is not divisible by n.") + yield _slice + + return ret() + else: + return iterator + + +def split_at(iterable, pred, maxsplit=-1, keep_separator=False): + """Yield lists of items from *iterable*, where each list is delimited by + an item where callable *pred* returns ``True``. + + >>> list(split_at('abcdcba', lambda x: x == 'b')) + [['a'], ['c', 'd', 'c'], ['a']] + + >>> list(split_at(range(10), lambda n: n % 2 == 1)) + [[0], [2], [4], [6], [8], []] + + At most *maxsplit* splits are done. If *maxsplit* is not specified or -1, + then there is no limit on the number of splits: + + >>> list(split_at(range(10), lambda n: n % 2 == 1, maxsplit=2)) + [[0], [2], [4, 5, 6, 7, 8, 9]] + + By default, the delimiting items are not included in the output. + To include them, set *keep_separator* to ``True``. + + >>> list(split_at('abcdcba', lambda x: x == 'b', keep_separator=True)) + [['a'], ['b'], ['c', 'd', 'c'], ['b'], ['a']] + + """ + if maxsplit == 0: + yield list(iterable) + return + + buf = [] + it = iter(iterable) + for item in it: + if pred(item): + yield buf + if keep_separator: + yield [item] + if maxsplit == 1: + yield list(it) + return + buf = [] + maxsplit -= 1 + else: + buf.append(item) + yield buf + + +def split_before(iterable, pred, maxsplit=-1): + """Yield lists of items from *iterable*, where each list ends just before + an item for which callable *pred* returns ``True``: + + >>> list(split_before('OneTwo', lambda s: s.isupper())) + [['O', 'n', 'e'], ['T', 'w', 'o']] + + >>> list(split_before(range(10), lambda n: n % 3 == 0)) + [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]] + + At most *maxsplit* splits are done. If *maxsplit* is not specified or -1, + then there is no limit on the number of splits: + + >>> list(split_before(range(10), lambda n: n % 3 == 0, maxsplit=2)) + [[0, 1, 2], [3, 4, 5], [6, 7, 8, 9]] + """ + if maxsplit == 0: + yield list(iterable) + return + + buf = [] + it = iter(iterable) + for item in it: + if pred(item) and buf: + yield buf + if maxsplit == 1: + yield [item, *it] + return + buf = [] + maxsplit -= 1 + buf.append(item) + if buf: + yield buf + + +def split_after(iterable, pred, maxsplit=-1): + """Yield lists of items from *iterable*, where each list ends with an + item where callable *pred* returns ``True``: + + >>> list(split_after('one1two2', lambda s: s.isdigit())) + [['o', 'n', 'e', '1'], ['t', 'w', 'o', '2']] + + >>> list(split_after(range(10), lambda n: n % 3 == 0)) + [[0], [1, 2, 3], [4, 5, 6], [7, 8, 9]] + + At most *maxsplit* splits are done. If *maxsplit* is not specified or -1, + then there is no limit on the number of splits: + + >>> list(split_after(range(10), lambda n: n % 3 == 0, maxsplit=2)) + [[0], [1, 2, 3], [4, 5, 6, 7, 8, 9]] + + """ + if maxsplit == 0: + yield list(iterable) + return + + buf = [] + it = iter(iterable) + for item in it: + buf.append(item) + if pred(item) and buf: + yield buf + if maxsplit == 1: + buf = list(it) + if buf: + yield buf + return + buf = [] + maxsplit -= 1 + if buf: + yield buf + + +def split_when(iterable, pred, maxsplit=-1): + """Split *iterable* into pieces based on the output of *pred*. + *pred* should be a function that takes successive pairs of items and + returns ``True`` if the iterable should be split in between them. + + For example, to find runs of increasing numbers, split the iterable when + element ``i`` is larger than element ``i + 1``: + + >>> list(split_when([1, 2, 3, 3, 2, 5, 2, 4, 2], lambda x, y: x > y)) + [[1, 2, 3, 3], [2, 5], [2, 4], [2]] + + At most *maxsplit* splits are done. If *maxsplit* is not specified or -1, + then there is no limit on the number of splits: + + >>> list(split_when([1, 2, 3, 3, 2, 5, 2, 4, 2], + ... lambda x, y: x > y, maxsplit=2)) + [[1, 2, 3, 3], [2, 5], [2, 4, 2]] + + """ + if maxsplit == 0: + yield list(iterable) + return + + it = iter(iterable) + try: + cur_item = next(it) + except StopIteration: + return + + buf = [cur_item] + for next_item in it: + if pred(cur_item, next_item): + yield buf + if maxsplit == 1: + yield [next_item, *it] + return + buf = [] + maxsplit -= 1 + + buf.append(next_item) + cur_item = next_item + + yield buf + + +def split_into(iterable, sizes): + """Yield a list of sequential items from *iterable* of length 'n' for each + integer 'n' in *sizes*. + + >>> list(split_into([1,2,3,4,5,6], [1,2,3])) + [[1], [2, 3], [4, 5, 6]] + + If the sum of *sizes* is smaller than the length of *iterable*, then the + remaining items of *iterable* will not be returned. + + >>> list(split_into([1,2,3,4,5,6], [2,3])) + [[1, 2], [3, 4, 5]] + + If the sum of *sizes* is larger than the length of *iterable*, fewer items + will be returned in the iteration that overruns the *iterable* and further + lists will be empty: + + >>> list(split_into([1,2,3,4], [1,2,3,4])) + [[1], [2, 3], [4], []] + + When a ``None`` object is encountered in *sizes*, the returned list will + contain items up to the end of *iterable* the same way that + :func:`itertools.slice` does: + + >>> list(split_into([1,2,3,4,5,6,7,8,9,0], [2,3,None])) + [[1, 2], [3, 4, 5], [6, 7, 8, 9, 0]] + + :func:`split_into` can be useful for grouping a series of items where the + sizes of the groups are not uniform. An example would be where in a row + from a table, multiple columns represent elements of the same feature + (e.g. a point represented by x,y,z) but, the format is not the same for + all columns. + """ + # convert the iterable argument into an iterator so its contents can + # be consumed by islice in case it is a generator + it = iter(iterable) + + for size in sizes: + if size is None: + yield list(it) + return + else: + yield list(islice(it, size)) + + +def padded(iterable, fillvalue=None, n=None, next_multiple=False): + """Yield the elements from *iterable*, followed by *fillvalue*, such that + at least *n* items are emitted. + + >>> list(padded([1, 2, 3], '?', 5)) + [1, 2, 3, '?', '?'] + + If *next_multiple* is ``True``, *fillvalue* will be emitted until the + number of items emitted is a multiple of *n*: + + >>> list(padded([1, 2, 3, 4], n=3, next_multiple=True)) + [1, 2, 3, 4, None, None] + + If *n* is ``None``, *fillvalue* will be emitted indefinitely. + + To create an *iterable* of exactly size *n*, you can truncate with + :func:`islice`. + + >>> list(islice(padded([1, 2, 3], '?'), 5)) + [1, 2, 3, '?', '?'] + >>> list(islice(padded([1, 2, 3, 4, 5, 6, 7, 8], '?'), 5)) + [1, 2, 3, 4, 5] + + """ + iterator = iter(iterable) + iterator_with_repeat = chain(iterator, repeat(fillvalue)) + + if n is None: + return iterator_with_repeat + elif n < 1: + raise ValueError('n must be at least 1') + elif next_multiple: + + def slice_generator(): + for first in iterator: + yield (first,) + yield islice(iterator_with_repeat, n - 1) + + # While elements exist produce slices of size n + return chain.from_iterable(slice_generator()) + else: + # Ensure the first batch is at least size n then iterate + return chain(islice(iterator_with_repeat, n), iterator) + + +def repeat_each(iterable, n=2): + """Repeat each element in *iterable* *n* times. + + >>> list(repeat_each('ABC', 3)) + ['A', 'A', 'A', 'B', 'B', 'B', 'C', 'C', 'C'] + """ + return chain.from_iterable(map(repeat, iterable, repeat(n))) + + +def repeat_last(iterable, default=None): + """After the *iterable* is exhausted, keep yielding its last element. + + >>> list(islice(repeat_last(range(3)), 5)) + [0, 1, 2, 2, 2] + + If the iterable is empty, yield *default* forever:: + + >>> list(islice(repeat_last(range(0), 42), 5)) + [42, 42, 42, 42, 42] + + """ + item = _marker + for item in iterable: + yield item + final = default if item is _marker else item + yield from repeat(final) + + +def distribute(n, iterable): + """Distribute the items from *iterable* among *n* smaller iterables. + + >>> group_1, group_2 = distribute(2, [1, 2, 3, 4, 5, 6]) + >>> list(group_1) + [1, 3, 5] + >>> list(group_2) + [2, 4, 6] + + If the length of *iterable* is not evenly divisible by *n*, then the + length of the returned iterables will not be identical: + + >>> children = distribute(3, [1, 2, 3, 4, 5, 6, 7]) + >>> [list(c) for c in children] + [[1, 4, 7], [2, 5], [3, 6]] + + If the length of *iterable* is smaller than *n*, then the last returned + iterables will be empty: + + >>> children = distribute(5, [1, 2, 3]) + >>> [list(c) for c in children] + [[1], [2], [3], [], []] + + This function uses :func:`itertools.tee` and may require significant + storage. + + If you need the order items in the smaller iterables to match the + original iterable, see :func:`divide`. + + """ + if n < 1: + raise ValueError('n must be at least 1') + + children = tee(iterable, n) + return [islice(it, index, None, n) for index, it in enumerate(children)] + + +def stagger(iterable, offsets=(-1, 0, 1), longest=False, fillvalue=None): + """Yield tuples whose elements are offset from *iterable*. + The amount by which the `i`-th item in each tuple is offset is given by + the `i`-th item in *offsets*. + + >>> list(stagger([0, 1, 2, 3])) + [(None, 0, 1), (0, 1, 2), (1, 2, 3)] + >>> list(stagger(range(8), offsets=(0, 2, 4))) + [(0, 2, 4), (1, 3, 5), (2, 4, 6), (3, 5, 7)] + + By default, the sequence will end when the final element of a tuple is the + last item in the iterable. To continue until the first element of a tuple + is the last item in the iterable, set *longest* to ``True``:: + + >>> list(stagger([0, 1, 2, 3], longest=True)) + [(None, 0, 1), (0, 1, 2), (1, 2, 3), (2, 3, None), (3, None, None)] + + By default, ``None`` will be used to replace offsets beyond the end of the + sequence. Specify *fillvalue* to use some other value. + + """ + children = tee(iterable, len(offsets)) + + return zip_offset( + *children, offsets=offsets, longest=longest, fillvalue=fillvalue + ) + + +def zip_equal(*iterables): + """``zip`` the input *iterables* together but raise + ``UnequalIterablesError`` if they aren't all the same length. + + >>> it_1 = range(3) + >>> it_2 = iter('abc') + >>> list(zip_equal(it_1, it_2)) + [(0, 'a'), (1, 'b'), (2, 'c')] + + >>> it_1 = range(3) + >>> it_2 = iter('abcd') + >>> list(zip_equal(it_1, it_2)) # doctest: +IGNORE_EXCEPTION_DETAIL + Traceback (most recent call last): + ... + more_itertools.more.UnequalIterablesError: Iterables have different + lengths + + """ + if hexversion >= 0x30A00A6: + warnings.warn( + ( + 'zip_equal will be removed in a future version of ' + 'more-itertools. Use the builtin zip function with ' + 'strict=True instead.' + ), + DeprecationWarning, + ) + + return _zip_equal(*iterables) + + +def zip_offset(*iterables, offsets, longest=False, fillvalue=None): + """``zip`` the input *iterables* together, but offset the `i`-th iterable + by the `i`-th item in *offsets*. + + >>> list(zip_offset('0123', 'abcdef', offsets=(0, 1))) + [('0', 'b'), ('1', 'c'), ('2', 'd'), ('3', 'e')] + + This can be used as a lightweight alternative to SciPy or pandas to analyze + data sets in which some series have a lead or lag relationship. + + By default, the sequence will end when the shortest iterable is exhausted. + To continue until the longest iterable is exhausted, set *longest* to + ``True``. + + >>> list(zip_offset('0123', 'abcdef', offsets=(0, 1), longest=True)) + [('0', 'b'), ('1', 'c'), ('2', 'd'), ('3', 'e'), (None, 'f')] + + By default, ``None`` will be used to replace offsets beyond the end of the + sequence. Specify *fillvalue* to use some other value. + + """ + if len(iterables) != len(offsets): + raise ValueError("Number of iterables and offsets didn't match") + + staggered = [] + for it, n in zip(iterables, offsets): + if n < 0: + staggered.append(chain(repeat(fillvalue, -n), it)) + elif n > 0: + staggered.append(islice(it, n, None)) + else: + staggered.append(it) + + if longest: + return zip_longest(*staggered, fillvalue=fillvalue) + + return zip(*staggered) + + +def sort_together( + iterables, key_list=(0,), key=None, reverse=False, strict=False +): + """Return the input iterables sorted together, with *key_list* as the + priority for sorting. All iterables are trimmed to the length of the + shortest one. + + This can be used like the sorting function in a spreadsheet. If each + iterable represents a column of data, the key list determines which + columns are used for sorting. + + By default, all iterables are sorted using the ``0``-th iterable:: + + >>> iterables = [(4, 3, 2, 1), ('a', 'b', 'c', 'd')] + >>> sort_together(iterables) + [(1, 2, 3, 4), ('d', 'c', 'b', 'a')] + + Set a different key list to sort according to another iterable. + Specifying multiple keys dictates how ties are broken:: + + >>> iterables = [(3, 1, 2), (0, 1, 0), ('c', 'b', 'a')] + >>> sort_together(iterables, key_list=(1, 2)) + [(2, 3, 1), (0, 0, 1), ('a', 'c', 'b')] + + To sort by a function of the elements of the iterable, pass a *key* + function. Its arguments are the elements of the iterables corresponding to + the key list:: + + >>> names = ('a', 'b', 'c') + >>> lengths = (1, 2, 3) + >>> widths = (5, 2, 1) + >>> def area(length, width): + ... return length * width + >>> sort_together([names, lengths, widths], key_list=(1, 2), key=area) + [('c', 'b', 'a'), (3, 2, 1), (1, 2, 5)] + + Set *reverse* to ``True`` to sort in descending order. + + >>> sort_together([(1, 2, 3), ('c', 'b', 'a')], reverse=True) + [(3, 2, 1), ('a', 'b', 'c')] + + If the *strict* keyword argument is ``True``, then + ``UnequalIterablesError`` will be raised if any of the iterables have + different lengths. + + """ + if key is None: + # if there is no key function, the key argument to sorted is an + # itemgetter + key_argument = itemgetter(*key_list) + else: + # if there is a key function, call it with the items at the offsets + # specified by the key function as arguments + key_list = list(key_list) + if len(key_list) == 1: + # if key_list contains a single item, pass the item at that offset + # as the only argument to the key function + key_offset = key_list[0] + key_argument = lambda zipped_items: key(zipped_items[key_offset]) + else: + # if key_list contains multiple items, use itemgetter to return a + # tuple of items, which we pass as *args to the key function + get_key_items = itemgetter(*key_list) + key_argument = lambda zipped_items: key( + *get_key_items(zipped_items) + ) + + zipper = zip_equal if strict else zip + return list( + zipper(*sorted(zipper(*iterables), key=key_argument, reverse=reverse)) + ) + + +def unzip(iterable): + """The inverse of :func:`zip`, this function disaggregates the elements + of the zipped *iterable*. + + The ``i``-th iterable contains the ``i``-th element from each element + of the zipped iterable. The first element is used to determine the + length of the remaining elements. + + >>> iterable = [('a', 1), ('b', 2), ('c', 3), ('d', 4)] + >>> letters, numbers = unzip(iterable) + >>> list(letters) + ['a', 'b', 'c', 'd'] + >>> list(numbers) + [1, 2, 3, 4] + + This is similar to using ``zip(*iterable)``, but it avoids reading + *iterable* into memory. Note, however, that this function uses + :func:`itertools.tee` and thus may require significant storage. + + """ + head, iterable = spy(iterable) + if not head: + # empty iterable, e.g. zip([], [], []) + return () + # spy returns a one-length iterable as head + head = head[0] + iterables = tee(iterable, len(head)) + + # If we have an iterable like iter([(1, 2, 3), (4, 5), (6,)]), + # the second unzipped iterable fails at the third tuple since + # it tries to access (6,)[1]. + # Same with the third unzipped iterable and the second tuple. + # To support these "improperly zipped" iterables, we suppress + # the IndexError, which just stops the unzipped iterables at + # first length mismatch. + return tuple( + iter_suppress(map(itemgetter(i), it), IndexError) + for i, it in enumerate(iterables) + ) + + +def divide(n, iterable): + """Divide the elements from *iterable* into *n* parts, maintaining + order. + + >>> group_1, group_2 = divide(2, [1, 2, 3, 4, 5, 6]) + >>> list(group_1) + [1, 2, 3] + >>> list(group_2) + [4, 5, 6] + + If the length of *iterable* is not evenly divisible by *n*, then the + length of the returned iterables will not be identical: + + >>> children = divide(3, [1, 2, 3, 4, 5, 6, 7]) + >>> [list(c) for c in children] + [[1, 2, 3], [4, 5], [6, 7]] + + If the length of the iterable is smaller than n, then the last returned + iterables will be empty: + + >>> children = divide(5, [1, 2, 3]) + >>> [list(c) for c in children] + [[1], [2], [3], [], []] + + This function will exhaust the iterable before returning. + If order is not important, see :func:`distribute`, which does not first + pull the iterable into memory. + + """ + if n < 1: + raise ValueError('n must be at least 1') + + try: + iterable[:0] + except TypeError: + seq = tuple(iterable) + else: + seq = iterable + + q, r = divmod(len(seq), n) + + ret = [] + stop = 0 + for i in range(1, n + 1): + start = stop + stop += q + 1 if i <= r else q + ret.append(iter(seq[start:stop])) + + return ret + + +def always_iterable(obj, base_type=(str, bytes)): + """If *obj* is iterable, return an iterator over its items:: + + >>> obj = (1, 2, 3) + >>> list(always_iterable(obj)) + [1, 2, 3] + + If *obj* is not iterable, return a one-item iterable containing *obj*:: + + >>> obj = 1 + >>> list(always_iterable(obj)) + [1] + + If *obj* is ``None``, return an empty iterable: + + >>> obj = None + >>> list(always_iterable(None)) + [] + + By default, binary and text strings are not considered iterable:: + + >>> obj = 'foo' + >>> list(always_iterable(obj)) + ['foo'] + + If *base_type* is set, objects for which ``isinstance(obj, base_type)`` + returns ``True`` won't be considered iterable. + + >>> obj = {'a': 1} + >>> list(always_iterable(obj)) # Iterate over the dict's keys + ['a'] + >>> list(always_iterable(obj, base_type=dict)) # Treat dicts as a unit + [{'a': 1}] + + Set *base_type* to ``None`` to avoid any special handling and treat objects + Python considers iterable as iterable: + + >>> obj = 'foo' + >>> list(always_iterable(obj, base_type=None)) + ['f', 'o', 'o'] + """ + if obj is None: + return iter(()) + + if (base_type is not None) and isinstance(obj, base_type): + return iter((obj,)) + + try: + return iter(obj) + except TypeError: + return iter((obj,)) + + +def adjacent(predicate, iterable, distance=1): + """Return an iterable over `(bool, item)` tuples where the `item` is + drawn from *iterable* and the `bool` indicates whether + that item satisfies the *predicate* or is adjacent to an item that does. + + For example, to find whether items are adjacent to a ``3``:: + + >>> list(adjacent(lambda x: x == 3, range(6))) + [(False, 0), (False, 1), (True, 2), (True, 3), (True, 4), (False, 5)] + + Set *distance* to change what counts as adjacent. For example, to find + whether items are two places away from a ``3``: + + >>> list(adjacent(lambda x: x == 3, range(6), distance=2)) + [(False, 0), (True, 1), (True, 2), (True, 3), (True, 4), (True, 5)] + + This is useful for contextualizing the results of a search function. + For example, a code comparison tool might want to identify lines that + have changed, but also surrounding lines to give the viewer of the diff + context. + + The predicate function will only be called once for each item in the + iterable. + + See also :func:`groupby_transform`, which can be used with this function + to group ranges of items with the same `bool` value. + + """ + # Allow distance=0 mainly for testing that it reproduces results with map() + if distance < 0: + raise ValueError('distance must be at least 0') + + i1, i2 = tee(iterable) + padding = [False] * distance + selected = chain(padding, map(predicate, i1), padding) + adjacent_to_selected = map(any, windowed(selected, 2 * distance + 1)) + return zip(adjacent_to_selected, i2) + + +def groupby_transform(iterable, keyfunc=None, valuefunc=None, reducefunc=None): + """An extension of :func:`itertools.groupby` that can apply transformations + to the grouped data. + + * *keyfunc* is a function computing a key value for each item in *iterable* + * *valuefunc* is a function that transforms the individual items from + *iterable* after grouping + * *reducefunc* is a function that transforms each group of items + + >>> iterable = 'aAAbBBcCC' + >>> keyfunc = lambda k: k.upper() + >>> valuefunc = lambda v: v.lower() + >>> reducefunc = lambda g: ''.join(g) + >>> list(groupby_transform(iterable, keyfunc, valuefunc, reducefunc)) + [('A', 'aaa'), ('B', 'bbb'), ('C', 'ccc')] + + Each optional argument defaults to an identity function if not specified. + + :func:`groupby_transform` is useful when grouping elements of an iterable + using a separate iterable as the key. To do this, :func:`zip` the iterables + and pass a *keyfunc* that extracts the first element and a *valuefunc* + that extracts the second element:: + + >>> from operator import itemgetter + >>> keys = [0, 0, 1, 1, 1, 2, 2, 2, 3] + >>> values = 'abcdefghi' + >>> iterable = zip(keys, values) + >>> grouper = groupby_transform(iterable, itemgetter(0), itemgetter(1)) + >>> [(k, ''.join(g)) for k, g in grouper] + [(0, 'ab'), (1, 'cde'), (2, 'fgh'), (3, 'i')] + + Note that the order of items in the iterable is significant. + Only adjacent items are grouped together, so if you don't want any + duplicate groups, you should sort the iterable by the key function. + + """ + ret = groupby(iterable, keyfunc) + if valuefunc: + ret = ((k, map(valuefunc, g)) for k, g in ret) + if reducefunc: + ret = ((k, reducefunc(g)) for k, g in ret) + + return ret + + +class numeric_range(abc.Sequence, abc.Hashable): + """An extension of the built-in ``range()`` function whose arguments can + be any orderable numeric type. + + With only *stop* specified, *start* defaults to ``0`` and *step* + defaults to ``1``. The output items will match the type of *stop*: + + >>> list(numeric_range(3.5)) + [0.0, 1.0, 2.0, 3.0] + + With only *start* and *stop* specified, *step* defaults to ``1``. The + output items will match the type of *start*: + + >>> from decimal import Decimal + >>> start = Decimal('2.1') + >>> stop = Decimal('5.1') + >>> list(numeric_range(start, stop)) + [Decimal('2.1'), Decimal('3.1'), Decimal('4.1')] + + With *start*, *stop*, and *step* specified the output items will match + the type of ``start + step``: + + >>> from fractions import Fraction + >>> start = Fraction(1, 2) # Start at 1/2 + >>> stop = Fraction(5, 2) # End at 5/2 + >>> step = Fraction(1, 2) # Count by 1/2 + >>> list(numeric_range(start, stop, step)) + [Fraction(1, 2), Fraction(1, 1), Fraction(3, 2), Fraction(2, 1)] + + If *step* is zero, ``ValueError`` is raised. Negative steps are supported: + + >>> list(numeric_range(3, -1, -1.0)) + [3.0, 2.0, 1.0, 0.0] + + Be aware of the limitations of floating-point numbers; the representation + of the yielded numbers may be surprising. + + ``datetime.datetime`` objects can be used for *start* and *stop*, if *step* + is a ``datetime.timedelta`` object: + + >>> import datetime + >>> start = datetime.datetime(2019, 1, 1) + >>> stop = datetime.datetime(2019, 1, 3) + >>> step = datetime.timedelta(days=1) + >>> items = iter(numeric_range(start, stop, step)) + >>> next(items) + datetime.datetime(2019, 1, 1, 0, 0) + >>> next(items) + datetime.datetime(2019, 1, 2, 0, 0) + + """ + + _EMPTY_HASH = hash(range(0, 0)) + + def __init__(self, *args): + argc = len(args) + if argc == 1: + (self._stop,) = args + self._start = type(self._stop)(0) + self._step = type(self._stop - self._start)(1) + elif argc == 2: + self._start, self._stop = args + self._step = type(self._stop - self._start)(1) + elif argc == 3: + self._start, self._stop, self._step = args + elif argc == 0: + raise TypeError( + f'numeric_range expected at least 1 argument, got {argc}' + ) + else: + raise TypeError( + f'numeric_range expected at most 3 arguments, got {argc}' + ) + + self._zero = type(self._step)(0) + if self._step == self._zero: + raise ValueError('numeric_range() arg 3 must not be zero') + self._growing = self._step > self._zero + + def __bool__(self): + if self._growing: + return self._start < self._stop + else: + return self._start > self._stop + + def __contains__(self, elem): + if self._growing: + if self._start <= elem < self._stop: + return (elem - self._start) % self._step == self._zero + else: + if self._start >= elem > self._stop: + return (self._start - elem) % (-self._step) == self._zero + + return False + + def __eq__(self, other): + if isinstance(other, numeric_range): + empty_self = not bool(self) + empty_other = not bool(other) + if empty_self or empty_other: + return empty_self and empty_other # True if both empty + else: + return ( + self._start == other._start + and self._step == other._step + and self._get_by_index(-1) == other._get_by_index(-1) + ) + else: + return False + + def __getitem__(self, key): + if isinstance(key, int): + return self._get_by_index(key) + elif isinstance(key, slice): + step = self._step if key.step is None else key.step * self._step + + if key.start is None or key.start <= -self._len: + start = self._start + elif key.start >= self._len: + start = self._stop + else: # -self._len < key.start < self._len + start = self._get_by_index(key.start) + + if key.stop is None or key.stop >= self._len: + stop = self._stop + elif key.stop <= -self._len: + stop = self._start + else: # -self._len < key.stop < self._len + stop = self._get_by_index(key.stop) + + return numeric_range(start, stop, step) + else: + raise TypeError( + 'numeric range indices must be ' + f'integers or slices, not {type(key).__name__}' + ) + + def __hash__(self): + if self: + return hash((self._start, self._get_by_index(-1), self._step)) + else: + return self._EMPTY_HASH + + def __iter__(self): + values = (self._start + (n * self._step) for n in count()) + if self._growing: + return takewhile(partial(gt, self._stop), values) + else: + return takewhile(partial(lt, self._stop), values) + + def __len__(self): + return self._len + + @cached_property + def _len(self): + if self._growing: + start = self._start + stop = self._stop + step = self._step + else: + start = self._stop + stop = self._start + step = -self._step + distance = stop - start + if distance <= self._zero: + return 0 + else: # distance > 0 and step > 0: regular euclidean division + q, r = divmod(distance, step) + return int(q) + int(r != self._zero) + + def __reduce__(self): + return numeric_range, (self._start, self._stop, self._step) + + def __repr__(self): + if self._step == 1: + return f"numeric_range({self._start!r}, {self._stop!r})" + return ( + f"numeric_range({self._start!r}, {self._stop!r}, {self._step!r})" + ) + + def __reversed__(self): + return iter( + numeric_range( + self._get_by_index(-1), self._start - self._step, -self._step + ) + ) + + def count(self, value): + return int(value in self) + + def index(self, value): + if self._growing: + if self._start <= value < self._stop: + q, r = divmod(value - self._start, self._step) + if r == self._zero: + return int(q) + else: + if self._start >= value > self._stop: + q, r = divmod(self._start - value, -self._step) + if r == self._zero: + return int(q) + + raise ValueError(f"{value} is not in numeric range") + + def _get_by_index(self, i): + if i < 0: + i += self._len + if i < 0 or i >= self._len: + raise IndexError("numeric range object index out of range") + return self._start + i * self._step + + +def count_cycle(iterable, n=None): + """Cycle through the items from *iterable* up to *n* times, yielding + the number of completed cycles along with each item. If *n* is omitted the + process repeats indefinitely. + + >>> list(count_cycle('AB', 3)) + [(0, 'A'), (0, 'B'), (1, 'A'), (1, 'B'), (2, 'A'), (2, 'B')] + + """ + seq = tuple(iterable) + if not seq: + return iter(()) + counter = count() if n is None else range(n) + return zip(repeat_each(counter, len(seq)), cycle(seq)) + + +def mark_ends(iterable): + """Yield 3-tuples of the form ``(is_first, is_last, item)``. + + >>> list(mark_ends('ABC')) + [(True, False, 'A'), (False, False, 'B'), (False, True, 'C')] + + Use this when looping over an iterable to take special action on its first + and/or last items: + + >>> iterable = ['Header', 100, 200, 'Footer'] + >>> total = 0 + >>> for is_first, is_last, item in mark_ends(iterable): + ... if is_first: + ... continue # Skip the header + ... if is_last: + ... continue # Skip the footer + ... total += item + >>> print(total) + 300 + """ + it = iter(iterable) + for a in it: + first = True + for b in it: + yield first, False, a + a = b + first = False + yield first, True, a + + +def locate(iterable, pred=bool, window_size=None): + """Yield the index of each item in *iterable* for which *pred* returns + ``True``. + + *pred* defaults to :func:`bool`, which will select truthy items: + + >>> list(locate([0, 1, 1, 0, 1, 0, 0])) + [1, 2, 4] + + Set *pred* to a custom function to, e.g., find the indexes for a particular + item. + + >>> list(locate(['a', 'b', 'c', 'b'], lambda x: x == 'b')) + [1, 3] + + If *window_size* is given, then the *pred* function will be called with + that many items. This enables searching for sub-sequences: + + >>> iterable = [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3] + >>> pred = lambda *args: args == (1, 2, 3) + >>> list(locate(iterable, pred=pred, window_size=3)) + [1, 5, 9] + + Use with :func:`seekable` to find indexes and then retrieve the associated + items: + + >>> from itertools import count + >>> from more_itertools import seekable + >>> source = (3 * n + 1 if (n % 2) else n // 2 for n in count()) + >>> it = seekable(source) + >>> pred = lambda x: x > 100 + >>> indexes = locate(it, pred=pred) + >>> i = next(indexes) + >>> it.seek(i) + >>> next(it) + 106 + + """ + if window_size is None: + return compress(count(), map(pred, iterable)) + + if window_size < 1: + raise ValueError('window size must be at least 1') + + it = windowed(iterable, window_size, fillvalue=_marker) + return compress(count(), starmap(pred, it)) + + +def longest_common_prefix(iterables): + """Yield elements of the longest common prefix among given *iterables*. + + >>> ''.join(longest_common_prefix(['abcd', 'abc', 'abf'])) + 'ab' + + """ + return (c[0] for c in takewhile(all_equal, zip(*iterables))) + + +def lstrip(iterable, pred): + """Yield the items from *iterable*, but strip any from the beginning + for which *pred* returns ``True``. + + For example, to remove a set of items from the start of an iterable: + + >>> iterable = (None, False, None, 1, 2, None, 3, False, None) + >>> pred = lambda x: x in {None, False, ''} + >>> list(lstrip(iterable, pred)) + [1, 2, None, 3, False, None] + + This function is analogous to to :func:`str.lstrip`, and is essentially + an wrapper for :func:`itertools.dropwhile`. + + """ + return dropwhile(pred, iterable) + + +def rstrip(iterable, pred): + """Yield the items from *iterable*, but strip any from the end + for which *pred* returns ``True``. + + For example, to remove a set of items from the end of an iterable: + + >>> iterable = (None, False, None, 1, 2, None, 3, False, None) + >>> pred = lambda x: x in {None, False, ''} + >>> list(rstrip(iterable, pred)) + [None, False, None, 1, 2, None, 3] + + This function is analogous to :func:`str.rstrip`. + + """ + cache = [] + cache_append = cache.append + cache_clear = cache.clear + for x in iterable: + if pred(x): + cache_append(x) + else: + yield from cache + cache_clear() + yield x + + +def strip(iterable, pred): + """Yield the items from *iterable*, but strip any from the + beginning and end for which *pred* returns ``True``. + + For example, to remove a set of items from both ends of an iterable: + + >>> iterable = (None, False, None, 1, 2, None, 3, False, None) + >>> pred = lambda x: x in {None, False, ''} + >>> list(strip(iterable, pred)) + [1, 2, None, 3] + + This function is analogous to :func:`str.strip`. + + """ + return rstrip(lstrip(iterable, pred), pred) + + +class islice_extended: + """An extension of :func:`itertools.islice` that supports negative values + for *stop*, *start*, and *step*. + + >>> iterator = iter('abcdefgh') + >>> list(islice_extended(iterator, -4, -1)) + ['e', 'f', 'g'] + + Slices with negative values require some caching of *iterable*, but this + function takes care to minimize the amount of memory required. + + For example, you can use a negative step with an infinite iterator: + + >>> from itertools import count + >>> list(islice_extended(count(), 110, 99, -2)) + [110, 108, 106, 104, 102, 100] + + You can also use slice notation directly: + + >>> iterator = map(str, count()) + >>> it = islice_extended(iterator)[10:20:2] + >>> list(it) + ['10', '12', '14', '16', '18'] + + """ + + def __init__(self, iterable, *args): + it = iter(iterable) + if args: + self._iterator = _islice_helper(it, slice(*args)) + else: + self._iterator = it + + def __iter__(self): + return self + + def __next__(self): + return next(self._iterator) + + def __getitem__(self, key): + if isinstance(key, slice): + return islice_extended(_islice_helper(self._iterator, key)) + + raise TypeError('islice_extended.__getitem__ argument must be a slice') + + +def _islice_helper(it, s): + start = s.start + stop = s.stop + if s.step == 0: + raise ValueError('step argument must be a non-zero integer or None.') + step = s.step or 1 + + if step > 0: + start = 0 if (start is None) else start + + if start < 0: + # Consume all but the last -start items + cache = deque(enumerate(it, 1), maxlen=-start) + len_iter = cache[-1][0] if cache else 0 + + # Adjust start to be positive + i = max(len_iter + start, 0) + + # Adjust stop to be positive + if stop is None: + j = len_iter + elif stop >= 0: + j = min(stop, len_iter) + else: + j = max(len_iter + stop, 0) + + # Slice the cache + n = j - i + if n <= 0: + return + + for index in range(n): + if index % step == 0: + # pop and yield the item. + # We don't want to use an intermediate variable + # it would extend the lifetime of the current item + yield cache.popleft()[1] + else: + # just pop and discard the item + cache.popleft() + elif (stop is not None) and (stop < 0): + # Advance to the start position + next(islice(it, start, start), None) + + # When stop is negative, we have to carry -stop items while + # iterating + cache = deque(islice(it, -stop), maxlen=-stop) + + for index, item in enumerate(it): + if index % step == 0: + # pop and yield the item. + # We don't want to use an intermediate variable + # it would extend the lifetime of the current item + yield cache.popleft() + else: + # just pop and discard the item + cache.popleft() + cache.append(item) + else: + # When both start and stop are positive we have the normal case + yield from islice(it, start, stop, step) + else: + start = -1 if (start is None) else start + + if (stop is not None) and (stop < 0): + # Consume all but the last items + n = -stop - 1 + cache = deque(enumerate(it, 1), maxlen=n) + len_iter = cache[-1][0] if cache else 0 + + # If start and stop are both negative they are comparable and + # we can just slice. Otherwise we can adjust start to be negative + # and then slice. + if start < 0: + i, j = start, stop + else: + i, j = min(start - len_iter, -1), None + + for index, item in list(cache)[i:j:step]: + yield item + else: + # Advance to the stop position + if stop is not None: + m = stop + 1 + next(islice(it, m, m), None) + + # stop is positive, so if start is negative they are not comparable + # and we need the rest of the items. + if start < 0: + i = start + n = None + # stop is None and start is positive, so we just need items up to + # the start index. + elif stop is None: + i = None + n = start + 1 + # Both stop and start are positive, so they are comparable. + else: + i = None + n = start - stop + if n <= 0: + return + + cache = list(islice(it, n)) + + yield from cache[i::step] + + +def always_reversible(iterable): + """An extension of :func:`reversed` that supports all iterables, not + just those which implement the ``Reversible`` or ``Sequence`` protocols. + + >>> print(*always_reversible(x for x in range(3))) + 2 1 0 + + If the iterable is already reversible, this function returns the + result of :func:`reversed()`. If the iterable is not reversible, + this function will cache the remaining items in the iterable and + yield them in reverse order, which may require significant storage. + """ + try: + return reversed(iterable) + except TypeError: + return reversed(list(iterable)) + + +def consecutive_groups(iterable, ordering=None): + """Yield groups of consecutive items using :func:`itertools.groupby`. + The *ordering* function determines whether two items are adjacent by + returning their position. + + By default, the ordering function is the identity function. This is + suitable for finding runs of numbers: + + >>> iterable = [1, 10, 11, 12, 20, 30, 31, 32, 33, 40] + >>> for group in consecutive_groups(iterable): + ... print(list(group)) + [1] + [10, 11, 12] + [20] + [30, 31, 32, 33] + [40] + + To find runs of adjacent letters, apply :func:`ord` function + to convert letters to ordinals. + + >>> iterable = 'abcdfgilmnop' + >>> ordering = ord + >>> for group in consecutive_groups(iterable, ordering): + ... print(list(group)) + ['a', 'b', 'c', 'd'] + ['f', 'g'] + ['i'] + ['l', 'm', 'n', 'o', 'p'] + + Each group of consecutive items is an iterator that shares it source with + *iterable*. When an an output group is advanced, the previous group is + no longer available unless its elements are copied (e.g., into a ``list``). + + >>> iterable = [1, 2, 11, 12, 21, 22] + >>> saved_groups = [] + >>> for group in consecutive_groups(iterable): + ... saved_groups.append(list(group)) # Copy group elements + >>> saved_groups + [[1, 2], [11, 12], [21, 22]] + + """ + if ordering is None: + key = lambda x: x[0] - x[1] + else: + key = lambda x: x[0] - ordering(x[1]) + + for k, g in groupby(enumerate(iterable), key=key): + yield map(itemgetter(1), g) + + +def difference(iterable, func=sub, *, initial=None): + """This function is the inverse of :func:`itertools.accumulate`. By default + it will compute the first difference of *iterable* using + :func:`operator.sub`: + + >>> from itertools import accumulate + >>> iterable = accumulate([0, 1, 2, 3, 4]) # produces 0, 1, 3, 6, 10 + >>> list(difference(iterable)) + [0, 1, 2, 3, 4] + + *func* defaults to :func:`operator.sub`, but other functions can be + specified. They will be applied as follows:: + + A, B, C, D, ... --> A, func(B, A), func(C, B), func(D, C), ... + + For example, to do progressive division: + + >>> iterable = [1, 2, 6, 24, 120] + >>> func = lambda x, y: x // y + >>> list(difference(iterable, func)) + [1, 2, 3, 4, 5] + + If the *initial* keyword is set, the first element will be skipped when + computing successive differences. + + >>> it = [10, 11, 13, 16] # from accumulate([1, 2, 3], initial=10) + >>> list(difference(it, initial=10)) + [1, 2, 3] + + """ + a, b = tee(iterable) + try: + first = [next(b)] + except StopIteration: + return iter([]) + + if initial is not None: + first = [] + + return chain(first, map(func, b, a)) + + +class SequenceView(Sequence): + """Return a read-only view of the sequence object *target*. + + :class:`SequenceView` objects are analogous to Python's built-in + "dictionary view" types. They provide a dynamic view of a sequence's items, + meaning that when the sequence updates, so does the view. + + >>> seq = ['0', '1', '2'] + >>> view = SequenceView(seq) + >>> view + SequenceView(['0', '1', '2']) + >>> seq.append('3') + >>> view + SequenceView(['0', '1', '2', '3']) + + Sequence views support indexing, slicing, and length queries. They act + like the underlying sequence, except they don't allow assignment: + + >>> view[1] + '1' + >>> view[1:-1] + ['1', '2'] + >>> len(view) + 4 + + Sequence views are useful as an alternative to copying, as they don't + require (much) extra storage. + + """ + + def __init__(self, target): + if not isinstance(target, Sequence): + raise TypeError + self._target = target + + def __getitem__(self, index): + return self._target[index] + + def __len__(self): + return len(self._target) + + def __repr__(self): + return f'{self.__class__.__name__}({self._target!r})' + + +class seekable: + """Wrap an iterator to allow for seeking backward and forward. This + progressively caches the items in the source iterable so they can be + re-visited. + + Call :meth:`seek` with an index to seek to that position in the source + iterable. + + To "reset" an iterator, seek to ``0``: + + >>> from itertools import count + >>> it = seekable((str(n) for n in count())) + >>> next(it), next(it), next(it) + ('0', '1', '2') + >>> it.seek(0) + >>> next(it), next(it), next(it) + ('0', '1', '2') + + You can also seek forward: + + >>> it = seekable((str(n) for n in range(20))) + >>> it.seek(10) + >>> next(it) + '10' + >>> it.seek(20) # Seeking past the end of the source isn't a problem + >>> list(it) + [] + >>> it.seek(0) # Resetting works even after hitting the end + >>> next(it) + '0' + + Call :meth:`relative_seek` to seek relative to the source iterator's + current position. + + >>> it = seekable((str(n) for n in range(20))) + >>> next(it), next(it), next(it) + ('0', '1', '2') + >>> it.relative_seek(2) + >>> next(it) + '5' + >>> it.relative_seek(-3) # Source is at '6', we move back to '3' + >>> next(it) + '3' + >>> it.relative_seek(-3) # Source is at '4', we move back to '1' + >>> next(it) + '1' + + + Call :meth:`peek` to look ahead one item without advancing the iterator: + + >>> it = seekable('1234') + >>> it.peek() + '1' + >>> list(it) + ['1', '2', '3', '4'] + >>> it.peek(default='empty') + 'empty' + + Before the iterator is at its end, calling :func:`bool` on it will return + ``True``. After it will return ``False``: + + >>> it = seekable('5678') + >>> bool(it) + True + >>> list(it) + ['5', '6', '7', '8'] + >>> bool(it) + False + + You may view the contents of the cache with the :meth:`elements` method. + That returns a :class:`SequenceView`, a view that updates automatically: + + >>> it = seekable((str(n) for n in range(10))) + >>> next(it), next(it), next(it) + ('0', '1', '2') + >>> elements = it.elements() + >>> elements + SequenceView(['0', '1', '2']) + >>> next(it) + '3' + >>> elements + SequenceView(['0', '1', '2', '3']) + + By default, the cache grows as the source iterable progresses, so beware of + wrapping very large or infinite iterables. Supply *maxlen* to limit the + size of the cache (this of course limits how far back you can seek). + + >>> from itertools import count + >>> it = seekable((str(n) for n in count()), maxlen=2) + >>> next(it), next(it), next(it), next(it) + ('0', '1', '2', '3') + >>> list(it.elements()) + ['2', '3'] + >>> it.seek(0) + >>> next(it), next(it), next(it), next(it) + ('2', '3', '4', '5') + >>> next(it) + '6' + + """ + + def __init__(self, iterable, maxlen=None): + self._source = iter(iterable) + if maxlen is None: + self._cache = [] + else: + self._cache = deque([], maxlen) + self._index = None + + def __iter__(self): + return self + + def __next__(self): + if self._index is not None: + try: + item = self._cache[self._index] + except IndexError: + self._index = None + else: + self._index += 1 + return item + + item = next(self._source) + self._cache.append(item) + return item + + def __bool__(self): + try: + self.peek() + except StopIteration: + return False + return True + + def peek(self, default=_marker): + try: + peeked = next(self) + except StopIteration: + if default is _marker: + raise + return default + if self._index is None: + self._index = len(self._cache) + self._index -= 1 + return peeked + + def elements(self): + return SequenceView(self._cache) + + def seek(self, index): + self._index = index + remainder = index - len(self._cache) + if remainder > 0: + consume(self, remainder) + + def relative_seek(self, count): + if self._index is None: + self._index = len(self._cache) + + self.seek(max(self._index + count, 0)) + + +class run_length: + """ + :func:`run_length.encode` compresses an iterable with run-length encoding. + It yields groups of repeated items with the count of how many times they + were repeated: + + >>> uncompressed = 'abbcccdddd' + >>> list(run_length.encode(uncompressed)) + [('a', 1), ('b', 2), ('c', 3), ('d', 4)] + + :func:`run_length.decode` decompresses an iterable that was previously + compressed with run-length encoding. It yields the items of the + decompressed iterable: + + >>> compressed = [('a', 1), ('b', 2), ('c', 3), ('d', 4)] + >>> list(run_length.decode(compressed)) + ['a', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd', 'd'] + + """ + + @staticmethod + def encode(iterable): + return ((k, ilen(g)) for k, g in groupby(iterable)) + + @staticmethod + def decode(iterable): + return chain.from_iterable(starmap(repeat, iterable)) + + +def exactly_n(iterable, n, predicate=bool): + """Return ``True`` if exactly ``n`` items in the iterable are ``True`` + according to the *predicate* function. + + >>> exactly_n([True, True, False], 2) + True + >>> exactly_n([True, True, False], 1) + False + >>> exactly_n([0, 1, 2, 3, 4, 5], 3, lambda x: x < 3) + True + + The iterable will be advanced until ``n + 1`` truthy items are encountered, + so avoid calling it on infinite iterables. + + """ + return ilen(islice(filter(predicate, iterable), n + 1)) == n + + +def circular_shifts(iterable, steps=1): + """Yield the circular shifts of *iterable*. + + >>> list(circular_shifts(range(4))) + [(0, 1, 2, 3), (1, 2, 3, 0), (2, 3, 0, 1), (3, 0, 1, 2)] + + Set *steps* to the number of places to rotate to the left + (or to the right if negative). Defaults to 1. + + >>> list(circular_shifts(range(4), 2)) + [(0, 1, 2, 3), (2, 3, 0, 1)] + + >>> list(circular_shifts(range(4), -1)) + [(0, 1, 2, 3), (3, 0, 1, 2), (2, 3, 0, 1), (1, 2, 3, 0)] + + """ + buffer = deque(iterable) + if steps == 0: + raise ValueError('Steps should be a non-zero integer') + + buffer.rotate(steps) + steps = -steps + n = len(buffer) + n //= math.gcd(n, steps) + + for _ in repeat(None, n): + buffer.rotate(steps) + yield tuple(buffer) + + +def make_decorator(wrapping_func, result_index=0): + """Return a decorator version of *wrapping_func*, which is a function that + modifies an iterable. *result_index* is the position in that function's + signature where the iterable goes. + + This lets you use itertools on the "production end," i.e. at function + definition. This can augment what the function returns without changing the + function's code. + + For example, to produce a decorator version of :func:`chunked`: + + >>> from more_itertools import chunked + >>> chunker = make_decorator(chunked, result_index=0) + >>> @chunker(3) + ... def iter_range(n): + ... return iter(range(n)) + ... + >>> list(iter_range(9)) + [[0, 1, 2], [3, 4, 5], [6, 7, 8]] + + To only allow truthy items to be returned: + + >>> truth_serum = make_decorator(filter, result_index=1) + >>> @truth_serum(bool) + ... def boolean_test(): + ... return [0, 1, '', ' ', False, True] + ... + >>> list(boolean_test()) + [1, ' ', True] + + The :func:`peekable` and :func:`seekable` wrappers make for practical + decorators: + + >>> from more_itertools import peekable + >>> peekable_function = make_decorator(peekable) + >>> @peekable_function() + ... def str_range(*args): + ... return (str(x) for x in range(*args)) + ... + >>> it = str_range(1, 20, 2) + >>> next(it), next(it), next(it) + ('1', '3', '5') + >>> it.peek() + '7' + >>> next(it) + '7' + + """ + + # See https://sites.google.com/site/bbayles/index/decorator_factory for + # notes on how this works. + def decorator(*wrapping_args, **wrapping_kwargs): + def outer_wrapper(f): + def inner_wrapper(*args, **kwargs): + result = f(*args, **kwargs) + wrapping_args_ = list(wrapping_args) + wrapping_args_.insert(result_index, result) + return wrapping_func(*wrapping_args_, **wrapping_kwargs) + + return inner_wrapper + + return outer_wrapper + + return decorator + + +def map_reduce(iterable, keyfunc, valuefunc=None, reducefunc=None): + """Return a dictionary that maps the items in *iterable* to categories + defined by *keyfunc*, transforms them with *valuefunc*, and + then summarizes them by category with *reducefunc*. + + *valuefunc* defaults to the identity function if it is unspecified. + If *reducefunc* is unspecified, no summarization takes place: + + >>> keyfunc = lambda x: x.upper() + >>> result = map_reduce('abbccc', keyfunc) + >>> sorted(result.items()) + [('A', ['a']), ('B', ['b', 'b']), ('C', ['c', 'c', 'c'])] + + Specifying *valuefunc* transforms the categorized items: + + >>> keyfunc = lambda x: x.upper() + >>> valuefunc = lambda x: 1 + >>> result = map_reduce('abbccc', keyfunc, valuefunc) + >>> sorted(result.items()) + [('A', [1]), ('B', [1, 1]), ('C', [1, 1, 1])] + + Specifying *reducefunc* summarizes the categorized items: + + >>> keyfunc = lambda x: x.upper() + >>> valuefunc = lambda x: 1 + >>> reducefunc = sum + >>> result = map_reduce('abbccc', keyfunc, valuefunc, reducefunc) + >>> sorted(result.items()) + [('A', 1), ('B', 2), ('C', 3)] + + You may want to filter the input iterable before applying the map/reduce + procedure: + + >>> all_items = range(30) + >>> items = [x for x in all_items if 10 <= x <= 20] # Filter + >>> keyfunc = lambda x: x % 2 # Evens map to 0; odds to 1 + >>> categories = map_reduce(items, keyfunc=keyfunc) + >>> sorted(categories.items()) + [(0, [10, 12, 14, 16, 18, 20]), (1, [11, 13, 15, 17, 19])] + >>> summaries = map_reduce(items, keyfunc=keyfunc, reducefunc=sum) + >>> sorted(summaries.items()) + [(0, 90), (1, 75)] + + Note that all items in the iterable are gathered into a list before the + summarization step, which may require significant storage. + + The returned object is a :obj:`collections.defaultdict` with the + ``default_factory`` set to ``None``, such that it behaves like a normal + dictionary. + + """ + + ret = defaultdict(list) + + if valuefunc is None: + for item in iterable: + key = keyfunc(item) + ret[key].append(item) + + else: + for item in iterable: + key = keyfunc(item) + value = valuefunc(item) + ret[key].append(value) + + if reducefunc is not None: + for key, value_list in ret.items(): + ret[key] = reducefunc(value_list) + + ret.default_factory = None + return ret + + +def rlocate(iterable, pred=bool, window_size=None): + """Yield the index of each item in *iterable* for which *pred* returns + ``True``, starting from the right and moving left. + + *pred* defaults to :func:`bool`, which will select truthy items: + + >>> list(rlocate([0, 1, 1, 0, 1, 0, 0])) # Truthy at 1, 2, and 4 + [4, 2, 1] + + Set *pred* to a custom function to, e.g., find the indexes for a particular + item: + + >>> iterator = iter('abcb') + >>> pred = lambda x: x == 'b' + >>> list(rlocate(iterator, pred)) + [3, 1] + + If *window_size* is given, then the *pred* function will be called with + that many items. This enables searching for sub-sequences: + + >>> iterable = [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3] + >>> pred = lambda *args: args == (1, 2, 3) + >>> list(rlocate(iterable, pred=pred, window_size=3)) + [9, 5, 1] + + Beware, this function won't return anything for infinite iterables. + If *iterable* is reversible, ``rlocate`` will reverse it and search from + the right. Otherwise, it will search from the left and return the results + in reverse order. + + See :func:`locate` to for other example applications. + + """ + if window_size is None: + try: + len_iter = len(iterable) + return (len_iter - i - 1 for i in locate(reversed(iterable), pred)) + except TypeError: + pass + + return reversed(list(locate(iterable, pred, window_size))) + + +def replace(iterable, pred, substitutes, count=None, window_size=1): + """Yield the items from *iterable*, replacing the items for which *pred* + returns ``True`` with the items from the iterable *substitutes*. + + >>> iterable = [1, 1, 0, 1, 1, 0, 1, 1] + >>> pred = lambda x: x == 0 + >>> substitutes = (2, 3) + >>> list(replace(iterable, pred, substitutes)) + [1, 1, 2, 3, 1, 1, 2, 3, 1, 1] + + If *count* is given, the number of replacements will be limited: + + >>> iterable = [1, 1, 0, 1, 1, 0, 1, 1, 0] + >>> pred = lambda x: x == 0 + >>> substitutes = [None] + >>> list(replace(iterable, pred, substitutes, count=2)) + [1, 1, None, 1, 1, None, 1, 1, 0] + + Use *window_size* to control the number of items passed as arguments to + *pred*. This allows for locating and replacing subsequences. + + >>> iterable = [0, 1, 2, 5, 0, 1, 2, 5] + >>> window_size = 3 + >>> pred = lambda *args: args == (0, 1, 2) # 3 items passed to pred + >>> substitutes = [3, 4] # Splice in these items + >>> list(replace(iterable, pred, substitutes, window_size=window_size)) + [3, 4, 5, 3, 4, 5] + + """ + if window_size < 1: + raise ValueError('window_size must be at least 1') + + # Save the substitutes iterable, since it's used more than once + substitutes = tuple(substitutes) + + # Add padding such that the number of windows matches the length of the + # iterable + it = chain(iterable, repeat(_marker, window_size - 1)) + windows = windowed(it, window_size) + + n = 0 + for w in windows: + # If the current window matches our predicate (and we haven't hit + # our maximum number of replacements), splice in the substitutes + # and then consume the following windows that overlap with this one. + # For example, if the iterable is (0, 1, 2, 3, 4...) + # and the window size is 2, we have (0, 1), (1, 2), (2, 3)... + # If the predicate matches on (0, 1), we need to zap (0, 1) and (1, 2) + if pred(*w): + if (count is None) or (n < count): + n += 1 + yield from substitutes + consume(windows, window_size - 1) + continue + + # If there was no match (or we've reached the replacement limit), + # yield the first item from the window. + if w and (w[0] is not _marker): + yield w[0] + + +def partitions(iterable): + """Yield all possible order-preserving partitions of *iterable*. + + >>> iterable = 'abc' + >>> for part in partitions(iterable): + ... print([''.join(p) for p in part]) + ['abc'] + ['a', 'bc'] + ['ab', 'c'] + ['a', 'b', 'c'] + + This is unrelated to :func:`partition`. + + """ + sequence = list(iterable) + n = len(sequence) + for i in powerset(range(1, n)): + yield [sequence[i:j] for i, j in zip((0,) + i, i + (n,))] + + +def set_partitions(iterable, k=None, min_size=None, max_size=None): + """ + Yield the set partitions of *iterable* into *k* parts. Set partitions are + not order-preserving. + + >>> iterable = 'abc' + >>> for part in set_partitions(iterable, 2): + ... print([''.join(p) for p in part]) + ['a', 'bc'] + ['ab', 'c'] + ['b', 'ac'] + + + If *k* is not given, every set partition is generated. + + >>> iterable = 'abc' + >>> for part in set_partitions(iterable): + ... print([''.join(p) for p in part]) + ['abc'] + ['a', 'bc'] + ['ab', 'c'] + ['b', 'ac'] + ['a', 'b', 'c'] + + if *min_size* and/or *max_size* are given, the minimum and/or maximum size + per block in partition is set. + + >>> iterable = 'abc' + >>> for part in set_partitions(iterable, min_size=2): + ... print([''.join(p) for p in part]) + ['abc'] + >>> for part in set_partitions(iterable, max_size=2): + ... print([''.join(p) for p in part]) + ['a', 'bc'] + ['ab', 'c'] + ['b', 'ac'] + ['a', 'b', 'c'] + + """ + L = list(iterable) + n = len(L) + if k is not None: + if k < 1: + raise ValueError( + "Can't partition in a negative or zero number of groups" + ) + elif k > n: + return + + min_size = min_size if min_size is not None else 0 + max_size = max_size if max_size is not None else n + if min_size > max_size: + return + + def set_partitions_helper(L, k): + n = len(L) + if k == 1: + yield [L] + elif n == k: + yield [[s] for s in L] + else: + e, *M = L + for p in set_partitions_helper(M, k - 1): + yield [[e], *p] + for p in set_partitions_helper(M, k): + for i in range(len(p)): + yield p[:i] + [[e] + p[i]] + p[i + 1 :] + + if k is None: + for k in range(1, n + 1): + yield from filter( + lambda z: all(min_size <= len(bk) <= max_size for bk in z), + set_partitions_helper(L, k), + ) + else: + yield from filter( + lambda z: all(min_size <= len(bk) <= max_size for bk in z), + set_partitions_helper(L, k), + ) + + +class time_limited: + """ + Yield items from *iterable* until *limit_seconds* have passed. + If the time limit expires before all items have been yielded, the + ``timed_out`` parameter will be set to ``True``. + + >>> from time import sleep + >>> def generator(): + ... yield 1 + ... yield 2 + ... sleep(0.2) + ... yield 3 + >>> iterable = time_limited(0.1, generator()) + >>> list(iterable) + [1, 2] + >>> iterable.timed_out + True + + Note that the time is checked before each item is yielded, and iteration + stops if the time elapsed is greater than *limit_seconds*. If your time + limit is 1 second, but it takes 2 seconds to generate the first item from + the iterable, the function will run for 2 seconds and not yield anything. + As a special case, when *limit_seconds* is zero, the iterator never + returns anything. + + """ + + def __init__(self, limit_seconds, iterable): + if limit_seconds < 0: + raise ValueError('limit_seconds must be positive') + self.limit_seconds = limit_seconds + self._iterator = iter(iterable) + self._start_time = monotonic() + self.timed_out = False + + def __iter__(self): + return self + + def __next__(self): + if self.limit_seconds == 0: + self.timed_out = True + raise StopIteration + item = next(self._iterator) + if monotonic() - self._start_time > self.limit_seconds: + self.timed_out = True + raise StopIteration + + return item + + +def only(iterable, default=None, too_long=None): + """If *iterable* has only one item, return it. + If it has zero items, return *default*. + If it has more than one item, raise the exception given by *too_long*, + which is ``ValueError`` by default. + + >>> only([], default='missing') + 'missing' + >>> only([1]) + 1 + >>> only([1, 2]) # doctest: +IGNORE_EXCEPTION_DETAIL + Traceback (most recent call last): + ... + ValueError: Expected exactly one item in iterable, but got 1, 2, + and perhaps more.' + >>> only([1, 2], too_long=TypeError) # doctest: +IGNORE_EXCEPTION_DETAIL + Traceback (most recent call last): + ... + TypeError + + Note that :func:`only` attempts to advance *iterable* twice to ensure there + is only one item. See :func:`spy` or :func:`peekable` to check + iterable contents less destructively. + + """ + iterator = iter(iterable) + for first in iterator: + for second in iterator: + msg = ( + f'Expected exactly one item in iterable, but got {first!r}, ' + f'{second!r}, and perhaps more.' + ) + raise too_long or ValueError(msg) + return first + return default + + +def _ichunk(iterator, n): + cache = deque() + chunk = islice(iterator, n) + + def generator(): + with suppress(StopIteration): + while True: + if cache: + yield cache.popleft() + else: + yield next(chunk) + + def materialize_next(n=1): + # if n not specified materialize everything + if n is None: + cache.extend(chunk) + return len(cache) + + to_cache = n - len(cache) + + # materialize up to n + if to_cache > 0: + cache.extend(islice(chunk, to_cache)) + + # return number materialized up to n + return min(n, len(cache)) + + return (generator(), materialize_next) + + +def ichunked(iterable, n): + """Break *iterable* into sub-iterables with *n* elements each. + :func:`ichunked` is like :func:`chunked`, but it yields iterables + instead of lists. + + If the sub-iterables are read in order, the elements of *iterable* + won't be stored in memory. + If they are read out of order, :func:`itertools.tee` is used to cache + elements as necessary. + + >>> from itertools import count + >>> all_chunks = ichunked(count(), 4) + >>> c_1, c_2, c_3 = next(all_chunks), next(all_chunks), next(all_chunks) + >>> list(c_2) # c_1's elements have been cached; c_3's haven't been + [4, 5, 6, 7] + >>> list(c_1) + [0, 1, 2, 3] + >>> list(c_3) + [8, 9, 10, 11] + + """ + iterator = iter(iterable) + while True: + # Create new chunk + chunk, materialize_next = _ichunk(iterator, n) + + # Check to see whether we're at the end of the source iterable + if not materialize_next(): + return + + yield chunk + + # Fill previous chunk's cache + materialize_next(None) + + +def iequals(*iterables): + """Return ``True`` if all given *iterables* are equal to each other, + which means that they contain the same elements in the same order. + + The function is useful for comparing iterables of different data types + or iterables that do not support equality checks. + + >>> iequals("abc", ['a', 'b', 'c'], ('a', 'b', 'c'), iter("abc")) + True + + >>> iequals("abc", "acb") + False + + Not to be confused with :func:`all_equal`, which checks whether all + elements of iterable are equal to each other. + + """ + return all(map(all_equal, zip_longest(*iterables, fillvalue=object()))) + + +def distinct_combinations(iterable, r): + """Yield the distinct combinations of *r* items taken from *iterable*. + + >>> list(distinct_combinations([0, 0, 1], 2)) + [(0, 0), (0, 1)] + + Equivalent to ``set(combinations(iterable))``, except duplicates are not + generated and thrown away. For larger input sequences this is much more + efficient. + + """ + if r < 0: + raise ValueError('r must be non-negative') + elif r == 0: + yield () + return + pool = tuple(iterable) + generators = [unique_everseen(enumerate(pool), key=itemgetter(1))] + current_combo = [None] * r + level = 0 + while generators: + try: + cur_idx, p = next(generators[-1]) + except StopIteration: + generators.pop() + level -= 1 + continue + current_combo[level] = p + if level + 1 == r: + yield tuple(current_combo) + else: + generators.append( + unique_everseen( + enumerate(pool[cur_idx + 1 :], cur_idx + 1), + key=itemgetter(1), + ) + ) + level += 1 + + +def filter_except(validator, iterable, *exceptions): + """Yield the items from *iterable* for which the *validator* function does + not raise one of the specified *exceptions*. + + *validator* is called for each item in *iterable*. + It should be a function that accepts one argument and raises an exception + if that item is not valid. + + >>> iterable = ['1', '2', 'three', '4', None] + >>> list(filter_except(int, iterable, ValueError, TypeError)) + ['1', '2', '4'] + + If an exception other than one given by *exceptions* is raised by + *validator*, it is raised like normal. + """ + for item in iterable: + try: + validator(item) + except exceptions: + pass + else: + yield item + + +def map_except(function, iterable, *exceptions): + """Transform each item from *iterable* with *function* and yield the + result, unless *function* raises one of the specified *exceptions*. + + *function* is called to transform each item in *iterable*. + It should accept one argument. + + >>> iterable = ['1', '2', 'three', '4', None] + >>> list(map_except(int, iterable, ValueError, TypeError)) + [1, 2, 4] + + If an exception other than one given by *exceptions* is raised by + *function*, it is raised like normal. + """ + for item in iterable: + try: + yield function(item) + except exceptions: + pass + + +def map_if(iterable, pred, func, func_else=None): + """Evaluate each item from *iterable* using *pred*. If the result is + equivalent to ``True``, transform the item with *func* and yield it. + Otherwise, transform the item with *func_else* and yield it. + + *pred*, *func*, and *func_else* should each be functions that accept + one argument. By default, *func_else* is the identity function. + + >>> from math import sqrt + >>> iterable = list(range(-5, 5)) + >>> iterable + [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4] + >>> list(map_if(iterable, lambda x: x > 3, lambda x: 'toobig')) + [-5, -4, -3, -2, -1, 0, 1, 2, 3, 'toobig'] + >>> list(map_if(iterable, lambda x: x >= 0, + ... lambda x: f'{sqrt(x):.2f}', lambda x: None)) + [None, None, None, None, None, '0.00', '1.00', '1.41', '1.73', '2.00'] + """ + + if func_else is None: + for item in iterable: + yield func(item) if pred(item) else item + + else: + for item in iterable: + yield func(item) if pred(item) else func_else(item) + + +def _sample_unweighted(iterator, k, strict): + # Algorithm L in the 1994 paper by Kim-Hung Li: + # "Reservoir-Sampling Algorithms of Time Complexity O(n(1+log(N/n)))". + + reservoir = list(islice(iterator, k)) + if strict and len(reservoir) < k: + raise ValueError('Sample larger than population') + W = 1.0 + + with suppress(StopIteration): + while True: + W *= random() ** (1 / k) + skip = floor(log(random()) / log1p(-W)) + element = next(islice(iterator, skip, None)) + reservoir[randrange(k)] = element + + shuffle(reservoir) + return reservoir + + +def _sample_weighted(iterator, k, weights, strict): + # Implementation of "A-ExpJ" from the 2006 paper by Efraimidis et al. : + # "Weighted random sampling with a reservoir". + + # Log-transform for numerical stability for weights that are small/large + weight_keys = (log(random()) / weight for weight in weights) + + # Fill up the reservoir (collection of samples) with the first `k` + # weight-keys and elements, then heapify the list. + reservoir = take(k, zip(weight_keys, iterator)) + if strict and len(reservoir) < k: + raise ValueError('Sample larger than population') + + heapify(reservoir) + + # The number of jumps before changing the reservoir is a random variable + # with an exponential distribution. Sample it using random() and logs. + smallest_weight_key, _ = reservoir[0] + weights_to_skip = log(random()) / smallest_weight_key + + for weight, element in zip(weights, iterator): + if weight >= weights_to_skip: + # The notation here is consistent with the paper, but we store + # the weight-keys in log-space for better numerical stability. + smallest_weight_key, _ = reservoir[0] + t_w = exp(weight * smallest_weight_key) + r_2 = uniform(t_w, 1) # generate U(t_w, 1) + weight_key = log(r_2) / weight + heapreplace(reservoir, (weight_key, element)) + smallest_weight_key, _ = reservoir[0] + weights_to_skip = log(random()) / smallest_weight_key + else: + weights_to_skip -= weight + + ret = [element for weight_key, element in reservoir] + shuffle(ret) + return ret + + +def _sample_counted(population, k, counts, strict): + element = None + remaining = 0 + + def feed(i): + # Advance *i* steps ahead and consume an element + nonlocal element, remaining + + while i + 1 > remaining: + i = i - remaining + element = next(population) + remaining = next(counts) + remaining -= i + 1 + return element + + with suppress(StopIteration): + reservoir = [] + for _ in range(k): + reservoir.append(feed(0)) + + if strict and len(reservoir) < k: + raise ValueError('Sample larger than population') + + with suppress(StopIteration): + W = 1.0 + while True: + W *= random() ** (1 / k) + skip = floor(log(random()) / log1p(-W)) + element = feed(skip) + reservoir[randrange(k)] = element + + shuffle(reservoir) + return reservoir + + +def sample(iterable, k, weights=None, *, counts=None, strict=False): + """Return a *k*-length list of elements chosen (without replacement) + from the *iterable*. + + Similar to :func:`random.sample`, but works on inputs that aren't + indexable (such as sets and dictionaries) and on inputs where the + size isn't known in advance (such as generators). + + >>> iterable = range(100) + >>> sample(iterable, 5) # doctest: +SKIP + [81, 60, 96, 16, 4] + + For iterables with repeated elements, you may supply *counts* to + indicate the repeats. + + >>> iterable = ['a', 'b'] + >>> counts = [3, 4] # Equivalent to 'a', 'a', 'a', 'b', 'b', 'b', 'b' + >>> sample(iterable, k=3, counts=counts) # doctest: +SKIP + ['a', 'a', 'b'] + + An iterable with *weights* may be given: + + >>> iterable = range(100) + >>> weights = (i * i + 1 for i in range(100)) + >>> sampled = sample(iterable, 5, weights=weights) # doctest: +SKIP + [79, 67, 74, 66, 78] + + Weighted selections are made without replacement. + After an element is selected, it is removed from the pool and the + relative weights of the other elements increase (this + does not match the behavior of :func:`random.sample`'s *counts* + parameter). Note that *weights* may not be used with *counts*. + + If the length of *iterable* is less than *k*, + ``ValueError`` is raised if *strict* is ``True`` and + all elements are returned (in shuffled order) if *strict* is ``False``. + + By default, the `Algorithm L `__ reservoir sampling + technique is used. When *weights* are provided, + `Algorithm A-ExpJ `__ is used instead. + + Notes on reproducibility: + + * The algorithms rely on inexact floating-point functions provided + by the underlying math library (e.g. ``log``, ``log1p``, and ``pow``). + Those functions can `produce slightly different results + `_ on + different builds. Accordingly, selections can vary across builds + even for the same seed. + + * The algorithms loop over the input and make selections based on + ordinal position, so selections from unordered collections (such as + sets) won't reproduce across sessions on the same platform using the + same seed. For example, this won't reproduce:: + + >> seed(8675309) + >> sample(set('abcdefghijklmnopqrstuvwxyz'), 10) + ['c', 'p', 'e', 'w', 's', 'a', 'j', 'd', 'n', 't'] + + """ + iterator = iter(iterable) + + if k < 0: + raise ValueError('k must be non-negative') + + if k == 0: + return [] + + if weights is not None and counts is not None: + raise TypeError('weights and counts are mutually exclusive') + + elif weights is not None: + weights = iter(weights) + return _sample_weighted(iterator, k, weights, strict) + + elif counts is not None: + counts = iter(counts) + return _sample_counted(iterator, k, counts, strict) + + else: + return _sample_unweighted(iterator, k, strict) + + +def is_sorted(iterable, key=None, reverse=False, strict=False): + """Returns ``True`` if the items of iterable are in sorted order, and + ``False`` otherwise. *key* and *reverse* have the same meaning that they do + in the built-in :func:`sorted` function. + + >>> is_sorted(['1', '2', '3', '4', '5'], key=int) + True + >>> is_sorted([5, 4, 3, 1, 2], reverse=True) + False + + If *strict*, tests for strict sorting, that is, returns ``False`` if equal + elements are found: + + >>> is_sorted([1, 2, 2]) + True + >>> is_sorted([1, 2, 2], strict=True) + False + + The function returns ``False`` after encountering the first out-of-order + item, which means it may produce results that differ from the built-in + :func:`sorted` function for objects with unusual comparison dynamics + (like ``math.nan``). If there are no out-of-order items, the iterable is + exhausted. + """ + it = iterable if (key is None) else map(key, iterable) + a, b = tee(it) + next(b, None) + if reverse: + b, a = a, b + return all(map(lt, a, b)) if strict else not any(map(lt, b, a)) + + +class AbortThread(BaseException): + pass + + +class callback_iter: + """Convert a function that uses callbacks to an iterator. + + Let *func* be a function that takes a `callback` keyword argument. + For example: + + >>> def func(callback=None): + ... for i, c in [(1, 'a'), (2, 'b'), (3, 'c')]: + ... if callback: + ... callback(i, c) + ... return 4 + + + Use ``with callback_iter(func)`` to get an iterator over the parameters + that are delivered to the callback. + + >>> with callback_iter(func) as it: + ... for args, kwargs in it: + ... print(args) + (1, 'a') + (2, 'b') + (3, 'c') + + The function will be called in a background thread. The ``done`` property + indicates whether it has completed execution. + + >>> it.done + True + + If it completes successfully, its return value will be available + in the ``result`` property. + + >>> it.result + 4 + + Notes: + + * If the function uses some keyword argument besides ``callback``, supply + *callback_kwd*. + * If it finished executing, but raised an exception, accessing the + ``result`` property will raise the same exception. + * If it hasn't finished executing, accessing the ``result`` + property from within the ``with`` block will raise ``RuntimeError``. + * If it hasn't finished executing, accessing the ``result`` property from + outside the ``with`` block will raise a + ``more_itertools.AbortThread`` exception. + * Provide *wait_seconds* to adjust how frequently the it is polled for + output. + + """ + + def __init__(self, func, callback_kwd='callback', wait_seconds=0.1): + self._func = func + self._callback_kwd = callback_kwd + self._aborted = False + self._future = None + self._wait_seconds = wait_seconds + # Lazily import concurrent.future + self._executor = __import__( + 'concurrent.futures' + ).futures.ThreadPoolExecutor(max_workers=1) + self._iterator = self._reader() + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + self._aborted = True + self._executor.shutdown() + + def __iter__(self): + return self + + def __next__(self): + return next(self._iterator) + + @property + def done(self): + if self._future is None: + return False + return self._future.done() + + @property + def result(self): + if not self.done: + raise RuntimeError('Function has not yet completed') + + return self._future.result() + + def _reader(self): + q = Queue() + + def callback(*args, **kwargs): + if self._aborted: + raise AbortThread('canceled by user') + + q.put((args, kwargs)) + + self._future = self._executor.submit( + self._func, **{self._callback_kwd: callback} + ) + + while True: + try: + item = q.get(timeout=self._wait_seconds) + except Empty: + pass + else: + q.task_done() + yield item + + if self._future.done(): + break + + remaining = [] + while True: + try: + item = q.get_nowait() + except Empty: + break + else: + q.task_done() + remaining.append(item) + q.join() + yield from remaining + + +def windowed_complete(iterable, n): + """ + Yield ``(beginning, middle, end)`` tuples, where: + + * Each ``middle`` has *n* items from *iterable* + * Each ``beginning`` has the items before the ones in ``middle`` + * Each ``end`` has the items after the ones in ``middle`` + + >>> iterable = range(7) + >>> n = 3 + >>> for beginning, middle, end in windowed_complete(iterable, n): + ... print(beginning, middle, end) + () (0, 1, 2) (3, 4, 5, 6) + (0,) (1, 2, 3) (4, 5, 6) + (0, 1) (2, 3, 4) (5, 6) + (0, 1, 2) (3, 4, 5) (6,) + (0, 1, 2, 3) (4, 5, 6) () + + Note that *n* must be at least 0 and most equal to the length of + *iterable*. + + This function will exhaust the iterable and may require significant + storage. + """ + if n < 0: + raise ValueError('n must be >= 0') + + seq = tuple(iterable) + size = len(seq) + + if n > size: + raise ValueError('n must be <= len(seq)') + + for i in range(size - n + 1): + beginning = seq[:i] + middle = seq[i : i + n] + end = seq[i + n :] + yield beginning, middle, end + + +def all_unique(iterable, key=None): + """ + Returns ``True`` if all the elements of *iterable* are unique (no two + elements are equal). + + >>> all_unique('ABCB') + False + + If a *key* function is specified, it will be used to make comparisons. + + >>> all_unique('ABCb') + True + >>> all_unique('ABCb', str.lower) + False + + The function returns as soon as the first non-unique element is + encountered. Iterables with a mix of hashable and unhashable items can + be used, but the function will be slower for unhashable items. + """ + seenset = set() + seenset_add = seenset.add + seenlist = [] + seenlist_add = seenlist.append + for element in map(key, iterable) if key else iterable: + try: + if element in seenset: + return False + seenset_add(element) + except TypeError: + if element in seenlist: + return False + seenlist_add(element) + return True + + +def nth_product(index, *args): + """Equivalent to ``list(product(*args))[index]``. + + The products of *args* can be ordered lexicographically. + :func:`nth_product` computes the product at sort position *index* without + computing the previous products. + + >>> nth_product(8, range(2), range(2), range(2), range(2)) + (1, 0, 0, 0) + + ``IndexError`` will be raised if the given *index* is invalid. + """ + pools = list(map(tuple, reversed(args))) + ns = list(map(len, pools)) + + c = reduce(mul, ns) + + if index < 0: + index += c + + if not 0 <= index < c: + raise IndexError + + result = [] + for pool, n in zip(pools, ns): + result.append(pool[index % n]) + index //= n + + return tuple(reversed(result)) + + +def nth_permutation(iterable, r, index): + """Equivalent to ``list(permutations(iterable, r))[index]``` + + The subsequences of *iterable* that are of length *r* where order is + important can be ordered lexicographically. :func:`nth_permutation` + computes the subsequence at sort position *index* directly, without + computing the previous subsequences. + + >>> nth_permutation('ghijk', 2, 5) + ('h', 'i') + + ``ValueError`` will be raised If *r* is negative or greater than the length + of *iterable*. + ``IndexError`` will be raised if the given *index* is invalid. + """ + pool = list(iterable) + n = len(pool) + + if r is None or r == n: + r, c = n, factorial(n) + elif not 0 <= r < n: + raise ValueError + else: + c = perm(n, r) + assert c > 0 # factorial(n)>0, and r>> nth_combination_with_replacement(range(5), 3, 5) + (0, 1, 1) + + ``ValueError`` will be raised If *r* is negative or greater than the length + of *iterable*. + ``IndexError`` will be raised if the given *index* is invalid. + """ + pool = tuple(iterable) + n = len(pool) + if (r < 0) or (r > n): + raise ValueError + + c = comb(n + r - 1, r) + + if index < 0: + index += c + + if (index < 0) or (index >= c): + raise IndexError + + result = [] + i = 0 + while r: + r -= 1 + while n >= 0: + num_combs = comb(n + r - 1, r) + if index < num_combs: + break + n -= 1 + i += 1 + index -= num_combs + result.append(pool[i]) + + return tuple(result) + + +def value_chain(*args): + """Yield all arguments passed to the function in the same order in which + they were passed. If an argument itself is iterable then iterate over its + values. + + >>> list(value_chain(1, 2, 3, [4, 5, 6])) + [1, 2, 3, 4, 5, 6] + + Binary and text strings are not considered iterable and are emitted + as-is: + + >>> list(value_chain('12', '34', ['56', '78'])) + ['12', '34', '56', '78'] + + Pre- or postpend a single element to an iterable: + + >>> list(value_chain(1, [2, 3, 4, 5, 6])) + [1, 2, 3, 4, 5, 6] + >>> list(value_chain([1, 2, 3, 4, 5], 6)) + [1, 2, 3, 4, 5, 6] + + Multiple levels of nesting are not flattened. + + """ + for value in args: + if isinstance(value, (str, bytes)): + yield value + continue + try: + yield from value + except TypeError: + yield value + + +def product_index(element, *args): + """Equivalent to ``list(product(*args)).index(element)`` + + The products of *args* can be ordered lexicographically. + :func:`product_index` computes the first index of *element* without + computing the previous products. + + >>> product_index([8, 2], range(10), range(5)) + 42 + + ``ValueError`` will be raised if the given *element* isn't in the product + of *args*. + """ + index = 0 + + for x, pool in zip_longest(element, args, fillvalue=_marker): + if x is _marker or pool is _marker: + raise ValueError('element is not a product of args') + + pool = tuple(pool) + index = index * len(pool) + pool.index(x) + + return index + + +def combination_index(element, iterable): + """Equivalent to ``list(combinations(iterable, r)).index(element)`` + + The subsequences of *iterable* that are of length *r* can be ordered + lexicographically. :func:`combination_index` computes the index of the + first *element*, without computing the previous combinations. + + >>> combination_index('adf', 'abcdefg') + 10 + + ``ValueError`` will be raised if the given *element* isn't one of the + combinations of *iterable*. + """ + element = enumerate(element) + k, y = next(element, (None, None)) + if k is None: + return 0 + + indexes = [] + pool = enumerate(iterable) + for n, x in pool: + if x == y: + indexes.append(n) + tmp, y = next(element, (None, None)) + if tmp is None: + break + else: + k = tmp + else: + raise ValueError('element is not a combination of iterable') + + n, _ = last(pool, default=(n, None)) + + # Python versions below 3.8 don't have math.comb + index = 1 + for i, j in enumerate(reversed(indexes), start=1): + j = n - j + if i <= j: + index += comb(j, i) + + return comb(n + 1, k + 1) - index + + +def combination_with_replacement_index(element, iterable): + """Equivalent to + ``list(combinations_with_replacement(iterable, r)).index(element)`` + + The subsequences with repetition of *iterable* that are of length *r* can + be ordered lexicographically. :func:`combination_with_replacement_index` + computes the index of the first *element*, without computing the previous + combinations with replacement. + + >>> combination_with_replacement_index('adf', 'abcdefg') + 20 + + ``ValueError`` will be raised if the given *element* isn't one of the + combinations with replacement of *iterable*. + """ + element = tuple(element) + l = len(element) + element = enumerate(element) + + k, y = next(element, (None, None)) + if k is None: + return 0 + + indexes = [] + pool = tuple(iterable) + for n, x in enumerate(pool): + while x == y: + indexes.append(n) + tmp, y = next(element, (None, None)) + if tmp is None: + break + else: + k = tmp + if y is None: + break + else: + raise ValueError( + 'element is not a combination with replacement of iterable' + ) + + n = len(pool) + occupations = [0] * n + for p in indexes: + occupations[p] += 1 + + index = 0 + cumulative_sum = 0 + for k in range(1, n): + cumulative_sum += occupations[k - 1] + j = l + n - 1 - k - cumulative_sum + i = n - k + if i <= j: + index += comb(j, i) + + return index + + +def permutation_index(element, iterable): + """Equivalent to ``list(permutations(iterable, r)).index(element)``` + + The subsequences of *iterable* that are of length *r* where order is + important can be ordered lexicographically. :func:`permutation_index` + computes the index of the first *element* directly, without computing + the previous permutations. + + >>> permutation_index([1, 3, 2], range(5)) + 19 + + ``ValueError`` will be raised if the given *element* isn't one of the + permutations of *iterable*. + """ + index = 0 + pool = list(iterable) + for i, x in zip(range(len(pool), -1, -1), element): + r = pool.index(x) + index = index * i + r + del pool[r] + + return index + + +class countable: + """Wrap *iterable* and keep a count of how many items have been consumed. + + The ``items_seen`` attribute starts at ``0`` and increments as the iterable + is consumed: + + >>> iterable = map(str, range(10)) + >>> it = countable(iterable) + >>> it.items_seen + 0 + >>> next(it), next(it) + ('0', '1') + >>> list(it) + ['2', '3', '4', '5', '6', '7', '8', '9'] + >>> it.items_seen + 10 + """ + + def __init__(self, iterable): + self._iterator = iter(iterable) + self.items_seen = 0 + + def __iter__(self): + return self + + def __next__(self): + item = next(self._iterator) + self.items_seen += 1 + + return item + + +def chunked_even(iterable, n): + """Break *iterable* into lists of approximately length *n*. + Items are distributed such the lengths of the lists differ by at most + 1 item. + + >>> iterable = [1, 2, 3, 4, 5, 6, 7] + >>> n = 3 + >>> list(chunked_even(iterable, n)) # List lengths: 3, 2, 2 + [[1, 2, 3], [4, 5], [6, 7]] + >>> list(chunked(iterable, n)) # List lengths: 3, 3, 1 + [[1, 2, 3], [4, 5, 6], [7]] + + """ + iterator = iter(iterable) + + # Initialize a buffer to process the chunks while keeping + # some back to fill any underfilled chunks + min_buffer = (n - 1) * (n - 2) + buffer = list(islice(iterator, min_buffer)) + + # Append items until we have a completed chunk + for _ in islice(map(buffer.append, iterator), n, None, n): + yield buffer[:n] + del buffer[:n] + + # Check if any chunks need addition processing + if not buffer: + return + length = len(buffer) + + # Chunks are either size `full_size <= n` or `partial_size = full_size - 1` + q, r = divmod(length, n) + num_lists = q + (1 if r > 0 else 0) + q, r = divmod(length, num_lists) + full_size = q + (1 if r > 0 else 0) + partial_size = full_size - 1 + num_full = length - partial_size * num_lists + + # Yield chunks of full size + partial_start_idx = num_full * full_size + if full_size > 0: + for i in range(0, partial_start_idx, full_size): + yield buffer[i : i + full_size] + + # Yield chunks of partial size + if partial_size > 0: + for i in range(partial_start_idx, length, partial_size): + yield buffer[i : i + partial_size] + + +def zip_broadcast(*objects, scalar_types=(str, bytes), strict=False): + """A version of :func:`zip` that "broadcasts" any scalar + (i.e., non-iterable) items into output tuples. + + >>> iterable_1 = [1, 2, 3] + >>> iterable_2 = ['a', 'b', 'c'] + >>> scalar = '_' + >>> list(zip_broadcast(iterable_1, iterable_2, scalar)) + [(1, 'a', '_'), (2, 'b', '_'), (3, 'c', '_')] + + The *scalar_types* keyword argument determines what types are considered + scalar. It is set to ``(str, bytes)`` by default. Set it to ``None`` to + treat strings and byte strings as iterable: + + >>> list(zip_broadcast('abc', 0, 'xyz', scalar_types=None)) + [('a', 0, 'x'), ('b', 0, 'y'), ('c', 0, 'z')] + + If the *strict* keyword argument is ``True``, then + ``UnequalIterablesError`` will be raised if any of the iterables have + different lengths. + """ + + def is_scalar(obj): + if scalar_types and isinstance(obj, scalar_types): + return True + try: + iter(obj) + except TypeError: + return True + else: + return False + + size = len(objects) + if not size: + return + + new_item = [None] * size + iterables, iterable_positions = [], [] + for i, obj in enumerate(objects): + if is_scalar(obj): + new_item[i] = obj + else: + iterables.append(iter(obj)) + iterable_positions.append(i) + + if not iterables: + yield tuple(objects) + return + + zipper = _zip_equal if strict else zip + for item in zipper(*iterables): + for i, new_item[i] in zip(iterable_positions, item): + pass + yield tuple(new_item) + + +def unique_in_window(iterable, n, key=None): + """Yield the items from *iterable* that haven't been seen recently. + *n* is the size of the lookback window. + + >>> iterable = [0, 1, 0, 2, 3, 0] + >>> n = 3 + >>> list(unique_in_window(iterable, n)) + [0, 1, 2, 3, 0] + + The *key* function, if provided, will be used to determine uniqueness: + + >>> list(unique_in_window('abAcda', 3, key=lambda x: x.lower())) + ['a', 'b', 'c', 'd', 'a'] + + The items in *iterable* must be hashable. + + """ + if n <= 0: + raise ValueError('n must be greater than 0') + + window = deque(maxlen=n) + counts = defaultdict(int) + use_key = key is not None + + for item in iterable: + if len(window) == n: + to_discard = window[0] + if counts[to_discard] == 1: + del counts[to_discard] + else: + counts[to_discard] -= 1 + + k = key(item) if use_key else item + if k not in counts: + yield item + counts[k] += 1 + window.append(k) + + +def duplicates_everseen(iterable, key=None): + """Yield duplicate elements after their first appearance. + + >>> list(duplicates_everseen('mississippi')) + ['s', 'i', 's', 's', 'i', 'p', 'i'] + >>> list(duplicates_everseen('AaaBbbCccAaa', str.lower)) + ['a', 'a', 'b', 'b', 'c', 'c', 'A', 'a', 'a'] + + This function is analogous to :func:`unique_everseen` and is subject to + the same performance considerations. + + """ + seen_set = set() + seen_list = [] + use_key = key is not None + + for element in iterable: + k = key(element) if use_key else element + try: + if k not in seen_set: + seen_set.add(k) + else: + yield element + except TypeError: + if k not in seen_list: + seen_list.append(k) + else: + yield element + + +def duplicates_justseen(iterable, key=None): + """Yields serially-duplicate elements after their first appearance. + + >>> list(duplicates_justseen('mississippi')) + ['s', 's', 'p'] + >>> list(duplicates_justseen('AaaBbbCccAaa', str.lower)) + ['a', 'a', 'b', 'b', 'c', 'c', 'a', 'a'] + + This function is analogous to :func:`unique_justseen`. + + """ + return flatten(g for _, g in groupby(iterable, key) for _ in g) + + +def classify_unique(iterable, key=None): + """Classify each element in terms of its uniqueness. + + For each element in the input iterable, return a 3-tuple consisting of: + + 1. The element itself + 2. ``False`` if the element is equal to the one preceding it in the input, + ``True`` otherwise (i.e. the equivalent of :func:`unique_justseen`) + 3. ``False`` if this element has been seen anywhere in the input before, + ``True`` otherwise (i.e. the equivalent of :func:`unique_everseen`) + + >>> list(classify_unique('otto')) # doctest: +NORMALIZE_WHITESPACE + [('o', True, True), + ('t', True, True), + ('t', False, False), + ('o', True, False)] + + This function is analogous to :func:`unique_everseen` and is subject to + the same performance considerations. + + """ + seen_set = set() + seen_list = [] + use_key = key is not None + previous = None + + for i, element in enumerate(iterable): + k = key(element) if use_key else element + is_unique_justseen = not i or previous != k + previous = k + is_unique_everseen = False + try: + if k not in seen_set: + seen_set.add(k) + is_unique_everseen = True + except TypeError: + if k not in seen_list: + seen_list.append(k) + is_unique_everseen = True + yield element, is_unique_justseen, is_unique_everseen + + +def minmax(iterable_or_value, *others, key=None, default=_marker): + """Returns both the smallest and largest items from an iterable + or from two or more arguments. + + >>> minmax([3, 1, 5]) + (1, 5) + + >>> minmax(4, 2, 6) + (2, 6) + + If a *key* function is provided, it will be used to transform the input + items for comparison. + + >>> minmax([5, 30], key=str) # '30' sorts before '5' + (30, 5) + + If a *default* value is provided, it will be returned if there are no + input items. + + >>> minmax([], default=(0, 0)) + (0, 0) + + Otherwise ``ValueError`` is raised. + + This function makes a single pass over the input elements and takes care to + minimize the number of comparisons made during processing. + + Note that unlike the builtin ``max`` function, which always returns the first + item with the maximum value, this function may return another item when there are + ties. + + This function is based on the + `recipe `__ by + Raymond Hettinger. + """ + iterable = (iterable_or_value, *others) if others else iterable_or_value + + it = iter(iterable) + + try: + lo = hi = next(it) + except StopIteration as exc: + if default is _marker: + raise ValueError( + '`minmax()` argument is an empty iterable. ' + 'Provide a `default` value to suppress this error.' + ) from exc + return default + + # Different branches depending on the presence of key. This saves a lot + # of unimportant copies which would slow the "key=None" branch + # significantly down. + if key is None: + for x, y in zip_longest(it, it, fillvalue=lo): + if y < x: + x, y = y, x + if x < lo: + lo = x + if hi < y: + hi = y + + else: + lo_key = hi_key = key(lo) + + for x, y in zip_longest(it, it, fillvalue=lo): + x_key, y_key = key(x), key(y) + + if y_key < x_key: + x, y, x_key, y_key = y, x, y_key, x_key + if x_key < lo_key: + lo, lo_key = x, x_key + if hi_key < y_key: + hi, hi_key = y, y_key + + return lo, hi + + +def constrained_batches( + iterable, max_size, max_count=None, get_len=len, strict=True +): + """Yield batches of items from *iterable* with a combined size limited by + *max_size*. + + >>> iterable = [b'12345', b'123', b'12345678', b'1', b'1', b'12', b'1'] + >>> list(constrained_batches(iterable, 10)) + [(b'12345', b'123'), (b'12345678', b'1', b'1'), (b'12', b'1')] + + If a *max_count* is supplied, the number of items per batch is also + limited: + + >>> iterable = [b'12345', b'123', b'12345678', b'1', b'1', b'12', b'1'] + >>> list(constrained_batches(iterable, 10, max_count = 2)) + [(b'12345', b'123'), (b'12345678', b'1'), (b'1', b'12'), (b'1',)] + + If a *get_len* function is supplied, use that instead of :func:`len` to + determine item size. + + If *strict* is ``True``, raise ``ValueError`` if any single item is bigger + than *max_size*. Otherwise, allow single items to exceed *max_size*. + """ + if max_size <= 0: + raise ValueError('maximum size must be greater than zero') + + batch = [] + batch_size = 0 + batch_count = 0 + for item in iterable: + item_len = get_len(item) + if strict and item_len > max_size: + raise ValueError('item size exceeds maximum size') + + reached_count = batch_count == max_count + reached_size = item_len + batch_size > max_size + if batch_count and (reached_size or reached_count): + yield tuple(batch) + batch.clear() + batch_size = 0 + batch_count = 0 + + batch.append(item) + batch_size += item_len + batch_count += 1 + + if batch: + yield tuple(batch) + + +def gray_product(*iterables): + """Like :func:`itertools.product`, but return tuples in an order such + that only one element in the generated tuple changes from one iteration + to the next. + + >>> list(gray_product('AB','CD')) + [('A', 'C'), ('B', 'C'), ('B', 'D'), ('A', 'D')] + + This function consumes all of the input iterables before producing output. + If any of the input iterables have fewer than two items, ``ValueError`` + is raised. + + For information on the algorithm, see + `this section `__ + of Donald Knuth's *The Art of Computer Programming*. + """ + all_iterables = tuple(tuple(x) for x in iterables) + iterable_count = len(all_iterables) + for iterable in all_iterables: + if len(iterable) < 2: + raise ValueError("each iterable must have two or more items") + + # This is based on "Algorithm H" from section 7.2.1.1, page 20. + # a holds the indexes of the source iterables for the n-tuple to be yielded + # f is the array of "focus pointers" + # o is the array of "directions" + a = [0] * iterable_count + f = list(range(iterable_count + 1)) + o = [1] * iterable_count + while True: + yield tuple(all_iterables[i][a[i]] for i in range(iterable_count)) + j = f[0] + f[0] = 0 + if j == iterable_count: + break + a[j] = a[j] + o[j] + if a[j] == 0 or a[j] == len(all_iterables[j]) - 1: + o[j] = -o[j] + f[j] = f[j + 1] + f[j + 1] = j + 1 + + +def partial_product(*iterables): + """Yields tuples containing one item from each iterator, with subsequent + tuples changing a single item at a time by advancing each iterator until it + is exhausted. This sequence guarantees every value in each iterable is + output at least once without generating all possible combinations. + + This may be useful, for example, when testing an expensive function. + + >>> list(partial_product('AB', 'C', 'DEF')) + [('A', 'C', 'D'), ('B', 'C', 'D'), ('B', 'C', 'E'), ('B', 'C', 'F')] + """ + + iterators = list(map(iter, iterables)) + + try: + prod = [next(it) for it in iterators] + except StopIteration: + return + yield tuple(prod) + + for i, it in enumerate(iterators): + for prod[i] in it: + yield tuple(prod) + + +def takewhile_inclusive(predicate, iterable): + """A variant of :func:`takewhile` that yields one additional element. + + >>> list(takewhile_inclusive(lambda x: x < 5, [1, 4, 6, 4, 1])) + [1, 4, 6] + + :func:`takewhile` would return ``[1, 4]``. + """ + for x in iterable: + yield x + if not predicate(x): + break + + +def outer_product(func, xs, ys, *args, **kwargs): + """A generalized outer product that applies a binary function to all + pairs of items. Returns a 2D matrix with ``len(xs)`` rows and ``len(ys)`` + columns. + Also accepts ``*args`` and ``**kwargs`` that are passed to ``func``. + + Multiplication table: + + >>> list(outer_product(mul, range(1, 4), range(1, 6))) + [(1, 2, 3, 4, 5), (2, 4, 6, 8, 10), (3, 6, 9, 12, 15)] + + Cross tabulation: + + >>> xs = ['A', 'B', 'A', 'A', 'B', 'B', 'A', 'A', 'B', 'B'] + >>> ys = ['X', 'X', 'X', 'Y', 'Z', 'Z', 'Y', 'Y', 'Z', 'Z'] + >>> pair_counts = Counter(zip(xs, ys)) + >>> count_rows = lambda x, y: pair_counts[x, y] + >>> list(outer_product(count_rows, sorted(set(xs)), sorted(set(ys)))) + [(2, 3, 0), (1, 0, 4)] + + Usage with ``*args`` and ``**kwargs``: + + >>> animals = ['cat', 'wolf', 'mouse'] + >>> list(outer_product(min, animals, animals, key=len)) + [('cat', 'cat', 'cat'), ('cat', 'wolf', 'wolf'), ('cat', 'wolf', 'mouse')] + """ + ys = tuple(ys) + return batched( + starmap(lambda x, y: func(x, y, *args, **kwargs), product(xs, ys)), + n=len(ys), + ) + + +def iter_suppress(iterable, *exceptions): + """Yield each of the items from *iterable*. If the iteration raises one of + the specified *exceptions*, that exception will be suppressed and iteration + will stop. + + >>> from itertools import chain + >>> def breaks_at_five(x): + ... while True: + ... if x >= 5: + ... raise RuntimeError + ... yield x + ... x += 1 + >>> it_1 = iter_suppress(breaks_at_five(1), RuntimeError) + >>> it_2 = iter_suppress(breaks_at_five(2), RuntimeError) + >>> list(chain(it_1, it_2)) + [1, 2, 3, 4, 2, 3, 4] + """ + try: + yield from iterable + except exceptions: + return + + +def filter_map(func, iterable): + """Apply *func* to every element of *iterable*, yielding only those which + are not ``None``. + + >>> elems = ['1', 'a', '2', 'b', '3'] + >>> list(filter_map(lambda s: int(s) if s.isnumeric() else None, elems)) + [1, 2, 3] + """ + for x in iterable: + y = func(x) + if y is not None: + yield y + + +def powerset_of_sets(iterable): + """Yields all possible subsets of the iterable. + + >>> list(powerset_of_sets([1, 2, 3])) # doctest: +SKIP + [set(), {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3}] + >>> list(powerset_of_sets([1, 1, 0])) # doctest: +SKIP + [set(), {1}, {0}, {0, 1}] + + :func:`powerset_of_sets` takes care to minimize the number + of hash operations performed. + """ + sets = tuple(dict.fromkeys(map(frozenset, zip(iterable)))) + return chain.from_iterable( + starmap(set().union, combinations(sets, r)) + for r in range(len(sets) + 1) + ) + + +def join_mappings(**field_to_map): + """ + Joins multiple mappings together using their common keys. + + >>> user_scores = {'elliot': 50, 'claris': 60} + >>> user_times = {'elliot': 30, 'claris': 40} + >>> join_mappings(score=user_scores, time=user_times) + {'elliot': {'score': 50, 'time': 30}, 'claris': {'score': 60, 'time': 40}} + """ + ret = defaultdict(dict) + + for field_name, mapping in field_to_map.items(): + for key, value in mapping.items(): + ret[key][field_name] = value + + return dict(ret) + + +def _complex_sumprod(v1, v2): + """High precision sumprod() for complex numbers. + Used by :func:`dft` and :func:`idft`. + """ + + real = attrgetter('real') + imag = attrgetter('imag') + r1 = chain(map(real, v1), map(neg, map(imag, v1))) + r2 = chain(map(real, v2), map(imag, v2)) + i1 = chain(map(real, v1), map(imag, v1)) + i2 = chain(map(imag, v2), map(real, v2)) + return complex(_fsumprod(r1, r2), _fsumprod(i1, i2)) + + +def dft(xarr): + """Discrete Fourier Transform. *xarr* is a sequence of complex numbers. + Yields the components of the corresponding transformed output vector. + + >>> import cmath + >>> xarr = [1, 2-1j, -1j, -1+2j] # time domain + >>> Xarr = [2, -2-2j, -2j, 4+4j] # frequency domain + >>> magnitudes, phases = zip(*map(cmath.polar, Xarr)) + >>> all(map(cmath.isclose, dft(xarr), Xarr)) + True + + Inputs are restricted to numeric types that can add and multiply + with a complex number. This includes int, float, complex, and + Fraction, but excludes Decimal. + + See :func:`idft` for the inverse Discrete Fourier Transform. + """ + N = len(xarr) + roots_of_unity = [e ** (n / N * tau * -1j) for n in range(N)] + for k in range(N): + coeffs = [roots_of_unity[k * n % N] for n in range(N)] + yield _complex_sumprod(xarr, coeffs) + + +def idft(Xarr): + """Inverse Discrete Fourier Transform. *Xarr* is a sequence of + complex numbers. Yields the components of the corresponding + inverse-transformed output vector. + + >>> import cmath + >>> xarr = [1, 2-1j, -1j, -1+2j] # time domain + >>> Xarr = [2, -2-2j, -2j, 4+4j] # frequency domain + >>> all(map(cmath.isclose, idft(Xarr), xarr)) + True + + Inputs are restricted to numeric types that can add and multiply + with a complex number. This includes int, float, complex, and + Fraction, but excludes Decimal. + + See :func:`dft` for the Discrete Fourier Transform. + """ + N = len(Xarr) + roots_of_unity = [e ** (n / N * tau * 1j) for n in range(N)] + for k in range(N): + coeffs = [roots_of_unity[k * n % N] for n in range(N)] + yield _complex_sumprod(Xarr, coeffs) / N + + +def doublestarmap(func, iterable): + """Apply *func* to every item of *iterable* by dictionary unpacking + the item into *func*. + + The difference between :func:`itertools.starmap` and :func:`doublestarmap` + parallels the distinction between ``func(*a)`` and ``func(**a)``. + + >>> iterable = [{'a': 1, 'b': 2}, {'a': 40, 'b': 60}] + >>> list(doublestarmap(lambda a, b: a + b, iterable)) + [3, 100] + + ``TypeError`` will be raised if *func*'s signature doesn't match the + mapping contained in *iterable* or if *iterable* does not contain mappings. + """ + for item in iterable: + yield func(**item) + + +def _nth_prime_bounds(n): + """Bounds for the nth prime (counting from 1): lb < p_n < ub.""" + # At and above 688,383, the lb/ub spread is under 0.003 * p_n. + + if n < 1: + raise ValueError + + if n < 6: + return (n, 2.25 * n) + + # https://en.wikipedia.org/wiki/Prime-counting_function#Inequalities + upper_bound = n * log(n * log(n)) + lower_bound = upper_bound - n + if n >= 688_383: + upper_bound -= n * (1.0 - (log(log(n)) - 2.0) / log(n)) + + return lower_bound, upper_bound + + +def nth_prime(n, *, approximate=False): + """Return the nth prime (counting from 0). + + >>> nth_prime(0) + 2 + >>> nth_prime(100) + 547 + + If *approximate* is set to True, will return a prime close + to the nth prime. The estimation is much faster than computing + an exact result. + + >>> nth_prime(200_000_000, approximate=True) # Exact result is 4222234763 + 4217820427 + + """ + lb, ub = _nth_prime_bounds(n + 1) + + if not approximate or n <= 1_000_000: + return nth(sieve(ceil(ub)), n) + + # Search from the midpoint and return the first odd prime + odd = floor((lb + ub) / 2) | 1 + return first_true(count(odd, step=2), pred=is_prime) + + +def argmin(iterable, *, key=None): + """ + Index of the first occurrence of a minimum value in an iterable. + + >>> argmin('efghabcdijkl') + 4 + >>> argmin([3, 2, 1, 0, 4, 2, 1, 0]) + 3 + + For example, look up a label corresponding to the position + of a value that minimizes a cost function:: + + >>> def cost(x): + ... "Days for a wound to heal given a subject's age." + ... return x**2 - 20*x + 150 + ... + >>> labels = ['homer', 'marge', 'bart', 'lisa', 'maggie'] + >>> ages = [ 35, 30, 10, 9, 1 ] + + # Fastest healing family member + >>> labels[argmin(ages, key=cost)] + 'bart' + + # Age with fastest healing + >>> min(ages, key=cost) + 10 + + """ + if key is not None: + iterable = map(key, iterable) + return min(enumerate(iterable), key=itemgetter(1))[0] + + +def argmax(iterable, *, key=None): + """ + Index of the first occurrence of a maximum value in an iterable. + + >>> argmax('abcdefghabcd') + 7 + >>> argmax([0, 1, 2, 3, 3, 2, 1, 0]) + 3 + + For example, identify the best machine learning model:: + + >>> models = ['svm', 'random forest', 'knn', 'naïve bayes'] + >>> accuracy = [ 68, 61, 84, 72 ] + + # Most accurate model + >>> models[argmax(accuracy)] + 'knn' + + # Best accuracy + >>> max(accuracy) + 84 + + """ + if key is not None: + iterable = map(key, iterable) + return max(enumerate(iterable), key=itemgetter(1))[0] + + +def extract(iterable, indices): + """Yield values at the specified indices. + + Example: + + >>> data = 'abcdefghijklmnopqrstuvwxyz' + >>> list(extract(data, [7, 4, 11, 11, 14])) + ['h', 'e', 'l', 'l', 'o'] + + The *iterable* is consumed lazily and can be infinite. + The *indices* are consumed immediately and must be finite. + + Raises ``IndexError`` if an index lies beyond the iterable. + Raises ``ValueError`` for negative indices. + """ + + iterator = iter(iterable) + index_and_position = sorted(zip(indices, count())) + + if index_and_position and index_and_position[0][0] < 0: + raise ValueError('Indices must be non-negative') + + buffer = {} + iterator_position = -1 + next_to_emit = 0 + + for index, order in index_and_position: + advance = index - iterator_position + if advance: + try: + value = next(islice(iterator, advance - 1, None)) + except StopIteration: + raise IndexError(index) + iterator_position = index + + buffer[order] = value + + while next_to_emit in buffer: + yield buffer.pop(next_to_emit) + next_to_emit += 1 diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/more.pyi b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/more.pyi new file mode 100644 index 0000000000000000000000000000000000000000..b5e33f8b747f70ae8c842c07dca5005449241a62 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/more.pyi @@ -0,0 +1,949 @@ +"""Stubs for more_itertools.more""" + +from __future__ import annotations + +import sys +import types + +from collections.abc import ( + Container, + Hashable, + Iterable, + Iterator, + Mapping, + Reversible, + Sequence, + Sized, +) +from contextlib import AbstractContextManager +from typing import ( + Any, + Callable, + Generic, + TypeVar, + overload, + type_check_only, +) +from typing_extensions import Protocol + +__all__ = [ + 'AbortThread', + 'SequenceView', + 'UnequalIterablesError', + 'adjacent', + 'all_unique', + 'always_iterable', + 'always_reversible', + 'argmax', + 'argmin', + 'bucket', + 'callback_iter', + 'chunked', + 'chunked_even', + 'circular_shifts', + 'collapse', + 'combination_index', + 'combination_with_replacement_index', + 'consecutive_groups', + 'constrained_batches', + 'consumer', + 'count_cycle', + 'countable', + 'derangements', + 'dft', + 'difference', + 'distinct_combinations', + 'distinct_permutations', + 'distribute', + 'divide', + 'doublestarmap', + 'duplicates_everseen', + 'duplicates_justseen', + 'classify_unique', + 'exactly_n', + 'extract', + 'filter_except', + 'filter_map', + 'first', + 'gray_product', + 'groupby_transform', + 'ichunked', + 'iequals', + 'idft', + 'ilen', + 'interleave', + 'interleave_evenly', + 'interleave_longest', + 'interleave_randomly', + 'intersperse', + 'is_sorted', + 'islice_extended', + 'iterate', + 'iter_suppress', + 'join_mappings', + 'last', + 'locate', + 'longest_common_prefix', + 'lstrip', + 'make_decorator', + 'map_except', + 'map_if', + 'map_reduce', + 'mark_ends', + 'minmax', + 'nth_or_last', + 'nth_permutation', + 'nth_prime', + 'nth_product', + 'nth_combination_with_replacement', + 'numeric_range', + 'one', + 'only', + 'outer_product', + 'padded', + 'partial_product', + 'partitions', + 'peekable', + 'permutation_index', + 'powerset_of_sets', + 'product_index', + 'raise_', + 'repeat_each', + 'repeat_last', + 'replace', + 'rlocate', + 'rstrip', + 'run_length', + 'sample', + 'seekable', + 'set_partitions', + 'side_effect', + 'sliced', + 'sort_together', + 'split_after', + 'split_at', + 'split_before', + 'split_into', + 'split_when', + 'spy', + 'stagger', + 'strip', + 'strictly_n', + 'substrings', + 'substrings_indexes', + 'takewhile_inclusive', + 'time_limited', + 'unique_in_window', + 'unique_to_each', + 'unzip', + 'value_chain', + 'windowed', + 'windowed_complete', + 'with_iter', + 'zip_broadcast', + 'zip_equal', + 'zip_offset', +] + +# Type and type variable definitions +_T = TypeVar('_T') +_T1 = TypeVar('_T1') +_T2 = TypeVar('_T2') +_T3 = TypeVar('_T3') +_T4 = TypeVar('_T4') +_T5 = TypeVar('_T5') +_U = TypeVar('_U') +_V = TypeVar('_V') +_W = TypeVar('_W') +_T_co = TypeVar('_T_co', covariant=True) +_GenFn = TypeVar('_GenFn', bound=Callable[..., Iterator[Any]]) +_Raisable = BaseException | type[BaseException] + +# The type of isinstance's second argument (from typeshed builtins) +if sys.version_info >= (3, 10): + _ClassInfo = type | types.UnionType | tuple[_ClassInfo, ...] +else: + _ClassInfo = type | tuple[_ClassInfo, ...] + +@type_check_only +class _SizedIterable(Protocol[_T_co], Sized, Iterable[_T_co]): ... + +@type_check_only +class _SizedReversible(Protocol[_T_co], Sized, Reversible[_T_co]): ... + +@type_check_only +class _SupportsSlicing(Protocol[_T_co]): + def __getitem__(self, __k: slice) -> _T_co: ... + +def chunked( + iterable: Iterable[_T], n: int | None, strict: bool = ... +) -> Iterator[list[_T]]: ... +@overload +def first(iterable: Iterable[_T]) -> _T: ... +@overload +def first(iterable: Iterable[_T], default: _U) -> _T | _U: ... +@overload +def last(iterable: Iterable[_T]) -> _T: ... +@overload +def last(iterable: Iterable[_T], default: _U) -> _T | _U: ... +@overload +def nth_or_last(iterable: Iterable[_T], n: int) -> _T: ... +@overload +def nth_or_last(iterable: Iterable[_T], n: int, default: _U) -> _T | _U: ... + +class peekable(Generic[_T], Iterator[_T]): + def __init__(self, iterable: Iterable[_T]) -> None: ... + def __iter__(self) -> peekable[_T]: ... + def __bool__(self) -> bool: ... + @overload + def peek(self) -> _T: ... + @overload + def peek(self, default: _U) -> _T | _U: ... + def prepend(self, *items: _T) -> None: ... + def __next__(self) -> _T: ... + @overload + def __getitem__(self, index: int) -> _T: ... + @overload + def __getitem__(self, index: slice) -> list[_T]: ... + +def consumer(func: _GenFn) -> _GenFn: ... +def ilen(iterable: Iterable[_T]) -> int: ... +def iterate(func: Callable[[_T], _T], start: _T) -> Iterator[_T]: ... +def with_iter( + context_manager: AbstractContextManager[Iterable[_T]], +) -> Iterator[_T]: ... +def one( + iterable: Iterable[_T], + too_short: _Raisable | None = ..., + too_long: _Raisable | None = ..., +) -> _T: ... +def raise_(exception: _Raisable, *args: Any) -> None: ... +def strictly_n( + iterable: Iterable[_T], + n: int, + too_short: _GenFn | None = ..., + too_long: _GenFn | None = ..., +) -> list[_T]: ... +def distinct_permutations( + iterable: Iterable[_T], r: int | None = ... +) -> Iterator[tuple[_T, ...]]: ... +def derangements( + iterable: Iterable[_T], r: int | None = None +) -> Iterator[tuple[_T, ...]]: ... +def intersperse( + e: _U, iterable: Iterable[_T], n: int = ... +) -> Iterator[_T | _U]: ... +def unique_to_each(*iterables: Iterable[_T]) -> list[list[_T]]: ... +@overload +def windowed( + seq: Iterable[_T], n: int, *, step: int = ... +) -> Iterator[tuple[_T | None, ...]]: ... +@overload +def windowed( + seq: Iterable[_T], n: int, fillvalue: _U, step: int = ... +) -> Iterator[tuple[_T | _U, ...]]: ... +def substrings(iterable: Iterable[_T]) -> Iterator[tuple[_T, ...]]: ... +def substrings_indexes( + seq: Sequence[_T], reverse: bool = ... +) -> Iterator[tuple[Sequence[_T], int, int]]: ... + +class bucket(Generic[_T, _U], Container[_U]): + def __init__( + self, + iterable: Iterable[_T], + key: Callable[[_T], _U], + validator: Callable[[_U], object] | None = ..., + ) -> None: ... + def __contains__(self, value: object) -> bool: ... + def __iter__(self) -> Iterator[_U]: ... + def __getitem__(self, value: object) -> Iterator[_T]: ... + +def spy( + iterable: Iterable[_T], n: int = ... +) -> tuple[list[_T], Iterator[_T]]: ... +def interleave(*iterables: Iterable[_T]) -> Iterator[_T]: ... +def interleave_longest(*iterables: Iterable[_T]) -> Iterator[_T]: ... +def interleave_evenly( + iterables: list[Iterable[_T]], lengths: list[int] | None = ... +) -> Iterator[_T]: ... +def interleave_randomly(*iterables: Iterable[_T]) -> Iterable[_T]: ... +def collapse( + iterable: Iterable[Any], + base_type: _ClassInfo | None = ..., + levels: int | None = ..., +) -> Iterator[Any]: ... +@overload +def side_effect( + func: Callable[[_T], object], + iterable: Iterable[_T], + chunk_size: None = ..., + before: Callable[[], object] | None = ..., + after: Callable[[], object] | None = ..., +) -> Iterator[_T]: ... +@overload +def side_effect( + func: Callable[[list[_T]], object], + iterable: Iterable[_T], + chunk_size: int, + before: Callable[[], object] | None = ..., + after: Callable[[], object] | None = ..., +) -> Iterator[_T]: ... +def sliced( + seq: _SupportsSlicing[_T], n: int, strict: bool = ... +) -> Iterator[_T]: ... +def split_at( + iterable: Iterable[_T], + pred: Callable[[_T], object], + maxsplit: int = ..., + keep_separator: bool = ..., +) -> Iterator[list[_T]]: ... +def split_before( + iterable: Iterable[_T], pred: Callable[[_T], object], maxsplit: int = ... +) -> Iterator[list[_T]]: ... +def split_after( + iterable: Iterable[_T], pred: Callable[[_T], object], maxsplit: int = ... +) -> Iterator[list[_T]]: ... +def split_when( + iterable: Iterable[_T], + pred: Callable[[_T, _T], object], + maxsplit: int = ..., +) -> Iterator[list[_T]]: ... +def split_into( + iterable: Iterable[_T], sizes: Iterable[int | None] +) -> Iterator[list[_T]]: ... +@overload +def padded( + iterable: Iterable[_T], + *, + n: int | None = ..., + next_multiple: bool = ..., +) -> Iterator[_T | None]: ... +@overload +def padded( + iterable: Iterable[_T], + fillvalue: _U, + n: int | None = ..., + next_multiple: bool = ..., +) -> Iterator[_T | _U]: ... +@overload +def repeat_last(iterable: Iterable[_T]) -> Iterator[_T]: ... +@overload +def repeat_last(iterable: Iterable[_T], default: _U) -> Iterator[_T | _U]: ... +def distribute(n: int, iterable: Iterable[_T]) -> list[Iterator[_T]]: ... +@overload +def stagger( + iterable: Iterable[_T], + offsets: _SizedIterable[int] = ..., + longest: bool = ..., +) -> Iterator[tuple[_T | None, ...]]: ... +@overload +def stagger( + iterable: Iterable[_T], + offsets: _SizedIterable[int] = ..., + longest: bool = ..., + fillvalue: _U = ..., +) -> Iterator[tuple[_T | _U, ...]]: ... + +class UnequalIterablesError(ValueError): + def __init__(self, details: tuple[int, int, int] | None = ...) -> None: ... + +# zip_equal +@overload +def zip_equal(__iter1: Iterable[_T1]) -> Iterator[tuple[_T1]]: ... +@overload +def zip_equal( + __iter1: Iterable[_T1], __iter2: Iterable[_T2] +) -> Iterator[tuple[_T1, _T2]]: ... +@overload +def zip_equal( + __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3] +) -> Iterator[tuple[_T1, _T2, _T3]]: ... +@overload +def zip_equal( + __iter1: Iterable[_T1], + __iter2: Iterable[_T2], + __iter3: Iterable[_T3], + __iter4: Iterable[_T4], +) -> Iterator[tuple[_T1, _T2, _T3, _T4]]: ... +@overload +def zip_equal( + __iter1: Iterable[_T1], + __iter2: Iterable[_T2], + __iter3: Iterable[_T3], + __iter4: Iterable[_T4], + __iter5: Iterable[_T5], +) -> Iterator[tuple[_T1, _T2, _T3, _T4, _T5]]: ... +@overload +def zip_equal( + __iter1: Iterable[Any], + __iter2: Iterable[Any], + __iter3: Iterable[Any], + __iter4: Iterable[Any], + __iter5: Iterable[Any], + __iter6: Iterable[Any], + *iterables: Iterable[Any], +) -> Iterator[tuple[Any, ...]]: ... + +# zip_offset +@overload +def zip_offset( + __iter1: Iterable[_T1], + *, + offsets: _SizedIterable[int], + longest: bool = ..., + fillvalue: None = None, +) -> Iterator[tuple[_T1 | None]]: ... +@overload +def zip_offset( + __iter1: Iterable[_T1], + __iter2: Iterable[_T2], + *, + offsets: _SizedIterable[int], + longest: bool = ..., + fillvalue: None = None, +) -> Iterator[tuple[_T1 | None, _T2 | None]]: ... +@overload +def zip_offset( + __iter1: Iterable[_T], + __iter2: Iterable[_T], + __iter3: Iterable[_T], + *iterables: Iterable[_T], + offsets: _SizedIterable[int], + longest: bool = ..., + fillvalue: None = None, +) -> Iterator[tuple[_T | None, ...]]: ... +@overload +def zip_offset( + __iter1: Iterable[_T1], + *, + offsets: _SizedIterable[int], + longest: bool = ..., + fillvalue: _U, +) -> Iterator[tuple[_T1 | _U]]: ... +@overload +def zip_offset( + __iter1: Iterable[_T1], + __iter2: Iterable[_T2], + *, + offsets: _SizedIterable[int], + longest: bool = ..., + fillvalue: _U, +) -> Iterator[tuple[_T1 | _U, _T2 | _U]]: ... +@overload +def zip_offset( + __iter1: Iterable[_T], + __iter2: Iterable[_T], + __iter3: Iterable[_T], + *iterables: Iterable[_T], + offsets: _SizedIterable[int], + longest: bool = ..., + fillvalue: _U, +) -> Iterator[tuple[_T | _U, ...]]: ... +def sort_together( + iterables: Iterable[Iterable[_T]], + key_list: Iterable[int] = ..., + key: Callable[..., Any] | None = ..., + reverse: bool = ..., + strict: bool = ..., +) -> list[tuple[_T, ...]]: ... +def unzip(iterable: Iterable[Sequence[_T]]) -> tuple[Iterator[_T], ...]: ... +def divide(n: int, iterable: Iterable[_T]) -> list[Iterator[_T]]: ... +def always_iterable( + obj: object, + base_type: _ClassInfo | None = ..., +) -> Iterator[Any]: ... +def adjacent( + predicate: Callable[[_T], bool], + iterable: Iterable[_T], + distance: int = ..., +) -> Iterator[tuple[bool, _T]]: ... +@overload +def groupby_transform( + iterable: Iterable[_T], + keyfunc: None = None, + valuefunc: None = None, + reducefunc: None = None, +) -> Iterator[tuple[_T, Iterator[_T]]]: ... +@overload +def groupby_transform( + iterable: Iterable[_T], + keyfunc: Callable[[_T], _U], + valuefunc: None, + reducefunc: None, +) -> Iterator[tuple[_U, Iterator[_T]]]: ... +@overload +def groupby_transform( + iterable: Iterable[_T], + keyfunc: None, + valuefunc: Callable[[_T], _V], + reducefunc: None, +) -> Iterator[tuple[_T, Iterator[_V]]]: ... +@overload +def groupby_transform( + iterable: Iterable[_T], + keyfunc: Callable[[_T], _U], + valuefunc: Callable[[_T], _V], + reducefunc: None, +) -> Iterator[tuple[_U, Iterator[_V]]]: ... +@overload +def groupby_transform( + iterable: Iterable[_T], + keyfunc: None, + valuefunc: None, + reducefunc: Callable[[Iterator[_T]], _W], +) -> Iterator[tuple[_T, _W]]: ... +@overload +def groupby_transform( + iterable: Iterable[_T], + keyfunc: Callable[[_T], _U], + valuefunc: None, + reducefunc: Callable[[Iterator[_T]], _W], +) -> Iterator[tuple[_U, _W]]: ... +@overload +def groupby_transform( + iterable: Iterable[_T], + keyfunc: None, + valuefunc: Callable[[_T], _V], + reducefunc: Callable[[Iterator[_V]], _W], +) -> Iterator[tuple[_T, _W]]: ... +@overload +def groupby_transform( + iterable: Iterable[_T], + keyfunc: Callable[[_T], _U], + valuefunc: Callable[[_T], _V], + reducefunc: Callable[[Iterator[_V]], _W], +) -> Iterator[tuple[_U, _W]]: ... + +class numeric_range(Generic[_T, _U], Sequence[_T], Hashable, Reversible[_T]): + @overload + def __init__(self, __stop: _T) -> None: ... + @overload + def __init__(self, __start: _T, __stop: _T) -> None: ... + @overload + def __init__(self, __start: _T, __stop: _T, __step: _U) -> None: ... + def __bool__(self) -> bool: ... + def __contains__(self, elem: object) -> bool: ... + def __eq__(self, other: object) -> bool: ... + @overload + def __getitem__(self, key: int) -> _T: ... + @overload + def __getitem__(self, key: slice) -> numeric_range[_T, _U]: ... + def __hash__(self) -> int: ... + def __iter__(self) -> Iterator[_T]: ... + def __len__(self) -> int: ... + def __reduce__( + self, + ) -> tuple[type[numeric_range[_T, _U]], tuple[_T, _T, _U]]: ... + def __repr__(self) -> str: ... + def __reversed__(self) -> Iterator[_T]: ... + def count(self, value: _T) -> int: ... + def index(self, value: _T) -> int: ... # type: ignore + +def count_cycle( + iterable: Iterable[_T], n: int | None = ... +) -> Iterable[tuple[int, _T]]: ... +def mark_ends( + iterable: Iterable[_T], +) -> Iterable[tuple[bool, bool, _T]]: ... +def locate( + iterable: Iterable[_T], + pred: Callable[..., Any] = ..., + window_size: int | None = ..., +) -> Iterator[int]: ... +def lstrip( + iterable: Iterable[_T], pred: Callable[[_T], object] +) -> Iterator[_T]: ... +def rstrip( + iterable: Iterable[_T], pred: Callable[[_T], object] +) -> Iterator[_T]: ... +def strip( + iterable: Iterable[_T], pred: Callable[[_T], object] +) -> Iterator[_T]: ... + +class islice_extended(Generic[_T], Iterator[_T]): + def __init__(self, iterable: Iterable[_T], *args: int | None) -> None: ... + def __iter__(self) -> islice_extended[_T]: ... + def __next__(self) -> _T: ... + def __getitem__(self, index: slice) -> islice_extended[_T]: ... + +def always_reversible(iterable: Iterable[_T]) -> Iterator[_T]: ... +def consecutive_groups( + iterable: Iterable[_T], ordering: None | Callable[[_T], int] = ... +) -> Iterator[Iterator[_T]]: ... +@overload +def difference( + iterable: Iterable[_T], + func: Callable[[_T, _T], _U] = ..., + *, + initial: None = ..., +) -> Iterator[_T | _U]: ... +@overload +def difference( + iterable: Iterable[_T], func: Callable[[_T, _T], _U] = ..., *, initial: _U +) -> Iterator[_U]: ... + +class SequenceView(Generic[_T], Sequence[_T]): + def __init__(self, target: Sequence[_T]) -> None: ... + @overload + def __getitem__(self, index: int) -> _T: ... + @overload + def __getitem__(self, index: slice) -> Sequence[_T]: ... + def __len__(self) -> int: ... + +class seekable(Generic[_T], Iterator[_T]): + def __init__( + self, iterable: Iterable[_T], maxlen: int | None = ... + ) -> None: ... + def __iter__(self) -> seekable[_T]: ... + def __next__(self) -> _T: ... + def __bool__(self) -> bool: ... + @overload + def peek(self) -> _T: ... + @overload + def peek(self, default: _U) -> _T | _U: ... + def elements(self) -> SequenceView[_T]: ... + def seek(self, index: int) -> None: ... + def relative_seek(self, count: int) -> None: ... + +class run_length: + @staticmethod + def encode(iterable: Iterable[_T]) -> Iterator[tuple[_T, int]]: ... + @staticmethod + def decode(iterable: Iterable[tuple[_T, int]]) -> Iterator[_T]: ... + +def exactly_n( + iterable: Iterable[_T], n: int, predicate: Callable[[_T], object] = ... +) -> bool: ... +def circular_shifts( + iterable: Iterable[_T], steps: int = 1 +) -> list[tuple[_T, ...]]: ... +def make_decorator( + wrapping_func: Callable[..., _U], result_index: int = ... +) -> Callable[..., Callable[[Callable[..., Any]], Callable[..., _U]]]: ... +@overload +def map_reduce( + iterable: Iterable[_T], + keyfunc: Callable[[_T], _U], + valuefunc: None = ..., + reducefunc: None = ..., +) -> dict[_U, list[_T]]: ... +@overload +def map_reduce( + iterable: Iterable[_T], + keyfunc: Callable[[_T], _U], + valuefunc: Callable[[_T], _V], + reducefunc: None = ..., +) -> dict[_U, list[_V]]: ... +@overload +def map_reduce( + iterable: Iterable[_T], + keyfunc: Callable[[_T], _U], + valuefunc: None = ..., + reducefunc: Callable[[list[_T]], _W] = ..., +) -> dict[_U, _W]: ... +@overload +def map_reduce( + iterable: Iterable[_T], + keyfunc: Callable[[_T], _U], + valuefunc: Callable[[_T], _V], + reducefunc: Callable[[list[_V]], _W], +) -> dict[_U, _W]: ... +def rlocate( + iterable: Iterable[_T], + pred: Callable[..., object] = ..., + window_size: int | None = ..., +) -> Iterator[int]: ... +def replace( + iterable: Iterable[_T], + pred: Callable[..., object], + substitutes: Iterable[_U], + count: int | None = ..., + window_size: int = ..., +) -> Iterator[_T | _U]: ... +def partitions(iterable: Iterable[_T]) -> Iterator[list[list[_T]]]: ... +def set_partitions( + iterable: Iterable[_T], + k: int | None = ..., + min_size: int | None = ..., + max_size: int | None = ..., +) -> Iterator[list[list[_T]]]: ... + +class time_limited(Generic[_T], Iterator[_T]): + def __init__( + self, limit_seconds: float, iterable: Iterable[_T] + ) -> None: ... + def __iter__(self) -> islice_extended[_T]: ... + def __next__(self) -> _T: ... + +@overload +def only( + iterable: Iterable[_T], *, too_long: _Raisable | None = ... +) -> _T | None: ... +@overload +def only( + iterable: Iterable[_T], default: _U, too_long: _Raisable | None = ... +) -> _T | _U: ... +def ichunked(iterable: Iterable[_T], n: int) -> Iterator[Iterator[_T]]: ... +def distinct_combinations( + iterable: Iterable[_T], r: int +) -> Iterator[tuple[_T, ...]]: ... +def filter_except( + validator: Callable[[Any], object], + iterable: Iterable[_T], + *exceptions: type[BaseException], +) -> Iterator[_T]: ... +def map_except( + function: Callable[[Any], _U], + iterable: Iterable[_T], + *exceptions: type[BaseException], +) -> Iterator[_U]: ... +def map_if( + iterable: Iterable[Any], + pred: Callable[[Any], bool], + func: Callable[[Any], Any], + func_else: Callable[[Any], Any] | None = ..., +) -> Iterator[Any]: ... +def _sample_unweighted( + iterator: Iterator[_T], k: int, strict: bool +) -> list[_T]: ... +def _sample_counted( + population: Iterator[_T], k: int, counts: Iterable[int], strict: bool +) -> list[_T]: ... +def _sample_weighted( + iterator: Iterator[_T], k: int, weights: Iterator[float], strict: bool +) -> list[_T]: ... +def sample( + iterable: Iterable[_T], + k: int, + weights: Iterable[float] | None = ..., + *, + counts: Iterable[int] | None = ..., + strict: bool = False, +) -> list[_T]: ... +def is_sorted( + iterable: Iterable[_T], + key: Callable[[_T], _U] | None = ..., + reverse: bool = False, + strict: bool = False, +) -> bool: ... + +class AbortThread(BaseException): + pass + +class callback_iter(Generic[_T], Iterator[_T]): + def __init__( + self, + func: Callable[..., Any], + callback_kwd: str = ..., + wait_seconds: float = ..., + ) -> None: ... + def __enter__(self) -> callback_iter[_T]: ... + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_value: BaseException | None, + traceback: types.TracebackType | None, + ) -> bool | None: ... + def __iter__(self) -> callback_iter[_T]: ... + def __next__(self) -> _T: ... + def _reader(self) -> Iterator[_T]: ... + @property + def done(self) -> bool: ... + @property + def result(self) -> Any: ... + +def windowed_complete( + iterable: Iterable[_T], n: int +) -> Iterator[tuple[tuple[_T, ...], tuple[_T, ...], tuple[_T, ...]]]: ... +def all_unique( + iterable: Iterable[_T], key: Callable[[_T], _U] | None = ... +) -> bool: ... +def nth_product(index: int, *args: Iterable[_T]) -> tuple[_T, ...]: ... +def nth_combination_with_replacement( + iterable: Iterable[_T], r: int, index: int +) -> tuple[_T, ...]: ... +def nth_permutation( + iterable: Iterable[_T], r: int, index: int +) -> tuple[_T, ...]: ... +def value_chain(*args: _T | Iterable[_T]) -> Iterable[_T]: ... +def product_index(element: Iterable[_T], *args: Iterable[_T]) -> int: ... +def combination_index( + element: Iterable[_T], iterable: Iterable[_T] +) -> int: ... +def combination_with_replacement_index( + element: Iterable[_T], iterable: Iterable[_T] +) -> int: ... +def permutation_index( + element: Iterable[_T], iterable: Iterable[_T] +) -> int: ... +def repeat_each(iterable: Iterable[_T], n: int = ...) -> Iterator[_T]: ... + +class countable(Generic[_T], Iterator[_T]): + def __init__(self, iterable: Iterable[_T]) -> None: ... + def __iter__(self) -> countable[_T]: ... + def __next__(self) -> _T: ... + items_seen: int + +def chunked_even(iterable: Iterable[_T], n: int) -> Iterator[list[_T]]: ... +@overload +def zip_broadcast( + __obj1: _T | Iterable[_T], + *, + scalar_types: _ClassInfo | None = ..., + strict: bool = ..., +) -> Iterable[tuple[_T, ...]]: ... +@overload +def zip_broadcast( + __obj1: _T | Iterable[_T], + __obj2: _T | Iterable[_T], + *, + scalar_types: _ClassInfo | None = ..., + strict: bool = ..., +) -> Iterable[tuple[_T, ...]]: ... +@overload +def zip_broadcast( + __obj1: _T | Iterable[_T], + __obj2: _T | Iterable[_T], + __obj3: _T | Iterable[_T], + *, + scalar_types: _ClassInfo | None = ..., + strict: bool = ..., +) -> Iterable[tuple[_T, ...]]: ... +@overload +def zip_broadcast( + __obj1: _T | Iterable[_T], + __obj2: _T | Iterable[_T], + __obj3: _T | Iterable[_T], + __obj4: _T | Iterable[_T], + *, + scalar_types: _ClassInfo | None = ..., + strict: bool = ..., +) -> Iterable[tuple[_T, ...]]: ... +@overload +def zip_broadcast( + __obj1: _T | Iterable[_T], + __obj2: _T | Iterable[_T], + __obj3: _T | Iterable[_T], + __obj4: _T | Iterable[_T], + __obj5: _T | Iterable[_T], + *, + scalar_types: _ClassInfo | None = ..., + strict: bool = ..., +) -> Iterable[tuple[_T, ...]]: ... +@overload +def zip_broadcast( + __obj1: _T | Iterable[_T], + __obj2: _T | Iterable[_T], + __obj3: _T | Iterable[_T], + __obj4: _T | Iterable[_T], + __obj5: _T | Iterable[_T], + __obj6: _T | Iterable[_T], + *objects: _T | Iterable[_T], + scalar_types: _ClassInfo | None = ..., + strict: bool = ..., +) -> Iterable[tuple[_T, ...]]: ... +def unique_in_window( + iterable: Iterable[_T], n: int, key: Callable[[_T], _U] | None = ... +) -> Iterator[_T]: ... +def duplicates_everseen( + iterable: Iterable[_T], key: Callable[[_T], _U] | None = ... +) -> Iterator[_T]: ... +def duplicates_justseen( + iterable: Iterable[_T], key: Callable[[_T], _U] | None = ... +) -> Iterator[_T]: ... +def classify_unique( + iterable: Iterable[_T], key: Callable[[_T], _U] | None = ... +) -> Iterator[tuple[_T, bool, bool]]: ... + +class _SupportsLessThan(Protocol): + def __lt__(self, __other: Any) -> bool: ... + +_SupportsLessThanT = TypeVar("_SupportsLessThanT", bound=_SupportsLessThan) + +@overload +def minmax( + iterable_or_value: Iterable[_SupportsLessThanT], *, key: None = None +) -> tuple[_SupportsLessThanT, _SupportsLessThanT]: ... +@overload +def minmax( + iterable_or_value: Iterable[_T], *, key: Callable[[_T], _SupportsLessThan] +) -> tuple[_T, _T]: ... +@overload +def minmax( + iterable_or_value: Iterable[_SupportsLessThanT], + *, + key: None = None, + default: _U, +) -> _U | tuple[_SupportsLessThanT, _SupportsLessThanT]: ... +@overload +def minmax( + iterable_or_value: Iterable[_T], + *, + key: Callable[[_T], _SupportsLessThan], + default: _U, +) -> _U | tuple[_T, _T]: ... +@overload +def minmax( + iterable_or_value: _SupportsLessThanT, + __other: _SupportsLessThanT, + *others: _SupportsLessThanT, +) -> tuple[_SupportsLessThanT, _SupportsLessThanT]: ... +@overload +def minmax( + iterable_or_value: _T, + __other: _T, + *others: _T, + key: Callable[[_T], _SupportsLessThan], +) -> tuple[_T, _T]: ... +def longest_common_prefix( + iterables: Iterable[Iterable[_T]], +) -> Iterator[_T]: ... +def iequals(*iterables: Iterable[Any]) -> bool: ... +def constrained_batches( + iterable: Iterable[_T], + max_size: int, + max_count: int | None = ..., + get_len: Callable[[_T], object] = ..., + strict: bool = ..., +) -> Iterator[tuple[_T]]: ... +def gray_product(*iterables: Iterable[_T]) -> Iterator[tuple[_T, ...]]: ... +def partial_product(*iterables: Iterable[_T]) -> Iterator[tuple[_T, ...]]: ... +def takewhile_inclusive( + predicate: Callable[[_T], bool], iterable: Iterable[_T] +) -> Iterator[_T]: ... +def outer_product( + func: Callable[[_T, _U], _V], + xs: Iterable[_T], + ys: Iterable[_U], + *args: Any, + **kwargs: Any, +) -> Iterator[tuple[_V, ...]]: ... +def iter_suppress( + iterable: Iterable[_T], + *exceptions: type[BaseException], +) -> Iterator[_T]: ... +def filter_map( + func: Callable[[_T], _V | None], + iterable: Iterable[_T], +) -> Iterator[_V]: ... +def powerset_of_sets(iterable: Iterable[_T]) -> Iterator[set[_T]]: ... +def join_mappings( + **field_to_map: Mapping[_T, _V], +) -> dict[_T, dict[str, _V]]: ... +def doublestarmap( + func: Callable[..., _T], + iterable: Iterable[Mapping[str, Any]], +) -> Iterator[_T]: ... +def dft(xarr: Sequence[complex]) -> Iterator[complex]: ... +def idft(Xarr: Sequence[complex]) -> Iterator[complex]: ... +def _nth_prime_ub(n: int) -> float: ... +def nth_prime(n: int, *, approximate: bool = ...) -> int: ... +def argmin( + iterable: Iterable[_T], *, key: Callable[[_T], _U] | None = ... +) -> int: ... +def argmax( + iterable: Iterable[_T], *, key: Callable[[_T], _U] | None = ... +) -> int: ... +def extract( + iterable: Iterable[_T], indices: Iterable[int] +) -> Iterator[_T]: ... diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/py.typed b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/py.typed new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/recipes.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/recipes.py new file mode 100644 index 0000000000000000000000000000000000000000..dacf61407d454907d661edde2d774bee11cec92a --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/recipes.py @@ -0,0 +1,1471 @@ +"""Imported from the recipes section of the itertools documentation. + +All functions taken from the recipes section of the itertools library docs +[1]_. +Some backward-compatible usability improvements have been made. + +.. [1] http://docs.python.org/library/itertools.html#recipes + +""" + +import random + +from bisect import bisect_left, insort +from collections import deque +from contextlib import suppress +from functools import lru_cache, partial, reduce +from heapq import heappush, heappushpop +from itertools import ( + accumulate, + chain, + combinations, + compress, + count, + cycle, + groupby, + islice, + product, + repeat, + starmap, + takewhile, + tee, + zip_longest, +) +from math import prod, comb, isqrt, gcd +from operator import mul, not_, itemgetter, getitem, index +from random import randrange, sample, choice +from sys import hexversion + +__all__ = [ + 'all_equal', + 'batched', + 'before_and_after', + 'consume', + 'convolve', + 'dotproduct', + 'first_true', + 'factor', + 'flatten', + 'grouper', + 'is_prime', + 'iter_except', + 'iter_index', + 'loops', + 'matmul', + 'multinomial', + 'ncycles', + 'nth', + 'nth_combination', + 'padnone', + 'pad_none', + 'pairwise', + 'partition', + 'polynomial_eval', + 'polynomial_from_roots', + 'polynomial_derivative', + 'powerset', + 'prepend', + 'quantify', + 'reshape', + 'random_combination_with_replacement', + 'random_combination', + 'random_permutation', + 'random_product', + 'repeatfunc', + 'roundrobin', + 'running_median', + 'sieve', + 'sliding_window', + 'subslices', + 'sum_of_squares', + 'tabulate', + 'tail', + 'take', + 'totient', + 'transpose', + 'triplewise', + 'unique', + 'unique_everseen', + 'unique_justseen', +] + +_marker = object() + + +# zip with strict is available for Python 3.10+ +try: + zip(strict=True) +except TypeError: # pragma: no cover + _zip_strict = zip +else: # pragma: no cover + _zip_strict = partial(zip, strict=True) + + +# math.sumprod is available for Python 3.12+ +try: + from math import sumprod as _sumprod +except ImportError: # pragma: no cover + _sumprod = lambda x, y: dotproduct(x, y) + + +# heapq max-heap functions are available for Python 3.14+ +try: + from heapq import heappush_max, heappushpop_max +except ImportError: # pragma: no cover + _max_heap_available = False +else: # pragma: no cover + _max_heap_available = True + + +def take(n, iterable): + """Return first *n* items of the *iterable* as a list. + + >>> take(3, range(10)) + [0, 1, 2] + + If there are fewer than *n* items in the iterable, all of them are + returned. + + >>> take(10, range(3)) + [0, 1, 2] + + """ + return list(islice(iterable, n)) + + +def tabulate(function, start=0): + """Return an iterator over the results of ``func(start)``, + ``func(start + 1)``, ``func(start + 2)``... + + *func* should be a function that accepts one integer argument. + + If *start* is not specified it defaults to 0. It will be incremented each + time the iterator is advanced. + + >>> square = lambda x: x ** 2 + >>> iterator = tabulate(square, -3) + >>> take(4, iterator) + [9, 4, 1, 0] + + """ + return map(function, count(start)) + + +def tail(n, iterable): + """Return an iterator over the last *n* items of *iterable*. + + >>> t = tail(3, 'ABCDEFG') + >>> list(t) + ['E', 'F', 'G'] + + """ + try: + size = len(iterable) + except TypeError: + return iter(deque(iterable, maxlen=n)) + else: + return islice(iterable, max(0, size - n), None) + + +def consume(iterator, n=None): + """Advance *iterable* by *n* steps. If *n* is ``None``, consume it + entirely. + + Efficiently exhausts an iterator without returning values. Defaults to + consuming the whole iterator, but an optional second argument may be + provided to limit consumption. + + >>> i = (x for x in range(10)) + >>> next(i) + 0 + >>> consume(i, 3) + >>> next(i) + 4 + >>> consume(i) + >>> next(i) + Traceback (most recent call last): + File "", line 1, in + StopIteration + + If the iterator has fewer items remaining than the provided limit, the + whole iterator will be consumed. + + >>> i = (x for x in range(3)) + >>> consume(i, 5) + >>> next(i) + Traceback (most recent call last): + File "", line 1, in + StopIteration + + """ + # Use functions that consume iterators at C speed. + if n is None: + # feed the entire iterator into a zero-length deque + deque(iterator, maxlen=0) + else: + # advance to the empty slice starting at position n + next(islice(iterator, n, n), None) + + +def nth(iterable, n, default=None): + """Returns the nth item or a default value. + + >>> l = range(10) + >>> nth(l, 3) + 3 + >>> nth(l, 20, "zebra") + 'zebra' + + """ + return next(islice(iterable, n, None), default) + + +def all_equal(iterable, key=None): + """ + Returns ``True`` if all the elements are equal to each other. + + >>> all_equal('aaaa') + True + >>> all_equal('aaab') + False + + A function that accepts a single argument and returns a transformed version + of each input item can be specified with *key*: + + >>> all_equal('AaaA', key=str.casefold) + True + >>> all_equal([1, 2, 3], key=lambda x: x < 10) + True + + """ + iterator = groupby(iterable, key) + for first in iterator: + for second in iterator: + return False + return True + return True + + +def quantify(iterable, pred=bool): + """Return the how many times the predicate is true. + + >>> quantify([True, False, True]) + 2 + + """ + return sum(map(pred, iterable)) + + +def pad_none(iterable): + """Returns the sequence of elements and then returns ``None`` indefinitely. + + >>> take(5, pad_none(range(3))) + [0, 1, 2, None, None] + + Useful for emulating the behavior of the built-in :func:`map` function. + + See also :func:`padded`. + + """ + return chain(iterable, repeat(None)) + + +padnone = pad_none + + +def ncycles(iterable, n): + """Returns the sequence elements *n* times + + >>> list(ncycles(["a", "b"], 3)) + ['a', 'b', 'a', 'b', 'a', 'b'] + + """ + return chain.from_iterable(repeat(tuple(iterable), n)) + + +def dotproduct(vec1, vec2): + """Returns the dot product of the two iterables. + + >>> dotproduct([10, 15, 12], [0.65, 0.80, 1.25]) + 33.5 + >>> 10 * 0.65 + 15 * 0.80 + 12 * 1.25 + 33.5 + + In Python 3.12 and later, use ``math.sumprod()`` instead. + """ + return sum(map(mul, vec1, vec2)) + + +def flatten(listOfLists): + """Return an iterator flattening one level of nesting in a list of lists. + + >>> list(flatten([[0, 1], [2, 3]])) + [0, 1, 2, 3] + + See also :func:`collapse`, which can flatten multiple levels of nesting. + + """ + return chain.from_iterable(listOfLists) + + +def repeatfunc(func, times=None, *args): + """Call *func* with *args* repeatedly, returning an iterable over the + results. + + If *times* is specified, the iterable will terminate after that many + repetitions: + + >>> from operator import add + >>> times = 4 + >>> args = 3, 5 + >>> list(repeatfunc(add, times, *args)) + [8, 8, 8, 8] + + If *times* is ``None`` the iterable will not terminate: + + >>> from random import randrange + >>> times = None + >>> args = 1, 11 + >>> take(6, repeatfunc(randrange, times, *args)) # doctest:+SKIP + [2, 4, 8, 1, 8, 4] + + """ + if times is None: + return starmap(func, repeat(args)) + return starmap(func, repeat(args, times)) + + +def _pairwise(iterable): + """Returns an iterator of paired items, overlapping, from the original + + >>> take(4, pairwise(count())) + [(0, 1), (1, 2), (2, 3), (3, 4)] + + On Python 3.10 and above, this is an alias for :func:`itertools.pairwise`. + + """ + a, b = tee(iterable) + next(b, None) + return zip(a, b) + + +try: + from itertools import pairwise as itertools_pairwise +except ImportError: # pragma: no cover + pairwise = _pairwise +else: # pragma: no cover + + def pairwise(iterable): + return itertools_pairwise(iterable) + + pairwise.__doc__ = _pairwise.__doc__ + + +class UnequalIterablesError(ValueError): + def __init__(self, details=None): + msg = 'Iterables have different lengths' + if details is not None: + msg += (': index 0 has length {}; index {} has length {}').format( + *details + ) + + super().__init__(msg) + + +def _zip_equal_generator(iterables): + for combo in zip_longest(*iterables, fillvalue=_marker): + for val in combo: + if val is _marker: + raise UnequalIterablesError() + yield combo + + +def _zip_equal(*iterables): + # Check whether the iterables are all the same size. + try: + first_size = len(iterables[0]) + for i, it in enumerate(iterables[1:], 1): + size = len(it) + if size != first_size: + raise UnequalIterablesError(details=(first_size, i, size)) + # All sizes are equal, we can use the built-in zip. + return zip(*iterables) + # If any one of the iterables didn't have a length, start reading + # them until one runs out. + except TypeError: + return _zip_equal_generator(iterables) + + +def grouper(iterable, n, incomplete='fill', fillvalue=None): + """Group elements from *iterable* into fixed-length groups of length *n*. + + >>> list(grouper('ABCDEF', 3)) + [('A', 'B', 'C'), ('D', 'E', 'F')] + + The keyword arguments *incomplete* and *fillvalue* control what happens for + iterables whose length is not a multiple of *n*. + + When *incomplete* is `'fill'`, the last group will contain instances of + *fillvalue*. + + >>> list(grouper('ABCDEFG', 3, incomplete='fill', fillvalue='x')) + [('A', 'B', 'C'), ('D', 'E', 'F'), ('G', 'x', 'x')] + + When *incomplete* is `'ignore'`, the last group will not be emitted. + + >>> list(grouper('ABCDEFG', 3, incomplete='ignore', fillvalue='x')) + [('A', 'B', 'C'), ('D', 'E', 'F')] + + When *incomplete* is `'strict'`, a subclass of `ValueError` will be raised. + + >>> iterator = grouper('ABCDEFG', 3, incomplete='strict') + >>> list(iterator) # doctest: +IGNORE_EXCEPTION_DETAIL + Traceback (most recent call last): + ... + UnequalIterablesError + + """ + iterators = [iter(iterable)] * n + if incomplete == 'fill': + return zip_longest(*iterators, fillvalue=fillvalue) + if incomplete == 'strict': + return _zip_equal(*iterators) + if incomplete == 'ignore': + return zip(*iterators) + else: + raise ValueError('Expected fill, strict, or ignore') + + +def roundrobin(*iterables): + """Visit input iterables in a cycle until each is exhausted. + + >>> list(roundrobin('ABC', 'D', 'EF')) + ['A', 'D', 'E', 'B', 'F', 'C'] + + This function produces the same output as :func:`interleave_longest`, but + may perform better for some inputs (in particular when the number of + iterables is small). + + """ + # Algorithm credited to George Sakkis + iterators = map(iter, iterables) + for num_active in range(len(iterables), 0, -1): + iterators = cycle(islice(iterators, num_active)) + yield from map(next, iterators) + + +def partition(pred, iterable): + """ + Returns a 2-tuple of iterables derived from the input iterable. + The first yields the items that have ``pred(item) == False``. + The second yields the items that have ``pred(item) == True``. + + >>> is_odd = lambda x: x % 2 != 0 + >>> iterable = range(10) + >>> even_items, odd_items = partition(is_odd, iterable) + >>> list(even_items), list(odd_items) + ([0, 2, 4, 6, 8], [1, 3, 5, 7, 9]) + + If *pred* is None, :func:`bool` is used. + + >>> iterable = [0, 1, False, True, '', ' '] + >>> false_items, true_items = partition(None, iterable) + >>> list(false_items), list(true_items) + ([0, False, ''], [1, True, ' ']) + + """ + if pred is None: + pred = bool + + t1, t2, p = tee(iterable, 3) + p1, p2 = tee(map(pred, p)) + return (compress(t1, map(not_, p1)), compress(t2, p2)) + + +def powerset(iterable): + """Yields all possible subsets of the iterable. + + >>> list(powerset([1, 2, 3])) + [(), (1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)] + + :func:`powerset` will operate on iterables that aren't :class:`set` + instances, so repeated elements in the input will produce repeated elements + in the output. + + >>> seq = [1, 1, 0] + >>> list(powerset(seq)) + [(), (1,), (1,), (0,), (1, 1), (1, 0), (1, 0), (1, 1, 0)] + + For a variant that efficiently yields actual :class:`set` instances, see + :func:`powerset_of_sets`. + """ + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s) + 1)) + + +def unique_everseen(iterable, key=None): + """ + Yield unique elements, preserving order. + + >>> list(unique_everseen('AAAABBBCCDAABBB')) + ['A', 'B', 'C', 'D'] + >>> list(unique_everseen('ABBCcAD', str.lower)) + ['A', 'B', 'C', 'D'] + + Sequences with a mix of hashable and unhashable items can be used. + The function will be slower (i.e., `O(n^2)`) for unhashable items. + + Remember that ``list`` objects are unhashable - you can use the *key* + parameter to transform the list to a tuple (which is hashable) to + avoid a slowdown. + + >>> iterable = ([1, 2], [2, 3], [1, 2]) + >>> list(unique_everseen(iterable)) # Slow + [[1, 2], [2, 3]] + >>> list(unique_everseen(iterable, key=tuple)) # Faster + [[1, 2], [2, 3]] + + Similarly, you may want to convert unhashable ``set`` objects with + ``key=frozenset``. For ``dict`` objects, + ``key=lambda x: frozenset(x.items())`` can be used. + + """ + seenset = set() + seenset_add = seenset.add + seenlist = [] + seenlist_add = seenlist.append + use_key = key is not None + + for element in iterable: + k = key(element) if use_key else element + try: + if k not in seenset: + seenset_add(k) + yield element + except TypeError: + if k not in seenlist: + seenlist_add(k) + yield element + + +def unique_justseen(iterable, key=None): + """Yields elements in order, ignoring serial duplicates + + >>> list(unique_justseen('AAAABBBCCDAABBB')) + ['A', 'B', 'C', 'D', 'A', 'B'] + >>> list(unique_justseen('ABBCcAD', str.lower)) + ['A', 'B', 'C', 'A', 'D'] + + """ + if key is None: + return map(itemgetter(0), groupby(iterable)) + + return map(next, map(itemgetter(1), groupby(iterable, key))) + + +def unique(iterable, key=None, reverse=False): + """Yields unique elements in sorted order. + + >>> list(unique([[1, 2], [3, 4], [1, 2]])) + [[1, 2], [3, 4]] + + *key* and *reverse* are passed to :func:`sorted`. + + >>> list(unique('ABBcCAD', str.casefold)) + ['A', 'B', 'c', 'D'] + >>> list(unique('ABBcCAD', str.casefold, reverse=True)) + ['D', 'c', 'B', 'A'] + + The elements in *iterable* need not be hashable, but they must be + comparable for sorting to work. + """ + sequenced = sorted(iterable, key=key, reverse=reverse) + return unique_justseen(sequenced, key=key) + + +def iter_except(func, exception, first=None): + """Yields results from a function repeatedly until an exception is raised. + + Converts a call-until-exception interface to an iterator interface. + Like ``iter(func, sentinel)``, but uses an exception instead of a sentinel + to end the loop. + + >>> l = [0, 1, 2] + >>> list(iter_except(l.pop, IndexError)) + [2, 1, 0] + + Multiple exceptions can be specified as a stopping condition: + + >>> l = [1, 2, 3, '...', 4, 5, 6] + >>> list(iter_except(lambda: 1 + l.pop(), (IndexError, TypeError))) + [7, 6, 5] + >>> list(iter_except(lambda: 1 + l.pop(), (IndexError, TypeError))) + [4, 3, 2] + >>> list(iter_except(lambda: 1 + l.pop(), (IndexError, TypeError))) + [] + + """ + with suppress(exception): + if first is not None: + yield first() + while True: + yield func() + + +def first_true(iterable, default=None, pred=None): + """ + Returns the first true value in the iterable. + + If no true value is found, returns *default* + + If *pred* is not None, returns the first item for which + ``pred(item) == True`` . + + >>> first_true(range(10)) + 1 + >>> first_true(range(10), pred=lambda x: x > 5) + 6 + >>> first_true(range(10), default='missing', pred=lambda x: x > 9) + 'missing' + + """ + return next(filter(pred, iterable), default) + + +def random_product(*args, repeat=1): + """Draw an item at random from each of the input iterables. + + >>> random_product('abc', range(4), 'XYZ') # doctest:+SKIP + ('c', 3, 'Z') + + If *repeat* is provided as a keyword argument, that many items will be + drawn from each iterable. + + >>> random_product('abcd', range(4), repeat=2) # doctest:+SKIP + ('a', 2, 'd', 3) + + This equivalent to taking a random selection from + ``itertools.product(*args, repeat=repeat)``. + + """ + pools = [tuple(pool) for pool in args] * repeat + return tuple(choice(pool) for pool in pools) + + +def random_permutation(iterable, r=None): + """Return a random *r* length permutation of the elements in *iterable*. + + If *r* is not specified or is ``None``, then *r* defaults to the length of + *iterable*. + + >>> random_permutation(range(5)) # doctest:+SKIP + (3, 4, 0, 1, 2) + + This equivalent to taking a random selection from + ``itertools.permutations(iterable, r)``. + + """ + pool = tuple(iterable) + r = len(pool) if r is None else r + return tuple(sample(pool, r)) + + +def random_combination(iterable, r): + """Return a random *r* length subsequence of the elements in *iterable*. + + >>> random_combination(range(5), 3) # doctest:+SKIP + (2, 3, 4) + + This equivalent to taking a random selection from + ``itertools.combinations(iterable, r)``. + + """ + pool = tuple(iterable) + n = len(pool) + indices = sorted(sample(range(n), r)) + return tuple(pool[i] for i in indices) + + +def random_combination_with_replacement(iterable, r): + """Return a random *r* length subsequence of elements in *iterable*, + allowing individual elements to be repeated. + + >>> random_combination_with_replacement(range(3), 5) # doctest:+SKIP + (0, 0, 1, 2, 2) + + This equivalent to taking a random selection from + ``itertools.combinations_with_replacement(iterable, r)``. + + """ + pool = tuple(iterable) + n = len(pool) + indices = sorted(randrange(n) for i in range(r)) + return tuple(pool[i] for i in indices) + + +def nth_combination(iterable, r, index): + """Equivalent to ``list(combinations(iterable, r))[index]``. + + The subsequences of *iterable* that are of length *r* can be ordered + lexicographically. :func:`nth_combination` computes the subsequence at + sort position *index* directly, without computing the previous + subsequences. + + >>> nth_combination(range(5), 3, 5) + (0, 3, 4) + + ``ValueError`` will be raised If *r* is negative or greater than the length + of *iterable*. + ``IndexError`` will be raised if the given *index* is invalid. + """ + pool = tuple(iterable) + n = len(pool) + if (r < 0) or (r > n): + raise ValueError + + c = 1 + k = min(r, n - r) + for i in range(1, k + 1): + c = c * (n - k + i) // i + + if index < 0: + index += c + + if (index < 0) or (index >= c): + raise IndexError + + result = [] + while r: + c, n, r = c * r // n, n - 1, r - 1 + while index >= c: + index -= c + c, n = c * (n - r) // n, n - 1 + result.append(pool[-1 - n]) + + return tuple(result) + + +def prepend(value, iterator): + """Yield *value*, followed by the elements in *iterator*. + + >>> value = '0' + >>> iterator = ['1', '2', '3'] + >>> list(prepend(value, iterator)) + ['0', '1', '2', '3'] + + To prepend multiple values, see :func:`itertools.chain` + or :func:`value_chain`. + + """ + return chain([value], iterator) + + +def convolve(signal, kernel): + """Discrete linear convolution of two iterables. + Equivalent to polynomial multiplication. + + For example, multiplying ``(x² -x - 20)`` by ``(x - 3)`` + gives ``(x³ -4x² -17x + 60)``. + + >>> list(convolve([1, -1, -20], [1, -3])) + [1, -4, -17, 60] + + Examples of popular kinds of kernels: + + * The kernel ``[0.25, 0.25, 0.25, 0.25]`` computes a moving average. + For image data, this blurs the image and reduces noise. + * The kernel ``[1/2, 0, -1/2]`` estimates the first derivative of + a function evaluated at evenly spaced inputs. + * The kernel ``[1, -2, 1]`` estimates the second derivative of a + function evaluated at evenly spaced inputs. + + Convolutions are mathematically commutative; however, the inputs are + evaluated differently. The signal is consumed lazily and can be + infinite. The kernel is fully consumed before the calculations begin. + + Supports all numeric types: int, float, complex, Decimal, Fraction. + + References: + + * Article: https://betterexplained.com/articles/intuitive-convolution/ + * Video by 3Blue1Brown: https://www.youtube.com/watch?v=KuXjwB4LzSA + + """ + # This implementation comes from an older version of the itertools + # documentation. While the newer implementation is a bit clearer, + # this one was kept because the inlined window logic is faster + # and it avoids an unnecessary deque-to-tuple conversion. + kernel = tuple(kernel)[::-1] + n = len(kernel) + window = deque([0], maxlen=n) * n + for x in chain(signal, repeat(0, n - 1)): + window.append(x) + yield _sumprod(kernel, window) + + +def before_and_after(predicate, it): + """A variant of :func:`takewhile` that allows complete access to the + remainder of the iterator. + + >>> it = iter('ABCdEfGhI') + >>> all_upper, remainder = before_and_after(str.isupper, it) + >>> ''.join(all_upper) + 'ABC' + >>> ''.join(remainder) # takewhile() would lose the 'd' + 'dEfGhI' + + Note that the first iterator must be fully consumed before the second + iterator can generate valid results. + """ + trues, after = tee(it) + trues = compress(takewhile(predicate, trues), zip(after)) + return trues, after + + +def triplewise(iterable): + """Return overlapping triplets from *iterable*. + + >>> list(triplewise('ABCDE')) + [('A', 'B', 'C'), ('B', 'C', 'D'), ('C', 'D', 'E')] + + """ + # This deviates from the itertools documentation recipe - see + # https://github.com/more-itertools/more-itertools/issues/889 + t1, t2, t3 = tee(iterable, 3) + next(t3, None) + next(t3, None) + next(t2, None) + return zip(t1, t2, t3) + + +def _sliding_window_islice(iterable, n): + # Fast path for small, non-zero values of n. + iterators = tee(iterable, n) + for i, iterator in enumerate(iterators): + next(islice(iterator, i, i), None) + return zip(*iterators) + + +def _sliding_window_deque(iterable, n): + # Normal path for other values of n. + iterator = iter(iterable) + window = deque(islice(iterator, n - 1), maxlen=n) + for x in iterator: + window.append(x) + yield tuple(window) + + +def sliding_window(iterable, n): + """Return a sliding window of width *n* over *iterable*. + + >>> list(sliding_window(range(6), 4)) + [(0, 1, 2, 3), (1, 2, 3, 4), (2, 3, 4, 5)] + + If *iterable* has fewer than *n* items, then nothing is yielded: + + >>> list(sliding_window(range(3), 4)) + [] + + For a variant with more features, see :func:`windowed`. + """ + if n > 20: + return _sliding_window_deque(iterable, n) + elif n > 2: + return _sliding_window_islice(iterable, n) + elif n == 2: + return pairwise(iterable) + elif n == 1: + return zip(iterable) + else: + raise ValueError(f'n should be at least one, not {n}') + + +def subslices(iterable): + """Return all contiguous non-empty subslices of *iterable*. + + >>> list(subslices('ABC')) + [['A'], ['A', 'B'], ['A', 'B', 'C'], ['B'], ['B', 'C'], ['C']] + + This is similar to :func:`substrings`, but emits items in a different + order. + """ + seq = list(iterable) + slices = starmap(slice, combinations(range(len(seq) + 1), 2)) + return map(getitem, repeat(seq), slices) + + +def polynomial_from_roots(roots): + """Compute a polynomial's coefficients from its roots. + + >>> roots = [5, -4, 3] # (x - 5) * (x + 4) * (x - 3) + >>> polynomial_from_roots(roots) # x³ - 4 x² - 17 x + 60 + [1, -4, -17, 60] + + Note that polynomial coefficients are specified in descending power order. + + Supports all numeric types: int, float, complex, Decimal, Fraction. + """ + + # This recipe differs from the one in itertools docs in that it + # applies list() after each call to convolve(). This avoids + # hitting stack limits with nested generators. + + poly = [1] + for root in roots: + poly = list(convolve(poly, (1, -root))) + return poly + + +def iter_index(iterable, value, start=0, stop=None): + """Yield the index of each place in *iterable* that *value* occurs, + beginning with index *start* and ending before index *stop*. + + + >>> list(iter_index('AABCADEAF', 'A')) + [0, 1, 4, 7] + >>> list(iter_index('AABCADEAF', 'A', 1)) # start index is inclusive + [1, 4, 7] + >>> list(iter_index('AABCADEAF', 'A', 1, 7)) # stop index is not inclusive + [1, 4] + + The behavior for non-scalar *values* matches the built-in Python types. + + >>> list(iter_index('ABCDABCD', 'AB')) + [0, 4] + >>> list(iter_index([0, 1, 2, 3, 0, 1, 2, 3], [0, 1])) + [] + >>> list(iter_index([[0, 1], [2, 3], [0, 1], [2, 3]], [0, 1])) + [0, 2] + + See :func:`locate` for a more general means of finding the indexes + associated with particular values. + + """ + seq_index = getattr(iterable, 'index', None) + if seq_index is None: + # Slow path for general iterables + iterator = islice(iterable, start, stop) + for i, element in enumerate(iterator, start): + if element is value or element == value: + yield i + else: + # Fast path for sequences + stop = len(iterable) if stop is None else stop + i = start - 1 + with suppress(ValueError): + while True: + yield (i := seq_index(value, i + 1, stop)) + + +def sieve(n): + """Yield the primes less than n. + + >>> list(sieve(30)) + [2, 3, 5, 7, 11, 13, 17, 19, 23, 29] + + """ + # This implementation comes from an older version of the itertools + # documentation. The newer implementation is easier to read but is + # less lazy. + if n > 2: + yield 2 + start = 3 + data = bytearray((0, 1)) * (n // 2) + for p in iter_index(data, 1, start, stop=isqrt(n) + 1): + yield from iter_index(data, 1, start, p * p) + data[p * p : n : p + p] = bytes(len(range(p * p, n, p + p))) + start = p * p + yield from iter_index(data, 1, start) + + +def _batched(iterable, n, *, strict=False): # pragma: no cover + """Batch data into tuples of length *n*. If the number of items in + *iterable* is not divisible by *n*: + * The last batch will be shorter if *strict* is ``False``. + * :exc:`ValueError` will be raised if *strict* is ``True``. + + >>> list(batched('ABCDEFG', 3)) + [('A', 'B', 'C'), ('D', 'E', 'F'), ('G',)] + + On Python 3.13 and above, this is an alias for :func:`itertools.batched`. + """ + if n < 1: + raise ValueError('n must be at least one') + iterator = iter(iterable) + while batch := tuple(islice(iterator, n)): + if strict and len(batch) != n: + raise ValueError('batched(): incomplete batch') + yield batch + + +if hexversion >= 0x30D00A2: # pragma: no cover + from itertools import batched as itertools_batched + + def batched(iterable, n, *, strict=False): + return itertools_batched(iterable, n, strict=strict) + + batched.__doc__ = _batched.__doc__ +else: # pragma: no cover + batched = _batched + + +def transpose(it): + """Swap the rows and columns of the input matrix. + + >>> list(transpose([(1, 2, 3), (11, 22, 33)])) + [(1, 11), (2, 22), (3, 33)] + + The caller should ensure that the dimensions of the input are compatible. + If the input is empty, no output will be produced. + """ + return _zip_strict(*it) + + +def _is_scalar(value, stringlike=(str, bytes)): + "Scalars are bytes, strings, and non-iterables." + try: + iter(value) + except TypeError: + return True + return isinstance(value, stringlike) + + +def _flatten_tensor(tensor): + "Depth-first iterator over scalars in a tensor." + iterator = iter(tensor) + while True: + try: + value = next(iterator) + except StopIteration: + return iterator + iterator = chain((value,), iterator) + if _is_scalar(value): + return iterator + iterator = chain.from_iterable(iterator) + + +def reshape(matrix, shape): + """Change the shape of a *matrix*. + + If *shape* is an integer, the matrix must be two dimensional + and the shape is interpreted as the desired number of columns: + + >>> matrix = [(0, 1), (2, 3), (4, 5)] + >>> cols = 3 + >>> list(reshape(matrix, cols)) + [(0, 1, 2), (3, 4, 5)] + + If *shape* is a tuple (or other iterable), the input matrix can have + any number of dimensions. It will first be flattened and then rebuilt + to the desired shape which can also be multidimensional: + + >>> matrix = [(0, 1), (2, 3), (4, 5)] # Start with a 3 x 2 matrix + + >>> list(reshape(matrix, (2, 3))) # Make a 2 x 3 matrix + [(0, 1, 2), (3, 4, 5)] + + >>> list(reshape(matrix, (6,))) # Make a vector of length six + [0, 1, 2, 3, 4, 5] + + >>> list(reshape(matrix, (2, 1, 3, 1))) # Make 2 x 1 x 3 x 1 tensor + [(((0,), (1,), (2,)),), (((3,), (4,), (5,)),)] + + Each dimension is assumed to be uniform, either all arrays or all scalars. + Flattening stops when the first value in a dimension is a scalar. + Scalars are bytes, strings, and non-iterables. + The reshape iterator stops when the requested shape is complete + or when the input is exhausted, whichever comes first. + + """ + if isinstance(shape, int): + return batched(chain.from_iterable(matrix), shape) + first_dim, *dims = shape + scalar_stream = _flatten_tensor(matrix) + reshaped = reduce(batched, reversed(dims), scalar_stream) + return islice(reshaped, first_dim) + + +def matmul(m1, m2): + """Multiply two matrices. + + >>> list(matmul([(7, 5), (3, 5)], [(2, 5), (7, 9)])) + [(49, 80), (41, 60)] + + The caller should ensure that the dimensions of the input matrices are + compatible with each other. + + Supports all numeric types: int, float, complex, Decimal, Fraction. + """ + n = len(m2[0]) + return batched(starmap(_sumprod, product(m1, transpose(m2))), n) + + +def _factor_pollard(n): + # Return a factor of n using Pollard's rho algorithm. + # Efficient when n is odd and composite. + for b in range(1, n): + x = y = 2 + d = 1 + while d == 1: + x = (x * x + b) % n + y = (y * y + b) % n + y = (y * y + b) % n + d = gcd(x - y, n) + if d != n: + return d + raise ValueError('prime or under 5') # pragma: no cover + + +_primes_below_211 = tuple(sieve(211)) + + +def factor(n): + """Yield the prime factors of n. + + >>> list(factor(360)) + [2, 2, 2, 3, 3, 5] + + Finds small factors with trial division. Larger factors are + either verified as prime with ``is_prime`` or split into + smaller factors with Pollard's rho algorithm. + """ + + # Corner case reduction + if n < 2: + return + + # Trial division reduction + for prime in _primes_below_211: + while not n % prime: + yield prime + n //= prime + + # Pollard's rho reduction + primes = [] + todo = [n] if n > 1 else [] + for n in todo: + if n < 211**2 or is_prime(n): + primes.append(n) + else: + fact = _factor_pollard(n) + todo += (fact, n // fact) + yield from sorted(primes) + + +def polynomial_eval(coefficients, x): + """Evaluate a polynomial at a specific value. + + Computes with better numeric stability than Horner's method. + + Evaluate ``x^3 - 4 * x^2 - 17 * x + 60`` at ``x = 2.5``: + + >>> coefficients = [1, -4, -17, 60] + >>> x = 2.5 + >>> polynomial_eval(coefficients, x) + 8.125 + + Note that polynomial coefficients are specified in descending power order. + + Supports all numeric types: int, float, complex, Decimal, Fraction. + """ + n = len(coefficients) + if n == 0: + return type(x)(0) + powers = map(pow, repeat(x), reversed(range(n))) + return _sumprod(coefficients, powers) + + +def sum_of_squares(it): + """Return the sum of the squares of the input values. + + >>> sum_of_squares([10, 20, 30]) + 1400 + + Supports all numeric types: int, float, complex, Decimal, Fraction. + """ + return _sumprod(*tee(it)) + + +def polynomial_derivative(coefficients): + """Compute the first derivative of a polynomial. + + Evaluate the derivative of ``x³ - 4 x² - 17 x + 60``: + + >>> coefficients = [1, -4, -17, 60] + >>> derivative_coefficients = polynomial_derivative(coefficients) + >>> derivative_coefficients + [3, -8, -17] + + Note that polynomial coefficients are specified in descending power order. + + Supports all numeric types: int, float, complex, Decimal, Fraction. + """ + n = len(coefficients) + powers = reversed(range(1, n)) + return list(map(mul, coefficients, powers)) + + +def totient(n): + """Return the count of natural numbers up to *n* that are coprime with *n*. + + Euler's totient function φ(n) gives the number of totatives. + Totative are integers k in the range 1 ≤ k ≤ n such that gcd(n, k) = 1. + + >>> n = 9 + >>> totient(n) + 6 + + >>> totatives = [x for x in range(1, n) if gcd(n, x) == 1] + >>> totatives + [1, 2, 4, 5, 7, 8] + >>> len(totatives) + 6 + + Reference: https://en.wikipedia.org/wiki/Euler%27s_totient_function + + """ + for prime in set(factor(n)): + n -= n // prime + return n + + +# Miller–Rabin primality test: https://oeis.org/A014233 +_perfect_tests = [ + (2047, (2,)), + (9080191, (31, 73)), + (4759123141, (2, 7, 61)), + (1122004669633, (2, 13, 23, 1662803)), + (2152302898747, (2, 3, 5, 7, 11)), + (3474749660383, (2, 3, 5, 7, 11, 13)), + (18446744073709551616, (2, 325, 9375, 28178, 450775, 9780504, 1795265022)), + ( + 3317044064679887385961981, + (2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41), + ), +] + + +@lru_cache +def _shift_to_odd(n): + 'Return s, d such that 2**s * d == n' + s = ((n - 1) ^ n).bit_length() - 1 + d = n >> s + assert (1 << s) * d == n and d & 1 and s >= 0 + return s, d + + +def _strong_probable_prime(n, base): + assert (n > 2) and (n & 1) and (2 <= base < n) + + s, d = _shift_to_odd(n - 1) + + x = pow(base, d, n) + if x == 1 or x == n - 1: + return True + + for _ in range(s - 1): + x = x * x % n + if x == n - 1: + return True + + return False + + +# Separate instance of Random() that doesn't share state +# with the default user instance of Random(). +_private_randrange = random.Random().randrange + + +def is_prime(n): + """Return ``True`` if *n* is prime and ``False`` otherwise. + + Basic examples: + + >>> is_prime(37) + True + >>> is_prime(3 * 13) + False + >>> is_prime(18_446_744_073_709_551_557) + True + + Find the next prime over one billion: + + >>> next(filter(is_prime, count(10**9))) + 1000000007 + + Generate random primes up to 200 bits and up to 60 decimal digits: + + >>> from random import seed, randrange, getrandbits + >>> seed(18675309) + + >>> next(filter(is_prime, map(getrandbits, repeat(200)))) + 893303929355758292373272075469392561129886005037663238028407 + + >>> next(filter(is_prime, map(randrange, repeat(10**60)))) + 269638077304026462407872868003560484232362454342414618963649 + + This function is exact for values of *n* below 10**24. For larger inputs, + the probabilistic Miller-Rabin primality test has a less than 1 in 2**128 + chance of a false positive. + """ + + if n < 17: + return n in {2, 3, 5, 7, 11, 13} + + if not (n & 1 and n % 3 and n % 5 and n % 7 and n % 11 and n % 13): + return False + + for limit, bases in _perfect_tests: + if n < limit: + break + else: + bases = (_private_randrange(2, n - 1) for i in range(64)) + + return all(_strong_probable_prime(n, base) for base in bases) + + +def loops(n): + """Returns an iterable with *n* elements for efficient looping. + Like ``range(n)`` but doesn't create integers. + + >>> i = 0 + >>> for _ in loops(5): + ... i += 1 + >>> i + 5 + + """ + return repeat(None, n) + + +def multinomial(*counts): + """Number of distinct arrangements of a multiset. + + The expression ``multinomial(3, 4, 2)`` has several equivalent + interpretations: + + * In the expansion of ``(a + b + c)⁹``, the coefficient of the + ``a³b⁴c²`` term is 1260. + + * There are 1260 distinct ways to arrange 9 balls consisting of 3 reds, 4 + greens, and 2 blues. + + * There are 1260 unique ways to place 9 distinct objects into three bins + with sizes 3, 4, and 2. + + The :func:`multinomial` function computes the length of + :func:`distinct_permutations`. For example, there are 83,160 distinct + anagrams of the word "abracadabra": + + >>> from more_itertools import distinct_permutations, ilen + >>> ilen(distinct_permutations('abracadabra')) + 83160 + + This can be computed directly from the letter counts, 5a 2b 2r 1c 1d: + + >>> from collections import Counter + >>> list(Counter('abracadabra').values()) + [5, 2, 2, 1, 1] + >>> multinomial(5, 2, 2, 1, 1) + 83160 + + A binomial coefficient is a special case of multinomial where there are + only two categories. For example, the number of ways to arrange 12 balls + with 5 reds and 7 blues is ``multinomial(5, 7)`` or ``math.comb(12, 5)``. + + Likewise, factorial is a special case of multinomial where + the multiplicities are all just 1 so that + ``multinomial(1, 1, 1, 1, 1, 1, 1) == math.factorial(7)``. + + Reference: https://en.wikipedia.org/wiki/Multinomial_theorem + + """ + return prod(map(comb, accumulate(counts), counts)) + + +def _running_median_minheap_and_maxheap(iterator): # pragma: no cover + "Non-windowed running_median() for Python 3.14+" + + read = iterator.__next__ + lo = [] # max-heap + hi = [] # min-heap (same size as or one smaller than lo) + + with suppress(StopIteration): + while True: + heappush_max(lo, heappushpop(hi, read())) + yield lo[0] + + heappush(hi, heappushpop_max(lo, read())) + yield (lo[0] + hi[0]) / 2 + + +def _running_median_minheap_only(iterator): # pragma: no cover + "Backport of non-windowed running_median() for Python 3.13 and prior." + + read = iterator.__next__ + lo = [] # max-heap (actually a minheap with negated values) + hi = [] # min-heap (same size as or one smaller than lo) + + with suppress(StopIteration): + while True: + heappush(lo, -heappushpop(hi, read())) + yield -lo[0] + + heappush(hi, -heappushpop(lo, -read())) + yield (hi[0] - lo[0]) / 2 + + +def _running_median_windowed(iterator, maxlen): + "Yield median of values in a sliding window." + + window = deque() + ordered = [] + + for x in iterator: + window.append(x) + insort(ordered, x) + + if len(ordered) > maxlen: + i = bisect_left(ordered, window.popleft()) + del ordered[i] + + n = len(ordered) + m = n // 2 + yield ordered[m] if n & 1 else (ordered[m - 1] + ordered[m]) / 2 + + +def running_median(iterable, *, maxlen=None): + """Cumulative median of values seen so far or values in a sliding window. + + Set *maxlen* to a positive integer to specify the maximum size + of the sliding window. The default of *None* is equivalent to + an unbounded window. + + For example: + + >>> list(running_median([5.0, 9.0, 4.0, 12.0, 8.0, 9.0])) + [5.0, 7.0, 5.0, 7.0, 8.0, 8.5] + >>> list(running_median([5.0, 9.0, 4.0, 12.0, 8.0, 9.0], maxlen=3)) + [5.0, 7.0, 5.0, 9.0, 8.0, 9.0] + + Supports numeric types such as int, float, Decimal, and Fraction, + but not complex numbers which are unorderable. + + On version Python 3.13 and prior, max-heaps are simulated with + negative values. The negation causes Decimal inputs to apply context + rounding, making the results slightly different than that obtained + by statistics.median(). + """ + + iterator = iter(iterable) + + if maxlen is not None: + maxlen = index(maxlen) + if maxlen <= 0: + raise ValueError('Window size should be positive') + return _running_median_windowed(iterator, maxlen) + + if not _max_heap_available: + return _running_median_minheap_only(iterator) # pragma: no cover + + return _running_median_minheap_and_maxheap(iterator) # pragma: no cover diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/recipes.pyi b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/recipes.pyi new file mode 100644 index 0000000000000000000000000000000000000000..de3d0a1777a547e986cba595de72f92b8e3cedbd --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/recipes.pyi @@ -0,0 +1,205 @@ +"""Stubs for more_itertools.recipes""" + +from __future__ import annotations + +from collections.abc import Iterable, Iterator, Sequence +from decimal import Decimal +from fractions import Fraction +from typing import ( + Any, + Callable, + TypeVar, + overload, +) + +__all__ = [ + 'all_equal', + 'batched', + 'before_and_after', + 'consume', + 'convolve', + 'dotproduct', + 'first_true', + 'factor', + 'flatten', + 'grouper', + 'is_prime', + 'iter_except', + 'iter_index', + 'loops', + 'matmul', + 'multinomial', + 'ncycles', + 'nth', + 'nth_combination', + 'padnone', + 'pad_none', + 'pairwise', + 'partition', + 'polynomial_eval', + 'polynomial_from_roots', + 'polynomial_derivative', + 'powerset', + 'prepend', + 'quantify', + 'reshape', + 'random_combination_with_replacement', + 'random_combination', + 'random_permutation', + 'random_product', + 'repeatfunc', + 'roundrobin', + 'running_median', + 'sieve', + 'sliding_window', + 'subslices', + 'sum_of_squares', + 'tabulate', + 'tail', + 'take', + 'totient', + 'transpose', + 'triplewise', + 'unique', + 'unique_everseen', + 'unique_justseen', +] + +# Type and type variable definitions +_T = TypeVar('_T') +_T1 = TypeVar('_T1') +_T2 = TypeVar('_T2') +_U = TypeVar('_U') +_NumberT = TypeVar("_NumberT", float, Decimal, Fraction) + +def take(n: int, iterable: Iterable[_T]) -> list[_T]: ... +def tabulate( + function: Callable[[int], _T], start: int = ... +) -> Iterator[_T]: ... +def tail(n: int, iterable: Iterable[_T]) -> Iterator[_T]: ... +def consume(iterator: Iterable[_T], n: int | None = ...) -> None: ... +@overload +def nth(iterable: Iterable[_T], n: int) -> _T | None: ... +@overload +def nth(iterable: Iterable[_T], n: int, default: _U) -> _T | _U: ... +def all_equal( + iterable: Iterable[_T], key: Callable[[_T], _U] | None = ... +) -> bool: ... +def quantify( + iterable: Iterable[_T], pred: Callable[[_T], bool] = ... +) -> int: ... +def pad_none(iterable: Iterable[_T]) -> Iterator[_T | None]: ... +def padnone(iterable: Iterable[_T]) -> Iterator[_T | None]: ... +def ncycles(iterable: Iterable[_T], n: int) -> Iterator[_T]: ... +def dotproduct(vec1: Iterable[_T1], vec2: Iterable[_T2]) -> Any: ... +def flatten(listOfLists: Iterable[Iterable[_T]]) -> Iterator[_T]: ... +def repeatfunc( + func: Callable[..., _U], times: int | None = ..., *args: Any +) -> Iterator[_U]: ... +def pairwise(iterable: Iterable[_T]) -> Iterator[tuple[_T, _T]]: ... +def grouper( + iterable: Iterable[_T], + n: int, + incomplete: str = ..., + fillvalue: _U = ..., +) -> Iterator[tuple[_T | _U, ...]]: ... +def roundrobin(*iterables: Iterable[_T]) -> Iterator[_T]: ... +def partition( + pred: Callable[[_T], object] | None, iterable: Iterable[_T] +) -> tuple[Iterator[_T], Iterator[_T]]: ... +def powerset(iterable: Iterable[_T]) -> Iterator[tuple[_T, ...]]: ... +def unique_everseen( + iterable: Iterable[_T], key: Callable[[_T], _U] | None = ... +) -> Iterator[_T]: ... +def unique_justseen( + iterable: Iterable[_T], key: Callable[[_T], object] | None = ... +) -> Iterator[_T]: ... +def unique( + iterable: Iterable[_T], + key: Callable[[_T], object] | None = ..., + reverse: bool = False, +) -> Iterator[_T]: ... +@overload +def iter_except( + func: Callable[[], _T], + exception: type[BaseException] | tuple[type[BaseException], ...], + first: None = ..., +) -> Iterator[_T]: ... +@overload +def iter_except( + func: Callable[[], _T], + exception: type[BaseException] | tuple[type[BaseException], ...], + first: Callable[[], _U], +) -> Iterator[_T | _U]: ... +@overload +def first_true( + iterable: Iterable[_T], *, pred: Callable[[_T], object] | None = ... +) -> _T | None: ... +@overload +def first_true( + iterable: Iterable[_T], + default: _U, + pred: Callable[[_T], object] | None = ..., +) -> _T | _U: ... +def random_product( + *args: Iterable[_T], repeat: int = ... +) -> tuple[_T, ...]: ... +def random_permutation( + iterable: Iterable[_T], r: int | None = ... +) -> tuple[_T, ...]: ... +def random_combination(iterable: Iterable[_T], r: int) -> tuple[_T, ...]: ... +def random_combination_with_replacement( + iterable: Iterable[_T], r: int +) -> tuple[_T, ...]: ... +def nth_combination( + iterable: Iterable[_T], r: int, index: int +) -> tuple[_T, ...]: ... +def prepend(value: _T, iterator: Iterable[_U]) -> Iterator[_T | _U]: ... +def convolve(signal: Iterable[_T], kernel: Iterable[_T]) -> Iterator[_T]: ... +def before_and_after( + predicate: Callable[[_T], bool], it: Iterable[_T] +) -> tuple[Iterator[_T], Iterator[_T]]: ... +def triplewise(iterable: Iterable[_T]) -> Iterator[tuple[_T, _T, _T]]: ... +def sliding_window( + iterable: Iterable[_T], n: int +) -> Iterator[tuple[_T, ...]]: ... +def subslices(iterable: Iterable[_T]) -> Iterator[list[_T]]: ... +def polynomial_from_roots(roots: Sequence[_T]) -> list[_T]: ... +def iter_index( + iterable: Iterable[_T], + value: Any, + start: int | None = ..., + stop: int | None = ..., +) -> Iterator[int]: ... +def sieve(n: int) -> Iterator[int]: ... +def _batched( + iterable: Iterable[_T], n: int, *, strict: bool = False +) -> Iterator[tuple[_T, ...]]: ... + +batched = _batched + +def transpose( + it: Iterable[Iterable[_T]], +) -> Iterator[tuple[_T, ...]]: ... +@overload +def reshape( + matrix: Iterable[Iterable[_T]], shape: int +) -> Iterator[tuple[_T, ...]]: ... +@overload +def reshape(matrix: Iterable[Any], shape: Iterable[int]) -> Iterator[Any]: ... +def matmul(m1: Sequence[_T], m2: Sequence[_T]) -> Iterator[tuple[_T]]: ... +def _factor_trial(n: int) -> Iterator[int]: ... +def _factor_pollard(n: int) -> int: ... +def factor(n: int) -> Iterator[int]: ... +def polynomial_eval(coefficients: Sequence[_T], x: _U) -> _U: ... +def sum_of_squares(it: Iterable[_T]) -> _T: ... +def polynomial_derivative(coefficients: Sequence[_T]) -> list[_T]: ... +def totient(n: int) -> int: ... +def _shift_to_odd(n: int) -> tuple[int, int]: ... +def _strong_probable_prime(n: int, base: int) -> bool: ... +def is_prime(n: int) -> bool: ... +def loops(n: int) -> Iterator[None]: ... +def multinomial(*counts: int) -> int: ... +def running_median( + iterable: Iterable[_NumberT], *, maxlen: int | None = ... +) -> Iterator[_NumberT]: ... diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging-26.0.dist-info/INSTALLER b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging-26.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..5c69047b2eb8235994febeeae1da4a82365a240a --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging-26.0.dist-info/INSTALLER @@ -0,0 +1 @@ +uv \ No newline at end of file diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging-26.0.dist-info/METADATA b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging-26.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..3200e601f970271fdde3fcc74f9af4423655a79d --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging-26.0.dist-info/METADATA @@ -0,0 +1,107 @@ +Metadata-Version: 2.4 +Name: packaging +Version: 26.0 +Summary: Core utilities for Python packages +Author-email: Donald Stufft +Requires-Python: >=3.8 +Description-Content-Type: text/x-rst +License-Expression: Apache-2.0 OR BSD-2-Clause +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Classifier: Programming Language :: Python :: 3.14 +Classifier: Programming Language :: Python :: Implementation :: CPython +Classifier: Programming Language :: Python :: Implementation :: PyPy +Classifier: Typing :: Typed +License-File: LICENSE +License-File: LICENSE.APACHE +License-File: LICENSE.BSD +Project-URL: Documentation, https://packaging.pypa.io/ +Project-URL: Source, https://github.com/pypa/packaging + +packaging +========= + +.. start-intro + +Reusable core utilities for various Python Packaging +`interoperability specifications `_. + +This library provides utilities that implement the interoperability +specifications which have clearly one correct behaviour (eg: :pep:`440`) +or benefit greatly from having a single shared implementation (eg: :pep:`425`). + +.. end-intro + +The ``packaging`` project includes the following: version handling, specifiers, +markers, requirements, tags, metadata, lockfiles, utilities. + +Documentation +------------- + +The `documentation`_ provides information and the API for the following: + +- Version Handling +- Specifiers +- Markers +- Requirements +- Tags +- Metadata +- Lockfiles +- Utilities + +Installation +------------ + +Use ``pip`` to install these utilities:: + + pip install packaging + +The ``packaging`` library uses calendar-based versioning (``YY.N``). + +Discussion +---------- + +If you run into bugs, you can file them in our `issue tracker`_. + +You can also join ``#pypa`` on Freenode to ask questions or get involved. + + +.. _`documentation`: https://packaging.pypa.io/ +.. _`issue tracker`: https://github.com/pypa/packaging/issues + + +Code of Conduct +--------------- + +Everyone interacting in the packaging project's codebases, issue trackers, chat +rooms, and mailing lists is expected to follow the `PSF Code of Conduct`_. + +.. _PSF Code of Conduct: https://github.com/pypa/.github/blob/main/CODE_OF_CONDUCT.md + +Contributing +------------ + +The ``CONTRIBUTING.rst`` file outlines how to contribute to this project as +well as how to report a potential security issue. The documentation for this +project also covers information about `project development`_ and `security`_. + +.. _`project development`: https://packaging.pypa.io/en/latest/development/ +.. _`security`: https://packaging.pypa.io/en/latest/security/ + +Project History +--------------- + +Please review the ``CHANGELOG.rst`` file or the `Changelog documentation`_ for +recent changes and project history. + +.. _`Changelog documentation`: https://packaging.pypa.io/en/latest/changelog/ + diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging-26.0.dist-info/RECORD b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging-26.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..38cdeafd21f1eab74d3f49f069bac093d7694f84 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging-26.0.dist-info/RECORD @@ -0,0 +1,26 @@ +packaging-26.0.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2 +packaging-26.0.dist-info/METADATA,sha256=M2K7fWom2iliuo2qpHhc0LrKwhq6kIoRlcyPWVgKJlo,3309 +packaging-26.0.dist-info/RECORD,, +packaging-26.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +packaging-26.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82 +packaging-26.0.dist-info/licenses/LICENSE,sha256=ytHvW9NA1z4HS6YU0m996spceUDD2MNIUuZcSQlobEg,197 +packaging-26.0.dist-info/licenses/LICENSE.APACHE,sha256=DVQuDIgE45qn836wDaWnYhSdxoLXgpRRKH4RuTjpRZQ,10174 +packaging-26.0.dist-info/licenses/LICENSE.BSD,sha256=tw5-m3QvHMb5SLNMFqo5_-zpQZY2S8iP8NIYDwAo-sU,1344 +packaging/__init__.py,sha256=y4lVbpeBzCGk-IPDw5BGBZ_b0P3ukEEJZAbGYc6Ey8c,494 +packaging/_elffile.py,sha256=-sKkptYqzYw2-x3QByJa5mB4rfPWu1pxkZHRx1WAFCY,3211 +packaging/_manylinux.py,sha256=Hf6nB0cOrayEs96-p3oIXAgGnFquv20DO5l-o2_Xnv0,9559 +packaging/_musllinux.py,sha256=Z6swjH3MA7XS3qXnmMN7QPhqP3fnoYI0eQ18e9-HgAE,2707 +packaging/_parser.py,sha256=U_DajsEx2VoC_F46fSVV3hDKNCWoQYkPkasO3dld0ig,10518 +packaging/_structures.py,sha256=Hn49Ta8zV9Wo8GiCL8Nl2ARZY983Un3pruZGVNldPwE,1514 +packaging/_tokenizer.py,sha256=M8EwNIdXeL9NMFuFrQtiOKwjka_xFx8KjRQnfE8O_z8,5421 +packaging/licenses/__init__.py,sha256=TwXLHZCXwSgdFwRLPxW602T6mSieunSFHM6fp8pgW78,5819 +packaging/licenses/_spdx.py,sha256=WW7DXiyg68up_YND_wpRYlr1SHhiV4FfJLQffghhMxQ,51122 +packaging/markers.py,sha256=ZX-cLvW1S3cZcEc0fHI4z7zSx5U2T19yMpDP_mE-CYw,12771 +packaging/metadata.py,sha256=CWVZpN_HfoYMSSDuCP7igOvGgqA9AOmpW8f3qTisfnc,39360 +packaging/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +packaging/pylock.py,sha256=-R1uNfJ4PaLto7Mg62YsGOHgvskuiIEqPwxOywl42Jk,22537 +packaging/requirements.py,sha256=PMCAWD8aNMnVD-6uZMedhBuAVX2573eZ4yPBLXmz04I,2870 +packaging/specifiers.py,sha256=EPNPimY_zFivthv1vdjZYz5IqkKGsnKR2yKh-EVyvZw,40797 +packaging/tags.py,sha256=cXLV1pJD3UtJlDg7Wz3zrfdQhRZqr8jumSAKKAAd2xE,22856 +packaging/utils.py,sha256=N4c6oZzFJy6klTZ3AnkNz7sSkJesuFWPp68LA3B5dAo,5040 +packaging/version.py,sha256=7XWlL2IDYLwDYC0ht6cFEhapLwLWbmyo4rb7sEFj0x8,23272 diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging-26.0.dist-info/REQUESTED b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging-26.0.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging-26.0.dist-info/WHEEL b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging-26.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..d8b9936dad9ab2513fa6979f411560d3b6b57e37 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging-26.0.dist-info/WHEEL @@ -0,0 +1,4 @@ +Wheel-Version: 1.0 +Generator: flit 3.12.0 +Root-Is-Purelib: true +Tag: py3-none-any diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging-26.0.dist-info/licenses/LICENSE b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging-26.0.dist-info/licenses/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..6f62d44e4ef733c0e713afcd2371fed7f2b3de67 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging-26.0.dist-info/licenses/LICENSE @@ -0,0 +1,3 @@ +This software is made available under the terms of *either* of the licenses +found in LICENSE.APACHE or LICENSE.BSD. Contributions to this software is made +under the terms of *both* these licenses. diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging-26.0.dist-info/licenses/LICENSE.APACHE b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging-26.0.dist-info/licenses/LICENSE.APACHE new file mode 100644 index 0000000000000000000000000000000000000000..f433b1a53f5b830a205fd2df78e2b34974656c7b --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging-26.0.dist-info/licenses/LICENSE.APACHE @@ -0,0 +1,177 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging-26.0.dist-info/licenses/LICENSE.BSD b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging-26.0.dist-info/licenses/LICENSE.BSD new file mode 100644 index 0000000000000000000000000000000000000000..42ce7b75c92fb01a3f6ed17eea363f756b7da582 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging-26.0.dist-info/licenses/LICENSE.BSD @@ -0,0 +1,23 @@ +Copyright (c) Donald Stufft and individual contributors. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/__init__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21695a74b5107c96ba4bb2cbca6b7f259dacd330 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/__init__.py @@ -0,0 +1,15 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +__title__ = "packaging" +__summary__ = "Core utilities for Python packages" +__uri__ = "https://github.com/pypa/packaging" + +__version__ = "26.0" + +__author__ = "Donald Stufft and individual contributors" +__email__ = "donald@stufft.io" + +__license__ = "BSD-2-Clause or Apache-2.0" +__copyright__ = f"2014 {__author__}" diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/_elffile.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/_elffile.py new file mode 100644 index 0000000000000000000000000000000000000000..497b0645217512ae2ba8ff61341fd2bbfa3648cd --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/_elffile.py @@ -0,0 +1,108 @@ +""" +ELF file parser. + +This provides a class ``ELFFile`` that parses an ELF executable in a similar +interface to ``ZipFile``. Only the read interface is implemented. + +ELF header: https://refspecs.linuxfoundation.org/elf/gabi4+/ch4.eheader.html +""" + +from __future__ import annotations + +import enum +import os +import struct +from typing import IO + + +class ELFInvalid(ValueError): + pass + + +class EIClass(enum.IntEnum): + C32 = 1 + C64 = 2 + + +class EIData(enum.IntEnum): + Lsb = 1 + Msb = 2 + + +class EMachine(enum.IntEnum): + I386 = 3 + S390 = 22 + Arm = 40 + X8664 = 62 + AArc64 = 183 + + +class ELFFile: + """ + Representation of an ELF executable. + """ + + def __init__(self, f: IO[bytes]) -> None: + self._f = f + + try: + ident = self._read("16B") + except struct.error as e: + raise ELFInvalid("unable to parse identification") from e + magic = bytes(ident[:4]) + if magic != b"\x7fELF": + raise ELFInvalid(f"invalid magic: {magic!r}") + + self.capacity = ident[4] # Format for program header (bitness). + self.encoding = ident[5] # Data structure encoding (endianness). + + try: + # e_fmt: Format for program header. + # p_fmt: Format for section header. + # p_idx: Indexes to find p_type, p_offset, and p_filesz. + e_fmt, self._p_fmt, self._p_idx = { + (1, 1): ("HHIIIIIHHH", ">IIIIIIII", (0, 1, 4)), # 32-bit MSB. + (2, 1): ("HHIQQQIHHH", ">IIQQQQQQ", (0, 2, 5)), # 64-bit MSB. + }[(self.capacity, self.encoding)] + except KeyError as e: + raise ELFInvalid( + f"unrecognized capacity ({self.capacity}) or encoding ({self.encoding})" + ) from e + + try: + ( + _, + self.machine, # Architecture type. + _, + _, + self._e_phoff, # Offset of program header. + _, + self.flags, # Processor-specific flags. + _, + self._e_phentsize, # Size of section. + self._e_phnum, # Number of sections. + ) = self._read(e_fmt) + except struct.error as e: + raise ELFInvalid("unable to parse machine and section information") from e + + def _read(self, fmt: str) -> tuple[int, ...]: + return struct.unpack(fmt, self._f.read(struct.calcsize(fmt))) + + @property + def interpreter(self) -> str | None: + """ + The path recorded in the ``PT_INTERP`` section header. + """ + for index in range(self._e_phnum): + self._f.seek(self._e_phoff + self._e_phentsize * index) + try: + data = self._read(self._p_fmt) + except struct.error: + continue + if data[self._p_idx[0]] != 3: # Not PT_INTERP. + continue + self._f.seek(data[self._p_idx[1]]) + return os.fsdecode(self._f.read(data[self._p_idx[2]])).strip("\0") + return None diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/_manylinux.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/_manylinux.py new file mode 100644 index 0000000000000000000000000000000000000000..0e79e8a882be74fe76c80ccf49a9cd68fb636fd4 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/_manylinux.py @@ -0,0 +1,262 @@ +from __future__ import annotations + +import collections +import contextlib +import functools +import os +import re +import sys +import warnings +from typing import Generator, Iterator, NamedTuple, Sequence + +from ._elffile import EIClass, EIData, ELFFile, EMachine + +EF_ARM_ABIMASK = 0xFF000000 +EF_ARM_ABI_VER5 = 0x05000000 +EF_ARM_ABI_FLOAT_HARD = 0x00000400 + +_ALLOWED_ARCHS = { + "x86_64", + "aarch64", + "ppc64", + "ppc64le", + "s390x", + "loongarch64", + "riscv64", +} + + +# `os.PathLike` not a generic type until Python 3.9, so sticking with `str` +# as the type for `path` until then. +@contextlib.contextmanager +def _parse_elf(path: str) -> Generator[ELFFile | None, None, None]: + try: + with open(path, "rb") as f: + yield ELFFile(f) + except (OSError, TypeError, ValueError): + yield None + + +def _is_linux_armhf(executable: str) -> bool: + # hard-float ABI can be detected from the ELF header of the running + # process + # https://static.docs.arm.com/ihi0044/g/aaelf32.pdf + with _parse_elf(executable) as f: + return ( + f is not None + and f.capacity == EIClass.C32 + and f.encoding == EIData.Lsb + and f.machine == EMachine.Arm + and f.flags & EF_ARM_ABIMASK == EF_ARM_ABI_VER5 + and f.flags & EF_ARM_ABI_FLOAT_HARD == EF_ARM_ABI_FLOAT_HARD + ) + + +def _is_linux_i686(executable: str) -> bool: + with _parse_elf(executable) as f: + return ( + f is not None + and f.capacity == EIClass.C32 + and f.encoding == EIData.Lsb + and f.machine == EMachine.I386 + ) + + +def _have_compatible_abi(executable: str, archs: Sequence[str]) -> bool: + if "armv7l" in archs: + return _is_linux_armhf(executable) + if "i686" in archs: + return _is_linux_i686(executable) + return any(arch in _ALLOWED_ARCHS for arch in archs) + + +# If glibc ever changes its major version, we need to know what the last +# minor version was, so we can build the complete list of all versions. +# For now, guess what the highest minor version might be, assume it will +# be 50 for testing. Once this actually happens, update the dictionary +# with the actual value. +_LAST_GLIBC_MINOR: dict[int, int] = collections.defaultdict(lambda: 50) + + +class _GLibCVersion(NamedTuple): + major: int + minor: int + + +def _glibc_version_string_confstr() -> str | None: + """ + Primary implementation of glibc_version_string using os.confstr. + """ + # os.confstr is quite a bit faster than ctypes.DLL. It's also less likely + # to be broken or missing. This strategy is used in the standard library + # platform module. + # https://github.com/python/cpython/blob/fcf1d003bf4f0100c/Lib/platform.py#L175-L183 + try: + # Should be a string like "glibc 2.17". + version_string: str | None = os.confstr("CS_GNU_LIBC_VERSION") + assert version_string is not None + _, version = version_string.rsplit() + except (AssertionError, AttributeError, OSError, ValueError): + # os.confstr() or CS_GNU_LIBC_VERSION not available (or a bad value)... + return None + return version + + +def _glibc_version_string_ctypes() -> str | None: + """ + Fallback implementation of glibc_version_string using ctypes. + """ + try: + import ctypes # noqa: PLC0415 + except ImportError: + return None + + # ctypes.CDLL(None) internally calls dlopen(NULL), and as the dlopen + # manpage says, "If filename is NULL, then the returned handle is for the + # main program". This way we can let the linker do the work to figure out + # which libc our process is actually using. + # + # We must also handle the special case where the executable is not a + # dynamically linked executable. This can occur when using musl libc, + # for example. In this situation, dlopen() will error, leading to an + # OSError. Interestingly, at least in the case of musl, there is no + # errno set on the OSError. The single string argument used to construct + # OSError comes from libc itself and is therefore not portable to + # hard code here. In any case, failure to call dlopen() means we + # can proceed, so we bail on our attempt. + try: + process_namespace = ctypes.CDLL(None) + except OSError: + return None + + try: + gnu_get_libc_version = process_namespace.gnu_get_libc_version + except AttributeError: + # Symbol doesn't exist -> therefore, we are not linked to + # glibc. + return None + + # Call gnu_get_libc_version, which returns a string like "2.5" + gnu_get_libc_version.restype = ctypes.c_char_p + version_str: str = gnu_get_libc_version() + # py2 / py3 compatibility: + if not isinstance(version_str, str): + version_str = version_str.decode("ascii") + + return version_str + + +def _glibc_version_string() -> str | None: + """Returns glibc version string, or None if not using glibc.""" + return _glibc_version_string_confstr() or _glibc_version_string_ctypes() + + +def _parse_glibc_version(version_str: str) -> _GLibCVersion: + """Parse glibc version. + + We use a regexp instead of str.split because we want to discard any + random junk that might come after the minor version -- this might happen + in patched/forked versions of glibc (e.g. Linaro's version of glibc + uses version strings like "2.20-2014.11"). See gh-3588. + """ + m = re.match(r"(?P[0-9]+)\.(?P[0-9]+)", version_str) + if not m: + warnings.warn( + f"Expected glibc version with 2 components major.minor, got: {version_str}", + RuntimeWarning, + stacklevel=2, + ) + return _GLibCVersion(-1, -1) + return _GLibCVersion(int(m.group("major")), int(m.group("minor"))) + + +@functools.lru_cache +def _get_glibc_version() -> _GLibCVersion: + version_str = _glibc_version_string() + if version_str is None: + return _GLibCVersion(-1, -1) + return _parse_glibc_version(version_str) + + +# From PEP 513, PEP 600 +def _is_compatible(arch: str, version: _GLibCVersion) -> bool: + sys_glibc = _get_glibc_version() + if sys_glibc < version: + return False + # Check for presence of _manylinux module. + try: + import _manylinux # noqa: PLC0415 + except ImportError: + return True + if hasattr(_manylinux, "manylinux_compatible"): + result = _manylinux.manylinux_compatible(version[0], version[1], arch) + if result is not None: + return bool(result) + return True + if version == _GLibCVersion(2, 5) and hasattr(_manylinux, "manylinux1_compatible"): + return bool(_manylinux.manylinux1_compatible) + if version == _GLibCVersion(2, 12) and hasattr( + _manylinux, "manylinux2010_compatible" + ): + return bool(_manylinux.manylinux2010_compatible) + if version == _GLibCVersion(2, 17) and hasattr( + _manylinux, "manylinux2014_compatible" + ): + return bool(_manylinux.manylinux2014_compatible) + return True + + +_LEGACY_MANYLINUX_MAP: dict[_GLibCVersion, str] = { + # CentOS 7 w/ glibc 2.17 (PEP 599) + _GLibCVersion(2, 17): "manylinux2014", + # CentOS 6 w/ glibc 2.12 (PEP 571) + _GLibCVersion(2, 12): "manylinux2010", + # CentOS 5 w/ glibc 2.5 (PEP 513) + _GLibCVersion(2, 5): "manylinux1", +} + + +def platform_tags(archs: Sequence[str]) -> Iterator[str]: + """Generate manylinux tags compatible to the current platform. + + :param archs: Sequence of compatible architectures. + The first one shall be the closest to the actual architecture and be the part of + platform tag after the ``linux_`` prefix, e.g. ``x86_64``. + The ``linux_`` prefix is assumed as a prerequisite for the current platform to + be manylinux-compatible. + + :returns: An iterator of compatible manylinux tags. + """ + if not _have_compatible_abi(sys.executable, archs): + return + # Oldest glibc to be supported regardless of architecture is (2, 17). + too_old_glibc2 = _GLibCVersion(2, 16) + if set(archs) & {"x86_64", "i686"}: + # On x86/i686 also oldest glibc to be supported is (2, 5). + too_old_glibc2 = _GLibCVersion(2, 4) + current_glibc = _GLibCVersion(*_get_glibc_version()) + glibc_max_list = [current_glibc] + # We can assume compatibility across glibc major versions. + # https://sourceware.org/bugzilla/show_bug.cgi?id=24636 + # + # Build a list of maximum glibc versions so that we can + # output the canonical list of all glibc from current_glibc + # down to too_old_glibc2, including all intermediary versions. + for glibc_major in range(current_glibc.major - 1, 1, -1): + glibc_minor = _LAST_GLIBC_MINOR[glibc_major] + glibc_max_list.append(_GLibCVersion(glibc_major, glibc_minor)) + for arch in archs: + for glibc_max in glibc_max_list: + if glibc_max.major == too_old_glibc2.major: + min_minor = too_old_glibc2.minor + else: + # For other glibc major versions oldest supported is (x, 0). + min_minor = -1 + for glibc_minor in range(glibc_max.minor, min_minor, -1): + glibc_version = _GLibCVersion(glibc_max.major, glibc_minor) + if _is_compatible(arch, glibc_version): + yield "manylinux_{}_{}_{}".format(*glibc_version, arch) + + # Handle the legacy manylinux1, manylinux2010, manylinux2014 tags. + if legacy_tag := _LEGACY_MANYLINUX_MAP.get(glibc_version): + yield f"{legacy_tag}_{arch}" diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/_musllinux.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/_musllinux.py new file mode 100644 index 0000000000000000000000000000000000000000..4e8116a79ca80d60657542a23b4bbcbc3c518eaf --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/_musllinux.py @@ -0,0 +1,85 @@ +"""PEP 656 support. + +This module implements logic to detect if the currently running Python is +linked against musl, and what musl version is used. +""" + +from __future__ import annotations + +import functools +import re +import subprocess +import sys +from typing import Iterator, NamedTuple, Sequence + +from ._elffile import ELFFile + + +class _MuslVersion(NamedTuple): + major: int + minor: int + + +def _parse_musl_version(output: str) -> _MuslVersion | None: + lines = [n for n in (n.strip() for n in output.splitlines()) if n] + if len(lines) < 2 or lines[0][:4] != "musl": + return None + m = re.match(r"Version (\d+)\.(\d+)", lines[1]) + if not m: + return None + return _MuslVersion(major=int(m.group(1)), minor=int(m.group(2))) + + +@functools.lru_cache +def _get_musl_version(executable: str) -> _MuslVersion | None: + """Detect currently-running musl runtime version. + + This is done by checking the specified executable's dynamic linking + information, and invoking the loader to parse its output for a version + string. If the loader is musl, the output would be something like:: + + musl libc (x86_64) + Version 1.2.2 + Dynamic Program Loader + """ + try: + with open(executable, "rb") as f: + ld = ELFFile(f).interpreter + except (OSError, TypeError, ValueError): + return None + if ld is None or "musl" not in ld: + return None + proc = subprocess.run([ld], check=False, stderr=subprocess.PIPE, text=True) + return _parse_musl_version(proc.stderr) + + +def platform_tags(archs: Sequence[str]) -> Iterator[str]: + """Generate musllinux tags compatible to the current platform. + + :param archs: Sequence of compatible architectures. + The first one shall be the closest to the actual architecture and be the part of + platform tag after the ``linux_`` prefix, e.g. ``x86_64``. + The ``linux_`` prefix is assumed as a prerequisite for the current platform to + be musllinux-compatible. + + :returns: An iterator of compatible musllinux tags. + """ + sys_musl = _get_musl_version(sys.executable) + if sys_musl is None: # Python not dynamically linked against musl. + return + for arch in archs: + for minor in range(sys_musl.minor, -1, -1): + yield f"musllinux_{sys_musl.major}_{minor}_{arch}" + + +if __name__ == "__main__": # pragma: no cover + import sysconfig + + plat = sysconfig.get_platform() + assert plat.startswith("linux-"), "not linux" + + print("plat:", plat) + print("musl:", _get_musl_version(sys.executable)) + print("tags:", end=" ") + for t in platform_tags(re.sub(r"[.-]", "_", plat.split("-", 1)[-1])): + print(t, end="\n ") diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/_parser.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/_parser.py new file mode 100644 index 0000000000000000000000000000000000000000..f6c1f5cd226b926f96a3bb1e9fb0f18d1bd021c9 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/_parser.py @@ -0,0 +1,365 @@ +"""Handwritten parser of dependency specifiers. + +The docstring for each __parse_* function contains EBNF-inspired grammar representing +the implementation. +""" + +from __future__ import annotations + +import ast +from typing import List, Literal, NamedTuple, Sequence, Tuple, Union + +from ._tokenizer import DEFAULT_RULES, Tokenizer + + +class Node: + __slots__ = ("value",) + + def __init__(self, value: str) -> None: + self.value = value + + def __str__(self) -> str: + return self.value + + def __repr__(self) -> str: + return f"<{self.__class__.__name__}({self.value!r})>" + + def serialize(self) -> str: + raise NotImplementedError + + +class Variable(Node): + __slots__ = () + + def serialize(self) -> str: + return str(self) + + +class Value(Node): + __slots__ = () + + def serialize(self) -> str: + return f'"{self}"' + + +class Op(Node): + __slots__ = () + + def serialize(self) -> str: + return str(self) + + +MarkerLogical = Literal["and", "or"] +MarkerVar = Union[Variable, Value] +MarkerItem = Tuple[MarkerVar, Op, MarkerVar] +MarkerAtom = Union[MarkerItem, Sequence["MarkerAtom"]] +MarkerList = List[Union["MarkerList", MarkerAtom, MarkerLogical]] + + +class ParsedRequirement(NamedTuple): + name: str + url: str + extras: list[str] + specifier: str + marker: MarkerList | None + + +# -------------------------------------------------------------------------------------- +# Recursive descent parser for dependency specifier +# -------------------------------------------------------------------------------------- +def parse_requirement(source: str) -> ParsedRequirement: + return _parse_requirement(Tokenizer(source, rules=DEFAULT_RULES)) + + +def _parse_requirement(tokenizer: Tokenizer) -> ParsedRequirement: + """ + requirement = WS? IDENTIFIER WS? extras WS? requirement_details + """ + tokenizer.consume("WS") + + name_token = tokenizer.expect( + "IDENTIFIER", expected="package name at the start of dependency specifier" + ) + name = name_token.text + tokenizer.consume("WS") + + extras = _parse_extras(tokenizer) + tokenizer.consume("WS") + + url, specifier, marker = _parse_requirement_details(tokenizer) + tokenizer.expect("END", expected="end of dependency specifier") + + return ParsedRequirement(name, url, extras, specifier, marker) + + +def _parse_requirement_details( + tokenizer: Tokenizer, +) -> tuple[str, str, MarkerList | None]: + """ + requirement_details = AT URL (WS requirement_marker?)? + | specifier WS? (requirement_marker)? + """ + + specifier = "" + url = "" + marker = None + + if tokenizer.check("AT"): + tokenizer.read() + tokenizer.consume("WS") + + url_start = tokenizer.position + url = tokenizer.expect("URL", expected="URL after @").text + if tokenizer.check("END", peek=True): + return (url, specifier, marker) + + tokenizer.expect("WS", expected="whitespace after URL") + + # The input might end after whitespace. + if tokenizer.check("END", peek=True): + return (url, specifier, marker) + + marker = _parse_requirement_marker( + tokenizer, + span_start=url_start, + expected="semicolon (after URL and whitespace)", + ) + else: + specifier_start = tokenizer.position + specifier = _parse_specifier(tokenizer) + tokenizer.consume("WS") + + if tokenizer.check("END", peek=True): + return (url, specifier, marker) + + marker = _parse_requirement_marker( + tokenizer, + span_start=specifier_start, + expected=( + "comma (within version specifier), semicolon (after version specifier)" + if specifier + else "semicolon (after name with no version specifier)" + ), + ) + + return (url, specifier, marker) + + +def _parse_requirement_marker( + tokenizer: Tokenizer, *, span_start: int, expected: str +) -> MarkerList: + """ + requirement_marker = SEMICOLON marker WS? + """ + + if not tokenizer.check("SEMICOLON"): + tokenizer.raise_syntax_error( + f"Expected {expected} or end", + span_start=span_start, + span_end=None, + ) + tokenizer.read() + + marker = _parse_marker(tokenizer) + tokenizer.consume("WS") + + return marker + + +def _parse_extras(tokenizer: Tokenizer) -> list[str]: + """ + extras = (LEFT_BRACKET wsp* extras_list? wsp* RIGHT_BRACKET)? + """ + if not tokenizer.check("LEFT_BRACKET", peek=True): + return [] + + with tokenizer.enclosing_tokens( + "LEFT_BRACKET", + "RIGHT_BRACKET", + around="extras", + ): + tokenizer.consume("WS") + extras = _parse_extras_list(tokenizer) + tokenizer.consume("WS") + + return extras + + +def _parse_extras_list(tokenizer: Tokenizer) -> list[str]: + """ + extras_list = identifier (wsp* ',' wsp* identifier)* + """ + extras: list[str] = [] + + if not tokenizer.check("IDENTIFIER"): + return extras + + extras.append(tokenizer.read().text) + + while True: + tokenizer.consume("WS") + if tokenizer.check("IDENTIFIER", peek=True): + tokenizer.raise_syntax_error("Expected comma between extra names") + elif not tokenizer.check("COMMA"): + break + + tokenizer.read() + tokenizer.consume("WS") + + extra_token = tokenizer.expect("IDENTIFIER", expected="extra name after comma") + extras.append(extra_token.text) + + return extras + + +def _parse_specifier(tokenizer: Tokenizer) -> str: + """ + specifier = LEFT_PARENTHESIS WS? version_many WS? RIGHT_PARENTHESIS + | WS? version_many WS? + """ + with tokenizer.enclosing_tokens( + "LEFT_PARENTHESIS", + "RIGHT_PARENTHESIS", + around="version specifier", + ): + tokenizer.consume("WS") + parsed_specifiers = _parse_version_many(tokenizer) + tokenizer.consume("WS") + + return parsed_specifiers + + +def _parse_version_many(tokenizer: Tokenizer) -> str: + """ + version_many = (SPECIFIER (WS? COMMA WS? SPECIFIER)*)? + """ + parsed_specifiers = "" + while tokenizer.check("SPECIFIER"): + span_start = tokenizer.position + parsed_specifiers += tokenizer.read().text + if tokenizer.check("VERSION_PREFIX_TRAIL", peek=True): + tokenizer.raise_syntax_error( + ".* suffix can only be used with `==` or `!=` operators", + span_start=span_start, + span_end=tokenizer.position + 1, + ) + if tokenizer.check("VERSION_LOCAL_LABEL_TRAIL", peek=True): + tokenizer.raise_syntax_error( + "Local version label can only be used with `==` or `!=` operators", + span_start=span_start, + span_end=tokenizer.position, + ) + tokenizer.consume("WS") + if not tokenizer.check("COMMA"): + break + parsed_specifiers += tokenizer.read().text + tokenizer.consume("WS") + + return parsed_specifiers + + +# -------------------------------------------------------------------------------------- +# Recursive descent parser for marker expression +# -------------------------------------------------------------------------------------- +def parse_marker(source: str) -> MarkerList: + return _parse_full_marker(Tokenizer(source, rules=DEFAULT_RULES)) + + +def _parse_full_marker(tokenizer: Tokenizer) -> MarkerList: + retval = _parse_marker(tokenizer) + tokenizer.expect("END", expected="end of marker expression") + return retval + + +def _parse_marker(tokenizer: Tokenizer) -> MarkerList: + """ + marker = marker_atom (BOOLOP marker_atom)+ + """ + expression = [_parse_marker_atom(tokenizer)] + while tokenizer.check("BOOLOP"): + token = tokenizer.read() + expr_right = _parse_marker_atom(tokenizer) + expression.extend((token.text, expr_right)) + return expression + + +def _parse_marker_atom(tokenizer: Tokenizer) -> MarkerAtom: + """ + marker_atom = WS? LEFT_PARENTHESIS WS? marker WS? RIGHT_PARENTHESIS WS? + | WS? marker_item WS? + """ + + tokenizer.consume("WS") + if tokenizer.check("LEFT_PARENTHESIS", peek=True): + with tokenizer.enclosing_tokens( + "LEFT_PARENTHESIS", + "RIGHT_PARENTHESIS", + around="marker expression", + ): + tokenizer.consume("WS") + marker: MarkerAtom = _parse_marker(tokenizer) + tokenizer.consume("WS") + else: + marker = _parse_marker_item(tokenizer) + tokenizer.consume("WS") + return marker + + +def _parse_marker_item(tokenizer: Tokenizer) -> MarkerItem: + """ + marker_item = WS? marker_var WS? marker_op WS? marker_var WS? + """ + tokenizer.consume("WS") + marker_var_left = _parse_marker_var(tokenizer) + tokenizer.consume("WS") + marker_op = _parse_marker_op(tokenizer) + tokenizer.consume("WS") + marker_var_right = _parse_marker_var(tokenizer) + tokenizer.consume("WS") + return (marker_var_left, marker_op, marker_var_right) + + +def _parse_marker_var(tokenizer: Tokenizer) -> MarkerVar: # noqa: RET503 + """ + marker_var = VARIABLE | QUOTED_STRING + """ + if tokenizer.check("VARIABLE"): + return process_env_var(tokenizer.read().text.replace(".", "_")) + elif tokenizer.check("QUOTED_STRING"): + return process_python_str(tokenizer.read().text) + else: + tokenizer.raise_syntax_error( + message="Expected a marker variable or quoted string" + ) + + +def process_env_var(env_var: str) -> Variable: + if env_var in ("platform_python_implementation", "python_implementation"): + return Variable("platform_python_implementation") + else: + return Variable(env_var) + + +def process_python_str(python_str: str) -> Value: + value = ast.literal_eval(python_str) + return Value(str(value)) + + +def _parse_marker_op(tokenizer: Tokenizer) -> Op: + """ + marker_op = IN | NOT IN | OP + """ + if tokenizer.check("IN"): + tokenizer.read() + return Op("in") + elif tokenizer.check("NOT"): + tokenizer.read() + tokenizer.expect("WS", expected="whitespace after 'not'") + tokenizer.expect("IN", expected="'in' after 'not'") + return Op("not in") + elif tokenizer.check("OP"): + return Op(tokenizer.read().text) + else: + return tokenizer.raise_syntax_error( + "Expected marker operator, one of <=, <, !=, ==, >=, >, ~=, ===, in, not in" + ) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/_structures.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/_structures.py new file mode 100644 index 0000000000000000000000000000000000000000..225e2eee01238571c50595eb104e0b70d5f503c4 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/_structures.py @@ -0,0 +1,69 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +import typing + + +@typing.final +class InfinityType: + __slots__ = () + + def __repr__(self) -> str: + return "Infinity" + + def __hash__(self) -> int: + return hash(repr(self)) + + def __lt__(self, other: object) -> bool: + return False + + def __le__(self, other: object) -> bool: + return False + + def __eq__(self, other: object) -> bool: + return isinstance(other, self.__class__) + + def __gt__(self, other: object) -> bool: + return True + + def __ge__(self, other: object) -> bool: + return True + + def __neg__(self: object) -> "NegativeInfinityType": + return NegativeInfinity + + +Infinity = InfinityType() + + +@typing.final +class NegativeInfinityType: + __slots__ = () + + def __repr__(self) -> str: + return "-Infinity" + + def __hash__(self) -> int: + return hash(repr(self)) + + def __lt__(self, other: object) -> bool: + return True + + def __le__(self, other: object) -> bool: + return True + + def __eq__(self, other: object) -> bool: + return isinstance(other, self.__class__) + + def __gt__(self, other: object) -> bool: + return False + + def __ge__(self, other: object) -> bool: + return False + + def __neg__(self: object) -> InfinityType: + return Infinity + + +NegativeInfinity = NegativeInfinityType() diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/_tokenizer.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/_tokenizer.py new file mode 100644 index 0000000000000000000000000000000000000000..e6d20dd3f56f880a92db7409a3e1335cb282a8f2 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/_tokenizer.py @@ -0,0 +1,193 @@ +from __future__ import annotations + +import contextlib +import re +from dataclasses import dataclass +from typing import Generator, Mapping, NoReturn + +from .specifiers import Specifier + + +@dataclass +class Token: + name: str + text: str + position: int + + +class ParserSyntaxError(Exception): + """The provided source text could not be parsed correctly.""" + + def __init__( + self, + message: str, + *, + source: str, + span: tuple[int, int], + ) -> None: + self.span = span + self.message = message + self.source = source + + super().__init__() + + def __str__(self) -> str: + marker = " " * self.span[0] + "~" * (self.span[1] - self.span[0]) + "^" + return f"{self.message}\n {self.source}\n {marker}" + + +DEFAULT_RULES: dict[str, re.Pattern[str]] = { + "LEFT_PARENTHESIS": re.compile(r"\("), + "RIGHT_PARENTHESIS": re.compile(r"\)"), + "LEFT_BRACKET": re.compile(r"\["), + "RIGHT_BRACKET": re.compile(r"\]"), + "SEMICOLON": re.compile(r";"), + "COMMA": re.compile(r","), + "QUOTED_STRING": re.compile( + r""" + ( + ('[^']*') + | + ("[^"]*") + ) + """, + re.VERBOSE, + ), + "OP": re.compile(r"(===|==|~=|!=|<=|>=|<|>)"), + "BOOLOP": re.compile(r"\b(or|and)\b"), + "IN": re.compile(r"\bin\b"), + "NOT": re.compile(r"\bnot\b"), + "VARIABLE": re.compile( + r""" + \b( + python_version + |python_full_version + |os[._]name + |sys[._]platform + |platform_(release|system) + |platform[._](version|machine|python_implementation) + |python_implementation + |implementation_(name|version) + |extras? + |dependency_groups + )\b + """, + re.VERBOSE, + ), + "SPECIFIER": re.compile( + Specifier._operator_regex_str + Specifier._version_regex_str, + re.VERBOSE | re.IGNORECASE, + ), + "AT": re.compile(r"\@"), + "URL": re.compile(r"[^ \t]+"), + "IDENTIFIER": re.compile(r"\b[a-zA-Z0-9][a-zA-Z0-9._-]*\b"), + "VERSION_PREFIX_TRAIL": re.compile(r"\.\*"), + "VERSION_LOCAL_LABEL_TRAIL": re.compile(r"\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*"), + "WS": re.compile(r"[ \t]+"), + "END": re.compile(r"$"), +} + + +class Tokenizer: + """Context-sensitive token parsing. + + Provides methods to examine the input stream to check whether the next token + matches. + """ + + def __init__( + self, + source: str, + *, + rules: Mapping[str, re.Pattern[str]], + ) -> None: + self.source = source + self.rules = rules + self.next_token: Token | None = None + self.position = 0 + + def consume(self, name: str) -> None: + """Move beyond provided token name, if at current position.""" + if self.check(name): + self.read() + + def check(self, name: str, *, peek: bool = False) -> bool: + """Check whether the next token has the provided name. + + By default, if the check succeeds, the token *must* be read before + another check. If `peek` is set to `True`, the token is not loaded and + would need to be checked again. + """ + assert self.next_token is None, ( + f"Cannot check for {name!r}, already have {self.next_token!r}" + ) + assert name in self.rules, f"Unknown token name: {name!r}" + + expression = self.rules[name] + + match = expression.match(self.source, self.position) + if match is None: + return False + if not peek: + self.next_token = Token(name, match[0], self.position) + return True + + def expect(self, name: str, *, expected: str) -> Token: + """Expect a certain token name next, failing with a syntax error otherwise. + + The token is *not* read. + """ + if not self.check(name): + raise self.raise_syntax_error(f"Expected {expected}") + return self.read() + + def read(self) -> Token: + """Consume the next token and return it.""" + token = self.next_token + assert token is not None + + self.position += len(token.text) + self.next_token = None + + return token + + def raise_syntax_error( + self, + message: str, + *, + span_start: int | None = None, + span_end: int | None = None, + ) -> NoReturn: + """Raise ParserSyntaxError at the given position.""" + span = ( + self.position if span_start is None else span_start, + self.position if span_end is None else span_end, + ) + raise ParserSyntaxError( + message, + source=self.source, + span=span, + ) + + @contextlib.contextmanager + def enclosing_tokens( + self, open_token: str, close_token: str, *, around: str + ) -> Generator[None, None, None]: + if self.check(open_token): + open_position = self.position + self.read() + else: + open_position = None + + yield + + if open_position is None: + return + + if not self.check(close_token): + self.raise_syntax_error( + f"Expected matching {close_token} for {open_token}, after {around}", + span_start=open_position, + ) + + self.read() diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/markers.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/markers.py new file mode 100644 index 0000000000000000000000000000000000000000..ca3706fe492f4cf0762f7734d84c2d269f88bbc5 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/markers.py @@ -0,0 +1,388 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import annotations + +import operator +import os +import platform +import sys +from typing import AbstractSet, Callable, Literal, Mapping, TypedDict, Union, cast + +from ._parser import MarkerAtom, MarkerList, Op, Value, Variable +from ._parser import parse_marker as _parse_marker +from ._tokenizer import ParserSyntaxError +from .specifiers import InvalidSpecifier, Specifier +from .utils import canonicalize_name + +__all__ = [ + "Environment", + "EvaluateContext", + "InvalidMarker", + "Marker", + "UndefinedComparison", + "UndefinedEnvironmentName", + "default_environment", +] + +Operator = Callable[[str, Union[str, AbstractSet[str]]], bool] +EvaluateContext = Literal["metadata", "lock_file", "requirement"] +MARKERS_ALLOWING_SET = {"extras", "dependency_groups"} +MARKERS_REQUIRING_VERSION = { + "implementation_version", + "platform_release", + "python_full_version", + "python_version", +} + + +class InvalidMarker(ValueError): + """ + An invalid marker was found, users should refer to PEP 508. + """ + + +class UndefinedComparison(ValueError): + """ + An invalid operation was attempted on a value that doesn't support it. + """ + + +class UndefinedEnvironmentName(ValueError): + """ + A name was attempted to be used that does not exist inside of the + environment. + """ + + +class Environment(TypedDict): + implementation_name: str + """The implementation's identifier, e.g. ``'cpython'``.""" + + implementation_version: str + """ + The implementation's version, e.g. ``'3.13.0a2'`` for CPython 3.13.0a2, or + ``'7.3.13'`` for PyPy3.10 v7.3.13. + """ + + os_name: str + """ + The value of :py:data:`os.name`. The name of the operating system dependent module + imported, e.g. ``'posix'``. + """ + + platform_machine: str + """ + Returns the machine type, e.g. ``'i386'``. + + An empty string if the value cannot be determined. + """ + + platform_release: str + """ + The system's release, e.g. ``'2.2.0'`` or ``'NT'``. + + An empty string if the value cannot be determined. + """ + + platform_system: str + """ + The system/OS name, e.g. ``'Linux'``, ``'Windows'`` or ``'Java'``. + + An empty string if the value cannot be determined. + """ + + platform_version: str + """ + The system's release version, e.g. ``'#3 on degas'``. + + An empty string if the value cannot be determined. + """ + + python_full_version: str + """ + The Python version as string ``'major.minor.patchlevel'``. + + Note that unlike the Python :py:data:`sys.version`, this value will always include + the patchlevel (it defaults to 0). + """ + + platform_python_implementation: str + """ + A string identifying the Python implementation, e.g. ``'CPython'``. + """ + + python_version: str + """The Python version as string ``'major.minor'``.""" + + sys_platform: str + """ + This string contains a platform identifier that can be used to append + platform-specific components to :py:data:`sys.path`, for instance. + + For Unix systems, except on Linux and AIX, this is the lowercased OS name as + returned by ``uname -s`` with the first part of the version as returned by + ``uname -r`` appended, e.g. ``'sunos5'`` or ``'freebsd8'``, at the time when Python + was built. + """ + + +def _normalize_extras( + result: MarkerList | MarkerAtom | str, +) -> MarkerList | MarkerAtom | str: + if not isinstance(result, tuple): + return result + + lhs, op, rhs = result + if isinstance(lhs, Variable) and lhs.value == "extra": + normalized_extra = canonicalize_name(rhs.value) + rhs = Value(normalized_extra) + elif isinstance(rhs, Variable) and rhs.value == "extra": + normalized_extra = canonicalize_name(lhs.value) + lhs = Value(normalized_extra) + return lhs, op, rhs + + +def _normalize_extra_values(results: MarkerList) -> MarkerList: + """ + Normalize extra values. + """ + + return [_normalize_extras(r) for r in results] + + +def _format_marker( + marker: list[str] | MarkerAtom | str, first: bool | None = True +) -> str: + assert isinstance(marker, (list, tuple, str)) + + # Sometimes we have a structure like [[...]] which is a single item list + # where the single item is itself it's own list. In that case we want skip + # the rest of this function so that we don't get extraneous () on the + # outside. + if ( + isinstance(marker, list) + and len(marker) == 1 + and isinstance(marker[0], (list, tuple)) + ): + return _format_marker(marker[0]) + + if isinstance(marker, list): + inner = (_format_marker(m, first=False) for m in marker) + if first: + return " ".join(inner) + else: + return "(" + " ".join(inner) + ")" + elif isinstance(marker, tuple): + return " ".join([m.serialize() for m in marker]) + else: + return marker + + +_operators: dict[str, Operator] = { + "in": lambda lhs, rhs: lhs in rhs, + "not in": lambda lhs, rhs: lhs not in rhs, + "<": lambda _lhs, _rhs: False, + "<=": operator.eq, + "==": operator.eq, + "!=": operator.ne, + ">=": operator.eq, + ">": lambda _lhs, _rhs: False, +} + + +def _eval_op(lhs: str, op: Op, rhs: str | AbstractSet[str], *, key: str) -> bool: + op_str = op.serialize() + if key in MARKERS_REQUIRING_VERSION: + try: + spec = Specifier(f"{op_str}{rhs}") + except InvalidSpecifier: + pass + else: + return spec.contains(lhs, prereleases=True) + + oper: Operator | None = _operators.get(op_str) + if oper is None: + raise UndefinedComparison(f"Undefined {op!r} on {lhs!r} and {rhs!r}.") + + return oper(lhs, rhs) + + +def _normalize( + lhs: str, rhs: str | AbstractSet[str], key: str +) -> tuple[str, str | AbstractSet[str]]: + # PEP 685 - Comparison of extra names for optional distribution dependencies + # https://peps.python.org/pep-0685/ + # > When comparing extra names, tools MUST normalize the names being + # > compared using the semantics outlined in PEP 503 for names + if key == "extra": + assert isinstance(rhs, str), "extra value must be a string" + # Both sides are normalized at this point already + return (lhs, rhs) + if key in MARKERS_ALLOWING_SET: + if isinstance(rhs, str): # pragma: no cover + return (canonicalize_name(lhs), canonicalize_name(rhs)) + else: + return (canonicalize_name(lhs), {canonicalize_name(v) for v in rhs}) + + # other environment markers don't have such standards + return lhs, rhs + + +def _evaluate_markers( + markers: MarkerList, environment: dict[str, str | AbstractSet[str]] +) -> bool: + groups: list[list[bool]] = [[]] + + for marker in markers: + if isinstance(marker, list): + groups[-1].append(_evaluate_markers(marker, environment)) + elif isinstance(marker, tuple): + lhs, op, rhs = marker + + if isinstance(lhs, Variable): + environment_key = lhs.value + lhs_value = environment[environment_key] + rhs_value = rhs.value + else: + lhs_value = lhs.value + environment_key = rhs.value + rhs_value = environment[environment_key] + + assert isinstance(lhs_value, str), "lhs must be a string" + lhs_value, rhs_value = _normalize(lhs_value, rhs_value, key=environment_key) + groups[-1].append(_eval_op(lhs_value, op, rhs_value, key=environment_key)) + elif marker == "or": + groups.append([]) + elif marker == "and": + pass + else: # pragma: nocover + raise TypeError(f"Unexpected marker {marker!r}") + + return any(all(item) for item in groups) + + +def format_full_version(info: sys._version_info) -> str: + version = f"{info.major}.{info.minor}.{info.micro}" + kind = info.releaselevel + if kind != "final": + version += kind[0] + str(info.serial) + return version + + +def default_environment() -> Environment: + iver = format_full_version(sys.implementation.version) + implementation_name = sys.implementation.name + return { + "implementation_name": implementation_name, + "implementation_version": iver, + "os_name": os.name, + "platform_machine": platform.machine(), + "platform_release": platform.release(), + "platform_system": platform.system(), + "platform_version": platform.version(), + "python_full_version": platform.python_version(), + "platform_python_implementation": platform.python_implementation(), + "python_version": ".".join(platform.python_version_tuple()[:2]), + "sys_platform": sys.platform, + } + + +class Marker: + def __init__(self, marker: str) -> None: + # Note: We create a Marker object without calling this constructor in + # packaging.requirements.Requirement. If any additional logic is + # added here, make sure to mirror/adapt Requirement. + + # If this fails and throws an error, the repr still expects _markers to + # be defined. + self._markers: MarkerList = [] + + try: + self._markers = _normalize_extra_values(_parse_marker(marker)) + # The attribute `_markers` can be described in terms of a recursive type: + # MarkerList = List[Union[Tuple[Node, ...], str, MarkerList]] + # + # For example, the following expression: + # python_version > "3.6" or (python_version == "3.6" and os_name == "unix") + # + # is parsed into: + # [ + # (, ')>, ), + # 'and', + # [ + # (, , ), + # 'or', + # (, , ) + # ] + # ] + except ParserSyntaxError as e: + raise InvalidMarker(str(e)) from e + + def __str__(self) -> str: + return _format_marker(self._markers) + + def __repr__(self) -> str: + return f"<{self.__class__.__name__}('{self}')>" + + def __hash__(self) -> int: + return hash(str(self)) + + def __eq__(self, other: object) -> bool: + if not isinstance(other, Marker): + return NotImplemented + + return str(self) == str(other) + + def evaluate( + self, + environment: Mapping[str, str | AbstractSet[str]] | None = None, + context: EvaluateContext = "metadata", + ) -> bool: + """Evaluate a marker. + + Return the boolean from evaluating the given marker against the + environment. environment is an optional argument to override all or + part of the determined environment. The *context* parameter specifies what + context the markers are being evaluated for, which influences what markers + are considered valid. Acceptable values are "metadata" (for core metadata; + default), "lock_file", and "requirement" (i.e. all other situations). + + The environment is determined from the current Python process. + """ + current_environment = cast( + "dict[str, str | AbstractSet[str]]", default_environment() + ) + if context == "lock_file": + current_environment.update( + extras=frozenset(), dependency_groups=frozenset() + ) + elif context == "metadata": + current_environment["extra"] = "" + + if environment is not None: + current_environment.update(environment) + if "extra" in current_environment: + # The API used to allow setting extra to None. We need to handle + # this case for backwards compatibility. Also skip running + # normalize name if extra is empty. + extra = cast("str | None", current_environment["extra"]) + current_environment["extra"] = canonicalize_name(extra) if extra else "" + + return _evaluate_markers( + self._markers, _repair_python_full_version(current_environment) + ) + + +def _repair_python_full_version( + env: dict[str, str | AbstractSet[str]], +) -> dict[str, str | AbstractSet[str]]: + """ + Work around platform.python_version() returning something that is not PEP 440 + compliant for non-tagged Python builds. + """ + python_full_version = cast("str", env["python_full_version"]) + if python_full_version.endswith("+"): + env["python_full_version"] = f"{python_full_version}local" + return env diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/metadata.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/metadata.py new file mode 100644 index 0000000000000000000000000000000000000000..253f6b1b7ebd711fdc6bbbab3b56897061bab515 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/metadata.py @@ -0,0 +1,978 @@ +from __future__ import annotations + +import email.feedparser +import email.header +import email.message +import email.parser +import email.policy +import keyword +import pathlib +import sys +import typing +from typing import ( + Any, + Callable, + Generic, + Literal, + TypedDict, + cast, +) + +from . import licenses, requirements, specifiers, utils +from . import version as version_module + +if typing.TYPE_CHECKING: + from .licenses import NormalizedLicenseExpression + +T = typing.TypeVar("T") + + +if sys.version_info >= (3, 11): # pragma: no cover + ExceptionGroup = ExceptionGroup # noqa: F821 +else: # pragma: no cover + + class ExceptionGroup(Exception): + """A minimal implementation of :external:exc:`ExceptionGroup` from Python 3.11. + + If :external:exc:`ExceptionGroup` is already defined by Python itself, + that version is used instead. + """ + + message: str + exceptions: list[Exception] + + def __init__(self, message: str, exceptions: list[Exception]) -> None: + self.message = message + self.exceptions = exceptions + + def __repr__(self) -> str: + return f"{self.__class__.__name__}({self.message!r}, {self.exceptions!r})" + + +class InvalidMetadata(ValueError): + """A metadata field contains invalid data.""" + + field: str + """The name of the field that contains invalid data.""" + + def __init__(self, field: str, message: str) -> None: + self.field = field + super().__init__(message) + + +# The RawMetadata class attempts to make as few assumptions about the underlying +# serialization formats as possible. The idea is that as long as a serialization +# formats offer some very basic primitives in *some* way then we can support +# serializing to and from that format. +class RawMetadata(TypedDict, total=False): + """A dictionary of raw core metadata. + + Each field in core metadata maps to a key of this dictionary (when data is + provided). The key is lower-case and underscores are used instead of dashes + compared to the equivalent core metadata field. Any core metadata field that + can be specified multiple times or can hold multiple values in a single + field have a key with a plural name. See :class:`Metadata` whose attributes + match the keys of this dictionary. + + Core metadata fields that can be specified multiple times are stored as a + list or dict depending on which is appropriate for the field. Any fields + which hold multiple values in a single field are stored as a list. + + """ + + # Metadata 1.0 - PEP 241 + metadata_version: str + name: str + version: str + platforms: list[str] + summary: str + description: str + keywords: list[str] + home_page: str + author: str + author_email: str + license: str + + # Metadata 1.1 - PEP 314 + supported_platforms: list[str] + download_url: str + classifiers: list[str] + requires: list[str] + provides: list[str] + obsoletes: list[str] + + # Metadata 1.2 - PEP 345 + maintainer: str + maintainer_email: str + requires_dist: list[str] + provides_dist: list[str] + obsoletes_dist: list[str] + requires_python: str + requires_external: list[str] + project_urls: dict[str, str] + + # Metadata 2.0 + # PEP 426 attempted to completely revamp the metadata format + # but got stuck without ever being able to build consensus on + # it and ultimately ended up withdrawn. + # + # However, a number of tools had started emitting METADATA with + # `2.0` Metadata-Version, so for historical reasons, this version + # was skipped. + + # Metadata 2.1 - PEP 566 + description_content_type: str + provides_extra: list[str] + + # Metadata 2.2 - PEP 643 + dynamic: list[str] + + # Metadata 2.3 - PEP 685 + # No new fields were added in PEP 685, just some edge case were + # tightened up to provide better interoperability. + + # Metadata 2.4 - PEP 639 + license_expression: str + license_files: list[str] + + # Metadata 2.5 - PEP 794 + import_names: list[str] + import_namespaces: list[str] + + +# 'keywords' is special as it's a string in the core metadata spec, but we +# represent it as a list. +_STRING_FIELDS = { + "author", + "author_email", + "description", + "description_content_type", + "download_url", + "home_page", + "license", + "license_expression", + "maintainer", + "maintainer_email", + "metadata_version", + "name", + "requires_python", + "summary", + "version", +} + +_LIST_FIELDS = { + "classifiers", + "dynamic", + "license_files", + "obsoletes", + "obsoletes_dist", + "platforms", + "provides", + "provides_dist", + "provides_extra", + "requires", + "requires_dist", + "requires_external", + "supported_platforms", + "import_names", + "import_namespaces", +} + +_DICT_FIELDS = { + "project_urls", +} + + +def _parse_keywords(data: str) -> list[str]: + """Split a string of comma-separated keywords into a list of keywords.""" + return [k.strip() for k in data.split(",")] + + +def _parse_project_urls(data: list[str]) -> dict[str, str]: + """Parse a list of label/URL string pairings separated by a comma.""" + urls = {} + for pair in data: + # Our logic is slightly tricky here as we want to try and do + # *something* reasonable with malformed data. + # + # The main thing that we have to worry about, is data that does + # not have a ',' at all to split the label from the Value. There + # isn't a singular right answer here, and we will fail validation + # later on (if the caller is validating) so it doesn't *really* + # matter, but since the missing value has to be an empty str + # and our return value is dict[str, str], if we let the key + # be the missing value, then they'd have multiple '' values that + # overwrite each other in a accumulating dict. + # + # The other potential issue is that it's possible to have the + # same label multiple times in the metadata, with no solid "right" + # answer with what to do in that case. As such, we'll do the only + # thing we can, which is treat the field as unparsable and add it + # to our list of unparsed fields. + # + # TODO: The spec doesn't say anything about if the keys should be + # considered case sensitive or not... logically they should + # be case-preserving and case-insensitive, but doing that + # would open up more cases where we might have duplicate + # entries. + label, _, url = (s.strip() for s in pair.partition(",")) + + if label in urls: + # The label already exists in our set of urls, so this field + # is unparsable, and we can just add the whole thing to our + # unparsable data and stop processing it. + raise KeyError("duplicate labels in project urls") + urls[label] = url + + return urls + + +def _get_payload(msg: email.message.Message, source: bytes | str) -> str: + """Get the body of the message.""" + # If our source is a str, then our caller has managed encodings for us, + # and we don't need to deal with it. + if isinstance(source, str): + payload = msg.get_payload() + assert isinstance(payload, str) + return payload + # If our source is a bytes, then we're managing the encoding and we need + # to deal with it. + else: + bpayload = msg.get_payload(decode=True) + assert isinstance(bpayload, bytes) + try: + return bpayload.decode("utf8", "strict") + except UnicodeDecodeError as exc: + raise ValueError("payload in an invalid encoding") from exc + + +# The various parse_FORMAT functions here are intended to be as lenient as +# possible in their parsing, while still returning a correctly typed +# RawMetadata. +# +# To aid in this, we also generally want to do as little touching of the +# data as possible, except where there are possibly some historic holdovers +# that make valid data awkward to work with. +# +# While this is a lower level, intermediate format than our ``Metadata`` +# class, some light touch ups can make a massive difference in usability. + +# Map METADATA fields to RawMetadata. +_EMAIL_TO_RAW_MAPPING = { + "author": "author", + "author-email": "author_email", + "classifier": "classifiers", + "description": "description", + "description-content-type": "description_content_type", + "download-url": "download_url", + "dynamic": "dynamic", + "home-page": "home_page", + "import-name": "import_names", + "import-namespace": "import_namespaces", + "keywords": "keywords", + "license": "license", + "license-expression": "license_expression", + "license-file": "license_files", + "maintainer": "maintainer", + "maintainer-email": "maintainer_email", + "metadata-version": "metadata_version", + "name": "name", + "obsoletes": "obsoletes", + "obsoletes-dist": "obsoletes_dist", + "platform": "platforms", + "project-url": "project_urls", + "provides": "provides", + "provides-dist": "provides_dist", + "provides-extra": "provides_extra", + "requires": "requires", + "requires-dist": "requires_dist", + "requires-external": "requires_external", + "requires-python": "requires_python", + "summary": "summary", + "supported-platform": "supported_platforms", + "version": "version", +} +_RAW_TO_EMAIL_MAPPING = {raw: email for email, raw in _EMAIL_TO_RAW_MAPPING.items()} + + +# This class is for writing RFC822 messages +class RFC822Policy(email.policy.EmailPolicy): + """ + This is :class:`email.policy.EmailPolicy`, but with a simple ``header_store_parse`` + implementation that handles multi-line values, and some nice defaults. + """ + + utf8 = True + mangle_from_ = False + max_line_length = 0 + + def header_store_parse(self, name: str, value: str) -> tuple[str, str]: + size = len(name) + 2 + value = value.replace("\n", "\n" + " " * size) + return (name, value) + + +# This class is for writing RFC822 messages +class RFC822Message(email.message.EmailMessage): + """ + This is :class:`email.message.EmailMessage` with two small changes: it defaults to + our `RFC822Policy`, and it correctly writes unicode when being called + with `bytes()`. + """ + + def __init__(self) -> None: + super().__init__(policy=RFC822Policy()) + + def as_bytes( + self, unixfrom: bool = False, policy: email.policy.Policy | None = None + ) -> bytes: + """ + Return the bytes representation of the message. + + This handles unicode encoding. + """ + return self.as_string(unixfrom, policy=policy).encode("utf-8") + + +def parse_email(data: bytes | str) -> tuple[RawMetadata, dict[str, list[str]]]: + """Parse a distribution's metadata stored as email headers (e.g. from ``METADATA``). + + This function returns a two-item tuple of dicts. The first dict is of + recognized fields from the core metadata specification. Fields that can be + parsed and translated into Python's built-in types are converted + appropriately. All other fields are left as-is. Fields that are allowed to + appear multiple times are stored as lists. + + The second dict contains all other fields from the metadata. This includes + any unrecognized fields. It also includes any fields which are expected to + be parsed into a built-in type but were not formatted appropriately. Finally, + any fields that are expected to appear only once but are repeated are + included in this dict. + + """ + raw: dict[str, str | list[str] | dict[str, str]] = {} + unparsed: dict[str, list[str]] = {} + + if isinstance(data, str): + parsed = email.parser.Parser(policy=email.policy.compat32).parsestr(data) + else: + parsed = email.parser.BytesParser(policy=email.policy.compat32).parsebytes(data) + + # We have to wrap parsed.keys() in a set, because in the case of multiple + # values for a key (a list), the key will appear multiple times in the + # list of keys, but we're avoiding that by using get_all(). + for name_with_case in frozenset(parsed.keys()): + # Header names in RFC are case insensitive, so we'll normalize to all + # lower case to make comparisons easier. + name = name_with_case.lower() + + # We use get_all() here, even for fields that aren't multiple use, + # because otherwise someone could have e.g. two Name fields, and we + # would just silently ignore it rather than doing something about it. + headers = parsed.get_all(name) or [] + + # The way the email module works when parsing bytes is that it + # unconditionally decodes the bytes as ascii using the surrogateescape + # handler. When you pull that data back out (such as with get_all() ), + # it looks to see if the str has any surrogate escapes, and if it does + # it wraps it in a Header object instead of returning the string. + # + # As such, we'll look for those Header objects, and fix up the encoding. + value = [] + # Flag if we have run into any issues processing the headers, thus + # signalling that the data belongs in 'unparsed'. + valid_encoding = True + for h in headers: + # It's unclear if this can return more types than just a Header or + # a str, so we'll just assert here to make sure. + assert isinstance(h, (email.header.Header, str)) + + # If it's a header object, we need to do our little dance to get + # the real data out of it. In cases where there is invalid data + # we're going to end up with mojibake, but there's no obvious, good + # way around that without reimplementing parts of the Header object + # ourselves. + # + # That should be fine since, if mojibacked happens, this key is + # going into the unparsed dict anyways. + if isinstance(h, email.header.Header): + # The Header object stores it's data as chunks, and each chunk + # can be independently encoded, so we'll need to check each + # of them. + chunks: list[tuple[bytes, str | None]] = [] + for binary, _encoding in email.header.decode_header(h): + try: + binary.decode("utf8", "strict") + except UnicodeDecodeError: + # Enable mojibake. + encoding = "latin1" + valid_encoding = False + else: + encoding = "utf8" + chunks.append((binary, encoding)) + + # Turn our chunks back into a Header object, then let that + # Header object do the right thing to turn them into a + # string for us. + value.append(str(email.header.make_header(chunks))) + # This is already a string, so just add it. + else: + value.append(h) + + # We've processed all of our values to get them into a list of str, + # but we may have mojibake data, in which case this is an unparsed + # field. + if not valid_encoding: + unparsed[name] = value + continue + + raw_name = _EMAIL_TO_RAW_MAPPING.get(name) + if raw_name is None: + # This is a bit of a weird situation, we've encountered a key that + # we don't know what it means, so we don't know whether it's meant + # to be a list or not. + # + # Since we can't really tell one way or another, we'll just leave it + # as a list, even though it may be a single item list, because that's + # what makes the most sense for email headers. + unparsed[name] = value + continue + + # If this is one of our string fields, then we'll check to see if our + # value is a list of a single item. If it is then we'll assume that + # it was emitted as a single string, and unwrap the str from inside + # the list. + # + # If it's any other kind of data, then we haven't the faintest clue + # what we should parse it as, and we have to just add it to our list + # of unparsed stuff. + if raw_name in _STRING_FIELDS and len(value) == 1: + raw[raw_name] = value[0] + # If this is import_names, we need to special case the empty field + # case, which converts to an empty list instead of None. We can't let + # the empty case slip through, as it will fail validation. + elif raw_name == "import_names" and value == [""]: + raw[raw_name] = [] + # If this is one of our list of string fields, then we can just assign + # the value, since email *only* has strings, and our get_all() call + # above ensures that this is a list. + elif raw_name in _LIST_FIELDS: + raw[raw_name] = value + # Special Case: Keywords + # The keywords field is implemented in the metadata spec as a str, + # but it conceptually is a list of strings, and is serialized using + # ", ".join(keywords), so we'll do some light data massaging to turn + # this into what it logically is. + elif raw_name == "keywords" and len(value) == 1: + raw[raw_name] = _parse_keywords(value[0]) + # Special Case: Project-URL + # The project urls is implemented in the metadata spec as a list of + # specially-formatted strings that represent a key and a value, which + # is fundamentally a mapping, however the email format doesn't support + # mappings in a sane way, so it was crammed into a list of strings + # instead. + # + # We will do a little light data massaging to turn this into a map as + # it logically should be. + elif raw_name == "project_urls": + try: + raw[raw_name] = _parse_project_urls(value) + except KeyError: + unparsed[name] = value + # Nothing that we've done has managed to parse this, so it'll just + # throw it in our unparsable data and move on. + else: + unparsed[name] = value + + # We need to support getting the Description from the message payload in + # addition to getting it from the the headers. This does mean, though, there + # is the possibility of it being set both ways, in which case we put both + # in 'unparsed' since we don't know which is right. + try: + payload = _get_payload(parsed, data) + except ValueError: + unparsed.setdefault("description", []).append( + parsed.get_payload(decode=isinstance(data, bytes)) # type: ignore[call-overload] + ) + else: + if payload: + # Check to see if we've already got a description, if so then both + # it, and this body move to unparsable. + if "description" in raw: + description_header = cast("str", raw.pop("description")) + unparsed.setdefault("description", []).extend( + [description_header, payload] + ) + elif "description" in unparsed: + unparsed["description"].append(payload) + else: + raw["description"] = payload + + # We need to cast our `raw` to a metadata, because a TypedDict only support + # literal key names, but we're computing our key names on purpose, but the + # way this function is implemented, our `TypedDict` can only have valid key + # names. + return cast("RawMetadata", raw), unparsed + + +_NOT_FOUND = object() + + +# Keep the two values in sync. +_VALID_METADATA_VERSIONS = ["1.0", "1.1", "1.2", "2.1", "2.2", "2.3", "2.4", "2.5"] +_MetadataVersion = Literal["1.0", "1.1", "1.2", "2.1", "2.2", "2.3", "2.4", "2.5"] + +_REQUIRED_ATTRS = frozenset(["metadata_version", "name", "version"]) + + +class _Validator(Generic[T]): + """Validate a metadata field. + + All _process_*() methods correspond to a core metadata field. The method is + called with the field's raw value. If the raw value is valid it is returned + in its "enriched" form (e.g. ``version.Version`` for the ``Version`` field). + If the raw value is invalid, :exc:`InvalidMetadata` is raised (with a cause + as appropriate). + """ + + name: str + raw_name: str + added: _MetadataVersion + + def __init__( + self, + *, + added: _MetadataVersion = "1.0", + ) -> None: + self.added = added + + def __set_name__(self, _owner: Metadata, name: str) -> None: + self.name = name + self.raw_name = _RAW_TO_EMAIL_MAPPING[name] + + def __get__(self, instance: Metadata, _owner: type[Metadata]) -> T: + # With Python 3.8, the caching can be replaced with functools.cached_property(). + # No need to check the cache as attribute lookup will resolve into the + # instance's __dict__ before __get__ is called. + cache = instance.__dict__ + value = instance._raw.get(self.name) + + # To make the _process_* methods easier, we'll check if the value is None + # and if this field is NOT a required attribute, and if both of those + # things are true, we'll skip the the converter. This will mean that the + # converters never have to deal with the None union. + if self.name in _REQUIRED_ATTRS or value is not None: + try: + converter: Callable[[Any], T] = getattr(self, f"_process_{self.name}") + except AttributeError: + pass + else: + value = converter(value) + + cache[self.name] = value + try: + del instance._raw[self.name] # type: ignore[misc] + except KeyError: + pass + + return cast("T", value) + + def _invalid_metadata( + self, msg: str, cause: Exception | None = None + ) -> InvalidMetadata: + exc = InvalidMetadata( + self.raw_name, msg.format_map({"field": repr(self.raw_name)}) + ) + exc.__cause__ = cause + return exc + + def _process_metadata_version(self, value: str) -> _MetadataVersion: + # Implicitly makes Metadata-Version required. + if value not in _VALID_METADATA_VERSIONS: + raise self._invalid_metadata(f"{value!r} is not a valid metadata version") + return cast("_MetadataVersion", value) + + def _process_name(self, value: str) -> str: + if not value: + raise self._invalid_metadata("{field} is a required field") + # Validate the name as a side-effect. + try: + utils.canonicalize_name(value, validate=True) + except utils.InvalidName as exc: + raise self._invalid_metadata( + f"{value!r} is invalid for {{field}}", cause=exc + ) from exc + else: + return value + + def _process_version(self, value: str) -> version_module.Version: + if not value: + raise self._invalid_metadata("{field} is a required field") + try: + return version_module.parse(value) + except version_module.InvalidVersion as exc: + raise self._invalid_metadata( + f"{value!r} is invalid for {{field}}", cause=exc + ) from exc + + def _process_summary(self, value: str) -> str: + """Check the field contains no newlines.""" + if "\n" in value: + raise self._invalid_metadata("{field} must be a single line") + return value + + def _process_description_content_type(self, value: str) -> str: + content_types = {"text/plain", "text/x-rst", "text/markdown"} + message = email.message.EmailMessage() + message["content-type"] = value + + content_type, parameters = ( + # Defaults to `text/plain` if parsing failed. + message.get_content_type().lower(), + message["content-type"].params, + ) + # Check if content-type is valid or defaulted to `text/plain` and thus was + # not parseable. + if content_type not in content_types or content_type not in value.lower(): + raise self._invalid_metadata( + f"{{field}} must be one of {list(content_types)}, not {value!r}" + ) + + charset = parameters.get("charset", "UTF-8") + if charset != "UTF-8": + raise self._invalid_metadata( + f"{{field}} can only specify the UTF-8 charset, not {list(charset)}" + ) + + markdown_variants = {"GFM", "CommonMark"} + variant = parameters.get("variant", "GFM") # Use an acceptable default. + if content_type == "text/markdown" and variant not in markdown_variants: + raise self._invalid_metadata( + f"valid Markdown variants for {{field}} are {list(markdown_variants)}, " + f"not {variant!r}", + ) + return value + + def _process_dynamic(self, value: list[str]) -> list[str]: + for dynamic_field in map(str.lower, value): + if dynamic_field in {"name", "version", "metadata-version"}: + raise self._invalid_metadata( + f"{dynamic_field!r} is not allowed as a dynamic field" + ) + elif dynamic_field not in _EMAIL_TO_RAW_MAPPING: + raise self._invalid_metadata( + f"{dynamic_field!r} is not a valid dynamic field" + ) + return list(map(str.lower, value)) + + def _process_provides_extra( + self, + value: list[str], + ) -> list[utils.NormalizedName]: + normalized_names = [] + try: + for name in value: + normalized_names.append(utils.canonicalize_name(name, validate=True)) + except utils.InvalidName as exc: + raise self._invalid_metadata( + f"{name!r} is invalid for {{field}}", cause=exc + ) from exc + else: + return normalized_names + + def _process_requires_python(self, value: str) -> specifiers.SpecifierSet: + try: + return specifiers.SpecifierSet(value) + except specifiers.InvalidSpecifier as exc: + raise self._invalid_metadata( + f"{value!r} is invalid for {{field}}", cause=exc + ) from exc + + def _process_requires_dist( + self, + value: list[str], + ) -> list[requirements.Requirement]: + reqs = [] + try: + for req in value: + reqs.append(requirements.Requirement(req)) + except requirements.InvalidRequirement as exc: + raise self._invalid_metadata( + f"{req!r} is invalid for {{field}}", cause=exc + ) from exc + else: + return reqs + + def _process_license_expression(self, value: str) -> NormalizedLicenseExpression: + try: + return licenses.canonicalize_license_expression(value) + except ValueError as exc: + raise self._invalid_metadata( + f"{value!r} is invalid for {{field}}", cause=exc + ) from exc + + def _process_license_files(self, value: list[str]) -> list[str]: + paths = [] + for path in value: + if ".." in path: + raise self._invalid_metadata( + f"{path!r} is invalid for {{field}}, " + "parent directory indicators are not allowed" + ) + if "*" in path: + raise self._invalid_metadata( + f"{path!r} is invalid for {{field}}, paths must be resolved" + ) + if ( + pathlib.PurePosixPath(path).is_absolute() + or pathlib.PureWindowsPath(path).is_absolute() + ): + raise self._invalid_metadata( + f"{path!r} is invalid for {{field}}, paths must be relative" + ) + if pathlib.PureWindowsPath(path).as_posix() != path: + raise self._invalid_metadata( + f"{path!r} is invalid for {{field}}, paths must use '/' delimiter" + ) + paths.append(path) + return paths + + def _process_import_names(self, value: list[str]) -> list[str]: + for import_name in value: + name, semicolon, private = import_name.partition(";") + name = name.rstrip() + for identifier in name.split("."): + if not identifier.isidentifier(): + raise self._invalid_metadata( + f"{name!r} is invalid for {{field}}; " + f"{identifier!r} is not a valid identifier" + ) + elif keyword.iskeyword(identifier): + raise self._invalid_metadata( + f"{name!r} is invalid for {{field}}; " + f"{identifier!r} is a keyword" + ) + if semicolon and private.lstrip() != "private": + raise self._invalid_metadata( + f"{import_name!r} is invalid for {{field}}; " + "the only valid option is 'private'" + ) + return value + + _process_import_namespaces = _process_import_names + + +class Metadata: + """Representation of distribution metadata. + + Compared to :class:`RawMetadata`, this class provides objects representing + metadata fields instead of only using built-in types. Any invalid metadata + will cause :exc:`InvalidMetadata` to be raised (with a + :py:attr:`~BaseException.__cause__` attribute as appropriate). + """ + + _raw: RawMetadata + + @classmethod + def from_raw(cls, data: RawMetadata, *, validate: bool = True) -> Metadata: + """Create an instance from :class:`RawMetadata`. + + If *validate* is true, all metadata will be validated. All exceptions + related to validation will be gathered and raised as an :class:`ExceptionGroup`. + """ + ins = cls() + ins._raw = data.copy() # Mutations occur due to caching enriched values. + + if validate: + exceptions: list[Exception] = [] + try: + metadata_version = ins.metadata_version + metadata_age = _VALID_METADATA_VERSIONS.index(metadata_version) + except InvalidMetadata as metadata_version_exc: + exceptions.append(metadata_version_exc) + metadata_version = None + + # Make sure to check for the fields that are present, the required + # fields (so their absence can be reported). + fields_to_check = frozenset(ins._raw) | _REQUIRED_ATTRS + # Remove fields that have already been checked. + fields_to_check -= {"metadata_version"} + + for key in fields_to_check: + try: + if metadata_version: + # Can't use getattr() as that triggers descriptor protocol which + # will fail due to no value for the instance argument. + try: + field_metadata_version = cls.__dict__[key].added + except KeyError: + exc = InvalidMetadata(key, f"unrecognized field: {key!r}") + exceptions.append(exc) + continue + field_age = _VALID_METADATA_VERSIONS.index( + field_metadata_version + ) + if field_age > metadata_age: + field = _RAW_TO_EMAIL_MAPPING[key] + exc = InvalidMetadata( + field, + f"{field} introduced in metadata version " + f"{field_metadata_version}, not {metadata_version}", + ) + exceptions.append(exc) + continue + getattr(ins, key) + except InvalidMetadata as exc: + exceptions.append(exc) + + if exceptions: + raise ExceptionGroup("invalid metadata", exceptions) + + return ins + + @classmethod + def from_email(cls, data: bytes | str, *, validate: bool = True) -> Metadata: + """Parse metadata from email headers. + + If *validate* is true, the metadata will be validated. All exceptions + related to validation will be gathered and raised as an :class:`ExceptionGroup`. + """ + raw, unparsed = parse_email(data) + + if validate: + exceptions: list[Exception] = [] + for unparsed_key in unparsed: + if unparsed_key in _EMAIL_TO_RAW_MAPPING: + message = f"{unparsed_key!r} has invalid data" + else: + message = f"unrecognized field: {unparsed_key!r}" + exceptions.append(InvalidMetadata(unparsed_key, message)) + + if exceptions: + raise ExceptionGroup("unparsed", exceptions) + + try: + return cls.from_raw(raw, validate=validate) + except ExceptionGroup as exc_group: + raise ExceptionGroup( + "invalid or unparsed metadata", exc_group.exceptions + ) from None + + metadata_version: _Validator[_MetadataVersion] = _Validator() + """:external:ref:`core-metadata-metadata-version` + (required; validated to be a valid metadata version)""" + # `name` is not normalized/typed to NormalizedName so as to provide access to + # the original/raw name. + name: _Validator[str] = _Validator() + """:external:ref:`core-metadata-name` + (required; validated using :func:`~packaging.utils.canonicalize_name` and its + *validate* parameter)""" + version: _Validator[version_module.Version] = _Validator() + """:external:ref:`core-metadata-version` (required)""" + dynamic: _Validator[list[str] | None] = _Validator( + added="2.2", + ) + """:external:ref:`core-metadata-dynamic` + (validated against core metadata field names and lowercased)""" + platforms: _Validator[list[str] | None] = _Validator() + """:external:ref:`core-metadata-platform`""" + supported_platforms: _Validator[list[str] | None] = _Validator(added="1.1") + """:external:ref:`core-metadata-supported-platform`""" + summary: _Validator[str | None] = _Validator() + """:external:ref:`core-metadata-summary` (validated to contain no newlines)""" + description: _Validator[str | None] = _Validator() # TODO 2.1: can be in body + """:external:ref:`core-metadata-description`""" + description_content_type: _Validator[str | None] = _Validator(added="2.1") + """:external:ref:`core-metadata-description-content-type` (validated)""" + keywords: _Validator[list[str] | None] = _Validator() + """:external:ref:`core-metadata-keywords`""" + home_page: _Validator[str | None] = _Validator() + """:external:ref:`core-metadata-home-page`""" + download_url: _Validator[str | None] = _Validator(added="1.1") + """:external:ref:`core-metadata-download-url`""" + author: _Validator[str | None] = _Validator() + """:external:ref:`core-metadata-author`""" + author_email: _Validator[str | None] = _Validator() + """:external:ref:`core-metadata-author-email`""" + maintainer: _Validator[str | None] = _Validator(added="1.2") + """:external:ref:`core-metadata-maintainer`""" + maintainer_email: _Validator[str | None] = _Validator(added="1.2") + """:external:ref:`core-metadata-maintainer-email`""" + license: _Validator[str | None] = _Validator() + """:external:ref:`core-metadata-license`""" + license_expression: _Validator[NormalizedLicenseExpression | None] = _Validator( + added="2.4" + ) + """:external:ref:`core-metadata-license-expression`""" + license_files: _Validator[list[str] | None] = _Validator(added="2.4") + """:external:ref:`core-metadata-license-file`""" + classifiers: _Validator[list[str] | None] = _Validator(added="1.1") + """:external:ref:`core-metadata-classifier`""" + requires_dist: _Validator[list[requirements.Requirement] | None] = _Validator( + added="1.2" + ) + """:external:ref:`core-metadata-requires-dist`""" + requires_python: _Validator[specifiers.SpecifierSet | None] = _Validator( + added="1.2" + ) + """:external:ref:`core-metadata-requires-python`""" + # Because `Requires-External` allows for non-PEP 440 version specifiers, we + # don't do any processing on the values. + requires_external: _Validator[list[str] | None] = _Validator(added="1.2") + """:external:ref:`core-metadata-requires-external`""" + project_urls: _Validator[dict[str, str] | None] = _Validator(added="1.2") + """:external:ref:`core-metadata-project-url`""" + # PEP 685 lets us raise an error if an extra doesn't pass `Name` validation + # regardless of metadata version. + provides_extra: _Validator[list[utils.NormalizedName] | None] = _Validator( + added="2.1", + ) + """:external:ref:`core-metadata-provides-extra`""" + provides_dist: _Validator[list[str] | None] = _Validator(added="1.2") + """:external:ref:`core-metadata-provides-dist`""" + obsoletes_dist: _Validator[list[str] | None] = _Validator(added="1.2") + """:external:ref:`core-metadata-obsoletes-dist`""" + import_names: _Validator[list[str] | None] = _Validator(added="2.5") + """:external:ref:`core-metadata-import-name`""" + import_namespaces: _Validator[list[str] | None] = _Validator(added="2.5") + """:external:ref:`core-metadata-import-namespace`""" + requires: _Validator[list[str] | None] = _Validator(added="1.1") + """``Requires`` (deprecated)""" + provides: _Validator[list[str] | None] = _Validator(added="1.1") + """``Provides`` (deprecated)""" + obsoletes: _Validator[list[str] | None] = _Validator(added="1.1") + """``Obsoletes`` (deprecated)""" + + def as_rfc822(self) -> RFC822Message: + """ + Return an RFC822 message with the metadata. + """ + message = RFC822Message() + self._write_metadata(message) + return message + + def _write_metadata(self, message: RFC822Message) -> None: + """ + Return an RFC822 message with the metadata. + """ + for name, validator in self.__class__.__dict__.items(): + if isinstance(validator, _Validator) and name != "description": + value = getattr(self, name) + email_name = _RAW_TO_EMAIL_MAPPING[name] + if value is not None: + if email_name == "project-url": + for label, url in value.items(): + message[email_name] = f"{label}, {url}" + elif email_name == "keywords": + message[email_name] = ",".join(value) + elif email_name == "import-name" and value == []: + message[email_name] = "" + elif isinstance(value, list): + for item in value: + message[email_name] = str(item) + else: + message[email_name] = str(value) + + # The description is a special case because it is in the body of the message. + if self.description is not None: + message.set_payload(self.description) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/py.typed b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/py.typed new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/pylock.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/pylock.py new file mode 100644 index 0000000000000000000000000000000000000000..a564f15246ad65038029f8fefb48621fa64a3abd --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/pylock.py @@ -0,0 +1,635 @@ +from __future__ import annotations + +import dataclasses +import logging +import re +from collections.abc import Mapping, Sequence +from dataclasses import dataclass +from datetime import datetime +from typing import ( + TYPE_CHECKING, + Any, + Callable, + Protocol, + TypeVar, +) + +from .markers import Marker +from .specifiers import SpecifierSet +from .utils import NormalizedName, is_normalized_name +from .version import Version + +if TYPE_CHECKING: # pragma: no cover + from pathlib import Path + + from typing_extensions import Self + +_logger = logging.getLogger(__name__) + +__all__ = [ + "Package", + "PackageArchive", + "PackageDirectory", + "PackageSdist", + "PackageVcs", + "PackageWheel", + "Pylock", + "PylockUnsupportedVersionError", + "PylockValidationError", + "is_valid_pylock_path", +] + +_T = TypeVar("_T") +_T2 = TypeVar("_T2") + + +class _FromMappingProtocol(Protocol): # pragma: no cover + @classmethod + def _from_dict(cls, d: Mapping[str, Any]) -> Self: ... + + +_FromMappingProtocolT = TypeVar("_FromMappingProtocolT", bound=_FromMappingProtocol) + + +_PYLOCK_FILE_NAME_RE = re.compile(r"^pylock\.([^.]+)\.toml$") + + +def is_valid_pylock_path(path: Path) -> bool: + """Check if the given path is a valid pylock file path.""" + return path.name == "pylock.toml" or bool(_PYLOCK_FILE_NAME_RE.match(path.name)) + + +def _toml_key(key: str) -> str: + return key.replace("_", "-") + + +def _toml_value(key: str, value: Any) -> Any: # noqa: ANN401 + if isinstance(value, (Version, Marker, SpecifierSet)): + return str(value) + if isinstance(value, Sequence) and key == "environments": + return [str(v) for v in value] + return value + + +def _toml_dict_factory(data: list[tuple[str, Any]]) -> dict[str, Any]: + return { + _toml_key(key): _toml_value(key, value) + for key, value in data + if value is not None + } + + +def _get(d: Mapping[str, Any], expected_type: type[_T], key: str) -> _T | None: + """Get a value from the dictionary and verify it's the expected type.""" + if (value := d.get(key)) is None: + return None + if not isinstance(value, expected_type): + raise PylockValidationError( + f"Unexpected type {type(value).__name__} " + f"(expected {expected_type.__name__})", + context=key, + ) + return value + + +def _get_required(d: Mapping[str, Any], expected_type: type[_T], key: str) -> _T: + """Get a required value from the dictionary and verify it's the expected type.""" + if (value := _get(d, expected_type, key)) is None: + raise _PylockRequiredKeyError(key) + return value + + +def _get_sequence( + d: Mapping[str, Any], expected_item_type: type[_T], key: str +) -> Sequence[_T] | None: + """Get a list value from the dictionary and verify it's the expected items type.""" + if (value := _get(d, Sequence, key)) is None: # type: ignore[type-abstract] + return None + if isinstance(value, (str, bytes)): + # special case: str and bytes are Sequences, but we want to reject it + raise PylockValidationError( + f"Unexpected type {type(value).__name__} (expected Sequence)", + context=key, + ) + for i, item in enumerate(value): + if not isinstance(item, expected_item_type): + raise PylockValidationError( + f"Unexpected type {type(item).__name__} " + f"(expected {expected_item_type.__name__})", + context=f"{key}[{i}]", + ) + return value + + +def _get_as( + d: Mapping[str, Any], + expected_type: type[_T], + target_type: Callable[[_T], _T2], + key: str, +) -> _T2 | None: + """Get a value from the dictionary, verify it's the expected type, + and convert to the target type. + + This assumes the target_type constructor accepts the value. + """ + if (value := _get(d, expected_type, key)) is None: + return None + try: + return target_type(value) + except Exception as e: + raise PylockValidationError(e, context=key) from e + + +def _get_required_as( + d: Mapping[str, Any], + expected_type: type[_T], + target_type: Callable[[_T], _T2], + key: str, +) -> _T2: + """Get a required value from the dict, verify it's the expected type, + and convert to the target type.""" + if (value := _get_as(d, expected_type, target_type, key)) is None: + raise _PylockRequiredKeyError(key) + return value + + +def _get_sequence_as( + d: Mapping[str, Any], + expected_item_type: type[_T], + target_item_type: Callable[[_T], _T2], + key: str, +) -> list[_T2] | None: + """Get list value from dictionary and verify expected items type.""" + if (value := _get_sequence(d, expected_item_type, key)) is None: + return None + result = [] + try: + for item in value: + typed_item = target_item_type(item) + result.append(typed_item) + except Exception as e: + raise PylockValidationError(e, context=f"{key}[{len(result)}]") from e + return result + + +def _get_object( + d: Mapping[str, Any], target_type: type[_FromMappingProtocolT], key: str +) -> _FromMappingProtocolT | None: + """Get a dictionary value from the dictionary and convert it to a dataclass.""" + if (value := _get(d, Mapping, key)) is None: # type: ignore[type-abstract] + return None + try: + return target_type._from_dict(value) + except Exception as e: + raise PylockValidationError(e, context=key) from e + + +def _get_sequence_of_objects( + d: Mapping[str, Any], target_item_type: type[_FromMappingProtocolT], key: str +) -> list[_FromMappingProtocolT] | None: + """Get a list value from the dictionary and convert its items to a dataclass.""" + if (value := _get_sequence(d, Mapping, key)) is None: # type: ignore[type-abstract] + return None + result: list[_FromMappingProtocolT] = [] + try: + for item in value: + typed_item = target_item_type._from_dict(item) + result.append(typed_item) + except Exception as e: + raise PylockValidationError(e, context=f"{key}[{len(result)}]") from e + return result + + +def _get_required_sequence_of_objects( + d: Mapping[str, Any], target_item_type: type[_FromMappingProtocolT], key: str +) -> Sequence[_FromMappingProtocolT]: + """Get a required list value from the dictionary and convert its items to a + dataclass.""" + if (result := _get_sequence_of_objects(d, target_item_type, key)) is None: + raise _PylockRequiredKeyError(key) + return result + + +def _validate_normalized_name(name: str) -> NormalizedName: + """Validate that a string is a NormalizedName.""" + if not is_normalized_name(name): + raise PylockValidationError(f"Name {name!r} is not normalized") + return NormalizedName(name) + + +def _validate_path_url(path: str | None, url: str | None) -> None: + if not path and not url: + raise PylockValidationError("path or url must be provided") + + +def _validate_hashes(hashes: Mapping[str, Any]) -> Mapping[str, Any]: + if not hashes: + raise PylockValidationError("At least one hash must be provided") + if not all(isinstance(hash_val, str) for hash_val in hashes.values()): + raise PylockValidationError("Hash values must be strings") + return hashes + + +class PylockValidationError(Exception): + """Raised when when input data is not spec-compliant.""" + + context: str | None = None + message: str + + def __init__( + self, + cause: str | Exception, + *, + context: str | None = None, + ) -> None: + if isinstance(cause, PylockValidationError): + if cause.context: + self.context = ( + f"{context}.{cause.context}" if context else cause.context + ) + else: + self.context = context + self.message = cause.message + else: + self.context = context + self.message = str(cause) + + def __str__(self) -> str: + if self.context: + return f"{self.message} in {self.context!r}" + return self.message + + +class _PylockRequiredKeyError(PylockValidationError): + def __init__(self, key: str) -> None: + super().__init__("Missing required value", context=key) + + +class PylockUnsupportedVersionError(PylockValidationError): + """Raised when encountering an unsupported `lock_version`.""" + + +@dataclass(frozen=True, init=False) +class PackageVcs: + type: str + url: str | None = None + path: str | None = None + requested_revision: str | None = None + commit_id: str # type: ignore[misc] + subdirectory: str | None = None + + def __init__( + self, + *, + type: str, + url: str | None = None, + path: str | None = None, + requested_revision: str | None = None, + commit_id: str, + subdirectory: str | None = None, + ) -> None: + # In Python 3.10+ make dataclass kw_only=True and remove __init__ + object.__setattr__(self, "type", type) + object.__setattr__(self, "url", url) + object.__setattr__(self, "path", path) + object.__setattr__(self, "requested_revision", requested_revision) + object.__setattr__(self, "commit_id", commit_id) + object.__setattr__(self, "subdirectory", subdirectory) + + @classmethod + def _from_dict(cls, d: Mapping[str, Any]) -> Self: + package_vcs = cls( + type=_get_required(d, str, "type"), + url=_get(d, str, "url"), + path=_get(d, str, "path"), + requested_revision=_get(d, str, "requested-revision"), + commit_id=_get_required(d, str, "commit-id"), + subdirectory=_get(d, str, "subdirectory"), + ) + _validate_path_url(package_vcs.path, package_vcs.url) + return package_vcs + + +@dataclass(frozen=True, init=False) +class PackageDirectory: + path: str + editable: bool | None = None + subdirectory: str | None = None + + def __init__( + self, + *, + path: str, + editable: bool | None = None, + subdirectory: str | None = None, + ) -> None: + # In Python 3.10+ make dataclass kw_only=True and remove __init__ + object.__setattr__(self, "path", path) + object.__setattr__(self, "editable", editable) + object.__setattr__(self, "subdirectory", subdirectory) + + @classmethod + def _from_dict(cls, d: Mapping[str, Any]) -> Self: + return cls( + path=_get_required(d, str, "path"), + editable=_get(d, bool, "editable"), + subdirectory=_get(d, str, "subdirectory"), + ) + + +@dataclass(frozen=True, init=False) +class PackageArchive: + url: str | None = None + path: str | None = None + size: int | None = None + upload_time: datetime | None = None + hashes: Mapping[str, str] # type: ignore[misc] + subdirectory: str | None = None + + def __init__( + self, + *, + url: str | None = None, + path: str | None = None, + size: int | None = None, + upload_time: datetime | None = None, + hashes: Mapping[str, str], + subdirectory: str | None = None, + ) -> None: + # In Python 3.10+ make dataclass kw_only=True and remove __init__ + object.__setattr__(self, "url", url) + object.__setattr__(self, "path", path) + object.__setattr__(self, "size", size) + object.__setattr__(self, "upload_time", upload_time) + object.__setattr__(self, "hashes", hashes) + object.__setattr__(self, "subdirectory", subdirectory) + + @classmethod + def _from_dict(cls, d: Mapping[str, Any]) -> Self: + package_archive = cls( + url=_get(d, str, "url"), + path=_get(d, str, "path"), + size=_get(d, int, "size"), + upload_time=_get(d, datetime, "upload-time"), + hashes=_get_required_as(d, Mapping, _validate_hashes, "hashes"), # type: ignore[type-abstract] + subdirectory=_get(d, str, "subdirectory"), + ) + _validate_path_url(package_archive.path, package_archive.url) + return package_archive + + +@dataclass(frozen=True, init=False) +class PackageSdist: + name: str | None = None + upload_time: datetime | None = None + url: str | None = None + path: str | None = None + size: int | None = None + hashes: Mapping[str, str] # type: ignore[misc] + + def __init__( + self, + *, + name: str | None = None, + upload_time: datetime | None = None, + url: str | None = None, + path: str | None = None, + size: int | None = None, + hashes: Mapping[str, str], + ) -> None: + # In Python 3.10+ make dataclass kw_only=True and remove __init__ + object.__setattr__(self, "name", name) + object.__setattr__(self, "upload_time", upload_time) + object.__setattr__(self, "url", url) + object.__setattr__(self, "path", path) + object.__setattr__(self, "size", size) + object.__setattr__(self, "hashes", hashes) + + @classmethod + def _from_dict(cls, d: Mapping[str, Any]) -> Self: + package_sdist = cls( + name=_get(d, str, "name"), + upload_time=_get(d, datetime, "upload-time"), + url=_get(d, str, "url"), + path=_get(d, str, "path"), + size=_get(d, int, "size"), + hashes=_get_required_as(d, Mapping, _validate_hashes, "hashes"), # type: ignore[type-abstract] + ) + _validate_path_url(package_sdist.path, package_sdist.url) + return package_sdist + + +@dataclass(frozen=True, init=False) +class PackageWheel: + name: str | None = None + upload_time: datetime | None = None + url: str | None = None + path: str | None = None + size: int | None = None + hashes: Mapping[str, str] # type: ignore[misc] + + def __init__( + self, + *, + name: str | None = None, + upload_time: datetime | None = None, + url: str | None = None, + path: str | None = None, + size: int | None = None, + hashes: Mapping[str, str], + ) -> None: + # In Python 3.10+ make dataclass kw_only=True and remove __init__ + object.__setattr__(self, "name", name) + object.__setattr__(self, "upload_time", upload_time) + object.__setattr__(self, "url", url) + object.__setattr__(self, "path", path) + object.__setattr__(self, "size", size) + object.__setattr__(self, "hashes", hashes) + + @classmethod + def _from_dict(cls, d: Mapping[str, Any]) -> Self: + package_wheel = cls( + name=_get(d, str, "name"), + upload_time=_get(d, datetime, "upload-time"), + url=_get(d, str, "url"), + path=_get(d, str, "path"), + size=_get(d, int, "size"), + hashes=_get_required_as(d, Mapping, _validate_hashes, "hashes"), # type: ignore[type-abstract] + ) + _validate_path_url(package_wheel.path, package_wheel.url) + return package_wheel + + +@dataclass(frozen=True, init=False) +class Package: + name: NormalizedName + version: Version | None = None + marker: Marker | None = None + requires_python: SpecifierSet | None = None + dependencies: Sequence[Mapping[str, Any]] | None = None + vcs: PackageVcs | None = None + directory: PackageDirectory | None = None + archive: PackageArchive | None = None + index: str | None = None + sdist: PackageSdist | None = None + wheels: Sequence[PackageWheel] | None = None + attestation_identities: Sequence[Mapping[str, Any]] | None = None + tool: Mapping[str, Any] | None = None + + def __init__( + self, + *, + name: NormalizedName, + version: Version | None = None, + marker: Marker | None = None, + requires_python: SpecifierSet | None = None, + dependencies: Sequence[Mapping[str, Any]] | None = None, + vcs: PackageVcs | None = None, + directory: PackageDirectory | None = None, + archive: PackageArchive | None = None, + index: str | None = None, + sdist: PackageSdist | None = None, + wheels: Sequence[PackageWheel] | None = None, + attestation_identities: Sequence[Mapping[str, Any]] | None = None, + tool: Mapping[str, Any] | None = None, + ) -> None: + # In Python 3.10+ make dataclass kw_only=True and remove __init__ + object.__setattr__(self, "name", name) + object.__setattr__(self, "version", version) + object.__setattr__(self, "marker", marker) + object.__setattr__(self, "requires_python", requires_python) + object.__setattr__(self, "dependencies", dependencies) + object.__setattr__(self, "vcs", vcs) + object.__setattr__(self, "directory", directory) + object.__setattr__(self, "archive", archive) + object.__setattr__(self, "index", index) + object.__setattr__(self, "sdist", sdist) + object.__setattr__(self, "wheels", wheels) + object.__setattr__(self, "attestation_identities", attestation_identities) + object.__setattr__(self, "tool", tool) + + @classmethod + def _from_dict(cls, d: Mapping[str, Any]) -> Self: + package = cls( + name=_get_required_as(d, str, _validate_normalized_name, "name"), + version=_get_as(d, str, Version, "version"), + requires_python=_get_as(d, str, SpecifierSet, "requires-python"), + dependencies=_get_sequence(d, Mapping, "dependencies"), # type: ignore[type-abstract] + marker=_get_as(d, str, Marker, "marker"), + vcs=_get_object(d, PackageVcs, "vcs"), + directory=_get_object(d, PackageDirectory, "directory"), + archive=_get_object(d, PackageArchive, "archive"), + index=_get(d, str, "index"), + sdist=_get_object(d, PackageSdist, "sdist"), + wheels=_get_sequence_of_objects(d, PackageWheel, "wheels"), + attestation_identities=_get_sequence(d, Mapping, "attestation-identities"), # type: ignore[type-abstract] + tool=_get(d, Mapping, "tool"), # type: ignore[type-abstract] + ) + distributions = bool(package.sdist) + len(package.wheels or []) + direct_urls = ( + bool(package.vcs) + bool(package.directory) + bool(package.archive) + ) + if distributions > 0 and direct_urls > 0: + raise PylockValidationError( + "None of vcs, directory, archive must be set if sdist or wheels are set" + ) + if distributions == 0 and direct_urls != 1: + raise PylockValidationError( + "Exactly one of vcs, directory, archive must be set " + "if sdist and wheels are not set" + ) + try: + for i, attestation_identity in enumerate( # noqa: B007 + package.attestation_identities or [] + ): + _get_required(attestation_identity, str, "kind") + except Exception as e: + raise PylockValidationError( + e, context=f"attestation-identities[{i}]" + ) from e + return package + + @property + def is_direct(self) -> bool: + return not (self.sdist or self.wheels) + + +@dataclass(frozen=True, init=False) +class Pylock: + """A class representing a pylock file.""" + + lock_version: Version + environments: Sequence[Marker] | None = None + requires_python: SpecifierSet | None = None + extras: Sequence[NormalizedName] | None = None + dependency_groups: Sequence[str] | None = None + default_groups: Sequence[str] | None = None + created_by: str # type: ignore[misc] + packages: Sequence[Package] # type: ignore[misc] + tool: Mapping[str, Any] | None = None + + def __init__( + self, + *, + lock_version: Version, + environments: Sequence[Marker] | None = None, + requires_python: SpecifierSet | None = None, + extras: Sequence[NormalizedName] | None = None, + dependency_groups: Sequence[str] | None = None, + default_groups: Sequence[str] | None = None, + created_by: str, + packages: Sequence[Package], + tool: Mapping[str, Any] | None = None, + ) -> None: + # In Python 3.10+ make dataclass kw_only=True and remove __init__ + object.__setattr__(self, "lock_version", lock_version) + object.__setattr__(self, "environments", environments) + object.__setattr__(self, "requires_python", requires_python) + object.__setattr__(self, "extras", extras) + object.__setattr__(self, "dependency_groups", dependency_groups) + object.__setattr__(self, "default_groups", default_groups) + object.__setattr__(self, "created_by", created_by) + object.__setattr__(self, "packages", packages) + object.__setattr__(self, "tool", tool) + + @classmethod + def _from_dict(cls, d: Mapping[str, Any]) -> Self: + pylock = cls( + lock_version=_get_required_as(d, str, Version, "lock-version"), + environments=_get_sequence_as(d, str, Marker, "environments"), + extras=_get_sequence_as(d, str, _validate_normalized_name, "extras"), + dependency_groups=_get_sequence(d, str, "dependency-groups"), + default_groups=_get_sequence(d, str, "default-groups"), + created_by=_get_required(d, str, "created-by"), + requires_python=_get_as(d, str, SpecifierSet, "requires-python"), + packages=_get_required_sequence_of_objects(d, Package, "packages"), + tool=_get(d, Mapping, "tool"), # type: ignore[type-abstract] + ) + if not Version("1") <= pylock.lock_version < Version("2"): + raise PylockUnsupportedVersionError( + f"pylock version {pylock.lock_version} is not supported" + ) + if pylock.lock_version > Version("1.0"): + _logger.warning( + "pylock minor version %s is not supported", pylock.lock_version + ) + return pylock + + @classmethod + def from_dict(cls, d: Mapping[str, Any], /) -> Self: + """Create and validate a Pylock instance from a TOML dictionary. + + Raises :class:`PylockValidationError` if the input data is not + spec-compliant. + """ + return cls._from_dict(d) + + def to_dict(self) -> Mapping[str, Any]: + """Convert the Pylock instance to a TOML dictionary.""" + return dataclasses.asdict(self, dict_factory=_toml_dict_factory) + + def validate(self) -> None: + """Validate the Pylock instance against the specification. + + Raises :class:`PylockValidationError` otherwise.""" + self.from_dict(self.to_dict()) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/requirements.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/requirements.py new file mode 100644 index 0000000000000000000000000000000000000000..3079be69bf880f47e64dbf62993f0e54754b7315 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/requirements.py @@ -0,0 +1,86 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. +from __future__ import annotations + +from typing import Iterator + +from ._parser import parse_requirement as _parse_requirement +from ._tokenizer import ParserSyntaxError +from .markers import Marker, _normalize_extra_values +from .specifiers import SpecifierSet +from .utils import canonicalize_name + + +class InvalidRequirement(ValueError): + """ + An invalid requirement was found, users should refer to PEP 508. + """ + + +class Requirement: + """Parse a requirement. + + Parse a given requirement string into its parts, such as name, specifier, + URL, and extras. Raises InvalidRequirement on a badly-formed requirement + string. + """ + + # TODO: Can we test whether something is contained within a requirement? + # If so how do we do that? Do we need to test against the _name_ of + # the thing as well as the version? What about the markers? + # TODO: Can we normalize the name and extra name? + + def __init__(self, requirement_string: str) -> None: + try: + parsed = _parse_requirement(requirement_string) + except ParserSyntaxError as e: + raise InvalidRequirement(str(e)) from e + + self.name: str = parsed.name + self.url: str | None = parsed.url or None + self.extras: set[str] = set(parsed.extras or []) + self.specifier: SpecifierSet = SpecifierSet(parsed.specifier) + self.marker: Marker | None = None + if parsed.marker is not None: + self.marker = Marker.__new__(Marker) + self.marker._markers = _normalize_extra_values(parsed.marker) + + def _iter_parts(self, name: str) -> Iterator[str]: + yield name + + if self.extras: + formatted_extras = ",".join(sorted(self.extras)) + yield f"[{formatted_extras}]" + + if self.specifier: + yield str(self.specifier) + + if self.url: + yield f" @ {self.url}" + if self.marker: + yield " " + + if self.marker: + yield f"; {self.marker}" + + def __str__(self) -> str: + return "".join(self._iter_parts(self.name)) + + def __repr__(self) -> str: + return f"<{self.__class__.__name__}('{self}')>" + + def __hash__(self) -> int: + return hash(tuple(self._iter_parts(canonicalize_name(self.name)))) + + def __eq__(self, other: object) -> bool: + if not isinstance(other, Requirement): + return NotImplemented + + return ( + canonicalize_name(self.name) == canonicalize_name(other.name) + and self.extras == other.extras + and self.specifier == other.specifier + and self.url == other.url + and self.marker == other.marker + ) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/specifiers.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/specifiers.py new file mode 100644 index 0000000000000000000000000000000000000000..5d26b0d1ae2d21b77e24b692d5a7e1fd01296edc --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/specifiers.py @@ -0,0 +1,1068 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. +""" +.. testsetup:: + + from packaging.specifiers import Specifier, SpecifierSet, InvalidSpecifier + from packaging.version import Version +""" + +from __future__ import annotations + +import abc +import itertools +import re +from typing import Callable, Final, Iterable, Iterator, TypeVar, Union + +from .utils import canonicalize_version +from .version import InvalidVersion, Version + +UnparsedVersion = Union[Version, str] +UnparsedVersionVar = TypeVar("UnparsedVersionVar", bound=UnparsedVersion) +CallableOperator = Callable[[Version, str], bool] + + +def _coerce_version(version: UnparsedVersion) -> Version | None: + if not isinstance(version, Version): + try: + version = Version(version) + except InvalidVersion: + return None + return version + + +def _public_version(version: Version) -> Version: + return version.__replace__(local=None) + + +def _base_version(version: Version) -> Version: + return version.__replace__(pre=None, post=None, dev=None, local=None) + + +class InvalidSpecifier(ValueError): + """ + Raised when attempting to create a :class:`Specifier` with a specifier + string that is invalid. + + >>> Specifier("lolwat") + Traceback (most recent call last): + ... + packaging.specifiers.InvalidSpecifier: Invalid specifier: 'lolwat' + """ + + +class BaseSpecifier(metaclass=abc.ABCMeta): + __slots__ = () + __match_args__ = ("_str",) + + @property + def _str(self) -> str: + """Internal property for match_args""" + return str(self) + + @abc.abstractmethod + def __str__(self) -> str: + """ + Returns the str representation of this Specifier-like object. This + should be representative of the Specifier itself. + """ + + @abc.abstractmethod + def __hash__(self) -> int: + """ + Returns a hash value for this Specifier-like object. + """ + + @abc.abstractmethod + def __eq__(self, other: object) -> bool: + """ + Returns a boolean representing whether or not the two Specifier-like + objects are equal. + + :param other: The other object to check against. + """ + + @property + @abc.abstractmethod + def prereleases(self) -> bool | None: + """Whether or not pre-releases as a whole are allowed. + + This can be set to either ``True`` or ``False`` to explicitly enable or disable + prereleases or it can be set to ``None`` (the default) to use default semantics. + """ + + @prereleases.setter # noqa: B027 + def prereleases(self, value: bool) -> None: + """Setter for :attr:`prereleases`. + + :param value: The value to set. + """ + + @abc.abstractmethod + def contains(self, item: str, prereleases: bool | None = None) -> bool: + """ + Determines if the given item is contained within this specifier. + """ + + @abc.abstractmethod + def filter( + self, iterable: Iterable[UnparsedVersionVar], prereleases: bool | None = None + ) -> Iterator[UnparsedVersionVar]: + """ + Takes an iterable of items and filters them so that only items which + are contained within this specifier are allowed in it. + """ + + +class Specifier(BaseSpecifier): + """This class abstracts handling of version specifiers. + + .. tip:: + + It is generally not required to instantiate this manually. You should instead + prefer to work with :class:`SpecifierSet` instead, which can parse + comma-separated version specifiers (which is what package metadata contains). + """ + + __slots__ = ("_prereleases", "_spec", "_spec_version") + + _operator_regex_str = r""" + (?P(~=|==|!=|<=|>=|<|>|===)) + """ + _version_regex_str = r""" + (?P + (?: + # The identity operators allow for an escape hatch that will + # do an exact string match of the version you wish to install. + # This will not be parsed by PEP 440 and we cannot determine + # any semantic meaning from it. This operator is discouraged + # but included entirely as an escape hatch. + (?<====) # Only match for the identity operator + \s* + [^\s;)]* # The arbitrary version can be just about anything, + # we match everything except for whitespace, a + # semi-colon for marker support, and a closing paren + # since versions can be enclosed in them. + ) + | + (?: + # The (non)equality operators allow for wild card and local + # versions to be specified so we have to define these two + # operators separately to enable that. + (?<===|!=) # Only match for equals and not equals + + \s* + v? + (?:[0-9]+!)? # epoch + [0-9]+(?:\.[0-9]+)* # release + + # You cannot use a wild card and a pre-release, post-release, a dev or + # local version together so group them with a | and make them optional. + (?: + \.\* # Wild card syntax of .* + | + (?: # pre release + [-_\.]? + (alpha|beta|preview|pre|a|b|c|rc) + [-_\.]? + [0-9]* + )? + (?: # post release + (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) + )? + (?:[-_\.]?dev[-_\.]?[0-9]*)? # dev release + (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local + )? + ) + | + (?: + # The compatible operator requires at least two digits in the + # release segment. + (?<=~=) # Only match for the compatible operator + + \s* + v? + (?:[0-9]+!)? # epoch + [0-9]+(?:\.[0-9]+)+ # release (We have a + instead of a *) + (?: # pre release + [-_\.]? + (alpha|beta|preview|pre|a|b|c|rc) + [-_\.]? + [0-9]* + )? + (?: # post release + (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) + )? + (?:[-_\.]?dev[-_\.]?[0-9]*)? # dev release + ) + | + (?: + # All other operators only allow a sub set of what the + # (non)equality operators do. Specifically they do not allow + # local versions to be specified nor do they allow the prefix + # matching wild cards. + (?=": "greater_than_equal", + "<": "less_than", + ">": "greater_than", + "===": "arbitrary", + } + + def __init__(self, spec: str = "", prereleases: bool | None = None) -> None: + """Initialize a Specifier instance. + + :param spec: + The string representation of a specifier which will be parsed and + normalized before use. + :param prereleases: + This tells the specifier if it should accept prerelease versions if + applicable or not. The default of ``None`` will autodetect it from the + given specifiers. + :raises InvalidSpecifier: + If the given specifier is invalid (i.e. bad syntax). + """ + match = self._regex.fullmatch(spec) + if not match: + raise InvalidSpecifier(f"Invalid specifier: {spec!r}") + + self._spec: tuple[str, str] = ( + match.group("operator").strip(), + match.group("version").strip(), + ) + + # Store whether or not this Specifier should accept prereleases + self._prereleases = prereleases + + # Specifier version cache + self._spec_version: tuple[str, Version] | None = None + + def _get_spec_version(self, version: str) -> Version | None: + """One element cache, as only one spec Version is needed per Specifier.""" + if self._spec_version is not None and self._spec_version[0] == version: + return self._spec_version[1] + + version_specifier = _coerce_version(version) + if version_specifier is None: + return None + + self._spec_version = (version, version_specifier) + return version_specifier + + def _require_spec_version(self, version: str) -> Version: + """Get spec version, asserting it's valid (not for === operator). + + This method should only be called for operators where version + strings are guaranteed to be valid PEP 440 versions (not ===). + """ + spec_version = self._get_spec_version(version) + assert spec_version is not None + return spec_version + + @property + def prereleases(self) -> bool | None: + # If there is an explicit prereleases set for this, then we'll just + # blindly use that. + if self._prereleases is not None: + return self._prereleases + + # Only the "!=" operator does not imply prereleases when + # the version in the specifier is a prerelease. + operator, version_str = self._spec + if operator != "!=": + # The == specifier with trailing .* cannot include prereleases + # e.g. "==1.0a1.*" is not valid. + if operator == "==" and version_str.endswith(".*"): + return False + + # "===" can have arbitrary string versions, so we cannot parse + # those, we take prereleases as unknown (None) for those. + version = self._get_spec_version(version_str) + if version is None: + return None + + # For all other operators, use the check if spec Version + # object implies pre-releases. + if version.is_prerelease: + return True + + return False + + @prereleases.setter + def prereleases(self, value: bool | None) -> None: + self._prereleases = value + + @property + def operator(self) -> str: + """The operator of this specifier. + + >>> Specifier("==1.2.3").operator + '==' + """ + return self._spec[0] + + @property + def version(self) -> str: + """The version of this specifier. + + >>> Specifier("==1.2.3").version + '1.2.3' + """ + return self._spec[1] + + def __repr__(self) -> str: + """A representation of the Specifier that shows all internal state. + + >>> Specifier('>=1.0.0') + =1.0.0')> + >>> Specifier('>=1.0.0', prereleases=False) + =1.0.0', prereleases=False)> + >>> Specifier('>=1.0.0', prereleases=True) + =1.0.0', prereleases=True)> + """ + pre = ( + f", prereleases={self.prereleases!r}" + if self._prereleases is not None + else "" + ) + + return f"<{self.__class__.__name__}({str(self)!r}{pre})>" + + def __str__(self) -> str: + """A string representation of the Specifier that can be round-tripped. + + >>> str(Specifier('>=1.0.0')) + '>=1.0.0' + >>> str(Specifier('>=1.0.0', prereleases=False)) + '>=1.0.0' + """ + return "{}{}".format(*self._spec) + + @property + def _canonical_spec(self) -> tuple[str, str]: + operator, version = self._spec + if operator == "===" or version.endswith(".*"): + return operator, version + + spec_version = self._require_spec_version(version) + + canonical_version = canonicalize_version( + spec_version, strip_trailing_zero=(operator != "~=") + ) + + return operator, canonical_version + + def __hash__(self) -> int: + return hash(self._canonical_spec) + + def __eq__(self, other: object) -> bool: + """Whether or not the two Specifier-like objects are equal. + + :param other: The other object to check against. + + The value of :attr:`prereleases` is ignored. + + >>> Specifier("==1.2.3") == Specifier("== 1.2.3.0") + True + >>> (Specifier("==1.2.3", prereleases=False) == + ... Specifier("==1.2.3", prereleases=True)) + True + >>> Specifier("==1.2.3") == "==1.2.3" + True + >>> Specifier("==1.2.3") == Specifier("==1.2.4") + False + >>> Specifier("==1.2.3") == Specifier("~=1.2.3") + False + """ + if isinstance(other, str): + try: + other = self.__class__(str(other)) + except InvalidSpecifier: + return NotImplemented + elif not isinstance(other, self.__class__): + return NotImplemented + + return self._canonical_spec == other._canonical_spec + + def _get_operator(self, op: str) -> CallableOperator: + operator_callable: CallableOperator = getattr( + self, f"_compare_{self._operators[op]}" + ) + return operator_callable + + def _compare_compatible(self, prospective: Version, spec: str) -> bool: + # Compatible releases have an equivalent combination of >= and ==. That + # is that ~=2.2 is equivalent to >=2.2,==2.*. This allows us to + # implement this in terms of the other specifiers instead of + # implementing it ourselves. The only thing we need to do is construct + # the other specifiers. + + # We want everything but the last item in the version, but we want to + # ignore suffix segments. + prefix = _version_join( + list(itertools.takewhile(_is_not_suffix, _version_split(spec)))[:-1] + ) + + # Add the prefix notation to the end of our string + prefix += ".*" + + return self._get_operator(">=")(prospective, spec) and self._get_operator("==")( + prospective, prefix + ) + + def _compare_equal(self, prospective: Version, spec: str) -> bool: + # We need special logic to handle prefix matching + if spec.endswith(".*"): + # In the case of prefix matching we want to ignore local segment. + normalized_prospective = canonicalize_version( + _public_version(prospective), strip_trailing_zero=False + ) + # Get the normalized version string ignoring the trailing .* + normalized_spec = canonicalize_version(spec[:-2], strip_trailing_zero=False) + # Split the spec out by bangs and dots, and pretend that there is + # an implicit dot in between a release segment and a pre-release segment. + split_spec = _version_split(normalized_spec) + + # Split the prospective version out by bangs and dots, and pretend + # that there is an implicit dot in between a release segment and + # a pre-release segment. + split_prospective = _version_split(normalized_prospective) + + # 0-pad the prospective version before shortening it to get the correct + # shortened version. + padded_prospective, _ = _pad_version(split_prospective, split_spec) + + # Shorten the prospective version to be the same length as the spec + # so that we can determine if the specifier is a prefix of the + # prospective version or not. + shortened_prospective = padded_prospective[: len(split_spec)] + + return shortened_prospective == split_spec + else: + # Convert our spec string into a Version + spec_version = self._require_spec_version(spec) + + # If the specifier does not have a local segment, then we want to + # act as if the prospective version also does not have a local + # segment. + if not spec_version.local: + prospective = _public_version(prospective) + + return prospective == spec_version + + def _compare_not_equal(self, prospective: Version, spec: str) -> bool: + return not self._compare_equal(prospective, spec) + + def _compare_less_than_equal(self, prospective: Version, spec: str) -> bool: + # NB: Local version identifiers are NOT permitted in the version + # specifier, so local version labels can be universally removed from + # the prospective version. + return _public_version(prospective) <= self._require_spec_version(spec) + + def _compare_greater_than_equal(self, prospective: Version, spec: str) -> bool: + # NB: Local version identifiers are NOT permitted in the version + # specifier, so local version labels can be universally removed from + # the prospective version. + return _public_version(prospective) >= self._require_spec_version(spec) + + def _compare_less_than(self, prospective: Version, spec_str: str) -> bool: + # Convert our spec to a Version instance, since we'll want to work with + # it as a version. + spec = self._require_spec_version(spec_str) + + # Check to see if the prospective version is less than the spec + # version. If it's not we can short circuit and just return False now + # instead of doing extra unneeded work. + if not prospective < spec: + return False + + # This special case is here so that, unless the specifier itself + # includes is a pre-release version, that we do not accept pre-release + # versions for the version mentioned in the specifier (e.g. <3.1 should + # not match 3.1.dev0, but should match 3.0.dev0). + if ( + not spec.is_prerelease + and prospective.is_prerelease + and _base_version(prospective) == _base_version(spec) + ): + return False + + # If we've gotten to here, it means that prospective version is both + # less than the spec version *and* it's not a pre-release of the same + # version in the spec. + return True + + def _compare_greater_than(self, prospective: Version, spec_str: str) -> bool: + # Convert our spec to a Version instance, since we'll want to work with + # it as a version. + spec = self._require_spec_version(spec_str) + + # Check to see if the prospective version is greater than the spec + # version. If it's not we can short circuit and just return False now + # instead of doing extra unneeded work. + if not prospective > spec: + return False + + # This special case is here so that, unless the specifier itself + # includes is a post-release version, that we do not accept + # post-release versions for the version mentioned in the specifier + # (e.g. >3.1 should not match 3.0.post0, but should match 3.2.post0). + if ( + not spec.is_postrelease + and prospective.is_postrelease + and _base_version(prospective) == _base_version(spec) + ): + return False + + # Ensure that we do not allow a local version of the version mentioned + # in the specifier, which is technically greater than, to match. + if prospective.local is not None and _base_version( + prospective + ) == _base_version(spec): + return False + + # If we've gotten to here, it means that prospective version is both + # greater than the spec version *and* it's not a pre-release of the + # same version in the spec. + return True + + def _compare_arbitrary(self, prospective: Version | str, spec: str) -> bool: + return str(prospective).lower() == str(spec).lower() + + def __contains__(self, item: str | Version) -> bool: + """Return whether or not the item is contained in this specifier. + + :param item: The item to check for. + + This is used for the ``in`` operator and behaves the same as + :meth:`contains` with no ``prereleases`` argument passed. + + >>> "1.2.3" in Specifier(">=1.2.3") + True + >>> Version("1.2.3") in Specifier(">=1.2.3") + True + >>> "1.0.0" in Specifier(">=1.2.3") + False + >>> "1.3.0a1" in Specifier(">=1.2.3") + True + >>> "1.3.0a1" in Specifier(">=1.2.3", prereleases=True) + True + """ + return self.contains(item) + + def contains(self, item: UnparsedVersion, prereleases: bool | None = None) -> bool: + """Return whether or not the item is contained in this specifier. + + :param item: + The item to check for, which can be a version string or a + :class:`Version` instance. + :param prereleases: + Whether or not to match prereleases with this Specifier. If set to + ``None`` (the default), it will follow the recommendation from + :pep:`440` and match prereleases, as there are no other versions. + + >>> Specifier(">=1.2.3").contains("1.2.3") + True + >>> Specifier(">=1.2.3").contains(Version("1.2.3")) + True + >>> Specifier(">=1.2.3").contains("1.0.0") + False + >>> Specifier(">=1.2.3").contains("1.3.0a1") + True + >>> Specifier(">=1.2.3", prereleases=False).contains("1.3.0a1") + False + >>> Specifier(">=1.2.3").contains("1.3.0a1") + True + """ + + return bool(list(self.filter([item], prereleases=prereleases))) + + def filter( + self, iterable: Iterable[UnparsedVersionVar], prereleases: bool | None = None + ) -> Iterator[UnparsedVersionVar]: + """Filter items in the given iterable, that match the specifier. + + :param iterable: + An iterable that can contain version strings and :class:`Version` instances. + The items in the iterable will be filtered according to the specifier. + :param prereleases: + Whether or not to allow prereleases in the returned iterator. If set to + ``None`` (the default), it will follow the recommendation from :pep:`440` + and match prereleases if there are no other versions. + + >>> list(Specifier(">=1.2.3").filter(["1.2", "1.3", "1.5a1"])) + ['1.3'] + >>> list(Specifier(">=1.2.3").filter(["1.2", "1.2.3", "1.3", Version("1.4")])) + ['1.2.3', '1.3', ] + >>> list(Specifier(">=1.2.3").filter(["1.2", "1.5a1"])) + ['1.5a1'] + >>> list(Specifier(">=1.2.3").filter(["1.3", "1.5a1"], prereleases=True)) + ['1.3', '1.5a1'] + >>> list(Specifier(">=1.2.3", prereleases=True).filter(["1.3", "1.5a1"])) + ['1.3', '1.5a1'] + """ + prereleases_versions = [] + found_non_prereleases = False + + # Determine if to include prereleases by default + include_prereleases = ( + prereleases if prereleases is not None else self.prereleases + ) + + # Get the matching operator + operator_callable = self._get_operator(self.operator) + + # Filter versions + for version in iterable: + parsed_version = _coerce_version(version) + if parsed_version is None: + # === operator can match arbitrary (non-version) strings + if self.operator == "===" and self._compare_arbitrary( + version, self.version + ): + yield version + elif operator_callable(parsed_version, self.version): + # If it's not a prerelease or prereleases are allowed, yield it directly + if not parsed_version.is_prerelease or include_prereleases: + found_non_prereleases = True + yield version + # Otherwise collect prereleases for potential later use + elif prereleases is None and self._prereleases is not False: + prereleases_versions.append(version) + + # If no non-prereleases were found and prereleases weren't + # explicitly forbidden, yield the collected prereleases + if ( + not found_non_prereleases + and prereleases is None + and self._prereleases is not False + ): + yield from prereleases_versions + + +_prefix_regex = re.compile(r"([0-9]+)((?:a|b|c|rc)[0-9]+)") + + +def _version_split(version: str) -> list[str]: + """Split version into components. + + The split components are intended for version comparison. The logic does + not attempt to retain the original version string, so joining the + components back with :func:`_version_join` may not produce the original + version string. + """ + result: list[str] = [] + + epoch, _, rest = version.rpartition("!") + result.append(epoch or "0") + + for item in rest.split("."): + match = _prefix_regex.fullmatch(item) + if match: + result.extend(match.groups()) + else: + result.append(item) + return result + + +def _version_join(components: list[str]) -> str: + """Join split version components into a version string. + + This function assumes the input came from :func:`_version_split`, where the + first component must be the epoch (either empty or numeric), and all other + components numeric. + """ + epoch, *rest = components + return f"{epoch}!{'.'.join(rest)}" + + +def _is_not_suffix(segment: str) -> bool: + return not any( + segment.startswith(prefix) for prefix in ("dev", "a", "b", "rc", "post") + ) + + +def _pad_version(left: list[str], right: list[str]) -> tuple[list[str], list[str]]: + left_split, right_split = [], [] + + # Get the release segment of our versions + left_split.append(list(itertools.takewhile(lambda x: x.isdigit(), left))) + right_split.append(list(itertools.takewhile(lambda x: x.isdigit(), right))) + + # Get the rest of our versions + left_split.append(left[len(left_split[0]) :]) + right_split.append(right[len(right_split[0]) :]) + + # Insert our padding + left_split.insert(1, ["0"] * max(0, len(right_split[0]) - len(left_split[0]))) + right_split.insert(1, ["0"] * max(0, len(left_split[0]) - len(right_split[0]))) + + return ( + list(itertools.chain.from_iterable(left_split)), + list(itertools.chain.from_iterable(right_split)), + ) + + +class SpecifierSet(BaseSpecifier): + """This class abstracts handling of a set of version specifiers. + + It can be passed a single specifier (``>=3.0``), a comma-separated list of + specifiers (``>=3.0,!=3.1``), or no specifier at all. + """ + + __slots__ = ("_prereleases", "_specs") + + def __init__( + self, + specifiers: str | Iterable[Specifier] = "", + prereleases: bool | None = None, + ) -> None: + """Initialize a SpecifierSet instance. + + :param specifiers: + The string representation of a specifier or a comma-separated list of + specifiers which will be parsed and normalized before use. + May also be an iterable of ``Specifier`` instances, which will be used + as is. + :param prereleases: + This tells the SpecifierSet if it should accept prerelease versions if + applicable or not. The default of ``None`` will autodetect it from the + given specifiers. + + :raises InvalidSpecifier: + If the given ``specifiers`` are not parseable than this exception will be + raised. + """ + + if isinstance(specifiers, str): + # Split on `,` to break each individual specifier into its own item, and + # strip each item to remove leading/trailing whitespace. + split_specifiers = [s.strip() for s in specifiers.split(",") if s.strip()] + + # Make each individual specifier a Specifier and save in a frozen set + # for later. + self._specs = frozenset(map(Specifier, split_specifiers)) + else: + # Save the supplied specifiers in a frozen set. + self._specs = frozenset(specifiers) + + # Store our prereleases value so we can use it later to determine if + # we accept prereleases or not. + self._prereleases = prereleases + + @property + def prereleases(self) -> bool | None: + # If we have been given an explicit prerelease modifier, then we'll + # pass that through here. + if self._prereleases is not None: + return self._prereleases + + # If we don't have any specifiers, and we don't have a forced value, + # then we'll just return None since we don't know if this should have + # pre-releases or not. + if not self._specs: + return None + + # Otherwise we'll see if any of the given specifiers accept + # prereleases, if any of them do we'll return True, otherwise False. + if any(s.prereleases for s in self._specs): + return True + + return None + + @prereleases.setter + def prereleases(self, value: bool | None) -> None: + self._prereleases = value + + def __repr__(self) -> str: + """A representation of the specifier set that shows all internal state. + + Note that the ordering of the individual specifiers within the set may not + match the input string. + + >>> SpecifierSet('>=1.0.0,!=2.0.0') + =1.0.0')> + >>> SpecifierSet('>=1.0.0,!=2.0.0', prereleases=False) + =1.0.0', prereleases=False)> + >>> SpecifierSet('>=1.0.0,!=2.0.0', prereleases=True) + =1.0.0', prereleases=True)> + """ + pre = ( + f", prereleases={self.prereleases!r}" + if self._prereleases is not None + else "" + ) + + return f"" + + def __str__(self) -> str: + """A string representation of the specifier set that can be round-tripped. + + Note that the ordering of the individual specifiers within the set may not + match the input string. + + >>> str(SpecifierSet(">=1.0.0,!=1.0.1")) + '!=1.0.1,>=1.0.0' + >>> str(SpecifierSet(">=1.0.0,!=1.0.1", prereleases=False)) + '!=1.0.1,>=1.0.0' + """ + return ",".join(sorted(str(s) for s in self._specs)) + + def __hash__(self) -> int: + return hash(self._specs) + + def __and__(self, other: SpecifierSet | str) -> SpecifierSet: + """Return a SpecifierSet which is a combination of the two sets. + + :param other: The other object to combine with. + + >>> SpecifierSet(">=1.0.0,!=1.0.1") & '<=2.0.0,!=2.0.1' + =1.0.0')> + >>> SpecifierSet(">=1.0.0,!=1.0.1") & SpecifierSet('<=2.0.0,!=2.0.1') + =1.0.0')> + """ + if isinstance(other, str): + other = SpecifierSet(other) + elif not isinstance(other, SpecifierSet): + return NotImplemented + + specifier = SpecifierSet() + specifier._specs = frozenset(self._specs | other._specs) + + if self._prereleases is None and other._prereleases is not None: + specifier._prereleases = other._prereleases + elif ( + self._prereleases is not None and other._prereleases is None + ) or self._prereleases == other._prereleases: + specifier._prereleases = self._prereleases + else: + raise ValueError( + "Cannot combine SpecifierSets with True and False prerelease overrides." + ) + + return specifier + + def __eq__(self, other: object) -> bool: + """Whether or not the two SpecifierSet-like objects are equal. + + :param other: The other object to check against. + + The value of :attr:`prereleases` is ignored. + + >>> SpecifierSet(">=1.0.0,!=1.0.1") == SpecifierSet(">=1.0.0,!=1.0.1") + True + >>> (SpecifierSet(">=1.0.0,!=1.0.1", prereleases=False) == + ... SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True)) + True + >>> SpecifierSet(">=1.0.0,!=1.0.1") == ">=1.0.0,!=1.0.1" + True + >>> SpecifierSet(">=1.0.0,!=1.0.1") == SpecifierSet(">=1.0.0") + False + >>> SpecifierSet(">=1.0.0,!=1.0.1") == SpecifierSet(">=1.0.0,!=1.0.2") + False + """ + if isinstance(other, (str, Specifier)): + other = SpecifierSet(str(other)) + elif not isinstance(other, SpecifierSet): + return NotImplemented + + return self._specs == other._specs + + def __len__(self) -> int: + """Returns the number of specifiers in this specifier set.""" + return len(self._specs) + + def __iter__(self) -> Iterator[Specifier]: + """ + Returns an iterator over all the underlying :class:`Specifier` instances + in this specifier set. + + >>> sorted(SpecifierSet(">=1.0.0,!=1.0.1"), key=str) + [, =1.0.0')>] + """ + return iter(self._specs) + + def __contains__(self, item: UnparsedVersion) -> bool: + """Return whether or not the item is contained in this specifier. + + :param item: The item to check for. + + This is used for the ``in`` operator and behaves the same as + :meth:`contains` with no ``prereleases`` argument passed. + + >>> "1.2.3" in SpecifierSet(">=1.0.0,!=1.0.1") + True + >>> Version("1.2.3") in SpecifierSet(">=1.0.0,!=1.0.1") + True + >>> "1.0.1" in SpecifierSet(">=1.0.0,!=1.0.1") + False + >>> "1.3.0a1" in SpecifierSet(">=1.0.0,!=1.0.1") + True + >>> "1.3.0a1" in SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True) + True + """ + return self.contains(item) + + def contains( + self, + item: UnparsedVersion, + prereleases: bool | None = None, + installed: bool | None = None, + ) -> bool: + """Return whether or not the item is contained in this SpecifierSet. + + :param item: + The item to check for, which can be a version string or a + :class:`Version` instance. + :param prereleases: + Whether or not to match prereleases with this SpecifierSet. If set to + ``None`` (the default), it will follow the recommendation from :pep:`440` + and match prereleases, as there are no other versions. + :param installed: + Whether or not the item is installed. If set to ``True``, it will + accept prerelease versions even if the specifier does not allow them. + + >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.2.3") + True + >>> SpecifierSet(">=1.0.0,!=1.0.1").contains(Version("1.2.3")) + True + >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.0.1") + False + >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.3.0a1") + True + >>> SpecifierSet(">=1.0.0,!=1.0.1", prereleases=False).contains("1.3.0a1") + False + >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.3.0a1", prereleases=True) + True + """ + version = _coerce_version(item) + + if version is not None and installed and version.is_prerelease: + prereleases = True + + check_item = item if version is None else version + return bool(list(self.filter([check_item], prereleases=prereleases))) + + def filter( + self, iterable: Iterable[UnparsedVersionVar], prereleases: bool | None = None + ) -> Iterator[UnparsedVersionVar]: + """Filter items in the given iterable, that match the specifiers in this set. + + :param iterable: + An iterable that can contain version strings and :class:`Version` instances. + The items in the iterable will be filtered according to the specifier. + :param prereleases: + Whether or not to allow prereleases in the returned iterator. If set to + ``None`` (the default), it will follow the recommendation from :pep:`440` + and match prereleases if there are no other versions. + + >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.3", "1.5a1"])) + ['1.3'] + >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.3", Version("1.4")])) + ['1.3', ] + >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.5a1"])) + ['1.5a1'] + >>> list(SpecifierSet(">=1.2.3").filter(["1.3", "1.5a1"], prereleases=True)) + ['1.3', '1.5a1'] + >>> list(SpecifierSet(">=1.2.3", prereleases=True).filter(["1.3", "1.5a1"])) + ['1.3', '1.5a1'] + + An "empty" SpecifierSet will filter items based on the presence of prerelease + versions in the set. + + >>> list(SpecifierSet("").filter(["1.3", "1.5a1"])) + ['1.3'] + >>> list(SpecifierSet("").filter(["1.5a1"])) + ['1.5a1'] + >>> list(SpecifierSet("", prereleases=True).filter(["1.3", "1.5a1"])) + ['1.3', '1.5a1'] + >>> list(SpecifierSet("").filter(["1.3", "1.5a1"], prereleases=True)) + ['1.3', '1.5a1'] + """ + # Determine if we're forcing a prerelease or not, if we're not forcing + # one for this particular filter call, then we'll use whatever the + # SpecifierSet thinks for whether or not we should support prereleases. + if prereleases is None and self.prereleases is not None: + prereleases = self.prereleases + + # If we have any specifiers, then we want to wrap our iterable in the + # filter method for each one, this will act as a logical AND amongst + # each specifier. + if self._specs: + # When prereleases is None, we need to let all versions through + # the individual filters, then decide about prereleases at the end + # based on whether any non-prereleases matched ALL specs. + for spec in self._specs: + iterable = spec.filter( + iterable, prereleases=True if prereleases is None else prereleases + ) + + if prereleases is not None: + # If we have a forced prereleases value, + # we can immediately return the iterator. + return iter(iterable) + else: + # Handle empty SpecifierSet cases where prereleases is not None. + if prereleases is True: + return iter(iterable) + + if prereleases is False: + return ( + item + for item in iterable + if (version := _coerce_version(item)) is None + or not version.is_prerelease + ) + + # Finally if prereleases is None, apply PEP 440 logic: + # exclude prereleases unless there are no final releases that matched. + filtered_items: list[UnparsedVersionVar] = [] + found_prereleases: list[UnparsedVersionVar] = [] + found_final_release = False + + for item in iterable: + parsed_version = _coerce_version(item) + # Arbitrary strings are always included as it is not + # possible to determine if they are prereleases, + # and they have already passed all specifiers. + if parsed_version is None: + filtered_items.append(item) + found_prereleases.append(item) + elif parsed_version.is_prerelease: + found_prereleases.append(item) + else: + filtered_items.append(item) + found_final_release = True + + return iter(filtered_items if found_final_release else found_prereleases) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/tags.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/tags.py new file mode 100644 index 0000000000000000000000000000000000000000..5ef27c897a4df35a2a6923b608a5e04a0a38b9ee --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/tags.py @@ -0,0 +1,651 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import annotations + +import logging +import platform +import re +import struct +import subprocess +import sys +import sysconfig +from importlib.machinery import EXTENSION_SUFFIXES +from typing import ( + Any, + Iterable, + Iterator, + Sequence, + Tuple, + cast, +) + +from . import _manylinux, _musllinux + +logger = logging.getLogger(__name__) + +PythonVersion = Sequence[int] +AppleVersion = Tuple[int, int] + +INTERPRETER_SHORT_NAMES: dict[str, str] = { + "python": "py", # Generic. + "cpython": "cp", + "pypy": "pp", + "ironpython": "ip", + "jython": "jy", +} + + +_32_BIT_INTERPRETER = struct.calcsize("P") == 4 + + +class Tag: + """ + A representation of the tag triple for a wheel. + + Instances are considered immutable and thus are hashable. Equality checking + is also supported. + """ + + __slots__ = ["_abi", "_hash", "_interpreter", "_platform"] + + def __init__(self, interpreter: str, abi: str, platform: str) -> None: + self._interpreter = interpreter.lower() + self._abi = abi.lower() + self._platform = platform.lower() + # The __hash__ of every single element in a Set[Tag] will be evaluated each time + # that a set calls its `.disjoint()` method, which may be called hundreds of + # times when scanning a page of links for packages with tags matching that + # Set[Tag]. Pre-computing the value here produces significant speedups for + # downstream consumers. + self._hash = hash((self._interpreter, self._abi, self._platform)) + + @property + def interpreter(self) -> str: + return self._interpreter + + @property + def abi(self) -> str: + return self._abi + + @property + def platform(self) -> str: + return self._platform + + def __eq__(self, other: object) -> bool: + if not isinstance(other, Tag): + return NotImplemented + + return ( + (self._hash == other._hash) # Short-circuit ASAP for perf reasons. + and (self._platform == other._platform) + and (self._abi == other._abi) + and (self._interpreter == other._interpreter) + ) + + def __hash__(self) -> int: + return self._hash + + def __str__(self) -> str: + return f"{self._interpreter}-{self._abi}-{self._platform}" + + def __repr__(self) -> str: + return f"<{self} @ {id(self)}>" + + def __setstate__(self, state: tuple[None, dict[str, Any]]) -> None: + # The cached _hash is wrong when unpickling. + _, slots = state + for k, v in slots.items(): + setattr(self, k, v) + self._hash = hash((self._interpreter, self._abi, self._platform)) + + +def parse_tag(tag: str) -> frozenset[Tag]: + """ + Parses the provided tag (e.g. `py3-none-any`) into a frozenset of Tag instances. + + Returning a set is required due to the possibility that the tag is a + compressed tag set. + """ + tags = set() + interpreters, abis, platforms = tag.split("-") + for interpreter in interpreters.split("."): + for abi in abis.split("."): + for platform_ in platforms.split("."): + tags.add(Tag(interpreter, abi, platform_)) + return frozenset(tags) + + +def _get_config_var(name: str, warn: bool = False) -> int | str | None: + value: int | str | None = sysconfig.get_config_var(name) + if value is None and warn: + logger.debug( + "Config variable '%s' is unset, Python ABI tag may be incorrect", name + ) + return value + + +def _normalize_string(string: str) -> str: + return string.replace(".", "_").replace("-", "_").replace(" ", "_") + + +def _is_threaded_cpython(abis: list[str]) -> bool: + """ + Determine if the ABI corresponds to a threaded (`--disable-gil`) build. + + The threaded builds are indicated by a "t" in the abiflags. + """ + if len(abis) == 0: + return False + # expect e.g., cp313 + m = re.match(r"cp\d+(.*)", abis[0]) + if not m: + return False + abiflags = m.group(1) + return "t" in abiflags + + +def _abi3_applies(python_version: PythonVersion, threading: bool) -> bool: + """ + Determine if the Python version supports abi3. + + PEP 384 was first implemented in Python 3.2. The threaded (`--disable-gil`) + builds do not support abi3. + """ + return len(python_version) > 1 and tuple(python_version) >= (3, 2) and not threading + + +def _cpython_abis(py_version: PythonVersion, warn: bool = False) -> list[str]: + py_version = tuple(py_version) # To allow for version comparison. + abis = [] + version = _version_nodot(py_version[:2]) + threading = debug = pymalloc = ucs4 = "" + with_debug = _get_config_var("Py_DEBUG", warn) + has_refcount = hasattr(sys, "gettotalrefcount") + # Windows doesn't set Py_DEBUG, so checking for support of debug-compiled + # extension modules is the best option. + # https://github.com/pypa/pip/issues/3383#issuecomment-173267692 + has_ext = "_d.pyd" in EXTENSION_SUFFIXES + if with_debug or (with_debug is None and (has_refcount or has_ext)): + debug = "d" + if py_version >= (3, 13) and _get_config_var("Py_GIL_DISABLED", warn): + threading = "t" + if py_version < (3, 8): + with_pymalloc = _get_config_var("WITH_PYMALLOC", warn) + if with_pymalloc or with_pymalloc is None: + pymalloc = "m" + if py_version < (3, 3): + unicode_size = _get_config_var("Py_UNICODE_SIZE", warn) + if unicode_size == 4 or ( + unicode_size is None and sys.maxunicode == 0x10FFFF + ): + ucs4 = "u" + elif debug: + # Debug builds can also load "normal" extension modules. + # We can also assume no UCS-4 or pymalloc requirement. + abis.append(f"cp{version}{threading}") + abis.insert(0, f"cp{version}{threading}{debug}{pymalloc}{ucs4}") + return abis + + +def cpython_tags( + python_version: PythonVersion | None = None, + abis: Iterable[str] | None = None, + platforms: Iterable[str] | None = None, + *, + warn: bool = False, +) -> Iterator[Tag]: + """ + Yields the tags for a CPython interpreter. + + The tags consist of: + - cp-- + - cp-abi3- + - cp-none- + - cp-abi3- # Older Python versions down to 3.2. + + If python_version only specifies a major version then user-provided ABIs and + the 'none' ABItag will be used. + + If 'abi3' or 'none' are specified in 'abis' then they will be yielded at + their normal position and not at the beginning. + """ + if not python_version: + python_version = sys.version_info[:2] + + interpreter = f"cp{_version_nodot(python_version[:2])}" + + if abis is None: + abis = _cpython_abis(python_version, warn) if len(python_version) > 1 else [] + abis = list(abis) + # 'abi3' and 'none' are explicitly handled later. + for explicit_abi in ("abi3", "none"): + try: + abis.remove(explicit_abi) + except ValueError: # noqa: PERF203 + pass + + platforms = list(platforms or platform_tags()) + for abi in abis: + for platform_ in platforms: + yield Tag(interpreter, abi, platform_) + + threading = _is_threaded_cpython(abis) + use_abi3 = _abi3_applies(python_version, threading) + if use_abi3: + yield from (Tag(interpreter, "abi3", platform_) for platform_ in platforms) + yield from (Tag(interpreter, "none", platform_) for platform_ in platforms) + + if use_abi3: + for minor_version in range(python_version[1] - 1, 1, -1): + for platform_ in platforms: + version = _version_nodot((python_version[0], minor_version)) + interpreter = f"cp{version}" + yield Tag(interpreter, "abi3", platform_) + + +def _generic_abi() -> list[str]: + """ + Return the ABI tag based on EXT_SUFFIX. + """ + # The following are examples of `EXT_SUFFIX`. + # We want to keep the parts which are related to the ABI and remove the + # parts which are related to the platform: + # - linux: '.cpython-310-x86_64-linux-gnu.so' => cp310 + # - mac: '.cpython-310-darwin.so' => cp310 + # - win: '.cp310-win_amd64.pyd' => cp310 + # - win: '.pyd' => cp37 (uses _cpython_abis()) + # - pypy: '.pypy38-pp73-x86_64-linux-gnu.so' => pypy38_pp73 + # - graalpy: '.graalpy-38-native-x86_64-darwin.dylib' + # => graalpy_38_native + + ext_suffix = _get_config_var("EXT_SUFFIX", warn=True) + if not isinstance(ext_suffix, str) or ext_suffix[0] != ".": + raise SystemError("invalid sysconfig.get_config_var('EXT_SUFFIX')") + parts = ext_suffix.split(".") + if len(parts) < 3: + # CPython3.7 and earlier uses ".pyd" on Windows. + return _cpython_abis(sys.version_info[:2]) + soabi = parts[1] + if soabi.startswith("cpython"): + # non-windows + abi = "cp" + soabi.split("-")[1] + elif soabi.startswith("cp"): + # windows + abi = soabi.split("-")[0] + elif soabi.startswith("pypy"): + abi = "-".join(soabi.split("-")[:2]) + elif soabi.startswith("graalpy"): + abi = "-".join(soabi.split("-")[:3]) + elif soabi: + # pyston, ironpython, others? + abi = soabi + else: + return [] + return [_normalize_string(abi)] + + +def generic_tags( + interpreter: str | None = None, + abis: Iterable[str] | None = None, + platforms: Iterable[str] | None = None, + *, + warn: bool = False, +) -> Iterator[Tag]: + """ + Yields the tags for a generic interpreter. + + The tags consist of: + - -- + + The "none" ABI will be added if it was not explicitly provided. + """ + if not interpreter: + interp_name = interpreter_name() + interp_version = interpreter_version(warn=warn) + interpreter = f"{interp_name}{interp_version}" + abis = _generic_abi() if abis is None else list(abis) + platforms = list(platforms or platform_tags()) + if "none" not in abis: + abis.append("none") + for abi in abis: + for platform_ in platforms: + yield Tag(interpreter, abi, platform_) + + +def _py_interpreter_range(py_version: PythonVersion) -> Iterator[str]: + """ + Yields Python versions in descending order. + + After the latest version, the major-only version will be yielded, and then + all previous versions of that major version. + """ + if len(py_version) > 1: + yield f"py{_version_nodot(py_version[:2])}" + yield f"py{py_version[0]}" + if len(py_version) > 1: + for minor in range(py_version[1] - 1, -1, -1): + yield f"py{_version_nodot((py_version[0], minor))}" + + +def compatible_tags( + python_version: PythonVersion | None = None, + interpreter: str | None = None, + platforms: Iterable[str] | None = None, +) -> Iterator[Tag]: + """ + Yields the sequence of tags that are compatible with a specific version of Python. + + The tags consist of: + - py*-none- + - -none-any # ... if `interpreter` is provided. + - py*-none-any + """ + if not python_version: + python_version = sys.version_info[:2] + platforms = list(platforms or platform_tags()) + for version in _py_interpreter_range(python_version): + for platform_ in platforms: + yield Tag(version, "none", platform_) + if interpreter: + yield Tag(interpreter, "none", "any") + for version in _py_interpreter_range(python_version): + yield Tag(version, "none", "any") + + +def _mac_arch(arch: str, is_32bit: bool = _32_BIT_INTERPRETER) -> str: + if not is_32bit: + return arch + + if arch.startswith("ppc"): + return "ppc" + + return "i386" + + +def _mac_binary_formats(version: AppleVersion, cpu_arch: str) -> list[str]: + formats = [cpu_arch] + if cpu_arch == "x86_64": + if version < (10, 4): + return [] + formats.extend(["intel", "fat64", "fat32"]) + + elif cpu_arch == "i386": + if version < (10, 4): + return [] + formats.extend(["intel", "fat32", "fat"]) + + elif cpu_arch == "ppc64": + # TODO: Need to care about 32-bit PPC for ppc64 through 10.2? + if version > (10, 5) or version < (10, 4): + return [] + formats.append("fat64") + + elif cpu_arch == "ppc": + if version > (10, 6): + return [] + formats.extend(["fat32", "fat"]) + + if cpu_arch in {"arm64", "x86_64"}: + formats.append("universal2") + + if cpu_arch in {"x86_64", "i386", "ppc64", "ppc", "intel"}: + formats.append("universal") + + return formats + + +def mac_platforms( + version: AppleVersion | None = None, arch: str | None = None +) -> Iterator[str]: + """ + Yields the platform tags for a macOS system. + + The `version` parameter is a two-item tuple specifying the macOS version to + generate platform tags for. The `arch` parameter is the CPU architecture to + generate platform tags for. Both parameters default to the appropriate value + for the current system. + """ + version_str, _, cpu_arch = platform.mac_ver() + if version is None: + version = cast("AppleVersion", tuple(map(int, version_str.split(".")[:2]))) + if version == (10, 16): + # When built against an older macOS SDK, Python will report macOS 10.16 + # instead of the real version. + version_str = subprocess.run( + [ + sys.executable, + "-sS", + "-c", + "import platform; print(platform.mac_ver()[0])", + ], + check=True, + env={"SYSTEM_VERSION_COMPAT": "0"}, + stdout=subprocess.PIPE, + text=True, + ).stdout + version = cast("AppleVersion", tuple(map(int, version_str.split(".")[:2]))) + + if arch is None: + arch = _mac_arch(cpu_arch) + + if (10, 0) <= version < (11, 0): + # Prior to Mac OS 11, each yearly release of Mac OS bumped the + # "minor" version number. The major version was always 10. + major_version = 10 + for minor_version in range(version[1], -1, -1): + compat_version = major_version, minor_version + binary_formats = _mac_binary_formats(compat_version, arch) + for binary_format in binary_formats: + yield f"macosx_{major_version}_{minor_version}_{binary_format}" + + if version >= (11, 0): + # Starting with Mac OS 11, each yearly release bumps the major version + # number. The minor versions are now the midyear updates. + minor_version = 0 + for major_version in range(version[0], 10, -1): + compat_version = major_version, minor_version + binary_formats = _mac_binary_formats(compat_version, arch) + for binary_format in binary_formats: + yield f"macosx_{major_version}_{minor_version}_{binary_format}" + + if version >= (11, 0): + # Mac OS 11 on x86_64 is compatible with binaries from previous releases. + # Arm64 support was introduced in 11.0, so no Arm binaries from previous + # releases exist. + # + # However, the "universal2" binary format can have a + # macOS version earlier than 11.0 when the x86_64 part of the binary supports + # that version of macOS. + major_version = 10 + if arch == "x86_64": + for minor_version in range(16, 3, -1): + compat_version = major_version, minor_version + binary_formats = _mac_binary_formats(compat_version, arch) + for binary_format in binary_formats: + yield f"macosx_{major_version}_{minor_version}_{binary_format}" + else: + for minor_version in range(16, 3, -1): + compat_version = major_version, minor_version + binary_format = "universal2" + yield f"macosx_{major_version}_{minor_version}_{binary_format}" + + +def ios_platforms( + version: AppleVersion | None = None, multiarch: str | None = None +) -> Iterator[str]: + """ + Yields the platform tags for an iOS system. + + :param version: A two-item tuple specifying the iOS version to generate + platform tags for. Defaults to the current iOS version. + :param multiarch: The CPU architecture+ABI to generate platform tags for - + (the value used by `sys.implementation._multiarch` e.g., + `arm64_iphoneos` or `x84_64_iphonesimulator`). Defaults to the current + multiarch value. + """ + if version is None: + # if iOS is the current platform, ios_ver *must* be defined. However, + # it won't exist for CPython versions before 3.13, which causes a mypy + # error. + _, release, _, _ = platform.ios_ver() # type: ignore[attr-defined, unused-ignore] + version = cast("AppleVersion", tuple(map(int, release.split(".")[:2]))) + + if multiarch is None: + multiarch = sys.implementation._multiarch + multiarch = multiarch.replace("-", "_") + + ios_platform_template = "ios_{major}_{minor}_{multiarch}" + + # Consider any iOS major.minor version from the version requested, down to + # 12.0. 12.0 is the first iOS version that is known to have enough features + # to support CPython. Consider every possible minor release up to X.9. There + # highest the minor has ever gone is 8 (14.8 and 15.8) but having some extra + # candidates that won't ever match doesn't really hurt, and it saves us from + # having to keep an explicit list of known iOS versions in the code. Return + # the results descending order of version number. + + # If the requested major version is less than 12, there won't be any matches. + if version[0] < 12: + return + + # Consider the actual X.Y version that was requested. + yield ios_platform_template.format( + major=version[0], minor=version[1], multiarch=multiarch + ) + + # Consider every minor version from X.0 to the minor version prior to the + # version requested by the platform. + for minor in range(version[1] - 1, -1, -1): + yield ios_platform_template.format( + major=version[0], minor=minor, multiarch=multiarch + ) + + for major in range(version[0] - 1, 11, -1): + for minor in range(9, -1, -1): + yield ios_platform_template.format( + major=major, minor=minor, multiarch=multiarch + ) + + +def android_platforms( + api_level: int | None = None, abi: str | None = None +) -> Iterator[str]: + """ + Yields the :attr:`~Tag.platform` tags for Android. If this function is invoked on + non-Android platforms, the ``api_level`` and ``abi`` arguments are required. + + :param int api_level: The maximum `API level + `__ to return. Defaults + to the current system's version, as returned by ``platform.android_ver``. + :param str abi: The `Android ABI `__, + e.g. ``arm64_v8a``. Defaults to the current system's ABI , as returned by + ``sysconfig.get_platform``. Hyphens and periods will be replaced with + underscores. + """ + if platform.system() != "Android" and (api_level is None or abi is None): + raise TypeError( + "on non-Android platforms, the api_level and abi arguments are required" + ) + + if api_level is None: + # Python 3.13 was the first version to return platform.system() == "Android", + # and also the first version to define platform.android_ver(). + api_level = platform.android_ver().api_level # type: ignore[attr-defined] + + if abi is None: + abi = sysconfig.get_platform().split("-")[-1] + abi = _normalize_string(abi) + + # 16 is the minimum API level known to have enough features to support CPython + # without major patching. Yield every API level from the maximum down to the + # minimum, inclusive. + min_api_level = 16 + for ver in range(api_level, min_api_level - 1, -1): + yield f"android_{ver}_{abi}" + + +def _linux_platforms(is_32bit: bool = _32_BIT_INTERPRETER) -> Iterator[str]: + linux = _normalize_string(sysconfig.get_platform()) + if not linux.startswith("linux_"): + # we should never be here, just yield the sysconfig one and return + yield linux + return + if is_32bit: + if linux == "linux_x86_64": + linux = "linux_i686" + elif linux == "linux_aarch64": + linux = "linux_armv8l" + _, arch = linux.split("_", 1) + archs = {"armv8l": ["armv8l", "armv7l"]}.get(arch, [arch]) + yield from _manylinux.platform_tags(archs) + yield from _musllinux.platform_tags(archs) + for arch in archs: + yield f"linux_{arch}" + + +def _generic_platforms() -> Iterator[str]: + yield _normalize_string(sysconfig.get_platform()) + + +def platform_tags() -> Iterator[str]: + """ + Provides the platform tags for this installation. + """ + if platform.system() == "Darwin": + return mac_platforms() + elif platform.system() == "iOS": + return ios_platforms() + elif platform.system() == "Android": + return android_platforms() + elif platform.system() == "Linux": + return _linux_platforms() + else: + return _generic_platforms() + + +def interpreter_name() -> str: + """ + Returns the name of the running interpreter. + + Some implementations have a reserved, two-letter abbreviation which will + be returned when appropriate. + """ + name = sys.implementation.name + return INTERPRETER_SHORT_NAMES.get(name) or name + + +def interpreter_version(*, warn: bool = False) -> str: + """ + Returns the version of the running interpreter. + """ + version = _get_config_var("py_version_nodot", warn=warn) + return str(version) if version else _version_nodot(sys.version_info[:2]) + + +def _version_nodot(version: PythonVersion) -> str: + return "".join(map(str, version)) + + +def sys_tags(*, warn: bool = False) -> Iterator[Tag]: + """ + Returns the sequence of tag triples for the running interpreter. + + The order of the sequence corresponds to priority order for the + interpreter, from most to least important. + """ + + interp_name = interpreter_name() + if interp_name == "cp": + yield from cpython_tags(warn=warn) + else: + yield from generic_tags() + + if interp_name == "pp": + interp = "pp3" + elif interp_name == "cp": + interp = "cp" + interpreter_version(warn=warn) + else: + interp = None + yield from compatible_tags(interpreter=interp) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/utils.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..c41c8137f2679a0fac21bb845596e231ae88dbd8 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/utils.py @@ -0,0 +1,158 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import annotations + +import re +from typing import NewType, Tuple, Union, cast + +from .tags import Tag, parse_tag +from .version import InvalidVersion, Version, _TrimmedRelease + +BuildTag = Union[Tuple[()], Tuple[int, str]] +NormalizedName = NewType("NormalizedName", str) + + +class InvalidName(ValueError): + """ + An invalid distribution name; users should refer to the packaging user guide. + """ + + +class InvalidWheelFilename(ValueError): + """ + An invalid wheel filename was found, users should refer to PEP 427. + """ + + +class InvalidSdistFilename(ValueError): + """ + An invalid sdist filename was found, users should refer to the packaging user guide. + """ + + +# Core metadata spec for `Name` +_validate_regex = re.compile(r"[A-Z0-9]|[A-Z0-9][A-Z0-9._-]*[A-Z0-9]", re.IGNORECASE) +_normalized_regex = re.compile(r"[a-z0-9]|[a-z0-9]([a-z0-9-](?!--))*[a-z0-9]") +# PEP 427: The build number must start with a digit. +_build_tag_regex = re.compile(r"(\d+)(.*)") + + +def canonicalize_name(name: str, *, validate: bool = False) -> NormalizedName: + if validate and not _validate_regex.fullmatch(name): + raise InvalidName(f"name is invalid: {name!r}") + # Ensure all ``.`` and ``_`` are ``-`` + # Emulates ``re.sub(r"[-_.]+", "-", name).lower()`` from PEP 503 + # Much faster than re, and even faster than str.translate + value = name.lower().replace("_", "-").replace(".", "-") + # Condense repeats (faster than regex) + while "--" in value: + value = value.replace("--", "-") + return cast("NormalizedName", value) + + +def is_normalized_name(name: str) -> bool: + return _normalized_regex.fullmatch(name) is not None + + +def canonicalize_version( + version: Version | str, *, strip_trailing_zero: bool = True +) -> str: + """ + Return a canonical form of a version as a string. + + >>> canonicalize_version('1.0.1') + '1.0.1' + + Per PEP 625, versions may have multiple canonical forms, differing + only by trailing zeros. + + >>> canonicalize_version('1.0.0') + '1' + >>> canonicalize_version('1.0.0', strip_trailing_zero=False) + '1.0.0' + + Invalid versions are returned unaltered. + + >>> canonicalize_version('foo bar baz') + 'foo bar baz' + """ + if isinstance(version, str): + try: + version = Version(version) + except InvalidVersion: + return str(version) + return str(_TrimmedRelease(version) if strip_trailing_zero else version) + + +def parse_wheel_filename( + filename: str, +) -> tuple[NormalizedName, Version, BuildTag, frozenset[Tag]]: + if not filename.endswith(".whl"): + raise InvalidWheelFilename( + f"Invalid wheel filename (extension must be '.whl'): {filename!r}" + ) + + filename = filename[:-4] + dashes = filename.count("-") + if dashes not in (4, 5): + raise InvalidWheelFilename( + f"Invalid wheel filename (wrong number of parts): {filename!r}" + ) + + parts = filename.split("-", dashes - 2) + name_part = parts[0] + # See PEP 427 for the rules on escaping the project name. + if "__" in name_part or re.match(r"^[\w\d._]*$", name_part, re.UNICODE) is None: + raise InvalidWheelFilename(f"Invalid project name: {filename!r}") + name = canonicalize_name(name_part) + + try: + version = Version(parts[1]) + except InvalidVersion as e: + raise InvalidWheelFilename( + f"Invalid wheel filename (invalid version): {filename!r}" + ) from e + + if dashes == 5: + build_part = parts[2] + build_match = _build_tag_regex.match(build_part) + if build_match is None: + raise InvalidWheelFilename( + f"Invalid build number: {build_part} in {filename!r}" + ) + build = cast("BuildTag", (int(build_match.group(1)), build_match.group(2))) + else: + build = () + tags = parse_tag(parts[-1]) + return (name, version, build, tags) + + +def parse_sdist_filename(filename: str) -> tuple[NormalizedName, Version]: + if filename.endswith(".tar.gz"): + file_stem = filename[: -len(".tar.gz")] + elif filename.endswith(".zip"): + file_stem = filename[: -len(".zip")] + else: + raise InvalidSdistFilename( + f"Invalid sdist filename (extension must be '.tar.gz' or '.zip'):" + f" {filename!r}" + ) + + # We are requiring a PEP 440 version, which cannot contain dashes, + # so we split on the last dash. + name_part, sep, version_part = file_stem.rpartition("-") + if not sep: + raise InvalidSdistFilename(f"Invalid sdist filename: {filename!r}") + + name = canonicalize_name(name_part) + + try: + version = Version(version_part) + except InvalidVersion as e: + raise InvalidSdistFilename( + f"Invalid sdist filename (invalid version): {filename!r}" + ) from e + + return (name, version) diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/version.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/version.py new file mode 100644 index 0000000000000000000000000000000000000000..1206c462d4fcaa670a816e201bb88b27dfc9cf88 --- /dev/null +++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/packaging/version.py @@ -0,0 +1,792 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. +""" +.. testsetup:: + + from packaging.version import parse, Version +""" + +from __future__ import annotations + +import re +import sys +import typing +from typing import ( + Any, + Callable, + Literal, + NamedTuple, + SupportsInt, + Tuple, + TypedDict, + Union, +) + +from ._structures import Infinity, InfinityType, NegativeInfinity, NegativeInfinityType + +if typing.TYPE_CHECKING: + from typing_extensions import Self, Unpack + +if sys.version_info >= (3, 13): # pragma: no cover + from warnings import deprecated as _deprecated +elif typing.TYPE_CHECKING: + from typing_extensions import deprecated as _deprecated +else: # pragma: no cover + import functools + import warnings + + def _deprecated(message: str) -> object: + def decorator(func: object) -> object: + @functools.wraps(func) + def wrapper(*args: object, **kwargs: object) -> object: + warnings.warn( + message, + category=DeprecationWarning, + stacklevel=2, + ) + return func(*args, **kwargs) + + return wrapper + + return decorator + + +_LETTER_NORMALIZATION = { + "alpha": "a", + "beta": "b", + "c": "rc", + "pre": "rc", + "preview": "rc", + "rev": "post", + "r": "post", +} + +__all__ = ["VERSION_PATTERN", "InvalidVersion", "Version", "parse"] + +LocalType = Tuple[Union[int, str], ...] + +CmpPrePostDevType = Union[InfinityType, NegativeInfinityType, Tuple[str, int]] +CmpLocalType = Union[ + NegativeInfinityType, + Tuple[Union[Tuple[int, str], Tuple[NegativeInfinityType, Union[int, str]]], ...], +] +CmpKey = Tuple[ + int, + Tuple[int, ...], + CmpPrePostDevType, + CmpPrePostDevType, + CmpPrePostDevType, + CmpLocalType, +] +VersionComparisonMethod = Callable[[CmpKey, CmpKey], bool] + + +class _VersionReplace(TypedDict, total=False): + epoch: int | None + release: tuple[int, ...] | None + pre: tuple[Literal["a", "b", "rc"], int] | None + post: int | None + dev: int | None + local: str | None + + +def parse(version: str) -> Version: + """Parse the given version string. + + >>> parse('1.0.dev1') + + + :param version: The version string to parse. + :raises InvalidVersion: When the version string is not a valid version. + """ + return Version(version) + + +class InvalidVersion(ValueError): + """Raised when a version string is not a valid version. + + >>> Version("invalid") + Traceback (most recent call last): + ... + packaging.version.InvalidVersion: Invalid version: 'invalid' + """ + + +class _BaseVersion: + __slots__ = () + + # This can also be a normal member (see the packaging_legacy package); + # we are just requiring it to be readable. Actually defining a property + # has runtime effect on subclasses, so it's typing only. + if typing.TYPE_CHECKING: + + @property + def _key(self) -> tuple[Any, ...]: ... + + def __hash__(self) -> int: + return hash(self._key) + + # Please keep the duplicated `isinstance` check + # in the six comparisons hereunder + # unless you find a way to avoid adding overhead function calls. + def __lt__(self, other: _BaseVersion) -> bool: + if not isinstance(other, _BaseVersion): + return NotImplemented + + return self._key < other._key + + def __le__(self, other: _BaseVersion) -> bool: + if not isinstance(other, _BaseVersion): + return NotImplemented + + return self._key <= other._key + + def __eq__(self, other: object) -> bool: + if not isinstance(other, _BaseVersion): + return NotImplemented + + return self._key == other._key + + def __ge__(self, other: _BaseVersion) -> bool: + if not isinstance(other, _BaseVersion): + return NotImplemented + + return self._key >= other._key + + def __gt__(self, other: _BaseVersion) -> bool: + if not isinstance(other, _BaseVersion): + return NotImplemented + + return self._key > other._key + + def __ne__(self, other: object) -> bool: + if not isinstance(other, _BaseVersion): + return NotImplemented + + return self._key != other._key + + +# Deliberately not anchored to the start and end of the string, to make it +# easier for 3rd party code to reuse + +# Note that ++ doesn't behave identically on CPython and PyPy, so not using it here +_VERSION_PATTERN = r""" + v?+ # optional leading v + (?: + (?:(?P[0-9]+)!)?+ # epoch + (?P[0-9]+(?:\.[0-9]+)*+) # release segment + (?P
                                              # pre-release
+            [._-]?+
+            (?Palpha|a|beta|b|preview|pre|c|rc)
+            [._-]?+
+            (?P[0-9]+)?
+        )?+
+        (?P                                         # post release
+            (?:-(?P[0-9]+))
+            |
+            (?:
+                [._-]?
+                (?Ppost|rev|r)
+                [._-]?
+                (?P[0-9]+)?
+            )
+        )?+
+        (?P                                          # dev release
+            [._-]?+
+            (?Pdev)
+            [._-]?+
+            (?P[0-9]+)?
+        )?+
+    )
+    (?:\+
+        (?P                                        # local version
+            [a-z0-9]+
+            (?:[._-][a-z0-9]+)*+
+        )
+    )?+
+"""
+
+_VERSION_PATTERN_OLD = _VERSION_PATTERN.replace("*+", "*").replace("?+", "?")
+
+# Possessive qualifiers were added in Python 3.11.
+# CPython 3.11.0-3.11.4 had a bug: https://github.com/python/cpython/pull/107795
+# Older PyPy also had a bug.
+VERSION_PATTERN = (
+    _VERSION_PATTERN_OLD
+    if (sys.implementation.name == "cpython" and sys.version_info < (3, 11, 5))
+    or (sys.implementation.name == "pypy" and sys.version_info < (3, 11, 13))
+    or sys.version_info < (3, 11)
+    else _VERSION_PATTERN
+)
+"""
+A string containing the regular expression used to match a valid version.
+
+The pattern is not anchored at either end, and is intended for embedding in larger
+expressions (for example, matching a version number as part of a file name). The
+regular expression should be compiled with the ``re.VERBOSE`` and ``re.IGNORECASE``
+flags set.
+
+:meta hide-value:
+"""
+
+
+# Validation pattern for local version in replace()
+_LOCAL_PATTERN = re.compile(r"[a-z0-9]+(?:[._-][a-z0-9]+)*", re.IGNORECASE)
+
+
+def _validate_epoch(value: object, /) -> int:
+    epoch = value or 0
+    if isinstance(epoch, int) and epoch >= 0:
+        return epoch
+    msg = f"epoch must be non-negative integer, got {epoch}"
+    raise InvalidVersion(msg)
+
+
+def _validate_release(value: object, /) -> tuple[int, ...]:
+    release = (0,) if value is None else value
+    if (
+        isinstance(release, tuple)
+        and len(release) > 0
+        and all(isinstance(i, int) and i >= 0 for i in release)
+    ):
+        return release
+    msg = f"release must be a non-empty tuple of non-negative integers, got {release}"
+    raise InvalidVersion(msg)
+
+
+def _validate_pre(value: object, /) -> tuple[Literal["a", "b", "rc"], int] | None:
+    if value is None:
+        return value
+    if (
+        isinstance(value, tuple)
+        and len(value) == 2
+        and value[0] in ("a", "b", "rc")
+        and isinstance(value[1], int)
+        and value[1] >= 0
+    ):
+        return value
+    msg = f"pre must be a tuple of ('a'|'b'|'rc', non-negative int), got {value}"
+    raise InvalidVersion(msg)
+
+
+def _validate_post(value: object, /) -> tuple[Literal["post"], int] | None:
+    if value is None:
+        return value
+    if isinstance(value, int) and value >= 0:
+        return ("post", value)
+    msg = f"post must be non-negative integer, got {value}"
+    raise InvalidVersion(msg)
+
+
+def _validate_dev(value: object, /) -> tuple[Literal["dev"], int] | None:
+    if value is None:
+        return value
+    if isinstance(value, int) and value >= 0:
+        return ("dev", value)
+    msg = f"dev must be non-negative integer, got {value}"
+    raise InvalidVersion(msg)
+
+
+def _validate_local(value: object, /) -> LocalType | None:
+    if value is None:
+        return value
+    if isinstance(value, str) and _LOCAL_PATTERN.fullmatch(value):
+        return _parse_local_version(value)
+    msg = f"local must be a valid version string, got {value!r}"
+    raise InvalidVersion(msg)
+
+
+# Backward compatibility for internals before 26.0. Do not use.
+class _Version(NamedTuple):
+    epoch: int
+    release: tuple[int, ...]
+    dev: tuple[str, int] | None
+    pre: tuple[str, int] | None
+    post: tuple[str, int] | None
+    local: LocalType | None
+
+
+class Version(_BaseVersion):
+    """This class abstracts handling of a project's versions.
+
+    A :class:`Version` instance is comparison aware and can be compared and
+    sorted using the standard Python interfaces.
+
+    >>> v1 = Version("1.0a5")
+    >>> v2 = Version("1.0")
+    >>> v1
+    
+    >>> v2
+    
+    >>> v1 < v2
+    True
+    >>> v1 == v2
+    False
+    >>> v1 > v2
+    False
+    >>> v1 >= v2
+    False
+    >>> v1 <= v2
+    True
+    """
+
+    __slots__ = ("_dev", "_epoch", "_key_cache", "_local", "_post", "_pre", "_release")
+    __match_args__ = ("_str",)
+
+    _regex = re.compile(r"\s*" + VERSION_PATTERN + r"\s*", re.VERBOSE | re.IGNORECASE)
+
+    _epoch: int
+    _release: tuple[int, ...]
+    _dev: tuple[str, int] | None
+    _pre: tuple[str, int] | None
+    _post: tuple[str, int] | None
+    _local: LocalType | None
+
+    _key_cache: CmpKey | None
+
+    def __init__(self, version: str) -> None:
+        """Initialize a Version object.
+
+        :param version:
+            The string representation of a version which will be parsed and normalized
+            before use.
+        :raises InvalidVersion:
+            If the ``version`` does not conform to PEP 440 in any way then this
+            exception will be raised.
+        """
+        # Validate the version and parse it into pieces
+        match = self._regex.fullmatch(version)
+        if not match:
+            raise InvalidVersion(f"Invalid version: {version!r}")
+        self._epoch = int(match.group("epoch")) if match.group("epoch") else 0
+        self._release = tuple(map(int, match.group("release").split(".")))
+        self._pre = _parse_letter_version(match.group("pre_l"), match.group("pre_n"))
+        self._post = _parse_letter_version(
+            match.group("post_l"), match.group("post_n1") or match.group("post_n2")
+        )
+        self._dev = _parse_letter_version(match.group("dev_l"), match.group("dev_n"))
+        self._local = _parse_local_version(match.group("local"))
+
+        # Key which will be used for sorting
+        self._key_cache = None
+
+    def __replace__(self, **kwargs: Unpack[_VersionReplace]) -> Self:
+        epoch = _validate_epoch(kwargs["epoch"]) if "epoch" in kwargs else self._epoch
+        release = (
+            _validate_release(kwargs["release"])
+            if "release" in kwargs
+            else self._release
+        )
+        pre = _validate_pre(kwargs["pre"]) if "pre" in kwargs else self._pre
+        post = _validate_post(kwargs["post"]) if "post" in kwargs else self._post
+        dev = _validate_dev(kwargs["dev"]) if "dev" in kwargs else self._dev
+        local = _validate_local(kwargs["local"]) if "local" in kwargs else self._local
+
+        if (
+            epoch == self._epoch
+            and release == self._release
+            and pre == self._pre
+            and post == self._post
+            and dev == self._dev
+            and local == self._local
+        ):
+            return self
+
+        new_version = self.__class__.__new__(self.__class__)
+        new_version._key_cache = None
+        new_version._epoch = epoch
+        new_version._release = release
+        new_version._pre = pre
+        new_version._post = post
+        new_version._dev = dev
+        new_version._local = local
+
+        return new_version
+
+    @property
+    def _key(self) -> CmpKey:
+        if self._key_cache is None:
+            self._key_cache = _cmpkey(
+                self._epoch,
+                self._release,
+                self._pre,
+                self._post,
+                self._dev,
+                self._local,
+            )
+        return self._key_cache
+
+    @property
+    @_deprecated("Version._version is private and will be removed soon")
+    def _version(self) -> _Version:
+        return _Version(
+            self._epoch, self._release, self._dev, self._pre, self._post, self._local
+        )
+
+    @_version.setter
+    @_deprecated("Version._version is private and will be removed soon")
+    def _version(self, value: _Version) -> None:
+        self._epoch = value.epoch
+        self._release = value.release
+        self._dev = value.dev
+        self._pre = value.pre
+        self._post = value.post
+        self._local = value.local
+        self._key_cache = None
+
+    def __repr__(self) -> str:
+        """A representation of the Version that shows all internal state.
+
+        >>> Version('1.0.0')
+        
+        """
+        return f""
+
+    def __str__(self) -> str:
+        """A string representation of the version that can be round-tripped.
+
+        >>> str(Version("1.0a5"))
+        '1.0a5'
+        """
+        # This is a hot function, so not calling self.base_version
+        version = ".".join(map(str, self.release))
+
+        # Epoch
+        if self.epoch:
+            version = f"{self.epoch}!{version}"
+
+        # Pre-release
+        if self.pre is not None:
+            version += "".join(map(str, self.pre))
+
+        # Post-release
+        if self.post is not None:
+            version += f".post{self.post}"
+
+        # Development release
+        if self.dev is not None:
+            version += f".dev{self.dev}"
+
+        # Local version segment
+        if self.local is not None:
+            version += f"+{self.local}"
+
+        return version
+
+    @property
+    def _str(self) -> str:
+        """Internal property for match_args"""
+        return str(self)
+
+    @property
+    def epoch(self) -> int:
+        """The epoch of the version.
+
+        >>> Version("2.0.0").epoch
+        0
+        >>> Version("1!2.0.0").epoch
+        1
+        """
+        return self._epoch
+
+    @property
+    def release(self) -> tuple[int, ...]:
+        """The components of the "release" segment of the version.
+
+        >>> Version("1.2.3").release
+        (1, 2, 3)
+        >>> Version("2.0.0").release
+        (2, 0, 0)
+        >>> Version("1!2.0.0.post0").release
+        (2, 0, 0)
+
+        Includes trailing zeroes but not the epoch or any pre-release / development /
+        post-release suffixes.
+        """
+        return self._release
+
+    @property
+    def pre(self) -> tuple[str, int] | None:
+        """The pre-release segment of the version.
+
+        >>> print(Version("1.2.3").pre)
+        None
+        >>> Version("1.2.3a1").pre
+        ('a', 1)
+        >>> Version("1.2.3b1").pre
+        ('b', 1)
+        >>> Version("1.2.3rc1").pre
+        ('rc', 1)
+        """
+        return self._pre
+
+    @property
+    def post(self) -> int | None:
+        """The post-release number of the version.
+
+        >>> print(Version("1.2.3").post)
+        None
+        >>> Version("1.2.3.post1").post
+        1
+        """
+        return self._post[1] if self._post else None
+
+    @property
+    def dev(self) -> int | None:
+        """The development number of the version.
+
+        >>> print(Version("1.2.3").dev)
+        None
+        >>> Version("1.2.3.dev1").dev
+        1
+        """
+        return self._dev[1] if self._dev else None
+
+    @property
+    def local(self) -> str | None:
+        """The local version segment of the version.
+
+        >>> print(Version("1.2.3").local)
+        None
+        >>> Version("1.2.3+abc").local
+        'abc'
+        """
+        if self._local:
+            return ".".join(str(x) for x in self._local)
+        else:
+            return None
+
+    @property
+    def public(self) -> str:
+        """The public portion of the version.
+
+        >>> Version("1.2.3").public
+        '1.2.3'
+        >>> Version("1.2.3+abc").public
+        '1.2.3'
+        >>> Version("1!1.2.3dev1+abc").public
+        '1!1.2.3.dev1'
+        """
+        return str(self).split("+", 1)[0]
+
+    @property
+    def base_version(self) -> str:
+        """The "base version" of the version.
+
+        >>> Version("1.2.3").base_version
+        '1.2.3'
+        >>> Version("1.2.3+abc").base_version
+        '1.2.3'
+        >>> Version("1!1.2.3dev1+abc").base_version
+        '1!1.2.3'
+
+        The "base version" is the public version of the project without any pre or post
+        release markers.
+        """
+        release_segment = ".".join(map(str, self.release))
+        return f"{self.epoch}!{release_segment}" if self.epoch else release_segment
+
+    @property
+    def is_prerelease(self) -> bool:
+        """Whether this version is a pre-release.
+
+        >>> Version("1.2.3").is_prerelease
+        False
+        >>> Version("1.2.3a1").is_prerelease
+        True
+        >>> Version("1.2.3b1").is_prerelease
+        True
+        >>> Version("1.2.3rc1").is_prerelease
+        True
+        >>> Version("1.2.3dev1").is_prerelease
+        True
+        """
+        return self.dev is not None or self.pre is not None
+
+    @property
+    def is_postrelease(self) -> bool:
+        """Whether this version is a post-release.
+
+        >>> Version("1.2.3").is_postrelease
+        False
+        >>> Version("1.2.3.post1").is_postrelease
+        True
+        """
+        return self.post is not None
+
+    @property
+    def is_devrelease(self) -> bool:
+        """Whether this version is a development release.
+
+        >>> Version("1.2.3").is_devrelease
+        False
+        >>> Version("1.2.3.dev1").is_devrelease
+        True
+        """
+        return self.dev is not None
+
+    @property
+    def major(self) -> int:
+        """The first item of :attr:`release` or ``0`` if unavailable.
+
+        >>> Version("1.2.3").major
+        1
+        """
+        return self.release[0] if len(self.release) >= 1 else 0
+
+    @property
+    def minor(self) -> int:
+        """The second item of :attr:`release` or ``0`` if unavailable.
+
+        >>> Version("1.2.3").minor
+        2
+        >>> Version("1").minor
+        0
+        """
+        return self.release[1] if len(self.release) >= 2 else 0
+
+    @property
+    def micro(self) -> int:
+        """The third item of :attr:`release` or ``0`` if unavailable.
+
+        >>> Version("1.2.3").micro
+        3
+        >>> Version("1").micro
+        0
+        """
+        return self.release[2] if len(self.release) >= 3 else 0
+
+
+class _TrimmedRelease(Version):
+    __slots__ = ()
+
+    def __init__(self, version: str | Version) -> None:
+        if isinstance(version, Version):
+            self._epoch = version._epoch
+            self._release = version._release
+            self._dev = version._dev
+            self._pre = version._pre
+            self._post = version._post
+            self._local = version._local
+            self._key_cache = version._key_cache
+            return
+        super().__init__(version)  # pragma: no cover
+
+    @property
+    def release(self) -> tuple[int, ...]:
+        """
+        Release segment without any trailing zeros.
+
+        >>> _TrimmedRelease('1.0.0').release
+        (1,)
+        >>> _TrimmedRelease('0.0').release
+        (0,)
+        """
+        # This leaves one 0.
+        rel = super().release
+        len_release = len(rel)
+        i = len_release
+        while i > 1 and rel[i - 1] == 0:
+            i -= 1
+        return rel if i == len_release else rel[:i]
+
+
+def _parse_letter_version(
+    letter: str | None, number: str | bytes | SupportsInt | None
+) -> tuple[str, int] | None:
+    if letter:
+        # We normalize any letters to their lower case form
+        letter = letter.lower()
+
+        # We consider some words to be alternate spellings of other words and
+        # in those cases we want to normalize the spellings to our preferred
+        # spelling.
+        letter = _LETTER_NORMALIZATION.get(letter, letter)
+
+        # We consider there to be an implicit 0 in a pre-release if there is
+        # not a numeral associated with it.
+        return letter, int(number or 0)
+
+    if number:
+        # We assume if we are given a number, but we are not given a letter
+        # then this is using the implicit post release syntax (e.g. 1.0-1)
+        return "post", int(number)
+
+    return None
+
+
+_local_version_separators = re.compile(r"[\._-]")
+
+
+def _parse_local_version(local: str | None) -> LocalType | None:
+    """
+    Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").
+    """
+    if local is not None:
+        return tuple(
+            part.lower() if not part.isdigit() else int(part)
+            for part in _local_version_separators.split(local)
+        )
+    return None
+
+
+def _cmpkey(
+    epoch: int,
+    release: tuple[int, ...],
+    pre: tuple[str, int] | None,
+    post: tuple[str, int] | None,
+    dev: tuple[str, int] | None,
+    local: LocalType | None,
+) -> CmpKey:
+    # When we compare a release version, we want to compare it with all of the
+    # trailing zeros removed. We will use this for our sorting key.
+    len_release = len(release)
+    i = len_release
+    while i and release[i - 1] == 0:
+        i -= 1
+    _release = release if i == len_release else release[:i]
+
+    # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0.
+    # We'll do this by abusing the pre segment, but we _only_ want to do this
+    # if there is not a pre or a post segment. If we have one of those then
+    # the normal sorting rules will handle this case correctly.
+    if pre is None and post is None and dev is not None:
+        _pre: CmpPrePostDevType = NegativeInfinity
+    # Versions without a pre-release (except as noted above) should sort after
+    # those with one.
+    elif pre is None:
+        _pre = Infinity
+    else:
+        _pre = pre
+
+    # Versions without a post segment should sort before those with one.
+    if post is None:
+        _post: CmpPrePostDevType = NegativeInfinity
+
+    else:
+        _post = post
+
+    # Versions without a development segment should sort after those with one.
+    if dev is None:
+        _dev: CmpPrePostDevType = Infinity
+
+    else:
+        _dev = dev
+
+    if local is None:
+        # Versions without a local segment should sort before those with one.
+        _local: CmpLocalType = NegativeInfinity
+    else:
+        # Versions with a local segment need that segment parsed to implement
+        # the sorting rules in PEP440.
+        # - Alpha numeric segments sort before numeric segments
+        # - Alpha numeric segments sort lexicographically
+        # - Numeric segments sort numerically
+        # - Shorter versions sort before longer versions when the prefixes
+        #   match exactly
+        _local = tuple(
+            (i, "") if isinstance(i, int) else (NegativeInfinity, i) for i in local
+        )
+
+    return epoch, _release, _pre, _post, _dev, _local
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs-4.4.0.dist-info/INSTALLER b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs-4.4.0.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..5c69047b2eb8235994febeeae1da4a82365a240a
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs-4.4.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+uv
\ No newline at end of file
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs-4.4.0.dist-info/METADATA b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs-4.4.0.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..6b0908fb707440b3828bfe2edb1799382693199e
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs-4.4.0.dist-info/METADATA
@@ -0,0 +1,350 @@
+Metadata-Version: 2.4
+Name: platformdirs
+Version: 4.4.0
+Summary: A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`.
+Project-URL: Changelog, https://github.com/tox-dev/platformdirs/releases
+Project-URL: Documentation, https://platformdirs.readthedocs.io
+Project-URL: Homepage, https://github.com/tox-dev/platformdirs
+Project-URL: Source, https://github.com/tox-dev/platformdirs
+Project-URL: Tracker, https://github.com/tox-dev/platformdirs/issues
+Maintainer-email: Bernát Gábor , Julian Berman , Ofek Lev , Ronny Pfannschmidt 
+License-Expression: MIT
+License-File: LICENSE
+Keywords: appdirs,application,cache,directory,log,user
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Provides-Extra: docs
+Requires-Dist: furo>=2024.8.6; extra == 'docs'
+Requires-Dist: proselint>=0.14; extra == 'docs'
+Requires-Dist: sphinx-autodoc-typehints>=3; extra == 'docs'
+Requires-Dist: sphinx>=8.1.3; extra == 'docs'
+Provides-Extra: test
+Requires-Dist: appdirs==1.4.4; extra == 'test'
+Requires-Dist: covdefaults>=2.3; extra == 'test'
+Requires-Dist: pytest-cov>=6; extra == 'test'
+Requires-Dist: pytest-mock>=3.14; extra == 'test'
+Requires-Dist: pytest>=8.3.4; extra == 'test'
+Provides-Extra: type
+Requires-Dist: mypy>=1.14.1; extra == 'type'
+Description-Content-Type: text/x-rst
+
+The problem
+===========
+
+.. image:: https://badge.fury.io/py/platformdirs.svg
+   :target: https://badge.fury.io/py/platformdirs
+.. image:: https://img.shields.io/pypi/pyversions/platformdirs.svg
+   :target: https://pypi.python.org/pypi/platformdirs/
+.. image:: https://github.com/tox-dev/platformdirs/actions/workflows/check.yaml/badge.svg
+   :target: https://github.com/platformdirs/platformdirs/actions
+.. image:: https://static.pepy.tech/badge/platformdirs/month
+   :target: https://pepy.tech/project/platformdirs
+
+When writing desktop application, finding the right location to store user data
+and configuration varies per platform. Even for single-platform apps, there
+may by plenty of nuances in figuring out the right location.
+
+For example, if running on macOS, you should use::
+
+    ~/Library/Application Support/
+
+If on Windows (at least English Win) that should be::
+
+    C:\Documents and Settings\\Application Data\Local Settings\\
+
+or possibly::
+
+    C:\Documents and Settings\\Application Data\\
+
+for `roaming profiles `_ but that is another story.
+
+On Linux (and other Unices), according to the `XDG Basedir Spec`_, it should be::
+
+    ~/.local/share/
+
+.. _XDG Basedir Spec: https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
+
+``platformdirs`` to the rescue
+==============================
+
+This kind of thing is what the ``platformdirs`` package is for.
+``platformdirs`` will help you choose an appropriate:
+
+- user data dir (``user_data_dir``)
+- user config dir (``user_config_dir``)
+- user cache dir (``user_cache_dir``)
+- site data dir (``site_data_dir``)
+- site config dir (``site_config_dir``)
+- user log dir (``user_log_dir``)
+- user documents dir (``user_documents_dir``)
+- user downloads dir (``user_downloads_dir``)
+- user pictures dir (``user_pictures_dir``)
+- user videos dir (``user_videos_dir``)
+- user music dir (``user_music_dir``)
+- user desktop dir (``user_desktop_dir``)
+- user runtime dir (``user_runtime_dir``)
+
+And also:
+
+- Is slightly opinionated on the directory names used. Look for "OPINION" in
+  documentation and code for when an opinion is being applied.
+
+Example output
+==============
+
+On macOS:
+
+.. code-block:: pycon
+
+    >>> from platformdirs import *
+    >>> appname = "SuperApp"
+    >>> appauthor = "Acme"
+    >>> user_data_dir(appname, appauthor)
+    '/Users/trentm/Library/Application Support/SuperApp'
+    >>> user_config_dir(appname, appauthor)
+    '/Users/trentm/Library/Application Support/SuperApp'
+    >>> user_cache_dir(appname, appauthor)
+    '/Users/trentm/Library/Caches/SuperApp'
+    >>> site_data_dir(appname, appauthor)
+    '/Library/Application Support/SuperApp'
+    >>> site_config_dir(appname, appauthor)
+    '/Library/Application Support/SuperApp'
+    >>> user_log_dir(appname, appauthor)
+    '/Users/trentm/Library/Logs/SuperApp'
+    >>> user_documents_dir()
+    '/Users/trentm/Documents'
+    >>> user_downloads_dir()
+    '/Users/trentm/Downloads'
+    >>> user_pictures_dir()
+    '/Users/trentm/Pictures'
+    >>> user_videos_dir()
+    '/Users/trentm/Movies'
+    >>> user_music_dir()
+    '/Users/trentm/Music'
+    >>> user_desktop_dir()
+    '/Users/trentm/Desktop'
+    >>> user_runtime_dir(appname, appauthor)
+    '/Users/trentm/Library/Caches/TemporaryItems/SuperApp'
+
+On Windows:
+
+.. code-block:: pycon
+
+    >>> from platformdirs import *
+    >>> appname = "SuperApp"
+    >>> appauthor = "Acme"
+    >>> user_data_dir(appname, appauthor)
+    'C:\\Users\\trentm\\AppData\\Local\\Acme\\SuperApp'
+    >>> user_data_dir(appname, appauthor, roaming=True)
+    'C:\\Users\\trentm\\AppData\\Roaming\\Acme\\SuperApp'
+    >>> user_config_dir(appname, appauthor)
+    'C:\\Users\\trentm\\AppData\\Local\\Acme\\SuperApp'
+    >>> user_cache_dir(appname, appauthor)
+    'C:\\Users\\trentm\\AppData\\Local\\Acme\\SuperApp\\Cache'
+    >>> site_data_dir(appname, appauthor)
+    'C:\\ProgramData\\Acme\\SuperApp'
+    >>> site_config_dir(appname, appauthor)
+    'C:\\ProgramData\\Acme\\SuperApp'
+    >>> user_log_dir(appname, appauthor)
+    'C:\\Users\\trentm\\AppData\\Local\\Acme\\SuperApp\\Logs'
+    >>> user_documents_dir()
+    'C:\\Users\\trentm\\Documents'
+    >>> user_downloads_dir()
+    'C:\\Users\\trentm\\Downloads'
+    >>> user_pictures_dir()
+    'C:\\Users\\trentm\\Pictures'
+    >>> user_videos_dir()
+    'C:\\Users\\trentm\\Videos'
+    >>> user_music_dir()
+    'C:\\Users\\trentm\\Music'
+    >>> user_desktop_dir()
+    'C:\\Users\\trentm\\Desktop'
+    >>> user_runtime_dir(appname, appauthor)
+    'C:\\Users\\trentm\\AppData\\Local\\Temp\\Acme\\SuperApp'
+
+On Linux:
+
+.. code-block:: pycon
+
+    >>> from platformdirs import *
+    >>> appname = "SuperApp"
+    >>> appauthor = "Acme"
+    >>> user_data_dir(appname, appauthor)
+    '/home/trentm/.local/share/SuperApp'
+    >>> user_config_dir(appname)
+    '/home/trentm/.config/SuperApp'
+    >>> user_cache_dir(appname, appauthor)
+    '/home/trentm/.cache/SuperApp'
+    >>> site_data_dir(appname, appauthor)
+    '/usr/local/share/SuperApp'
+    >>> site_data_dir(appname, appauthor, multipath=True)
+    '/usr/local/share/SuperApp:/usr/share/SuperApp'
+    >>> site_config_dir(appname)
+    '/etc/xdg/SuperApp'
+    >>> os.environ["XDG_CONFIG_DIRS"] = "/etc:/usr/local/etc"
+    >>> site_config_dir(appname, multipath=True)
+    '/etc/SuperApp:/usr/local/etc/SuperApp'
+    >>> user_log_dir(appname, appauthor)
+    '/home/trentm/.local/state/SuperApp/log'
+    >>> user_documents_dir()
+    '/home/trentm/Documents'
+    >>> user_downloads_dir()
+    '/home/trentm/Downloads'
+    >>> user_pictures_dir()
+    '/home/trentm/Pictures'
+    >>> user_videos_dir()
+    '/home/trentm/Videos'
+    >>> user_music_dir()
+    '/home/trentm/Music'
+    >>> user_desktop_dir()
+    '/home/trentm/Desktop'
+    >>> user_runtime_dir(appname, appauthor)
+    '/run/user/{os.getuid()}/SuperApp'
+
+On Android::
+
+    >>> from platformdirs import *
+    >>> appname = "SuperApp"
+    >>> appauthor = "Acme"
+    >>> user_data_dir(appname, appauthor)
+    '/data/data/com.myApp/files/SuperApp'
+    >>> user_config_dir(appname)
+    '/data/data/com.myApp/shared_prefs/SuperApp'
+    >>> user_cache_dir(appname, appauthor)
+    '/data/data/com.myApp/cache/SuperApp'
+    >>> site_data_dir(appname, appauthor)
+    '/data/data/com.myApp/files/SuperApp'
+    >>> site_config_dir(appname)
+    '/data/data/com.myApp/shared_prefs/SuperApp'
+    >>> user_log_dir(appname, appauthor)
+    '/data/data/com.myApp/cache/SuperApp/log'
+    >>> user_documents_dir()
+    '/storage/emulated/0/Documents'
+    >>> user_downloads_dir()
+    '/storage/emulated/0/Downloads'
+    >>> user_pictures_dir()
+    '/storage/emulated/0/Pictures'
+    >>> user_videos_dir()
+    '/storage/emulated/0/DCIM/Camera'
+    >>> user_music_dir()
+    '/storage/emulated/0/Music'
+    >>> user_desktop_dir()
+    '/storage/emulated/0/Desktop'
+    >>> user_runtime_dir(appname, appauthor)
+    '/data/data/com.myApp/cache/SuperApp/tmp'
+
+Note: Some android apps like Termux and Pydroid are used as shells. These
+apps are used by the end user to emulate Linux environment. Presence of
+``SHELL`` environment variable is used by Platformdirs to differentiate
+between general android apps and android apps used as shells. Shell android
+apps also support ``XDG_*`` environment variables.
+
+
+``PlatformDirs`` for convenience
+================================
+
+.. code-block:: pycon
+
+    >>> from platformdirs import PlatformDirs
+    >>> dirs = PlatformDirs("SuperApp", "Acme")
+    >>> dirs.user_data_dir
+    '/Users/trentm/Library/Application Support/SuperApp'
+    >>> dirs.user_config_dir
+    '/Users/trentm/Library/Application Support/SuperApp'
+    >>> dirs.user_cache_dir
+    '/Users/trentm/Library/Caches/SuperApp'
+    >>> dirs.site_data_dir
+    '/Library/Application Support/SuperApp'
+    >>> dirs.site_config_dir
+    '/Library/Application Support/SuperApp'
+    >>> dirs.user_cache_dir
+    '/Users/trentm/Library/Caches/SuperApp'
+    >>> dirs.user_log_dir
+    '/Users/trentm/Library/Logs/SuperApp'
+    >>> dirs.user_documents_dir
+    '/Users/trentm/Documents'
+    >>> dirs.user_downloads_dir
+    '/Users/trentm/Downloads'
+    >>> dirs.user_pictures_dir
+    '/Users/trentm/Pictures'
+    >>> dirs.user_videos_dir
+    '/Users/trentm/Movies'
+    >>> dirs.user_music_dir
+    '/Users/trentm/Music'
+    >>> dirs.user_desktop_dir
+    '/Users/trentm/Desktop'
+    >>> dirs.user_runtime_dir
+    '/Users/trentm/Library/Caches/TemporaryItems/SuperApp'
+
+Per-version isolation
+=====================
+
+If you have multiple versions of your app in use that you want to be
+able to run side-by-side, then you may want version-isolation for these
+dirs::
+
+    >>> from platformdirs import PlatformDirs
+    >>> dirs = PlatformDirs("SuperApp", "Acme", version="1.0")
+    >>> dirs.user_data_dir
+    '/Users/trentm/Library/Application Support/SuperApp/1.0'
+    >>> dirs.user_config_dir
+    '/Users/trentm/Library/Application Support/SuperApp/1.0'
+    >>> dirs.user_cache_dir
+    '/Users/trentm/Library/Caches/SuperApp/1.0'
+    >>> dirs.site_data_dir
+    '/Library/Application Support/SuperApp/1.0'
+    >>> dirs.site_config_dir
+    '/Library/Application Support/SuperApp/1.0'
+    >>> dirs.user_log_dir
+    '/Users/trentm/Library/Logs/SuperApp/1.0'
+    >>> dirs.user_documents_dir
+    '/Users/trentm/Documents'
+    >>> dirs.user_downloads_dir
+    '/Users/trentm/Downloads'
+    >>> dirs.user_pictures_dir
+    '/Users/trentm/Pictures'
+    >>> dirs.user_videos_dir
+    '/Users/trentm/Movies'
+    >>> dirs.user_music_dir
+    '/Users/trentm/Music'
+    >>> dirs.user_desktop_dir
+    '/Users/trentm/Desktop'
+    >>> dirs.user_runtime_dir
+    '/Users/trentm/Library/Caches/TemporaryItems/SuperApp/1.0'
+
+Be wary of using this for configuration files though; you'll need to handle
+migrating configuration files manually.
+
+Why this Fork?
+==============
+
+This repository is a friendly fork of the wonderful work started by
+`ActiveState `_ who created
+``appdirs``, this package's ancestor.
+
+Maintaining an open source project is no easy task, particularly
+from within an organization, and the Python community is indebted
+to ``appdirs`` (and to Trent Mick and Jeff Rouse in particular) for
+creating an incredibly useful simple module, as evidenced by the wide
+number of users it has attracted over the years.
+
+Nonetheless, given the number of long-standing open issues
+and pull requests, and no clear path towards `ensuring
+that maintenance of the package would continue or grow
+`_, this fork was
+created.
+
+Contributions are most welcome.
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs-4.4.0.dist-info/RECORD b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs-4.4.0.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..09572f1780ad3554e93d8309547e9bc802a60371
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs-4.4.0.dist-info/RECORD
@@ -0,0 +1,15 @@
+platformdirs-4.4.0.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+platformdirs-4.4.0.dist-info/METADATA,sha256=u8UhbV9Md7-8VyJyZNUuZrzN5xzPeedeGmBG0CnTAiM,12831
+platformdirs-4.4.0.dist-info/RECORD,,
+platformdirs-4.4.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+platformdirs-4.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+platformdirs-4.4.0.dist-info/licenses/LICENSE,sha256=KeD9YukphQ6G6yjD_czwzv30-pSHkBHP-z0NS-1tTbY,1089
+platformdirs/__init__.py,sha256=iORRy6_lZ9tXLvO0W6fJPn8QV7F532ivl-f2WGmabBc,22284
+platformdirs/__main__.py,sha256=HnsUQHpiBaiTxwcmwVw-nFaPdVNZtQIdi1eWDtI-MzI,1493
+platformdirs/android.py,sha256=r0DshVBf-RO1jXJGX8C4Til7F1XWt-bkdWMgmvEiaYg,9013
+platformdirs/api.py,sha256=wPHOlwOsfz2oqQZ6A2FcCu5kEAj-JondzoNOHYFQ0h8,9281
+platformdirs/macos.py,sha256=0XoOgin1NK7Qki7iskD-oS8xKxw6bXgoKEgdqpCRAFQ,6322
+platformdirs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+platformdirs/unix.py,sha256=WZmkUA--L3JNRGmz32s35YfoD3ica6xKIPdCV_HhLcs,10458
+platformdirs/version.py,sha256=i31fi3nNO19D2FdSx8aldD7IFLSqm2YrAo6SmkV0FLM,704
+platformdirs/windows.py,sha256=IFpiohUBwxPtCzlyKwNtxyW4Jk8haa6W8o59mfrDXVo,10125
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs-4.4.0.dist-info/REQUESTED b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs-4.4.0.dist-info/REQUESTED
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs-4.4.0.dist-info/WHEEL b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs-4.4.0.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..12228d414b6cfed7c39d3781c85c63256a1d7fb5
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs-4.4.0.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__init__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..02daa5914a82da08293dc1675e75c11ed3fb2bd8
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__init__.py
@@ -0,0 +1,631 @@
+"""
+Utilities for determining application-specific dirs.
+
+See  for details and usage.
+
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import TYPE_CHECKING
+
+from .api import PlatformDirsABC
+from .version import __version__
+from .version import __version_tuple__ as __version_info__
+
+if TYPE_CHECKING:
+    from pathlib import Path
+    from typing import Literal
+
+if sys.platform == "win32":
+    from platformdirs.windows import Windows as _Result
+elif sys.platform == "darwin":
+    from platformdirs.macos import MacOS as _Result
+else:
+    from platformdirs.unix import Unix as _Result
+
+
+def _set_platform_dir_class() -> type[PlatformDirsABC]:
+    if os.getenv("ANDROID_DATA") == "/data" and os.getenv("ANDROID_ROOT") == "/system":
+        if os.getenv("SHELL") or os.getenv("PREFIX"):
+            return _Result
+
+        from platformdirs.android import _android_folder  # noqa: PLC0415
+
+        if _android_folder() is not None:
+            from platformdirs.android import Android  # noqa: PLC0415
+
+            return Android  # return to avoid redefinition of a result
+
+    return _Result
+
+
+if TYPE_CHECKING:
+    # Work around mypy issue: https://github.com/python/mypy/issues/10962
+    PlatformDirs = _Result
+else:
+    PlatformDirs = _set_platform_dir_class()  #: Currently active platform
+AppDirs = PlatformDirs  #: Backwards compatibility with appdirs
+
+
+def user_data_dir(
+    appname: str | None = None,
+    appauthor: str | Literal[False] | None = None,
+    version: str | None = None,
+    roaming: bool = False,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> str:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param roaming: See `roaming `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: data directory tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        roaming=roaming,
+        ensure_exists=ensure_exists,
+    ).user_data_dir
+
+
+def site_data_dir(
+    appname: str | None = None,
+    appauthor: str | Literal[False] | None = None,
+    version: str | None = None,
+    multipath: bool = False,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> str:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param multipath: See `roaming `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: data directory shared by users
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        multipath=multipath,
+        ensure_exists=ensure_exists,
+    ).site_data_dir
+
+
+def user_config_dir(
+    appname: str | None = None,
+    appauthor: str | Literal[False] | None = None,
+    version: str | None = None,
+    roaming: bool = False,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> str:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param roaming: See `roaming `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: config directory tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        roaming=roaming,
+        ensure_exists=ensure_exists,
+    ).user_config_dir
+
+
+def site_config_dir(
+    appname: str | None = None,
+    appauthor: str | Literal[False] | None = None,
+    version: str | None = None,
+    multipath: bool = False,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> str:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param multipath: See `roaming `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: config directory shared by the users
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        multipath=multipath,
+        ensure_exists=ensure_exists,
+    ).site_config_dir
+
+
+def user_cache_dir(
+    appname: str | None = None,
+    appauthor: str | Literal[False] | None = None,
+    version: str | None = None,
+    opinion: bool = True,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> str:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param opinion: See `roaming `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: cache directory tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        opinion=opinion,
+        ensure_exists=ensure_exists,
+    ).user_cache_dir
+
+
+def site_cache_dir(
+    appname: str | None = None,
+    appauthor: str | Literal[False] | None = None,
+    version: str | None = None,
+    opinion: bool = True,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> str:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param opinion: See `opinion `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: cache directory tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        opinion=opinion,
+        ensure_exists=ensure_exists,
+    ).site_cache_dir
+
+
+def user_state_dir(
+    appname: str | None = None,
+    appauthor: str | Literal[False] | None = None,
+    version: str | None = None,
+    roaming: bool = False,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> str:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param roaming: See `roaming `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: state directory tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        roaming=roaming,
+        ensure_exists=ensure_exists,
+    ).user_state_dir
+
+
+def user_log_dir(
+    appname: str | None = None,
+    appauthor: str | Literal[False] | None = None,
+    version: str | None = None,
+    opinion: bool = True,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> str:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param opinion: See `roaming `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: log directory tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        opinion=opinion,
+        ensure_exists=ensure_exists,
+    ).user_log_dir
+
+
+def user_documents_dir() -> str:
+    """:returns: documents directory tied to the user"""
+    return PlatformDirs().user_documents_dir
+
+
+def user_downloads_dir() -> str:
+    """:returns: downloads directory tied to the user"""
+    return PlatformDirs().user_downloads_dir
+
+
+def user_pictures_dir() -> str:
+    """:returns: pictures directory tied to the user"""
+    return PlatformDirs().user_pictures_dir
+
+
+def user_videos_dir() -> str:
+    """:returns: videos directory tied to the user"""
+    return PlatformDirs().user_videos_dir
+
+
+def user_music_dir() -> str:
+    """:returns: music directory tied to the user"""
+    return PlatformDirs().user_music_dir
+
+
+def user_desktop_dir() -> str:
+    """:returns: desktop directory tied to the user"""
+    return PlatformDirs().user_desktop_dir
+
+
+def user_runtime_dir(
+    appname: str | None = None,
+    appauthor: str | Literal[False] | None = None,
+    version: str | None = None,
+    opinion: bool = True,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> str:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param opinion: See `opinion `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: runtime directory tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        opinion=opinion,
+        ensure_exists=ensure_exists,
+    ).user_runtime_dir
+
+
+def site_runtime_dir(
+    appname: str | None = None,
+    appauthor: str | Literal[False] | None = None,
+    version: str | None = None,
+    opinion: bool = True,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> str:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param opinion: See `opinion `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: runtime directory shared by users
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        opinion=opinion,
+        ensure_exists=ensure_exists,
+    ).site_runtime_dir
+
+
+def user_data_path(
+    appname: str | None = None,
+    appauthor: str | Literal[False] | None = None,
+    version: str | None = None,
+    roaming: bool = False,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> Path:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param roaming: See `roaming `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: data path tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        roaming=roaming,
+        ensure_exists=ensure_exists,
+    ).user_data_path
+
+
+def site_data_path(
+    appname: str | None = None,
+    appauthor: str | Literal[False] | None = None,
+    version: str | None = None,
+    multipath: bool = False,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> Path:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param multipath: See `multipath `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: data path shared by users
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        multipath=multipath,
+        ensure_exists=ensure_exists,
+    ).site_data_path
+
+
+def user_config_path(
+    appname: str | None = None,
+    appauthor: str | Literal[False] | None = None,
+    version: str | None = None,
+    roaming: bool = False,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> Path:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param roaming: See `roaming `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: config path tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        roaming=roaming,
+        ensure_exists=ensure_exists,
+    ).user_config_path
+
+
+def site_config_path(
+    appname: str | None = None,
+    appauthor: str | Literal[False] | None = None,
+    version: str | None = None,
+    multipath: bool = False,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> Path:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param multipath: See `roaming `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: config path shared by the users
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        multipath=multipath,
+        ensure_exists=ensure_exists,
+    ).site_config_path
+
+
+def site_cache_path(
+    appname: str | None = None,
+    appauthor: str | Literal[False] | None = None,
+    version: str | None = None,
+    opinion: bool = True,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> Path:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param opinion: See `opinion `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: cache directory tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        opinion=opinion,
+        ensure_exists=ensure_exists,
+    ).site_cache_path
+
+
+def user_cache_path(
+    appname: str | None = None,
+    appauthor: str | Literal[False] | None = None,
+    version: str | None = None,
+    opinion: bool = True,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> Path:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param opinion: See `roaming `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: cache path tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        opinion=opinion,
+        ensure_exists=ensure_exists,
+    ).user_cache_path
+
+
+def user_state_path(
+    appname: str | None = None,
+    appauthor: str | Literal[False] | None = None,
+    version: str | None = None,
+    roaming: bool = False,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> Path:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param roaming: See `roaming `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: state path tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        roaming=roaming,
+        ensure_exists=ensure_exists,
+    ).user_state_path
+
+
+def user_log_path(
+    appname: str | None = None,
+    appauthor: str | Literal[False] | None = None,
+    version: str | None = None,
+    opinion: bool = True,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> Path:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param opinion: See `roaming `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: log path tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        opinion=opinion,
+        ensure_exists=ensure_exists,
+    ).user_log_path
+
+
+def user_documents_path() -> Path:
+    """:returns: documents a path tied to the user"""
+    return PlatformDirs().user_documents_path
+
+
+def user_downloads_path() -> Path:
+    """:returns: downloads path tied to the user"""
+    return PlatformDirs().user_downloads_path
+
+
+def user_pictures_path() -> Path:
+    """:returns: pictures path tied to the user"""
+    return PlatformDirs().user_pictures_path
+
+
+def user_videos_path() -> Path:
+    """:returns: videos path tied to the user"""
+    return PlatformDirs().user_videos_path
+
+
+def user_music_path() -> Path:
+    """:returns: music path tied to the user"""
+    return PlatformDirs().user_music_path
+
+
+def user_desktop_path() -> Path:
+    """:returns: desktop path tied to the user"""
+    return PlatformDirs().user_desktop_path
+
+
+def user_runtime_path(
+    appname: str | None = None,
+    appauthor: str | Literal[False] | None = None,
+    version: str | None = None,
+    opinion: bool = True,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> Path:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param opinion: See `opinion `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: runtime path tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        opinion=opinion,
+        ensure_exists=ensure_exists,
+    ).user_runtime_path
+
+
+def site_runtime_path(
+    appname: str | None = None,
+    appauthor: str | Literal[False] | None = None,
+    version: str | None = None,
+    opinion: bool = True,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> Path:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param opinion: See `opinion `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: runtime path shared by users
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        opinion=opinion,
+        ensure_exists=ensure_exists,
+    ).site_runtime_path
+
+
+__all__ = [
+    "AppDirs",
+    "PlatformDirs",
+    "PlatformDirsABC",
+    "__version__",
+    "__version_info__",
+    "site_cache_dir",
+    "site_cache_path",
+    "site_config_dir",
+    "site_config_path",
+    "site_data_dir",
+    "site_data_path",
+    "site_runtime_dir",
+    "site_runtime_path",
+    "user_cache_dir",
+    "user_cache_path",
+    "user_config_dir",
+    "user_config_path",
+    "user_data_dir",
+    "user_data_path",
+    "user_desktop_dir",
+    "user_desktop_path",
+    "user_documents_dir",
+    "user_documents_path",
+    "user_downloads_dir",
+    "user_downloads_path",
+    "user_log_dir",
+    "user_log_path",
+    "user_music_dir",
+    "user_music_path",
+    "user_pictures_dir",
+    "user_pictures_path",
+    "user_runtime_dir",
+    "user_runtime_path",
+    "user_state_dir",
+    "user_state_path",
+    "user_videos_dir",
+    "user_videos_path",
+]
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__main__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__main__.py
new file mode 100644
index 0000000000000000000000000000000000000000..922c521358e349470ec48d6372b8f8ee8641128a
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__main__.py
@@ -0,0 +1,55 @@
+"""Main entry point."""
+
+from __future__ import annotations
+
+from platformdirs import PlatformDirs, __version__
+
+PROPS = (
+    "user_data_dir",
+    "user_config_dir",
+    "user_cache_dir",
+    "user_state_dir",
+    "user_log_dir",
+    "user_documents_dir",
+    "user_downloads_dir",
+    "user_pictures_dir",
+    "user_videos_dir",
+    "user_music_dir",
+    "user_runtime_dir",
+    "site_data_dir",
+    "site_config_dir",
+    "site_cache_dir",
+    "site_runtime_dir",
+)
+
+
+def main() -> None:
+    """Run the main entry point."""
+    app_name = "MyApp"
+    app_author = "MyCompany"
+
+    print(f"-- platformdirs {__version__} --")  # noqa: T201
+
+    print("-- app dirs (with optional 'version')")  # noqa: T201
+    dirs = PlatformDirs(app_name, app_author, version="1.0")
+    for prop in PROPS:
+        print(f"{prop}: {getattr(dirs, prop)}")  # noqa: T201
+
+    print("\n-- app dirs (without optional 'version')")  # noqa: T201
+    dirs = PlatformDirs(app_name, app_author)
+    for prop in PROPS:
+        print(f"{prop}: {getattr(dirs, prop)}")  # noqa: T201
+
+    print("\n-- app dirs (without optional 'appauthor')")  # noqa: T201
+    dirs = PlatformDirs(app_name)
+    for prop in PROPS:
+        print(f"{prop}: {getattr(dirs, prop)}")  # noqa: T201
+
+    print("\n-- app dirs (with disabled 'appauthor')")  # noqa: T201
+    dirs = PlatformDirs(app_name, appauthor=False)
+    for prop in PROPS:
+        print(f"{prop}: {getattr(dirs, prop)}")  # noqa: T201
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..18c2d58564d8273ff7ac7c9500601d4c24adca92
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__pycache__/__main__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__pycache__/__main__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2ab5be0b83215244ce92ab4c8c0fa169eabd6b03
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__pycache__/__main__.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__pycache__/android.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__pycache__/android.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..132e9837013ecbc7410a481c8f138d81ad1e3a4a
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__pycache__/android.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__pycache__/api.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__pycache__/api.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fb86ebe5585b974eccd576d8602cabfca0eaeb08
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__pycache__/api.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__pycache__/macos.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__pycache__/macos.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..89bc061e5543638be59dfa889726c952a7a2cd04
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__pycache__/macos.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__pycache__/unix.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__pycache__/unix.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4d90bd88670bcf8eb0812715e5f91a495c7a191d
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__pycache__/unix.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__pycache__/version.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__pycache__/version.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c2a143e48ff57e66788ad97a9ff6d4c868679667
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__pycache__/version.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__pycache__/windows.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__pycache__/windows.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b79f9ca275a0ae7783123607f72b0d5c9e0c11cf
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/__pycache__/windows.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/android.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/android.py
new file mode 100644
index 0000000000000000000000000000000000000000..92efc852d3818b70a708ab61ba2b291eb5a6ee67
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/android.py
@@ -0,0 +1,249 @@
+"""Android."""
+
+from __future__ import annotations
+
+import os
+import re
+import sys
+from functools import lru_cache
+from typing import TYPE_CHECKING, cast
+
+from .api import PlatformDirsABC
+
+
+class Android(PlatformDirsABC):
+    """
+    Follows the guidance `from here `_.
+
+    Makes use of the `appname `, `version
+    `, `ensure_exists `.
+
+    """
+
+    @property
+    def user_data_dir(self) -> str:
+        """:return: data directory tied to the user, e.g. ``/data/user///files/``"""
+        return self._append_app_name_and_version(cast("str", _android_folder()), "files")
+
+    @property
+    def site_data_dir(self) -> str:
+        """:return: data directory shared by users, same as `user_data_dir`"""
+        return self.user_data_dir
+
+    @property
+    def user_config_dir(self) -> str:
+        """
+        :return: config directory tied to the user, e.g. \
+        ``/data/user///shared_prefs/``
+        """
+        return self._append_app_name_and_version(cast("str", _android_folder()), "shared_prefs")
+
+    @property
+    def site_config_dir(self) -> str:
+        """:return: config directory shared by the users, same as `user_config_dir`"""
+        return self.user_config_dir
+
+    @property
+    def user_cache_dir(self) -> str:
+        """:return: cache directory tied to the user, e.g.,``/data/user///cache/``"""
+        return self._append_app_name_and_version(cast("str", _android_folder()), "cache")
+
+    @property
+    def site_cache_dir(self) -> str:
+        """:return: cache directory shared by users, same as `user_cache_dir`"""
+        return self.user_cache_dir
+
+    @property
+    def user_state_dir(self) -> str:
+        """:return: state directory tied to the user, same as `user_data_dir`"""
+        return self.user_data_dir
+
+    @property
+    def user_log_dir(self) -> str:
+        """
+        :return: log directory tied to the user, same as `user_cache_dir` if not opinionated else ``log`` in it,
+          e.g. ``/data/user///cache//log``
+        """
+        path = self.user_cache_dir
+        if self.opinion:
+            path = os.path.join(path, "log")  # noqa: PTH118
+        return path
+
+    @property
+    def user_documents_dir(self) -> str:
+        """:return: documents directory tied to the user e.g. ``/storage/emulated/0/Documents``"""
+        return _android_documents_folder()
+
+    @property
+    def user_downloads_dir(self) -> str:
+        """:return: downloads directory tied to the user e.g. ``/storage/emulated/0/Downloads``"""
+        return _android_downloads_folder()
+
+    @property
+    def user_pictures_dir(self) -> str:
+        """:return: pictures directory tied to the user e.g. ``/storage/emulated/0/Pictures``"""
+        return _android_pictures_folder()
+
+    @property
+    def user_videos_dir(self) -> str:
+        """:return: videos directory tied to the user e.g. ``/storage/emulated/0/DCIM/Camera``"""
+        return _android_videos_folder()
+
+    @property
+    def user_music_dir(self) -> str:
+        """:return: music directory tied to the user e.g. ``/storage/emulated/0/Music``"""
+        return _android_music_folder()
+
+    @property
+    def user_desktop_dir(self) -> str:
+        """:return: desktop directory tied to the user e.g. ``/storage/emulated/0/Desktop``"""
+        return "/storage/emulated/0/Desktop"
+
+    @property
+    def user_runtime_dir(self) -> str:
+        """
+        :return: runtime directory tied to the user, same as `user_cache_dir` if not opinionated else ``tmp`` in it,
+          e.g. ``/data/user///cache//tmp``
+        """
+        path = self.user_cache_dir
+        if self.opinion:
+            path = os.path.join(path, "tmp")  # noqa: PTH118
+        return path
+
+    @property
+    def site_runtime_dir(self) -> str:
+        """:return: runtime directory shared by users, same as `user_runtime_dir`"""
+        return self.user_runtime_dir
+
+
+@lru_cache(maxsize=1)
+def _android_folder() -> str | None:  # noqa: C901
+    """:return: base folder for the Android OS or None if it cannot be found"""
+    result: str | None = None
+    # type checker isn't happy with our "import android", just don't do this when type checking see
+    # https://stackoverflow.com/a/61394121
+    if not TYPE_CHECKING:
+        try:
+            # First try to get a path to android app using python4android (if available)...
+            from android import mActivity  # noqa: PLC0415
+
+            context = cast("android.content.Context", mActivity.getApplicationContext())  # noqa: F821
+            result = context.getFilesDir().getParentFile().getAbsolutePath()
+        except Exception:  # noqa: BLE001
+            result = None
+    if result is None:
+        try:
+            # ...and fall back to using plain pyjnius, if python4android isn't available or doesn't deliver any useful
+            # result...
+            from jnius import autoclass  # noqa: PLC0415
+
+            context = autoclass("android.content.Context")
+            result = context.getFilesDir().getParentFile().getAbsolutePath()
+        except Exception:  # noqa: BLE001
+            result = None
+    if result is None:
+        # and if that fails, too, find an android folder looking at path on the sys.path
+        # warning: only works for apps installed under /data, not adopted storage etc.
+        pattern = re.compile(r"/data/(data|user/\d+)/(.+)/files")
+        for path in sys.path:
+            if pattern.match(path):
+                result = path.split("/files")[0]
+                break
+        else:
+            result = None
+    if result is None:
+        # one last try: find an android folder looking at path on the sys.path taking adopted storage paths into
+        # account
+        pattern = re.compile(r"/mnt/expand/[a-fA-F0-9-]{36}/(data|user/\d+)/(.+)/files")
+        for path in sys.path:
+            if pattern.match(path):
+                result = path.split("/files")[0]
+                break
+        else:
+            result = None
+    return result
+
+
+@lru_cache(maxsize=1)
+def _android_documents_folder() -> str:
+    """:return: documents folder for the Android OS"""
+    # Get directories with pyjnius
+    try:
+        from jnius import autoclass  # noqa: PLC0415
+
+        context = autoclass("android.content.Context")
+        environment = autoclass("android.os.Environment")
+        documents_dir: str = context.getExternalFilesDir(environment.DIRECTORY_DOCUMENTS).getAbsolutePath()
+    except Exception:  # noqa: BLE001
+        documents_dir = "/storage/emulated/0/Documents"
+
+    return documents_dir
+
+
+@lru_cache(maxsize=1)
+def _android_downloads_folder() -> str:
+    """:return: downloads folder for the Android OS"""
+    # Get directories with pyjnius
+    try:
+        from jnius import autoclass  # noqa: PLC0415
+
+        context = autoclass("android.content.Context")
+        environment = autoclass("android.os.Environment")
+        downloads_dir: str = context.getExternalFilesDir(environment.DIRECTORY_DOWNLOADS).getAbsolutePath()
+    except Exception:  # noqa: BLE001
+        downloads_dir = "/storage/emulated/0/Downloads"
+
+    return downloads_dir
+
+
+@lru_cache(maxsize=1)
+def _android_pictures_folder() -> str:
+    """:return: pictures folder for the Android OS"""
+    # Get directories with pyjnius
+    try:
+        from jnius import autoclass  # noqa: PLC0415
+
+        context = autoclass("android.content.Context")
+        environment = autoclass("android.os.Environment")
+        pictures_dir: str = context.getExternalFilesDir(environment.DIRECTORY_PICTURES).getAbsolutePath()
+    except Exception:  # noqa: BLE001
+        pictures_dir = "/storage/emulated/0/Pictures"
+
+    return pictures_dir
+
+
+@lru_cache(maxsize=1)
+def _android_videos_folder() -> str:
+    """:return: videos folder for the Android OS"""
+    # Get directories with pyjnius
+    try:
+        from jnius import autoclass  # noqa: PLC0415
+
+        context = autoclass("android.content.Context")
+        environment = autoclass("android.os.Environment")
+        videos_dir: str = context.getExternalFilesDir(environment.DIRECTORY_DCIM).getAbsolutePath()
+    except Exception:  # noqa: BLE001
+        videos_dir = "/storage/emulated/0/DCIM/Camera"
+
+    return videos_dir
+
+
+@lru_cache(maxsize=1)
+def _android_music_folder() -> str:
+    """:return: music folder for the Android OS"""
+    # Get directories with pyjnius
+    try:
+        from jnius import autoclass  # noqa: PLC0415
+
+        context = autoclass("android.content.Context")
+        environment = autoclass("android.os.Environment")
+        music_dir: str = context.getExternalFilesDir(environment.DIRECTORY_MUSIC).getAbsolutePath()
+    except Exception:  # noqa: BLE001
+        music_dir = "/storage/emulated/0/Music"
+
+    return music_dir
+
+
+__all__ = [
+    "Android",
+]
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/api.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/api.py
new file mode 100644
index 0000000000000000000000000000000000000000..251600e6d1b6f7d38f6fee0b91de34d31b2124d0
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/api.py
@@ -0,0 +1,299 @@
+"""Base API."""
+
+from __future__ import annotations
+
+import os
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+    from typing import Literal
+
+
+class PlatformDirsABC(ABC):  # noqa: PLR0904
+    """Abstract base class for platform directories."""
+
+    def __init__(  # noqa: PLR0913, PLR0917
+        self,
+        appname: str | None = None,
+        appauthor: str | Literal[False] | None = None,
+        version: str | None = None,
+        roaming: bool = False,  # noqa: FBT001, FBT002
+        multipath: bool = False,  # noqa: FBT001, FBT002
+        opinion: bool = True,  # noqa: FBT001, FBT002
+        ensure_exists: bool = False,  # noqa: FBT001, FBT002
+    ) -> None:
+        """
+        Create a new platform directory.
+
+        :param appname: See `appname`.
+        :param appauthor: See `appauthor`.
+        :param version: See `version`.
+        :param roaming: See `roaming`.
+        :param multipath: See `multipath`.
+        :param opinion: See `opinion`.
+        :param ensure_exists: See `ensure_exists`.
+
+        """
+        self.appname = appname  #: The name of application.
+        self.appauthor = appauthor
+        """
+        The name of the app author or distributing body for this application.
+
+        Typically, it is the owning company name. Defaults to `appname`. You may pass ``False`` to disable it.
+
+        """
+        self.version = version
+        """
+        An optional version path element to append to the path.
+
+        You might want to use this if you want multiple versions of your app to be able to run independently. If used,
+        this would typically be ``.``.
+
+        """
+        self.roaming = roaming
+        """
+        Whether to use the roaming appdata directory on Windows.
+
+        That means that for users on a Windows network setup for roaming profiles, this user data will be synced on
+        login (see
+        `here `_).
+
+        """
+        self.multipath = multipath
+        """
+        An optional parameter which indicates that the entire list of data dirs should be returned.
+
+        By default, the first item would only be returned.
+
+        """
+        self.opinion = opinion  #: A flag to indicating to use opinionated values.
+        self.ensure_exists = ensure_exists
+        """
+        Optionally create the directory (and any missing parents) upon access if it does not exist.
+
+        By default, no directories are created.
+
+        """
+
+    def _append_app_name_and_version(self, *base: str) -> str:
+        params = list(base[1:])
+        if self.appname:
+            params.append(self.appname)
+            if self.version:
+                params.append(self.version)
+        path = os.path.join(base[0], *params)  # noqa: PTH118
+        self._optionally_create_directory(path)
+        return path
+
+    def _optionally_create_directory(self, path: str) -> None:
+        if self.ensure_exists:
+            Path(path).mkdir(parents=True, exist_ok=True)
+
+    def _first_item_as_path_if_multipath(self, directory: str) -> Path:
+        if self.multipath:
+            # If multipath is True, the first path is returned.
+            directory = directory.partition(os.pathsep)[0]
+        return Path(directory)
+
+    @property
+    @abstractmethod
+    def user_data_dir(self) -> str:
+        """:return: data directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def site_data_dir(self) -> str:
+        """:return: data directory shared by users"""
+
+    @property
+    @abstractmethod
+    def user_config_dir(self) -> str:
+        """:return: config directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def site_config_dir(self) -> str:
+        """:return: config directory shared by the users"""
+
+    @property
+    @abstractmethod
+    def user_cache_dir(self) -> str:
+        """:return: cache directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def site_cache_dir(self) -> str:
+        """:return: cache directory shared by users"""
+
+    @property
+    @abstractmethod
+    def user_state_dir(self) -> str:
+        """:return: state directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def user_log_dir(self) -> str:
+        """:return: log directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def user_documents_dir(self) -> str:
+        """:return: documents directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def user_downloads_dir(self) -> str:
+        """:return: downloads directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def user_pictures_dir(self) -> str:
+        """:return: pictures directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def user_videos_dir(self) -> str:
+        """:return: videos directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def user_music_dir(self) -> str:
+        """:return: music directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def user_desktop_dir(self) -> str:
+        """:return: desktop directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def user_runtime_dir(self) -> str:
+        """:return: runtime directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def site_runtime_dir(self) -> str:
+        """:return: runtime directory shared by users"""
+
+    @property
+    def user_data_path(self) -> Path:
+        """:return: data path tied to the user"""
+        return Path(self.user_data_dir)
+
+    @property
+    def site_data_path(self) -> Path:
+        """:return: data path shared by users"""
+        return Path(self.site_data_dir)
+
+    @property
+    def user_config_path(self) -> Path:
+        """:return: config path tied to the user"""
+        return Path(self.user_config_dir)
+
+    @property
+    def site_config_path(self) -> Path:
+        """:return: config path shared by the users"""
+        return Path(self.site_config_dir)
+
+    @property
+    def user_cache_path(self) -> Path:
+        """:return: cache path tied to the user"""
+        return Path(self.user_cache_dir)
+
+    @property
+    def site_cache_path(self) -> Path:
+        """:return: cache path shared by users"""
+        return Path(self.site_cache_dir)
+
+    @property
+    def user_state_path(self) -> Path:
+        """:return: state path tied to the user"""
+        return Path(self.user_state_dir)
+
+    @property
+    def user_log_path(self) -> Path:
+        """:return: log path tied to the user"""
+        return Path(self.user_log_dir)
+
+    @property
+    def user_documents_path(self) -> Path:
+        """:return: documents a path tied to the user"""
+        return Path(self.user_documents_dir)
+
+    @property
+    def user_downloads_path(self) -> Path:
+        """:return: downloads path tied to the user"""
+        return Path(self.user_downloads_dir)
+
+    @property
+    def user_pictures_path(self) -> Path:
+        """:return: pictures path tied to the user"""
+        return Path(self.user_pictures_dir)
+
+    @property
+    def user_videos_path(self) -> Path:
+        """:return: videos path tied to the user"""
+        return Path(self.user_videos_dir)
+
+    @property
+    def user_music_path(self) -> Path:
+        """:return: music path tied to the user"""
+        return Path(self.user_music_dir)
+
+    @property
+    def user_desktop_path(self) -> Path:
+        """:return: desktop path tied to the user"""
+        return Path(self.user_desktop_dir)
+
+    @property
+    def user_runtime_path(self) -> Path:
+        """:return: runtime path tied to the user"""
+        return Path(self.user_runtime_dir)
+
+    @property
+    def site_runtime_path(self) -> Path:
+        """:return: runtime path shared by users"""
+        return Path(self.site_runtime_dir)
+
+    def iter_config_dirs(self) -> Iterator[str]:
+        """:yield: all user and site configuration directories."""
+        yield self.user_config_dir
+        yield self.site_config_dir
+
+    def iter_data_dirs(self) -> Iterator[str]:
+        """:yield: all user and site data directories."""
+        yield self.user_data_dir
+        yield self.site_data_dir
+
+    def iter_cache_dirs(self) -> Iterator[str]:
+        """:yield: all user and site cache directories."""
+        yield self.user_cache_dir
+        yield self.site_cache_dir
+
+    def iter_runtime_dirs(self) -> Iterator[str]:
+        """:yield: all user and site runtime directories."""
+        yield self.user_runtime_dir
+        yield self.site_runtime_dir
+
+    def iter_config_paths(self) -> Iterator[Path]:
+        """:yield: all user and site configuration paths."""
+        for path in self.iter_config_dirs():
+            yield Path(path)
+
+    def iter_data_paths(self) -> Iterator[Path]:
+        """:yield: all user and site data paths."""
+        for path in self.iter_data_dirs():
+            yield Path(path)
+
+    def iter_cache_paths(self) -> Iterator[Path]:
+        """:yield: all user and site cache paths."""
+        for path in self.iter_cache_dirs():
+            yield Path(path)
+
+    def iter_runtime_paths(self) -> Iterator[Path]:
+        """:yield: all user and site runtime paths."""
+        for path in self.iter_runtime_dirs():
+            yield Path(path)
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/macos.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/macos.py
new file mode 100644
index 0000000000000000000000000000000000000000..30ab368913061aa4b7935e65f5696f7d8cffcf4f
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/macos.py
@@ -0,0 +1,146 @@
+"""macOS."""
+
+from __future__ import annotations
+
+import os.path
+import sys
+from typing import TYPE_CHECKING
+
+from .api import PlatformDirsABC
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+class MacOS(PlatformDirsABC):
+    """
+    Platform directories for the macOS operating system.
+
+    Follows the guidance from
+    `Apple documentation `_.
+    Makes use of the `appname `,
+    `version `,
+    `ensure_exists `.
+
+    """
+
+    @property
+    def user_data_dir(self) -> str:
+        """:return: data directory tied to the user, e.g. ``~/Library/Application Support/$appname/$version``"""
+        return self._append_app_name_and_version(os.path.expanduser("~/Library/Application Support"))  # noqa: PTH111
+
+    @property
+    def site_data_dir(self) -> str:
+        """
+        :return: data directory shared by users, e.g. ``/Library/Application Support/$appname/$version``.
+          If we're using a Python binary managed by `Homebrew `_, the directory
+          will be under the Homebrew prefix, e.g. ``$homebrew_prefix/share/$appname/$version``.
+          If `multipath ` is enabled, and we're in Homebrew,
+          the response is a multi-path string separated by ":", e.g.
+          ``$homebrew_prefix/share/$appname/$version:/Library/Application Support/$appname/$version``
+        """
+        is_homebrew = "/opt/python" in sys.prefix
+        homebrew_prefix = sys.prefix.split("/opt/python")[0] if is_homebrew else ""
+        path_list = [self._append_app_name_and_version(f"{homebrew_prefix}/share")] if is_homebrew else []
+        path_list.append(self._append_app_name_and_version("/Library/Application Support"))
+        if self.multipath:
+            return os.pathsep.join(path_list)
+        return path_list[0]
+
+    @property
+    def site_data_path(self) -> Path:
+        """:return: data path shared by users. Only return the first item, even if ``multipath`` is set to ``True``"""
+        return self._first_item_as_path_if_multipath(self.site_data_dir)
+
+    @property
+    def user_config_dir(self) -> str:
+        """:return: config directory tied to the user, same as `user_data_dir`"""
+        return self.user_data_dir
+
+    @property
+    def site_config_dir(self) -> str:
+        """:return: config directory shared by the users, same as `site_data_dir`"""
+        return self.site_data_dir
+
+    @property
+    def user_cache_dir(self) -> str:
+        """:return: cache directory tied to the user, e.g. ``~/Library/Caches/$appname/$version``"""
+        return self._append_app_name_and_version(os.path.expanduser("~/Library/Caches"))  # noqa: PTH111
+
+    @property
+    def site_cache_dir(self) -> str:
+        """
+        :return: cache directory shared by users, e.g. ``/Library/Caches/$appname/$version``.
+          If we're using a Python binary managed by `Homebrew `_, the directory
+          will be under the Homebrew prefix, e.g. ``$homebrew_prefix/var/cache/$appname/$version``.
+          If `multipath ` is enabled, and we're in Homebrew,
+          the response is a multi-path string separated by ":", e.g.
+          ``$homebrew_prefix/var/cache/$appname/$version:/Library/Caches/$appname/$version``
+        """
+        is_homebrew = "/opt/python" in sys.prefix
+        homebrew_prefix = sys.prefix.split("/opt/python")[0] if is_homebrew else ""
+        path_list = [self._append_app_name_and_version(f"{homebrew_prefix}/var/cache")] if is_homebrew else []
+        path_list.append(self._append_app_name_and_version("/Library/Caches"))
+        if self.multipath:
+            return os.pathsep.join(path_list)
+        return path_list[0]
+
+    @property
+    def site_cache_path(self) -> Path:
+        """:return: cache path shared by users. Only return the first item, even if ``multipath`` is set to ``True``"""
+        return self._first_item_as_path_if_multipath(self.site_cache_dir)
+
+    @property
+    def user_state_dir(self) -> str:
+        """:return: state directory tied to the user, same as `user_data_dir`"""
+        return self.user_data_dir
+
+    @property
+    def user_log_dir(self) -> str:
+        """:return: log directory tied to the user, e.g. ``~/Library/Logs/$appname/$version``"""
+        return self._append_app_name_and_version(os.path.expanduser("~/Library/Logs"))  # noqa: PTH111
+
+    @property
+    def user_documents_dir(self) -> str:
+        """:return: documents directory tied to the user, e.g. ``~/Documents``"""
+        return os.path.expanduser("~/Documents")  # noqa: PTH111
+
+    @property
+    def user_downloads_dir(self) -> str:
+        """:return: downloads directory tied to the user, e.g. ``~/Downloads``"""
+        return os.path.expanduser("~/Downloads")  # noqa: PTH111
+
+    @property
+    def user_pictures_dir(self) -> str:
+        """:return: pictures directory tied to the user, e.g. ``~/Pictures``"""
+        return os.path.expanduser("~/Pictures")  # noqa: PTH111
+
+    @property
+    def user_videos_dir(self) -> str:
+        """:return: videos directory tied to the user, e.g. ``~/Movies``"""
+        return os.path.expanduser("~/Movies")  # noqa: PTH111
+
+    @property
+    def user_music_dir(self) -> str:
+        """:return: music directory tied to the user, e.g. ``~/Music``"""
+        return os.path.expanduser("~/Music")  # noqa: PTH111
+
+    @property
+    def user_desktop_dir(self) -> str:
+        """:return: desktop directory tied to the user, e.g. ``~/Desktop``"""
+        return os.path.expanduser("~/Desktop")  # noqa: PTH111
+
+    @property
+    def user_runtime_dir(self) -> str:
+        """:return: runtime directory tied to the user, e.g. ``~/Library/Caches/TemporaryItems/$appname/$version``"""
+        return self._append_app_name_and_version(os.path.expanduser("~/Library/Caches/TemporaryItems"))  # noqa: PTH111
+
+    @property
+    def site_runtime_dir(self) -> str:
+        """:return: runtime directory shared by users, same as `user_runtime_dir`"""
+        return self.user_runtime_dir
+
+
+__all__ = [
+    "MacOS",
+]
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/py.typed b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/unix.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/unix.py
new file mode 100644
index 0000000000000000000000000000000000000000..fc75d8d0747b0d5ce84b96cfc37877a126d1a9b6
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/unix.py
@@ -0,0 +1,272 @@
+"""Unix."""
+
+from __future__ import annotations
+
+import os
+import sys
+from configparser import ConfigParser
+from pathlib import Path
+from typing import TYPE_CHECKING, NoReturn
+
+from .api import PlatformDirsABC
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+if sys.platform == "win32":
+
+    def getuid() -> NoReturn:
+        msg = "should only be used on Unix"
+        raise RuntimeError(msg)
+
+else:
+    from os import getuid
+
+
+class Unix(PlatformDirsABC):  # noqa: PLR0904
+    """
+    On Unix/Linux, we follow the `XDG Basedir Spec `_.
+
+    The spec allows overriding directories with environment variables. The examples shown are the default values,
+    alongside the name of the environment variable that overrides them. Makes use of the `appname
+    `, `version `, `multipath
+    `, `opinion `, `ensure_exists
+    `.
+
+    """
+
+    @property
+    def user_data_dir(self) -> str:
+        """
+        :return: data directory tied to the user, e.g. ``~/.local/share/$appname/$version`` or
+         ``$XDG_DATA_HOME/$appname/$version``
+        """
+        path = os.environ.get("XDG_DATA_HOME", "")
+        if not path.strip():
+            path = os.path.expanduser("~/.local/share")  # noqa: PTH111
+        return self._append_app_name_and_version(path)
+
+    @property
+    def _site_data_dirs(self) -> list[str]:
+        path = os.environ.get("XDG_DATA_DIRS", "")
+        if not path.strip():
+            path = f"/usr/local/share{os.pathsep}/usr/share"
+        return [self._append_app_name_and_version(p) for p in path.split(os.pathsep)]
+
+    @property
+    def site_data_dir(self) -> str:
+        """
+        :return: data directories shared by users (if `multipath ` is
+         enabled and ``XDG_DATA_DIRS`` is set and a multi path the response is also a multi path separated by the
+         OS path separator), e.g. ``/usr/local/share/$appname/$version`` or ``/usr/share/$appname/$version``
+        """
+        # XDG default for $XDG_DATA_DIRS; only first, if multipath is False
+        dirs = self._site_data_dirs
+        if not self.multipath:
+            return dirs[0]
+        return os.pathsep.join(dirs)
+
+    @property
+    def user_config_dir(self) -> str:
+        """
+        :return: config directory tied to the user, e.g. ``~/.config/$appname/$version`` or
+         ``$XDG_CONFIG_HOME/$appname/$version``
+        """
+        path = os.environ.get("XDG_CONFIG_HOME", "")
+        if not path.strip():
+            path = os.path.expanduser("~/.config")  # noqa: PTH111
+        return self._append_app_name_and_version(path)
+
+    @property
+    def _site_config_dirs(self) -> list[str]:
+        path = os.environ.get("XDG_CONFIG_DIRS", "")
+        if not path.strip():
+            path = "/etc/xdg"
+        return [self._append_app_name_and_version(p) for p in path.split(os.pathsep)]
+
+    @property
+    def site_config_dir(self) -> str:
+        """
+        :return: config directories shared by users (if `multipath `
+         is enabled and ``XDG_CONFIG_DIRS`` is set and a multi path the response is also a multi path separated by
+         the OS path separator), e.g. ``/etc/xdg/$appname/$version``
+        """
+        # XDG default for $XDG_CONFIG_DIRS only first, if multipath is False
+        dirs = self._site_config_dirs
+        if not self.multipath:
+            return dirs[0]
+        return os.pathsep.join(dirs)
+
+    @property
+    def user_cache_dir(self) -> str:
+        """
+        :return: cache directory tied to the user, e.g. ``~/.cache/$appname/$version`` or
+         ``~/$XDG_CACHE_HOME/$appname/$version``
+        """
+        path = os.environ.get("XDG_CACHE_HOME", "")
+        if not path.strip():
+            path = os.path.expanduser("~/.cache")  # noqa: PTH111
+        return self._append_app_name_and_version(path)
+
+    @property
+    def site_cache_dir(self) -> str:
+        """:return: cache directory shared by users, e.g. ``/var/cache/$appname/$version``"""
+        return self._append_app_name_and_version("/var/cache")
+
+    @property
+    def user_state_dir(self) -> str:
+        """
+        :return: state directory tied to the user, e.g. ``~/.local/state/$appname/$version`` or
+         ``$XDG_STATE_HOME/$appname/$version``
+        """
+        path = os.environ.get("XDG_STATE_HOME", "")
+        if not path.strip():
+            path = os.path.expanduser("~/.local/state")  # noqa: PTH111
+        return self._append_app_name_and_version(path)
+
+    @property
+    def user_log_dir(self) -> str:
+        """:return: log directory tied to the user, same as `user_state_dir` if not opinionated else ``log`` in it"""
+        path = self.user_state_dir
+        if self.opinion:
+            path = os.path.join(path, "log")  # noqa: PTH118
+            self._optionally_create_directory(path)
+        return path
+
+    @property
+    def user_documents_dir(self) -> str:
+        """:return: documents directory tied to the user, e.g. ``~/Documents``"""
+        return _get_user_media_dir("XDG_DOCUMENTS_DIR", "~/Documents")
+
+    @property
+    def user_downloads_dir(self) -> str:
+        """:return: downloads directory tied to the user, e.g. ``~/Downloads``"""
+        return _get_user_media_dir("XDG_DOWNLOAD_DIR", "~/Downloads")
+
+    @property
+    def user_pictures_dir(self) -> str:
+        """:return: pictures directory tied to the user, e.g. ``~/Pictures``"""
+        return _get_user_media_dir("XDG_PICTURES_DIR", "~/Pictures")
+
+    @property
+    def user_videos_dir(self) -> str:
+        """:return: videos directory tied to the user, e.g. ``~/Videos``"""
+        return _get_user_media_dir("XDG_VIDEOS_DIR", "~/Videos")
+
+    @property
+    def user_music_dir(self) -> str:
+        """:return: music directory tied to the user, e.g. ``~/Music``"""
+        return _get_user_media_dir("XDG_MUSIC_DIR", "~/Music")
+
+    @property
+    def user_desktop_dir(self) -> str:
+        """:return: desktop directory tied to the user, e.g. ``~/Desktop``"""
+        return _get_user_media_dir("XDG_DESKTOP_DIR", "~/Desktop")
+
+    @property
+    def user_runtime_dir(self) -> str:
+        """
+        :return: runtime directory tied to the user, e.g. ``/run/user/$(id -u)/$appname/$version`` or
+         ``$XDG_RUNTIME_DIR/$appname/$version``.
+
+         For FreeBSD/OpenBSD/NetBSD, it would return ``/var/run/user/$(id -u)/$appname/$version`` if
+         exists, otherwise ``/tmp/runtime-$(id -u)/$appname/$version``, if``$XDG_RUNTIME_DIR``
+         is not set.
+        """
+        path = os.environ.get("XDG_RUNTIME_DIR", "")
+        if not path.strip():
+            if sys.platform.startswith(("freebsd", "openbsd", "netbsd")):
+                path = f"/var/run/user/{getuid()}"
+                if not Path(path).exists():
+                    path = f"/tmp/runtime-{getuid()}"  # noqa: S108
+            else:
+                path = f"/run/user/{getuid()}"
+        return self._append_app_name_and_version(path)
+
+    @property
+    def site_runtime_dir(self) -> str:
+        """
+        :return: runtime directory shared by users, e.g. ``/run/$appname/$version`` or \
+        ``$XDG_RUNTIME_DIR/$appname/$version``.
+
+        Note that this behaves almost exactly like `user_runtime_dir` if ``$XDG_RUNTIME_DIR`` is set, but will
+        fall back to paths associated to the root user instead of a regular logged-in user if it's not set.
+
+        If you wish to ensure that a logged-in root user path is returned e.g. ``/run/user/0``, use `user_runtime_dir`
+        instead.
+
+        For FreeBSD/OpenBSD/NetBSD, it would return ``/var/run/$appname/$version`` if ``$XDG_RUNTIME_DIR`` is not set.
+        """
+        path = os.environ.get("XDG_RUNTIME_DIR", "")
+        if not path.strip():
+            if sys.platform.startswith(("freebsd", "openbsd", "netbsd")):
+                path = "/var/run"
+            else:
+                path = "/run"
+        return self._append_app_name_and_version(path)
+
+    @property
+    def site_data_path(self) -> Path:
+        """:return: data path shared by users. Only return the first item, even if ``multipath`` is set to ``True``"""
+        return self._first_item_as_path_if_multipath(self.site_data_dir)
+
+    @property
+    def site_config_path(self) -> Path:
+        """:return: config path shared by the users, returns the first item, even if ``multipath`` is set to ``True``"""
+        return self._first_item_as_path_if_multipath(self.site_config_dir)
+
+    @property
+    def site_cache_path(self) -> Path:
+        """:return: cache path shared by users. Only return the first item, even if ``multipath`` is set to ``True``"""
+        return self._first_item_as_path_if_multipath(self.site_cache_dir)
+
+    def iter_config_dirs(self) -> Iterator[str]:
+        """:yield: all user and site configuration directories."""
+        yield self.user_config_dir
+        yield from self._site_config_dirs
+
+    def iter_data_dirs(self) -> Iterator[str]:
+        """:yield: all user and site data directories."""
+        yield self.user_data_dir
+        yield from self._site_data_dirs
+
+
+def _get_user_media_dir(env_var: str, fallback_tilde_path: str) -> str:
+    media_dir = _get_user_dirs_folder(env_var)
+    if media_dir is None:
+        media_dir = os.environ.get(env_var, "").strip()
+        if not media_dir:
+            media_dir = os.path.expanduser(fallback_tilde_path)  # noqa: PTH111
+
+    return media_dir
+
+
+def _get_user_dirs_folder(key: str) -> str | None:
+    """
+    Return directory from user-dirs.dirs config file.
+
+    See https://freedesktop.org/wiki/Software/xdg-user-dirs/.
+
+    """
+    user_dirs_config_path = Path(Unix().user_config_dir) / "user-dirs.dirs"
+    if user_dirs_config_path.exists():
+        parser = ConfigParser()
+
+        with user_dirs_config_path.open() as stream:
+            # Add fake section header, so ConfigParser doesn't complain
+            parser.read_string(f"[top]\n{stream.read()}")
+
+        if key not in parser["top"]:
+            return None
+
+        path = parser["top"][key].strip('"')
+        # Handle relative home paths
+        return path.replace("$HOME", os.path.expanduser("~"))  # noqa: PTH111
+
+    return None
+
+
+__all__ = [
+    "Unix",
+]
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/version.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/version.py
new file mode 100644
index 0000000000000000000000000000000000000000..b9451472c3c68e0d775e32c8b193bf93bf217107
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/version.py
@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '4.4.0'
+__version_tuple__ = version_tuple = (4, 4, 0)
+
+__commit_id__ = commit_id = None
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/windows.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/windows.py
new file mode 100644
index 0000000000000000000000000000000000000000..d7bc96091a2b1cd078a0847519cb5dd50a5d8898
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/platformdirs/windows.py
@@ -0,0 +1,272 @@
+"""Windows."""
+
+from __future__ import annotations
+
+import os
+import sys
+from functools import lru_cache
+from typing import TYPE_CHECKING
+
+from .api import PlatformDirsABC
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+class Windows(PlatformDirsABC):
+    """
+    `MSDN on where to store app data files `_.
+
+    Makes use of the `appname `, `appauthor
+    `, `version `, `roaming
+    `, `opinion `, `ensure_exists
+    `.
+
+    """
+
+    @property
+    def user_data_dir(self) -> str:
+        """
+        :return: data directory tied to the user, e.g.
+         ``%USERPROFILE%\\AppData\\Local\\$appauthor\\$appname`` (not roaming) or
+         ``%USERPROFILE%\\AppData\\Roaming\\$appauthor\\$appname`` (roaming)
+        """
+        const = "CSIDL_APPDATA" if self.roaming else "CSIDL_LOCAL_APPDATA"
+        path = os.path.normpath(get_win_folder(const))
+        return self._append_parts(path)
+
+    def _append_parts(self, path: str, *, opinion_value: str | None = None) -> str:
+        params = []
+        if self.appname:
+            if self.appauthor is not False:
+                author = self.appauthor or self.appname
+                params.append(author)
+            params.append(self.appname)
+            if opinion_value is not None and self.opinion:
+                params.append(opinion_value)
+            if self.version:
+                params.append(self.version)
+        path = os.path.join(path, *params)  # noqa: PTH118
+        self._optionally_create_directory(path)
+        return path
+
+    @property
+    def site_data_dir(self) -> str:
+        """:return: data directory shared by users, e.g. ``C:\\ProgramData\\$appauthor\\$appname``"""
+        path = os.path.normpath(get_win_folder("CSIDL_COMMON_APPDATA"))
+        return self._append_parts(path)
+
+    @property
+    def user_config_dir(self) -> str:
+        """:return: config directory tied to the user, same as `user_data_dir`"""
+        return self.user_data_dir
+
+    @property
+    def site_config_dir(self) -> str:
+        """:return: config directory shared by the users, same as `site_data_dir`"""
+        return self.site_data_dir
+
+    @property
+    def user_cache_dir(self) -> str:
+        """
+        :return: cache directory tied to the user (if opinionated with ``Cache`` folder within ``$appname``) e.g.
+         ``%USERPROFILE%\\AppData\\Local\\$appauthor\\$appname\\Cache\\$version``
+        """
+        path = os.path.normpath(get_win_folder("CSIDL_LOCAL_APPDATA"))
+        return self._append_parts(path, opinion_value="Cache")
+
+    @property
+    def site_cache_dir(self) -> str:
+        """:return: cache directory shared by users, e.g. ``C:\\ProgramData\\$appauthor\\$appname\\Cache\\$version``"""
+        path = os.path.normpath(get_win_folder("CSIDL_COMMON_APPDATA"))
+        return self._append_parts(path, opinion_value="Cache")
+
+    @property
+    def user_state_dir(self) -> str:
+        """:return: state directory tied to the user, same as `user_data_dir`"""
+        return self.user_data_dir
+
+    @property
+    def user_log_dir(self) -> str:
+        """:return: log directory tied to the user, same as `user_data_dir` if not opinionated else ``Logs`` in it"""
+        path = self.user_data_dir
+        if self.opinion:
+            path = os.path.join(path, "Logs")  # noqa: PTH118
+            self._optionally_create_directory(path)
+        return path
+
+    @property
+    def user_documents_dir(self) -> str:
+        """:return: documents directory tied to the user e.g. ``%USERPROFILE%\\Documents``"""
+        return os.path.normpath(get_win_folder("CSIDL_PERSONAL"))
+
+    @property
+    def user_downloads_dir(self) -> str:
+        """:return: downloads directory tied to the user e.g. ``%USERPROFILE%\\Downloads``"""
+        return os.path.normpath(get_win_folder("CSIDL_DOWNLOADS"))
+
+    @property
+    def user_pictures_dir(self) -> str:
+        """:return: pictures directory tied to the user e.g. ``%USERPROFILE%\\Pictures``"""
+        return os.path.normpath(get_win_folder("CSIDL_MYPICTURES"))
+
+    @property
+    def user_videos_dir(self) -> str:
+        """:return: videos directory tied to the user e.g. ``%USERPROFILE%\\Videos``"""
+        return os.path.normpath(get_win_folder("CSIDL_MYVIDEO"))
+
+    @property
+    def user_music_dir(self) -> str:
+        """:return: music directory tied to the user e.g. ``%USERPROFILE%\\Music``"""
+        return os.path.normpath(get_win_folder("CSIDL_MYMUSIC"))
+
+    @property
+    def user_desktop_dir(self) -> str:
+        """:return: desktop directory tied to the user, e.g. ``%USERPROFILE%\\Desktop``"""
+        return os.path.normpath(get_win_folder("CSIDL_DESKTOPDIRECTORY"))
+
+    @property
+    def user_runtime_dir(self) -> str:
+        """
+        :return: runtime directory tied to the user, e.g.
+         ``%USERPROFILE%\\AppData\\Local\\Temp\\$appauthor\\$appname``
+        """
+        path = os.path.normpath(os.path.join(get_win_folder("CSIDL_LOCAL_APPDATA"), "Temp"))  # noqa: PTH118
+        return self._append_parts(path)
+
+    @property
+    def site_runtime_dir(self) -> str:
+        """:return: runtime directory shared by users, same as `user_runtime_dir`"""
+        return self.user_runtime_dir
+
+
+def get_win_folder_from_env_vars(csidl_name: str) -> str:
+    """Get folder from environment variables."""
+    result = get_win_folder_if_csidl_name_not_env_var(csidl_name)
+    if result is not None:
+        return result
+
+    env_var_name = {
+        "CSIDL_APPDATA": "APPDATA",
+        "CSIDL_COMMON_APPDATA": "ALLUSERSPROFILE",
+        "CSIDL_LOCAL_APPDATA": "LOCALAPPDATA",
+    }.get(csidl_name)
+    if env_var_name is None:
+        msg = f"Unknown CSIDL name: {csidl_name}"
+        raise ValueError(msg)
+    result = os.environ.get(env_var_name)
+    if result is None:
+        msg = f"Unset environment variable: {env_var_name}"
+        raise ValueError(msg)
+    return result
+
+
+def get_win_folder_if_csidl_name_not_env_var(csidl_name: str) -> str | None:
+    """Get a folder for a CSIDL name that does not exist as an environment variable."""
+    if csidl_name == "CSIDL_PERSONAL":
+        return os.path.join(os.path.normpath(os.environ["USERPROFILE"]), "Documents")  # noqa: PTH118
+
+    if csidl_name == "CSIDL_DOWNLOADS":
+        return os.path.join(os.path.normpath(os.environ["USERPROFILE"]), "Downloads")  # noqa: PTH118
+
+    if csidl_name == "CSIDL_MYPICTURES":
+        return os.path.join(os.path.normpath(os.environ["USERPROFILE"]), "Pictures")  # noqa: PTH118
+
+    if csidl_name == "CSIDL_MYVIDEO":
+        return os.path.join(os.path.normpath(os.environ["USERPROFILE"]), "Videos")  # noqa: PTH118
+
+    if csidl_name == "CSIDL_MYMUSIC":
+        return os.path.join(os.path.normpath(os.environ["USERPROFILE"]), "Music")  # noqa: PTH118
+    return None
+
+
+def get_win_folder_from_registry(csidl_name: str) -> str:
+    """
+    Get folder from the registry.
+
+    This is a fallback technique at best. I'm not sure if using the registry for these guarantees us the correct answer
+    for all CSIDL_* names.
+
+    """
+    shell_folder_name = {
+        "CSIDL_APPDATA": "AppData",
+        "CSIDL_COMMON_APPDATA": "Common AppData",
+        "CSIDL_LOCAL_APPDATA": "Local AppData",
+        "CSIDL_PERSONAL": "Personal",
+        "CSIDL_DOWNLOADS": "{374DE290-123F-4565-9164-39C4925E467B}",
+        "CSIDL_MYPICTURES": "My Pictures",
+        "CSIDL_MYVIDEO": "My Video",
+        "CSIDL_MYMUSIC": "My Music",
+    }.get(csidl_name)
+    if shell_folder_name is None:
+        msg = f"Unknown CSIDL name: {csidl_name}"
+        raise ValueError(msg)
+    if sys.platform != "win32":  # only needed for mypy type checker to know that this code runs only on Windows
+        raise NotImplementedError
+    import winreg  # noqa: PLC0415
+
+    key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders")
+    directory, _ = winreg.QueryValueEx(key, shell_folder_name)
+    return str(directory)
+
+
+def get_win_folder_via_ctypes(csidl_name: str) -> str:
+    """Get folder with ctypes."""
+    # There is no 'CSIDL_DOWNLOADS'.
+    # Use 'CSIDL_PROFILE' (40) and append the default folder 'Downloads' instead.
+    # https://learn.microsoft.com/en-us/windows/win32/shell/knownfolderid
+
+    import ctypes  # noqa: PLC0415
+
+    csidl_const = {
+        "CSIDL_APPDATA": 26,
+        "CSIDL_COMMON_APPDATA": 35,
+        "CSIDL_LOCAL_APPDATA": 28,
+        "CSIDL_PERSONAL": 5,
+        "CSIDL_MYPICTURES": 39,
+        "CSIDL_MYVIDEO": 14,
+        "CSIDL_MYMUSIC": 13,
+        "CSIDL_DOWNLOADS": 40,
+        "CSIDL_DESKTOPDIRECTORY": 16,
+    }.get(csidl_name)
+    if csidl_const is None:
+        msg = f"Unknown CSIDL name: {csidl_name}"
+        raise ValueError(msg)
+
+    buf = ctypes.create_unicode_buffer(1024)
+    windll = getattr(ctypes, "windll")  # noqa: B009 # using getattr to avoid false positive with mypy type checker
+    windll.shell32.SHGetFolderPathW(None, csidl_const, None, 0, buf)
+
+    # Downgrade to short path name if it has high-bit chars.
+    if any(ord(c) > 255 for c in buf):  # noqa: PLR2004
+        buf2 = ctypes.create_unicode_buffer(1024)
+        if windll.kernel32.GetShortPathNameW(buf.value, buf2, 1024):
+            buf = buf2
+
+    if csidl_name == "CSIDL_DOWNLOADS":
+        return os.path.join(buf.value, "Downloads")  # noqa: PTH118
+
+    return buf.value
+
+
+def _pick_get_win_folder() -> Callable[[str], str]:
+    try:
+        import ctypes  # noqa: PLC0415
+    except ImportError:
+        pass
+    else:
+        if hasattr(ctypes, "windll"):
+            return get_win_folder_via_ctypes
+    try:
+        import winreg  # noqa: PLC0415, F401
+    except ImportError:
+        return get_win_folder_from_env_vars
+    else:
+        return get_win_folder_from_registry
+
+
+get_win_folder = lru_cache(maxsize=None)(_pick_get_win_folder())
+
+__all__ = [
+    "Windows",
+]
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli-2.4.0.dist-info/INSTALLER b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli-2.4.0.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..5c69047b2eb8235994febeeae1da4a82365a240a
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli-2.4.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+uv
\ No newline at end of file
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli-2.4.0.dist-info/METADATA b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli-2.4.0.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..ffe8e40d77f07e829e420f056b7ecd9c81ec38a5
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli-2.4.0.dist-info/METADATA
@@ -0,0 +1,270 @@
+Metadata-Version: 2.4
+Name: tomli
+Version: 2.4.0
+Summary: A lil' TOML parser
+Keywords: toml
+Author-email: Taneli Hukkinen 
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-Expression: MIT
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+License-File: LICENSE
+Project-URL: Changelog, https://github.com/hukkin/tomli/blob/master/CHANGELOG.md
+Project-URL: Homepage, https://github.com/hukkin/tomli
+
+[![Build Status](https://github.com/hukkin/tomli/actions/workflows/tests.yaml/badge.svg?branch=master)](https://github.com/hukkin/tomli/actions?query=workflow%3ATests+branch%3Amaster+event%3Apush)
+[![codecov.io](https://codecov.io/gh/hukkin/tomli/branch/master/graph/badge.svg)](https://codecov.io/gh/hukkin/tomli)
+[![PyPI version](https://img.shields.io/pypi/v/tomli)](https://pypi.org/project/tomli)
+
+# Tomli
+
+> A lil' TOML parser
+
+**Table of Contents** *generated with [mdformat-toc](https://github.com/hukkin/mdformat-toc)*
+
+
+
+- [Intro](#intro)
+- [Installation](#installation)
+- [Usage](#usage)
+  - [Parse a TOML string](#parse-a-toml-string)
+  - [Parse a TOML file](#parse-a-toml-file)
+  - [Handle invalid TOML](#handle-invalid-toml)
+  - [Construct `decimal.Decimal`s from TOML floats](#construct-decimaldecimals-from-toml-floats)
+  - [Building a `tomli`/`tomllib` compatibility layer](#building-a-tomlitomllib-compatibility-layer)
+- [FAQ](#faq)
+  - [Why this parser?](#why-this-parser)
+  - [Is comment preserving round-trip parsing supported?](#is-comment-preserving-round-trip-parsing-supported)
+  - [Is there a `dumps`, `write` or `encode` function?](#is-there-a-dumps-write-or-encode-function)
+  - [How do TOML types map into Python types?](#how-do-toml-types-map-into-python-types)
+- [Performance](#performance)
+  - [Pure Python](#pure-python)
+  - [Mypyc generated wheel](#mypyc-generated-wheel)
+
+
+
+## Intro
+
+Tomli is a Python library for parsing [TOML](https://toml.io).
+Version 2.4.0 and later are compatible with [TOML v1.1.0](https://toml.io/en/v1.1.0).
+Older versions are [TOML v1.0.0](https://toml.io/en/v1.0.0) compatible.
+
+A version of Tomli, the `tomllib` module,
+was added to the standard library in Python 3.11
+via [PEP 680](https://www.python.org/dev/peps/pep-0680/).
+Tomli continues to provide a backport on PyPI for Python versions
+where the standard library module is not available
+and that have not yet reached their end-of-life.
+
+Tomli uses [mypyc](https://github.com/mypyc/mypyc)
+to generate binary wheels for most of the widely used platforms,
+so Python 3.11+ users may prefer it over `tomllib` for improved performance.
+Pure Python wheels are available on any platform and should perform the same as `tomllib`.
+
+## Installation
+
+```bash
+pip install tomli
+```
+
+## Usage
+
+### Parse a TOML string
+
+```python
+import tomli
+
+toml_str = """
+[[players]]
+name = "Lehtinen"
+number = 26
+
+[[players]]
+name = "Numminen"
+number = 27
+"""
+
+toml_dict = tomli.loads(toml_str)
+assert toml_dict == {
+    "players": [{"name": "Lehtinen", "number": 26}, {"name": "Numminen", "number": 27}]
+}
+```
+
+### Parse a TOML file
+
+```python
+import tomli
+
+with open("path_to_file/conf.toml", "rb") as f:
+    toml_dict = tomli.load(f)
+```
+
+The file must be opened in binary mode (with the `"rb"` flag).
+Binary mode will enforce decoding the file as UTF-8 with universal newlines disabled,
+both of which are required to correctly parse TOML.
+
+### Handle invalid TOML
+
+```python
+import tomli
+
+try:
+    toml_dict = tomli.loads("]] this is invalid TOML [[")
+except tomli.TOMLDecodeError:
+    print("Yep, definitely not valid.")
+```
+
+Note that error messages are considered informational only.
+They should not be assumed to stay constant across Tomli versions.
+
+### Construct `decimal.Decimal`s from TOML floats
+
+```python
+from decimal import Decimal
+import tomli
+
+toml_dict = tomli.loads("precision-matters = 0.982492", parse_float=Decimal)
+assert isinstance(toml_dict["precision-matters"], Decimal)
+assert toml_dict["precision-matters"] == Decimal("0.982492")
+```
+
+Note that `decimal.Decimal` can be replaced with another callable that converts a TOML float from string to a Python type.
+The `decimal.Decimal` is, however, a practical choice for use cases where float inaccuracies can not be tolerated.
+
+Illegal types are `dict` and `list`, and their subtypes.
+A `ValueError` will be raised if `parse_float` produces illegal types.
+
+### Building a `tomli`/`tomllib` compatibility layer
+
+Python versions 3.11+ ship with a version of Tomli:
+the `tomllib` standard library module.
+To build code that uses the standard library if available,
+but still works seamlessly with Python 3.6+,
+do the following.
+
+Instead of a hard Tomli dependency, use the following
+[dependency specifier](https://packaging.python.org/en/latest/specifications/dependency-specifiers/)
+to only require Tomli when the standard library module is not available:
+
+```
+tomli >= 1.1.0 ; python_version < "3.11"
+```
+
+Then, in your code, import a TOML parser using the following fallback mechanism:
+
+```python
+import sys
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+tomllib.loads("['This parses fine with Python 3.6+']")
+```
+
+## FAQ
+
+### Why this parser?
+
+- it's lil'
+- pure Python with zero dependencies
+- the fastest pure Python parser [\*](#pure-python):
+  18x as fast as [tomlkit](https://pypi.org/project/tomlkit/),
+  2.1x as fast as [toml](https://pypi.org/project/toml/)
+- outputs [basic data types](#how-do-toml-types-map-into-python-types) only
+- 100% spec compliant: passes all tests in
+  [toml-lang/toml-test](https://github.com/toml-lang/toml-test)
+  test suite
+- thoroughly tested: 100% branch coverage
+
+### Is comment preserving round-trip parsing supported?
+
+No.
+
+The `tomli.loads` function returns a plain `dict` that is populated with builtin types and types from the standard library only.
+Preserving comments requires a custom type to be returned so will not be supported,
+at least not by the `tomli.loads` and `tomli.load` functions.
+
+Look into [TOML Kit](https://github.com/sdispater/tomlkit) if preservation of style is what you need.
+
+### Is there a `dumps`, `write` or `encode` function?
+
+[Tomli-W](https://github.com/hukkin/tomli-w) is the write-only counterpart of Tomli, providing `dump` and `dumps` functions.
+
+The core library does not include write capability, as most TOML use cases are read-only, and Tomli intends to be minimal.
+
+### How do TOML types map into Python types?
+
+| TOML type        | Python type         | Details                                                      |
+| ---------------- | ------------------- | ------------------------------------------------------------ |
+| Document Root    | `dict`              |                                                              |
+| Key              | `str`               |                                                              |
+| String           | `str`               |                                                              |
+| Integer          | `int`               |                                                              |
+| Float            | `float`             |                                                              |
+| Boolean          | `bool`              |                                                              |
+| Offset Date-Time | `datetime.datetime` | `tzinfo` attribute set to an instance of `datetime.timezone` |
+| Local Date-Time  | `datetime.datetime` | `tzinfo` attribute set to `None`                             |
+| Local Date       | `datetime.date`     |                                                              |
+| Local Time       | `datetime.time`     |                                                              |
+| Array            | `list`              |                                                              |
+| Table            | `dict`              |                                                              |
+| Inline Table     | `dict`              |                                                              |
+
+## Performance
+
+The `benchmark/` folder in this repository contains a performance benchmark for comparing the various Python TOML parsers.
+
+Below are the results for commit [0724e2a](https://github.com/hukkin/tomli/tree/0724e2ab1858da7f5e05a9bffdb24c33589d951c).
+
+### Pure Python
+
+```console
+foo@bar:~/dev/tomli$ python --version
+Python 3.12.7
+foo@bar:~/dev/tomli$ pip freeze
+attrs==21.4.0
+click==8.1.7
+pytomlpp==1.0.13
+qtoml==0.3.1
+rtoml==0.11.0
+toml==0.10.2
+tomli @ file:///home/foo/dev/tomli
+tomlkit==0.13.2
+foo@bar:~/dev/tomli$ python benchmark/run.py
+Parsing data.toml 5000 times:
+------------------------------------------------------
+    parser |  exec time | performance (more is better)
+-----------+------------+-----------------------------
+     rtoml |    0.647 s | baseline (100%)
+  pytomlpp |    0.891 s | 72.62%
+     tomli |     3.14 s | 20.56%
+      toml |     6.69 s | 9.67%
+     qtoml |     8.27 s | 7.82%
+   tomlkit |     56.1 s | 1.15%
+```
+
+### Mypyc generated wheel
+
+```console
+foo@bar:~/dev/tomli$ python benchmark/run.py
+Parsing data.toml 5000 times:
+------------------------------------------------------
+    parser |  exec time | performance (more is better)
+-----------+------------+-----------------------------
+     rtoml |    0.668 s | baseline (100%)
+  pytomlpp |    0.893 s | 74.81%
+     tomli |     1.96 s | 34.18%
+      toml |     6.64 s | 10.07%
+     qtoml |     8.26 s | 8.09%
+   tomlkit |     52.9 s | 1.26%
+```
+
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli-2.4.0.dist-info/RECORD b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli-2.4.0.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..d2415a38de6198f1dad22ba1de542d15cd7065b3
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli-2.4.0.dist-info/RECORD
@@ -0,0 +1,11 @@
+tomli-2.4.0.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+tomli-2.4.0.dist-info/METADATA,sha256=9awKH4-6kItGRs1lUwnpGq2Wm2eHYWrFccpGKjgy_84,10567
+tomli-2.4.0.dist-info/RECORD,,
+tomli-2.4.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tomli-2.4.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+tomli-2.4.0.dist-info/licenses/LICENSE,sha256=uAgWsNUwuKzLTCIReDeQmEpuO2GSLCte6S8zcqsnQv4,1072
+tomli/__init__.py,sha256=ahtDjGJA2M_wWVvGpzx4YJtWxrWBx6qE-GH5-UYoECA,314
+tomli/_parser.py,sha256=txeATLE3zHyZ-ushXtYfrZ3LoIs7JzQF2W2KL1gwJPg,25958
+tomli/_re.py,sha256=oSNZ_ilFI6chEuQ01YRSoUydBQr_okF_mSdHTkFmv90,3396
+tomli/_types.py,sha256=-GTG2VUqkpxwMqzmVO4F7ybKddIbAnuAHXfmWQcTi3Q,254
+tomli/py.typed,sha256=8PjyZ1aVoQpRVvt71muvuq5qE-jTFZkK-GLHkhdebmc,26
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli-2.4.0.dist-info/REQUESTED b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli-2.4.0.dist-info/REQUESTED
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli-2.4.0.dist-info/WHEEL b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli-2.4.0.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..d8b9936dad9ab2513fa6979f411560d3b6b57e37
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli-2.4.0.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.12.0
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli/__init__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..55699b1ea68247f72a382dc11cd2b5c4b07d24fd
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli/__init__.py
@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: 2021 Taneli Hukkinen
+# Licensed to PSF under a Contributor Agreement.
+
+__all__ = ("loads", "load", "TOMLDecodeError")
+__version__ = "2.4.0"  # DO NOT EDIT THIS LINE MANUALLY. LET bump2version UTILITY DO IT
+
+from ._parser import TOMLDecodeError, load, loads
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1921b443c15e6f7e8551b815a42a3df71ab8b609
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli/__pycache__/_parser.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli/__pycache__/_parser.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6d86c11ea01b3dddf5cadc7298c36594735a4ac8
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli/__pycache__/_parser.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli/__pycache__/_re.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli/__pycache__/_re.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5c44f354ff0483b81e200ab8664b33da2de832fb
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli/__pycache__/_re.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli/__pycache__/_types.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli/__pycache__/_types.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..880261c718a8509a6b39de56497037f06c14c23b
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli/__pycache__/_types.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli/_parser.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli/_parser.py
new file mode 100644
index 0000000000000000000000000000000000000000..3038891afec8d4e6608ae4209365cf31f94b7f41
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli/_parser.py
@@ -0,0 +1,782 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: 2021 Taneli Hukkinen
+# Licensed to PSF under a Contributor Agreement.
+
+from __future__ import annotations
+
+import sys
+from types import MappingProxyType
+
+from ._re import (
+    RE_DATETIME,
+    RE_LOCALTIME,
+    RE_NUMBER,
+    match_to_datetime,
+    match_to_localtime,
+    match_to_number,
+)
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from typing import IO, Any, Final
+
+    from ._types import Key, ParseFloat, Pos
+
+# Inline tables/arrays are implemented using recursion. Pathologically
+# nested documents cause pure Python to raise RecursionError (which is OK),
+# but mypyc binary wheels will crash unrecoverably (not OK). According to
+# mypyc docs this will be fixed in the future:
+# https://mypyc.readthedocs.io/en/latest/differences_from_python.html#stack-overflows
+# Before mypyc's fix is in, recursion needs to be limited by this library.
+# Choosing `sys.getrecursionlimit()` as maximum inline table/array nesting
+# level, as it allows more nesting than pure Python, but still seems a far
+# lower number than where mypyc binaries crash.
+MAX_INLINE_NESTING: Final = sys.getrecursionlimit()
+
+ASCII_CTRL: Final = frozenset(chr(i) for i in range(32)) | frozenset(chr(127))
+
+# Neither of these sets include quotation mark or backslash. They are
+# currently handled as separate cases in the parser functions.
+ILLEGAL_BASIC_STR_CHARS: Final = ASCII_CTRL - frozenset("\t")
+ILLEGAL_MULTILINE_BASIC_STR_CHARS: Final = ASCII_CTRL - frozenset("\t\n")
+
+ILLEGAL_LITERAL_STR_CHARS: Final = ILLEGAL_BASIC_STR_CHARS
+ILLEGAL_MULTILINE_LITERAL_STR_CHARS: Final = ILLEGAL_MULTILINE_BASIC_STR_CHARS
+
+ILLEGAL_COMMENT_CHARS: Final = ILLEGAL_BASIC_STR_CHARS
+
+TOML_WS: Final = frozenset(" \t")
+TOML_WS_AND_NEWLINE: Final = TOML_WS | frozenset("\n")
+BARE_KEY_CHARS: Final = frozenset(
+    "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "0123456789" "-_"
+)
+KEY_INITIAL_CHARS: Final = BARE_KEY_CHARS | frozenset("\"'")
+HEXDIGIT_CHARS: Final = frozenset("abcdef" "ABCDEF" "0123456789")
+
+BASIC_STR_ESCAPE_REPLACEMENTS: Final = MappingProxyType(
+    {
+        "\\b": "\u0008",  # backspace
+        "\\t": "\u0009",  # tab
+        "\\n": "\u000a",  # linefeed
+        "\\f": "\u000c",  # form feed
+        "\\r": "\u000d",  # carriage return
+        "\\e": "\u001b",  # escape
+        '\\"': "\u0022",  # quote
+        "\\\\": "\u005c",  # backslash
+    }
+)
+
+
+class DEPRECATED_DEFAULT:
+    """Sentinel to be used as default arg during deprecation
+    period of TOMLDecodeError's free-form arguments."""
+
+
+class TOMLDecodeError(ValueError):
+    """An error raised if a document is not valid TOML.
+
+    Adds the following attributes to ValueError:
+    msg: The unformatted error message
+    doc: The TOML document being parsed
+    pos: The index of doc where parsing failed
+    lineno: The line corresponding to pos
+    colno: The column corresponding to pos
+    """
+
+    def __init__(
+        self,
+        msg: str | type[DEPRECATED_DEFAULT] = DEPRECATED_DEFAULT,
+        doc: str | type[DEPRECATED_DEFAULT] = DEPRECATED_DEFAULT,
+        pos: Pos | type[DEPRECATED_DEFAULT] = DEPRECATED_DEFAULT,
+        *args: Any,
+    ):
+        if (
+            args
+            or not isinstance(msg, str)
+            or not isinstance(doc, str)
+            or not isinstance(pos, int)
+        ):
+            import warnings
+
+            warnings.warn(
+                "Free-form arguments for TOMLDecodeError are deprecated. "
+                "Please set 'msg' (str), 'doc' (str) and 'pos' (int) arguments only.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            if pos is not DEPRECATED_DEFAULT:
+                args = pos, *args
+            if doc is not DEPRECATED_DEFAULT:
+                args = doc, *args
+            if msg is not DEPRECATED_DEFAULT:
+                args = msg, *args
+            ValueError.__init__(self, *args)
+            return
+
+        lineno = doc.count("\n", 0, pos) + 1
+        if lineno == 1:
+            colno = pos + 1
+        else:
+            colno = pos - doc.rindex("\n", 0, pos)
+
+        if pos >= len(doc):
+            coord_repr = "end of document"
+        else:
+            coord_repr = f"line {lineno}, column {colno}"
+        errmsg = f"{msg} (at {coord_repr})"
+        ValueError.__init__(self, errmsg)
+
+        self.msg = msg
+        self.doc = doc
+        self.pos = pos
+        self.lineno = lineno
+        self.colno = colno
+
+
+def load(__fp: IO[bytes], *, parse_float: ParseFloat = float) -> dict[str, Any]:
+    """Parse TOML from a binary file object."""
+    b = __fp.read()
+    try:
+        s = b.decode()
+    except AttributeError:
+        raise TypeError(
+            "File must be opened in binary mode, e.g. use `open('foo.toml', 'rb')`"
+        ) from None
+    return loads(s, parse_float=parse_float)
+
+
+def loads(__s: str, *, parse_float: ParseFloat = float) -> dict[str, Any]:
+    """Parse TOML from a string."""
+
+    # The spec allows converting "\r\n" to "\n", even in string
+    # literals. Let's do so to simplify parsing.
+    try:
+        src = __s.replace("\r\n", "\n")
+    except (AttributeError, TypeError):
+        raise TypeError(
+            f"Expected str object, not '{type(__s).__qualname__}'"
+        ) from None
+    pos = 0
+    out = Output()
+    header: Key = ()
+    parse_float = make_safe_parse_float(parse_float)
+
+    # Parse one statement at a time
+    # (typically means one line in TOML source)
+    while True:
+        # 1. Skip line leading whitespace
+        pos = skip_chars(src, pos, TOML_WS)
+
+        # 2. Parse rules. Expect one of the following:
+        #    - end of file
+        #    - end of line
+        #    - comment
+        #    - key/value pair
+        #    - append dict to list (and move to its namespace)
+        #    - create dict (and move to its namespace)
+        # Skip trailing whitespace when applicable.
+        try:
+            char = src[pos]
+        except IndexError:
+            break
+        if char == "\n":
+            pos += 1
+            continue
+        if char in KEY_INITIAL_CHARS:
+            pos = key_value_rule(src, pos, out, header, parse_float)
+            pos = skip_chars(src, pos, TOML_WS)
+        elif char == "[":
+            try:
+                second_char: str | None = src[pos + 1]
+            except IndexError:
+                second_char = None
+            out.flags.finalize_pending()
+            if second_char == "[":
+                pos, header = create_list_rule(src, pos, out)
+            else:
+                pos, header = create_dict_rule(src, pos, out)
+            pos = skip_chars(src, pos, TOML_WS)
+        elif char != "#":
+            raise TOMLDecodeError("Invalid statement", src, pos)
+
+        # 3. Skip comment
+        pos = skip_comment(src, pos)
+
+        # 4. Expect end of line or end of file
+        try:
+            char = src[pos]
+        except IndexError:
+            break
+        if char != "\n":
+            raise TOMLDecodeError(
+                "Expected newline or end of document after a statement", src, pos
+            )
+        pos += 1
+
+    return out.data.dict
+
+
+class Flags:
+    """Flags that map to parsed keys/namespaces."""
+
+    # Marks an immutable namespace (inline array or inline table).
+    FROZEN: Final = 0
+    # Marks a nest that has been explicitly created and can no longer
+    # be opened using the "[table]" syntax.
+    EXPLICIT_NEST: Final = 1
+
+    def __init__(self) -> None:
+        self._flags: dict[str, dict[Any, Any]] = {}
+        self._pending_flags: set[tuple[Key, int]] = set()
+
+    def add_pending(self, key: Key, flag: int) -> None:
+        self._pending_flags.add((key, flag))
+
+    def finalize_pending(self) -> None:
+        for key, flag in self._pending_flags:
+            self.set(key, flag, recursive=False)
+        self._pending_flags.clear()
+
+    def unset_all(self, key: Key) -> None:
+        cont = self._flags
+        for k in key[:-1]:
+            if k not in cont:
+                return
+            cont = cont[k]["nested"]
+        cont.pop(key[-1], None)
+
+    def set(self, key: Key, flag: int, *, recursive: bool) -> None:  # noqa: A003
+        cont = self._flags
+        key_parent, key_stem = key[:-1], key[-1]
+        for k in key_parent:
+            if k not in cont:
+                cont[k] = {"flags": set(), "recursive_flags": set(), "nested": {}}
+            cont = cont[k]["nested"]
+        if key_stem not in cont:
+            cont[key_stem] = {"flags": set(), "recursive_flags": set(), "nested": {}}
+        cont[key_stem]["recursive_flags" if recursive else "flags"].add(flag)
+
+    def is_(self, key: Key, flag: int) -> bool:
+        if not key:
+            return False  # document root has no flags
+        cont = self._flags
+        for k in key[:-1]:
+            if k not in cont:
+                return False
+            inner_cont = cont[k]
+            if flag in inner_cont["recursive_flags"]:
+                return True
+            cont = inner_cont["nested"]
+        key_stem = key[-1]
+        if key_stem in cont:
+            inner_cont = cont[key_stem]
+            return flag in inner_cont["flags"] or flag in inner_cont["recursive_flags"]
+        return False
+
+
+class NestedDict:
+    def __init__(self) -> None:
+        # The parsed content of the TOML document
+        self.dict: dict[str, Any] = {}
+
+    def get_or_create_nest(
+        self,
+        key: Key,
+        *,
+        access_lists: bool = True,
+    ) -> dict[str, Any]:
+        cont: Any = self.dict
+        for k in key:
+            if k not in cont:
+                cont[k] = {}
+            cont = cont[k]
+            if access_lists and isinstance(cont, list):
+                cont = cont[-1]
+            if not isinstance(cont, dict):
+                raise KeyError("There is no nest behind this key")
+        return cont  # type: ignore[no-any-return]
+
+    def append_nest_to_list(self, key: Key) -> None:
+        cont = self.get_or_create_nest(key[:-1])
+        last_key = key[-1]
+        if last_key in cont:
+            list_ = cont[last_key]
+            if not isinstance(list_, list):
+                raise KeyError("An object other than list found behind this key")
+            list_.append({})
+        else:
+            cont[last_key] = [{}]
+
+
+class Output:
+    def __init__(self) -> None:
+        self.data = NestedDict()
+        self.flags = Flags()
+
+
+def skip_chars(src: str, pos: Pos, chars: Iterable[str]) -> Pos:
+    try:
+        while src[pos] in chars:
+            pos += 1
+    except IndexError:
+        pass
+    return pos
+
+
+def skip_until(
+    src: str,
+    pos: Pos,
+    expect: str,
+    *,
+    error_on: frozenset[str],
+    error_on_eof: bool,
+) -> Pos:
+    try:
+        new_pos = src.index(expect, pos)
+    except ValueError:
+        new_pos = len(src)
+        if error_on_eof:
+            raise TOMLDecodeError(f"Expected {expect!r}", src, new_pos) from None
+
+    if not error_on.isdisjoint(src[pos:new_pos]):
+        while src[pos] not in error_on:
+            pos += 1
+        raise TOMLDecodeError(f"Found invalid character {src[pos]!r}", src, pos)
+    return new_pos
+
+
+def skip_comment(src: str, pos: Pos) -> Pos:
+    try:
+        char: str | None = src[pos]
+    except IndexError:
+        char = None
+    if char == "#":
+        return skip_until(
+            src, pos + 1, "\n", error_on=ILLEGAL_COMMENT_CHARS, error_on_eof=False
+        )
+    return pos
+
+
+def skip_comments_and_array_ws(src: str, pos: Pos) -> Pos:
+    while True:
+        pos_before_skip = pos
+        pos = skip_chars(src, pos, TOML_WS_AND_NEWLINE)
+        pos = skip_comment(src, pos)
+        if pos == pos_before_skip:
+            return pos
+
+
+def create_dict_rule(src: str, pos: Pos, out: Output) -> tuple[Pos, Key]:
+    pos += 1  # Skip "["
+    pos = skip_chars(src, pos, TOML_WS)
+    pos, key = parse_key(src, pos)
+
+    if out.flags.is_(key, Flags.EXPLICIT_NEST) or out.flags.is_(key, Flags.FROZEN):
+        raise TOMLDecodeError(f"Cannot declare {key} twice", src, pos)
+    out.flags.set(key, Flags.EXPLICIT_NEST, recursive=False)
+    try:
+        out.data.get_or_create_nest(key)
+    except KeyError:
+        raise TOMLDecodeError("Cannot overwrite a value", src, pos) from None
+
+    if not src.startswith("]", pos):
+        raise TOMLDecodeError(
+            "Expected ']' at the end of a table declaration", src, pos
+        )
+    return pos + 1, key
+
+
+def create_list_rule(src: str, pos: Pos, out: Output) -> tuple[Pos, Key]:
+    pos += 2  # Skip "[["
+    pos = skip_chars(src, pos, TOML_WS)
+    pos, key = parse_key(src, pos)
+
+    if out.flags.is_(key, Flags.FROZEN):
+        raise TOMLDecodeError(f"Cannot mutate immutable namespace {key}", src, pos)
+    # Free the namespace now that it points to another empty list item...
+    out.flags.unset_all(key)
+    # ...but this key precisely is still prohibited from table declaration
+    out.flags.set(key, Flags.EXPLICIT_NEST, recursive=False)
+    try:
+        out.data.append_nest_to_list(key)
+    except KeyError:
+        raise TOMLDecodeError("Cannot overwrite a value", src, pos) from None
+
+    if not src.startswith("]]", pos):
+        raise TOMLDecodeError(
+            "Expected ']]' at the end of an array declaration", src, pos
+        )
+    return pos + 2, key
+
+
+def key_value_rule(
+    src: str, pos: Pos, out: Output, header: Key, parse_float: ParseFloat
+) -> Pos:
+    pos, key, value = parse_key_value_pair(src, pos, parse_float, nest_lvl=0)
+    key_parent, key_stem = key[:-1], key[-1]
+    abs_key_parent = header + key_parent
+
+    relative_path_cont_keys = (header + key[:i] for i in range(1, len(key)))
+    for cont_key in relative_path_cont_keys:
+        # Check that dotted key syntax does not redefine an existing table
+        if out.flags.is_(cont_key, Flags.EXPLICIT_NEST):
+            raise TOMLDecodeError(f"Cannot redefine namespace {cont_key}", src, pos)
+        # Containers in the relative path can't be opened with the table syntax or
+        # dotted key/value syntax in following table sections.
+        out.flags.add_pending(cont_key, Flags.EXPLICIT_NEST)
+
+    if out.flags.is_(abs_key_parent, Flags.FROZEN):
+        raise TOMLDecodeError(
+            f"Cannot mutate immutable namespace {abs_key_parent}", src, pos
+        )
+
+    try:
+        nest = out.data.get_or_create_nest(abs_key_parent)
+    except KeyError:
+        raise TOMLDecodeError("Cannot overwrite a value", src, pos) from None
+    if key_stem in nest:
+        raise TOMLDecodeError("Cannot overwrite a value", src, pos)
+    # Mark inline table and array namespaces recursively immutable
+    if isinstance(value, (dict, list)):
+        out.flags.set(header + key, Flags.FROZEN, recursive=True)
+    nest[key_stem] = value
+    return pos
+
+
+def parse_key_value_pair(
+    src: str, pos: Pos, parse_float: ParseFloat, nest_lvl: int
+) -> tuple[Pos, Key, Any]:
+    pos, key = parse_key(src, pos)
+    try:
+        char: str | None = src[pos]
+    except IndexError:
+        char = None
+    if char != "=":
+        raise TOMLDecodeError("Expected '=' after a key in a key/value pair", src, pos)
+    pos += 1
+    pos = skip_chars(src, pos, TOML_WS)
+    pos, value = parse_value(src, pos, parse_float, nest_lvl)
+    return pos, key, value
+
+
+def parse_key(src: str, pos: Pos) -> tuple[Pos, Key]:
+    pos, key_part = parse_key_part(src, pos)
+    key: Key = (key_part,)
+    pos = skip_chars(src, pos, TOML_WS)
+    while True:
+        try:
+            char: str | None = src[pos]
+        except IndexError:
+            char = None
+        if char != ".":
+            return pos, key
+        pos += 1
+        pos = skip_chars(src, pos, TOML_WS)
+        pos, key_part = parse_key_part(src, pos)
+        key += (key_part,)
+        pos = skip_chars(src, pos, TOML_WS)
+
+
+def parse_key_part(src: str, pos: Pos) -> tuple[Pos, str]:
+    try:
+        char: str | None = src[pos]
+    except IndexError:
+        char = None
+    if char in BARE_KEY_CHARS:
+        start_pos = pos
+        pos = skip_chars(src, pos, BARE_KEY_CHARS)
+        return pos, src[start_pos:pos]
+    if char == "'":
+        return parse_literal_str(src, pos)
+    if char == '"':
+        return parse_one_line_basic_str(src, pos)
+    raise TOMLDecodeError("Invalid initial character for a key part", src, pos)
+
+
+def parse_one_line_basic_str(src: str, pos: Pos) -> tuple[Pos, str]:
+    pos += 1
+    return parse_basic_str(src, pos, multiline=False)
+
+
+def parse_array(
+    src: str, pos: Pos, parse_float: ParseFloat, nest_lvl: int
+) -> tuple[Pos, list[Any]]:
+    pos += 1
+    array: list[Any] = []
+
+    pos = skip_comments_and_array_ws(src, pos)
+    if src.startswith("]", pos):
+        return pos + 1, array
+    while True:
+        pos, val = parse_value(src, pos, parse_float, nest_lvl)
+        array.append(val)
+        pos = skip_comments_and_array_ws(src, pos)
+
+        c = src[pos : pos + 1]
+        if c == "]":
+            return pos + 1, array
+        if c != ",":
+            raise TOMLDecodeError("Unclosed array", src, pos)
+        pos += 1
+
+        pos = skip_comments_and_array_ws(src, pos)
+        if src.startswith("]", pos):
+            return pos + 1, array
+
+
+def parse_inline_table(
+    src: str, pos: Pos, parse_float: ParseFloat, nest_lvl: int
+) -> tuple[Pos, dict[str, Any]]:
+    pos += 1
+    nested_dict = NestedDict()
+    flags = Flags()
+
+    pos = skip_comments_and_array_ws(src, pos)
+    if src.startswith("}", pos):
+        return pos + 1, nested_dict.dict
+    while True:
+        pos, key, value = parse_key_value_pair(src, pos, parse_float, nest_lvl)
+        key_parent, key_stem = key[:-1], key[-1]
+        if flags.is_(key, Flags.FROZEN):
+            raise TOMLDecodeError(f"Cannot mutate immutable namespace {key}", src, pos)
+        try:
+            nest = nested_dict.get_or_create_nest(key_parent, access_lists=False)
+        except KeyError:
+            raise TOMLDecodeError("Cannot overwrite a value", src, pos) from None
+        if key_stem in nest:
+            raise TOMLDecodeError(f"Duplicate inline table key {key_stem!r}", src, pos)
+        nest[key_stem] = value
+        pos = skip_comments_and_array_ws(src, pos)
+        c = src[pos : pos + 1]
+        if c == "}":
+            return pos + 1, nested_dict.dict
+        if c != ",":
+            raise TOMLDecodeError("Unclosed inline table", src, pos)
+        pos += 1
+        pos = skip_comments_and_array_ws(src, pos)
+        if src.startswith("}", pos):
+            return pos + 1, nested_dict.dict
+        if isinstance(value, (dict, list)):
+            flags.set(key, Flags.FROZEN, recursive=True)
+
+
+def parse_basic_str_escape(
+    src: str, pos: Pos, *, multiline: bool = False
+) -> tuple[Pos, str]:
+    escape_id = src[pos : pos + 2]
+    pos += 2
+    if multiline and escape_id in {"\\ ", "\\\t", "\\\n"}:
+        # Skip whitespace until next non-whitespace character or end of
+        # the doc. Error if non-whitespace is found before newline.
+        if escape_id != "\\\n":
+            pos = skip_chars(src, pos, TOML_WS)
+            try:
+                char = src[pos]
+            except IndexError:
+                return pos, ""
+            if char != "\n":
+                raise TOMLDecodeError("Unescaped '\\' in a string", src, pos)
+            pos += 1
+        pos = skip_chars(src, pos, TOML_WS_AND_NEWLINE)
+        return pos, ""
+    if escape_id == "\\x":
+        return parse_hex_char(src, pos, 2)
+    if escape_id == "\\u":
+        return parse_hex_char(src, pos, 4)
+    if escape_id == "\\U":
+        return parse_hex_char(src, pos, 8)
+    try:
+        return pos, BASIC_STR_ESCAPE_REPLACEMENTS[escape_id]
+    except KeyError:
+        raise TOMLDecodeError("Unescaped '\\' in a string", src, pos) from None
+
+
+def parse_basic_str_escape_multiline(src: str, pos: Pos) -> tuple[Pos, str]:
+    return parse_basic_str_escape(src, pos, multiline=True)
+
+
+def parse_hex_char(src: str, pos: Pos, hex_len: int) -> tuple[Pos, str]:
+    hex_str = src[pos : pos + hex_len]
+    if len(hex_str) != hex_len or not HEXDIGIT_CHARS.issuperset(hex_str):
+        raise TOMLDecodeError("Invalid hex value", src, pos)
+    pos += hex_len
+    hex_int = int(hex_str, 16)
+    if not is_unicode_scalar_value(hex_int):
+        raise TOMLDecodeError(
+            "Escaped character is not a Unicode scalar value", src, pos
+        )
+    return pos, chr(hex_int)
+
+
+def parse_literal_str(src: str, pos: Pos) -> tuple[Pos, str]:
+    pos += 1  # Skip starting apostrophe
+    start_pos = pos
+    pos = skip_until(
+        src, pos, "'", error_on=ILLEGAL_LITERAL_STR_CHARS, error_on_eof=True
+    )
+    return pos + 1, src[start_pos:pos]  # Skip ending apostrophe
+
+
+def parse_multiline_str(src: str, pos: Pos, *, literal: bool) -> tuple[Pos, str]:
+    pos += 3
+    if src.startswith("\n", pos):
+        pos += 1
+
+    if literal:
+        delim = "'"
+        end_pos = skip_until(
+            src,
+            pos,
+            "'''",
+            error_on=ILLEGAL_MULTILINE_LITERAL_STR_CHARS,
+            error_on_eof=True,
+        )
+        result = src[pos:end_pos]
+        pos = end_pos + 3
+    else:
+        delim = '"'
+        pos, result = parse_basic_str(src, pos, multiline=True)
+
+    # Add at maximum two extra apostrophes/quotes if the end sequence
+    # is 4 or 5 chars long instead of just 3.
+    if not src.startswith(delim, pos):
+        return pos, result
+    pos += 1
+    if not src.startswith(delim, pos):
+        return pos, result + delim
+    pos += 1
+    return pos, result + (delim * 2)
+
+
+def parse_basic_str(src: str, pos: Pos, *, multiline: bool) -> tuple[Pos, str]:
+    if multiline:
+        error_on = ILLEGAL_MULTILINE_BASIC_STR_CHARS
+        parse_escapes = parse_basic_str_escape_multiline
+    else:
+        error_on = ILLEGAL_BASIC_STR_CHARS
+        parse_escapes = parse_basic_str_escape
+    result = ""
+    start_pos = pos
+    while True:
+        try:
+            char = src[pos]
+        except IndexError:
+            raise TOMLDecodeError("Unterminated string", src, pos) from None
+        if char == '"':
+            if not multiline:
+                return pos + 1, result + src[start_pos:pos]
+            if src.startswith('"""', pos):
+                return pos + 3, result + src[start_pos:pos]
+            pos += 1
+            continue
+        if char == "\\":
+            result += src[start_pos:pos]
+            pos, parsed_escape = parse_escapes(src, pos)
+            result += parsed_escape
+            start_pos = pos
+            continue
+        if char in error_on:
+            raise TOMLDecodeError(f"Illegal character {char!r}", src, pos)
+        pos += 1
+
+
+def parse_value(
+    src: str, pos: Pos, parse_float: ParseFloat, nest_lvl: int
+) -> tuple[Pos, Any]:
+    if nest_lvl > MAX_INLINE_NESTING:
+        # Pure Python should have raised RecursionError already.
+        # This ensures mypyc binaries eventually do the same.
+        raise RecursionError(  # pragma: no cover
+            "TOML inline arrays/tables are nested more than the allowed"
+            f" {MAX_INLINE_NESTING} levels"
+        )
+
+    try:
+        char: str | None = src[pos]
+    except IndexError:
+        char = None
+
+    # IMPORTANT: order conditions based on speed of checking and likelihood
+
+    # Basic strings
+    if char == '"':
+        if src.startswith('"""', pos):
+            return parse_multiline_str(src, pos, literal=False)
+        return parse_one_line_basic_str(src, pos)
+
+    # Literal strings
+    if char == "'":
+        if src.startswith("'''", pos):
+            return parse_multiline_str(src, pos, literal=True)
+        return parse_literal_str(src, pos)
+
+    # Booleans
+    if char == "t":
+        if src.startswith("true", pos):
+            return pos + 4, True
+    if char == "f":
+        if src.startswith("false", pos):
+            return pos + 5, False
+
+    # Arrays
+    if char == "[":
+        return parse_array(src, pos, parse_float, nest_lvl + 1)
+
+    # Inline tables
+    if char == "{":
+        return parse_inline_table(src, pos, parse_float, nest_lvl + 1)
+
+    # Dates and times
+    datetime_match = RE_DATETIME.match(src, pos)
+    if datetime_match:
+        try:
+            datetime_obj = match_to_datetime(datetime_match)
+        except ValueError as e:
+            raise TOMLDecodeError("Invalid date or datetime", src, pos) from e
+        return datetime_match.end(), datetime_obj
+    localtime_match = RE_LOCALTIME.match(src, pos)
+    if localtime_match:
+        return localtime_match.end(), match_to_localtime(localtime_match)
+
+    # Integers and "normal" floats.
+    # The regex will greedily match any type starting with a decimal
+    # char, so needs to be located after handling of dates and times.
+    number_match = RE_NUMBER.match(src, pos)
+    if number_match:
+        return number_match.end(), match_to_number(number_match, parse_float)
+
+    # Special floats
+    first_three = src[pos : pos + 3]
+    if first_three in {"inf", "nan"}:
+        return pos + 3, parse_float(first_three)
+    first_four = src[pos : pos + 4]
+    if first_four in {"-inf", "+inf", "-nan", "+nan"}:
+        return pos + 4, parse_float(first_four)
+
+    raise TOMLDecodeError("Invalid value", src, pos)
+
+
+def is_unicode_scalar_value(codepoint: int) -> bool:
+    return (0 <= codepoint <= 55295) or (57344 <= codepoint <= 1114111)
+
+
+def make_safe_parse_float(parse_float: ParseFloat) -> ParseFloat:
+    """A decorator to make `parse_float` safe.
+
+    `parse_float` must not return dicts or lists, because these types
+    would be mixed with parsed TOML tables and arrays, thus confusing
+    the parser. The returned decorated callable raises `ValueError`
+    instead of returning illegal types.
+    """
+    # The default `float` callable never returns illegal types. Optimize it.
+    if parse_float is float:
+        return float
+
+    def safe_parse_float(float_str: str) -> Any:
+        float_value = parse_float(float_str)
+        if isinstance(float_value, (dict, list)):
+            raise ValueError("parse_float must not return dicts or lists")
+        return float_value
+
+    return safe_parse_float
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli/_re.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli/_re.py
new file mode 100644
index 0000000000000000000000000000000000000000..fc374ed63d3e3742a97134349fc25b14223ab57b
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli/_re.py
@@ -0,0 +1,119 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: 2021 Taneli Hukkinen
+# Licensed to PSF under a Contributor Agreement.
+
+from __future__ import annotations
+
+from datetime import date, datetime, time, timedelta, timezone, tzinfo
+from functools import lru_cache
+import re
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Any, Final
+
+    from ._types import ParseFloat
+
+_TIME_RE_STR: Final = r"""
+([01][0-9]|2[0-3])             # hours
+:([0-5][0-9])                  # minutes
+(?:
+    :([0-5][0-9])              # optional seconds
+    (?:\.([0-9]{1,6})[0-9]*)?  # optional fractions of a second
+)?
+"""
+
+RE_NUMBER: Final = re.compile(
+    r"""
+0
+(?:
+    x[0-9A-Fa-f](?:_?[0-9A-Fa-f])*   # hex
+    |
+    b[01](?:_?[01])*                 # bin
+    |
+    o[0-7](?:_?[0-7])*               # oct
+)
+|
+[+-]?(?:0|[1-9](?:_?[0-9])*)         # dec, integer part
+(?P
+    (?:\.[0-9](?:_?[0-9])*)?         # optional fractional part
+    (?:[eE][+-]?[0-9](?:_?[0-9])*)?  # optional exponent part
+)
+""",
+    flags=re.VERBOSE,
+)
+RE_LOCALTIME: Final = re.compile(_TIME_RE_STR, flags=re.VERBOSE)
+RE_DATETIME: Final = re.compile(
+    rf"""
+([0-9]{{4}})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])  # date, e.g. 1988-10-27
+(?:
+    [Tt ]
+    {_TIME_RE_STR}
+    (?:([Zz])|([+-])([01][0-9]|2[0-3]):([0-5][0-9]))?  # optional time offset
+)?
+""",
+    flags=re.VERBOSE,
+)
+
+
+def match_to_datetime(match: re.Match[str]) -> datetime | date:
+    """Convert a `RE_DATETIME` match to `datetime.datetime` or `datetime.date`.
+
+    Raises ValueError if the match does not correspond to a valid date
+    or datetime.
+    """
+    (
+        year_str,
+        month_str,
+        day_str,
+        hour_str,
+        minute_str,
+        sec_str,
+        micros_str,
+        zulu_time,
+        offset_sign_str,
+        offset_hour_str,
+        offset_minute_str,
+    ) = match.groups()
+    year, month, day = int(year_str), int(month_str), int(day_str)
+    if hour_str is None:
+        return date(year, month, day)
+    hour, minute = int(hour_str), int(minute_str)
+    sec = int(sec_str) if sec_str else 0
+    micros = int(micros_str.ljust(6, "0")) if micros_str else 0
+    if offset_sign_str:
+        tz: tzinfo | None = cached_tz(
+            offset_hour_str, offset_minute_str, offset_sign_str
+        )
+    elif zulu_time:
+        tz = timezone.utc
+    else:  # local date-time
+        tz = None
+    return datetime(year, month, day, hour, minute, sec, micros, tzinfo=tz)
+
+
+# No need to limit cache size. This is only ever called on input
+# that matched RE_DATETIME, so there is an implicit bound of
+# 24 (hours) * 60 (minutes) * 2 (offset direction) = 2880.
+@lru_cache(maxsize=None)
+def cached_tz(hour_str: str, minute_str: str, sign_str: str) -> timezone:
+    sign = 1 if sign_str == "+" else -1
+    return timezone(
+        timedelta(
+            hours=sign * int(hour_str),
+            minutes=sign * int(minute_str),
+        )
+    )
+
+
+def match_to_localtime(match: re.Match[str]) -> time:
+    hour_str, minute_str, sec_str, micros_str = match.groups()
+    sec = int(sec_str) if sec_str else 0
+    micros = int(micros_str.ljust(6, "0")) if micros_str else 0
+    return time(int(hour_str), int(minute_str), sec, micros)
+
+
+def match_to_number(match: re.Match[str], parse_float: ParseFloat) -> Any:
+    if match.group("floatpart"):
+        return parse_float(match.group())
+    return int(match.group(), 0)
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli/_types.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli/_types.py
new file mode 100644
index 0000000000000000000000000000000000000000..d949412e03b29d70592c7721fe747e5085c2e280
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli/_types.py
@@ -0,0 +1,10 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: 2021 Taneli Hukkinen
+# Licensed to PSF under a Contributor Agreement.
+
+from typing import Any, Callable, Tuple
+
+# Type annotations
+ParseFloat = Callable[[str], Any]
+Key = Tuple[str, ...]
+Pos = int
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli/py.typed b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..7632ecf77545c5e5501cb3fc5719df0761104ca2
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/tomli/py.typed
@@ -0,0 +1 @@
+# Marker file for PEP 561
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel-0.46.3.dist-info/INSTALLER b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel-0.46.3.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..5c69047b2eb8235994febeeae1da4a82365a240a
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel-0.46.3.dist-info/INSTALLER
@@ -0,0 +1 @@
+uv
\ No newline at end of file
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel-0.46.3.dist-info/METADATA b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel-0.46.3.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..77936a9eb631d1aad5a9a9d12ce825c97392943e
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel-0.46.3.dist-info/METADATA
@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: wheel
+Version: 0.46.3
+Summary: Command line tool for manipulating wheel files
+Keywords: wheel,packaging
+Author-email: Daniel Holth 
+Maintainer-email: Alex Grönholm 
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+License-Expression: MIT
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: System :: Archiving :: Packaging
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+License-File: LICENSE.txt
+Requires-Dist: packaging >= 24.0
+Requires-Dist: pytest >= 6.0.0 ; extra == "test"
+Requires-Dist: setuptools >= 77 ; extra == "test"
+Project-URL: Changelog, https://wheel.readthedocs.io/en/stable/news.html
+Project-URL: Documentation, https://wheel.readthedocs.io/
+Project-URL: Issue Tracker, https://github.com/pypa/wheel/issues
+Project-URL: Source, https://github.com/pypa/wheel
+Provides-Extra: test
+
+wheel
+=====
+
+This is a command line tool for manipulating Python wheel files, as defined in
+`PEP 427`_. It contains the following functionality:
+
+* Convert ``.egg`` archives into ``.whl``
+* Unpack wheel archives
+* Repack wheel archives
+* Add or remove tags in existing wheel archives
+
+.. _PEP 427: https://www.python.org/dev/peps/pep-0427/
+
+Historical note
+---------------
+
+This project used to contain the implementation of the setuptools_ ``bdist_wheel``
+command, but as of setuptools v70.1, it no longer needs ``wheel`` installed for that to
+work. Thus, you should install this **only** if you intend to use the ``wheel`` command
+line tool!
+
+.. _setuptools: https://pypi.org/project/setuptools/
+
+Documentation
+-------------
+
+The documentation_ can be found on Read The Docs.
+
+.. _documentation: https://wheel.readthedocs.io/
+
+Code of Conduct
+---------------
+
+Everyone interacting in the wheel project's codebases, issue trackers, chat
+rooms, and mailing lists is expected to follow the `PSF Code of Conduct`_.
+
+.. _PSF Code of Conduct: https://github.com/pypa/.github/blob/main/CODE_OF_CONDUCT.md
+
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel-0.46.3.dist-info/RECORD b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel-0.46.3.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..5890933bcb85e7a1f5bca660d3aa311b71884e5d
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel-0.46.3.dist-info/RECORD
@@ -0,0 +1,22 @@
+bin/wheel,sha256=OLjFs9G7MQ-f_mhuW2aLGpngsyphW_v5FIoyN88Hfk0,339
+wheel-0.46.3.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+wheel-0.46.3.dist-info/METADATA,sha256=IpEKqXyonLzCCgGeJ_4xNgt5KaS9ZsoNMQ-ZpE9szTU,2410
+wheel-0.46.3.dist-info/RECORD,,
+wheel-0.46.3.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wheel-0.46.3.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+wheel-0.46.3.dist-info/entry_points.txt,sha256=JJdtSAGTvMLbIkTVZUAMvGKO39FtWfCVF8mp_NH6e4g,110
+wheel-0.46.3.dist-info/licenses/LICENSE.txt,sha256=MMI2GGeRCPPo6h0qZYx8pBe9_IkcmO8aifpP8MmChlQ,1107
+wheel/__init__.py,sha256=UweKvhe4SyP7zFyDoYo8BOuwTA6q3-_WpMmY2NNO54c,59
+wheel/__main__.py,sha256=_83wl9tyGU2cHiqfudpubGHdRL5uonPXnzeznznkxzs,512
+wheel/_bdist_wheel.py,sha256=bpmNa7_s-CYFkVgXf9ENAYTiJ01XBhRW4pxH1T8XYsI,21729
+wheel/_commands/__init__.py,sha256=fCRAQZNDyj2JLrufdgPsBlaRS_t_j_aBUMpXj09KZ4E,4432
+wheel/_commands/convert.py,sha256=0wSJMU0m-6LY16Om8Wmmloy-hJWFZeOmI8hT-2Z7Qms,12743
+wheel/_commands/pack.py,sha256=o3iwjfRHl7N9ul-M2kHbewLJZnqBLAWf0tzUCwoiTMw,3078
+wheel/_commands/tags.py,sha256=Rv2ySVb8-qX3osKp3uJgxcIMXkjt43XUD0-zvC6KvnY,4775
+wheel/_commands/unpack.py,sha256=AjDSS23XYyCSFfifnMutinrpPv-DK_2wbNHkKAUFwgM,1016
+wheel/_metadata.py,sha256=BP5jC9uC1hyicp7nL4FJ2LYixNFpEJIV_uMDY1KBZBg,6188
+wheel/_setuptools_logging.py,sha256=-5KC-lne0ilOUWIDfOkqapUWGMFZhuKYDIavIZiB5kM,781
+wheel/bdist_wheel.py,sha256=HrzYiSzMkh5ohAAhlQnYBS1p8qbr85X6F59xqxd9kBg,1102
+wheel/macosx_libfile.py,sha256=pL0wm88jRMl_4ASgGlNg_mz69Zmv5xm8JSkjLdwyvIQ,16712
+wheel/metadata.py,sha256=GknOO7JJiZMlcEe_fiD7nqnDTTLd0sX_-IgipM4L3-4,757
+wheel/wheelfile.py,sha256=m_g_7TNsEp-j-xnvSr5yDLEFb1nhyObueq9Q5_1_lBA,8720
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel-0.46.3.dist-info/REQUESTED b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel-0.46.3.dist-info/REQUESTED
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel-0.46.3.dist-info/WHEEL b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel-0.46.3.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..d8b9936dad9ab2513fa6979f411560d3b6b57e37
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel-0.46.3.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.12.0
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel-0.46.3.dist-info/entry_points.txt b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel-0.46.3.dist-info/entry_points.txt
new file mode 100644
index 0000000000000000000000000000000000000000..dcebd58811da1ee2758dd0f45c575704afdd61bd
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel-0.46.3.dist-info/entry_points.txt
@@ -0,0 +1,6 @@
+[console_scripts]
+wheel=wheel._commands:main
+
+[distutils.commands]
+bdist_wheel=wheel.bdist_wheel:bdist_wheel
+
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/__init__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b5b076f05a69ac941356361db47159d6cc06c296
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/__init__.py
@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+__version__ = "0.46.3"
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/__main__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/__main__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3c7de5fb7fd2fcc1bbb60b5c3977e82c3aa2f898
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/__main__.py
@@ -0,0 +1,25 @@
+"""
+Wheel command line tool (enables the ``python -m wheel`` syntax)
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import NoReturn
+
+
+def main() -> NoReturn:  # needed for console script
+    if __package__ == "":
+        # To be able to run 'python wheel-0.9.whl/wheel':
+        import os.path
+
+        path = os.path.dirname(os.path.dirname(__file__))
+        sys.path[0:0] = [path]
+
+    from ._commands import main as cli_main
+
+    sys.exit(cli_main())
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/__pycache__/_bdist_wheel.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/__pycache__/_bdist_wheel.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4fc400c05c17f86932d5df4634c3e634c6752eb3
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/__pycache__/_bdist_wheel.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/_bdist_wheel.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/_bdist_wheel.py
new file mode 100644
index 0000000000000000000000000000000000000000..575fbfb35105eb82faee5a368781ecf818379354
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/_bdist_wheel.py
@@ -0,0 +1,616 @@
+"""
+Create a wheel (.whl) distribution.
+
+A wheel is a built archive format.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import re
+import shutil
+import stat
+import struct
+import sys
+import sysconfig
+import warnings
+from collections.abc import Iterable, Sequence
+from email.generator import BytesGenerator, Generator
+from email.policy import EmailPolicy
+from glob import iglob
+from shutil import rmtree
+from typing import TYPE_CHECKING, Callable, Literal, cast
+from zipfile import ZIP_DEFLATED, ZIP_STORED
+
+import setuptools
+from packaging import tags
+from packaging import version as _packaging_version
+from setuptools import Command
+
+from . import __version__ as wheel_version
+from ._metadata import pkginfo_to_metadata
+from .wheelfile import WheelFile
+
+if TYPE_CHECKING:
+    import types
+
+# ensure Python logging is configured
+try:
+    __import__("setuptools.logging")
+except ImportError:
+    # setuptools < ??
+    from . import _setuptools_logging
+
+    _setuptools_logging.configure()
+
+log = logging.getLogger("wheel")
+
+
+def safe_name(name: str) -> str:
+    """Convert an arbitrary string to a standard distribution name
+    Any runs of non-alphanumeric/. characters are replaced with a single '-'.
+    """
+    return re.sub("[^A-Za-z0-9.]+", "-", name)
+
+
+def safe_version(version: str) -> str:
+    """
+    Convert an arbitrary string to a standard version string
+    """
+    try:
+        # normalize the version
+        return str(_packaging_version.Version(version))
+    except _packaging_version.InvalidVersion:
+        version = version.replace(" ", ".")
+        return re.sub("[^A-Za-z0-9.]+", "-", version)
+
+
+setuptools_major_version = int(setuptools.__version__.split(".")[0])
+
+PY_LIMITED_API_PATTERN = r"cp3\d"
+
+
+def _is_32bit_interpreter() -> bool:
+    return struct.calcsize("P") == 4
+
+
+def python_tag() -> str:
+    return f"py{sys.version_info[0]}"
+
+
+def get_platform(archive_root: str | None) -> str:
+    """Return our platform name 'win32', 'linux_x86_64'"""
+    result = sysconfig.get_platform()
+    if result.startswith("macosx") and archive_root is not None:
+        from .macosx_libfile import calculate_macosx_platform_tag
+
+        result = calculate_macosx_platform_tag(archive_root, result)
+    elif _is_32bit_interpreter():
+        if result == "linux-x86_64":
+            # pip pull request #3497
+            result = "linux-i686"
+        elif result == "linux-aarch64":
+            # packaging pull request #234
+            # TODO armv8l, packaging pull request #690 => this did not land
+            # in pip/packaging yet
+            result = "linux-armv7l"
+
+    return result.replace("-", "_")
+
+
+def get_flag(
+    var: str, fallback: bool, expected: bool = True, warn: bool = True
+) -> bool:
+    """Use a fallback value for determining SOABI flags if the needed config
+    var is unset or unavailable."""
+    val = sysconfig.get_config_var(var)
+    if val is None:
+        if warn:
+            warnings.warn(
+                f"Config variable '{var}' is unset, Python ABI tag may be incorrect",
+                RuntimeWarning,
+                stacklevel=2,
+            )
+        return fallback
+    return val == expected
+
+
+def get_abi_tag() -> str | None:
+    """Return the ABI tag based on SOABI (if available) or emulate SOABI (PyPy2)."""
+    soabi: str = sysconfig.get_config_var("SOABI")
+    impl = tags.interpreter_name()
+    if not soabi and impl in ("cp", "pp") and hasattr(sys, "maxunicode"):
+        d = ""
+        m = ""
+        u = ""
+        if get_flag("Py_DEBUG", hasattr(sys, "gettotalrefcount"), warn=(impl == "cp")):
+            d = "d"
+
+        if get_flag(
+            "WITH_PYMALLOC",
+            impl == "cp",
+            warn=(impl == "cp" and sys.version_info < (3, 8)),
+        ) and sys.version_info < (3, 8):
+            m = "m"
+
+        abi = f"{impl}{tags.interpreter_version()}{d}{m}{u}"
+    elif soabi and impl == "cp" and soabi.startswith("cpython"):
+        # non-Windows
+        abi = "cp" + soabi.split("-")[1]
+    elif soabi and impl == "cp" and soabi.startswith("cp"):
+        # Windows
+        abi = soabi.split("-")[0]
+    elif soabi and impl == "pp":
+        # we want something like pypy36-pp73
+        abi = "-".join(soabi.split("-")[:2])
+        abi = abi.replace(".", "_").replace("-", "_")
+    elif soabi and impl == "graalpy":
+        abi = "-".join(soabi.split("-")[:3])
+        abi = abi.replace(".", "_").replace("-", "_")
+    elif soabi:
+        abi = soabi.replace(".", "_").replace("-", "_")
+    else:
+        abi = None
+
+    return abi
+
+
+def safer_name(name: str) -> str:
+    return safe_name(name).replace("-", "_")
+
+
+def safer_version(version: str) -> str:
+    return safe_version(version).replace("-", "_")
+
+
+def remove_readonly(
+    func: Callable[..., object],
+    path: str,
+    excinfo: tuple[type[Exception], Exception, types.TracebackType],
+) -> None:
+    remove_readonly_exc(func, path, excinfo[1])
+
+
+def remove_readonly_exc(func: Callable[..., object], path: str, exc: Exception) -> None:
+    os.chmod(path, stat.S_IWRITE)
+    func(path)
+
+
+class bdist_wheel(Command):
+    description = "create a wheel distribution"
+
+    supported_compressions = {
+        "stored": ZIP_STORED,
+        "deflated": ZIP_DEFLATED,
+    }
+
+    user_options = [
+        ("bdist-dir=", "b", "temporary directory for creating the distribution"),
+        (
+            "plat-name=",
+            "p",
+            "platform name to embed in generated filenames "
+            f"(default: {get_platform(None)})",
+        ),
+        (
+            "keep-temp",
+            "k",
+            "keep the pseudo-installation tree around after "
+            "creating the distribution archive",
+        ),
+        ("dist-dir=", "d", "directory to put final built distributions in"),
+        ("skip-build", None, "skip rebuilding everything (for testing/debugging)"),
+        (
+            "relative",
+            None,
+            "build the archive using relative paths (default: false)",
+        ),
+        (
+            "owner=",
+            "u",
+            "Owner name used when creating a tar file [default: current user]",
+        ),
+        (
+            "group=",
+            "g",
+            "Group name used when creating a tar file [default: current group]",
+        ),
+        ("universal", None, "make a universal wheel (default: false)"),
+        (
+            "compression=",
+            None,
+            "zipfile compression (one of: {}) (default: 'deflated')".format(
+                ", ".join(supported_compressions)
+            ),
+        ),
+        (
+            "python-tag=",
+            None,
+            f"Python implementation compatibility tag (default: '{python_tag()}')",
+        ),
+        (
+            "build-number=",
+            None,
+            "Build number for this particular version. "
+            "As specified in PEP-0427, this must start with a digit. "
+            "[default: None]",
+        ),
+        (
+            "py-limited-api=",
+            None,
+            "Python tag (cp32|cp33|cpNN) for abi3 wheel tag (default: false)",
+        ),
+    ]
+
+    boolean_options = ["keep-temp", "skip-build", "relative", "universal"]
+
+    def initialize_options(self):
+        self.bdist_dir: str = None
+        self.data_dir = None
+        self.plat_name: str | None = None
+        self.plat_tag = None
+        self.format = "zip"
+        self.keep_temp = False
+        self.dist_dir: str | None = None
+        self.egginfo_dir = None
+        self.root_is_pure: bool | None = None
+        self.skip_build = None
+        self.relative = False
+        self.owner = None
+        self.group = None
+        self.universal: bool = False
+        self.compression: str | int = "deflated"
+        self.python_tag: str = python_tag()
+        self.build_number: str | None = None
+        self.py_limited_api: str | Literal[False] = False
+        self.plat_name_supplied = False
+
+    def finalize_options(self):
+        if self.bdist_dir is None:
+            bdist_base = self.get_finalized_command("bdist").bdist_base
+            self.bdist_dir = os.path.join(bdist_base, "wheel")
+
+        egg_info = self.distribution.get_command_obj("egg_info")
+        egg_info.ensure_finalized()  # needed for correct `wheel_dist_name`
+
+        self.data_dir = self.wheel_dist_name + ".data"
+        self.plat_name_supplied = self.plat_name is not None
+
+        try:
+            self.compression = self.supported_compressions[self.compression]
+        except KeyError:
+            raise ValueError(f"Unsupported compression: {self.compression}") from None
+
+        need_options = ("dist_dir", "plat_name", "skip_build")
+
+        self.set_undefined_options("bdist", *zip(need_options, need_options))
+
+        self.root_is_pure = not (
+            self.distribution.has_ext_modules() or self.distribution.has_c_libraries()
+        )
+
+        if self.py_limited_api and not re.match(
+            PY_LIMITED_API_PATTERN, self.py_limited_api
+        ):
+            raise ValueError(f"py-limited-api must match '{PY_LIMITED_API_PATTERN}'")
+
+        # Support legacy [wheel] section for setting universal
+        wheel = self.distribution.get_option_dict("wheel")
+        if "universal" in wheel:
+            # please don't define this in your global configs
+            log.warning(
+                "The [wheel] section is deprecated. Use [bdist_wheel] instead.",
+            )
+            val = wheel["universal"][1].strip()
+            if val.lower() in ("1", "true", "yes"):
+                self.universal = True
+
+        if self.build_number is not None and not self.build_number[:1].isdigit():
+            raise ValueError("Build tag (build-number) must start with a digit.")
+
+    @property
+    def wheel_dist_name(self):
+        """Return distribution full name with - replaced with _"""
+        components = (
+            safer_name(self.distribution.get_name()),
+            safer_version(self.distribution.get_version()),
+        )
+        if self.build_number:
+            components += (self.build_number,)
+        return "-".join(components)
+
+    def get_tag(self) -> tuple[str, str, str]:
+        # bdist sets self.plat_name if unset, we should only use it for purepy
+        # wheels if the user supplied it.
+        if self.plat_name_supplied:
+            plat_name = cast(str, self.plat_name)
+        elif self.root_is_pure:
+            plat_name = "any"
+        else:
+            # macosx contains system version in platform name so need special handle
+            if self.plat_name and not self.plat_name.startswith("macosx"):
+                plat_name = self.plat_name
+            else:
+                # on macosx always limit the platform name to comply with any
+                # c-extension modules in bdist_dir, since the user can specify
+                # a higher MACOSX_DEPLOYMENT_TARGET via tools like CMake
+
+                # on other platforms, and on macosx if there are no c-extension
+                # modules, use the default platform name.
+                plat_name = get_platform(self.bdist_dir)
+
+            if _is_32bit_interpreter():
+                if plat_name in ("linux-x86_64", "linux_x86_64"):
+                    plat_name = "linux_i686"
+                if plat_name in ("linux-aarch64", "linux_aarch64"):
+                    # TODO armv8l, packaging pull request #690 => this did not land
+                    # in pip/packaging yet
+                    plat_name = "linux_armv7l"
+
+        plat_name = (
+            plat_name.lower().replace("-", "_").replace(".", "_").replace(" ", "_")
+        )
+
+        if self.root_is_pure:
+            if self.universal:
+                impl = "py2.py3"
+            else:
+                impl = self.python_tag
+            tag = (impl, "none", plat_name)
+        else:
+            impl_name = tags.interpreter_name()
+            impl_ver = tags.interpreter_version()
+            impl = impl_name + impl_ver
+            # We don't work on CPython 3.1, 3.0.
+            if self.py_limited_api and (impl_name + impl_ver).startswith("cp3"):
+                impl = self.py_limited_api
+                abi_tag = "abi3"
+            else:
+                abi_tag = str(get_abi_tag()).lower()
+            tag = (impl, abi_tag, plat_name)
+            # issue gh-374: allow overriding plat_name
+            supported_tags = [
+                (t.interpreter, t.abi, plat_name) for t in tags.sys_tags()
+            ]
+            assert tag in supported_tags, (
+                f"would build wheel with unsupported tag {tag}"
+            )
+        return tag
+
+    def run(self):
+        build_scripts = self.reinitialize_command("build_scripts")
+        build_scripts.executable = "python"
+        build_scripts.force = True
+
+        build_ext = self.reinitialize_command("build_ext")
+        build_ext.inplace = False
+
+        if not self.skip_build:
+            self.run_command("build")
+
+        install = self.reinitialize_command("install", reinit_subcommands=True)
+        install.root = self.bdist_dir
+        install.compile = False
+        install.skip_build = self.skip_build
+        install.warn_dir = False
+
+        # A wheel without setuptools scripts is more cross-platform.
+        # Use the (undocumented) `no_ep` option to setuptools'
+        # install_scripts command to avoid creating entry point scripts.
+        install_scripts = self.reinitialize_command("install_scripts")
+        install_scripts.no_ep = True
+
+        # Use a custom scheme for the archive, because we have to decide
+        # at installation time which scheme to use.
+        for key in ("headers", "scripts", "data", "purelib", "platlib"):
+            setattr(install, "install_" + key, os.path.join(self.data_dir, key))
+
+        basedir_observed = ""
+
+        if os.name == "nt":
+            # win32 barfs if any of these are ''; could be '.'?
+            # (distutils.command.install:change_roots bug)
+            basedir_observed = os.path.normpath(os.path.join(self.data_dir, ".."))
+            self.install_libbase = self.install_lib = basedir_observed
+
+        setattr(
+            install,
+            "install_purelib" if self.root_is_pure else "install_platlib",
+            basedir_observed,
+        )
+
+        log.info(f"installing to {self.bdist_dir}")
+
+        self.run_command("install")
+
+        impl_tag, abi_tag, plat_tag = self.get_tag()
+        archive_basename = f"{self.wheel_dist_name}-{impl_tag}-{abi_tag}-{plat_tag}"
+        if not self.relative:
+            archive_root = self.bdist_dir
+        else:
+            archive_root = os.path.join(
+                self.bdist_dir, self._ensure_relative(install.install_base)
+            )
+
+        self.set_undefined_options("install_egg_info", ("target", "egginfo_dir"))
+        distinfo_dirname = (
+            f"{safer_name(self.distribution.get_name())}-"
+            f"{safer_version(self.distribution.get_version())}.dist-info"
+        )
+        distinfo_dir = os.path.join(self.bdist_dir, distinfo_dirname)
+        self.egg2dist(self.egginfo_dir, distinfo_dir)
+
+        self.write_wheelfile(distinfo_dir)
+
+        # Make the archive
+        if not os.path.exists(self.dist_dir):
+            os.makedirs(self.dist_dir)
+
+        wheel_path = os.path.join(self.dist_dir, archive_basename + ".whl")
+        with WheelFile(wheel_path, "w", self.compression) as wf:
+            wf.write_files(archive_root)
+
+        # Add to 'Distribution.dist_files' so that the "upload" command works
+        getattr(self.distribution, "dist_files", []).append(
+            (
+                "bdist_wheel",
+                "{}.{}".format(*sys.version_info[:2]),  # like 3.7
+                wheel_path,
+            )
+        )
+
+        if not self.keep_temp:
+            log.info(f"removing {self.bdist_dir}")
+            if not self.dry_run:
+                if sys.version_info < (3, 12):
+                    rmtree(self.bdist_dir, onerror=remove_readonly)
+                else:
+                    rmtree(self.bdist_dir, onexc=remove_readonly_exc)
+
+    def write_wheelfile(
+        self, wheelfile_base: str, generator: str = f"bdist_wheel ({wheel_version})"
+    ):
+        from email.message import Message
+
+        msg = Message()
+        msg["Wheel-Version"] = "1.0"  # of the spec
+        msg["Generator"] = generator
+        msg["Root-Is-Purelib"] = str(self.root_is_pure).lower()
+        if self.build_number is not None:
+            msg["Build"] = self.build_number
+
+        # Doesn't work for bdist_wininst
+        impl_tag, abi_tag, plat_tag = self.get_tag()
+        for impl in impl_tag.split("."):
+            for abi in abi_tag.split("."):
+                for plat in plat_tag.split("."):
+                    msg["Tag"] = "-".join((impl, abi, plat))
+
+        wheelfile_path = os.path.join(wheelfile_base, "WHEEL")
+        log.info(f"creating {wheelfile_path}")
+        with open(wheelfile_path, "wb") as f:
+            BytesGenerator(f, maxheaderlen=0).flatten(msg)
+
+    def _ensure_relative(self, path: str) -> str:
+        # copied from dir_util, deleted
+        drive, path = os.path.splitdrive(path)
+        if path[0:1] == os.sep:
+            path = drive + path[1:]
+        return path
+
+    @property
+    def license_paths(self) -> Iterable[str]:
+        if setuptools_major_version >= 57:
+            # Setuptools has resolved any patterns to actual file names
+            return self.distribution.metadata.license_files or ()
+
+        files: set[str] = set()
+        metadata = self.distribution.get_option_dict("metadata")
+        if setuptools_major_version >= 42:
+            # Setuptools recognizes the license_files option but does not do globbing
+            patterns = cast(Sequence[str], self.distribution.metadata.license_files)
+        else:
+            # Prior to those, wheel is entirely responsible for handling license files
+            if "license_files" in metadata:
+                patterns = metadata["license_files"][1].split()
+            else:
+                patterns = ()
+
+        if "license_file" in metadata:
+            warnings.warn(
+                'The "license_file" option is deprecated. Use "license_files" instead.',
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            files.add(metadata["license_file"][1])
+
+        if not files and not patterns and not isinstance(patterns, list):
+            patterns = ("LICEN[CS]E*", "COPYING*", "NOTICE*", "AUTHORS*")
+
+        for pattern in patterns:
+            for path in iglob(pattern):
+                if path.endswith("~"):
+                    log.debug(
+                        f'ignoring license file "{path}" as it looks like a backup'
+                    )
+                    continue
+
+                if path not in files and os.path.isfile(path):
+                    log.info(
+                        f'adding license file "{path}" (matched pattern "{pattern}")'
+                    )
+                    files.add(path)
+
+        return files
+
+    def egg2dist(self, egginfo_path: str, distinfo_path: str):
+        """Convert an .egg-info directory into a .dist-info directory"""
+
+        def adios(p: str) -> None:
+            """Appropriately delete directory, file or link."""
+            if os.path.exists(p) and not os.path.islink(p) and os.path.isdir(p):
+                shutil.rmtree(p)
+            elif os.path.exists(p):
+                os.unlink(p)
+
+        adios(distinfo_path)
+
+        if not os.path.exists(egginfo_path):
+            # There is no egg-info. This is probably because the egg-info
+            # file/directory is not named matching the distribution name used
+            # to name the archive file. Check for this case and report
+            # accordingly.
+            import glob
+
+            pat = os.path.join(os.path.dirname(egginfo_path), "*.egg-info")
+            possible = glob.glob(pat)
+            err = f"Egg metadata expected at {egginfo_path} but not found"
+            if possible:
+                alt = os.path.basename(possible[0])
+                err += f" ({alt} found - possible misnamed archive file?)"
+
+            raise ValueError(err)
+
+        if os.path.isfile(egginfo_path):
+            # .egg-info is a single file
+            pkg_info = pkginfo_to_metadata(egginfo_path, egginfo_path)
+            os.mkdir(distinfo_path)
+        else:
+            # .egg-info is a directory
+            pkginfo_path = os.path.join(egginfo_path, "PKG-INFO")
+            pkg_info = pkginfo_to_metadata(egginfo_path, pkginfo_path)
+
+            # ignore common egg metadata that is useless to wheel
+            shutil.copytree(
+                egginfo_path,
+                distinfo_path,
+                ignore=lambda x, y: {
+                    "PKG-INFO",
+                    "requires.txt",
+                    "SOURCES.txt",
+                    "not-zip-safe",
+                },
+            )
+
+            # delete dependency_links if it is only whitespace
+            dependency_links_path = os.path.join(distinfo_path, "dependency_links.txt")
+            with open(dependency_links_path, encoding="utf-8") as dependency_links_file:
+                dependency_links = dependency_links_file.read().strip()
+            if not dependency_links:
+                adios(dependency_links_path)
+
+        pkg_info_path = os.path.join(distinfo_path, "METADATA")
+        serialization_policy = EmailPolicy(
+            utf8=True,
+            mangle_from_=False,
+            max_line_length=0,
+        )
+        with open(pkg_info_path, "w", encoding="utf-8") as out:
+            Generator(out, policy=serialization_policy).flatten(pkg_info)
+
+        for license_path in self.license_paths:
+            filename = os.path.basename(license_path)
+            shutil.copy(license_path, os.path.join(distinfo_path, filename))
+
+        adios(egginfo_path)
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/_metadata.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/_metadata.py
new file mode 100644
index 0000000000000000000000000000000000000000..e17a7b924526b9fcad83fc44996f17695dea0161
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/_metadata.py
@@ -0,0 +1,184 @@
+"""
+Tools for converting old- to new-style metadata.
+"""
+
+from __future__ import annotations
+
+import functools
+import itertools
+import os.path
+import re
+import textwrap
+from collections.abc import Generator, Iterable, Iterator
+from email.message import Message
+from email.parser import Parser
+from typing import Literal
+
+from packaging.requirements import Requirement
+
+
+def _nonblank(str: str) -> bool | Literal[""]:
+    return str and not str.startswith("#")
+
+
+@functools.singledispatch
+def yield_lines(iterable: Iterable[str]) -> Iterator[str]:
+    r"""
+    Yield valid lines of a string or iterable.
+    >>> list(yield_lines(''))
+    []
+    >>> list(yield_lines(['foo', 'bar']))
+    ['foo', 'bar']
+    >>> list(yield_lines('foo\nbar'))
+    ['foo', 'bar']
+    >>> list(yield_lines('\nfoo\n#bar\nbaz #comment'))
+    ['foo', 'baz #comment']
+    >>> list(yield_lines(['foo\nbar', 'baz', 'bing\n\n\n']))
+    ['foo', 'bar', 'baz', 'bing']
+    """
+    return itertools.chain.from_iterable(map(yield_lines, iterable))
+
+
+@yield_lines.register(str)
+def _(text: str) -> Iterator[str]:
+    return filter(_nonblank, map(str.strip, text.splitlines()))
+
+
+def split_sections(
+    s: str | Iterator[str],
+) -> Generator[tuple[str | None, list[str]], None, None]:
+    """Split a string or iterable thereof into (section, content) pairs
+    Each ``section`` is a stripped version of the section header ("[section]")
+    and each ``content`` is a list of stripped lines excluding blank lines and
+    comment-only lines.  If there are any such lines before the first section
+    header, they're returned in a first ``section`` of ``None``.
+    """
+    section = None
+    content: list[str] = []
+    for line in yield_lines(s):
+        if line.startswith("["):
+            if line.endswith("]"):
+                if section or content:
+                    yield section, content
+                section = line[1:-1].strip()
+                content = []
+            else:
+                raise ValueError("Invalid section heading", line)
+        else:
+            content.append(line)
+
+    # wrap up last segment
+    yield section, content
+
+
+def safe_extra(extra: str) -> str:
+    """Convert an arbitrary string to a standard 'extra' name
+    Any runs of non-alphanumeric characters are replaced with a single '_',
+    and the result is always lowercased.
+    """
+    return re.sub("[^A-Za-z0-9.-]+", "_", extra).lower()
+
+
+def safe_name(name: str) -> str:
+    """Convert an arbitrary string to a standard distribution name
+    Any runs of non-alphanumeric/. characters are replaced with a single '-'.
+    """
+    return re.sub("[^A-Za-z0-9.]+", "-", name)
+
+
+def requires_to_requires_dist(requirement: Requirement) -> str:
+    """Return the version specifier for a requirement in PEP 345/566 fashion."""
+    if requirement.url:
+        return " @ " + requirement.url
+
+    requires_dist: list[str] = []
+    for spec in requirement.specifier:
+        requires_dist.append(spec.operator + spec.version)
+
+    if requires_dist:
+        return " " + ",".join(sorted(requires_dist))
+    else:
+        return ""
+
+
+def convert_requirements(requirements: list[str]) -> Iterator[str]:
+    """Yield Requires-Dist: strings for parsed requirements strings."""
+    for req in requirements:
+        parsed_requirement = Requirement(req)
+        spec = requires_to_requires_dist(parsed_requirement)
+        extras = ",".join(sorted(safe_extra(e) for e in parsed_requirement.extras))
+        if extras:
+            extras = f"[{extras}]"
+
+        yield safe_name(parsed_requirement.name) + extras + spec
+
+
+def generate_requirements(
+    extras_require: dict[str | None, list[str]],
+) -> Iterator[tuple[str, str]]:
+    """
+    Convert requirements from a setup()-style dictionary to
+    ('Requires-Dist', 'requirement') and ('Provides-Extra', 'extra') tuples.
+
+    extras_require is a dictionary of {extra: [requirements]} as passed to setup(),
+    using the empty extra {'': [requirements]} to hold install_requires.
+    """
+    for extra, depends in extras_require.items():
+        condition = ""
+        extra = extra or ""
+        if ":" in extra:  # setuptools extra:condition syntax
+            extra, condition = extra.split(":", 1)
+
+        extra = safe_extra(extra)
+        if extra:
+            yield "Provides-Extra", extra
+            if condition:
+                condition = "(" + condition + ") and "
+            condition += f"extra == '{extra}'"
+
+        if condition:
+            condition = " ; " + condition
+
+        for new_req in convert_requirements(depends):
+            canonical_req = str(Requirement(new_req + condition))
+            yield "Requires-Dist", canonical_req
+
+
+def pkginfo_to_metadata(egg_info_path: str, pkginfo_path: str) -> Message:
+    """
+    Convert .egg-info directory with PKG-INFO to the Metadata 2.1 format
+    """
+    with open(pkginfo_path, encoding="utf-8") as headers:
+        pkg_info = Parser().parse(headers)
+
+    pkg_info.replace_header("Metadata-Version", "2.1")
+    # Those will be regenerated from `requires.txt`.
+    del pkg_info["Provides-Extra"]
+    del pkg_info["Requires-Dist"]
+    requires_path = os.path.join(egg_info_path, "requires.txt")
+    if os.path.exists(requires_path):
+        with open(requires_path, encoding="utf-8") as requires_file:
+            requires = requires_file.read()
+
+        parsed_requirements = sorted(split_sections(requires), key=lambda x: x[0] or "")
+        for extra, reqs in parsed_requirements:
+            for key, value in generate_requirements({extra: reqs}):
+                if (key, value) not in pkg_info.items():
+                    pkg_info[key] = value
+
+    description = pkg_info["Description"]
+    if description:
+        description_lines = pkg_info["Description"].splitlines()
+        dedented_description = "\n".join(
+            # if the first line of long_description is blank,
+            # the first line here will be indented.
+            (
+                description_lines[0].lstrip(),
+                textwrap.dedent("\n".join(description_lines[1:])),
+                "\n",
+            )
+        )
+        pkg_info.set_payload(dedented_description)
+        del pkg_info["Description"]
+
+    return pkg_info
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/_setuptools_logging.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/_setuptools_logging.py
new file mode 100644
index 0000000000000000000000000000000000000000..a1a2482ba29ac5290c8f7d7688452ec3faf59332
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/_setuptools_logging.py
@@ -0,0 +1,26 @@
+# copied from setuptools.logging, omitting monkeypatching
+from __future__ import annotations
+
+import logging
+import sys
+
+
+def _not_warning(record: logging.LogRecord) -> bool:
+    return record.levelno < logging.WARNING
+
+
+def configure() -> None:
+    """
+    Configure logging to emit warning and above to stderr
+    and everything else to stdout. This behavior is provided
+    for compatibility with distutils.log but may change in
+    the future.
+    """
+    err_handler = logging.StreamHandler()
+    err_handler.setLevel(logging.WARNING)
+    out_handler = logging.StreamHandler(sys.stdout)
+    out_handler.addFilter(_not_warning)
+    handlers = err_handler, out_handler
+    logging.basicConfig(
+        format="{message}", style="{", handlers=handlers, level=logging.DEBUG
+    )
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/bdist_wheel.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/bdist_wheel.py
new file mode 100644
index 0000000000000000000000000000000000000000..24199c246d44a6874ad991c2f3492ca30fc10f27
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/bdist_wheel.py
@@ -0,0 +1,26 @@
+from typing import TYPE_CHECKING
+from warnings import warn
+
+warn(
+    "The 'wheel' package is no longer the canonical location of the 'bdist_wheel' "
+    "command, and will be removed in a future release. Please update to setuptools "
+    "v70.1 or later which contains an integrated version of this command.",
+    FutureWarning,
+    stacklevel=1,
+)
+
+if TYPE_CHECKING:
+    from ._bdist_wheel import bdist_wheel as bdist_wheel
+else:
+    try:
+        # Better integration/compatibility with setuptools:
+        # in the case new fixes or PEPs are implemented in setuptools
+        # there is no need to backport them to the deprecated code base.
+        # This is useful in the case of old packages in the ecosystem
+        # that are still used but have low maintenance.
+        from setuptools.command.bdist_wheel import bdist_wheel
+    except ImportError:
+        # Only used in the case of old setuptools versions.
+        # If the user wants to get the latest fixes/PEPs,
+        # they are encouraged to address the deprecation warning.
+        from ._bdist_wheel import bdist_wheel as bdist_wheel
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/macosx_libfile.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/macosx_libfile.py
new file mode 100644
index 0000000000000000000000000000000000000000..06e51af299d0fe15f7618f803cfb8ff52d199cf7
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/macosx_libfile.py
@@ -0,0 +1,486 @@
+"""
+IMPORTANT: DO NOT IMPORT THIS MODULE DIRECTLY.
+THIS IS ONLY KEPT IN PLACE FOR BACKWARDS COMPATIBILITY WITH
+setuptools.command.bdist_wheel.
+
+This module contains function to analyse dynamic library
+headers to extract system information
+
+Currently only for MacOSX
+
+Library file on macosx system starts with Mach-O or Fat field.
+This can be distinguish by first 32 bites and it is called magic number.
+Proper value of magic number is with suffix _MAGIC. Suffix _CIGAM means
+reversed bytes order.
+Both fields can occur in two types: 32 and 64 bytes.
+
+FAT field inform that this library contains few version of library
+(typically for different types version). It contains
+information where Mach-O headers starts.
+
+Each section started with Mach-O header contains one library
+(So if file starts with this field it contains only one version).
+
+After filed Mach-O there are section fields.
+Each of them starts with two fields:
+cmd - magic number for this command
+cmdsize - total size occupied by this section information.
+
+In this case only sections LC_VERSION_MIN_MACOSX (for macosx 10.13 and earlier)
+and LC_BUILD_VERSION (for macosx 10.14 and newer) are interesting,
+because them contains information about minimal system version.
+
+Important remarks:
+- For fat files this implementation looks for maximum number version.
+  It not check if it is 32 or 64 and do not compare it with currently built package.
+  So it is possible to false report higher version that needed.
+- All structures signatures are taken form macosx header files.
+- I think that binary format will be more stable than `otool` output.
+  and if apple introduce some changes both implementation will need to be updated.
+- The system compile will set the deployment target no lower than
+  11.0 for arm64 builds. For "Universal 2" builds use the x86_64 deployment
+  target when the arm64 target is 11.0.
+"""
+
+from __future__ import annotations
+
+import ctypes
+import os
+import sys
+from io import BufferedIOBase
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Union
+
+    StrPath = Union[str, os.PathLike[str]]
+
+"""here the needed const and struct from mach-o header files"""
+
+FAT_MAGIC = 0xCAFEBABE
+FAT_CIGAM = 0xBEBAFECA
+FAT_MAGIC_64 = 0xCAFEBABF
+FAT_CIGAM_64 = 0xBFBAFECA
+MH_MAGIC = 0xFEEDFACE
+MH_CIGAM = 0xCEFAEDFE
+MH_MAGIC_64 = 0xFEEDFACF
+MH_CIGAM_64 = 0xCFFAEDFE
+
+LC_VERSION_MIN_MACOSX = 0x24
+LC_BUILD_VERSION = 0x32
+
+CPU_TYPE_ARM64 = 0x0100000C
+
+mach_header_fields = [
+    ("magic", ctypes.c_uint32),
+    ("cputype", ctypes.c_int),
+    ("cpusubtype", ctypes.c_int),
+    ("filetype", ctypes.c_uint32),
+    ("ncmds", ctypes.c_uint32),
+    ("sizeofcmds", ctypes.c_uint32),
+    ("flags", ctypes.c_uint32),
+]
+"""
+struct mach_header {
+    uint32_t	magic;		/* mach magic number identifier */
+    cpu_type_t	cputype;	/* cpu specifier */
+    cpu_subtype_t	cpusubtype;	/* machine specifier */
+    uint32_t	filetype;	/* type of file */
+    uint32_t	ncmds;		/* number of load commands */
+    uint32_t	sizeofcmds;	/* the size of all the load commands */
+    uint32_t	flags;		/* flags */
+};
+typedef integer_t cpu_type_t;
+typedef integer_t cpu_subtype_t;
+"""
+
+mach_header_fields_64 = mach_header_fields + [("reserved", ctypes.c_uint32)]
+"""
+struct mach_header_64 {
+    uint32_t	magic;		/* mach magic number identifier */
+    cpu_type_t	cputype;	/* cpu specifier */
+    cpu_subtype_t	cpusubtype;	/* machine specifier */
+    uint32_t	filetype;	/* type of file */
+    uint32_t	ncmds;		/* number of load commands */
+    uint32_t	sizeofcmds;	/* the size of all the load commands */
+    uint32_t	flags;		/* flags */
+    uint32_t	reserved;	/* reserved */
+};
+"""
+
+fat_header_fields = [("magic", ctypes.c_uint32), ("nfat_arch", ctypes.c_uint32)]
+"""
+struct fat_header {
+    uint32_t	magic;		/* FAT_MAGIC or FAT_MAGIC_64 */
+    uint32_t	nfat_arch;	/* number of structs that follow */
+};
+"""
+
+fat_arch_fields = [
+    ("cputype", ctypes.c_int),
+    ("cpusubtype", ctypes.c_int),
+    ("offset", ctypes.c_uint32),
+    ("size", ctypes.c_uint32),
+    ("align", ctypes.c_uint32),
+]
+"""
+struct fat_arch {
+    cpu_type_t	cputype;	/* cpu specifier (int) */
+    cpu_subtype_t	cpusubtype;	/* machine specifier (int) */
+    uint32_t	offset;		/* file offset to this object file */
+    uint32_t	size;		/* size of this object file */
+    uint32_t	align;		/* alignment as a power of 2 */
+};
+"""
+
+fat_arch_64_fields = [
+    ("cputype", ctypes.c_int),
+    ("cpusubtype", ctypes.c_int),
+    ("offset", ctypes.c_uint64),
+    ("size", ctypes.c_uint64),
+    ("align", ctypes.c_uint32),
+    ("reserved", ctypes.c_uint32),
+]
+"""
+struct fat_arch_64 {
+    cpu_type_t	cputype;	/* cpu specifier (int) */
+    cpu_subtype_t	cpusubtype;	/* machine specifier (int) */
+    uint64_t	offset;		/* file offset to this object file */
+    uint64_t	size;		/* size of this object file */
+    uint32_t	align;		/* alignment as a power of 2 */
+    uint32_t	reserved;	/* reserved */
+};
+"""
+
+segment_base_fields = [("cmd", ctypes.c_uint32), ("cmdsize", ctypes.c_uint32)]
+"""base for reading segment info"""
+
+segment_command_fields = [
+    ("cmd", ctypes.c_uint32),
+    ("cmdsize", ctypes.c_uint32),
+    ("segname", ctypes.c_char * 16),
+    ("vmaddr", ctypes.c_uint32),
+    ("vmsize", ctypes.c_uint32),
+    ("fileoff", ctypes.c_uint32),
+    ("filesize", ctypes.c_uint32),
+    ("maxprot", ctypes.c_int),
+    ("initprot", ctypes.c_int),
+    ("nsects", ctypes.c_uint32),
+    ("flags", ctypes.c_uint32),
+]
+"""
+struct segment_command { /* for 32-bit architectures */
+    uint32_t	cmd;		/* LC_SEGMENT */
+    uint32_t	cmdsize;	/* includes sizeof section structs */
+    char		segname[16];	/* segment name */
+    uint32_t	vmaddr;		/* memory address of this segment */
+    uint32_t	vmsize;		/* memory size of this segment */
+    uint32_t	fileoff;	/* file offset of this segment */
+    uint32_t	filesize;	/* amount to map from the file */
+    vm_prot_t	maxprot;	/* maximum VM protection */
+    vm_prot_t	initprot;	/* initial VM protection */
+    uint32_t	nsects;		/* number of sections in segment */
+    uint32_t	flags;		/* flags */
+};
+typedef int vm_prot_t;
+"""
+
+segment_command_fields_64 = [
+    ("cmd", ctypes.c_uint32),
+    ("cmdsize", ctypes.c_uint32),
+    ("segname", ctypes.c_char * 16),
+    ("vmaddr", ctypes.c_uint64),
+    ("vmsize", ctypes.c_uint64),
+    ("fileoff", ctypes.c_uint64),
+    ("filesize", ctypes.c_uint64),
+    ("maxprot", ctypes.c_int),
+    ("initprot", ctypes.c_int),
+    ("nsects", ctypes.c_uint32),
+    ("flags", ctypes.c_uint32),
+]
+"""
+struct segment_command_64 { /* for 64-bit architectures */
+    uint32_t	cmd;		/* LC_SEGMENT_64 */
+    uint32_t	cmdsize;	/* includes sizeof section_64 structs */
+    char		segname[16];	/* segment name */
+    uint64_t	vmaddr;		/* memory address of this segment */
+    uint64_t	vmsize;		/* memory size of this segment */
+    uint64_t	fileoff;	/* file offset of this segment */
+    uint64_t	filesize;	/* amount to map from the file */
+    vm_prot_t	maxprot;	/* maximum VM protection */
+    vm_prot_t	initprot;	/* initial VM protection */
+    uint32_t	nsects;		/* number of sections in segment */
+    uint32_t	flags;		/* flags */
+};
+"""
+
+version_min_command_fields = segment_base_fields + [
+    ("version", ctypes.c_uint32),
+    ("sdk", ctypes.c_uint32),
+]
+"""
+struct version_min_command {
+    uint32_t	cmd;		/* LC_VERSION_MIN_MACOSX or
+                               LC_VERSION_MIN_IPHONEOS or
+                               LC_VERSION_MIN_WATCHOS or
+                               LC_VERSION_MIN_TVOS */
+    uint32_t	cmdsize;	/* sizeof(struct min_version_command) */
+    uint32_t	version;	/* X.Y.Z is encoded in nibbles xxxx.yy.zz */
+    uint32_t	sdk;		/* X.Y.Z is encoded in nibbles xxxx.yy.zz */
+};
+"""
+
+build_version_command_fields = segment_base_fields + [
+    ("platform", ctypes.c_uint32),
+    ("minos", ctypes.c_uint32),
+    ("sdk", ctypes.c_uint32),
+    ("ntools", ctypes.c_uint32),
+]
+"""
+struct build_version_command {
+    uint32_t	cmd;		/* LC_BUILD_VERSION */
+    uint32_t	cmdsize;	/* sizeof(struct build_version_command) plus */
+                                /* ntools * sizeof(struct build_tool_version) */
+    uint32_t	platform;	/* platform */
+    uint32_t	minos;		/* X.Y.Z is encoded in nibbles xxxx.yy.zz */
+    uint32_t	sdk;		/* X.Y.Z is encoded in nibbles xxxx.yy.zz */
+    uint32_t	ntools;		/* number of tool entries following this */
+};
+"""
+
+
+def swap32(x: int) -> int:
+    return (
+        ((x << 24) & 0xFF000000)
+        | ((x << 8) & 0x00FF0000)
+        | ((x >> 8) & 0x0000FF00)
+        | ((x >> 24) & 0x000000FF)
+    )
+
+
+def get_base_class_and_magic_number(
+    lib_file: BufferedIOBase,
+    seek: int | None = None,
+) -> tuple[type[ctypes.Structure], int]:
+    if seek is None:
+        seek = lib_file.tell()
+    else:
+        lib_file.seek(seek)
+    magic_number = ctypes.c_uint32.from_buffer_copy(
+        lib_file.read(ctypes.sizeof(ctypes.c_uint32))
+    ).value
+
+    # Handle wrong byte order
+    if magic_number in [FAT_CIGAM, FAT_CIGAM_64, MH_CIGAM, MH_CIGAM_64]:
+        if sys.byteorder == "little":
+            BaseClass = ctypes.BigEndianStructure
+        else:
+            BaseClass = ctypes.LittleEndianStructure
+
+        magic_number = swap32(magic_number)
+    else:
+        BaseClass = ctypes.Structure
+
+    lib_file.seek(seek)
+    return BaseClass, magic_number
+
+
+def read_data(struct_class: type[ctypes.Structure], lib_file: BufferedIOBase):
+    return struct_class.from_buffer_copy(lib_file.read(ctypes.sizeof(struct_class)))
+
+
+def extract_macosx_min_system_version(path_to_lib: str):
+    with open(path_to_lib, "rb") as lib_file:
+        BaseClass, magic_number = get_base_class_and_magic_number(lib_file, 0)
+        if magic_number not in [FAT_MAGIC, FAT_MAGIC_64, MH_MAGIC, MH_MAGIC_64]:
+            return
+
+        if magic_number in [FAT_MAGIC, FAT_CIGAM_64]:
+
+            class FatHeader(BaseClass):
+                _fields_ = fat_header_fields
+
+            fat_header = read_data(FatHeader, lib_file)
+            if magic_number == FAT_MAGIC:
+
+                class FatArch(BaseClass):
+                    _fields_ = fat_arch_fields
+
+            else:
+
+                class FatArch(BaseClass):
+                    _fields_ = fat_arch_64_fields
+
+            fat_arch_list = [
+                read_data(FatArch, lib_file) for _ in range(fat_header.nfat_arch)
+            ]
+
+            versions_list: list[tuple[int, int, int]] = []
+            for el in fat_arch_list:
+                try:
+                    version = read_mach_header(lib_file, el.offset)
+                    if version is not None:
+                        if el.cputype == CPU_TYPE_ARM64 and len(fat_arch_list) != 1:
+                            # Xcode will not set the deployment target below 11.0.0
+                            # for the arm64 architecture. Ignore the arm64 deployment
+                            # in fat binaries when the target is 11.0.0, that way
+                            # the other architectures can select a lower deployment
+                            # target.
+                            # This is safe because there is no arm64 variant for
+                            # macOS 10.15 or earlier.
+                            if version == (11, 0, 0):
+                                continue
+                        versions_list.append(version)
+                except ValueError:
+                    pass
+
+            if len(versions_list) > 0:
+                return max(versions_list)
+            else:
+                return None
+
+        else:
+            try:
+                return read_mach_header(lib_file, 0)
+            except ValueError:
+                """when some error during read library files"""
+                return None
+
+
+def read_mach_header(
+    lib_file: BufferedIOBase,
+    seek: int | None = None,
+) -> tuple[int, int, int] | None:
+    """
+    This function parses a Mach-O header and extracts
+    information about the minimal macOS version.
+
+    :param lib_file: reference to opened library file with pointer
+    """
+    base_class, magic_number = get_base_class_and_magic_number(lib_file, seek)
+    arch = "32" if magic_number == MH_MAGIC else "64"
+
+    class SegmentBase(base_class):
+        _fields_ = segment_base_fields
+
+    if arch == "32":
+
+        class MachHeader(base_class):
+            _fields_ = mach_header_fields
+
+    else:
+
+        class MachHeader(base_class):
+            _fields_ = mach_header_fields_64
+
+    mach_header = read_data(MachHeader, lib_file)
+    for _i in range(mach_header.ncmds):
+        pos = lib_file.tell()
+        segment_base = read_data(SegmentBase, lib_file)
+        lib_file.seek(pos)
+        if segment_base.cmd == LC_VERSION_MIN_MACOSX:
+
+            class VersionMinCommand(base_class):
+                _fields_ = version_min_command_fields
+
+            version_info = read_data(VersionMinCommand, lib_file)
+            return parse_version(version_info.version)
+        elif segment_base.cmd == LC_BUILD_VERSION:
+
+            class VersionBuild(base_class):
+                _fields_ = build_version_command_fields
+
+            version_info = read_data(VersionBuild, lib_file)
+            return parse_version(version_info.minos)
+        else:
+            lib_file.seek(pos + segment_base.cmdsize)
+            continue
+
+
+def parse_version(version: int) -> tuple[int, int, int]:
+    x = (version & 0xFFFF0000) >> 16
+    y = (version & 0x0000FF00) >> 8
+    z = version & 0x000000FF
+    return x, y, z
+
+
+def calculate_macosx_platform_tag(archive_root: StrPath, platform_tag: str) -> str:
+    """
+    Calculate proper macosx platform tag basing on files which are included to wheel
+
+    Example platform tag `macosx-10.14-x86_64`
+    """
+    prefix, base_version, suffix = platform_tag.split("-")
+    base_version = tuple(int(x) for x in base_version.split("."))
+    base_version = base_version[:2]
+    if base_version[0] > 10:
+        base_version = (base_version[0], 0)
+    assert len(base_version) == 2
+    if "MACOSX_DEPLOYMENT_TARGET" in os.environ:
+        deploy_target = tuple(
+            int(x) for x in os.environ["MACOSX_DEPLOYMENT_TARGET"].split(".")
+        )
+        deploy_target = deploy_target[:2]
+        if deploy_target[0] > 10:
+            deploy_target = (deploy_target[0], 0)
+        if deploy_target < base_version:
+            sys.stderr.write(
+                "[WARNING] MACOSX_DEPLOYMENT_TARGET is set to a lower value ({}) than "
+                "the version on which the Python interpreter was compiled ({}), and "
+                "will be ignored.\n".format(
+                    ".".join(str(x) for x in deploy_target),
+                    ".".join(str(x) for x in base_version),
+                )
+            )
+        else:
+            base_version = deploy_target
+
+    assert len(base_version) == 2
+    start_version = base_version
+    versions_dict: dict[str, tuple[int, int]] = {}
+    for dirpath, _dirnames, filenames in os.walk(archive_root):
+        for filename in filenames:
+            if filename.endswith(".dylib") or filename.endswith(".so"):
+                lib_path = os.path.join(dirpath, filename)
+                min_ver = extract_macosx_min_system_version(lib_path)
+                if min_ver is not None:
+                    min_ver = min_ver[0:2]
+                    if min_ver[0] > 10:
+                        min_ver = (min_ver[0], 0)
+                    versions_dict[lib_path] = min_ver
+
+    if len(versions_dict) > 0:
+        base_version = max(base_version, max(versions_dict.values()))
+
+    # macosx platform tag do not support minor bugfix release
+    fin_base_version = "_".join([str(x) for x in base_version])
+    if start_version < base_version:
+        problematic_files = [k for k, v in versions_dict.items() if v > start_version]
+        problematic_files = "\n".join(problematic_files)
+        if len(problematic_files) == 1:
+            files_form = "this file"
+        else:
+            files_form = "these files"
+        error_message = (
+            "[WARNING] This wheel needs a higher macOS version than {}  "
+            "To silence this warning, set MACOSX_DEPLOYMENT_TARGET to at least "
+            + fin_base_version
+            + " or recreate "
+            + files_form
+            + " with lower "
+            "MACOSX_DEPLOYMENT_TARGET:  \n" + problematic_files
+        )
+
+        if "MACOSX_DEPLOYMENT_TARGET" in os.environ:
+            error_message = error_message.format(
+                "is set in MACOSX_DEPLOYMENT_TARGET variable."
+            )
+        else:
+            error_message = error_message.format(
+                "the version your Python interpreter is compiled against."
+            )
+
+        sys.stderr.write(error_message)
+
+    platform_tag = prefix + "_" + fin_base_version + "_" + suffix
+    return platform_tag
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/metadata.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/metadata.py
new file mode 100644
index 0000000000000000000000000000000000000000..e27900a2565c859ff32b0e4bf497c2548e4912de
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/metadata.py
@@ -0,0 +1,17 @@
+from warnings import warn
+
+from ._metadata import convert_requirements as convert_requirements
+from ._metadata import generate_requirements as generate_requirements
+from ._metadata import pkginfo_to_metadata as pkginfo_to_metadata
+from ._metadata import requires_to_requires_dist as requires_to_requires_dist
+from ._metadata import safe_extra as safe_extra
+from ._metadata import safe_name as safe_name
+from ._metadata import split_sections as split_sections
+
+warn(
+    f"The {__name__!r} package has been made private and should no longer be imported. "
+    f"Please either copy the code or find an alternative library to import it from, as "
+    f"this warning will be removed in a future version of 'wheel'.",
+    DeprecationWarning,
+    stacklevel=2,
+)
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/wheelfile.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/wheelfile.py
new file mode 100644
index 0000000000000000000000000000000000000000..7b6fd71621b9a14274a17086edeb287db58d7fe0
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/wheel/wheelfile.py
@@ -0,0 +1,241 @@
+from __future__ import annotations
+
+__all__ = ["WHEEL_INFO_RE", "WheelFile", "WheelError"]
+
+import base64
+import csv
+import hashlib
+import logging
+import os.path
+import re
+import stat
+import time
+from io import StringIO, TextIOWrapper
+from typing import IO, TYPE_CHECKING, Literal
+from zipfile import ZIP_DEFLATED, ZipFile, ZipInfo
+
+if TYPE_CHECKING:
+    from _typeshed import SizedBuffer, StrPath
+
+
+# Non-greedy matching of an optional build number may be too clever (more
+# invalid wheel filenames will match). Separate regex for .dist-info?
+WHEEL_INFO_RE = re.compile(
+    r"""^(?P(?P[^\s-]+?)-(?P[^\s-]+?))(-(?P\d[^\s-]*))?
+     -(?P[^\s-]+?)-(?P[^\s-]+?)-(?P\S+)\.whl$""",
+    re.VERBOSE,
+)
+MINIMUM_TIMESTAMP = 315532800  # 1980-01-01 00:00:00 UTC
+
+log = logging.getLogger("wheel")
+
+
+class WheelError(Exception):
+    pass
+
+
+def urlsafe_b64encode(data: bytes) -> bytes:
+    """urlsafe_b64encode without padding"""
+    return base64.urlsafe_b64encode(data).rstrip(b"=")
+
+
+def urlsafe_b64decode(data: bytes) -> bytes:
+    """urlsafe_b64decode without padding"""
+    pad = b"=" * (4 - (len(data) & 3))
+    return base64.urlsafe_b64decode(data + pad)
+
+
+def get_zipinfo_datetime(
+    timestamp: float | None = None,
+) -> tuple[int, int, int, int, int]:
+    # Some applications need reproducible .whl files, but they can't do this without
+    # forcing the timestamp of the individual ZipInfo objects. See issue #143.
+    timestamp = int(os.environ.get("SOURCE_DATE_EPOCH", timestamp or time.time()))
+    timestamp = max(timestamp, MINIMUM_TIMESTAMP)
+    return time.gmtime(timestamp)[0:6]
+
+
+class WheelFile(ZipFile):
+    """A ZipFile derivative class that also reads SHA-256 hashes from
+    .dist-info/RECORD and checks any read files against those.
+    """
+
+    _default_algorithm = hashlib.sha256
+
+    def __init__(
+        self,
+        file: StrPath,
+        mode: Literal["r", "w", "x", "a"] = "r",
+        compression: int = ZIP_DEFLATED,
+    ):
+        basename = os.path.basename(file)
+        self.parsed_filename = WHEEL_INFO_RE.match(basename)
+        if not basename.endswith(".whl") or self.parsed_filename is None:
+            raise WheelError(f"Bad wheel filename {basename!r}")
+
+        ZipFile.__init__(self, file, mode, compression=compression, allowZip64=True)
+
+        self.dist_info_path = "{}.dist-info".format(
+            self.parsed_filename.group("namever")
+        )
+        self.record_path = self.dist_info_path + "/RECORD"
+        self._file_hashes: dict[str, tuple[None, None] | tuple[int, bytes]] = {}
+        self._file_sizes = {}
+        if mode == "r":
+            # Ignore RECORD and any embedded wheel signatures
+            self._file_hashes[self.record_path] = None, None
+            self._file_hashes[self.record_path + ".jws"] = None, None
+            self._file_hashes[self.record_path + ".p7s"] = None, None
+
+            # Fill in the expected hashes by reading them from RECORD
+            try:
+                record = self.open(self.record_path)
+            except KeyError:
+                raise WheelError(f"Missing {self.record_path} file") from None
+
+            with record:
+                for line in csv.reader(
+                    TextIOWrapper(record, newline="", encoding="utf-8")
+                ):
+                    path, hash_sum, size = line
+                    if not hash_sum:
+                        continue
+
+                    algorithm, hash_sum = hash_sum.split("=")
+                    try:
+                        hashlib.new(algorithm)
+                    except ValueError:
+                        raise WheelError(
+                            f"Unsupported hash algorithm: {algorithm}"
+                        ) from None
+
+                    if algorithm.lower() in {"md5", "sha1"}:
+                        raise WheelError(
+                            f"Weak hash algorithm ({algorithm}) is not permitted by "
+                            f"PEP 427"
+                        )
+
+                    self._file_hashes[path] = (
+                        algorithm,
+                        urlsafe_b64decode(hash_sum.encode("ascii")),
+                    )
+
+    def open(
+        self,
+        name_or_info: str | ZipInfo,
+        mode: Literal["r", "w"] = "r",
+        pwd: bytes | None = None,
+    ) -> IO[bytes]:
+        def _update_crc(newdata: bytes) -> None:
+            eof = ef._eof
+            update_crc_orig(newdata)
+            running_hash.update(newdata)
+            if eof and running_hash.digest() != expected_hash:
+                raise WheelError(f"Hash mismatch for file '{ef_name}'")
+
+        ef_name = (
+            name_or_info.filename if isinstance(name_or_info, ZipInfo) else name_or_info
+        )
+        if (
+            mode == "r"
+            and not ef_name.endswith("/")
+            and ef_name not in self._file_hashes
+        ):
+            raise WheelError(f"No hash found for file '{ef_name}'")
+
+        ef = ZipFile.open(self, name_or_info, mode, pwd)
+        if mode == "r" and not ef_name.endswith("/"):
+            algorithm, expected_hash = self._file_hashes[ef_name]
+            if expected_hash is not None:
+                # Monkey patch the _update_crc method to also check for the hash from
+                # RECORD
+                running_hash = hashlib.new(algorithm)
+                update_crc_orig, ef._update_crc = ef._update_crc, _update_crc
+
+        return ef
+
+    def write_files(self, base_dir: str) -> None:
+        log.info("creating %r and adding %r to it", self.filename, base_dir)
+        deferred: list[tuple[str, str]] = []
+        for root, dirnames, filenames in os.walk(base_dir):
+            # Sort the directory names so that `os.walk` will walk them in a
+            # defined order on the next iteration.
+            dirnames.sort()
+            for name in sorted(filenames):
+                path = os.path.normpath(os.path.join(root, name))
+                if os.path.isfile(path):
+                    arcname = os.path.relpath(path, base_dir).replace(os.path.sep, "/")
+                    if arcname == self.record_path:
+                        pass
+                    elif root.endswith(".dist-info"):
+                        deferred.append((path, arcname))
+                    else:
+                        self.write(path, arcname)
+
+        deferred.sort()
+        for path, arcname in deferred:
+            self.write(path, arcname)
+
+    def write(
+        self,
+        filename: str,
+        arcname: str | None = None,
+        compress_type: int | None = None,
+    ) -> None:
+        with open(filename, "rb") as f:
+            st = os.fstat(f.fileno())
+            data = f.read()
+
+        zinfo = ZipInfo(
+            arcname or filename, date_time=get_zipinfo_datetime(st.st_mtime)
+        )
+        zinfo.external_attr = (stat.S_IMODE(st.st_mode) | stat.S_IFMT(st.st_mode)) << 16
+        zinfo.compress_type = compress_type or self.compression
+        self.writestr(zinfo, data, compress_type)
+
+    def writestr(
+        self,
+        zinfo_or_arcname: str | ZipInfo,
+        data: SizedBuffer | str,
+        compress_type: int | None = None,
+    ) -> None:
+        if isinstance(zinfo_or_arcname, str):
+            zinfo_or_arcname = ZipInfo(
+                zinfo_or_arcname, date_time=get_zipinfo_datetime()
+            )
+            zinfo_or_arcname.compress_type = self.compression
+            zinfo_or_arcname.external_attr = (0o664 | stat.S_IFREG) << 16
+
+        if isinstance(data, str):
+            data = data.encode("utf-8")
+
+        ZipFile.writestr(self, zinfo_or_arcname, data, compress_type)
+        fname = (
+            zinfo_or_arcname.filename
+            if isinstance(zinfo_or_arcname, ZipInfo)
+            else zinfo_or_arcname
+        )
+        log.info("adding %r", fname)
+        if fname != self.record_path:
+            hash_ = self._default_algorithm(data)
+            self._file_hashes[fname] = (
+                hash_.name,
+                urlsafe_b64encode(hash_.digest()).decode("ascii"),
+            )
+            self._file_sizes[fname] = len(data)
+
+    def close(self) -> None:
+        # Write RECORD
+        if self.fp is not None and self.mode == "w" and self._file_hashes:
+            data = StringIO()
+            writer = csv.writer(data, delimiter=",", quotechar='"', lineterminator="\n")
+            writer.writerows(
+                (
+                    (fname, algorithm + "=" + hash_, self._file_sizes[fname])
+                    for fname, (algorithm, hash_) in self._file_hashes.items()
+                )
+            )
+            writer.writerow((format(self.record_path), "", ""))
+            self.writestr(self.record_path, data.getvalue())
+
+        ZipFile.close(self)
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp-3.23.0.dist-info/INSTALLER b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp-3.23.0.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..5c69047b2eb8235994febeeae1da4a82365a240a
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp-3.23.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+uv
\ No newline at end of file
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp-3.23.0.dist-info/METADATA b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp-3.23.0.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..6420117987041c052142deea6b16884cdb435c2f
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp-3.23.0.dist-info/METADATA
@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: zipp
+Version: 3.23.0
+Summary: Backport of pathlib-compatible object wrapper for zip files
+Author-email: "Jason R. Coombs" 
+License-Expression: MIT
+Project-URL: Source, https://github.com/jaraco/zipp
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest!=8.1.*,>=6; extra == "test"
+Requires-Dist: jaraco.itertools; extra == "test"
+Requires-Dist: jaraco.functools; extra == "test"
+Requires-Dist: more_itertools; extra == "test"
+Requires-Dist: big-O; extra == "test"
+Requires-Dist: pytest-ignore-flaky; extra == "test"
+Requires-Dist: jaraco.test; extra == "test"
+Provides-Extra: doc
+Requires-Dist: sphinx>=3.5; extra == "doc"
+Requires-Dist: jaraco.packaging>=9.3; extra == "doc"
+Requires-Dist: rst.linker>=1.9; extra == "doc"
+Requires-Dist: furo; extra == "doc"
+Requires-Dist: sphinx-lint; extra == "doc"
+Requires-Dist: jaraco.tidelift>=1.4; extra == "doc"
+Provides-Extra: check
+Requires-Dist: pytest-checkdocs>=2.4; extra == "check"
+Requires-Dist: pytest-ruff>=0.2.1; sys_platform != "cygwin" and extra == "check"
+Provides-Extra: cover
+Requires-Dist: pytest-cov; extra == "cover"
+Provides-Extra: enabler
+Requires-Dist: pytest-enabler>=2.2; extra == "enabler"
+Provides-Extra: type
+Requires-Dist: pytest-mypy; extra == "type"
+Dynamic: license-file
+
+.. image:: https://img.shields.io/pypi/v/zipp.svg
+   :target: https://pypi.org/project/zipp
+
+.. image:: https://img.shields.io/pypi/pyversions/zipp.svg
+
+.. image:: https://github.com/jaraco/zipp/actions/workflows/main.yml/badge.svg
+   :target: https://github.com/jaraco/zipp/actions?query=workflow%3A%22tests%22
+   :alt: tests
+
+.. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json
+    :target: https://github.com/astral-sh/ruff
+    :alt: Ruff
+
+.. image:: https://readthedocs.org/projects/zipp/badge/?version=latest
+..    :target: https://zipp.readthedocs.io/en/latest/?badge=latest
+
+.. image:: https://img.shields.io/badge/skeleton-2025-informational
+   :target: https://blog.jaraco.com/skeleton
+
+.. image:: https://tidelift.com/badges/package/pypi/zipp
+   :target: https://tidelift.com/subscription/pkg/pypi-zipp?utm_source=pypi-zipp&utm_medium=readme
+
+
+A pathlib-compatible Zipfile object wrapper. Official backport of the standard library
+`Path object `_.
+
+
+Compatibility
+=============
+
+New features are introduced in this third-party library and later merged
+into CPython. The following table indicates which versions of this library
+were contributed to different versions in the standard library:
+
+.. list-table::
+   :header-rows: 1
+
+   * - zipp
+     - stdlib
+   * - 3.18
+     - 3.13
+   * - 3.16
+     - 3.12
+   * - 3.5
+     - 3.11
+   * - 3.2
+     - 3.10
+   * - 3.3 ??
+     - 3.9
+   * - 1.0
+     - 3.8
+
+
+Usage
+=====
+
+Use ``zipp.Path`` in place of ``zipfile.Path`` on any Python.
+
+For Enterprise
+==============
+
+Available as part of the Tidelift Subscription.
+
+This project and the maintainers of thousands of other packages are working with Tidelift to deliver one enterprise subscription that covers all of the open source you use.
+
+`Learn more `_.
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp-3.23.0.dist-info/RECORD b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp-3.23.0.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..167e234a530053b60d4bf6d51b12598723433a8c
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp-3.23.0.dist-info/RECORD
@@ -0,0 +1,14 @@
+zipp-3.23.0.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+zipp-3.23.0.dist-info/METADATA,sha256=vdZ9TRbPC_O4k-fRjNPS13StuC837Zhbx3cMYHIms1s,3563
+zipp-3.23.0.dist-info/RECORD,,
+zipp-3.23.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+zipp-3.23.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+zipp-3.23.0.dist-info/licenses/LICENSE,sha256=WlfLTbheKi3YjCkGKJCK3VfjRRRJ4KmnH9-zh3b9dZ0,1076
+zipp-3.23.0.dist-info/top_level.txt,sha256=iAbdoSHfaGqBfVb2XuR9JqSQHCoOsOtG6y9C_LSpqFw,5
+zipp/__init__.py,sha256=ieXh9GIMdABjKRX_JUJtP9k5wdBLK4Mt5X4nszSkmYE,11976
+zipp/_functools.py,sha256=f6Kt9LxZ4TE-cY1lJVdXSId3memSXmH9IdgMbU-_x2k,575
+zipp/compat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+zipp/compat/overlay.py,sha256=oEIGAnbr8yGjuKTrVSO2ByewPui71uppbX18BLnYTKE,783
+zipp/compat/py310.py,sha256=S7i6N9mToEn3asNb2ILyjnzvITOXrATD_J4emjyBbDU,256
+zipp/compat/py313.py,sha256=RndvDNtuY7H2D9ecnnzcPBMZ8mZc42gmXD_IwQAXXAE,654
+zipp/glob.py,sha256=DLV9LBsDxA6YVW82e3-tkoNrus1h4R-j3BR6VqS0AzE,3382
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp-3.23.0.dist-info/REQUESTED b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp-3.23.0.dist-info/REQUESTED
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp-3.23.0.dist-info/WHEEL b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp-3.23.0.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..e7fa31b6f3f78deb1022c1f7927f07d4d16da822
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp-3.23.0.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp-3.23.0.dist-info/licenses/LICENSE b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp-3.23.0.dist-info/licenses/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..f60bd572013c6abcb3a82ba9b50d84935de6394f
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp-3.23.0.dist-info/licenses/LICENSE
@@ -0,0 +1,18 @@
+MIT License
+
+Copyright (c) 2025 
+
+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.
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp-3.23.0.dist-info/top_level.txt b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp-3.23.0.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e82f676f82a3381fa909d1e6578c7a22044fafca
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp-3.23.0.dist-info/top_level.txt
@@ -0,0 +1 @@
+zipp
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/__init__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed5b21463295b8cee93d855316fb5e9000f9b8ec
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/__init__.py
@@ -0,0 +1,456 @@
+"""
+A Path-like interface for zipfiles.
+
+This codebase is shared between zipfile.Path in the stdlib
+and zipp in PyPI. See
+https://github.com/python/importlib_metadata/wiki/Development-Methodology
+for more detail.
+"""
+
+import functools
+import io
+import itertools
+import pathlib
+import posixpath
+import re
+import stat
+import sys
+import zipfile
+
+from ._functools import save_method_args
+from .compat.py310 import text_encoding
+from .glob import Translator
+
+__all__ = ['Path']
+
+
+def _parents(path):
+    """
+    Given a path with elements separated by
+    posixpath.sep, generate all parents of that path.
+
+    >>> list(_parents('b/d'))
+    ['b']
+    >>> list(_parents('/b/d/'))
+    ['/b']
+    >>> list(_parents('b/d/f/'))
+    ['b/d', 'b']
+    >>> list(_parents('b'))
+    []
+    >>> list(_parents(''))
+    []
+    """
+    return itertools.islice(_ancestry(path), 1, None)
+
+
+def _ancestry(path):
+    """
+    Given a path with elements separated by
+    posixpath.sep, generate all elements of that path.
+
+    >>> list(_ancestry('b/d'))
+    ['b/d', 'b']
+    >>> list(_ancestry('/b/d/'))
+    ['/b/d', '/b']
+    >>> list(_ancestry('b/d/f/'))
+    ['b/d/f', 'b/d', 'b']
+    >>> list(_ancestry('b'))
+    ['b']
+    >>> list(_ancestry(''))
+    []
+
+    Multiple separators are treated like a single.
+
+    >>> list(_ancestry('//b//d///f//'))
+    ['//b//d///f', '//b//d', '//b']
+    """
+    path = path.rstrip(posixpath.sep)
+    while path.rstrip(posixpath.sep):
+        yield path
+        path, tail = posixpath.split(path)
+
+
+_dedupe = dict.fromkeys
+"""Deduplicate an iterable in original order"""
+
+
+def _difference(minuend, subtrahend):
+    """
+    Return items in minuend not in subtrahend, retaining order
+    with O(1) lookup.
+    """
+    return itertools.filterfalse(set(subtrahend).__contains__, minuend)
+
+
+class InitializedState:
+    """
+    Mix-in to save the initialization state for pickling.
+    """
+
+    @save_method_args
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def __getstate__(self):
+        return self._saved___init__.args, self._saved___init__.kwargs
+
+    def __setstate__(self, state):
+        args, kwargs = state
+        super().__init__(*args, **kwargs)
+
+
+class CompleteDirs(InitializedState, zipfile.ZipFile):
+    """
+    A ZipFile subclass that ensures that implied directories
+    are always included in the namelist.
+
+    >>> list(CompleteDirs._implied_dirs(['foo/bar.txt', 'foo/bar/baz.txt']))
+    ['foo/', 'foo/bar/']
+    >>> list(CompleteDirs._implied_dirs(['foo/bar.txt', 'foo/bar/baz.txt', 'foo/bar/']))
+    ['foo/']
+    """
+
+    @staticmethod
+    def _implied_dirs(names):
+        parents = itertools.chain.from_iterable(map(_parents, names))
+        as_dirs = (p + posixpath.sep for p in parents)
+        return _dedupe(_difference(as_dirs, names))
+
+    def namelist(self):
+        names = super().namelist()
+        return names + list(self._implied_dirs(names))
+
+    def _name_set(self):
+        return set(self.namelist())
+
+    def resolve_dir(self, name):
+        """
+        If the name represents a directory, return that name
+        as a directory (with the trailing slash).
+        """
+        names = self._name_set()
+        dirname = name + '/'
+        dir_match = name not in names and dirname in names
+        return dirname if dir_match else name
+
+    def getinfo(self, name):
+        """
+        Supplement getinfo for implied dirs.
+        """
+        try:
+            return super().getinfo(name)
+        except KeyError:
+            if not name.endswith('/') or name not in self._name_set():
+                raise
+            return zipfile.ZipInfo(filename=name)
+
+    @classmethod
+    def make(cls, source):
+        """
+        Given a source (filename or zipfile), return an
+        appropriate CompleteDirs subclass.
+        """
+        if isinstance(source, CompleteDirs):
+            return source
+
+        if not isinstance(source, zipfile.ZipFile):
+            return cls(source)
+
+        # Only allow for FastLookup when supplied zipfile is read-only
+        if 'r' not in source.mode:
+            cls = CompleteDirs
+
+        source.__class__ = cls
+        return source
+
+    @classmethod
+    def inject(cls, zf: zipfile.ZipFile) -> zipfile.ZipFile:
+        """
+        Given a writable zip file zf, inject directory entries for
+        any directories implied by the presence of children.
+        """
+        for name in cls._implied_dirs(zf.namelist()):
+            zf.writestr(name, b"")
+        return zf
+
+
+class FastLookup(CompleteDirs):
+    """
+    ZipFile subclass to ensure implicit
+    dirs exist and are resolved rapidly.
+    """
+
+    def namelist(self):
+        return self._namelist
+
+    @functools.cached_property
+    def _namelist(self):
+        return super().namelist()
+
+    def _name_set(self):
+        return self._name_set_prop
+
+    @functools.cached_property
+    def _name_set_prop(self):
+        return super()._name_set()
+
+
+def _extract_text_encoding(encoding=None, *args, **kwargs):
+    # compute stack level so that the caller of the caller sees any warning.
+    is_pypy = sys.implementation.name == 'pypy'
+    # PyPy no longer special cased after 7.3.19 (or maybe 7.3.18)
+    # See jaraco/zipp#143
+    is_old_pypi = is_pypy and sys.pypy_version_info < (7, 3, 19)
+    stack_level = 3 + is_old_pypi
+    return text_encoding(encoding, stack_level), args, kwargs
+
+
+class Path:
+    """
+    A :class:`importlib.resources.abc.Traversable` interface for zip files.
+
+    Implements many of the features users enjoy from
+    :class:`pathlib.Path`.
+
+    Consider a zip file with this structure::
+
+        .
+        ├── a.txt
+        └── b
+            ├── c.txt
+            └── d
+                └── e.txt
+
+    >>> data = io.BytesIO()
+    >>> zf = zipfile.ZipFile(data, 'w')
+    >>> zf.writestr('a.txt', 'content of a')
+    >>> zf.writestr('b/c.txt', 'content of c')
+    >>> zf.writestr('b/d/e.txt', 'content of e')
+    >>> zf.filename = 'mem/abcde.zip'
+
+    Path accepts the zipfile object itself or a filename
+
+    >>> path = Path(zf)
+
+    From there, several path operations are available.
+
+    Directory iteration (including the zip file itself):
+
+    >>> a, b = path.iterdir()
+    >>> a
+    Path('mem/abcde.zip', 'a.txt')
+    >>> b
+    Path('mem/abcde.zip', 'b/')
+
+    name property:
+
+    >>> b.name
+    'b'
+
+    join with divide operator:
+
+    >>> c = b / 'c.txt'
+    >>> c
+    Path('mem/abcde.zip', 'b/c.txt')
+    >>> c.name
+    'c.txt'
+
+    Read text:
+
+    >>> c.read_text(encoding='utf-8')
+    'content of c'
+
+    existence:
+
+    >>> c.exists()
+    True
+    >>> (b / 'missing.txt').exists()
+    False
+
+    Coercion to string:
+
+    >>> import os
+    >>> str(c).replace(os.sep, posixpath.sep)
+    'mem/abcde.zip/b/c.txt'
+
+    At the root, ``name``, ``filename``, and ``parent``
+    resolve to the zipfile.
+
+    >>> str(path)
+    'mem/abcde.zip/'
+    >>> path.name
+    'abcde.zip'
+    >>> path.filename == pathlib.Path('mem/abcde.zip')
+    True
+    >>> str(path.parent)
+    'mem'
+
+    If the zipfile has no filename, such attributes are not
+    valid and accessing them will raise an Exception.
+
+    >>> zf.filename = None
+    >>> path.name
+    Traceback (most recent call last):
+    ...
+    TypeError: ...
+
+    >>> path.filename
+    Traceback (most recent call last):
+    ...
+    TypeError: ...
+
+    >>> path.parent
+    Traceback (most recent call last):
+    ...
+    TypeError: ...
+
+    # workaround python/cpython#106763
+    >>> pass
+    """
+
+    __repr = "{self.__class__.__name__}({self.root.filename!r}, {self.at!r})"
+
+    def __init__(self, root, at=""):
+        """
+        Construct a Path from a ZipFile or filename.
+
+        Note: When the source is an existing ZipFile object,
+        its type (__class__) will be mutated to a
+        specialized type. If the caller wishes to retain the
+        original type, the caller should either create a
+        separate ZipFile object or pass a filename.
+        """
+        self.root = FastLookup.make(root)
+        self.at = at
+
+    def __eq__(self, other):
+        """
+        >>> Path(zipfile.ZipFile(io.BytesIO(), 'w')) == 'foo'
+        False
+        """
+        if self.__class__ is not other.__class__:
+            return NotImplemented
+        return (self.root, self.at) == (other.root, other.at)
+
+    def __hash__(self):
+        return hash((self.root, self.at))
+
+    def open(self, mode='r', *args, pwd=None, **kwargs):
+        """
+        Open this entry as text or binary following the semantics
+        of ``pathlib.Path.open()`` by passing arguments through
+        to io.TextIOWrapper().
+        """
+        if self.is_dir():
+            raise IsADirectoryError(self)
+        zip_mode = mode[0]
+        if zip_mode == 'r' and not self.exists():
+            raise FileNotFoundError(self)
+        stream = self.root.open(self.at, zip_mode, pwd=pwd)
+        if 'b' in mode:
+            if args or kwargs:
+                raise ValueError("encoding args invalid for binary operation")
+            return stream
+        # Text mode:
+        encoding, args, kwargs = _extract_text_encoding(*args, **kwargs)
+        return io.TextIOWrapper(stream, encoding, *args, **kwargs)
+
+    def _base(self):
+        return pathlib.PurePosixPath(self.at) if self.at else self.filename
+
+    @property
+    def name(self):
+        return self._base().name
+
+    @property
+    def suffix(self):
+        return self._base().suffix
+
+    @property
+    def suffixes(self):
+        return self._base().suffixes
+
+    @property
+    def stem(self):
+        return self._base().stem
+
+    @property
+    def filename(self):
+        return pathlib.Path(self.root.filename).joinpath(self.at)
+
+    def read_text(self, *args, **kwargs):
+        encoding, args, kwargs = _extract_text_encoding(*args, **kwargs)
+        with self.open('r', encoding, *args, **kwargs) as strm:
+            return strm.read()
+
+    def read_bytes(self):
+        with self.open('rb') as strm:
+            return strm.read()
+
+    def _is_child(self, path):
+        return posixpath.dirname(path.at.rstrip("/")) == self.at.rstrip("/")
+
+    def _next(self, at):
+        return self.__class__(self.root, at)
+
+    def is_dir(self):
+        return not self.at or self.at.endswith("/")
+
+    def is_file(self):
+        return self.exists() and not self.is_dir()
+
+    def exists(self):
+        return self.at in self.root._name_set()
+
+    def iterdir(self):
+        if not self.is_dir():
+            raise ValueError("Can't listdir a file")
+        subs = map(self._next, self.root.namelist())
+        return filter(self._is_child, subs)
+
+    def match(self, path_pattern):
+        return pathlib.PurePosixPath(self.at).match(path_pattern)
+
+    def is_symlink(self):
+        """
+        Return whether this path is a symlink.
+        """
+        info = self.root.getinfo(self.at)
+        mode = info.external_attr >> 16
+        return stat.S_ISLNK(mode)
+
+    def glob(self, pattern):
+        if not pattern:
+            raise ValueError(f"Unacceptable pattern: {pattern!r}")
+
+        prefix = re.escape(self.at)
+        tr = Translator(seps='/')
+        matches = re.compile(prefix + tr.translate(pattern)).fullmatch
+        return map(self._next, filter(matches, self.root.namelist()))
+
+    def rglob(self, pattern):
+        return self.glob(f'**/{pattern}')
+
+    def relative_to(self, other, *extra):
+        return posixpath.relpath(str(self), str(other.joinpath(*extra)))
+
+    def __str__(self):
+        return posixpath.join(self.root.filename, self.at)
+
+    def __repr__(self):
+        return self.__repr.format(self=self)
+
+    def joinpath(self, *other):
+        next = posixpath.join(self.at, *other)
+        return self._next(self.root.resolve_dir(next))
+
+    __truediv__ = joinpath
+
+    @property
+    def parent(self):
+        if not self.at:
+            return self.filename.parent
+        parent_at = posixpath.dirname(self.at.rstrip('/'))
+        if parent_at:
+            parent_at += '/'
+        return self._next(parent_at)
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..414896b0bb5c903951ca0c5078a739dbc0f981e4
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/__pycache__/_functools.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/__pycache__/_functools.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..695b8fa576d8d55f48da4d6ebc7ff2d4b96099bd
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/__pycache__/_functools.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/__pycache__/glob.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/__pycache__/glob.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..037916fd035ba2f707a3b8c3f0d931d1532f2b3e
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/__pycache__/glob.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/_functools.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/_functools.py
new file mode 100644
index 0000000000000000000000000000000000000000..7390be21873e4ba439bde0553e4c0dcde8eb7d74
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/_functools.py
@@ -0,0 +1,20 @@
+import collections
+import functools
+
+
+# from jaraco.functools 4.0.2
+def save_method_args(method):
+    """
+    Wrap a method such that when it is called, the args and kwargs are
+    saved on the method.
+    """
+    args_and_kwargs = collections.namedtuple('args_and_kwargs', 'args kwargs')  # noqa: PYI024
+
+    @functools.wraps(method)
+    def wrapper(self, /, *args, **kwargs):
+        attr_name = '_saved_' + method.__name__
+        attr = args_and_kwargs(args, kwargs)
+        setattr(self, attr_name, attr)
+        return method(self, *args, **kwargs)
+
+    return wrapper
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/compat/__init__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/compat/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/compat/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/compat/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..59e74844d6b75f10fa8e0b76a77d3f4b477fd52b
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/compat/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/compat/__pycache__/overlay.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/compat/__pycache__/overlay.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f1601bb4ec87b3fd14df0148f7905ff9373ea4d0
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/compat/__pycache__/overlay.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/compat/__pycache__/py310.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/compat/__pycache__/py310.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a4d45eb5cef3f164b7b1b018b0db7080441d780d
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/compat/__pycache__/py310.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/compat/__pycache__/py313.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/compat/__pycache__/py313.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..be5954a0cc7603b6a22147c42d526dd5b6e3def2
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/compat/__pycache__/py313.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/compat/overlay.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/compat/overlay.py
new file mode 100644
index 0000000000000000000000000000000000000000..5a97ee7cd8b98f3a5487c0a0b0a80ffde5ff4dfd
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/compat/overlay.py
@@ -0,0 +1,37 @@
+"""
+Expose zipp.Path as .zipfile.Path.
+
+Includes everything else in ``zipfile`` to match future usage. Just
+use:
+
+>>> from zipp.compat.overlay import zipfile
+
+in place of ``import zipfile``.
+
+Relative imports are supported too.
+
+>>> from zipp.compat.overlay.zipfile import ZipInfo
+
+The ``zipfile`` object added to ``sys.modules`` needs to be
+hashable (#126).
+
+>>> _ = hash(sys.modules['zipp.compat.overlay.zipfile'])
+"""
+
+import importlib
+import sys
+import types
+
+import zipp
+
+
+class HashableNamespace(types.SimpleNamespace):
+    def __hash__(self):
+        return hash(tuple(vars(self)))
+
+
+zipfile = HashableNamespace(**vars(importlib.import_module('zipfile')))
+zipfile.Path = zipp.Path
+zipfile._path = zipp
+
+sys.modules[__name__ + '.zipfile'] = zipfile  # type: ignore[assignment]
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/compat/py310.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/compat/py310.py
new file mode 100644
index 0000000000000000000000000000000000000000..e1e7ec229062b8556cdd85f530d1ff301b2e6845
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/compat/py310.py
@@ -0,0 +1,13 @@
+import io
+import sys
+
+
+def _text_encoding(encoding, stacklevel=2, /):  # pragma: no cover
+    return encoding
+
+
+text_encoding = (
+    io.text_encoding  # type: ignore[unused-ignore, attr-defined]
+    if sys.version_info > (3, 10)
+    else _text_encoding
+)
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/compat/py313.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/compat/py313.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae458690553f92107ce296adf4bb49add8e78250
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/compat/py313.py
@@ -0,0 +1,34 @@
+import functools
+import sys
+
+
+# from jaraco.functools 4.1
+def identity(x):
+    return x
+
+
+# from jaraco.functools 4.1
+def apply(transform):
+    def wrap(func):
+        return functools.wraps(func)(compose(transform, func))
+
+    return wrap
+
+
+# from jaraco.functools 4.1
+def compose(*funcs):
+    def compose_two(f1, f2):
+        return lambda *args, **kwargs: f1(f2(*args, **kwargs))
+
+    return functools.reduce(compose_two, funcs)
+
+
+def replace(pattern):
+    r"""
+    >>> replace(r'foo\z')
+    'foo\\Z'
+    """
+    return pattern[:-2] + pattern[-2:].replace(r'\z', r'\Z')
+
+
+legacy_end_marker = apply(replace) if sys.version_info < (3, 14) else identity
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/glob.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/glob.py
new file mode 100644
index 0000000000000000000000000000000000000000..1b4ffb33187b65b4378925c472071c845bcecc26
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/_vendor/zipp/glob.py
@@ -0,0 +1,116 @@
+import os
+import re
+
+from .compat.py313 import legacy_end_marker
+
+_default_seps = os.sep + str(os.altsep) * bool(os.altsep)
+
+
+class Translator:
+    """
+    >>> Translator('xyz')
+    Traceback (most recent call last):
+    ...
+    AssertionError: Invalid separators
+
+    >>> Translator('')
+    Traceback (most recent call last):
+    ...
+    AssertionError: Invalid separators
+    """
+
+    seps: str
+
+    def __init__(self, seps: str = _default_seps):
+        assert seps and set(seps) <= set(_default_seps), "Invalid separators"
+        self.seps = seps
+
+    def translate(self, pattern):
+        """
+        Given a glob pattern, produce a regex that matches it.
+        """
+        return self.extend(self.match_dirs(self.translate_core(pattern)))
+
+    @legacy_end_marker
+    def extend(self, pattern):
+        r"""
+        Extend regex for pattern-wide concerns.
+
+        Apply '(?s:)' to create a non-matching group that
+        matches newlines (valid on Unix).
+
+        Append '\z' to imply fullmatch even when match is used.
+        """
+        return rf'(?s:{pattern})\z'
+
+    def match_dirs(self, pattern):
+        """
+        Ensure that zipfile.Path directory names are matched.
+
+        zipfile.Path directory names always end in a slash.
+        """
+        return rf'{pattern}[/]?'
+
+    def translate_core(self, pattern):
+        r"""
+        Given a glob pattern, produce a regex that matches it.
+
+        >>> t = Translator()
+        >>> t.translate_core('*.txt').replace('\\\\', '')
+        '[^/]*\\.txt'
+        >>> t.translate_core('a?txt')
+        'a[^/]txt'
+        >>> t.translate_core('**/*').replace('\\\\', '')
+        '.*/[^/][^/]*'
+        """
+        self.restrict_rglob(pattern)
+        return ''.join(map(self.replace, separate(self.star_not_empty(pattern))))
+
+    def replace(self, match):
+        """
+        Perform the replacements for a match from :func:`separate`.
+        """
+        return match.group('set') or (
+            re.escape(match.group(0))
+            .replace('\\*\\*', r'.*')
+            .replace('\\*', rf'[^{re.escape(self.seps)}]*')
+            .replace('\\?', r'[^/]')
+        )
+
+    def restrict_rglob(self, pattern):
+        """
+        Raise ValueError if ** appears in anything but a full path segment.
+
+        >>> Translator().translate('**foo')
+        Traceback (most recent call last):
+        ...
+        ValueError: ** must appear alone in a path segment
+        """
+        seps_pattern = rf'[{re.escape(self.seps)}]+'
+        segments = re.split(seps_pattern, pattern)
+        if any('**' in segment and segment != '**' for segment in segments):
+            raise ValueError("** must appear alone in a path segment")
+
+    def star_not_empty(self, pattern):
+        """
+        Ensure that * will not match an empty segment.
+        """
+
+        def handle_segment(match):
+            segment = match.group(0)
+            return '?*' if segment == '*' else segment
+
+        not_seps_pattern = rf'[^{re.escape(self.seps)}]+'
+        return re.sub(not_seps_pattern, handle_segment, pattern)
+
+
+def separate(pattern):
+    """
+    Separate out character sets to avoid translating their contents.
+
+    >>> [m.group(0) for m in separate('*.txt')]
+    ['*.txt']
+    >>> [m.group(0) for m in separate('a[?]txt')]
+    ['a', '[?]', 'txt']
+    """
+    return re.finditer(r'([^\[]+)|(?P[\[].*?[\]])|([\[][^\]]*$)', pattern)
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__init__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..50e6c2f54f38db5bf5175a7a4db219815785f1bc
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__init__.py
@@ -0,0 +1,21 @@
+# mypy: disable_error_code=call-overload
+# pyright: reportCallIssue=false, reportArgumentType=false
+# Can't disable on the exact line because distutils doesn't exists on Python 3.12
+# and type-checkers aren't aware of distutils_hack,
+# causing distutils.command.bdist.bdist.format_commands to be Any.
+
+import sys
+
+from distutils.command.bdist import bdist
+
+if 'egg' not in bdist.format_commands:
+    try:
+        # format_commands is a dict in vendored distutils
+        # It used to be a list in older (stdlib) distutils
+        # We support both for backwards compatibility
+        bdist.format_commands['egg'] = ('bdist_egg', "Python .egg file")
+    except TypeError:
+        bdist.format_command['egg'] = ('bdist_egg', "Python .egg file")
+        bdist.format_commands.append('egg')
+
+del bdist, sys
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b89253aeb374974fe64d676ccc89fbed154a2b91
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/_requirestxt.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/_requirestxt.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c5b629dd3aca9641c60351241909bc94fa99c875
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/_requirestxt.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/alias.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/alias.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b1f74fd4f362ff8eb28787aed96f60684aca82cc
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/alias.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/bdist_egg.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/bdist_egg.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4689c29a810277ef657f89785922e4c2b0e01d66
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/bdist_egg.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/bdist_rpm.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/bdist_rpm.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..69becbb9df59f4fb96d60736e5c4ef6be9766530
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/bdist_rpm.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/bdist_wheel.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/bdist_wheel.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..03595dad8148857f9431fc642dbc98c3ea8a977a
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/bdist_wheel.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/build.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/build.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0d9dda9ebfd3483d42c4d69304dafed61cfb25f2
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/build.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/build_clib.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/build_clib.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..87d6b3d0fd58caca96dc86549440b2e7fb97db50
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/build_clib.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/build_ext.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/build_ext.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..14629c89cc83aaff50faf76bf145dd0e2a5dcab8
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/build_ext.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/build_py.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/build_py.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e27868d2273d90dd3b6a7a6d977fd39d64919d33
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/build_py.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/develop.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/develop.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1aeecdff85807bf4d838b4ae379bf6c154801566
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/develop.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/dist_info.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/dist_info.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..25ff2f61f50e3f5e596b55a747613813dd933481
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/dist_info.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/easy_install.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/easy_install.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bab37714cd1c9dcb6874b8aa6584fc47a9812fd3
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/easy_install.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/editable_wheel.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/editable_wheel.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b1555cfc69872ea3355ab54d10510bc342e43a41
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/editable_wheel.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/egg_info.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/egg_info.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ebb486894b5c5aa5f259aeb5bda3bb5cf595acbf
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/egg_info.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/install.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/install.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2d5795a8a28afd87dd864336865d4f08f1d5bfe9
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/install.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/install_egg_info.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/install_egg_info.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fc33c7ab2549341015181375c686f05ddfa138db
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/install_egg_info.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/install_lib.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/install_lib.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..205b2afa626b912a73c5fceaf8c2d333c9935bb0
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/install_lib.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/install_scripts.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/install_scripts.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7583e7fce9ab9c2296ea17959100bb5c407d620e
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/install_scripts.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/rotate.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/rotate.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c78a835a2b7e74ebab88e15250b876244ace7fda
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/rotate.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/saveopts.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/saveopts.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6f7bdefa47fe2b1e91e3bee3bdc6b25de5cca5f9
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/saveopts.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/sdist.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/sdist.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c8c0374b3521ace589125a9bf1e02f85f78bc379
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/sdist.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/setopt.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/setopt.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..03fec4e7790f9d7c7c327b1b8f7ae2e576cd8875
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/setopt.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/test.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/test.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..73267257bb85302fb6eed140e653a9040a598b2e
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/__pycache__/test.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/_requirestxt.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/_requirestxt.py
new file mode 100644
index 0000000000000000000000000000000000000000..9029b125141158d4b12de1db8215819ce6ccf437
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/_requirestxt.py
@@ -0,0 +1,131 @@
+"""Helper code used to generate ``requires.txt`` files in the egg-info directory.
+
+The ``requires.txt`` file has an specific format:
+    - Environment markers need to be part of the section headers and
+      should not be part of the requirement spec itself.
+
+See https://setuptools.pypa.io/en/latest/deprecated/python_eggs.html#requires-txt
+"""
+
+from __future__ import annotations
+
+import io
+from collections import defaultdict
+from collections.abc import Mapping
+from itertools import filterfalse
+from typing import TypeVar
+
+from jaraco.text import yield_lines
+from packaging.requirements import Requirement
+
+from .. import _reqs
+from .._reqs import _StrOrIter
+
+# dict can work as an ordered set
+_T = TypeVar("_T")
+_Ordered = dict[_T, None]
+
+
+def _prepare(
+    install_requires: _StrOrIter, extras_require: Mapping[str, _StrOrIter]
+) -> tuple[list[str], dict[str, list[str]]]:
+    """Given values for ``install_requires`` and ``extras_require``
+    create modified versions in a way that can be written in ``requires.txt``
+    """
+    extras = _convert_extras_requirements(extras_require)
+    return _move_install_requirements_markers(install_requires, extras)
+
+
+def _convert_extras_requirements(
+    extras_require: Mapping[str, _StrOrIter],
+) -> defaultdict[str, _Ordered[Requirement]]:
+    """
+    Convert requirements in `extras_require` of the form
+    `"extra": ["barbazquux; {marker}"]` to
+    `"extra:{marker}": ["barbazquux"]`.
+    """
+    output = defaultdict[str, _Ordered[Requirement]](dict)
+    for section, v in extras_require.items():
+        # Do not strip empty sections.
+        output[section]
+        for r in _reqs.parse(v):
+            output[section + _suffix_for(r)].setdefault(r)
+
+    return output
+
+
+def _move_install_requirements_markers(
+    install_requires: _StrOrIter, extras_require: Mapping[str, _Ordered[Requirement]]
+) -> tuple[list[str], dict[str, list[str]]]:
+    """
+    The ``requires.txt`` file has an specific format:
+        - Environment markers need to be part of the section headers and
+          should not be part of the requirement spec itself.
+
+    Move requirements in ``install_requires`` that are using environment
+    markers ``extras_require``.
+    """
+
+    # divide the install_requires into two sets, simple ones still
+    # handled by install_requires and more complex ones handled by extras_require.
+
+    inst_reqs = list(_reqs.parse(install_requires))
+    simple_reqs = filter(_no_marker, inst_reqs)
+    complex_reqs = filterfalse(_no_marker, inst_reqs)
+    simple_install_requires = list(map(str, simple_reqs))
+
+    for r in complex_reqs:
+        extras_require[':' + str(r.marker)].setdefault(r)
+
+    expanded_extras = dict(
+        # list(dict.fromkeys(...))  ensures a list of unique strings
+        (k, list(dict.fromkeys(str(r) for r in map(_clean_req, v))))
+        for k, v in extras_require.items()
+    )
+
+    return simple_install_requires, expanded_extras
+
+
+def _suffix_for(req):
+    """Return the 'extras_require' suffix for a given requirement."""
+    return ':' + str(req.marker) if req.marker else ''
+
+
+def _clean_req(req):
+    """Given a Requirement, remove environment markers and return it"""
+    r = Requirement(str(req))  # create a copy before modifying
+    r.marker = None
+    return r
+
+
+def _no_marker(req):
+    return not req.marker
+
+
+def _write_requirements(stream, reqs):
+    lines = yield_lines(reqs or ())
+
+    def append_cr(line):
+        return line + '\n'
+
+    lines = map(append_cr, lines)
+    stream.writelines(lines)
+
+
+def write_requirements(cmd, basename, filename):
+    dist = cmd.distribution
+    data = io.StringIO()
+    install_requires, extras_require = _prepare(
+        dist.install_requires or (), dist.extras_require or {}
+    )
+    _write_requirements(data, install_requires)
+    for extra in sorted(extras_require):
+        data.write('\n[{extra}]\n'.format(**vars()))
+        _write_requirements(data, extras_require[extra])
+    cmd.write_or_delete_file("requirements", filename, data.getvalue())
+
+
+def write_setup_requirements(cmd, basename, filename):
+    data = io.StringIO()
+    _write_requirements(data, cmd.distribution.setup_requires)
+    cmd.write_or_delete_file("setup-requirements", filename, data.getvalue())
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/alias.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/alias.py
new file mode 100644
index 0000000000000000000000000000000000000000..0ffa3116d609614d7d15766552cf86f2b55966af
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/alias.py
@@ -0,0 +1,77 @@
+from setuptools.command.setopt import config_file, edit_config, option_base
+
+from distutils.errors import DistutilsOptionError
+
+
+def shquote(arg):
+    """Quote an argument for later parsing by shlex.split()"""
+    for c in '"', "'", "\\", "#":
+        if c in arg:
+            return repr(arg)
+    if arg.split() != [arg]:
+        return repr(arg)
+    return arg
+
+
+class alias(option_base):
+    """Define a shortcut that invokes one or more commands"""
+
+    description = "define a shortcut to invoke one or more commands"
+    command_consumes_arguments = True
+
+    user_options = [
+        ('remove', 'r', 'remove (unset) the alias'),
+    ] + option_base.user_options
+
+    boolean_options = option_base.boolean_options + ['remove']
+
+    def initialize_options(self):
+        option_base.initialize_options(self)
+        self.args = None
+        self.remove = None
+
+    def finalize_options(self) -> None:
+        option_base.finalize_options(self)
+        if self.remove and len(self.args) != 1:
+            raise DistutilsOptionError(
+                "Must specify exactly one argument (the alias name) when using --remove"
+            )
+
+    def run(self) -> None:
+        aliases = self.distribution.get_option_dict('aliases')
+
+        if not self.args:
+            print("Command Aliases")
+            print("---------------")
+            for alias in aliases:
+                print("setup.py alias", format_alias(alias, aliases))
+            return
+
+        elif len(self.args) == 1:
+            (alias,) = self.args
+            if self.remove:
+                command = None
+            elif alias in aliases:
+                print("setup.py alias", format_alias(alias, aliases))
+                return
+            else:
+                print(f"No alias definition found for {alias!r}")
+                return
+        else:
+            alias = self.args[0]
+            command = ' '.join(map(shquote, self.args[1:]))
+
+        edit_config(self.filename, {'aliases': {alias: command}})
+
+
+def format_alias(name, aliases):
+    source, command = aliases[name]
+    if source == config_file('global'):
+        source = '--global-config '
+    elif source == config_file('user'):
+        source = '--user-config '
+    elif source == config_file('local'):
+        source = ''
+    else:
+        source = f'--filename={source!r}'
+    return source + name + ' ' + command
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/bdist_egg.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/bdist_egg.py
new file mode 100644
index 0000000000000000000000000000000000000000..dbabeccb9df13a3f67c45e0b86ea0d31ed95b4e9
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/bdist_egg.py
@@ -0,0 +1,471 @@
+"""setuptools.command.bdist_egg
+
+Build .egg distributions"""
+
+from __future__ import annotations
+
+import marshal
+import os
+import re
+import sys
+import textwrap
+from collections.abc import Iterator
+from sysconfig import get_path, get_platform, get_python_version
+from types import CodeType
+from typing import TYPE_CHECKING, AnyStr, Literal
+
+from setuptools import Command
+from setuptools.extension import Library
+
+from .._path import StrPath, StrPathT, ensure_directory
+
+from distutils import log
+from distutils.dir_util import mkpath, remove_tree
+
+if TYPE_CHECKING:
+    from _typeshed import GenericPath
+    from typing_extensions import TypeAlias
+
+# Same as zipfile._ZipFileMode from typeshed
+_ZipFileMode: TypeAlias = Literal["r", "w", "x", "a"]
+
+
+def _get_purelib():
+    return get_path("purelib")
+
+
+def strip_module(filename):
+    if '.' in filename:
+        filename = os.path.splitext(filename)[0]
+    filename = filename.removesuffix('module')
+    return filename
+
+
+def sorted_walk(
+    dir: GenericPath[AnyStr],
+) -> Iterator[tuple[AnyStr, list[AnyStr], list[AnyStr]]]:
+    """Do os.walk in a reproducible way,
+    independent of indeterministic filesystem readdir order
+    """
+    for base, dirs, files in os.walk(dir):
+        dirs.sort()
+        files.sort()
+        yield base, dirs, files
+
+
+def write_stub(resource, pyfile) -> None:
+    _stub_template = textwrap.dedent(
+        """
+        def __bootstrap__():
+            global __bootstrap__, __loader__, __file__
+            import sys, importlib.resources as irs, importlib.util
+            with irs.as_file(irs.files(__name__).joinpath(%r)) as __file__:
+                __loader__ = None; del __bootstrap__, __loader__
+                spec = importlib.util.spec_from_file_location(__name__,__file__)
+                mod = importlib.util.module_from_spec(spec)
+                spec.loader.exec_module(mod)
+        __bootstrap__()
+        """
+    ).lstrip()
+    with open(pyfile, 'w', encoding="utf-8") as f:
+        f.write(_stub_template % resource)
+
+
+class bdist_egg(Command):
+    description = 'create an "egg" distribution'
+
+    user_options = [
+        ('bdist-dir=', 'b', "temporary directory for creating the distribution"),
+        (
+            'plat-name=',
+            'p',
+            "platform name to embed in generated filenames "
+            "(by default uses `sysconfig.get_platform()`)",
+        ),
+        ('exclude-source-files', None, "remove all .py files from the generated egg"),
+        (
+            'keep-temp',
+            'k',
+            "keep the pseudo-installation tree around after "
+            "creating the distribution archive",
+        ),
+        ('dist-dir=', 'd', "directory to put final built distributions in"),
+        ('skip-build', None, "skip rebuilding everything (for testing/debugging)"),
+    ]
+
+    boolean_options = ['keep-temp', 'skip-build', 'exclude-source-files']
+
+    def initialize_options(self):
+        self.bdist_dir = None
+        self.plat_name = None
+        self.keep_temp = False
+        self.dist_dir = None
+        self.skip_build = False
+        self.egg_output = None
+        self.exclude_source_files = None
+
+    def finalize_options(self) -> None:
+        ei_cmd = self.ei_cmd = self.get_finalized_command("egg_info")
+        self.egg_info = ei_cmd.egg_info
+
+        if self.bdist_dir is None:
+            bdist_base = self.get_finalized_command('bdist').bdist_base
+            self.bdist_dir = os.path.join(bdist_base, 'egg')
+
+        if self.plat_name is None:
+            self.plat_name = get_platform()
+
+        self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
+
+        if self.egg_output is None:
+            # Compute filename of the output egg
+            basename = ei_cmd._get_egg_basename(
+                py_version=get_python_version(),
+                platform=self.distribution.has_ext_modules() and self.plat_name,
+            )
+
+            self.egg_output = os.path.join(self.dist_dir, basename + '.egg')
+
+    def do_install_data(self) -> None:
+        # Hack for packages that install data to install's --install-lib
+        self.get_finalized_command('install').install_lib = self.bdist_dir
+
+        site_packages = os.path.normcase(os.path.realpath(_get_purelib()))
+        old, self.distribution.data_files = self.distribution.data_files, []
+
+        for item in old:
+            if isinstance(item, tuple) and len(item) == 2:
+                if os.path.isabs(item[0]):
+                    realpath = os.path.realpath(item[0])
+                    normalized = os.path.normcase(realpath)
+                    if normalized == site_packages or normalized.startswith(
+                        site_packages + os.sep
+                    ):
+                        item = realpath[len(site_packages) + 1 :], item[1]
+                        # XXX else: raise ???
+            self.distribution.data_files.append(item)
+
+        try:
+            log.info("installing package data to %s", self.bdist_dir)
+            self.call_command('install_data', force=False, root=None)
+        finally:
+            self.distribution.data_files = old
+
+    def get_outputs(self):
+        return [self.egg_output]
+
+    def call_command(self, cmdname, **kw):
+        """Invoke reinitialized command `cmdname` with keyword args"""
+        for dirname in INSTALL_DIRECTORY_ATTRS:
+            kw.setdefault(dirname, self.bdist_dir)
+        kw.setdefault('skip_build', self.skip_build)
+        cmd = self.reinitialize_command(cmdname, **kw)
+        self.run_command(cmdname)
+        return cmd
+
+    def run(self) -> None:  # noqa: C901  # is too complex (14)  # FIXME
+        # Generate metadata first
+        self.run_command("egg_info")
+        # We run install_lib before install_data, because some data hacks
+        # pull their data path from the install_lib command.
+        log.info("installing library code to %s", self.bdist_dir)
+        instcmd = self.get_finalized_command('install')
+        old_root = instcmd.root
+        instcmd.root = None
+        if self.distribution.has_c_libraries() and not self.skip_build:
+            self.run_command('build_clib')
+        cmd = self.call_command('install_lib', warn_dir=False)
+        instcmd.root = old_root
+
+        all_outputs, ext_outputs = self.get_ext_outputs()
+        self.stubs = []
+        to_compile = []
+        for p, ext_name in enumerate(ext_outputs):
+            filename, _ext = os.path.splitext(ext_name)
+            pyfile = os.path.join(self.bdist_dir, strip_module(filename) + '.py')
+            self.stubs.append(pyfile)
+            log.info("creating stub loader for %s", ext_name)
+            write_stub(os.path.basename(ext_name), pyfile)
+            to_compile.append(pyfile)
+            ext_outputs[p] = ext_name.replace(os.sep, '/')
+
+        if to_compile:
+            cmd.byte_compile(to_compile)
+        if self.distribution.data_files:
+            self.do_install_data()
+
+        # Make the EGG-INFO directory
+        archive_root = self.bdist_dir
+        egg_info = os.path.join(archive_root, 'EGG-INFO')
+        self.mkpath(egg_info)
+        if self.distribution.scripts:
+            script_dir = os.path.join(egg_info, 'scripts')
+            log.info("installing scripts to %s", script_dir)
+            self.call_command('install_scripts', install_dir=script_dir, no_ep=True)
+
+        self.copy_metadata_to(egg_info)
+        native_libs = os.path.join(egg_info, "native_libs.txt")
+        if all_outputs:
+            log.info("writing %s", native_libs)
+            ensure_directory(native_libs)
+            with open(native_libs, 'wt', encoding="utf-8") as libs_file:
+                libs_file.write('\n'.join(all_outputs))
+                libs_file.write('\n')
+        elif os.path.isfile(native_libs):
+            log.info("removing %s", native_libs)
+            os.unlink(native_libs)
+
+        write_safety_flag(os.path.join(archive_root, 'EGG-INFO'), self.zip_safe())
+
+        if os.path.exists(os.path.join(self.egg_info, 'depends.txt')):
+            log.warn(
+                "WARNING: 'depends.txt' will not be used by setuptools 0.6!\n"
+                "Use the install_requires/extras_require setup() args instead."
+            )
+
+        if self.exclude_source_files:
+            self.zap_pyfiles()
+
+        # Make the archive
+        make_zipfile(
+            self.egg_output,
+            archive_root,
+            verbose=self.verbose,
+            mode=self.gen_header(),
+        )
+        if not self.keep_temp:
+            remove_tree(self.bdist_dir)
+
+        # Add to 'Distribution.dist_files' so that the "upload" command works
+        getattr(self.distribution, 'dist_files', []).append((
+            'bdist_egg',
+            get_python_version(),
+            self.egg_output,
+        ))
+
+    def zap_pyfiles(self) -> None:
+        log.info("Removing .py files from temporary directory")
+        for base, dirs, files in walk_egg(self.bdist_dir):
+            for name in files:
+                path = os.path.join(base, name)
+
+                if name.endswith('.py'):
+                    log.debug("Deleting %s", path)
+                    os.unlink(path)
+
+                if base.endswith('__pycache__'):
+                    path_old = path
+
+                    pattern = r'(?P.+)\.(?P[^.]+)\.pyc'
+                    m = re.match(pattern, name)
+                    # We shouldn't find any non-pyc files in __pycache__
+                    assert m is not None
+                    path_new = os.path.join(base, os.pardir, m.group('name') + '.pyc')
+                    log.info(f"Renaming file from [{path_old}] to [{path_new}]")
+                    try:
+                        os.remove(path_new)
+                    except OSError:
+                        pass
+                    os.rename(path_old, path_new)
+
+    def zip_safe(self):
+        safe = getattr(self.distribution, 'zip_safe', None)
+        if safe is not None:
+            return safe
+        log.warn("zip_safe flag not set; analyzing archive contents...")
+        return analyze_egg(self.bdist_dir, self.stubs)
+
+    def gen_header(self) -> Literal["w"]:
+        return 'w'
+
+    def copy_metadata_to(self, target_dir) -> None:
+        "Copy metadata (egg info) to the target_dir"
+        # normalize the path (so that a forward-slash in egg_info will
+        # match using startswith below)
+        norm_egg_info = os.path.normpath(self.egg_info)
+        prefix = os.path.join(norm_egg_info, '')
+        for path in self.ei_cmd.filelist.files:
+            if path.startswith(prefix):
+                target = os.path.join(target_dir, path[len(prefix) :])
+                ensure_directory(target)
+                self.copy_file(path, target)
+
+    def get_ext_outputs(self):
+        """Get a list of relative paths to C extensions in the output distro"""
+
+        all_outputs = []
+        ext_outputs = []
+
+        paths = {self.bdist_dir: ''}
+        for base, dirs, files in sorted_walk(self.bdist_dir):
+            all_outputs.extend(
+                paths[base] + filename
+                for filename in files
+                if os.path.splitext(filename)[1].lower() in NATIVE_EXTENSIONS
+            )
+            for filename in dirs:
+                paths[os.path.join(base, filename)] = paths[base] + filename + '/'
+
+        if self.distribution.has_ext_modules():
+            build_cmd = self.get_finalized_command('build_ext')
+            for ext in build_cmd.extensions:
+                if isinstance(ext, Library):
+                    continue
+                fullname = build_cmd.get_ext_fullname(ext.name)
+                filename = build_cmd.get_ext_filename(fullname)
+                if not os.path.basename(filename).startswith('dl-'):
+                    if os.path.exists(os.path.join(self.bdist_dir, filename)):
+                        ext_outputs.append(filename)
+
+        return all_outputs, ext_outputs
+
+
+NATIVE_EXTENSIONS: dict[str, None] = dict.fromkeys('.dll .so .dylib .pyd'.split())
+
+
+def walk_egg(egg_dir: StrPath) -> Iterator[tuple[str, list[str], list[str]]]:
+    """Walk an unpacked egg's contents, skipping the metadata directory"""
+    walker = sorted_walk(egg_dir)
+    base, dirs, files = next(walker)
+    if 'EGG-INFO' in dirs:
+        dirs.remove('EGG-INFO')
+    yield base, dirs, files
+    yield from walker
+
+
+def analyze_egg(egg_dir, stubs):
+    # check for existing flag in EGG-INFO
+    for flag, fn in safety_flags.items():
+        if os.path.exists(os.path.join(egg_dir, 'EGG-INFO', fn)):
+            return flag
+    if not can_scan():
+        return False
+    safe = True
+    for base, dirs, files in walk_egg(egg_dir):
+        for name in files:
+            if name.endswith(('.py', '.pyw')):
+                continue
+            elif name.endswith(('.pyc', '.pyo')):
+                # always scan, even if we already know we're not safe
+                safe = scan_module(egg_dir, base, name, stubs) and safe
+    return safe
+
+
+def write_safety_flag(egg_dir, safe) -> None:
+    # Write or remove zip safety flag file(s)
+    for flag, fn in safety_flags.items():
+        fn = os.path.join(egg_dir, fn)
+        if os.path.exists(fn):
+            if safe is None or bool(safe) != flag:
+                os.unlink(fn)
+        elif safe is not None and bool(safe) == flag:
+            with open(fn, 'wt', encoding="utf-8") as f:
+                f.write('\n')
+
+
+safety_flags = {
+    True: 'zip-safe',
+    False: 'not-zip-safe',
+}
+
+
+def scan_module(egg_dir, base, name, stubs):
+    """Check whether module possibly uses unsafe-for-zipfile stuff"""
+
+    filename = os.path.join(base, name)
+    if filename[:-1] in stubs:
+        return True  # Extension module
+    pkg = base[len(egg_dir) + 1 :].replace(os.sep, '.')
+    module = pkg + (pkg and '.' or '') + os.path.splitext(name)[0]
+    skip = 16  # skip magic & reserved? & date & file size
+    f = open(filename, 'rb')
+    f.read(skip)
+    code = marshal.load(f)
+    f.close()
+    safe = True
+    symbols = dict.fromkeys(iter_symbols(code))
+    for bad in ['__file__', '__path__']:
+        if bad in symbols:
+            log.warn("%s: module references %s", module, bad)
+            safe = False
+    if 'inspect' in symbols:
+        for bad in [
+            'getsource',
+            'getabsfile',
+            'getfile',
+            'getsourcefile',
+            'getsourcelines',
+            'findsource',
+            'getcomments',
+            'getframeinfo',
+            'getinnerframes',
+            'getouterframes',
+            'stack',
+            'trace',
+        ]:
+            if bad in symbols:
+                log.warn("%s: module MAY be using inspect.%s", module, bad)
+                safe = False
+    return safe
+
+
+def iter_symbols(code: CodeType) -> Iterator[str]:
+    """Yield names and strings used by `code` and its nested code objects"""
+    yield from code.co_names
+    for const in code.co_consts:
+        if isinstance(const, str):
+            yield const
+        elif isinstance(const, CodeType):
+            yield from iter_symbols(const)
+
+
+def can_scan() -> bool:
+    if not sys.platform.startswith('java') and sys.platform != 'cli':
+        # CPython, PyPy, etc.
+        return True
+    log.warn("Unable to analyze compiled code on this platform.")
+    log.warn(
+        "Please ask the author to include a 'zip_safe'"
+        " setting (either True or False) in the package's setup.py"
+    )
+    return False
+
+
+# Attribute names of options for commands that might need to be convinced to
+# install to the egg build directory
+
+INSTALL_DIRECTORY_ATTRS = ['install_lib', 'install_dir', 'install_data', 'install_base']
+
+
+def make_zipfile(
+    zip_filename: StrPathT,
+    base_dir,
+    verbose: bool = False,
+    compress=True,
+    mode: _ZipFileMode = 'w',
+) -> StrPathT:
+    """Create a zip file from all the files under 'base_dir'.  The output
+    zip file will be named 'base_dir' + ".zip".  Uses either the "zipfile"
+    Python module (if available) or the InfoZIP "zip" utility (if installed
+    and found on the default search path).  If neither tool is available,
+    raises DistutilsExecError.  Returns the name of the output zip file.
+    """
+    import zipfile
+
+    mkpath(os.path.dirname(zip_filename))  # type: ignore[arg-type] # python/mypy#18075
+    log.info("creating '%s' and adding '%s' to it", zip_filename, base_dir)
+
+    def visit(z, dirname, names):
+        for name in names:
+            path = os.path.normpath(os.path.join(dirname, name))
+            if os.path.isfile(path):
+                p = path[len(base_dir) + 1 :]
+                z.write(path, p)
+                log.debug("adding '%s'", p)
+
+    compression = zipfile.ZIP_DEFLATED if compress else zipfile.ZIP_STORED
+    z = zipfile.ZipFile(zip_filename, mode, compression=compression)
+    for dirname, dirs, files in sorted_walk(base_dir):
+        visit(z, dirname, files)
+    z.close()
+    return zip_filename
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/bdist_rpm.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/bdist_rpm.py
new file mode 100644
index 0000000000000000000000000000000000000000..6dbb27002a8cc7f1cafd4f5cbb75ba39aa7430e2
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/bdist_rpm.py
@@ -0,0 +1,42 @@
+from ..dist import Distribution
+from ..warnings import SetuptoolsDeprecationWarning
+
+import distutils.command.bdist_rpm as orig
+
+
+class bdist_rpm(orig.bdist_rpm):
+    """
+    Override the default bdist_rpm behavior to do the following:
+
+    1. Run egg_info to ensure the name and version are properly calculated.
+    2. Always run 'install' using --single-version-externally-managed to
+       disable eggs in RPM distributions.
+    """
+
+    distribution: Distribution  # override distutils.dist.Distribution with setuptools.dist.Distribution
+
+    def run(self) -> None:
+        SetuptoolsDeprecationWarning.emit(
+            "Deprecated command",
+            """
+            bdist_rpm is deprecated and will be removed in a future version.
+            Use bdist_wheel (wheel packages) instead.
+            """,
+            see_url="https://github.com/pypa/setuptools/issues/1988",
+            due_date=(2023, 10, 30),  # Deprecation introduced in 22 Oct 2021.
+        )
+
+        # ensure distro name is up-to-date
+        self.run_command('egg_info')
+
+        orig.bdist_rpm.run(self)
+
+    def _make_spec_file(self):
+        spec = orig.bdist_rpm._make_spec_file(self)
+        return [
+            line.replace(
+                "setup.py install ",
+                "setup.py install --single-version-externally-managed ",
+            ).replace("%setup", "%setup -n %{name}-%{unmangled_version}")
+            for line in spec
+        ]
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/bdist_wheel.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/bdist_wheel.py
new file mode 100644
index 0000000000000000000000000000000000000000..3bdfa0b35aedb4665ac1f127c016392162869832
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/bdist_wheel.py
@@ -0,0 +1,603 @@
+"""
+Create a wheel (.whl) distribution.
+
+A wheel is a built archive format.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import struct
+import sys
+import sysconfig
+import warnings
+from collections.abc import Iterable, Sequence
+from email.generator import BytesGenerator
+from glob import iglob
+from typing import Literal, cast
+from zipfile import ZIP_DEFLATED, ZIP_STORED
+
+from packaging import tags, version as _packaging_version
+from wheel.wheelfile import WheelFile
+
+from .. import Command, __version__, _shutil
+from .._core_metadata import _safe_license_file
+from .._normalization import safer_name
+from ..warnings import SetuptoolsDeprecationWarning
+from .egg_info import egg_info as egg_info_cls
+
+from distutils import log
+
+
+def safe_version(version: str) -> str:
+    """
+    Convert an arbitrary string to a standard version string
+    """
+    try:
+        # normalize the version
+        return str(_packaging_version.Version(version))
+    except _packaging_version.InvalidVersion:
+        version = version.replace(" ", ".")
+        return re.sub("[^A-Za-z0-9.]+", "-", version)
+
+
+setuptools_major_version = int(__version__.split(".")[0])
+
+PY_LIMITED_API_PATTERN = r"cp3\d"
+
+
+def _is_32bit_interpreter() -> bool:
+    return struct.calcsize("P") == 4
+
+
+def python_tag() -> str:
+    return f"py{sys.version_info.major}"
+
+
+def get_platform(archive_root: str | None) -> str:
+    """Return our platform name 'win32', 'linux_x86_64'"""
+    result = sysconfig.get_platform()
+    if result.startswith("macosx") and archive_root is not None:  # pragma: no cover
+        from wheel.macosx_libfile import calculate_macosx_platform_tag
+
+        result = calculate_macosx_platform_tag(archive_root, result)
+    elif _is_32bit_interpreter():
+        if result == "linux-x86_64":
+            # pip pull request #3497
+            result = "linux-i686"
+        elif result == "linux-aarch64":
+            # packaging pull request #234
+            # TODO armv8l, packaging pull request #690 => this did not land
+            # in pip/packaging yet
+            result = "linux-armv7l"
+
+    return result.replace("-", "_")
+
+
+def get_flag(
+    var: str, fallback: bool, expected: bool = True, warn: bool = True
+) -> bool:
+    """Use a fallback value for determining SOABI flags if the needed config
+    var is unset or unavailable."""
+    val = sysconfig.get_config_var(var)
+    if val is None:
+        if warn:
+            warnings.warn(
+                f"Config variable '{var}' is unset, Python ABI tag may be incorrect",
+                RuntimeWarning,
+                stacklevel=2,
+            )
+        return fallback
+    return val == expected
+
+
+def get_abi_tag() -> str | None:
+    """Return the ABI tag based on SOABI (if available) or emulate SOABI (PyPy2)."""
+    soabi: str = sysconfig.get_config_var("SOABI")
+    impl = tags.interpreter_name()
+    if not soabi and impl in ("cp", "pp") and hasattr(sys, "maxunicode"):
+        d = ""
+        u = ""
+        if get_flag("Py_DEBUG", hasattr(sys, "gettotalrefcount"), warn=(impl == "cp")):
+            d = "d"
+
+        abi = f"{impl}{tags.interpreter_version()}{d}{u}"
+    elif soabi and impl == "cp" and soabi.startswith("cpython"):
+        # non-Windows
+        abi = "cp" + soabi.split("-")[1]
+    elif soabi and impl == "cp" and soabi.startswith("cp"):
+        # Windows
+        abi = soabi.split("-")[0]
+        if hasattr(sys, "gettotalrefcount"):
+            # using debug build; append "d" flag
+            abi += "d"
+    elif soabi and impl == "pp":
+        # we want something like pypy36-pp73
+        abi = "-".join(soabi.split("-")[:2])
+        abi = abi.replace(".", "_").replace("-", "_")
+    elif soabi and impl == "graalpy":
+        abi = "-".join(soabi.split("-")[:3])
+        abi = abi.replace(".", "_").replace("-", "_")
+    elif soabi:
+        abi = soabi.replace(".", "_").replace("-", "_")
+    else:
+        abi = None
+
+    return abi
+
+
+def safer_version(version: str) -> str:
+    return safe_version(version).replace("-", "_")
+
+
+class bdist_wheel(Command):
+    description = "create a wheel distribution"
+
+    supported_compressions = {
+        "stored": ZIP_STORED,
+        "deflated": ZIP_DEFLATED,
+    }
+
+    user_options = [
+        ("bdist-dir=", "b", "temporary directory for creating the distribution"),
+        (
+            "plat-name=",
+            "p",
+            "platform name to embed in generated filenames "
+            f"[default: {get_platform(None)}]",
+        ),
+        (
+            "keep-temp",
+            "k",
+            "keep the pseudo-installation tree around after "
+            "creating the distribution archive",
+        ),
+        ("dist-dir=", "d", "directory to put final built distributions in"),
+        ("skip-build", None, "skip rebuilding everything (for testing/debugging)"),
+        (
+            "relative",
+            None,
+            "build the archive using relative paths [default: false]",
+        ),
+        (
+            "owner=",
+            "u",
+            "Owner name used when creating a tar file [default: current user]",
+        ),
+        (
+            "group=",
+            "g",
+            "Group name used when creating a tar file [default: current group]",
+        ),
+        ("universal", None, "*DEPRECATED* make a universal wheel [default: false]"),
+        (
+            "compression=",
+            None,
+            f"zipfile compression (one of: {', '.join(supported_compressions)}) [default: 'deflated']",
+        ),
+        (
+            "python-tag=",
+            None,
+            f"Python implementation compatibility tag [default: '{python_tag()}']",
+        ),
+        (
+            "build-number=",
+            None,
+            "Build number for this particular version. "
+            "As specified in PEP-0427, this must start with a digit. "
+            "[default: None]",
+        ),
+        (
+            "py-limited-api=",
+            None,
+            "Python tag (cp32|cp33|cpNN) for abi3 wheel tag [default: false]",
+        ),
+        (
+            "dist-info-dir=",
+            None,
+            "directory where a pre-generated dist-info can be found (e.g. as a "
+            "result of calling the PEP517 'prepare_metadata_for_build_wheel' "
+            "method)",
+        ),
+    ]
+
+    boolean_options = ["keep-temp", "skip-build", "relative", "universal"]
+
+    def initialize_options(self) -> None:
+        self.bdist_dir: str | None = None
+        self.data_dir = ""
+        self.plat_name: str | None = None
+        self.plat_tag: str | None = None
+        self.format = "zip"
+        self.keep_temp = False
+        self.dist_dir: str | None = None
+        self.dist_info_dir = None
+        self.egginfo_dir: str | None = None
+        self.root_is_pure: bool | None = None
+        self.skip_build = False
+        self.relative = False
+        self.owner = None
+        self.group = None
+        self.universal = False
+        self.compression: str | int = "deflated"
+        self.python_tag = python_tag()
+        self.build_number: str | None = None
+        self.py_limited_api: str | Literal[False] = False
+        self.plat_name_supplied = False
+
+    def finalize_options(self) -> None:
+        if not self.bdist_dir:
+            bdist_base = self.get_finalized_command("bdist").bdist_base
+            self.bdist_dir = os.path.join(bdist_base, "wheel")
+
+        if self.dist_info_dir is None:
+            egg_info = cast(egg_info_cls, self.distribution.get_command_obj("egg_info"))
+            egg_info.ensure_finalized()  # needed for correct `wheel_dist_name`
+
+        self.data_dir = self.wheel_dist_name + ".data"
+        self.plat_name_supplied = bool(self.plat_name)
+
+        need_options = ("dist_dir", "plat_name", "skip_build")
+
+        self.set_undefined_options("bdist", *zip(need_options, need_options))
+
+        self.root_is_pure = not (
+            self.distribution.has_ext_modules() or self.distribution.has_c_libraries()
+        )
+
+        self._validate_py_limited_api()
+
+        # Support legacy [wheel] section for setting universal
+        wheel = self.distribution.get_option_dict("wheel")
+        if "universal" in wheel:  # pragma: no cover
+            # please don't define this in your global configs
+            log.warn("The [wheel] section is deprecated. Use [bdist_wheel] instead.")
+            val = wheel["universal"][1].strip()
+            if val.lower() in ("1", "true", "yes"):
+                self.universal = True
+
+        if self.universal:
+            SetuptoolsDeprecationWarning.emit(
+                "bdist_wheel.universal is deprecated",
+                """
+                With Python 2.7 end-of-life, support for building universal wheels
+                (i.e., wheels that support both Python 2 and Python 3)
+                is being obviated.
+                Please discontinue using this option, or if you still need it,
+                file an issue with pypa/setuptools describing your use case.
+                """,
+                due_date=(2025, 8, 30),  # Introduced in 2024-08-30
+            )
+
+        if self.build_number is not None and not self.build_number[:1].isdigit():
+            raise ValueError("Build tag (build-number) must start with a digit.")
+
+    def _validate_py_limited_api(self) -> None:
+        if not self.py_limited_api:
+            return
+
+        if not re.match(PY_LIMITED_API_PATTERN, self.py_limited_api):
+            raise ValueError(f"py-limited-api must match '{PY_LIMITED_API_PATTERN}'")
+
+        if sysconfig.get_config_var("Py_GIL_DISABLED"):
+            raise ValueError(
+                f"`py_limited_api={self.py_limited_api!r}` not supported. "
+                "`Py_LIMITED_API` is currently incompatible with "
+                "`Py_GIL_DISABLED`. "
+                "See https://github.com/python/cpython/issues/111506."
+            )
+
+    @property
+    def wheel_dist_name(self) -> str:
+        """Return distribution full name with - replaced with _"""
+        components = [
+            safer_name(self.distribution.get_name()),
+            safer_version(self.distribution.get_version()),
+        ]
+        if self.build_number:
+            components.append(self.build_number)
+        return "-".join(components)
+
+    def get_tag(self) -> tuple[str, str, str]:
+        # bdist sets self.plat_name if unset, we should only use it for purepy
+        # wheels if the user supplied it.
+        if self.plat_name_supplied and self.plat_name:
+            plat_name = self.plat_name
+        elif self.root_is_pure:
+            plat_name = "any"
+        else:
+            # macosx contains system version in platform name so need special handle
+            if self.plat_name and not self.plat_name.startswith("macosx"):
+                plat_name = self.plat_name
+            else:
+                # on macosx always limit the platform name to comply with any
+                # c-extension modules in bdist_dir, since the user can specify
+                # a higher MACOSX_DEPLOYMENT_TARGET via tools like CMake
+
+                # on other platforms, and on macosx if there are no c-extension
+                # modules, use the default platform name.
+                plat_name = get_platform(self.bdist_dir)
+
+            if _is_32bit_interpreter():
+                if plat_name in ("linux-x86_64", "linux_x86_64"):
+                    plat_name = "linux_i686"
+                if plat_name in ("linux-aarch64", "linux_aarch64"):
+                    # TODO armv8l, packaging pull request #690 => this did not land
+                    # in pip/packaging yet
+                    plat_name = "linux_armv7l"
+
+        plat_name = (
+            plat_name.lower().replace("-", "_").replace(".", "_").replace(" ", "_")
+        )
+
+        if self.root_is_pure:
+            if self.universal:
+                impl = "py2.py3"
+            else:
+                impl = self.python_tag
+            tag = (impl, "none", plat_name)
+        else:
+            impl_name = tags.interpreter_name()
+            impl_ver = tags.interpreter_version()
+            impl = impl_name + impl_ver
+            # We don't work on CPython 3.1, 3.0.
+            if self.py_limited_api and (impl_name + impl_ver).startswith("cp3"):
+                impl = self.py_limited_api
+                abi_tag = "abi3"
+            else:
+                abi_tag = str(get_abi_tag()).lower()
+            tag = (impl, abi_tag, plat_name)
+            # issue gh-374: allow overriding plat_name
+            supported_tags = [
+                (t.interpreter, t.abi, plat_name) for t in tags.sys_tags()
+            ]
+            assert tag in supported_tags, (
+                f"would build wheel with unsupported tag {tag}"
+            )
+        return tag
+
+    def run(self):
+        build_scripts = self.reinitialize_command("build_scripts")
+        build_scripts.executable = "python"
+        build_scripts.force = True
+
+        build_ext = self.reinitialize_command("build_ext")
+        build_ext.inplace = False
+
+        if not self.skip_build:
+            self.run_command("build")
+
+        install = self.reinitialize_command("install", reinit_subcommands=True)
+        install.root = self.bdist_dir
+        install.compile = False
+        install.skip_build = self.skip_build
+        install.warn_dir = False
+
+        # A wheel without setuptools scripts is more cross-platform.
+        # Use the (undocumented) `no_ep` option to setuptools'
+        # install_scripts command to avoid creating entry point scripts.
+        install_scripts = self.reinitialize_command("install_scripts")
+        install_scripts.no_ep = True
+
+        # Use a custom scheme for the archive, because we have to decide
+        # at installation time which scheme to use.
+        for key in ("headers", "scripts", "data", "purelib", "platlib"):
+            setattr(install, "install_" + key, os.path.join(self.data_dir, key))
+
+        basedir_observed = ""
+
+        if os.name == "nt":
+            # win32 barfs if any of these are ''; could be '.'?
+            # (distutils.command.install:change_roots bug)
+            basedir_observed = os.path.normpath(os.path.join(self.data_dir, ".."))
+            self.install_libbase = self.install_lib = basedir_observed
+
+        setattr(
+            install,
+            "install_purelib" if self.root_is_pure else "install_platlib",
+            basedir_observed,
+        )
+
+        log.info(f"installing to {self.bdist_dir}")
+
+        self.run_command("install")
+
+        impl_tag, abi_tag, plat_tag = self.get_tag()
+        archive_basename = f"{self.wheel_dist_name}-{impl_tag}-{abi_tag}-{plat_tag}"
+        if not self.relative:
+            archive_root = self.bdist_dir
+        else:
+            archive_root = os.path.join(
+                self.bdist_dir, self._ensure_relative(install.install_base)
+            )
+
+        self.set_undefined_options("install_egg_info", ("target", "egginfo_dir"))
+        distinfo_dirname = (
+            f"{safer_name(self.distribution.get_name())}-"
+            f"{safer_version(self.distribution.get_version())}.dist-info"
+        )
+        distinfo_dir = os.path.join(self.bdist_dir, distinfo_dirname)
+        if self.dist_info_dir:
+            # Use the given dist-info directly.
+            log.debug(f"reusing {self.dist_info_dir}")
+            shutil.copytree(self.dist_info_dir, distinfo_dir)
+            # Egg info is still generated, so remove it now to avoid it getting
+            # copied into the wheel.
+            _shutil.rmtree(self.egginfo_dir)
+        else:
+            # Convert the generated egg-info into dist-info.
+            self.egg2dist(self.egginfo_dir, distinfo_dir)
+
+        self.write_wheelfile(distinfo_dir)
+
+        # Make the archive
+        if not os.path.exists(self.dist_dir):
+            os.makedirs(self.dist_dir)
+
+        wheel_path = os.path.join(self.dist_dir, archive_basename + ".whl")
+        with WheelFile(wheel_path, "w", self._zip_compression()) as wf:
+            wf.write_files(archive_root)
+
+        # Add to 'Distribution.dist_files' so that the "upload" command works
+        getattr(self.distribution, "dist_files", []).append((
+            "bdist_wheel",
+            f"{sys.version_info.major}.{sys.version_info.minor}",
+            wheel_path,
+        ))
+
+        if not self.keep_temp:
+            log.info(f"removing {self.bdist_dir}")
+            _shutil.rmtree(self.bdist_dir)
+
+    def write_wheelfile(
+        self, wheelfile_base: str, generator: str = f"setuptools ({__version__})"
+    ) -> None:
+        from email.message import Message
+
+        msg = Message()
+        msg["Wheel-Version"] = "1.0"  # of the spec
+        msg["Generator"] = generator
+        msg["Root-Is-Purelib"] = str(self.root_is_pure).lower()
+        if self.build_number is not None:
+            msg["Build"] = self.build_number
+
+        # Doesn't work for bdist_wininst
+        impl_tag, abi_tag, plat_tag = self.get_tag()
+        for impl in impl_tag.split("."):
+            for abi in abi_tag.split("."):
+                for plat in plat_tag.split("."):
+                    msg["Tag"] = "-".join((impl, abi, plat))
+
+        wheelfile_path = os.path.join(wheelfile_base, "WHEEL")
+        log.info(f"creating {wheelfile_path}")
+        with open(wheelfile_path, "wb") as f:
+            BytesGenerator(f, maxheaderlen=0).flatten(msg)
+
+    def _ensure_relative(self, path: str) -> str:
+        # copied from dir_util, deleted
+        drive, path = os.path.splitdrive(path)
+        if path[0:1] == os.sep:
+            path = drive + path[1:]
+        return path
+
+    @property
+    def license_paths(self) -> Iterable[str]:
+        if setuptools_major_version >= 57:
+            # Setuptools has resolved any patterns to actual file names
+            return self.distribution.metadata.license_files or ()
+
+        files = set[str]()
+        metadata = self.distribution.get_option_dict("metadata")
+        if setuptools_major_version >= 42:
+            # Setuptools recognizes the license_files option but does not do globbing
+            patterns = cast(Sequence[str], self.distribution.metadata.license_files)
+        else:
+            # Prior to those, wheel is entirely responsible for handling license files
+            if "license_files" in metadata:
+                patterns = metadata["license_files"][1].split()
+            else:
+                patterns = ()
+
+        if "license_file" in metadata:
+            warnings.warn(
+                'The "license_file" option is deprecated. Use "license_files" instead.',
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            files.add(metadata["license_file"][1])
+
+        if not files and not patterns and not isinstance(patterns, list):
+            patterns = ("LICEN[CS]E*", "COPYING*", "NOTICE*", "AUTHORS*")
+
+        for pattern in patterns:
+            for path in iglob(pattern):
+                if path.endswith("~"):
+                    log.debug(
+                        f'ignoring license file "{path}" as it looks like a backup'
+                    )
+                    continue
+
+                if path not in files and os.path.isfile(path):
+                    log.info(
+                        f'adding license file "{path}" (matched pattern "{pattern}")'
+                    )
+                    files.add(path)
+
+        return files
+
+    def egg2dist(self, egginfo_path: str, distinfo_path: str) -> None:
+        """Convert an .egg-info directory into a .dist-info directory"""
+
+        def adios(p: str) -> None:
+            """Appropriately delete directory, file or link."""
+            if os.path.exists(p) and not os.path.islink(p) and os.path.isdir(p):
+                _shutil.rmtree(p)
+            elif os.path.exists(p):
+                os.unlink(p)
+
+        adios(distinfo_path)
+
+        if not os.path.exists(egginfo_path):
+            # There is no egg-info. This is probably because the egg-info
+            # file/directory is not named matching the distribution name used
+            # to name the archive file. Check for this case and report
+            # accordingly.
+            import glob
+
+            pat = os.path.join(os.path.dirname(egginfo_path), "*.egg-info")
+            possible = glob.glob(pat)
+            err = f"Egg metadata expected at {egginfo_path} but not found"
+            if possible:
+                alt = os.path.basename(possible[0])
+                err += f" ({alt} found - possible misnamed archive file?)"
+
+            raise ValueError(err)
+
+        # .egg-info is a directory
+        pkginfo_path = os.path.join(egginfo_path, "PKG-INFO")
+
+        # ignore common egg metadata that is useless to wheel
+        shutil.copytree(
+            egginfo_path,
+            distinfo_path,
+            ignore=lambda x, y: {
+                "PKG-INFO",
+                "requires.txt",
+                "SOURCES.txt",
+                "not-zip-safe",
+            },
+        )
+
+        # delete dependency_links if it is only whitespace
+        dependency_links_path = os.path.join(distinfo_path, "dependency_links.txt")
+        with open(dependency_links_path, encoding="utf-8") as dependency_links_file:
+            dependency_links = dependency_links_file.read().strip()
+        if not dependency_links:
+            adios(dependency_links_path)
+
+        metadata_path = os.path.join(distinfo_path, "METADATA")
+        shutil.copy(pkginfo_path, metadata_path)
+
+        licenses_folder_path = os.path.join(distinfo_path, "licenses")
+        for license_path in self.license_paths:
+            safe_path = _safe_license_file(license_path)
+            dist_info_license_path = os.path.join(licenses_folder_path, safe_path)
+            os.makedirs(os.path.dirname(dist_info_license_path), exist_ok=True)
+            shutil.copy(license_path, dist_info_license_path)
+
+        adios(egginfo_path)
+
+    def _zip_compression(self) -> int:
+        if (
+            isinstance(self.compression, int)
+            and self.compression in self.supported_compressions.values()
+        ):
+            return self.compression
+
+        compression = self.supported_compressions.get(str(self.compression))
+        if compression is not None:
+            return compression
+
+        raise ValueError(f"Unsupported compression: {self.compression!r}")
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/build.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/build.py
new file mode 100644
index 0000000000000000000000000000000000000000..54cbb8d2e7bf41de4e187613718879f2a4c3d8d3
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/build.py
@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+from typing import Protocol
+
+from ..dist import Distribution
+
+from distutils.command.build import build as _build
+
+_ORIGINAL_SUBCOMMANDS = {"build_py", "build_clib", "build_ext", "build_scripts"}
+
+
+class build(_build):
+    distribution: Distribution  # override distutils.dist.Distribution with setuptools.dist.Distribution
+
+    # copy to avoid sharing the object with parent class
+    sub_commands = _build.sub_commands[:]
+
+
+class SubCommand(Protocol):
+    """In order to support editable installations (see :pep:`660`) all
+    build subcommands **SHOULD** implement this protocol. They also **MUST** inherit
+    from ``setuptools.Command``.
+
+    When creating an :pep:`editable wheel <660>`, ``setuptools`` will try to evaluate
+    custom ``build`` subcommands using the following procedure:
+
+    1. ``setuptools`` will set the ``editable_mode`` attribute to ``True``
+    2. ``setuptools`` will execute the ``run()`` command.
+
+       .. important::
+          Subcommands **SHOULD** take advantage of ``editable_mode=True`` to adequate
+          its behaviour or perform optimisations.
+
+          For example, if a subcommand doesn't need to generate an extra file and
+          all it does is to copy a source file into the build directory,
+          ``run()`` **SHOULD** simply "early return".
+
+          Similarly, if the subcommand creates files that would be placed alongside
+          Python files in the final distribution, during an editable install
+          the command **SHOULD** generate these files "in place" (i.e. write them to
+          the original source directory, instead of using the build directory).
+          Note that ``get_output_mapping()`` should reflect that and include mappings
+          for "in place" builds accordingly.
+
+    3. ``setuptools`` use any knowledge it can derive from the return values of
+       ``get_outputs()`` and ``get_output_mapping()`` to create an editable wheel.
+       When relevant ``setuptools`` **MAY** attempt to use file links based on the value
+       of ``get_output_mapping()``. Alternatively, ``setuptools`` **MAY** attempt to use
+       :doc:`import hooks ` to redirect any attempt to import
+       to the directory with the original source code and other files built in place.
+
+    Please note that custom sub-commands **SHOULD NOT** rely on ``run()`` being
+    executed (or not) to provide correct return values for ``get_outputs()``,
+    ``get_output_mapping()`` or ``get_source_files()``. The ``get_*`` methods should
+    work independently of ``run()``.
+    """
+
+    editable_mode: bool = False
+    """Boolean flag that will be set to ``True`` when setuptools is used for an
+    editable installation (see :pep:`660`).
+    Implementations **SHOULD** explicitly set the default value of this attribute to
+    ``False``.
+    When subcommands run, they can use this flag to perform optimizations or change
+    their behaviour accordingly.
+    """
+
+    build_lib: str
+    """String representing the directory where the build artifacts should be stored,
+    e.g. ``build/lib``.
+    For example, if a distribution wants to provide a Python module named ``pkg.mod``,
+    then a corresponding file should be written to ``{build_lib}/package/module.py``.
+    A way of thinking about this is that the files saved under ``build_lib``
+    would be eventually copied to one of the directories in :obj:`site.PREFIXES`
+    upon installation.
+
+    A command that produces platform-independent files (e.g. compiling text templates
+    into Python functions), **CAN** initialize ``build_lib`` by copying its value from
+    the ``build_py`` command. On the other hand, a command that produces
+    platform-specific files **CAN** initialize ``build_lib`` by copying its value from
+    the ``build_ext`` command. In general this is done inside the ``finalize_options``
+    method with the help of the ``set_undefined_options`` command::
+
+        def finalize_options(self):
+            self.set_undefined_options("build_py", ("build_lib", "build_lib"))
+            ...
+    """
+
+    def initialize_options(self) -> None:
+        """(Required by the original :class:`setuptools.Command` interface)"""
+        ...
+
+    def finalize_options(self) -> None:
+        """(Required by the original :class:`setuptools.Command` interface)"""
+        ...
+
+    def run(self) -> None:
+        """(Required by the original :class:`setuptools.Command` interface)"""
+        ...
+
+    def get_source_files(self) -> list[str]:
+        """
+        Return a list of all files that are used by the command to create the expected
+        outputs.
+        For example, if your build command transpiles Java files into Python, you should
+        list here all the Java files.
+        The primary purpose of this function is to help populating the ``sdist``
+        with all the files necessary to build the distribution.
+        All files should be strings relative to the project root directory.
+        """
+        ...
+
+    def get_outputs(self) -> list[str]:
+        """
+        Return a list of files intended for distribution as they would have been
+        produced by the build.
+        These files should be strings in the form of
+        ``"{build_lib}/destination/file/path"``.
+
+        .. note::
+           The return value of ``get_output()`` should include all files used as keys
+           in ``get_output_mapping()`` plus files that are generated during the build
+           and don't correspond to any source file already present in the project.
+        """
+        ...
+
+    def get_output_mapping(self) -> dict[str, str]:
+        """
+        Return a mapping between destination files as they would be produced by the
+        build (dict keys) into the respective existing (source) files (dict values).
+        Existing (source) files should be represented as strings relative to the project
+        root directory.
+        Destination files should be strings in the form of
+        ``"{build_lib}/destination/file/path"``.
+        """
+        ...
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/build_clib.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/build_clib.py
new file mode 100644
index 0000000000000000000000000000000000000000..f376f4ce4d2afc4a58f1fa0e85624136edc93835
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/build_clib.py
@@ -0,0 +1,103 @@
+from ..dist import Distribution
+from ..modified import newer_pairwise_group
+
+import distutils.command.build_clib as orig
+from distutils import log
+from distutils.errors import DistutilsSetupError
+
+
+class build_clib(orig.build_clib):
+    """
+    Override the default build_clib behaviour to do the following:
+
+    1. Implement a rudimentary timestamp-based dependency system
+       so 'compile()' doesn't run every time.
+    2. Add more keys to the 'build_info' dictionary:
+        * obj_deps - specify dependencies for each object compiled.
+                     this should be a dictionary mapping a key
+                     with the source filename to a list of
+                     dependencies. Use an empty string for global
+                     dependencies.
+        * cflags   - specify a list of additional flags to pass to
+                     the compiler.
+    """
+
+    distribution: Distribution  # override distutils.dist.Distribution with setuptools.dist.Distribution
+
+    def build_libraries(self, libraries) -> None:
+        for lib_name, build_info in libraries:
+            sources = build_info.get('sources')
+            if sources is None or not isinstance(sources, (list, tuple)):
+                raise DistutilsSetupError(
+                    f"in 'libraries' option (library '{lib_name}'), "
+                    "'sources' must be present and must be "
+                    "a list of source filenames"
+                )
+            sources = sorted(list(sources))
+
+            log.info("building '%s' library", lib_name)
+
+            # Make sure everything is the correct type.
+            # obj_deps should be a dictionary of keys as sources
+            # and a list/tuple of files that are its dependencies.
+            obj_deps = build_info.get('obj_deps', dict())
+            if not isinstance(obj_deps, dict):
+                raise DistutilsSetupError(
+                    f"in 'libraries' option (library '{lib_name}'), "
+                    "'obj_deps' must be a dictionary of "
+                    "type 'source: list'"
+                )
+            dependencies = []
+
+            # Get the global dependencies that are specified by the '' key.
+            # These will go into every source's dependency list.
+            global_deps = obj_deps.get('', list())
+            if not isinstance(global_deps, (list, tuple)):
+                raise DistutilsSetupError(
+                    f"in 'libraries' option (library '{lib_name}'), "
+                    "'obj_deps' must be a dictionary of "
+                    "type 'source: list'"
+                )
+
+            # Build the list to be used by newer_pairwise_group
+            # each source will be auto-added to its dependencies.
+            for source in sources:
+                src_deps = [source]
+                src_deps.extend(global_deps)
+                extra_deps = obj_deps.get(source, list())
+                if not isinstance(extra_deps, (list, tuple)):
+                    raise DistutilsSetupError(
+                        f"in 'libraries' option (library '{lib_name}'), "
+                        "'obj_deps' must be a dictionary of "
+                        "type 'source: list'"
+                    )
+                src_deps.extend(extra_deps)
+                dependencies.append(src_deps)
+
+            expected_objects = self.compiler.object_filenames(
+                sources,
+                output_dir=self.build_temp,
+            )
+
+            if newer_pairwise_group(dependencies, expected_objects) != ([], []):
+                # First, compile the source code to object files in the library
+                # directory.  (This should probably change to putting object
+                # files in a temporary build directory.)
+                macros = build_info.get('macros')
+                include_dirs = build_info.get('include_dirs')
+                cflags = build_info.get('cflags')
+                self.compiler.compile(
+                    sources,
+                    output_dir=self.build_temp,
+                    macros=macros,
+                    include_dirs=include_dirs,
+                    extra_postargs=cflags,
+                    debug=self.debug,
+                )
+
+            # Now "link" the object files together into a static library.
+            # (On Unix at least, this isn't really linking -- it just
+            # builds an archive.  Whatever.)
+            self.compiler.create_static_lib(
+                expected_objects, lib_name, output_dir=self.build_clib, debug=self.debug
+            )
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/build_ext.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/build_ext.py
new file mode 100644
index 0000000000000000000000000000000000000000..dbb956db8d0f3da22fb6acb6644e86929c999514
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/build_ext.py
@@ -0,0 +1,470 @@
+from __future__ import annotations
+
+import itertools
+import operator
+import os
+import sys
+import textwrap
+from collections.abc import Iterator
+from importlib.machinery import EXTENSION_SUFFIXES
+from importlib.util import cache_from_source as _compiled_file_name
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from setuptools.dist import Distribution
+from setuptools.errors import BaseError
+from setuptools.extension import Extension, Library
+
+from distutils import log
+from distutils.ccompiler import new_compiler
+from distutils.sysconfig import customize_compiler, get_config_var
+
+if TYPE_CHECKING:
+    # Cython not installed on CI tests, causing _build_ext to be `Any`
+    from distutils.command.build_ext import build_ext as _build_ext
+else:
+    try:
+        # Attempt to use Cython for building extensions, if available
+        from Cython.Distutils.build_ext import build_ext as _build_ext
+
+        # Additionally, assert that the compiler module will load
+        # also. Ref #1229.
+        __import__('Cython.Compiler.Main')
+    except ImportError:
+        from distutils.command.build_ext import build_ext as _build_ext
+
+# make sure _config_vars is initialized
+get_config_var("LDSHARED")
+# Not publicly exposed in typeshed distutils stubs, but this is done on purpose
+# See https://github.com/pypa/setuptools/pull/4228#issuecomment-1959856400
+from distutils.sysconfig import _config_vars as _CONFIG_VARS  # noqa: E402
+
+
+def _customize_compiler_for_shlib(compiler):
+    if sys.platform == "darwin":
+        # building .dylib requires additional compiler flags on OSX; here we
+        # temporarily substitute the pyconfig.h variables so that distutils'
+        # 'customize_compiler' uses them before we build the shared libraries.
+        tmp = _CONFIG_VARS.copy()
+        try:
+            # XXX Help!  I don't have any idea whether these are right...
+            _CONFIG_VARS['LDSHARED'] = (
+                "gcc -Wl,-x -dynamiclib -undefined dynamic_lookup"
+            )
+            _CONFIG_VARS['CCSHARED'] = " -dynamiclib"
+            _CONFIG_VARS['SO'] = ".dylib"
+            customize_compiler(compiler)
+        finally:
+            _CONFIG_VARS.clear()
+            _CONFIG_VARS.update(tmp)
+    else:
+        customize_compiler(compiler)
+
+
+have_rtld = False
+use_stubs = False
+libtype = 'shared'
+
+if sys.platform == "darwin":
+    use_stubs = True
+elif os.name != 'nt':
+    try:
+        import dl  # type: ignore[import-not-found] # https://github.com/python/mypy/issues/13002
+
+        use_stubs = have_rtld = hasattr(dl, 'RTLD_NOW')
+    except ImportError:
+        pass
+
+
+def get_abi3_suffix():
+    """Return the file extension for an abi3-compliant Extension()"""
+    for suffix in EXTENSION_SUFFIXES:
+        if '.abi3' in suffix:  # Unix
+            return suffix
+        elif suffix == '.pyd':  # Windows
+            return suffix
+    return None
+
+
+class build_ext(_build_ext):
+    distribution: Distribution  # override distutils.dist.Distribution with setuptools.dist.Distribution
+    editable_mode = False
+    inplace = False
+
+    def run(self) -> None:
+        """Build extensions in build directory, then copy if --inplace"""
+        old_inplace, self.inplace = self.inplace, False
+        _build_ext.run(self)
+        self.inplace = old_inplace
+        if old_inplace:
+            self.copy_extensions_to_source()
+
+    def _get_inplace_equivalent(self, build_py, ext: Extension) -> tuple[str, str]:
+        fullname = self.get_ext_fullname(ext.name)
+        filename = self.get_ext_filename(fullname)
+        modpath = fullname.split('.')
+        package = '.'.join(modpath[:-1])
+        package_dir = build_py.get_package_dir(package)
+        inplace_file = os.path.join(package_dir, os.path.basename(filename))
+        regular_file = os.path.join(self.build_lib, filename)
+        return (inplace_file, regular_file)
+
+    def copy_extensions_to_source(self) -> None:
+        build_py = self.get_finalized_command('build_py')
+        for ext in self.extensions:
+            inplace_file, regular_file = self._get_inplace_equivalent(build_py, ext)
+
+            # Always copy, even if source is older than destination, to ensure
+            # that the right extensions for the current Python/platform are
+            # used.
+            if os.path.exists(regular_file) or not ext.optional:
+                self.copy_file(regular_file, inplace_file, level=self.verbose)
+
+            if ext._needs_stub:
+                inplace_stub = self._get_equivalent_stub(ext, inplace_file)
+                self._write_stub_file(inplace_stub, ext, compile=True)
+                # Always compile stub and remove the original (leave the cache behind)
+                # (this behaviour was observed in previous iterations of the code)
+
+    def _get_equivalent_stub(self, ext: Extension, output_file: str) -> str:
+        dir_ = os.path.dirname(output_file)
+        _, _, name = ext.name.rpartition(".")
+        return f"{os.path.join(dir_, name)}.py"
+
+    def _get_output_mapping(self) -> Iterator[tuple[str, str]]:
+        if not self.inplace:
+            return
+
+        build_py = self.get_finalized_command('build_py')
+        opt = self.get_finalized_command('install_lib').optimize or ""
+
+        for ext in self.extensions:
+            inplace_file, regular_file = self._get_inplace_equivalent(build_py, ext)
+            yield (regular_file, inplace_file)
+
+            if ext._needs_stub:
+                # This version of `build_ext` always builds artifacts in another dir,
+                # when "inplace=True" is given it just copies them back.
+                # This is done in the `copy_extensions_to_source` function, which
+                # always compile stub files via `_compile_and_remove_stub`.
+                # At the end of the process, a `.pyc` stub file is created without the
+                # corresponding `.py`.
+
+                inplace_stub = self._get_equivalent_stub(ext, inplace_file)
+                regular_stub = self._get_equivalent_stub(ext, regular_file)
+                inplace_cache = _compiled_file_name(inplace_stub, optimization=opt)
+                output_cache = _compiled_file_name(regular_stub, optimization=opt)
+                yield (output_cache, inplace_cache)
+
+    def get_ext_filename(self, fullname: str) -> str:
+        so_ext = os.getenv('SETUPTOOLS_EXT_SUFFIX')
+        if so_ext:
+            filename = os.path.join(*fullname.split('.')) + so_ext
+        else:
+            filename = _build_ext.get_ext_filename(self, fullname)
+            ext_suffix = get_config_var('EXT_SUFFIX')
+            if not isinstance(ext_suffix, str):
+                raise OSError(
+                    "Configuration variable EXT_SUFFIX not found for this platform "
+                    "and environment variable SETUPTOOLS_EXT_SUFFIX is missing"
+                )
+            so_ext = ext_suffix
+
+        if fullname in self.ext_map:
+            ext = self.ext_map[fullname]
+            abi3_suffix = get_abi3_suffix()
+            if ext.py_limited_api and abi3_suffix:  # Use abi3
+                filename = filename[: -len(so_ext)] + abi3_suffix
+            if isinstance(ext, Library):
+                fn, ext = os.path.splitext(filename)
+                return self.shlib_compiler.library_filename(fn, libtype)
+            elif use_stubs and ext._links_to_dynamic:
+                d, fn = os.path.split(filename)
+                return os.path.join(d, 'dl-' + fn)
+        return filename
+
+    def initialize_options(self):
+        _build_ext.initialize_options(self)
+        self.shlib_compiler = None
+        self.shlibs = []
+        self.ext_map = {}
+        self.editable_mode = False
+
+    def finalize_options(self) -> None:
+        _build_ext.finalize_options(self)
+        self.extensions = self.extensions or []
+        self.check_extensions_list(self.extensions)
+        self.shlibs = [ext for ext in self.extensions if isinstance(ext, Library)]
+        if self.shlibs:
+            self.setup_shlib_compiler()
+        for ext in self.extensions:
+            ext._full_name = self.get_ext_fullname(ext.name)
+        for ext in self.extensions:
+            fullname = ext._full_name
+            self.ext_map[fullname] = ext
+
+            # distutils 3.1 will also ask for module names
+            # XXX what to do with conflicts?
+            self.ext_map[fullname.split('.')[-1]] = ext
+
+            ltd = self.shlibs and self.links_to_dynamic(ext) or False
+            ns = ltd and use_stubs and not isinstance(ext, Library)
+            ext._links_to_dynamic = ltd
+            ext._needs_stub = ns
+            filename = ext._file_name = self.get_ext_filename(fullname)
+            libdir = os.path.dirname(os.path.join(self.build_lib, filename))
+            if ltd and libdir not in ext.library_dirs:
+                ext.library_dirs.append(libdir)
+            if ltd and use_stubs and os.curdir not in ext.runtime_library_dirs:
+                ext.runtime_library_dirs.append(os.curdir)
+
+        if self.editable_mode:
+            self.inplace = True
+
+    def setup_shlib_compiler(self) -> None:
+        compiler = self.shlib_compiler = new_compiler(
+            compiler=self.compiler, force=self.force
+        )
+        _customize_compiler_for_shlib(compiler)
+
+        if self.include_dirs is not None:
+            compiler.set_include_dirs(self.include_dirs)
+        if self.define is not None:
+            # 'define' option is a list of (name,value) tuples
+            for name, value in self.define:
+                compiler.define_macro(name, value)
+        if self.undef is not None:
+            for macro in self.undef:
+                compiler.undefine_macro(macro)
+        if self.libraries is not None:
+            compiler.set_libraries(self.libraries)
+        if self.library_dirs is not None:
+            compiler.set_library_dirs(self.library_dirs)
+        if self.rpath is not None:
+            compiler.set_runtime_library_dirs(self.rpath)
+        if self.link_objects is not None:
+            compiler.set_link_objects(self.link_objects)
+
+        # hack so distutils' build_extension() builds a library instead
+        compiler.link_shared_object = link_shared_object.__get__(compiler)  # type: ignore[method-assign]
+
+    def get_export_symbols(self, ext):
+        if isinstance(ext, Library):
+            return ext.export_symbols
+        return _build_ext.get_export_symbols(self, ext)
+
+    def build_extension(self, ext) -> None:
+        ext._convert_pyx_sources_to_lang()
+        _compiler = self.compiler
+        try:
+            if isinstance(ext, Library):
+                self.compiler = self.shlib_compiler
+            _build_ext.build_extension(self, ext)
+            if ext._needs_stub:
+                build_lib = self.get_finalized_command('build_py').build_lib
+                self.write_stub(build_lib, ext)
+        finally:
+            self.compiler = _compiler
+
+    def links_to_dynamic(self, ext):
+        """Return true if 'ext' links to a dynamic lib in the same package"""
+        # XXX this should check to ensure the lib is actually being built
+        # XXX as dynamic, and not just using a locally-found version or a
+        # XXX static-compiled version
+        libnames = dict.fromkeys([lib._full_name for lib in self.shlibs])
+        pkg = '.'.join(ext._full_name.split('.')[:-1] + [''])
+        return any(pkg + libname in libnames for libname in ext.libraries)
+
+    def get_source_files(self) -> list[str]:
+        return [*_build_ext.get_source_files(self), *self._get_internal_depends()]
+
+    def _get_internal_depends(self) -> Iterator[str]:
+        """Yield ``ext.depends`` that are contained by the project directory"""
+        project_root = Path(self.distribution.src_root or os.curdir).resolve()
+        depends = (dep for ext in self.extensions for dep in ext.depends)
+
+        def skip(orig_path: str, reason: str) -> None:
+            log.info(
+                "dependency %s won't be automatically "
+                "included in the manifest: the path %s",
+                orig_path,
+                reason,
+            )
+
+        for dep in depends:
+            path = Path(dep)
+
+            if path.is_absolute():
+                skip(dep, "must be relative")
+                continue
+
+            if ".." in path.parts:
+                skip(dep, "can't have `..` segments")
+                continue
+
+            try:
+                resolved = (project_root / path).resolve(strict=True)
+            except OSError:
+                skip(dep, "doesn't exist")
+                continue
+
+            try:
+                resolved.relative_to(project_root)
+            except ValueError:
+                skip(dep, "must be inside the project root")
+                continue
+
+            yield path.as_posix()
+
+    def get_outputs(self) -> list[str]:
+        if self.inplace:
+            return list(self.get_output_mapping().keys())
+        return sorted(_build_ext.get_outputs(self) + self.__get_stubs_outputs())
+
+    def get_output_mapping(self) -> dict[str, str]:
+        """See :class:`setuptools.commands.build.SubCommand`"""
+        mapping = self._get_output_mapping()
+        return dict(sorted(mapping, key=operator.itemgetter(0)))
+
+    def __get_stubs_outputs(self):
+        # assemble the base name for each extension that needs a stub
+        ns_ext_bases = (
+            os.path.join(self.build_lib, *ext._full_name.split('.'))
+            for ext in self.extensions
+            if ext._needs_stub
+        )
+        # pair each base with the extension
+        pairs = itertools.product(ns_ext_bases, self.__get_output_extensions())
+        return list(base + fnext for base, fnext in pairs)
+
+    def __get_output_extensions(self):
+        yield '.py'
+        yield '.pyc'
+        if self.get_finalized_command('build_py').optimize:
+            yield '.pyo'
+
+    def write_stub(self, output_dir, ext, compile=False) -> None:
+        stub_file = os.path.join(output_dir, *ext._full_name.split('.')) + '.py'
+        self._write_stub_file(stub_file, ext, compile)
+
+    def _write_stub_file(self, stub_file: str, ext: Extension, compile=False):
+        log.info("writing stub loader for %s to %s", ext._full_name, stub_file)
+        if compile and os.path.exists(stub_file):
+            raise BaseError(stub_file + " already exists! Please delete.")
+        with open(stub_file, 'w', encoding="utf-8") as f:
+            content = (
+                textwrap
+                .dedent(f"""
+                def __bootstrap__():
+                   global __bootstrap__, __file__, __loader__
+                   import sys, os, importlib.resources as irs, importlib.util
+                #rtld   import dl
+                   with irs.files(__name__).joinpath(
+                     {os.path.basename(ext._file_name)!r}) as __file__:
+                      del __bootstrap__
+                      if '__loader__' in globals():
+                          del __loader__
+                #rtld      old_flags = sys.getdlopenflags()
+                      old_dir = os.getcwd()
+                      try:
+                        os.chdir(os.path.dirname(__file__))
+                #rtld        sys.setdlopenflags(dl.RTLD_NOW)
+                        spec = importlib.util.spec_from_file_location(
+                                   __name__, __file__)
+                        mod = importlib.util.module_from_spec(spec)
+                        spec.loader.exec_module(mod)
+                      finally:
+                #rtld        sys.setdlopenflags(old_flags)
+                        os.chdir(old_dir)
+                __bootstrap__()
+                """)
+                .lstrip()
+                .replace('#rtld', '#rtld' * (not have_rtld))
+            )
+            f.write(content)
+        if compile:
+            self._compile_and_remove_stub(stub_file)
+
+    def _compile_and_remove_stub(self, stub_file: str):
+        from distutils.util import byte_compile
+
+        byte_compile([stub_file], optimize=0, force=True)
+        optimize = self.get_finalized_command('install_lib').optimize
+        if optimize > 0:
+            byte_compile(
+                [stub_file],
+                optimize=optimize,
+                force=True,
+            )
+        if os.path.exists(stub_file):
+            os.unlink(stub_file)
+
+
+if use_stubs or os.name == 'nt':
+    # Build shared libraries
+    #
+    def link_shared_object(
+        self,
+        objects,
+        output_libname,
+        output_dir=None,
+        libraries=None,
+        library_dirs=None,
+        runtime_library_dirs=None,
+        export_symbols=None,
+        debug: bool = False,
+        extra_preargs=None,
+        extra_postargs=None,
+        build_temp=None,
+        target_lang=None,
+    ) -> None:
+        self.link(
+            self.SHARED_LIBRARY,
+            objects,
+            output_libname,
+            output_dir,
+            libraries,
+            library_dirs,
+            runtime_library_dirs,
+            export_symbols,
+            debug,
+            extra_preargs,
+            extra_postargs,
+            build_temp,
+            target_lang,
+        )
+
+else:
+    # Build static libraries everywhere else
+    libtype = 'static'
+
+    def link_shared_object(
+        self,
+        objects,
+        output_libname,
+        output_dir=None,
+        libraries=None,
+        library_dirs=None,
+        runtime_library_dirs=None,
+        export_symbols=None,
+        debug: bool = False,
+        extra_preargs=None,
+        extra_postargs=None,
+        build_temp=None,
+        target_lang=None,
+    ) -> None:
+        # XXX we need to either disallow these attrs on Library instances,
+        # or warn/abort here if set, or something...
+        # libraries=None, library_dirs=None, runtime_library_dirs=None,
+        # export_symbols=None, extra_preargs=None, extra_postargs=None,
+        # build_temp=None
+
+        assert output_dir is None  # distutils build_ext doesn't pass this
+        output_dir, filename = os.path.split(output_libname)
+        basename, _ext = os.path.splitext(filename)
+        if self.library_filename("x").startswith('lib'):
+            # strip 'lib' prefix; this is kludgy if some platform uses
+            # a different prefix
+            basename = basename[3:]
+
+        self.create_static_lib(objects, basename, output_dir, debug, target_lang)
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/build_py.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/build_py.py
new file mode 100644
index 0000000000000000000000000000000000000000..3c7c2d1bd6ac84dfaf82a0906d34cb30f69b9dc3
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/build_py.py
@@ -0,0 +1,403 @@
+from __future__ import annotations
+
+import fnmatch
+import itertools
+import operator
+import os
+import stat
+import textwrap
+from collections.abc import Iterable, Iterator
+from functools import partial
+from glob import glob
+from pathlib import Path
+from typing import Any
+
+from more_itertools import unique_everseen
+
+from .._path import StrPath, StrPathT
+from ..dist import Distribution
+from ..warnings import SetuptoolsDeprecationWarning
+
+import distutils.command.build_py as orig
+import distutils.errors
+from distutils.util import convert_path
+
+_IMPLICIT_DATA_FILES = ('*.pyi', 'py.typed')
+
+
+def make_writable(target) -> None:
+    os.chmod(target, os.stat(target).st_mode | stat.S_IWRITE)
+
+
+class build_py(orig.build_py):
+    """Enhanced 'build_py' command that includes data files with packages
+
+    The data files are specified via a 'package_data' argument to 'setup()'.
+    See 'setuptools.dist.Distribution' for more details.
+
+    Also, this version of the 'build_py' command allows you to specify both
+    'py_modules' and 'packages' in the same setup operation.
+    """
+
+    distribution: Distribution  # override distutils.dist.Distribution with setuptools.dist.Distribution
+    editable_mode: bool = False
+    existing_egg_info_dir: StrPath | None = None  #: Private API, internal use only.
+
+    def finalize_options(self) -> None:
+        orig.build_py.finalize_options(self)
+        self.package_data = self.distribution.package_data
+        self.exclude_package_data = self.distribution.exclude_package_data or {}
+        if 'data_files' in self.__dict__:
+            del self.__dict__['data_files']
+
+    def copy_file(  # type: ignore[override] # No overload, no bytes support
+        self,
+        infile: StrPath,
+        outfile: StrPathT,
+        preserve_mode: bool = True,
+        preserve_times: bool = True,
+        link: str | None = None,
+        level: object = 1,
+    ) -> tuple[StrPathT | str, bool]:
+        # Overwrite base class to allow using links
+        if link:
+            infile = str(Path(infile).resolve())
+            outfile = str(Path(outfile).resolve())  # type: ignore[assignment] # Re-assigning a str when outfile is StrPath is ok
+        return super().copy_file(  # pyright: ignore[reportReturnType] # pypa/distutils#309
+            infile, outfile, preserve_mode, preserve_times, link, level
+        )
+
+    def run(self) -> None:
+        """Build modules, packages, and copy data files to build directory"""
+        if not (self.py_modules or self.packages) or self.editable_mode:
+            return
+
+        if self.py_modules:
+            self.build_modules()
+
+        if self.packages:
+            self.build_packages()
+            self.build_package_data()
+
+        # Only compile actual .py files, using our base class' idea of what our
+        # output files are.
+        self.byte_compile(orig.build_py.get_outputs(self, include_bytecode=False))
+
+    # Should return "list[tuple[str, str, str, list[str]]] | Any" but can't do without typed distutils on Python 3.12+
+    def __getattr__(self, attr: str) -> Any:
+        "lazily compute data files"
+        if attr == 'data_files':
+            self.data_files = self._get_data_files()
+            return self.data_files
+        return orig.build_py.__getattr__(self, attr)
+
+    def _get_data_files(self):
+        """Generate list of '(package,src_dir,build_dir,filenames)' tuples"""
+        self.analyze_manifest()
+        return list(map(self._get_pkg_data_files, self.packages or ()))
+
+    def get_data_files_without_manifest(self) -> list[tuple[str, str, str, list[str]]]:
+        """
+        Generate list of ``(package,src_dir,build_dir,filenames)`` tuples,
+        but without triggering any attempt to analyze or build the manifest.
+        """
+        # Prevent eventual errors from unset `manifest_files`
+        # (that would otherwise be set by `analyze_manifest`)
+        self.__dict__.setdefault('manifest_files', {})
+        return list(map(self._get_pkg_data_files, self.packages or ()))
+
+    def _get_pkg_data_files(self, package: str) -> tuple[str, str, str, list[str]]:
+        # Locate package source directory
+        src_dir = self.get_package_dir(package)
+
+        # Compute package build directory
+        build_dir = os.path.join(*([self.build_lib] + package.split('.')))
+
+        # Strip directory from globbed filenames
+        filenames = [
+            os.path.relpath(file, src_dir)
+            for file in self.find_data_files(package, src_dir)
+        ]
+        return package, src_dir, build_dir, filenames
+
+    def find_data_files(self, package, src_dir):
+        """Return filenames for package's data files in 'src_dir'"""
+        patterns = self._get_platform_patterns(
+            self.package_data,
+            package,
+            src_dir,
+            extra_patterns=_IMPLICIT_DATA_FILES,
+        )
+        globs_expanded = map(partial(glob, recursive=True), patterns)
+        # flatten the expanded globs into an iterable of matches
+        globs_matches = itertools.chain.from_iterable(globs_expanded)
+        glob_files = filter(os.path.isfile, globs_matches)
+        files = itertools.chain(
+            self.manifest_files.get(package, []),
+            glob_files,
+        )
+        return self.exclude_data_files(package, src_dir, files)
+
+    def get_outputs(self, include_bytecode: bool = True) -> list[str]:  # type: ignore[override] # Using a real boolean instead of 0|1
+        """See :class:`setuptools.commands.build.SubCommand`"""
+        if self.editable_mode:
+            return list(self.get_output_mapping().keys())
+        return super().get_outputs(include_bytecode)
+
+    def get_output_mapping(self) -> dict[str, str]:
+        """See :class:`setuptools.commands.build.SubCommand`"""
+        mapping = itertools.chain(
+            self._get_package_data_output_mapping(),
+            self._get_module_mapping(),
+        )
+        return dict(sorted(mapping, key=operator.itemgetter(0)))
+
+    def _get_module_mapping(self) -> Iterator[tuple[str, str]]:
+        """Iterate over all modules producing (dest, src) pairs."""
+        for package, module, module_file in self.find_all_modules():
+            package = package.split('.')
+            filename = self.get_module_outfile(self.build_lib, package, module)
+            yield (filename, module_file)
+
+    def _get_package_data_output_mapping(self) -> Iterator[tuple[str, str]]:
+        """Iterate over package data producing (dest, src) pairs."""
+        for package, src_dir, build_dir, filenames in self.data_files:
+            for filename in filenames:
+                target = os.path.join(build_dir, filename)
+                srcfile = os.path.join(src_dir, filename)
+                yield (target, srcfile)
+
+    def build_package_data(self) -> None:
+        """Copy data files into build directory"""
+        for target, srcfile in self._get_package_data_output_mapping():
+            self.mkpath(os.path.dirname(target))
+            _outf, _copied = self.copy_file(srcfile, target)
+            make_writable(target)
+
+    def analyze_manifest(self) -> None:
+        self.manifest_files: dict[str, list[str]] = {}
+        if not self.distribution.include_package_data:
+            return
+        src_dirs: dict[str, str] = {}
+        for package in self.packages or ():
+            # Locate package source directory
+            src_dirs[assert_relative(self.get_package_dir(package))] = package
+
+        if (
+            self.existing_egg_info_dir
+            and Path(self.existing_egg_info_dir, "SOURCES.txt").exists()
+        ):
+            egg_info_dir = self.existing_egg_info_dir
+            manifest = Path(egg_info_dir, "SOURCES.txt")
+            files = manifest.read_text(encoding="utf-8").splitlines()
+        else:
+            self.run_command('egg_info')
+            ei_cmd = self.get_finalized_command('egg_info')
+            egg_info_dir = ei_cmd.egg_info
+            files = ei_cmd.filelist.files
+
+        check = _IncludePackageDataAbuse()
+        for path in self._filter_build_files(files, egg_info_dir):
+            d, f = os.path.split(assert_relative(path))
+            prev = None
+            oldf = f
+            while d and d != prev and d not in src_dirs:
+                prev = d
+                d, df = os.path.split(d)
+                f = os.path.join(df, f)
+            if d in src_dirs:
+                if f == oldf:
+                    if check.is_module(f):
+                        continue  # it's a module, not data
+                else:
+                    importable = check.importable_subpackage(src_dirs[d], f)
+                    if importable:
+                        check.warn(importable)
+                self.manifest_files.setdefault(src_dirs[d], []).append(path)
+
+    def _filter_build_files(
+        self, files: Iterable[str], egg_info: StrPath
+    ) -> Iterator[str]:
+        """
+        ``build_meta`` may try to create egg_info outside of the project directory,
+        and this can be problematic for certain plugins (reported in issue #3500).
+
+        Extensions might also include between their sources files created on the
+        ``build_lib`` and ``build_temp`` directories.
+
+        This function should filter this case of invalid files out.
+        """
+        build = self.get_finalized_command("build")
+        build_dirs = (egg_info, self.build_lib, build.build_temp, build.build_base)
+        norm_dirs = [os.path.normpath(p) for p in build_dirs if p]
+
+        for file in files:
+            norm_path = os.path.normpath(file)
+            if not os.path.isabs(file) or all(d not in norm_path for d in norm_dirs):
+                yield file
+
+    def get_data_files(self) -> None:
+        pass  # Lazily compute data files in _get_data_files() function.
+
+    def check_package(self, package, package_dir):
+        """Check namespace packages' __init__ for declare_namespace"""
+        try:
+            return self.packages_checked[package]
+        except KeyError:
+            pass
+
+        init_py = orig.build_py.check_package(self, package, package_dir)
+        self.packages_checked[package] = init_py
+
+        if not init_py or not self.distribution.namespace_packages:
+            return init_py
+
+        for pkg in self.distribution.namespace_packages:
+            if pkg == package or pkg.startswith(package + '.'):
+                break
+        else:
+            return init_py
+
+        with open(init_py, 'rb') as f:
+            contents = f.read()
+        if b'declare_namespace' not in contents:
+            raise distutils.errors.DistutilsError(
+                f"Namespace package problem: {package} is a namespace package, but "
+                "its\n__init__.py does not call declare_namespace()! Please "
+                'fix it.\n(See the setuptools manual under '
+                '"Namespace Packages" for details.)\n"'
+            )
+        return init_py
+
+    def initialize_options(self):
+        self.packages_checked = {}
+        orig.build_py.initialize_options(self)
+        self.editable_mode = False
+        self.existing_egg_info_dir = None
+
+    def get_package_dir(self, package: str) -> str:
+        res = orig.build_py.get_package_dir(self, package)
+        if self.distribution.src_root is not None:
+            return os.path.join(self.distribution.src_root, res)
+        return res
+
+    def exclude_data_files(self, package, src_dir, files):
+        """Filter filenames for package's data files in 'src_dir'"""
+        files = list(files)
+        patterns = self._get_platform_patterns(
+            self.exclude_package_data,
+            package,
+            src_dir,
+        )
+        match_groups = (fnmatch.filter(files, pattern) for pattern in patterns)
+        # flatten the groups of matches into an iterable of matches
+        matches = itertools.chain.from_iterable(match_groups)
+        bad = set(matches)
+        keepers = (fn for fn in files if fn not in bad)
+        # ditch dupes
+        return list(unique_everseen(keepers))
+
+    @staticmethod
+    def _get_platform_patterns(spec, package, src_dir, extra_patterns=()):
+        """
+        yield platform-specific path patterns (suitable for glob
+        or fn_match) from a glob-based spec (such as
+        self.package_data or self.exclude_package_data)
+        matching package in src_dir.
+        """
+        raw_patterns = itertools.chain(
+            extra_patterns,
+            spec.get('', []),
+            spec.get(package, []),
+        )
+        return (
+            # Each pattern has to be converted to a platform-specific path
+            os.path.join(src_dir, convert_path(pattern))
+            for pattern in raw_patterns
+        )
+
+
+def assert_relative(path):
+    if not os.path.isabs(path):
+        return path
+    from distutils.errors import DistutilsSetupError
+
+    msg = (
+        textwrap.dedent(
+            """
+        Error: setup script specifies an absolute path:
+
+            %s
+
+        setup() arguments must *always* be /-separated paths relative to the
+        setup.py directory, *never* absolute paths.
+        """
+        ).lstrip()
+        % path
+    )
+    raise DistutilsSetupError(msg)
+
+
+class _IncludePackageDataAbuse:
+    """Inform users that package or module is included as 'data file'"""
+
+    class _Warning(SetuptoolsDeprecationWarning):
+        _SUMMARY = """
+        Package {importable!r} is absent from the `packages` configuration.
+        """
+
+        _DETAILS = """
+        ############################
+        # Package would be ignored #
+        ############################
+        Python recognizes {importable!r} as an importable package[^1],
+        but it is absent from setuptools' `packages` configuration.
+
+        This leads to an ambiguous overall configuration. If you want to distribute this
+        package, please make sure that {importable!r} is explicitly added
+        to the `packages` configuration field.
+
+        Alternatively, you can also rely on setuptools' discovery methods
+        (for example by using `find_namespace_packages(...)`/`find_namespace:`
+        instead of `find_packages(...)`/`find:`).
+
+        You can read more about "package discovery" on setuptools documentation page:
+
+        - https://setuptools.pypa.io/en/latest/userguide/package_discovery.html
+
+        If you don't want {importable!r} to be distributed and are
+        already explicitly excluding {importable!r} via
+        `find_namespace_packages(...)/find_namespace` or `find_packages(...)/find`,
+        you can try to use `exclude_package_data`, or `include-package-data=False` in
+        combination with a more fine grained `package-data` configuration.
+
+        You can read more about "package data files" on setuptools documentation page:
+
+        - https://setuptools.pypa.io/en/latest/userguide/datafiles.html
+
+
+        [^1]: For Python, any directory (with suitable naming) can be imported,
+              even if it does not contain any `.py` files.
+              On the other hand, currently there is no concept of package data
+              directory, all directories are treated like packages.
+        """
+        # _DUE_DATE: still not defined as this is particularly controversial.
+        # Warning initially introduced in May 2022. See issue #3340 for discussion.
+
+    def __init__(self) -> None:
+        self._already_warned = set[str]()
+
+    def is_module(self, file):
+        return file.endswith(".py") and file[: -len(".py")].isidentifier()
+
+    def importable_subpackage(self, parent, file):
+        pkg = Path(file).parent
+        parts = list(itertools.takewhile(str.isidentifier, pkg.parts))
+        if parts:
+            return ".".join([parent, *parts])
+        return None
+
+    def warn(self, importable):
+        if importable not in self._already_warned:
+            self._Warning.emit(importable=importable)
+            self._already_warned.add(importable)
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/develop.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/develop.py
new file mode 100644
index 0000000000000000000000000000000000000000..2d468845e5d802a1c2891f6ed31d43c0fed26ec2
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/develop.py
@@ -0,0 +1,58 @@
+import site
+import subprocess
+import sys
+from typing import cast
+
+from setuptools import Command
+from setuptools.warnings import SetuptoolsDeprecationWarning
+
+
+class develop(Command):
+    """Set up package for development"""
+
+    user_options = [
+        ("install-dir=", "d", "install package to DIR"),
+        ('no-deps', 'N', "don't install dependencies"),
+        ('user', None, f"install in user site-package '{site.USER_SITE}'"),
+        ('prefix=', None, "installation prefix"),
+        ("index-url=", "i", "base URL of Python Package Index"),
+    ]
+    boolean_options = [
+        'no-deps',
+        'user',
+    ]
+
+    install_dir = None
+    no_deps = False
+    user = False
+    prefix = None
+    index_url = None
+
+    def run(self) -> None:
+        # Casting because mypy doesn't understand bool mult conditionals
+        cmd = cast(
+            list[str],
+            [sys.executable, '-m', 'pip', 'install', '-e', '.', '--use-pep517']
+            + ['--target', self.install_dir] * bool(self.install_dir)
+            + ['--no-deps'] * self.no_deps
+            + ['--user'] * self.user
+            + ['--prefix', self.prefix] * bool(self.prefix)
+            + ['--index-url', self.index_url] * bool(self.index_url),
+        )
+        subprocess.check_call(cmd)
+
+    def initialize_options(self) -> None:
+        DevelopDeprecationWarning.emit()
+
+    def finalize_options(self) -> None:
+        pass
+
+
+class DevelopDeprecationWarning(SetuptoolsDeprecationWarning):
+    _SUMMARY = "develop command is deprecated."
+    _DETAILS = """
+    Please avoid running ``setup.py`` and ``develop``.
+    Instead, use standards-based tools like pip or uv.
+    """
+    _SEE_URL = "https://github.com/pypa/setuptools/issues/917"
+    _DUE_DATE = 2025, 10, 31
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/dist_info.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/dist_info.py
new file mode 100644
index 0000000000000000000000000000000000000000..dca01ff0ce355dfd375512e4a06b05b909ee41b6
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/dist_info.py
@@ -0,0 +1,103 @@
+"""
+Create a dist_info directory
+As defined in the wheel specification
+"""
+
+import os
+import shutil
+from contextlib import contextmanager
+from pathlib import Path
+from typing import cast
+
+from .. import _normalization
+from .._shutil import rmdir as _rm
+from .egg_info import egg_info as egg_info_cls
+
+from distutils import log
+from distutils.core import Command
+
+
+class dist_info(Command):
+    """
+    This command is private and reserved for internal use of setuptools,
+    users should rely on ``setuptools.build_meta`` APIs.
+    """
+
+    description = "DO NOT CALL DIRECTLY, INTERNAL ONLY: create .dist-info directory"
+
+    user_options = [
+        (
+            'output-dir=',
+            'o',
+            "directory inside of which the .dist-info will be"
+            "created [default: top of the source tree]",
+        ),
+        ('tag-date', 'd', "Add date stamp (e.g. 20050528) to version number"),
+        ('tag-build=', 'b', "Specify explicit tag to add to version number"),
+        ('no-date', 'D', "Don't include date stamp [default]"),
+        ('keep-egg-info', None, "*TRANSITIONAL* will be removed in the future"),
+    ]
+
+    boolean_options = ['tag-date', 'keep-egg-info']
+    negative_opt = {'no-date': 'tag-date'}
+
+    def initialize_options(self):
+        self.output_dir = None
+        self.name = None
+        self.dist_info_dir = None
+        self.tag_date = None
+        self.tag_build = None
+        self.keep_egg_info = False
+
+    def finalize_options(self) -> None:
+        dist = self.distribution
+        project_dir = dist.src_root or os.curdir
+        self.output_dir = Path(self.output_dir or project_dir)
+
+        egg_info = cast(egg_info_cls, self.reinitialize_command("egg_info"))
+        egg_info.egg_base = str(self.output_dir)
+
+        if self.tag_date:
+            egg_info.tag_date = self.tag_date
+        else:
+            self.tag_date = egg_info.tag_date
+
+        if self.tag_build:
+            egg_info.tag_build = self.tag_build
+        else:
+            self.tag_build = egg_info.tag_build
+
+        egg_info.finalize_options()
+        self.egg_info = egg_info
+
+        name = _normalization.safer_name(dist.get_name())
+        version = _normalization.safer_best_effort_version(dist.get_version())
+        self.name = f"{name}-{version}"
+        self.dist_info_dir = os.path.join(self.output_dir, f"{self.name}.dist-info")
+
+    @contextmanager
+    def _maybe_bkp_dir(self, dir_path: str, requires_bkp: bool):
+        if requires_bkp:
+            bkp_name = f"{dir_path}.__bkp__"
+            _rm(bkp_name, ignore_errors=True)
+            shutil.copytree(dir_path, bkp_name, dirs_exist_ok=True, symlinks=True)
+            try:
+                yield
+            finally:
+                _rm(dir_path, ignore_errors=True)
+                shutil.move(bkp_name, dir_path)
+        else:
+            yield
+
+    def run(self) -> None:
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        self.egg_info.run()
+        egg_info_dir = self.egg_info.egg_info
+        assert os.path.isdir(egg_info_dir), ".egg-info dir should have been created"
+
+        log.info(f"creating '{os.path.abspath(self.dist_info_dir)}'")
+        bdist_wheel = self.get_finalized_command('bdist_wheel')
+
+        # TODO: if bdist_wheel if merged into setuptools, just add "keep_egg_info" there
+        with self._maybe_bkp_dir(egg_info_dir, self.keep_egg_info):
+            bdist_wheel.egg2dist(egg_info_dir, self.dist_info_dir)
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/easy_install.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/easy_install.py
new file mode 100644
index 0000000000000000000000000000000000000000..8765793d4cdec9e47982f4817e56cb32323c21b9
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/easy_install.py
@@ -0,0 +1,30 @@
+import os
+import sys
+import types
+
+from setuptools import Command
+
+from .. import _scripts, warnings
+
+
+class easy_install(Command):
+    """Stubbed command for temporary pbr compatibility."""
+
+
+def __getattr__(name):
+    attr = getattr(
+        types.SimpleNamespace(
+            ScriptWriter=_scripts.ScriptWriter,
+            sys_executable=os.environ.get(
+                "__PYVENV_LAUNCHER__", os.path.normpath(sys.executable)
+            ),
+        ),
+        name,
+    )
+    warnings.SetuptoolsDeprecationWarning.emit(
+        summary="easy_install module is deprecated",
+        details="Avoid accessing attributes of setuptools.command.easy_install.",
+        due_date=(2025, 10, 31),
+        see_url="https://github.com/pypa/setuptools/issues/4976",
+    )
+    return attr
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/editable_wheel.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/editable_wheel.py
new file mode 100644
index 0000000000000000000000000000000000000000..6f44f1364349c55d0dd808127bc3131ff1e69788
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/editable_wheel.py
@@ -0,0 +1,914 @@
+"""
+Create a wheel that, when installed, will make the source package 'editable'
+(add it to the interpreter's path, including metadata) per PEP 660. Replaces
+'setup.py develop'.
+
+.. note::
+   One of the mechanisms briefly mentioned in PEP 660 to implement editable installs is
+   to create a separated directory inside ``build`` and use a .pth file to point to that
+   directory. In the context of this file such directory is referred as
+   *auxiliary build directory* or ``auxiliary_dir``.
+"""
+
+from __future__ import annotations
+
+import io
+import logging
+import operator
+import os
+import shutil
+import traceback
+from collections.abc import Iterable, Iterator, Mapping
+from contextlib import suppress
+from enum import Enum
+from inspect import cleandoc
+from itertools import chain, starmap
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from types import TracebackType
+from typing import TYPE_CHECKING, Protocol, TypeVar, cast
+
+from .. import Command, _normalization, _path, _shutil, errors, namespaces
+from .._path import StrPath
+from ..compat import py310, py312
+from ..discovery import find_package_path
+from ..dist import Distribution
+from ..warnings import InformationOnly, SetuptoolsDeprecationWarning
+from .build import build as build_cls
+from .build_py import build_py as build_py_cls
+from .dist_info import dist_info as dist_info_cls
+from .egg_info import egg_info as egg_info_cls
+from .install import install as install_cls
+from .install_scripts import install_scripts as install_scripts_cls
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+    from .._vendor.wheel.wheelfile import WheelFile
+
+_P = TypeVar("_P", bound=StrPath)
+_logger = logging.getLogger(__name__)
+
+
+class _EditableMode(Enum):
+    """
+    Possible editable installation modes:
+    `lenient` (new files automatically added to the package - DEFAULT);
+    `strict` (requires a new installation when files are added/removed); or
+    `compat` (attempts to emulate `python setup.py develop` - DEPRECATED).
+    """
+
+    STRICT = "strict"
+    LENIENT = "lenient"
+    COMPAT = "compat"  # TODO: Remove `compat` after Dec/2022.
+
+    @classmethod
+    def convert(cls, mode: str | None) -> _EditableMode:
+        if not mode:
+            return _EditableMode.LENIENT  # default
+
+        _mode = mode.upper()
+        if _mode not in _EditableMode.__members__:
+            raise errors.OptionError(f"Invalid editable mode: {mode!r}. Try: 'strict'.")
+
+        if _mode == "COMPAT":
+            SetuptoolsDeprecationWarning.emit(
+                "Compat editable installs",
+                """
+                The 'compat' editable mode is transitional and will be removed
+                in future versions of `setuptools`.
+                Please adapt your code accordingly to use either the 'strict' or the
+                'lenient' modes.
+                """,
+                see_docs="userguide/development_mode.html",
+                # TODO: define due_date
+                # There is a series of shortcomings with the available editable install
+                # methods, and they are very controversial. This is something that still
+                # needs work.
+                # Moreover, `pip` is still hiding this warning, so users are not aware.
+            )
+
+        return _EditableMode[_mode]
+
+
+_STRICT_WARNING = """
+New or renamed files may not be automatically picked up without a new installation.
+"""
+
+_LENIENT_WARNING = """
+Options like `package-data`, `include/exclude-package-data` or
+`packages.find.exclude/include` may have no effect.
+"""
+
+
+class editable_wheel(Command):
+    """Build 'editable' wheel for development.
+    This command is private and reserved for internal use of setuptools,
+    users should rely on ``setuptools.build_meta`` APIs.
+    """
+
+    description = "DO NOT CALL DIRECTLY, INTERNAL ONLY: create PEP 660 editable wheel"
+
+    user_options = [
+        ("dist-dir=", "d", "directory to put final built distributions in"),
+        ("dist-info-dir=", "I", "path to a pre-build .dist-info directory"),
+        ("mode=", None, cleandoc(_EditableMode.__doc__ or "")),
+    ]
+
+    def initialize_options(self):
+        self.dist_dir = None
+        self.dist_info_dir = None
+        self.project_dir = None
+        self.mode = None
+
+    def finalize_options(self) -> None:
+        dist = self.distribution
+        self.project_dir = dist.src_root or os.curdir
+        self.package_dir = dist.package_dir or {}
+        self.dist_dir = Path(self.dist_dir or os.path.join(self.project_dir, "dist"))
+
+    def run(self) -> None:
+        try:
+            self.dist_dir.mkdir(exist_ok=True)
+            self._ensure_dist_info()
+
+            # Add missing dist_info files
+            self.reinitialize_command("bdist_wheel")
+            bdist_wheel = self.get_finalized_command("bdist_wheel")
+            bdist_wheel.write_wheelfile(self.dist_info_dir)
+
+            self._create_wheel_file(bdist_wheel)
+        except Exception as ex:
+            project = self.distribution.name or self.distribution.get_name()
+            py310.add_note(
+                ex,
+                f"An error occurred when building editable wheel for {project}.\n"
+                "See debugging tips in: "
+                "https://setuptools.pypa.io/en/latest/userguide/development_mode.html#debugging-tips",
+            )
+            raise
+
+    def _ensure_dist_info(self):
+        if self.dist_info_dir is None:
+            dist_info = cast(dist_info_cls, self.reinitialize_command("dist_info"))
+            dist_info.output_dir = self.dist_dir
+            dist_info.ensure_finalized()
+            dist_info.run()
+            self.dist_info_dir = dist_info.dist_info_dir
+        else:
+            assert str(self.dist_info_dir).endswith(".dist-info")
+            assert Path(self.dist_info_dir, "METADATA").exists()
+
+    def _install_namespaces(self, installation_dir, pth_prefix):
+        # XXX: Only required to support the deprecated namespace practice
+        dist = self.distribution
+        if not dist.namespace_packages:
+            return
+
+        src_root = Path(self.project_dir, self.package_dir.get("", ".")).resolve()
+        installer = _NamespaceInstaller(dist, installation_dir, pth_prefix, src_root)
+        installer.install_namespaces()
+
+    def _find_egg_info_dir(self) -> str | None:
+        parent_dir = Path(self.dist_info_dir).parent if self.dist_info_dir else Path()
+        candidates = map(str, parent_dir.glob("*.egg-info"))
+        return next(candidates, None)
+
+    def _configure_build(
+        self, name: str, unpacked_wheel: StrPath, build_lib: StrPath, tmp_dir: StrPath
+    ):
+        """Configure commands to behave in the following ways:
+
+        - Build commands can write to ``build_lib`` if they really want to...
+          (but this folder is expected to be ignored and modules are expected to live
+          in the project directory...)
+        - Binary extensions should be built in-place (editable_mode = True)
+        - Data/header/script files are not part of the "editable" specification
+          so they are written directly to the unpacked_wheel directory.
+        """
+        # Non-editable files (data, headers, scripts) are written directly to the
+        # unpacked_wheel
+
+        dist = self.distribution
+        wheel = str(unpacked_wheel)
+        build_lib = str(build_lib)
+        data = str(Path(unpacked_wheel, f"{name}.data", "data"))
+        headers = str(Path(unpacked_wheel, f"{name}.data", "headers"))
+        scripts = str(Path(unpacked_wheel, f"{name}.data", "scripts"))
+
+        # egg-info may be generated again to create a manifest (used for package data)
+        egg_info = cast(
+            egg_info_cls, dist.reinitialize_command("egg_info", reinit_subcommands=True)
+        )
+        egg_info.egg_base = str(tmp_dir)
+        egg_info.ignore_egg_info_in_manifest = True
+
+        build = cast(
+            build_cls, dist.reinitialize_command("build", reinit_subcommands=True)
+        )
+        install = cast(
+            install_cls, dist.reinitialize_command("install", reinit_subcommands=True)
+        )
+
+        build.build_platlib = build.build_purelib = build.build_lib = build_lib
+        install.install_purelib = install.install_platlib = install.install_lib = wheel
+        install.install_scripts = build.build_scripts = scripts
+        install.install_headers = headers
+        install.install_data = data
+
+        # For portability, ensure scripts are built with #!python shebang
+        # pypa/setuptools#4863
+        build_scripts = dist.get_command_obj("build_scripts")
+        build_scripts.executable = 'python'
+
+        install_scripts = cast(
+            install_scripts_cls, dist.get_command_obj("install_scripts")
+        )
+        install_scripts.no_ep = True
+
+        build.build_temp = str(tmp_dir)
+
+        build_py = cast(build_py_cls, dist.get_command_obj("build_py"))
+        build_py.compile = False
+        build_py.existing_egg_info_dir = self._find_egg_info_dir()
+
+        self._set_editable_mode()
+
+        build.ensure_finalized()
+        install.ensure_finalized()
+
+    def _set_editable_mode(self):
+        """Set the ``editable_mode`` flag in the build sub-commands"""
+        dist = self.distribution
+        build = dist.get_command_obj("build")
+        for cmd_name in build.get_sub_commands():
+            cmd = dist.get_command_obj(cmd_name)
+            if hasattr(cmd, "editable_mode"):
+                cmd.editable_mode = True
+            elif hasattr(cmd, "inplace"):
+                cmd.inplace = True  # backward compatibility with distutils
+
+    def _collect_build_outputs(self) -> tuple[list[str], dict[str, str]]:
+        files: list[str] = []
+        mapping: dict[str, str] = {}
+        build = self.get_finalized_command("build")
+
+        for cmd_name in build.get_sub_commands():
+            cmd = self.get_finalized_command(cmd_name)
+            if hasattr(cmd, "get_outputs"):
+                files.extend(cmd.get_outputs() or [])
+            if hasattr(cmd, "get_output_mapping"):
+                mapping.update(cmd.get_output_mapping() or {})
+
+        return files, mapping
+
+    def _run_build_commands(
+        self,
+        dist_name: str,
+        unpacked_wheel: StrPath,
+        build_lib: StrPath,
+        tmp_dir: StrPath,
+    ) -> tuple[list[str], dict[str, str]]:
+        self._configure_build(dist_name, unpacked_wheel, build_lib, tmp_dir)
+        self._run_build_subcommands()
+        files, mapping = self._collect_build_outputs()
+        self._run_install("headers")
+        self._run_install("scripts")
+        self._run_install("data")
+        return files, mapping
+
+    def _run_build_subcommands(self) -> None:
+        """
+        Issue #3501 indicates that some plugins/customizations might rely on:
+
+        1. ``build_py`` not running
+        2. ``build_py`` always copying files to ``build_lib``
+
+        However both these assumptions may be false in editable_wheel.
+        This method implements a temporary workaround to support the ecosystem
+        while the implementations catch up.
+        """
+        # TODO: Once plugins/customizations had the chance to catch up, replace
+        #       `self._run_build_subcommands()` with `self.run_command("build")`.
+        #       Also remove _safely_run, TestCustomBuildPy. Suggested date: Aug/2023.
+        build = self.get_finalized_command("build")
+        for name in build.get_sub_commands():
+            cmd = self.get_finalized_command(name)
+            if name == "build_py" and type(cmd) is not build_py_cls:
+                self._safely_run(name)
+            else:
+                self.run_command(name)
+
+    def _safely_run(self, cmd_name: str):
+        try:
+            return self.run_command(cmd_name)
+        except Exception:
+            SetuptoolsDeprecationWarning.emit(
+                "Customization incompatible with editable install",
+                f"""
+                {traceback.format_exc()}
+
+                If you are seeing this warning it is very likely that a setuptools
+                plugin or customization overrides the `{cmd_name}` command, without
+                taking into consideration how editable installs run build steps
+                starting from setuptools v64.0.0.
+
+                Plugin authors and developers relying on custom build steps are
+                encouraged to update their `{cmd_name}` implementation considering the
+                information about editable installs in
+                https://setuptools.pypa.io/en/latest/userguide/extension.html.
+
+                For the time being `setuptools` will silence this error and ignore
+                the faulty command, but this behavior will change in future versions.
+                """,
+                # TODO: define due_date
+                # There is a series of shortcomings with the available editable install
+                # methods, and they are very controversial. This is something that still
+                # needs work.
+            )
+
+    def _create_wheel_file(self, bdist_wheel):
+        from wheel.wheelfile import WheelFile
+
+        dist_info = self.get_finalized_command("dist_info")
+        dist_name = dist_info.name
+        tag = "-".join(bdist_wheel.get_tag())
+        build_tag = "0.editable"  # According to PEP 427 needs to start with digit
+        archive_name = f"{dist_name}-{build_tag}-{tag}.whl"
+        wheel_path = Path(self.dist_dir, archive_name)
+        if wheel_path.exists():
+            wheel_path.unlink()
+
+        unpacked_wheel = TemporaryDirectory(suffix=archive_name)
+        build_lib = TemporaryDirectory(suffix=".build-lib")
+        build_tmp = TemporaryDirectory(suffix=".build-temp")
+
+        with unpacked_wheel as unpacked, build_lib as lib, build_tmp as tmp:
+            unpacked_dist_info = Path(unpacked, Path(self.dist_info_dir).name)
+            shutil.copytree(self.dist_info_dir, unpacked_dist_info)
+            self._install_namespaces(unpacked, dist_name)
+            files, mapping = self._run_build_commands(dist_name, unpacked, lib, tmp)
+            strategy = self._select_strategy(dist_name, tag, lib)
+            with strategy, WheelFile(wheel_path, "w") as wheel_obj:
+                strategy(wheel_obj, files, mapping)
+                wheel_obj.write_files(unpacked)
+
+        return wheel_path
+
+    def _run_install(self, category: str):
+        has_category = getattr(self.distribution, f"has_{category}", None)
+        if has_category and has_category():
+            _logger.info(f"Installing {category} as non editable")
+            self.run_command(f"install_{category}")
+
+    def _select_strategy(
+        self,
+        name: str,
+        tag: str,
+        build_lib: StrPath,
+    ) -> EditableStrategy:
+        """Decides which strategy to use to implement an editable installation."""
+        build_name = f"__editable__.{name}-{tag}"
+        project_dir = Path(self.project_dir)
+        mode = _EditableMode.convert(self.mode)
+
+        if mode is _EditableMode.STRICT:
+            auxiliary_dir = _empty_dir(Path(self.project_dir, "build", build_name))
+            return _LinkTree(self.distribution, name, auxiliary_dir, build_lib)
+
+        packages = _find_packages(self.distribution)
+        has_simple_layout = _simple_layout(packages, self.package_dir, project_dir)
+        is_compat_mode = mode is _EditableMode.COMPAT
+        if set(self.package_dir) == {""} and has_simple_layout or is_compat_mode:
+            # src-layout(ish) is relatively safe for a simple pth file
+            src_dir = self.package_dir.get("", ".")
+            return _StaticPth(self.distribution, name, [Path(project_dir, src_dir)])
+
+        # Use a MetaPathFinder to avoid adding accidental top-level packages/modules
+        return _TopLevelFinder(self.distribution, name)
+
+
+class EditableStrategy(Protocol):
+    def __call__(
+        self, wheel: WheelFile, files: list[str], mapping: Mapping[str, str]
+    ) -> object: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self,
+        _exc_type: type[BaseException] | None,
+        _exc_value: BaseException | None,
+        _traceback: TracebackType | None,
+    ) -> object: ...
+
+
+class _StaticPth:
+    def __init__(self, dist: Distribution, name: str, path_entries: list[Path]) -> None:
+        self.dist = dist
+        self.name = name
+        self.path_entries = path_entries
+
+    def __call__(
+        self, wheel: WheelFile, files: list[str], mapping: Mapping[str, str]
+    ) -> None:
+        entries = "\n".join(str(p.resolve()) for p in self.path_entries)
+        contents = _encode_pth(f"{entries}\n")
+        wheel.writestr(f"__editable__.{self.name}.pth", contents)
+
+    def __enter__(self) -> Self:
+        msg = f"""
+        Editable install will be performed using .pth file to extend `sys.path` with:
+        {list(map(os.fspath, self.path_entries))!r}
+        """
+        _logger.warning(msg + _LENIENT_WARNING)
+        return self
+
+    def __exit__(
+        self,
+        _exc_type: object,
+        _exc_value: object,
+        _traceback: object,
+    ) -> None:
+        pass
+
+
+class _LinkTree(_StaticPth):
+    """
+    Creates a ``.pth`` file that points to a link tree in the ``auxiliary_dir``.
+
+    This strategy will only link files (not dirs), so it can be implemented in
+    any OS, even if that means using hardlinks instead of symlinks.
+
+    By collocating ``auxiliary_dir`` and the original source code, limitations
+    with hardlinks should be avoided.
+    """
+
+    def __init__(
+        self,
+        dist: Distribution,
+        name: str,
+        auxiliary_dir: StrPath,
+        build_lib: StrPath,
+    ) -> None:
+        self.auxiliary_dir = Path(auxiliary_dir)
+        self.build_lib = Path(build_lib).resolve()
+        self._file = dist.get_command_obj("build_py").copy_file
+        super().__init__(dist, name, [self.auxiliary_dir])
+
+    def __call__(
+        self, wheel: WheelFile, files: list[str], mapping: Mapping[str, str]
+    ) -> None:
+        self._create_links(files, mapping)
+        super().__call__(wheel, files, mapping)
+
+    def _normalize_output(self, file: str) -> str | None:
+        # Files relative to build_lib will be normalized to None
+        with suppress(ValueError):
+            path = Path(file).resolve().relative_to(self.build_lib)
+            return str(path).replace(os.sep, '/')
+        return None
+
+    def _create_file(self, relative_output: str, src_file: str, link=None):
+        dest = self.auxiliary_dir / relative_output
+        if not dest.parent.is_dir():
+            dest.parent.mkdir(parents=True)
+        self._file(src_file, dest, link=link)
+
+    def _create_links(self, outputs, output_mapping: Mapping[str, str]):
+        self.auxiliary_dir.mkdir(parents=True, exist_ok=True)
+        link_type = "sym" if _can_symlink_files(self.auxiliary_dir) else "hard"
+        normalised = ((self._normalize_output(k), v) for k, v in output_mapping.items())
+        # remove files that are not relative to build_lib
+        mappings = {k: v for k, v in normalised if k is not None}
+
+        for output in outputs:
+            relative = self._normalize_output(output)
+            if relative and relative not in mappings:
+                self._create_file(relative, output)
+
+        for relative, src in mappings.items():
+            self._create_file(relative, src, link=link_type)
+
+    def __enter__(self) -> Self:
+        msg = "Strict editable install will be performed using a link tree.\n"
+        _logger.warning(msg + _STRICT_WARNING)
+        return self
+
+    def __exit__(
+        self,
+        _exc_type: object,
+        _exc_value: object,
+        _traceback: object,
+    ) -> None:
+        msg = f"""\n
+        Strict editable installation performed using the auxiliary directory:
+            {self.auxiliary_dir}
+
+        Please be careful to not remove this directory, otherwise you might not be able
+        to import/use your package.
+        """
+        InformationOnly.emit("Editable installation.", msg)
+
+
+class _TopLevelFinder:
+    def __init__(self, dist: Distribution, name: str) -> None:
+        self.dist = dist
+        self.name = name
+
+    def template_vars(self) -> tuple[str, str, dict[str, str], dict[str, list[str]]]:
+        src_root = self.dist.src_root or os.curdir
+        top_level = chain(_find_packages(self.dist), _find_top_level_modules(self.dist))
+        package_dir = self.dist.package_dir or {}
+        roots = _find_package_roots(top_level, package_dir, src_root)
+
+        namespaces_ = dict(
+            chain(
+                _find_namespaces(self.dist.packages or [], roots),
+                ((ns, []) for ns in _find_virtual_namespaces(roots)),
+            )
+        )
+
+        legacy_namespaces = {
+            pkg: find_package_path(pkg, roots, self.dist.src_root or "")
+            for pkg in self.dist.namespace_packages or []
+        }
+
+        mapping = {**roots, **legacy_namespaces}
+        # ^-- We need to explicitly add the legacy_namespaces to the mapping to be
+        #     able to import their modules even if another package sharing the same
+        #     namespace is installed in a conventional (non-editable) way.
+
+        name = f"__editable__.{self.name}.finder"
+        finder = _normalization.safe_identifier(name)
+        return finder, name, mapping, namespaces_
+
+    def get_implementation(self) -> Iterator[tuple[str, bytes]]:
+        finder, name, mapping, namespaces_ = self.template_vars()
+
+        content = bytes(_finder_template(name, mapping, namespaces_), "utf-8")
+        yield (f"{finder}.py", content)
+
+        content = _encode_pth(f"import {finder}; {finder}.install()")
+        yield (f"__editable__.{self.name}.pth", content)
+
+    def __call__(
+        self, wheel: WheelFile, files: list[str], mapping: Mapping[str, str]
+    ) -> None:
+        for file, content in self.get_implementation():
+            wheel.writestr(file, content)
+
+    def __enter__(self) -> Self:
+        msg = "Editable install will be performed using a meta path finder.\n"
+        _logger.warning(msg + _LENIENT_WARNING)
+        return self
+
+    def __exit__(
+        self,
+        _exc_type: object,
+        _exc_value: object,
+        _traceback: object,
+    ) -> None:
+        msg = """\n
+        Please be careful with folders in your working directory with the same
+        name as your package as they may take precedence during imports.
+        """
+        InformationOnly.emit("Editable installation.", msg)
+
+
+def _encode_pth(content: str) -> bytes:
+    """
+    Prior to Python 3.13 (see https://github.com/python/cpython/issues/77102),
+    .pth files are always read with 'locale' encoding, the recommendation
+    from the cpython core developers is to write them as ``open(path, "w")``
+    and ignore warnings (see python/cpython#77102, pypa/setuptools#3937).
+    This function tries to simulate this behavior without having to create an
+    actual file, in a way that supports a range of active Python versions.
+    (There seems to be some variety in the way different version of Python handle
+    ``encoding=None``, not all of them use ``locale.getpreferredencoding(False)``
+    or ``locale.getencoding()``).
+    """
+    with io.BytesIO() as buffer:
+        wrapper = io.TextIOWrapper(buffer, encoding=py312.PTH_ENCODING)
+        # TODO: Python 3.13 replace the whole function with `bytes(content, "utf-8")`
+        wrapper.write(content)
+        wrapper.flush()
+        buffer.seek(0)
+        return buffer.read()
+
+
+def _can_symlink_files(base_dir: Path) -> bool:
+    with TemporaryDirectory(dir=str(base_dir.resolve())) as tmp:
+        path1, path2 = Path(tmp, "file1.txt"), Path(tmp, "file2.txt")
+        path1.write_text("file1", encoding="utf-8")
+        with suppress(AttributeError, NotImplementedError, OSError):
+            os.symlink(path1, path2)
+            if path2.is_symlink() and path2.read_text(encoding="utf-8") == "file1":
+                return True
+
+        try:
+            os.link(path1, path2)  # Ensure hard links can be created
+        except Exception as ex:
+            msg = (
+                "File system does not seem to support either symlinks or hard links. "
+                "Strict editable installs require one of them to be supported."
+            )
+            raise LinksNotSupported(msg) from ex
+        return False
+
+
+def _simple_layout(
+    packages: Iterable[str], package_dir: dict[str, str], project_dir: StrPath
+) -> bool:
+    """Return ``True`` if:
+    - all packages are contained by the same parent directory, **and**
+    - all packages become importable if the parent directory is added to ``sys.path``.
+
+    >>> _simple_layout(['a'], {"": "src"}, "/tmp/myproj")
+    True
+    >>> _simple_layout(['a', 'a.b'], {"": "src"}, "/tmp/myproj")
+    True
+    >>> _simple_layout(['a', 'a.b'], {}, "/tmp/myproj")
+    True
+    >>> _simple_layout(['a', 'a.a1', 'a.a1.a2', 'b'], {"": "src"}, "/tmp/myproj")
+    True
+    >>> _simple_layout(['a', 'a.a1', 'a.a1.a2', 'b'], {"a": "a", "b": "b"}, ".")
+    True
+    >>> _simple_layout(['a', 'a.a1', 'a.a1.a2', 'b'], {"a": "_a", "b": "_b"}, ".")
+    False
+    >>> _simple_layout(['a', 'a.a1', 'a.a1.a2', 'b'], {"a": "_a"}, "/tmp/myproj")
+    False
+    >>> _simple_layout(['a', 'a.a1', 'a.a1.a2', 'b'], {"a.a1.a2": "_a2"}, ".")
+    False
+    >>> _simple_layout(['a', 'a.b'], {"": "src", "a.b": "_ab"}, "/tmp/myproj")
+    False
+    >>> # Special cases, no packages yet:
+    >>> _simple_layout([], {"": "src"}, "/tmp/myproj")
+    True
+    >>> _simple_layout([], {"a": "_a", "": "src"}, "/tmp/myproj")
+    False
+    """
+    layout = {pkg: find_package_path(pkg, package_dir, project_dir) for pkg in packages}
+    if not layout:
+        return set(package_dir) in ({}, {""})
+    parent = os.path.commonpath(starmap(_parent_path, layout.items()))
+    return all(
+        _path.same_path(Path(parent, *key.split('.')), value)
+        for key, value in layout.items()
+    )
+
+
+def _parent_path(pkg, pkg_path):
+    """Infer the parent path containing a package, that if added to ``sys.path`` would
+    allow importing that package.
+    When ``pkg`` is directly mapped into a directory with a different name, return its
+    own path.
+    >>> _parent_path("a", "src/a")
+    'src'
+    >>> _parent_path("b", "src/c")
+    'src/c'
+    """
+    parent = pkg_path.removesuffix(pkg)
+    return parent.rstrip("/" + os.sep)
+
+
+def _find_packages(dist: Distribution) -> Iterator[str]:
+    yield from iter(dist.packages or [])
+
+    py_modules = dist.py_modules or []
+    nested_modules = [mod for mod in py_modules if "." in mod]
+    if dist.ext_package:
+        yield dist.ext_package
+    else:
+        ext_modules = dist.ext_modules or []
+        nested_modules += [x.name for x in ext_modules if "." in x.name]
+
+    for module in nested_modules:
+        package, _, _ = module.rpartition(".")
+        yield package
+
+
+def _find_top_level_modules(dist: Distribution) -> Iterator[str]:
+    py_modules = dist.py_modules or []
+    yield from (mod for mod in py_modules if "." not in mod)
+
+    if not dist.ext_package:
+        ext_modules = dist.ext_modules or []
+        yield from (x.name for x in ext_modules if "." not in x.name)
+
+
+def _find_package_roots(
+    packages: Iterable[str],
+    package_dir: Mapping[str, str],
+    src_root: StrPath,
+) -> dict[str, str]:
+    pkg_roots: dict[str, str] = {
+        pkg: _absolute_root(find_package_path(pkg, package_dir, src_root))
+        for pkg in sorted(packages)
+    }
+
+    return _remove_nested(pkg_roots)
+
+
+def _absolute_root(path: StrPath) -> str:
+    """Works for packages and top-level modules"""
+    path_ = Path(path)
+    parent = path_.parent
+
+    if path_.exists():
+        return str(path_.resolve())
+    else:
+        return str(parent.resolve() / path_.name)
+
+
+def _find_virtual_namespaces(pkg_roots: dict[str, str]) -> Iterator[str]:
+    """By carefully designing ``package_dir``, it is possible to implement the logical
+    structure of PEP 420 in a package without the corresponding directories.
+
+    Moreover a parent package can be purposefully/accidentally skipped in the discovery
+    phase (e.g. ``find_packages(include=["mypkg.*"])``, when ``mypkg.foo`` is included
+    by ``mypkg`` itself is not).
+    We consider this case to also be a virtual namespace (ignoring the original
+    directory) to emulate a non-editable installation.
+
+    This function will try to find these kinds of namespaces.
+    """
+    for pkg in pkg_roots:
+        if "." not in pkg:
+            continue
+        parts = pkg.split(".")
+        for i in range(len(parts) - 1, 0, -1):
+            partial_name = ".".join(parts[:i])
+            path = Path(find_package_path(partial_name, pkg_roots, ""))
+            if not path.exists() or partial_name not in pkg_roots:
+                # partial_name not in pkg_roots ==> purposefully/accidentally skipped
+                yield partial_name
+
+
+def _find_namespaces(
+    packages: list[str], pkg_roots: dict[str, str]
+) -> Iterator[tuple[str, list[str]]]:
+    for pkg in packages:
+        path = find_package_path(pkg, pkg_roots, "")
+        if Path(path).exists() and not Path(path, "__init__.py").exists():
+            yield (pkg, [path])
+
+
+def _remove_nested(pkg_roots: dict[str, str]) -> dict[str, str]:
+    output = dict(pkg_roots.copy())
+
+    for pkg, path in reversed(list(pkg_roots.items())):
+        if any(
+            pkg != other and _is_nested(pkg, path, other, other_path)
+            for other, other_path in pkg_roots.items()
+        ):
+            output.pop(pkg)
+
+    return output
+
+
+def _is_nested(pkg: str, pkg_path: str, parent: str, parent_path: str) -> bool:
+    """
+    Return ``True`` if ``pkg`` is nested inside ``parent`` both logically and in the
+    file system.
+    >>> _is_nested("a.b", "path/a/b", "a", "path/a")
+    True
+    >>> _is_nested("a.b", "path/a/b", "a", "otherpath/a")
+    False
+    >>> _is_nested("a.b", "path/a/b", "c", "path/c")
+    False
+    >>> _is_nested("a.a", "path/a/a", "a", "path/a")
+    True
+    >>> _is_nested("b.a", "path/b/a", "a", "path/a")
+    False
+    """
+    norm_pkg_path = _path.normpath(pkg_path)
+    rest = pkg.replace(parent, "", 1).strip(".").split(".")
+    return pkg.startswith(parent) and norm_pkg_path == _path.normpath(
+        Path(parent_path, *rest)
+    )
+
+
+def _empty_dir(dir_: _P) -> _P:
+    """Create a directory ensured to be empty. Existing files may be removed."""
+    _shutil.rmtree(dir_, ignore_errors=True)
+    os.makedirs(dir_)
+    return dir_
+
+
+class _NamespaceInstaller(namespaces.Installer):
+    def __init__(self, distribution, installation_dir, editable_name, src_root) -> None:
+        self.distribution = distribution
+        self.src_root = src_root
+        self.installation_dir = installation_dir
+        self.editable_name = editable_name
+        self.outputs: list[str] = []
+
+    def _get_nspkg_file(self):
+        """Installation target."""
+        return os.path.join(self.installation_dir, self.editable_name + self.nspkg_ext)
+
+    def _get_root(self):
+        """Where the modules/packages should be loaded from."""
+        return repr(str(self.src_root))
+
+
+_FINDER_TEMPLATE = """\
+from __future__ import annotations
+import sys
+from importlib.machinery import ModuleSpec, PathFinder
+from importlib.machinery import all_suffixes as module_suffixes
+from importlib.util import spec_from_file_location
+from itertools import chain
+from pathlib import Path
+
+MAPPING: dict[str, str] = {mapping!r}
+NAMESPACES: dict[str, list[str]] = {namespaces!r}
+PATH_PLACEHOLDER = {name!r} + ".__path_hook__"
+
+
+class _EditableFinder:  # MetaPathFinder
+    @classmethod
+    def find_spec(cls, fullname: str, path=None, target=None) -> ModuleSpec | None:  # type: ignore
+        # Top-level packages and modules (we know these exist in the FS)
+        if fullname in MAPPING:
+            pkg_path = MAPPING[fullname]
+            return cls._find_spec(fullname, Path(pkg_path))
+
+        # Handle immediate children modules (required for namespaces to work)
+        # To avoid problems with case sensitivity in the file system we delegate
+        # to the importlib.machinery implementation.
+        parent, _, child = fullname.rpartition(".")
+        if parent and parent in MAPPING:
+            return PathFinder.find_spec(fullname, path=[MAPPING[parent]])
+
+        # Other levels of nesting should be handled automatically by importlib
+        # using the parent path.
+        return None
+
+    @classmethod
+    def _find_spec(cls, fullname: str, candidate_path: Path) -> ModuleSpec | None:
+        init = candidate_path / "__init__.py"
+        candidates = (candidate_path.with_suffix(x) for x in module_suffixes())
+        for candidate in chain([init], candidates):
+            if candidate.exists():
+                return spec_from_file_location(fullname, candidate)
+        return None
+
+
+class _EditableNamespaceFinder:  # PathEntryFinder
+    @classmethod
+    def _path_hook(cls, path) -> type[_EditableNamespaceFinder]:
+        if path == PATH_PLACEHOLDER:
+            return cls
+        raise ImportError
+
+    @classmethod
+    def _paths(cls, fullname: str) -> list[str]:
+        paths = NAMESPACES[fullname]
+        if not paths and fullname in MAPPING:
+            paths = [MAPPING[fullname]]
+        # Always add placeholder, for 2 reasons:
+        # 1. __path__ cannot be empty for the spec to be considered namespace.
+        # 2. In the case of nested namespaces, we need to force
+        #    import machinery to query _EditableNamespaceFinder again.
+        return [*paths, PATH_PLACEHOLDER]
+
+    @classmethod
+    def find_spec(cls, fullname: str, target=None) -> ModuleSpec | None:  # type: ignore
+        if fullname in NAMESPACES:
+            spec = ModuleSpec(fullname, None, is_package=True)
+            spec.submodule_search_locations = cls._paths(fullname)
+            return spec
+        return None
+
+    @classmethod
+    def find_module(cls, _fullname) -> None:
+        return None
+
+
+def install():
+    if not any(finder == _EditableFinder for finder in sys.meta_path):
+        sys.meta_path.append(_EditableFinder)
+
+    if not NAMESPACES:
+        return
+
+    if not any(hook == _EditableNamespaceFinder._path_hook for hook in sys.path_hooks):
+        # PathEntryFinder is needed to create NamespaceSpec without private APIS
+        sys.path_hooks.append(_EditableNamespaceFinder._path_hook)
+    if PATH_PLACEHOLDER not in sys.path:
+        sys.path.append(PATH_PLACEHOLDER)  # Used just to trigger the path hook
+"""
+
+
+def _finder_template(
+    name: str, mapping: Mapping[str, str], namespaces: dict[str, list[str]]
+) -> str:
+    """Create a string containing the code for the``MetaPathFinder`` and
+    ``PathEntryFinder``.
+    """
+    mapping = dict(sorted(mapping.items(), key=operator.itemgetter(0)))
+    return _FINDER_TEMPLATE.format(name=name, mapping=mapping, namespaces=namespaces)
+
+
+class LinksNotSupported(errors.FileError):
+    """File system does not seem to support either symlinks or hard links."""
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/egg_info.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/egg_info.py
new file mode 100644
index 0000000000000000000000000000000000000000..a5b5932702a541baffef2c823ad851b2a4cfa36c
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/egg_info.py
@@ -0,0 +1,716 @@
+"""setuptools.command.egg_info
+
+Create a distribution's .egg-info directory and contents"""
+
+from __future__ import annotations
+
+import functools
+import os
+import re
+import sys
+import time
+from collections.abc import Callable
+
+import packaging
+import packaging.requirements
+import packaging.version
+
+import setuptools.unicode_utils as unicode_utils
+from setuptools import Command
+from setuptools.command import bdist_egg
+from setuptools.command.sdist import sdist, walk_revctrl
+from setuptools.command.setopt import edit_config
+from setuptools.glob import glob
+
+from .. import _entry_points, _normalization
+from .._importlib import metadata
+from ..warnings import SetuptoolsDeprecationWarning
+from . import _requirestxt
+
+import distutils.errors
+import distutils.filelist
+from distutils import log
+from distutils.errors import DistutilsInternalError
+from distutils.filelist import FileList as _FileList
+from distutils.util import convert_path
+
+PY_MAJOR = f'{sys.version_info.major}.{sys.version_info.minor}'
+
+
+def translate_pattern(glob):  # noqa: C901  # is too complex (14)  # FIXME
+    """
+    Translate a file path glob like '*.txt' in to a regular expression.
+    This differs from fnmatch.translate which allows wildcards to match
+    directory separators. It also knows about '**/' which matches any number of
+    directories.
+    """
+    pat = ''
+
+    # This will split on '/' within [character classes]. This is deliberate.
+    chunks = glob.split(os.path.sep)
+
+    sep = re.escape(os.sep)
+    valid_char = f'[^{sep}]'
+
+    for c, chunk in enumerate(chunks):
+        last_chunk = c == len(chunks) - 1
+
+        # Chunks that are a literal ** are globstars. They match anything.
+        if chunk == '**':
+            if last_chunk:
+                # Match anything if this is the last component
+                pat += '.*'
+            else:
+                # Match '(name/)*'
+                pat += f'(?:{valid_char}+{sep})*'
+            continue  # Break here as the whole path component has been handled
+
+        # Find any special characters in the remainder
+        i = 0
+        chunk_len = len(chunk)
+        while i < chunk_len:
+            char = chunk[i]
+            if char == '*':
+                # Match any number of name characters
+                pat += valid_char + '*'
+            elif char == '?':
+                # Match a name character
+                pat += valid_char
+            elif char == '[':
+                # Character class
+                inner_i = i + 1
+                # Skip initial !/] chars
+                if inner_i < chunk_len and chunk[inner_i] == '!':
+                    inner_i = inner_i + 1
+                if inner_i < chunk_len and chunk[inner_i] == ']':
+                    inner_i = inner_i + 1
+
+                # Loop till the closing ] is found
+                while inner_i < chunk_len and chunk[inner_i] != ']':
+                    inner_i = inner_i + 1
+
+                if inner_i >= chunk_len:
+                    # Got to the end of the string without finding a closing ]
+                    # Do not treat this as a matching group, but as a literal [
+                    pat += re.escape(char)
+                else:
+                    # Grab the insides of the [brackets]
+                    inner = chunk[i + 1 : inner_i]
+                    char_class = ''
+
+                    # Class negation
+                    if inner[0] == '!':
+                        char_class = '^'
+                        inner = inner[1:]
+
+                    char_class += re.escape(inner)
+                    pat += f'[{char_class}]'
+
+                    # Skip to the end ]
+                    i = inner_i
+            else:
+                pat += re.escape(char)
+            i += 1
+
+        # Join each chunk with the dir separator
+        if not last_chunk:
+            pat += sep
+
+    pat += r'\Z'
+    return re.compile(pat, flags=re.MULTILINE | re.DOTALL)
+
+
+class InfoCommon:
+    tag_build = None
+    tag_date = None
+
+    @property
+    def name(self):
+        return _normalization.safe_name(self.distribution.get_name())
+
+    def tagged_version(self):
+        tagged = self._maybe_tag(self.distribution.get_version())
+        return _normalization.safe_version(tagged)
+
+    def _maybe_tag(self, version):
+        """
+        egg_info may be called more than once for a distribution,
+        in which case the version string already contains all tags.
+        """
+        return (
+            version
+            if self.vtags and self._already_tagged(version)
+            else version + self.vtags
+        )
+
+    def _already_tagged(self, version: str) -> bool:
+        # Depending on their format, tags may change with version normalization.
+        # So in addition the regular tags, we have to search for the normalized ones.
+        return version.endswith((self.vtags, self._safe_tags()))
+
+    def _safe_tags(self) -> str:
+        # To implement this we can rely on `safe_version` pretending to be version 0
+        # followed by tags. Then we simply discard the starting 0 (fake version number)
+        try:
+            return _normalization.safe_version(f"0{self.vtags}")[1:]
+        except packaging.version.InvalidVersion:
+            return _normalization.safe_name(self.vtags.replace(' ', '.'))
+
+    def tags(self) -> str:
+        version = ''
+        if self.tag_build:
+            version += self.tag_build
+        if self.tag_date:
+            version += time.strftime("%Y%m%d")
+        return version
+
+    vtags = property(tags)
+
+
+class egg_info(InfoCommon, Command):
+    description = "create a distribution's .egg-info directory"
+
+    user_options = [
+        (
+            'egg-base=',
+            'e',
+            "directory containing .egg-info directories"
+            " [default: top of the source tree]",
+        ),
+        ('tag-date', 'd', "Add date stamp (e.g. 20050528) to version number"),
+        ('tag-build=', 'b', "Specify explicit tag to add to version number"),
+        ('no-date', 'D', "Don't include date stamp [default]"),
+    ]
+
+    boolean_options = ['tag-date']
+    negative_opt = {
+        'no-date': 'tag-date',
+    }
+
+    def initialize_options(self):
+        self.egg_base = None
+        self.egg_name = None
+        self.egg_info = None
+        self.egg_version = None
+        self.ignore_egg_info_in_manifest = False
+
+    ####################################
+    # allow the 'tag_svn_revision' to be detected and
+    # set, supporting sdists built on older Setuptools.
+    @property
+    def tag_svn_revision(self) -> int | None:
+        pass
+
+    @tag_svn_revision.setter
+    def tag_svn_revision(self, value) -> None:
+        pass
+
+    ####################################
+
+    def save_version_info(self, filename) -> None:
+        """
+        Materialize the value of date into the
+        build tag. Install build keys in a deterministic order
+        to avoid arbitrary reordering on subsequent builds.
+        """
+        # follow the order these keys would have been added
+        # when PYTHONHASHSEED=0
+        egg_info = dict(tag_build=self.tags(), tag_date=0)
+        edit_config(filename, dict(egg_info=egg_info))
+
+    def finalize_options(self) -> None:
+        # Note: we need to capture the current value returned
+        # by `self.tagged_version()`, so we can later update
+        # `self.distribution.metadata.version` without
+        # repercussions.
+        self.egg_name = self.name
+        self.egg_version = self.tagged_version()
+        parsed_version = packaging.version.Version(self.egg_version)
+
+        try:
+            is_version = isinstance(parsed_version, packaging.version.Version)
+            spec = "%s==%s" if is_version else "%s===%s"
+            packaging.requirements.Requirement(spec % (self.egg_name, self.egg_version))
+        except ValueError as e:
+            raise distutils.errors.DistutilsOptionError(
+                f"Invalid distribution name or version syntax: {self.egg_name}-{self.egg_version}"
+            ) from e
+
+        if self.egg_base is None:
+            dirs = self.distribution.package_dir
+            self.egg_base = (dirs or {}).get('', os.curdir)
+
+        self.ensure_dirname('egg_base')
+        self.egg_info = _normalization.filename_component(self.egg_name) + '.egg-info'
+        if self.egg_base != os.curdir:
+            self.egg_info = os.path.join(self.egg_base, self.egg_info)
+
+        # Set package version for the benefit of dumber commands
+        # (e.g. sdist, bdist_wininst, etc.)
+        #
+        self.distribution.metadata.version = self.egg_version
+
+    def _get_egg_basename(self, py_version=PY_MAJOR, platform=None):
+        """Compute filename of the output egg. Private API."""
+        return _egg_basename(self.egg_name, self.egg_version, py_version, platform)
+
+    def write_or_delete_file(self, what, filename, data, force: bool = False) -> None:
+        """Write `data` to `filename` or delete if empty
+
+        If `data` is non-empty, this routine is the same as ``write_file()``.
+        If `data` is empty but not ``None``, this is the same as calling
+        ``delete_file(filename)`.  If `data` is ``None``, then this is a no-op
+        unless `filename` exists, in which case a warning is issued about the
+        orphaned file (if `force` is false), or deleted (if `force` is true).
+        """
+        if data:
+            self.write_file(what, filename, data)
+        elif os.path.exists(filename):
+            if data is None and not force:
+                log.warn("%s not set in setup(), but %s exists", what, filename)
+                return
+            else:
+                self.delete_file(filename)
+
+    def write_file(self, what, filename, data) -> None:
+        """Write `data` to `filename` (if not a dry run) after announcing it
+
+        `what` is used in a log message to identify what is being written
+        to the file.
+        """
+        log.info("writing %s to %s", what, filename)
+        data = data.encode("utf-8")
+        f = open(filename, 'wb')
+        f.write(data)
+        f.close()
+
+    def delete_file(self, filename) -> None:
+        """Delete `filename` (if not a dry run) after announcing it"""
+        log.info("deleting %s", filename)
+        os.unlink(filename)
+
+    def run(self) -> None:
+        # Pre-load to avoid iterating over entry-points while an empty .egg-info
+        # exists in sys.path. See pypa/pyproject-hooks#206
+        writers = list(metadata.entry_points(group='egg_info.writers'))
+
+        self.mkpath(self.egg_info)
+        try:
+            os.utime(self.egg_info, None)
+        except OSError as e:
+            msg = f"Cannot update time stamp of directory '{self.egg_info}'"
+            raise distutils.errors.DistutilsFileError(msg) from e
+        for ep in writers:
+            writer = ep.load()
+            writer(self, ep.name, os.path.join(self.egg_info, ep.name))
+
+        # Get rid of native_libs.txt if it was put there by older bdist_egg
+        nl = os.path.join(self.egg_info, "native_libs.txt")
+        if os.path.exists(nl):
+            self.delete_file(nl)
+
+        self.find_sources()
+
+    def find_sources(self) -> None:
+        """Generate SOURCES.txt manifest file"""
+        manifest_filename = os.path.join(self.egg_info, "SOURCES.txt")
+        mm = manifest_maker(self.distribution)
+        mm.ignore_egg_info_dir = self.ignore_egg_info_in_manifest
+        mm.manifest = manifest_filename
+        mm.run()
+        self.filelist = mm.filelist
+
+
+class FileList(_FileList):
+    # Implementations of the various MANIFEST.in commands
+
+    def __init__(
+        self, warn=None, debug_print=None, ignore_egg_info_dir: bool = False
+    ) -> None:
+        super().__init__(warn, debug_print)
+        self.ignore_egg_info_dir = ignore_egg_info_dir
+
+    def process_template_line(self, line) -> None:
+        # Parse the line: split it up, make sure the right number of words
+        # is there, and return the relevant words.  'action' is always
+        # defined: it's the first word of the line.  Which of the other
+        # three are defined depends on the action; it'll be either
+        # patterns, (dir and patterns), or (dir_pattern).
+        (action, patterns, dir, dir_pattern) = self._parse_template_line(line)
+
+        action_map: dict[str, Callable] = {
+            'include': self.include,
+            'exclude': self.exclude,
+            'global-include': self.global_include,
+            'global-exclude': self.global_exclude,
+            'recursive-include': functools.partial(
+                self.recursive_include,
+                dir,
+            ),
+            'recursive-exclude': functools.partial(
+                self.recursive_exclude,
+                dir,
+            ),
+            'graft': self.graft,
+            'prune': self.prune,
+        }
+        log_map = {
+            'include': "warning: no files found matching '%s'",
+            'exclude': ("warning: no previously-included files found matching '%s'"),
+            'global-include': (
+                "warning: no files found matching '%s' anywhere in distribution"
+            ),
+            'global-exclude': (
+                "warning: no previously-included files matching "
+                "'%s' found anywhere in distribution"
+            ),
+            'recursive-include': (
+                "warning: no files found matching '%s' under directory '%s'"
+            ),
+            'recursive-exclude': (
+                "warning: no previously-included files matching "
+                "'%s' found under directory '%s'"
+            ),
+            'graft': "warning: no directories found matching '%s'",
+            'prune': "no previously-included directories found matching '%s'",
+        }
+
+        try:
+            process_action = action_map[action]
+        except KeyError:
+            msg = f"Invalid MANIFEST.in: unknown action {action!r} in {line!r}"
+            raise DistutilsInternalError(msg) from None
+
+        # OK, now we know that the action is valid and we have the
+        # right number of words on the line for that action -- so we
+        # can proceed with minimal error-checking.
+
+        action_is_recursive = action.startswith('recursive-')
+        if action in {'graft', 'prune'}:
+            patterns = [dir_pattern]
+        extra_log_args = (dir,) if action_is_recursive else ()
+        log_tmpl = log_map[action]
+
+        self.debug_print(
+            ' '.join(
+                [action] + ([dir] if action_is_recursive else []) + patterns,
+            )
+        )
+        for pattern in patterns:
+            if not process_action(pattern):
+                log.warn(log_tmpl, pattern, *extra_log_args)
+
+    def _remove_files(self, predicate):
+        """
+        Remove all files from the file list that match the predicate.
+        Return True if any matching files were removed
+        """
+        found = False
+        for i in range(len(self.files) - 1, -1, -1):
+            if predicate(self.files[i]):
+                self.debug_print(" removing " + self.files[i])
+                del self.files[i]
+                found = True
+        return found
+
+    def include(self, pattern):
+        """Include files that match 'pattern'."""
+        found = [f for f in glob(pattern) if not os.path.isdir(f)]
+        self.extend(found)
+        return bool(found)
+
+    def exclude(self, pattern):
+        """Exclude files that match 'pattern'."""
+        match = translate_pattern(pattern)
+        return self._remove_files(match.match)
+
+    def recursive_include(self, dir, pattern):
+        """
+        Include all files anywhere in 'dir/' that match the pattern.
+        """
+        full_pattern = os.path.join(dir, '**', pattern)
+        found = [f for f in glob(full_pattern, recursive=True) if not os.path.isdir(f)]
+        self.extend(found)
+        return bool(found)
+
+    def recursive_exclude(self, dir, pattern):
+        """
+        Exclude any file anywhere in 'dir/' that match the pattern.
+        """
+        match = translate_pattern(os.path.join(dir, '**', pattern))
+        return self._remove_files(match.match)
+
+    def graft(self, dir):
+        """Include all files from 'dir/'."""
+        found = [
+            item
+            for match_dir in glob(dir)
+            for item in distutils.filelist.findall(match_dir)
+        ]
+        self.extend(found)
+        return bool(found)
+
+    def prune(self, dir):
+        """Filter out files from 'dir/'."""
+        match = translate_pattern(os.path.join(dir, '**'))
+        return self._remove_files(match.match)
+
+    def global_include(self, pattern):
+        """
+        Include all files anywhere in the current directory that match the
+        pattern. This is very inefficient on large file trees.
+        """
+        if self.allfiles is None:
+            self.findall()
+        match = translate_pattern(os.path.join('**', pattern))
+        found = [f for f in self.allfiles if match.match(f)]
+        self.extend(found)
+        return bool(found)
+
+    def global_exclude(self, pattern):
+        """
+        Exclude all files anywhere that match the pattern.
+        """
+        match = translate_pattern(os.path.join('**', pattern))
+        return self._remove_files(match.match)
+
+    def append(self, item) -> None:
+        item = item.removesuffix('\r')  # Fix older sdists built on Windows
+        path = convert_path(item)
+
+        if self._safe_path(path):
+            self.files.append(path)
+
+    def extend(self, paths) -> None:
+        self.files.extend(filter(self._safe_path, paths))
+
+    def _repair(self):
+        """
+        Replace self.files with only safe paths
+
+        Because some owners of FileList manipulate the underlying
+        ``files`` attribute directly, this method must be called to
+        repair those paths.
+        """
+        self.files = list(filter(self._safe_path, self.files))
+
+    def _safe_path(self, path):
+        enc_warn = "'%s' not %s encodable -- skipping"
+
+        # To avoid accidental trans-codings errors, first to unicode
+        u_path = unicode_utils.filesys_decode(path)
+        if u_path is None:
+            log.warn(f"'{path}' in unexpected encoding -- skipping")
+            return False
+
+        # Must ensure utf-8 encodability
+        utf8_path = unicode_utils.try_encode(u_path, "utf-8")
+        if utf8_path is None:
+            log.warn(enc_warn, path, 'utf-8')
+            return False
+
+        try:
+            # ignore egg-info paths
+            is_egg_info = ".egg-info" in u_path or b".egg-info" in utf8_path
+            if self.ignore_egg_info_dir and is_egg_info:
+                return False
+            # accept is either way checks out
+            if os.path.exists(u_path) or os.path.exists(utf8_path):
+                return True
+        # this will catch any encode errors decoding u_path
+        except UnicodeEncodeError:
+            log.warn(enc_warn, path, sys.getfilesystemencoding())
+
+
+class manifest_maker(sdist):
+    template = "MANIFEST.in"
+
+    def initialize_options(self) -> None:
+        self.use_defaults = True
+        self.prune = True
+        self.manifest_only = True
+        self.force_manifest = True
+        self.ignore_egg_info_dir = False
+
+    def finalize_options(self) -> None:
+        pass
+
+    def run(self) -> None:
+        self.filelist = FileList(ignore_egg_info_dir=self.ignore_egg_info_dir)
+        if not os.path.exists(self.manifest):
+            self.write_manifest()  # it must exist so it'll get in the list
+        self.add_defaults()
+        if os.path.exists(self.template):
+            self.read_template()
+        self.add_license_files()
+        self._add_referenced_files()
+        self.prune_file_list()
+        self.filelist.sort()
+        self.filelist.remove_duplicates()
+        self.write_manifest()
+
+    def _manifest_normalize(self, path):
+        path = unicode_utils.filesys_decode(path)
+        return path.replace(os.sep, '/')
+
+    def write_manifest(self) -> None:
+        """
+        Write the file list in 'self.filelist' to the manifest file
+        named by 'self.manifest'.
+        """
+        self.filelist._repair()
+
+        # Now _repairs should encodability, but not unicode
+        files = [self._manifest_normalize(f) for f in self.filelist.files]
+        msg = f"writing manifest file '{self.manifest}'"
+        self.execute(write_file, (self.manifest, files), msg)
+
+    def warn(self, msg) -> None:
+        if not self._should_suppress_warning(msg):
+            sdist.warn(self, msg)
+
+    @staticmethod
+    def _should_suppress_warning(msg):
+        """
+        suppress missing-file warnings from sdist
+        """
+        return re.match(r"standard file .*not found", msg)
+
+    def add_defaults(self) -> None:
+        sdist.add_defaults(self)
+        self.filelist.append(self.template)
+        self.filelist.append(self.manifest)
+        rcfiles = list(walk_revctrl())
+        if rcfiles:
+            self.filelist.extend(rcfiles)
+        elif os.path.exists(self.manifest):
+            self.read_manifest()
+
+        if os.path.exists("setup.py"):
+            # setup.py should be included by default, even if it's not
+            # the script called to create the sdist
+            self.filelist.append("setup.py")
+
+        ei_cmd = self.get_finalized_command('egg_info')
+        self.filelist.graft(ei_cmd.egg_info)
+
+    def add_license_files(self) -> None:
+        license_files = self.distribution.metadata.license_files or []
+        for lf in license_files:
+            log.info("adding license file '%s'", lf)
+        self.filelist.extend(license_files)
+
+    def _add_referenced_files(self):
+        """Add files referenced by the config (e.g. `file:` directive) to filelist"""
+        referenced = getattr(self.distribution, '_referenced_files', [])
+        # ^-- fallback if dist comes from distutils or is a custom class
+        for rf in referenced:
+            log.debug("adding file referenced by config '%s'", rf)
+        self.filelist.extend(referenced)
+
+    def _safe_data_files(self, build_py):
+        """
+        The parent class implementation of this method
+        (``sdist``) will try to include data files, which
+        might cause recursion problems when
+        ``include_package_data=True``.
+
+        Therefore, avoid triggering any attempt of
+        analyzing/building the manifest again.
+        """
+        if hasattr(build_py, 'get_data_files_without_manifest'):
+            return build_py.get_data_files_without_manifest()
+
+        SetuptoolsDeprecationWarning.emit(
+            "`build_py` command does not inherit from setuptools' `build_py`.",
+            """
+            Custom 'build_py' does not implement 'get_data_files_without_manifest'.
+            Please extend command classes from setuptools instead of distutils.
+            """,
+            see_url="https://peps.python.org/pep-0632/",
+            # due_date not defined yet, old projects might still do it?
+        )
+        return build_py.get_data_files()
+
+
+def write_file(filename, contents) -> None:
+    """Create a file with the specified name and write 'contents' (a
+    sequence of strings without line terminators) to it.
+    """
+    contents = "\n".join(contents)
+
+    # assuming the contents has been vetted for utf-8 encoding
+    contents = contents.encode("utf-8")
+
+    with open(filename, "wb") as f:  # always write POSIX-style manifest
+        f.write(contents)
+
+
+def write_pkg_info(cmd, basename, filename) -> None:
+    log.info("writing %s", filename)
+    metadata = cmd.distribution.metadata
+    metadata.version, oldver = cmd.egg_version, metadata.version
+    metadata.name, oldname = cmd.egg_name, metadata.name
+
+    try:
+        metadata.write_pkg_info(cmd.egg_info)
+    finally:
+        metadata.name, metadata.version = oldname, oldver
+
+    safe = getattr(cmd.distribution, 'zip_safe', None)
+
+    bdist_egg.write_safety_flag(cmd.egg_info, safe)
+
+
+def warn_depends_obsolete(cmd, basename, filename) -> None:
+    """
+    Unused: left to avoid errors when updating (from source) from <= 67.8.
+    Old installations have a .dist-info directory with the entry-point
+    ``depends.txt = setuptools.command.egg_info:warn_depends_obsolete``.
+    This may trigger errors when running the first egg_info in build_meta.
+    TODO: Remove this function in a version sufficiently > 68.
+    """
+
+
+# Export API used in entry_points
+write_requirements = _requirestxt.write_requirements
+write_setup_requirements = _requirestxt.write_setup_requirements
+
+
+def write_toplevel_names(cmd, basename, filename) -> None:
+    pkgs = dict.fromkeys([
+        k.split('.', 1)[0] for k in cmd.distribution.iter_distribution_names()
+    ])
+    cmd.write_file("top-level names", filename, '\n'.join(sorted(pkgs)) + '\n')
+
+
+def overwrite_arg(cmd, basename, filename) -> None:
+    write_arg(cmd, basename, filename, True)
+
+
+def write_arg(cmd, basename, filename, force: bool = False) -> None:
+    argname = os.path.splitext(basename)[0]
+    value = getattr(cmd.distribution, argname, None)
+    if value is not None:
+        value = '\n'.join(value) + '\n'
+    cmd.write_or_delete_file(argname, filename, value, force)
+
+
+def write_entries(cmd, basename, filename) -> None:
+    eps = _entry_points.load(cmd.distribution.entry_points)
+    defn = _entry_points.render(eps)
+    cmd.write_or_delete_file('entry points', filename, defn, True)
+
+
+def _egg_basename(egg_name, egg_version, py_version=None, platform=None):
+    """Compute filename of the output egg. Private API."""
+    name = _normalization.filename_component(egg_name)
+    version = _normalization.filename_component(egg_version)
+    egg = f"{name}-{version}-py{py_version or PY_MAJOR}"
+    if platform:
+        egg += f"-{platform}"
+    return egg
+
+
+class EggInfoDeprecationWarning(SetuptoolsDeprecationWarning):
+    """Deprecated behavior warning for EggInfo, bypassing suppression."""
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/install.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/install.py
new file mode 100644
index 0000000000000000000000000000000000000000..19ca601458f99c50a6cceec1e70ce70ebd39e9cb
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/install.py
@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import inspect
+import platform
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from ..dist import Distribution
+from ..warnings import SetuptoolsDeprecationWarning, SetuptoolsWarning
+
+import distutils.command.install as orig
+from distutils.errors import DistutilsArgError
+
+if TYPE_CHECKING:
+    # This is only used for a type-cast, don't import at runtime or it'll cause deprecation warnings
+    from .easy_install import easy_install as easy_install_cls
+else:
+    easy_install_cls = None
+
+
+def __getattr__(name: str):  # pragma: no cover
+    if name == "_install":
+        SetuptoolsDeprecationWarning.emit(
+            "`setuptools.command._install` was an internal implementation detail "
+            "that was left in for numpy<1.9 support.",
+            due_date=(2025, 5, 2),  # Originally added on 2024-11-01
+        )
+        return orig.install
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+class install(orig.install):
+    """Use easy_install to install the package, w/dependencies"""
+
+    distribution: Distribution  # override distutils.dist.Distribution with setuptools.dist.Distribution
+
+    user_options = orig.install.user_options + [
+        ('old-and-unmanageable', None, "Try not to use this!"),
+        (
+            'single-version-externally-managed',
+            None,
+            "used by system package builders to create 'flat' eggs",
+        ),
+    ]
+    boolean_options = orig.install.boolean_options + [
+        'old-and-unmanageable',
+        'single-version-externally-managed',
+    ]
+    # Type the same as distutils.command.install.install.sub_commands
+    # Must keep the second tuple item potentially None due to invariance
+    new_commands: ClassVar[list[tuple[str, Callable[[Any], bool] | None]]] = [
+        ('install_egg_info', lambda self: True),
+        ('install_scripts', lambda self: True),
+    ]
+    _nc = dict(new_commands)
+
+    def initialize_options(self):
+        SetuptoolsDeprecationWarning.emit(
+            "setup.py install is deprecated.",
+            """
+            Please avoid running ``setup.py`` directly.
+            Instead, use pypa/build, pypa/installer or other
+            standards-based tools.
+            """,
+            see_url="https://blog.ganssle.io/articles/2021/10/setup-py-deprecated.html",
+            due_date=(2025, 10, 31),
+        )
+
+        super().initialize_options()
+        self.old_and_unmanageable = None
+        self.single_version_externally_managed = None
+
+    def finalize_options(self) -> None:
+        super().finalize_options()
+        if self.root:
+            self.single_version_externally_managed = True
+        elif self.single_version_externally_managed:
+            if not self.root and not self.record:
+                raise DistutilsArgError(
+                    "You must specify --record or --root when building system packages"
+                )
+
+    def handle_extra_path(self):
+        if self.root or self.single_version_externally_managed:
+            # explicit backward-compatibility mode, allow extra_path to work
+            return orig.install.handle_extra_path(self)
+
+        # Ignore extra_path when installing an egg (or being run by another
+        # command without --root or --single-version-externally-managed
+        self.path_file = None
+        self.extra_dirs = ''
+        return None
+
+    @staticmethod
+    def _called_from_setup(run_frame):
+        """
+        Attempt to detect whether run() was called from setup() or by another
+        command.  If called by setup(), the parent caller will be the
+        'run_command' method in 'distutils.dist', and *its* caller will be
+        the 'run_commands' method.  If called any other way, the
+        immediate caller *might* be 'run_command', but it won't have been
+        called by 'run_commands'. Return True in that case or if a call stack
+        is unavailable. Return False otherwise.
+        """
+        if run_frame is None:
+            msg = "Call stack not available. bdist_* commands may fail."
+            SetuptoolsWarning.emit(msg)
+            if platform.python_implementation() == 'IronPython':
+                msg = "For best results, pass -X:Frames to enable call stack."
+                SetuptoolsWarning.emit(msg)
+            return True
+
+        frames = inspect.getouterframes(run_frame)
+        for frame in frames[2:4]:
+            (caller,) = frame[:1]
+            info = inspect.getframeinfo(caller)
+            caller_module = caller.f_globals.get('__name__', '')
+
+            if caller_module == "setuptools.dist" and info.function == "run_command":
+                # Starting from v61.0.0 setuptools overwrites dist.run_command
+                continue
+
+            return caller_module == 'distutils.dist' and info.function == 'run_commands'
+
+        return False
+
+
+# XXX Python 3.1 doesn't see _nc if this is inside the class
+install.sub_commands = [
+    cmd for cmd in orig.install.sub_commands if cmd[0] not in install._nc
+] + install.new_commands
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/install_egg_info.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/install_egg_info.py
new file mode 100644
index 0000000000000000000000000000000000000000..46138d2fd7d9f1215a2d077f7d5e8e129451dc42
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/install_egg_info.py
@@ -0,0 +1,57 @@
+import os
+
+from setuptools import Command, namespaces
+from setuptools.archive_util import unpack_archive
+
+from .._path import ensure_directory
+
+from distutils import dir_util, log
+
+
+class install_egg_info(namespaces.Installer, Command):
+    """Install an .egg-info directory for the package"""
+
+    description = "Install an .egg-info directory for the package"
+
+    user_options = [
+        ('install-dir=', 'd', "directory to install to"),
+    ]
+
+    def initialize_options(self):
+        self.install_dir = None
+
+    def finalize_options(self) -> None:
+        self.set_undefined_options('install_lib', ('install_dir', 'install_dir'))
+        ei_cmd = self.get_finalized_command("egg_info")
+        basename = f"{ei_cmd._get_egg_basename()}.egg-info"
+        self.source = ei_cmd.egg_info
+        self.target = os.path.join(self.install_dir, basename)
+        self.outputs: list[str] = []
+
+    def run(self) -> None:
+        self.run_command('egg_info')
+        if os.path.isdir(self.target) and not os.path.islink(self.target):
+            dir_util.remove_tree(self.target)
+        elif os.path.exists(self.target):
+            self.execute(os.unlink, (self.target,), "Removing " + self.target)
+        ensure_directory(self.target)
+        self.execute(self.copytree, (), f"Copying {self.source} to {self.target}")
+        self.install_namespaces()
+
+    def get_outputs(self):
+        return self.outputs
+
+    def copytree(self) -> None:
+        # Copy the .egg-info tree to site-packages
+        def skimmer(src, dst):
+            # filter out source-control directories; note that 'src' is always
+            # a '/'-separated path, regardless of platform.  'dst' is a
+            # platform-specific path.
+            for skip in '.svn/', 'CVS/':
+                if src.startswith(skip) or '/' + skip in src:
+                    return None
+            self.outputs.append(dst)
+            log.debug("Copying %s to %s", src, dst)
+            return dst
+
+        unpack_archive(self.source, self.target, skimmer)
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/install_lib.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/install_lib.py
new file mode 100644
index 0000000000000000000000000000000000000000..8e1e07271028386e138585cac7619ab0338017cc
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/install_lib.py
@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+import os
+import sys
+from itertools import product, starmap
+
+from .._path import StrPath
+from ..dist import Distribution
+
+import distutils.command.install_lib as orig
+
+
+class install_lib(orig.install_lib):
+    """Don't add compiled flags to filenames of non-Python files"""
+
+    distribution: Distribution  # override distutils.dist.Distribution with setuptools.dist.Distribution
+
+    def run(self) -> None:
+        self.build()
+        outfiles = self.install()
+        if outfiles is not None:
+            # always compile, in case we have any extension stubs to deal with
+            self.byte_compile(outfiles)
+
+    def get_exclusions(self):
+        """
+        Return a collections.Sized collections.Container of paths to be
+        excluded for single_version_externally_managed installations.
+        """
+        all_packages = (
+            pkg
+            for ns_pkg in self._get_SVEM_NSPs()
+            for pkg in self._all_packages(ns_pkg)
+        )
+
+        excl_specs = product(all_packages, self._gen_exclusion_paths())
+        return set(starmap(self._exclude_pkg_path, excl_specs))
+
+    def _exclude_pkg_path(self, pkg, exclusion_path):
+        """
+        Given a package name and exclusion path within that package,
+        compute the full exclusion path.
+        """
+        parts = pkg.split('.') + [exclusion_path]
+        return os.path.join(self.install_dir, *parts)
+
+    @staticmethod
+    def _all_packages(pkg_name):
+        """
+        >>> list(install_lib._all_packages('foo.bar.baz'))
+        ['foo.bar.baz', 'foo.bar', 'foo']
+        """
+        while pkg_name:
+            yield pkg_name
+            pkg_name, _sep, _child = pkg_name.rpartition('.')
+
+    def _get_SVEM_NSPs(self):
+        """
+        Get namespace packages (list) but only for
+        single_version_externally_managed installations and empty otherwise.
+        """
+        # TODO: is it necessary to short-circuit here? i.e. what's the cost
+        # if get_finalized_command is called even when namespace_packages is
+        # False?
+        if not self.distribution.namespace_packages:
+            return []
+
+        install_cmd = self.get_finalized_command('install')
+        svem = install_cmd.single_version_externally_managed
+
+        return self.distribution.namespace_packages if svem else []
+
+    @staticmethod
+    def _gen_exclusion_paths():
+        """
+        Generate file paths to be excluded for namespace packages (bytecode
+        cache files).
+        """
+        # always exclude the package module itself
+        yield '__init__.py'
+
+        yield '__init__.pyc'
+        yield '__init__.pyo'
+
+        if not hasattr(sys, 'implementation'):
+            return
+
+        base = os.path.join('__pycache__', '__init__.' + sys.implementation.cache_tag)
+        yield base + '.pyc'
+        yield base + '.pyo'
+        yield base + '.opt-1.pyc'
+        yield base + '.opt-2.pyc'
+
+    def copy_tree(
+        self,
+        infile: StrPath,
+        outfile: str,
+        # override: Using actual booleans
+        preserve_mode: bool = True,  # type: ignore[override]
+        preserve_times: bool = True,  # type: ignore[override]
+        preserve_symlinks: bool = False,  # type: ignore[override]
+        level: object = 1,
+    ) -> list[str]:
+        assert preserve_mode
+        assert preserve_times
+        assert not preserve_symlinks
+        exclude = self.get_exclusions()
+
+        if not exclude:
+            return orig.install_lib.copy_tree(self, infile, outfile)
+
+        # Exclude namespace package __init__.py* files from the output
+
+        from setuptools.archive_util import unpack_directory
+
+        from distutils import log
+
+        outfiles: list[str] = []
+
+        def pf(src: str, dst: str):
+            if dst in exclude:
+                log.warn("Skipping installation of %s (namespace package)", dst)
+                return False
+
+            log.info("copying %s -> %s", src, os.path.dirname(dst))
+            outfiles.append(dst)
+            return dst
+
+        unpack_directory(infile, outfile, pf)
+        return outfiles
+
+    def get_outputs(self):
+        outputs = orig.install_lib.get_outputs(self)
+        exclude = self.get_exclusions()
+        if exclude:
+            return [f for f in outputs if f not in exclude]
+        return outputs
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/install_scripts.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/install_scripts.py
new file mode 100644
index 0000000000000000000000000000000000000000..5d7d3869ec5cf53dabab4c79fcddbe0618ad38cf
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/install_scripts.py
@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import os
+import sys
+
+from .._path import ensure_directory
+from ..dist import Distribution
+
+import distutils.command.install_scripts as orig
+from distutils import log
+
+
+class install_scripts(orig.install_scripts):
+    """Do normal script install, plus any egg_info wrapper scripts"""
+
+    distribution: Distribution  # override distutils.dist.Distribution with setuptools.dist.Distribution
+
+    def initialize_options(self) -> None:
+        orig.install_scripts.initialize_options(self)
+        self.no_ep = False
+
+    def run(self) -> None:
+        self.run_command("egg_info")
+        if self.distribution.scripts:
+            orig.install_scripts.run(self)  # run first to set up self.outfiles
+        else:
+            self.outfiles: list[str] = []
+        if self.no_ep:
+            # don't install entry point scripts into .egg file!
+            return
+        self._install_ep_scripts()
+
+    def _install_ep_scripts(self):
+        # Delay import side-effects
+        from .. import _scripts
+        from .._importlib import metadata
+
+        ei_cmd = self.get_finalized_command("egg_info")
+        dist = metadata.Distribution.at(path=ei_cmd.egg_info)
+        bs_cmd = self.get_finalized_command('build_scripts')
+        exec_param = getattr(bs_cmd, 'executable', None)
+        writer = _scripts.ScriptWriter
+        if exec_param == sys.executable:
+            # In case the path to the Python executable contains a space, wrap
+            # it so it's not split up.
+            exec_param = [exec_param]
+        # resolve the writer to the environment
+        writer = writer.best()
+        cmd = writer.command_spec_class.best().from_param(exec_param)
+        for args in writer.get_args(dist, cmd.as_header()):
+            self.write_script(*args)
+
+    def write_script(self, script_name, contents, mode: str = "t", *ignored) -> None:
+        """Write an executable file to the scripts directory"""
+        from .._shutil import attempt_chmod_verbose as chmod, current_umask
+
+        log.info("Installing %s script to %s", script_name, self.install_dir)
+        target = os.path.join(self.install_dir, script_name)
+        self.outfiles.append(target)
+
+        encoding = None if "b" in mode else "utf-8"
+        mask = current_umask()
+        ensure_directory(target)
+        with open(target, "w" + mode, encoding=encoding) as f:
+            f.write(contents)
+        chmod(target, 0o777 - mask)
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/rotate.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/rotate.py
new file mode 100644
index 0000000000000000000000000000000000000000..9ff72f56006303ed521ef42c227c78a38804f851
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/rotate.py
@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import os
+from typing import ClassVar
+
+from .. import Command, _shutil
+
+from distutils import log
+from distutils.errors import DistutilsOptionError
+from distutils.util import convert_path
+
+
+class rotate(Command):
+    """Delete older distributions"""
+
+    description = "delete older distributions, keeping N newest files"
+    user_options = [
+        ('match=', 'm', "patterns to match (required)"),
+        ('dist-dir=', 'd', "directory where the distributions are"),
+        ('keep=', 'k', "number of matching distributions to keep"),
+    ]
+
+    boolean_options: ClassVar[list[str]] = []
+
+    def initialize_options(self):
+        self.match = None
+        self.dist_dir = None
+        self.keep = None
+
+    def finalize_options(self) -> None:
+        if self.match is None:
+            raise DistutilsOptionError(
+                "Must specify one or more (comma-separated) match patterns "
+                "(e.g. '.zip' or '.egg')"
+            )
+        if self.keep is None:
+            raise DistutilsOptionError("Must specify number of files to keep")
+        try:
+            self.keep = int(self.keep)
+        except ValueError as e:
+            raise DistutilsOptionError("--keep must be an integer") from e
+        if isinstance(self.match, str):
+            self.match = [convert_path(p.strip()) for p in self.match.split(',')]
+        self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
+
+    def run(self) -> None:
+        self.run_command("egg_info")
+        from glob import glob
+
+        for pattern in self.match:
+            pattern = self.distribution.get_name() + '*' + pattern
+            files = glob(os.path.join(self.dist_dir, pattern))
+            files = [(os.path.getmtime(f), f) for f in files]
+            files.sort()
+            files.reverse()
+
+            log.info("%d file(s) matching %s", len(files), pattern)
+            files = files[self.keep :]
+            for t, f in files:
+                log.info("Deleting %s", f)
+                if os.path.isdir(f):
+                    _shutil.rmtree(f)
+                else:
+                    os.unlink(f)
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/saveopts.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/saveopts.py
new file mode 100644
index 0000000000000000000000000000000000000000..76c3cdbf3795d391f1180073d224c9becae174fc
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/saveopts.py
@@ -0,0 +1,21 @@
+from setuptools.command.setopt import edit_config, option_base
+
+
+class saveopts(option_base):
+    """Save command-line options to a file"""
+
+    description = "save supplied options to setup.cfg or other config file"
+
+    def run(self) -> None:
+        dist = self.distribution
+        settings: dict[str, dict[str, str]] = {}
+
+        for cmd in dist.command_options:
+            if cmd == 'saveopts':
+                continue  # don't save our own options!
+
+            for opt, (src, val) in dist.get_option_dict(cmd).items():
+                if src == "command line":
+                    settings.setdefault(cmd, {})[opt] = val
+
+        edit_config(self.filename, settings)
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/sdist.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/sdist.py
new file mode 100644
index 0000000000000000000000000000000000000000..17279ac421fce8cb8e062048549615e7f36aea9d
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/sdist.py
@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+import contextlib
+import os
+import re
+from collections.abc import Iterator
+from itertools import chain
+from typing import ClassVar
+
+from .._importlib import metadata
+from ..dist import Distribution
+from .build import _ORIGINAL_SUBCOMMANDS
+
+import distutils.command.sdist as orig
+from distutils import log
+
+_default_revctrl = list
+
+
+def walk_revctrl(dirname='') -> Iterator:
+    """Find all files under revision control"""
+    for ep in metadata.entry_points(group='setuptools.file_finders'):
+        yield from ep.load()(dirname)
+
+
+class sdist(orig.sdist):
+    """Smart sdist that finds anything supported by revision control"""
+
+    user_options = [
+        ('formats=', None, "formats for source distribution (comma-separated list)"),
+        (
+            'keep-temp',
+            'k',
+            "keep the distribution tree around after creating archive file(s)",
+        ),
+        (
+            'dist-dir=',
+            'd',
+            "directory to put the source distribution archive(s) in [default: dist]",
+        ),
+        (
+            'owner=',
+            'u',
+            "Owner name used when creating a tar file [default: current user]",
+        ),
+        (
+            'group=',
+            'g',
+            "Group name used when creating a tar file [default: current group]",
+        ),
+    ]
+
+    distribution: Distribution  # override distutils.dist.Distribution with setuptools.dist.Distribution
+    negative_opt: ClassVar[dict[str, str]] = {}
+
+    README_EXTENSIONS = ['', '.rst', '.txt', '.md']
+    READMES = tuple(f'README{ext}' for ext in README_EXTENSIONS)
+
+    def run(self) -> None:
+        self.run_command('egg_info')
+        ei_cmd = self.get_finalized_command('egg_info')
+        self.filelist = ei_cmd.filelist
+        self.filelist.append(os.path.join(ei_cmd.egg_info, 'SOURCES.txt'))
+        self.check_readme()
+
+        # Run sub commands
+        for cmd_name in self.get_sub_commands():
+            self.run_command(cmd_name)
+
+        self.make_distribution()
+
+        dist_files = getattr(self.distribution, 'dist_files', [])
+        for file in self.archive_files:
+            data = ('sdist', '', file)
+            if data not in dist_files:
+                dist_files.append(data)
+
+    def initialize_options(self) -> None:
+        orig.sdist.initialize_options(self)
+
+    def make_distribution(self) -> None:
+        """
+        Workaround for #516
+        """
+        with self._remove_os_link():
+            orig.sdist.make_distribution(self)
+
+    @staticmethod
+    @contextlib.contextmanager
+    def _remove_os_link():
+        """
+        In a context, remove and restore os.link if it exists
+        """
+
+        class NoValue:
+            pass
+
+        orig_val = getattr(os, 'link', NoValue)
+        try:
+            del os.link
+        except Exception:
+            pass
+        try:
+            yield
+        finally:
+            if orig_val is not NoValue:
+                os.link = orig_val
+
+    def add_defaults(self) -> None:
+        super().add_defaults()
+        self._add_defaults_build_sub_commands()
+
+    def _add_defaults_optional(self):
+        super()._add_defaults_optional()
+        if os.path.isfile('pyproject.toml'):
+            self.filelist.append('pyproject.toml')
+
+    def _add_defaults_python(self):
+        """getting python files"""
+        if self.distribution.has_pure_modules():
+            build_py = self.get_finalized_command('build_py')
+            self.filelist.extend(build_py.get_source_files())
+            self._add_data_files(self._safe_data_files(build_py))
+
+    def _add_defaults_build_sub_commands(self):
+        build = self.get_finalized_command("build")
+        missing_cmds = set(build.get_sub_commands()) - _ORIGINAL_SUBCOMMANDS
+        # ^-- the original built-in sub-commands are already handled by default.
+        cmds = (self.get_finalized_command(c) for c in missing_cmds)
+        files = (c.get_source_files() for c in cmds if hasattr(c, "get_source_files"))
+        self.filelist.extend(chain.from_iterable(files))
+
+    def _safe_data_files(self, build_py):
+        """
+        Since the ``sdist`` class is also used to compute the MANIFEST
+        (via :obj:`setuptools.command.egg_info.manifest_maker`),
+        there might be recursion problems when trying to obtain the list of
+        data_files and ``include_package_data=True`` (which in turn depends on
+        the files included in the MANIFEST).
+
+        To avoid that, ``manifest_maker`` should be able to overwrite this
+        method and avoid recursive attempts to build/analyze the MANIFEST.
+        """
+        return build_py.data_files
+
+    def _add_data_files(self, data_files):
+        """
+        Add data files as found in build_py.data_files.
+        """
+        self.filelist.extend(
+            os.path.join(src_dir, name)
+            for _, src_dir, _, filenames in data_files
+            for name in filenames
+        )
+
+    def _add_defaults_data_files(self):
+        try:
+            super()._add_defaults_data_files()
+        except TypeError:
+            log.warn("data_files contains unexpected objects")
+
+    def prune_file_list(self) -> None:
+        super().prune_file_list()
+        # Prevent accidental inclusion of test-related cache dirs at the project root
+        sep = re.escape(os.sep)
+        self.filelist.exclude_pattern(r"^(\.tox|\.nox|\.venv)" + sep, is_regex=True)
+
+    def check_readme(self) -> None:
+        for f in self.READMES:
+            if os.path.exists(f):
+                return
+        else:
+            self.warn(
+                "standard file not found: should have one of " + ', '.join(self.READMES)
+            )
+
+    def make_release_tree(self, base_dir, files) -> None:
+        orig.sdist.make_release_tree(self, base_dir, files)
+
+        # Save any egg_info command line options used to create this sdist
+        dest = os.path.join(base_dir, 'setup.cfg')
+        if hasattr(os, 'link') and os.path.exists(dest):
+            # unlink and re-copy, since it might be hard-linked, and
+            # we don't want to change the source version
+            os.unlink(dest)
+            self.copy_file('setup.cfg', dest)
+
+        self.get_finalized_command('egg_info').save_version_info(dest)
+
+    def _manifest_is_not_generated(self):
+        # check for special comment used in 2.7.1 and higher
+        if not os.path.isfile(self.manifest):
+            return False
+
+        with open(self.manifest, 'rb') as fp:
+            first_line = fp.readline()
+        return first_line != b'# file GENERATED by distutils, do NOT edit\n'
+
+    def read_manifest(self) -> None:
+        """Read the manifest file (named by 'self.manifest') and use it to
+        fill in 'self.filelist', the list of files to include in the source
+        distribution.
+        """
+        log.info("reading manifest file '%s'", self.manifest)
+        manifest = open(self.manifest, 'rb')
+        for bytes_line in manifest:
+            # The manifest must contain UTF-8. See #303.
+            try:
+                line = bytes_line.decode('UTF-8')
+            except UnicodeDecodeError:
+                log.warn(f"{line!r} not UTF-8 decodable -- skipping")
+                continue
+            # ignore comments and blank lines
+            line = line.strip()
+            if line.startswith('#') or not line:
+                continue
+            self.filelist.append(line)
+        manifest.close()
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/setopt.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/setopt.py
new file mode 100644
index 0000000000000000000000000000000000000000..349041ecb65ce06671286bc142c27eb5102f2fbc
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/setopt.py
@@ -0,0 +1,139 @@
+import configparser
+import os
+
+from .. import Command
+from ..unicode_utils import _cfg_read_utf8_with_fallback
+
+import distutils
+from distutils import log
+from distutils.errors import DistutilsOptionError
+from distutils.util import convert_path
+
+__all__ = ['config_file', 'edit_config', 'option_base', 'setopt']
+
+
+def config_file(kind="local"):
+    """Get the filename of the distutils, local, global, or per-user config
+
+    `kind` must be one of "local", "global", or "user"
+    """
+    if kind == 'local':
+        return 'setup.cfg'
+    if kind == 'global':
+        return os.path.join(os.path.dirname(distutils.__file__), 'distutils.cfg')
+    if kind == 'user':
+        dot = os.name == 'posix' and '.' or ''
+        return os.path.expanduser(convert_path(f"~/{dot}pydistutils.cfg"))
+    raise ValueError("config_file() type must be 'local', 'global', or 'user'", kind)
+
+
+def edit_config(filename, settings) -> None:
+    """Edit a configuration file to include `settings`
+
+    `settings` is a dictionary of dictionaries or ``None`` values, keyed by
+    command/section name.  A ``None`` value means to delete the entire section,
+    while a dictionary lists settings to be changed or deleted in that section.
+    A setting of ``None`` means to delete that setting.
+    """
+    log.debug("Reading configuration from %s", filename)
+    opts = configparser.RawConfigParser()
+    opts.optionxform = lambda optionstr: optionstr  # type: ignore[method-assign] # overriding method
+    _cfg_read_utf8_with_fallback(opts, filename)
+
+    for section, options in settings.items():
+        if options is None:
+            log.info("Deleting section [%s] from %s", section, filename)
+            opts.remove_section(section)
+        else:
+            if not opts.has_section(section):
+                log.debug("Adding new section [%s] to %s", section, filename)
+                opts.add_section(section)
+            for option, value in options.items():
+                if value is None:
+                    log.debug("Deleting %s.%s from %s", section, option, filename)
+                    opts.remove_option(section, option)
+                    if not opts.options(section):
+                        log.info(
+                            "Deleting empty [%s] section from %s", section, filename
+                        )
+                        opts.remove_section(section)
+                else:
+                    log.debug(
+                        "Setting %s.%s to %r in %s", section, option, value, filename
+                    )
+                    opts.set(section, option, value)
+
+    log.info("Writing %s", filename)
+    with open(filename, 'w', encoding="utf-8") as f:
+        opts.write(f)
+
+
+class option_base(Command):
+    """Abstract base class for commands that mess with config files"""
+
+    user_options = [
+        ('global-config', 'g', "save options to the site-wide distutils.cfg file"),
+        ('user-config', 'u', "save options to the current user's pydistutils.cfg file"),
+        ('filename=', 'f', "configuration file to use (default=setup.cfg)"),
+    ]
+
+    boolean_options = [
+        'global-config',
+        'user-config',
+    ]
+
+    def initialize_options(self):
+        self.global_config = None
+        self.user_config = None
+        self.filename = None
+
+    def finalize_options(self) -> None:
+        filenames = []
+        if self.global_config:
+            filenames.append(config_file('global'))
+        if self.user_config:
+            filenames.append(config_file('user'))
+        if self.filename is not None:
+            filenames.append(self.filename)
+        if not filenames:
+            filenames.append(config_file('local'))
+        if len(filenames) > 1:
+            raise DistutilsOptionError(
+                "Must specify only one configuration file option", filenames
+            )
+        (self.filename,) = filenames
+
+
+class setopt(option_base):
+    """Save command-line options to a file"""
+
+    description = "set an option in setup.cfg or another config file"
+
+    user_options = [
+        ('command=', 'c', 'command to set an option for'),
+        ('option=', 'o', 'option to set'),
+        ('set-value=', 's', 'value of the option'),
+        ('remove', 'r', 'remove (unset) the value'),
+    ] + option_base.user_options
+
+    boolean_options = option_base.boolean_options + ['remove']
+
+    def initialize_options(self):
+        option_base.initialize_options(self)
+        self.command = None
+        self.option = None
+        self.set_value = None
+        self.remove = None
+
+    def finalize_options(self) -> None:
+        option_base.finalize_options(self)
+        if self.command is None or self.option is None:
+            raise DistutilsOptionError("Must specify --command *and* --option")
+        if self.set_value is None and not self.remove:
+            raise DistutilsOptionError("Must specify --set-value or --remove")
+
+    def run(self) -> None:
+        edit_config(
+            self.filename,
+            {self.command: {self.option.replace('-', '_'): self.set_value}},
+        )
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/command/test.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/test.py
new file mode 100644
index 0000000000000000000000000000000000000000..5d03c91102fa62d252adcbd858053e2e3d7ca7ef
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/command/test.py
@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import NoReturn
+
+from setuptools import Command
+from setuptools.warnings import SetuptoolsDeprecationWarning
+
+
+# Would restrict to Literal["test"], but mypy doesn't support it: https://github.com/python/mypy/issues/8203
+def __getattr__(name: str) -> type[_test]:
+    if name == 'test':
+        SetuptoolsDeprecationWarning.emit(
+            "The test command is disabled and references to it are deprecated.",
+            "Please remove any references to `setuptools.command.test` in all "
+            "supported versions of the affected package.",
+            due_date=(2024, 11, 15),
+            stacklevel=2,
+        )
+        return _test
+    raise AttributeError(name)
+
+
+class _test(Command):
+    """
+    Stub to warn when test command is referenced or used.
+    """
+
+    description = "stub for old test command (do not use)"
+
+    user_options = [
+        ('test-module=', 'm', "Run 'test_suite' in specified module"),
+        (
+            'test-suite=',
+            's',
+            "Run single test, case or suite (e.g. 'module.test_suite')",
+        ),
+        ('test-runner=', 'r', "Test runner to use"),
+    ]
+
+    def initialize_options(self) -> None:
+        pass
+
+    def finalize_options(self) -> None:
+        pass
+
+    def run(self) -> NoReturn:
+        raise RuntimeError("Support for the test command was removed in Setuptools 72")
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/compat/__init__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/compat/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/compat/py310.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/compat/py310.py
new file mode 100644
index 0000000000000000000000000000000000000000..58a4d9f36606d3be8c288418568b0f2e1ef8bcf2
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/compat/py310.py
@@ -0,0 +1,20 @@
+import sys
+
+__all__ = ['tomllib']
+
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:  # pragma: no cover
+    import tomli as tomllib
+
+
+if sys.version_info >= (3, 11):
+
+    def add_note(ex, note):
+        ex.add_note(note)
+
+else:  # pragma: no cover
+
+    def add_note(ex, note):
+        vars(ex).setdefault('__notes__', []).append(note)
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/compat/py311.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/compat/py311.py
new file mode 100644
index 0000000000000000000000000000000000000000..52b58af32a28817deeaf592cc795f311434e39e7
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/compat/py311.py
@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import shutil
+import sys
+from typing import TYPE_CHECKING, Any, Callable
+
+if TYPE_CHECKING:
+    from _typeshed import ExcInfo, StrOrBytesPath
+    from typing_extensions import TypeAlias
+
+# Same as shutil._OnExcCallback from typeshed
+_OnExcCallback: TypeAlias = Callable[[Callable[..., Any], str, BaseException], object]
+
+
+def shutil_rmtree(
+    path: StrOrBytesPath,
+    ignore_errors: bool = False,
+    onexc: _OnExcCallback | None = None,
+) -> None:
+    if sys.version_info >= (3, 12):
+        return shutil.rmtree(path, ignore_errors, onexc=onexc)
+
+    def _handler(fn: Callable[..., Any], path: str, excinfo: ExcInfo) -> None:
+        if onexc:
+            onexc(fn, path, excinfo[1])
+
+    return shutil.rmtree(path, ignore_errors, onerror=_handler)
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/compat/py312.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/compat/py312.py
new file mode 100644
index 0000000000000000000000000000000000000000..b20c5f697a861a680c4a747baf9ca9c901e72978
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/compat/py312.py
@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+import sys
+
+if sys.version_info >= (3, 12, 4):
+    # Python 3.13 should support `.pth` files encoded in UTF-8
+    # See discussion in https://github.com/python/cpython/issues/77102
+    PTH_ENCODING: str | None = "utf-8"
+else:
+    from .py39 import LOCALE_ENCODING
+
+    # PTH_ENCODING = "locale"
+    PTH_ENCODING = LOCALE_ENCODING
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/compat/py39.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/compat/py39.py
new file mode 100644
index 0000000000000000000000000000000000000000..04a4abe5a9e61596f97dc3d1b0b3da93a558158f
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/compat/py39.py
@@ -0,0 +1,9 @@
+import sys
+
+# Explicitly use the ``"locale"`` encoding in versions that support it,
+# otherwise just rely on the implicit handling of ``encoding=None``.
+# Since all platforms that support ``EncodingWarning`` also support
+# ``encoding="locale"``, this can be used to suppress the warning.
+# However, please try to use UTF-8 when possible
+# (.pth files are the notorious exception: python/cpython#77102, pypa/setuptools#3937).
+LOCALE_ENCODING = "locale" if sys.version_info >= (3, 10) else None
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/config/NOTICE b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/NOTICE
new file mode 100644
index 0000000000000000000000000000000000000000..01864511b0f52a6bf944f70b5e15b75364791935
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/NOTICE
@@ -0,0 +1,10 @@
+The following files include code from opensource projects
+(either as direct copies or modified versions):
+
+- `setuptools.schema.json`, `distutils.schema.json`:
+    - project: `validate-pyproject` - licensed under MPL-2.0
+      (https://github.com/abravalheri/validate-pyproject):
+
+      This Source Code Form is subject to the terms of the Mozilla Public
+      License, v. 2.0. If a copy of the MPL was not distributed with this file,
+      You can obtain one at https://mozilla.org/MPL/2.0/.
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/config/__init__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..fcc7d008d6c9b3ab2610f2a1b05c4c1eeb5e1416
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/__init__.py
@@ -0,0 +1,43 @@
+"""For backward compatibility, expose main functions from
+``setuptools.config.setupcfg``
+"""
+
+from functools import wraps
+from typing import Callable, TypeVar, cast
+
+from ..warnings import SetuptoolsDeprecationWarning
+from . import setupcfg
+
+Fn = TypeVar("Fn", bound=Callable)
+
+__all__ = ('parse_configuration', 'read_configuration')
+
+
+def _deprecation_notice(fn: Fn) -> Fn:
+    @wraps(fn)
+    def _wrapper(*args, **kwargs):
+        SetuptoolsDeprecationWarning.emit(
+            "Deprecated API usage.",
+            f"""
+            As setuptools moves its configuration towards `pyproject.toml`,
+            `{__name__}.{fn.__name__}` became deprecated.
+
+            For the time being, you can use the `{setupcfg.__name__}` module
+            to access a backward compatible API, but this module is provisional
+            and might be removed in the future.
+
+            To read project metadata, consider using
+            ``build.util.project_wheel_metadata`` (https://pypi.org/project/build/).
+            For simple scenarios, you can also try parsing the file directly
+            with the help of ``configparser``.
+            """,
+            # due_date not defined yet, because the community still heavily relies on it
+            # Warning introduced in 24 Mar 2022
+        )
+        return fn(*args, **kwargs)
+
+    return cast(Fn, _wrapper)
+
+
+read_configuration = _deprecation_notice(setupcfg.read_configuration)
+parse_configuration = _deprecation_notice(setupcfg.parse_configuration)
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/config/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1633d4be22f26833b08fa67409b4251509dc9805
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/config/__pycache__/_apply_pyprojecttoml.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/__pycache__/_apply_pyprojecttoml.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..11b29d9f0f4d56e0e877a1c753a22cb81d1f9c07
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/__pycache__/_apply_pyprojecttoml.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/config/__pycache__/expand.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/__pycache__/expand.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3839529e0041594299ee2ce11ab61d208dee3dd9
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/__pycache__/expand.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/config/__pycache__/pyprojecttoml.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/__pycache__/pyprojecttoml.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7bb74a1a54f4ebec1ddf7020da077e58faf8c013
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/__pycache__/pyprojecttoml.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/config/__pycache__/setupcfg.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/__pycache__/setupcfg.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..58abec456b6667db4830f40f47b3258de1e4fd60
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/__pycache__/setupcfg.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_apply_pyprojecttoml.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_apply_pyprojecttoml.py
new file mode 100644
index 0000000000000000000000000000000000000000..4559193774fabc6c381f4cec2c725d9b805de1b4
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_apply_pyprojecttoml.py
@@ -0,0 +1,534 @@
+"""Translation layer between pyproject config and setuptools distribution and
+metadata objects.
+
+The distribution and metadata objects are modeled after (an old version of)
+core metadata, therefore configs in the format specified for ``pyproject.toml``
+need to be processed before being applied.
+
+**PRIVATE MODULE**: API reserved for setuptools internal usage only.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from collections.abc import Mapping
+from email.headerregistry import Address
+from functools import partial, reduce
+from inspect import cleandoc
+from itertools import chain
+from types import MappingProxyType
+from typing import TYPE_CHECKING, Any, Callable, TypeVar, Union
+
+from .. import _static
+from .._path import StrPath
+from ..errors import InvalidConfigError, RemovedConfigError
+from ..extension import Extension
+from ..warnings import SetuptoolsDeprecationWarning, SetuptoolsWarning
+
+if TYPE_CHECKING:
+    from typing_extensions import TypeAlias
+
+    from setuptools._importlib import metadata
+    from setuptools.dist import Distribution
+
+    from distutils.dist import _OptionsList  # Comes from typeshed
+
+
+EMPTY: Mapping = MappingProxyType({})  # Immutable dict-like
+_ProjectReadmeValue: TypeAlias = Union[str, dict[str, str]]
+_Correspondence: TypeAlias = Callable[["Distribution", Any, Union[StrPath, None]], None]
+_T = TypeVar("_T")
+
+_logger = logging.getLogger(__name__)
+
+
+def apply(dist: Distribution, config: dict, filename: StrPath) -> Distribution:
+    """Apply configuration dict read with :func:`read_configuration`"""
+
+    if not config:
+        return dist  # short-circuit unrelated pyproject.toml file
+
+    root_dir = os.path.dirname(filename) or "."
+
+    _apply_project_table(dist, config, root_dir)
+    _apply_tool_table(dist, config, filename)
+
+    current_directory = os.getcwd()
+    os.chdir(root_dir)
+    try:
+        dist._finalize_requires()
+        dist._finalize_license_expression()
+        dist._finalize_license_files()
+    finally:
+        os.chdir(current_directory)
+
+    return dist
+
+
+def _apply_project_table(dist: Distribution, config: dict, root_dir: StrPath):
+    orig_config = config.get("project", {})
+    if not orig_config:
+        return  # short-circuit
+
+    project_table = {k: _static.attempt_conversion(v) for k, v in orig_config.items()}
+    _handle_missing_dynamic(dist, project_table)
+    _unify_entry_points(project_table)
+
+    for field, value in project_table.items():
+        norm_key = json_compatible_key(field)
+        corresp = PYPROJECT_CORRESPONDENCE.get(norm_key, norm_key)
+        if callable(corresp):
+            corresp(dist, value, root_dir)
+        else:
+            _set_config(dist, corresp, value)
+
+
+def _apply_tool_table(dist: Distribution, config: dict, filename: StrPath):
+    tool_table = config.get("tool", {}).get("setuptools", {})
+    if not tool_table:
+        return  # short-circuit
+
+    if "license-files" in tool_table:
+        if "license-files" in config.get("project", {}):
+            # https://github.com/pypa/setuptools/pull/4837#discussion_r2004983349
+            raise InvalidConfigError(
+                "'project.license-files' is defined already. "
+                "Remove 'tool.setuptools.license-files'."
+            )
+
+        pypa_guides = "guides/writing-pyproject-toml/#license-files"
+        SetuptoolsDeprecationWarning.emit(
+            "'tool.setuptools.license-files' is deprecated in favor of "
+            "'project.license-files' (available on setuptools>=77.0.0).",
+            see_url=f"https://packaging.python.org/en/latest/{pypa_guides}",
+            due_date=(2027, 2, 18),  # Warning introduced on 2025-02-18
+        )
+
+    for field, value in tool_table.items():
+        norm_key = json_compatible_key(field)
+
+        if norm_key in TOOL_TABLE_REMOVALS:
+            suggestion = cleandoc(TOOL_TABLE_REMOVALS[norm_key])
+            msg = f"""
+            The parameter `tool.setuptools.{field}` was long deprecated
+            and has been removed from `pyproject.toml`.
+            """
+            raise RemovedConfigError("\n".join([cleandoc(msg), suggestion]))
+
+        norm_key = TOOL_TABLE_RENAMES.get(norm_key, norm_key)
+        corresp = TOOL_TABLE_CORRESPONDENCE.get(norm_key, norm_key)
+        if callable(corresp):
+            corresp(dist, value)
+        else:
+            _set_config(dist, corresp, value)
+
+    _copy_command_options(config, dist, filename)
+
+
+def _handle_missing_dynamic(dist: Distribution, project_table: dict):
+    """Be temporarily forgiving with ``dynamic`` fields not listed in ``dynamic``"""
+    dynamic = set(project_table.get("dynamic", []))
+    for field, getter in _PREVIOUSLY_DEFINED.items():
+        if not (field in project_table or field in dynamic):
+            value = getter(dist)
+            if value:
+                _MissingDynamic.emit(field=field, value=value)
+                project_table[field] = _RESET_PREVIOUSLY_DEFINED.get(field)
+
+
+def json_compatible_key(key: str) -> str:
+    """As defined in :pep:`566#json-compatible-metadata`"""
+    return key.lower().replace("-", "_")
+
+
+def _set_config(dist: Distribution, field: str, value: Any):
+    val = _PREPROCESS.get(field, _noop)(dist, value)
+    setter = getattr(dist.metadata, f"set_{field}", None)
+    if setter:
+        setter(val)
+    elif hasattr(dist.metadata, field) or field in SETUPTOOLS_PATCHES:
+        setattr(dist.metadata, field, val)
+    else:
+        setattr(dist, field, val)
+
+
+_CONTENT_TYPES = {
+    ".md": "text/markdown",
+    ".rst": "text/x-rst",
+    ".txt": "text/plain",
+}
+
+
+def _guess_content_type(file: str) -> str | None:
+    _, ext = os.path.splitext(file.lower())
+    if not ext:
+        return None
+
+    if ext in _CONTENT_TYPES:
+        return _static.Str(_CONTENT_TYPES[ext])
+
+    valid = ", ".join(f"{k} ({v})" for k, v in _CONTENT_TYPES.items())
+    msg = f"only the following file extensions are recognized: {valid}."
+    raise ValueError(f"Undefined content type for {file}, {msg}")
+
+
+def _long_description(
+    dist: Distribution, val: _ProjectReadmeValue, root_dir: StrPath | None
+):
+    from setuptools.config import expand
+
+    file: str | tuple[()]
+    if isinstance(val, str):
+        file = val
+        text = expand.read_files(file, root_dir)
+        ctype = _guess_content_type(file)
+    else:
+        file = val.get("file") or ()
+        text = val.get("text") or expand.read_files(file, root_dir)
+        ctype = val["content-type"]
+
+    # XXX: Is it completely safe to assume static?
+    _set_config(dist, "long_description", _static.Str(text))
+
+    if ctype:
+        _set_config(dist, "long_description_content_type", _static.Str(ctype))
+
+    if file:
+        dist._referenced_files.add(file)
+
+
+def _license(dist: Distribution, val: str | dict, root_dir: StrPath | None):
+    from setuptools.config import expand
+
+    if isinstance(val, str):
+        if getattr(dist.metadata, "license", None):
+            SetuptoolsWarning.emit("`license` overwritten by `pyproject.toml`")
+            dist.metadata.license = None
+        _set_config(dist, "license_expression", _static.Str(val))
+    else:
+        pypa_guides = "guides/writing-pyproject-toml/#license"
+        SetuptoolsDeprecationWarning.emit(
+            "`project.license` as a TOML table is deprecated",
+            "Please use a simple string containing a SPDX expression for "
+            "`project.license`. You can also use `project.license-files`. "
+            "(Both options available on setuptools>=77.0.0).",
+            see_url=f"https://packaging.python.org/en/latest/{pypa_guides}",
+            due_date=(2027, 2, 18),  # Introduced on 2025-02-18
+        )
+        if "file" in val:
+            # XXX: Is it completely safe to assume static?
+            value = expand.read_files([val["file"]], root_dir)
+            _set_config(dist, "license", _static.Str(value))
+            dist._referenced_files.add(val["file"])
+        else:
+            _set_config(dist, "license", _static.Str(val["text"]))
+
+
+def _people(dist: Distribution, val: list[dict], _root_dir: StrPath | None, kind: str):
+    field = []
+    email_field = []
+    for person in val:
+        if "name" not in person:
+            email_field.append(person["email"])
+        elif "email" not in person:
+            field.append(person["name"])
+        else:
+            addr = Address(display_name=person["name"], addr_spec=person["email"])
+            email_field.append(str(addr))
+
+    if field:
+        _set_config(dist, kind, _static.Str(", ".join(field)))
+    if email_field:
+        _set_config(dist, f"{kind}_email", _static.Str(", ".join(email_field)))
+
+
+def _project_urls(dist: Distribution, val: dict, _root_dir: StrPath | None):
+    _set_config(dist, "project_urls", val)
+
+
+def _python_requires(dist: Distribution, val: str, _root_dir: StrPath | None):
+    _set_config(dist, "python_requires", _static.SpecifierSet(val))
+
+
+def _dependencies(dist: Distribution, val: list, _root_dir: StrPath | None):
+    if getattr(dist, "install_requires", []):
+        msg = "`install_requires` overwritten in `pyproject.toml` (dependencies)"
+        SetuptoolsWarning.emit(msg)
+    dist.install_requires = val
+
+
+def _optional_dependencies(dist: Distribution, val: dict, _root_dir: StrPath | None):
+    if getattr(dist, "extras_require", None):
+        msg = "`extras_require` overwritten in `pyproject.toml` (optional-dependencies)"
+        SetuptoolsWarning.emit(msg)
+    dist.extras_require = val
+
+
+def _ext_modules(dist: Distribution, val: list[dict]) -> list[Extension]:
+    existing = dist.ext_modules or []
+    args = ({k.replace("-", "_"): v for k, v in x.items()} for x in val)
+    new = (Extension(**_adjust_ext_attrs(kw)) for kw in args)
+    return [*existing, *new]
+
+
+def _adjust_ext_attrs(attrs: dict) -> dict:
+    # https://github.com/pypa/setuptools/issues/4810
+    # In TOML there is no differentiation between tuples and lists,
+    # and distutils requires tuples...
+    attrs["define_macros"] = list(map(tuple, attrs.get("define_macros") or []))
+    return attrs
+
+
+def _noop(_dist: Distribution, val: _T) -> _T:
+    return val
+
+
+def _identity(val: _T) -> _T:
+    return val
+
+
+def _unify_entry_points(project_table: dict):
+    project = project_table
+    given = project.pop("entry-points", project.pop("entry_points", {}))
+    entry_points = dict(given)  # Avoid problems with static
+    renaming = {"scripts": "console_scripts", "gui_scripts": "gui_scripts"}
+    for key, value in list(project.items()):  # eager to allow modifications
+        norm_key = json_compatible_key(key)
+        if norm_key in renaming:
+            # Don't skip even if value is empty (reason: reset missing `dynamic`)
+            entry_points[renaming[norm_key]] = project.pop(key)
+
+    if entry_points:
+        project["entry-points"] = {
+            name: [f"{k} = {v}" for k, v in group.items()]
+            for name, group in entry_points.items()
+            if group  # now we can skip empty groups
+        }
+        # Sometimes this will set `project["entry-points"] = {}`, and that is
+        # intentional (for resetting configurations that are missing `dynamic`).
+
+
+def _copy_command_options(pyproject: dict, dist: Distribution, filename: StrPath):
+    tool_table = pyproject.get("tool", {})
+    cmdclass = tool_table.get("setuptools", {}).get("cmdclass", {})
+    valid_options = _valid_command_options(cmdclass)
+
+    cmd_opts = dist.command_options
+    for cmd, config in pyproject.get("tool", {}).get("distutils", {}).items():
+        cmd = json_compatible_key(cmd)
+        valid = valid_options.get(cmd, set())
+        cmd_opts.setdefault(cmd, {})
+        for key, value in config.items():
+            key = json_compatible_key(key)
+            cmd_opts[cmd][key] = (str(filename), value)
+            if key not in valid:
+                # To avoid removing options that are specified dynamically we
+                # just log a warn...
+                _logger.warning(f"Command option {cmd}.{key} is not defined")
+
+
+def _valid_command_options(cmdclass: Mapping = EMPTY) -> dict[str, set[str]]:
+    from setuptools.dist import Distribution
+
+    from .._importlib import metadata
+
+    valid_options = {"global": _normalise_cmd_options(Distribution.global_options)}
+
+    unloaded_entry_points = metadata.entry_points(group='distutils.commands')
+    loaded_entry_points = (_load_ep(ep) for ep in unloaded_entry_points)
+    entry_points = (ep for ep in loaded_entry_points if ep)
+    for cmd, cmd_class in chain(entry_points, cmdclass.items()):
+        opts = valid_options.get(cmd, set())
+        opts = opts | _normalise_cmd_options(getattr(cmd_class, "user_options", []))
+        valid_options[cmd] = opts
+
+    return valid_options
+
+
+def _load_ep(ep: metadata.EntryPoint) -> tuple[str, type] | None:
+    if ep.value.startswith("wheel.bdist_wheel"):
+        # Ignore deprecated entrypoint from wheel and avoid warning pypa/wheel#631
+        # TODO: remove check when `bdist_wheel` has been fully removed from pypa/wheel
+        return None
+
+    # Ignore all the errors
+    try:
+        return (ep.name, ep.load())
+    except Exception as ex:
+        msg = f"{ex.__class__.__name__} while trying to load entry-point {ep.name}"
+        _logger.warning(f"{msg}: {ex}")
+        return None
+
+
+def _normalise_cmd_option_key(name: str) -> str:
+    return json_compatible_key(name).strip("_=")
+
+
+def _normalise_cmd_options(desc: _OptionsList) -> set[str]:
+    return {_normalise_cmd_option_key(fancy_option[0]) for fancy_option in desc}
+
+
+def _get_previous_entrypoints(dist: Distribution) -> dict[str, list]:
+    ignore = ("console_scripts", "gui_scripts")
+    value = getattr(dist, "entry_points", None) or {}
+    return {k: v for k, v in value.items() if k not in ignore}
+
+
+def _get_previous_scripts(dist: Distribution) -> list | None:
+    value = getattr(dist, "entry_points", None) or {}
+    return value.get("console_scripts")
+
+
+def _get_previous_gui_scripts(dist: Distribution) -> list | None:
+    value = getattr(dist, "entry_points", None) or {}
+    return value.get("gui_scripts")
+
+
+def _set_static_list_metadata(attr: str, dist: Distribution, val: list) -> None:
+    """Apply distutils metadata validation but preserve "static" behaviour"""
+    meta = dist.metadata
+    setter, getter = getattr(meta, f"set_{attr}"), getattr(meta, f"get_{attr}")
+    setter(val)
+    setattr(meta, attr, _static.List(getter()))
+
+
+def _attrgetter(attr):
+    """
+    Similar to ``operator.attrgetter`` but returns None if ``attr`` is not found
+    >>> from types import SimpleNamespace
+    >>> obj = SimpleNamespace(a=42, b=SimpleNamespace(c=13))
+    >>> _attrgetter("a")(obj)
+    42
+    >>> _attrgetter("b.c")(obj)
+    13
+    >>> _attrgetter("d")(obj) is None
+    True
+    """
+    return partial(reduce, lambda acc, x: getattr(acc, x, None), attr.split("."))
+
+
+def _some_attrgetter(*items):
+    """
+    Return the first "truth-y" attribute or None
+    >>> from types import SimpleNamespace
+    >>> obj = SimpleNamespace(a=42, b=SimpleNamespace(c=13))
+    >>> _some_attrgetter("d", "a", "b.c")(obj)
+    42
+    >>> _some_attrgetter("d", "e", "b.c", "a")(obj)
+    13
+    >>> _some_attrgetter("d", "e", "f")(obj) is None
+    True
+    """
+
+    def _acessor(obj):
+        values = (_attrgetter(i)(obj) for i in items)
+        return next((i for i in values if i is not None), None)
+
+    return _acessor
+
+
+PYPROJECT_CORRESPONDENCE: dict[str, _Correspondence] = {
+    "readme": _long_description,
+    "license": _license,
+    "authors": partial(_people, kind="author"),
+    "maintainers": partial(_people, kind="maintainer"),
+    "urls": _project_urls,
+    "dependencies": _dependencies,
+    "optional_dependencies": _optional_dependencies,
+    "requires_python": _python_requires,
+}
+
+TOOL_TABLE_RENAMES = {"script_files": "scripts"}
+TOOL_TABLE_REMOVALS = {
+    "namespace_packages": """
+        Please migrate to implicit native namespaces instead.
+        See https://packaging.python.org/en/latest/guides/packaging-namespace-packages/.
+        """,
+}
+TOOL_TABLE_CORRESPONDENCE = {
+    # Fields with corresponding core metadata need to be marked as static:
+    "obsoletes": partial(_set_static_list_metadata, "obsoletes"),
+    "provides": partial(_set_static_list_metadata, "provides"),
+    "platforms": partial(_set_static_list_metadata, "platforms"),
+}
+
+SETUPTOOLS_PATCHES = {
+    "long_description_content_type",
+    "project_urls",
+    "provides_extras",
+    "license_file",
+    "license_files",
+    "license_expression",
+}
+
+_PREPROCESS = {
+    "ext_modules": _ext_modules,
+}
+
+_PREVIOUSLY_DEFINED = {
+    "name": _attrgetter("metadata.name"),
+    "version": _attrgetter("metadata.version"),
+    "description": _attrgetter("metadata.description"),
+    "readme": _attrgetter("metadata.long_description"),
+    "requires-python": _some_attrgetter("python_requires", "metadata.python_requires"),
+    "license": _some_attrgetter("metadata.license_expression", "metadata.license"),
+    # XXX: `license-file` is currently not considered in the context of `dynamic`.
+    #      See TestPresetField.test_license_files_exempt_from_dynamic
+    "authors": _some_attrgetter("metadata.author", "metadata.author_email"),
+    "maintainers": _some_attrgetter("metadata.maintainer", "metadata.maintainer_email"),
+    "keywords": _attrgetter("metadata.keywords"),
+    "classifiers": _attrgetter("metadata.classifiers"),
+    "urls": _attrgetter("metadata.project_urls"),
+    "entry-points": _get_previous_entrypoints,
+    "scripts": _get_previous_scripts,
+    "gui-scripts": _get_previous_gui_scripts,
+    "dependencies": _attrgetter("install_requires"),
+    "optional-dependencies": _attrgetter("extras_require"),
+}
+
+
+_RESET_PREVIOUSLY_DEFINED: dict = {
+    # Fix improper setting: given in `setup.py`, but not listed in `dynamic`
+    # Use "immutable" data structures to avoid in-place modification.
+    # dict: pyproject name => value to which reset
+    "license": "",
+    # XXX: `license-file` is currently not considered in the context of `dynamic`.
+    #      See TestPresetField.test_license_files_exempt_from_dynamic
+    "authors": _static.EMPTY_LIST,
+    "maintainers": _static.EMPTY_LIST,
+    "keywords": _static.EMPTY_LIST,
+    "classifiers": _static.EMPTY_LIST,
+    "urls": _static.EMPTY_DICT,
+    "entry-points": _static.EMPTY_DICT,
+    "scripts": _static.EMPTY_DICT,
+    "gui-scripts": _static.EMPTY_DICT,
+    "dependencies": _static.EMPTY_LIST,
+    "optional-dependencies": _static.EMPTY_DICT,
+}
+
+
+class _MissingDynamic(SetuptoolsWarning):
+    _SUMMARY = "`{field}` defined outside of `pyproject.toml` is ignored."
+
+    _DETAILS = """
+    The following seems to be defined outside of `pyproject.toml`:
+
+    `{field} = {value!r}`
+
+    According to the spec (see the link below), however, setuptools CANNOT
+    consider this value unless `{field}` is listed as `dynamic`.
+
+    https://packaging.python.org/en/latest/specifications/pyproject-toml/#declaring-project-metadata-the-project-table
+
+    To prevent this problem, you can list `{field}` under `dynamic` or alternatively
+    remove the `[project]` table from your file and rely entirely on other means of
+    configuration.
+    """
+    # TODO: Consider removing this check in the future?
+    #       There is a trade-off here between improving "debug-ability" and the cost
+    #       of running/testing/maintaining these unnecessary checks...
+
+    @classmethod
+    def details(cls, field: str, value: Any) -> str:
+        return cls._DETAILS.format(field=field, value=value)
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/NOTICE b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/NOTICE
new file mode 100644
index 0000000000000000000000000000000000000000..74e8821fc84b4d62796e08b3941c1a6e2017e1e8
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/NOTICE
@@ -0,0 +1,438 @@
+The code contained in this directory was automatically generated using the
+following command:
+
+    python -m validate_pyproject.pre_compile --output-dir=setuptools/config/_validate_pyproject --enable-plugins setuptools distutils --very-verbose -t distutils=setuptools/config/distutils.schema.json -t setuptools=setuptools/config/setuptools.schema.json
+
+Please avoid changing it manually.
+
+
+You can report issues or suggest changes directly to `validate-pyproject`
+(or to the relevant plugin repository)
+
+- https://github.com/abravalheri/validate-pyproject/issues
+
+
+***
+
+The following files include code from opensource projects
+(either as direct copies or modified versions):
+
+- `fastjsonschema_exceptions.py`:
+    - project: `fastjsonschema` - licensed under BSD-3-Clause
+      (https://github.com/horejsek/python-fastjsonschema)
+- `extra_validations.py` and `format.py`, `error_reporting.py`:
+    - project: `validate-pyproject` - licensed under MPL-2.0
+      (https://github.com/abravalheri/validate-pyproject)
+
+
+Additionally the following files are automatically generated by tools provided
+by the same projects:
+
+- `__init__.py`
+- `fastjsonschema_validations.py`
+
+The relevant copyright notes and licenses are included below.
+
+
+***
+
+`fastjsonschema`
+================
+
+Copyright (c) 2018, Michal Horejsek
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+  Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or
+  other materials provided with the distribution.
+
+  Neither the name of the {organization} nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+
+***
+
+`validate-pyproject`
+====================
+
+Mozilla Public License, version 2.0
+
+1. Definitions
+
+1.1. "Contributor"
+
+     means each individual or legal entity that creates, contributes to the
+     creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+
+     means the combination of the Contributions of others (if any) used by a
+     Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+
+     means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+
+     means Source Code Form to which the initial Contributor has attached the
+     notice in Exhibit A, the Executable Form of such Source Code Form, and
+     Modifications of such Source Code Form, in each case including portions
+     thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+     means
+
+     a. that the initial Contributor has attached the notice described in
+        Exhibit B to the Covered Software; or
+
+     b. that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the terms of
+        a Secondary License.
+
+1.6. "Executable Form"
+
+     means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+
+     means a work that combines Covered Software with other material, in a
+     separate file or files, that is not Covered Software.
+
+1.8. "License"
+
+     means this document.
+
+1.9. "Licensable"
+
+     means having the right to grant, to the maximum extent possible, whether
+     at the time of the initial grant or subsequently, any and all of the
+     rights conveyed by this License.
+
+1.10. "Modifications"
+
+     means any of the following:
+
+     a. any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered Software; or
+
+     b. any new file in Source Code Form that contains any Covered Software.
+
+1.11. "Patent Claims" of a Contributor
+
+      means any patent claim(s), including without limitation, method,
+      process, and apparatus claims, in any patent Licensable by such
+      Contributor that would be infringed, but for the grant of the License,
+      by the making, using, selling, offering for sale, having made, import,
+      or transfer of either its Contributions or its Contributor Version.
+
+1.12. "Secondary License"
+
+      means either the GNU General Public License, Version 2.0, the GNU Lesser
+      General Public License, Version 2.1, the GNU Affero General Public
+      License, Version 3.0, or any later versions of those licenses.
+
+1.13. "Source Code Form"
+
+      means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+
+      means an individual or a legal entity exercising rights under this
+      License. For legal entities, "You" includes any entity that controls, is
+      controlled by, or is under common control with You. For purposes of this
+      definition, "control" means (a) the power, direct or indirect, to cause
+      the direction or management of such entity, whether by contract or
+      otherwise, or (b) ownership of more than fifty percent (50%) of the
+      outstanding shares or beneficial ownership of such entity.
+
+
+2. License Grants and Conditions
+
+2.1. Grants
+
+     Each Contributor hereby grants You a world-wide, royalty-free,
+     non-exclusive license:
+
+     a. under intellectual property rights (other than patent or trademark)
+        Licensable by such Contributor to use, reproduce, make available,
+        modify, display, perform, distribute, and otherwise exploit its
+        Contributions, either on an unmodified basis, with Modifications, or
+        as part of a Larger Work; and
+
+     b. under Patent Claims of such Contributor to make, use, sell, offer for
+        sale, have made, import, and otherwise transfer either its
+        Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+     The licenses granted in Section 2.1 with respect to any Contribution
+     become effective for each Contribution on the date the Contributor first
+     distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+     The licenses granted in this Section 2 are the only rights granted under
+     this License. No additional rights or licenses will be implied from the
+     distribution or licensing of Covered Software under this License.
+     Notwithstanding Section 2.1(b) above, no patent license is granted by a
+     Contributor:
+
+     a. for any code that a Contributor has removed from Covered Software; or
+
+     b. for infringements caused by: (i) Your and any other third party's
+        modifications of Covered Software, or (ii) the combination of its
+        Contributions with other software (except as part of its Contributor
+        Version); or
+
+     c. under Patent Claims infringed by Covered Software in the absence of
+        its Contributions.
+
+     This License does not grant any rights in the trademarks, service marks,
+     or logos of any Contributor (except as may be necessary to comply with
+     the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+     No Contributor makes additional grants as a result of Your choice to
+     distribute the Covered Software under a subsequent version of this
+     License (see Section 10.2) or under the terms of a Secondary License (if
+     permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+     Each Contributor represents that the Contributor believes its
+     Contributions are its original creation(s) or it has sufficient rights to
+     grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+     This License is not intended to limit any rights You have under
+     applicable copyright doctrines of fair use, fair dealing, or other
+     equivalents.
+
+2.7. Conditions
+
+     Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in
+     Section 2.1.
+
+
+3. Responsibilities
+
+3.1. Distribution of Source Form
+
+     All distribution of Covered Software in Source Code Form, including any
+     Modifications that You create or to which You contribute, must be under
+     the terms of this License. You must inform recipients that the Source
+     Code Form of the Covered Software is governed by the terms of this
+     License, and how they can obtain a copy of this License. You may not
+     attempt to alter or restrict the recipients' rights in the Source Code
+     Form.
+
+3.2. Distribution of Executable Form
+
+     If You distribute Covered Software in Executable Form then:
+
+     a. such Covered Software must also be made available in Source Code Form,
+        as described in Section 3.1, and You must inform recipients of the
+        Executable Form how they can obtain a copy of such Source Code Form by
+        reasonable means in a timely manner, at a charge no more than the cost
+        of distribution to the recipient; and
+
+     b. You may distribute such Executable Form under the terms of this
+        License, or sublicense it under different terms, provided that the
+        license for the Executable Form does not attempt to limit or alter the
+        recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+     You may create and distribute a Larger Work under terms of Your choice,
+     provided that You also comply with the requirements of this License for
+     the Covered Software. If the Larger Work is a combination of Covered
+     Software with a work governed by one or more Secondary Licenses, and the
+     Covered Software is not Incompatible With Secondary Licenses, this
+     License permits You to additionally distribute such Covered Software
+     under the terms of such Secondary License(s), so that the recipient of
+     the Larger Work may, at their option, further distribute the Covered
+     Software under the terms of either this License or such Secondary
+     License(s).
+
+3.4. Notices
+
+     You may not remove or alter the substance of any license notices
+     (including copyright notices, patent notices, disclaimers of warranty, or
+     limitations of liability) contained within the Source Code Form of the
+     Covered Software, except that You may alter any license notices to the
+     extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+     You may choose to offer, and to charge a fee for, warranty, support,
+     indemnity or liability obligations to one or more recipients of Covered
+     Software. However, You may do so only on Your own behalf, and not on
+     behalf of any Contributor. You must make it absolutely clear that any
+     such warranty, support, indemnity, or liability obligation is offered by
+     You alone, and You hereby agree to indemnify every Contributor for any
+     liability incurred by such Contributor as a result of warranty, support,
+     indemnity or liability terms You offer. You may include additional
+     disclaimers of warranty and limitations of liability specific to any
+     jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+
+   If it is impossible for You to comply with any of the terms of this License
+   with respect to some or all of the Covered Software due to statute,
+   judicial order, or regulation then You must: (a) comply with the terms of
+   this License to the maximum extent possible; and (b) describe the
+   limitations and the code they affect. Such description must be placed in a
+   text file included with all distributions of the Covered Software under
+   this License. Except to the extent prohibited by statute or regulation,
+   such description must be sufficiently detailed for a recipient of ordinary
+   skill to be able to understand it.
+
+5. Termination
+
+5.1. The rights granted under this License will terminate automatically if You
+     fail to comply with any of its terms. However, if You become compliant,
+     then the rights granted under this License from a particular Contributor
+     are reinstated (a) provisionally, unless and until such Contributor
+     explicitly and finally terminates Your grants, and (b) on an ongoing
+     basis, if such Contributor fails to notify You of the non-compliance by
+     some reasonable means prior to 60 days after You have come back into
+     compliance. Moreover, Your grants from a particular Contributor are
+     reinstated on an ongoing basis if such Contributor notifies You of the
+     non-compliance by some reasonable means, this is the first time You have
+     received notice of non-compliance with this License from such
+     Contributor, and You become compliant prior to 30 days after Your receipt
+     of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+     infringement claim (excluding declaratory judgment actions,
+     counter-claims, and cross-claims) alleging that a Contributor Version
+     directly or indirectly infringes any patent, then the rights granted to
+     You by any and all Contributors for the Covered Software under Section
+     2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user
+     license agreements (excluding distributors and resellers) which have been
+     validly granted by You or Your distributors under this License prior to
+     termination shall survive termination.
+
+6. Disclaimer of Warranty
+
+   Covered Software is provided under this License on an "as is" basis,
+   without warranty of any kind, either expressed, implied, or statutory,
+   including, without limitation, warranties that the Covered Software is free
+   of defects, merchantable, fit for a particular purpose or non-infringing.
+   The entire risk as to the quality and performance of the Covered Software
+   is with You. Should any Covered Software prove defective in any respect,
+   You (not any Contributor) assume the cost of any necessary servicing,
+   repair, or correction. This disclaimer of warranty constitutes an essential
+   part of this License. No use of  any Covered Software is authorized under
+   this License except under this disclaimer.
+
+7. Limitation of Liability
+
+   Under no circumstances and under no legal theory, whether tort (including
+   negligence), contract, or otherwise, shall any Contributor, or anyone who
+   distributes Covered Software as permitted above, be liable to You for any
+   direct, indirect, special, incidental, or consequential damages of any
+   character including, without limitation, damages for lost profits, loss of
+   goodwill, work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses, even if such party shall have been
+   informed of the possibility of such damages. This limitation of liability
+   shall not apply to liability for death or personal injury resulting from
+   such party's negligence to the extent applicable law prohibits such
+   limitation. Some jurisdictions do not allow the exclusion or limitation of
+   incidental or consequential damages, so this exclusion and limitation may
+   not apply to You.
+
+8. Litigation
+
+   Any litigation relating to this License may be brought only in the courts
+   of a jurisdiction where the defendant maintains its principal place of
+   business and such litigation shall be governed by laws of that
+   jurisdiction, without reference to its conflict-of-law provisions. Nothing
+   in this Section shall prevent a party's ability to bring cross-claims or
+   counter-claims.
+
+9. Miscellaneous
+
+   This License represents the complete agreement concerning the subject
+   matter hereof. If any provision of this License is held to be
+   unenforceable, such provision shall be reformed only to the extent
+   necessary to make it enforceable. Any law or regulation which provides that
+   the language of a contract shall be construed against the drafter shall not
+   be used to construe this License against a Contributor.
+
+
+10. Versions of the License
+
+10.1. New Versions
+
+      Mozilla Foundation is the license steward. Except as provided in Section
+      10.3, no one other than the license steward has the right to modify or
+      publish new versions of this License. Each version will be given a
+      distinguishing version number.
+
+10.2. Effect of New Versions
+
+      You may distribute the Covered Software under the terms of the version
+      of the License under which You originally received the Covered Software,
+      or under the terms of any subsequent version published by the license
+      steward.
+
+10.3. Modified Versions
+
+      If you create software not governed by this License, and you want to
+      create a new license for such software, you may create and use a
+      modified version of this License if you rename the license and remove
+      any references to the name of the license steward (except to note that
+      such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+      Licenses If You choose to distribute Source Code Form that is
+      Incompatible With Secondary Licenses under the terms of this version of
+      the License, the notice described in Exhibit B of this License must be
+      attached.
+
+Exhibit A - Source Code Form License Notice
+
+      This Source Code Form is subject to the
+      terms of the Mozilla Public License, v.
+      2.0. If a copy of the MPL was not
+      distributed with this file, You can
+      obtain one at
+      https://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular file,
+then You may include the notice in a location (such as a LICENSE file in a
+relevant directory) where a recipient would be likely to look for such a
+notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+
+      This Source Code Form is "Incompatible
+      With Secondary Licenses", as defined by
+      the Mozilla Public License, v. 2.0.
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/__init__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4f612bd51c4ac1d272318ed6fb96e4aeb57e3e27
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/__init__.py
@@ -0,0 +1,34 @@
+from functools import reduce
+from typing import Any, Callable, Dict
+
+from . import formats
+from .error_reporting import detailed_errors, ValidationError
+from .extra_validations import EXTRA_VALIDATIONS
+from .fastjsonschema_exceptions import JsonSchemaException, JsonSchemaValueException
+from .fastjsonschema_validations import validate as _validate
+
+__all__ = [
+    "validate",
+    "FORMAT_FUNCTIONS",
+    "EXTRA_VALIDATIONS",
+    "ValidationError",
+    "JsonSchemaException",
+    "JsonSchemaValueException",
+]
+
+
+FORMAT_FUNCTIONS: Dict[str, Callable[[str], bool]] = {
+    fn.__name__.replace("_", "-"): fn
+    for fn in formats.__dict__.values()
+    if callable(fn) and not fn.__name__.startswith("_")
+}
+
+
+def validate(data: Any) -> bool:
+    """Validate the given ``data`` object using JSON Schema
+    This function raises ``ValidationError`` if ``data`` is invalid.
+    """
+    with detailed_errors():
+        _validate(data, custom_formats=FORMAT_FUNCTIONS)
+        reduce(lambda acc, fn: fn(acc), EXTRA_VALIDATIONS, data)
+    return True
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3867c48ad18d3a92eea5c1594d698b4fa1f730ce
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/__pycache__/error_reporting.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/__pycache__/error_reporting.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d5002cd5b046da29e3d854b7c4c2f368c80e61d0
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/__pycache__/error_reporting.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/__pycache__/extra_validations.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/__pycache__/extra_validations.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..09cbd3ec4a419c6b468166e7db105d1f47a6784b
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/__pycache__/extra_validations.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/__pycache__/fastjsonschema_exceptions.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/__pycache__/fastjsonschema_exceptions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..de4e9237a6592ec7463365fc80a82aff87d83568
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/__pycache__/fastjsonschema_exceptions.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/__pycache__/formats.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/__pycache__/formats.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ff0570132685e2b9053979c2e056eefa80786a95
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/__pycache__/formats.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/error_reporting.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/error_reporting.py
new file mode 100644
index 0000000000000000000000000000000000000000..9ebe6a335c9308a79c147ed2ae2e4085e9964013
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/error_reporting.py
@@ -0,0 +1,338 @@
+from __future__ import annotations
+
+import io
+import json
+import logging
+import os
+import re
+import typing
+from contextlib import contextmanager
+from textwrap import indent, wrap
+from typing import Any, Generator, Iterator, Sequence
+
+from .fastjsonschema_exceptions import JsonSchemaValueException
+
+if typing.TYPE_CHECKING:
+    import sys
+
+    if sys.version_info < (3, 11):
+        from typing_extensions import Self
+    else:
+        from typing import Self
+
+_logger = logging.getLogger(__name__)
+
+_MESSAGE_REPLACEMENTS = {
+    "must be named by propertyName definition": "keys must be named by",
+    "one of contains definition": "at least one item that matches",
+    " same as const definition:": "",
+    "only specified items": "only items matching the definition",
+}
+
+_SKIP_DETAILS = (
+    "must not be empty",
+    "is always invalid",
+    "must not be there",
+)
+
+_NEED_DETAILS = {"anyOf", "oneOf", "allOf", "contains", "propertyNames", "not", "items"}
+
+_CAMEL_CASE_SPLITTER = re.compile(r"\W+|([A-Z][^A-Z\W]*)")
+_IDENTIFIER = re.compile(r"^[\w_]+$", re.IGNORECASE)
+
+_TOML_JARGON = {
+    "object": "table",
+    "property": "key",
+    "properties": "keys",
+    "property names": "keys",
+}
+
+_FORMATS_HELP = """
+For more details about `format` see
+https://validate-pyproject.readthedocs.io/en/latest/api/validate_pyproject.formats.html
+"""
+
+
+class ValidationError(JsonSchemaValueException):
+    """Report violations of a given JSON schema.
+
+    This class extends :exc:`~fastjsonschema.JsonSchemaValueException`
+    by adding the following properties:
+
+    - ``summary``: an improved version of the ``JsonSchemaValueException`` error message
+      with only the necessary information)
+
+    - ``details``: more contextual information about the error like the failing schema
+      itself and the value that violates the schema.
+
+    Depending on the level of the verbosity of the ``logging`` configuration
+    the exception message will be only ``summary`` (default) or a combination of
+    ``summary`` and ``details`` (when the logging level is set to :obj:`logging.DEBUG`).
+    """
+
+    summary = ""
+    details = ""
+    _original_message = ""
+
+    @classmethod
+    def _from_jsonschema(cls, ex: JsonSchemaValueException) -> Self:
+        formatter = _ErrorFormatting(ex)
+        obj = cls(str(formatter), ex.value, formatter.name, ex.definition, ex.rule)
+        debug_code = os.getenv("JSONSCHEMA_DEBUG_CODE_GENERATION", "false").lower()
+        if debug_code != "false":  # pragma: no cover
+            obj.__cause__, obj.__traceback__ = ex.__cause__, ex.__traceback__
+        obj._original_message = ex.message
+        obj.summary = formatter.summary
+        obj.details = formatter.details
+        return obj
+
+
+@contextmanager
+def detailed_errors() -> Generator[None, None, None]:
+    try:
+        yield
+    except JsonSchemaValueException as ex:
+        raise ValidationError._from_jsonschema(ex) from None
+
+
+class _ErrorFormatting:
+    def __init__(self, ex: JsonSchemaValueException):
+        self.ex = ex
+        self.name = f"`{self._simplify_name(ex.name)}`"
+        self._original_message: str = self.ex.message.replace(ex.name, self.name)
+        self._summary = ""
+        self._details = ""
+
+    def __str__(self) -> str:
+        if _logger.getEffectiveLevel() <= logging.DEBUG and self.details:
+            return f"{self.summary}\n\n{self.details}"
+
+        return self.summary
+
+    @property
+    def summary(self) -> str:
+        if not self._summary:
+            self._summary = self._expand_summary()
+
+        return self._summary
+
+    @property
+    def details(self) -> str:
+        if not self._details:
+            self._details = self._expand_details()
+
+        return self._details
+
+    @staticmethod
+    def _simplify_name(name: str) -> str:
+        x = len("data.")
+        return name[x:] if name.startswith("data.") else name
+
+    def _expand_summary(self) -> str:
+        msg = self._original_message
+
+        for bad, repl in _MESSAGE_REPLACEMENTS.items():
+            msg = msg.replace(bad, repl)
+
+        if any(substring in msg for substring in _SKIP_DETAILS):
+            return msg
+
+        schema = self.ex.rule_definition
+        if self.ex.rule in _NEED_DETAILS and schema:
+            summary = _SummaryWriter(_TOML_JARGON)
+            return f"{msg}:\n\n{indent(summary(schema), '    ')}"
+
+        return msg
+
+    def _expand_details(self) -> str:
+        optional = []
+        definition = self.ex.definition or {}
+        desc_lines = definition.pop("$$description", [])
+        desc = definition.pop("description", None) or " ".join(desc_lines)
+        if desc:
+            description = "\n".join(
+                wrap(
+                    desc,
+                    width=80,
+                    initial_indent="    ",
+                    subsequent_indent="    ",
+                    break_long_words=False,
+                )
+            )
+            optional.append(f"DESCRIPTION:\n{description}")
+        schema = json.dumps(definition, indent=4)
+        value = json.dumps(self.ex.value, indent=4)
+        defaults = [
+            f"GIVEN VALUE:\n{indent(value, '    ')}",
+            f"OFFENDING RULE: {self.ex.rule!r}",
+            f"DEFINITION:\n{indent(schema, '    ')}",
+        ]
+        msg = "\n\n".join(optional + defaults)
+        epilog = f"\n{_FORMATS_HELP}" if "format" in msg.lower() else ""
+        return msg + epilog
+
+
+class _SummaryWriter:
+    _IGNORE = frozenset(("description", "default", "title", "examples"))
+
+    def __init__(self, jargon: dict[str, str] | None = None):
+        self.jargon: dict[str, str] = jargon or {}
+        # Clarify confusing terms
+        self._terms = {
+            "anyOf": "at least one of the following",
+            "oneOf": "exactly one of the following",
+            "allOf": "all of the following",
+            "not": "(*NOT* the following)",
+            "prefixItems": f"{self._jargon('items')} (in order)",
+            "items": "items",
+            "contains": "contains at least one of",
+            "propertyNames": (
+                f"non-predefined acceptable {self._jargon('property names')}"
+            ),
+            "patternProperties": f"{self._jargon('properties')} named via pattern",
+            "const": "predefined value",
+            "enum": "one of",
+        }
+        # Attributes that indicate that the definition is easy and can be done
+        # inline (e.g. string and number)
+        self._guess_inline_defs = [
+            "enum",
+            "const",
+            "maxLength",
+            "minLength",
+            "pattern",
+            "format",
+            "minimum",
+            "maximum",
+            "exclusiveMinimum",
+            "exclusiveMaximum",
+            "multipleOf",
+        ]
+
+    def _jargon(self, term: str | list[str]) -> str | list[str]:
+        if isinstance(term, list):
+            return [self.jargon.get(t, t) for t in term]
+        return self.jargon.get(term, term)
+
+    def __call__(
+        self,
+        schema: dict | list[dict],
+        prefix: str = "",
+        *,
+        _path: Sequence[str] = (),
+    ) -> str:
+        if isinstance(schema, list):
+            return self._handle_list(schema, prefix, _path)
+
+        filtered = self._filter_unecessary(schema, _path)
+        simple = self._handle_simple_dict(filtered, _path)
+        if simple:
+            return f"{prefix}{simple}"
+
+        child_prefix = self._child_prefix(prefix, "  ")
+        item_prefix = self._child_prefix(prefix, "- ")
+        indent = len(prefix) * " "
+        with io.StringIO() as buffer:
+            for i, (key, value) in enumerate(filtered.items()):
+                child_path = [*_path, key]
+                line_prefix = prefix if i == 0 else indent
+                buffer.write(f"{line_prefix}{self._label(child_path)}:")
+                # ^  just the first item should receive the complete prefix
+                if isinstance(value, dict):
+                    filtered = self._filter_unecessary(value, child_path)
+                    simple = self._handle_simple_dict(filtered, child_path)
+                    buffer.write(
+                        f" {simple}"
+                        if simple
+                        else f"\n{self(value, child_prefix, _path=child_path)}"
+                    )
+                elif isinstance(value, list) and (
+                    key != "type" or self._is_property(child_path)
+                ):
+                    children = self._handle_list(value, item_prefix, child_path)
+                    sep = " " if children.startswith("[") else "\n"
+                    buffer.write(f"{sep}{children}")
+                else:
+                    buffer.write(f" {self._value(value, child_path)}\n")
+            return buffer.getvalue()
+
+    def _is_unecessary(self, path: Sequence[str]) -> bool:
+        if self._is_property(path) or not path:  # empty path => instruction @ root
+            return False
+        key = path[-1]
+        return any(key.startswith(k) for k in "$_") or key in self._IGNORE
+
+    def _filter_unecessary(
+        self, schema: dict[str, Any], path: Sequence[str]
+    ) -> dict[str, Any]:
+        return {
+            key: value
+            for key, value in schema.items()
+            if not self._is_unecessary([*path, key])
+        }
+
+    def _handle_simple_dict(self, value: dict, path: Sequence[str]) -> str | None:
+        inline = any(p in value for p in self._guess_inline_defs)
+        simple = not any(isinstance(v, (list, dict)) for v in value.values())
+        if inline or simple:
+            return f"{{{', '.join(self._inline_attrs(value, path))}}}\n"
+        return None
+
+    def _handle_list(
+        self, schemas: list, prefix: str = "", path: Sequence[str] = ()
+    ) -> str:
+        if self._is_unecessary(path):
+            return ""
+
+        repr_ = repr(schemas)
+        if all(not isinstance(e, (dict, list)) for e in schemas) and len(repr_) < 60:
+            return f"{repr_}\n"
+
+        item_prefix = self._child_prefix(prefix, "- ")
+        return "".join(
+            self(v, item_prefix, _path=[*path, f"[{i}]"]) for i, v in enumerate(schemas)
+        )
+
+    def _is_property(self, path: Sequence[str]) -> bool:
+        """Check if the given path can correspond to an arbitrarily named property"""
+        counter = 0
+        for key in path[-2::-1]:
+            if key not in {"properties", "patternProperties"}:
+                break
+            counter += 1
+
+        # If the counter if even, the path correspond to a JSON Schema keyword
+        # otherwise it can be any arbitrary string naming a property
+        return counter % 2 == 1
+
+    def _label(self, path: Sequence[str]) -> str:
+        *parents, key = path
+        if not self._is_property(path):
+            norm_key = _separate_terms(key)
+            return self._terms.get(key) or " ".join(self._jargon(norm_key))
+
+        if parents[-1] == "patternProperties":
+            return f"(regex {key!r})"
+        return repr(key)  # property name
+
+    def _value(self, value: Any, path: Sequence[str]) -> str:
+        if path[-1] == "type" and not self._is_property(path):
+            type_ = self._jargon(value)
+            return f"[{', '.join(type_)}]" if isinstance(type_, list) else type_
+        return repr(value)
+
+    def _inline_attrs(self, schema: dict, path: Sequence[str]) -> Iterator[str]:
+        for key, value in schema.items():
+            child_path = [*path, key]
+            yield f"{self._label(child_path)}: {self._value(value, child_path)}"
+
+    def _child_prefix(self, parent_prefix: str, child_prefix: str) -> str:
+        return len(parent_prefix) * " " + child_prefix
+
+
+def _separate_terms(word: str) -> list[str]:
+    """
+    >>> _separate_terms("FooBar-foo")
+    ['foo', 'bar', 'foo']
+    """
+    return [w.lower() for w in _CAMEL_CASE_SPLITTER.split(word) if w]
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/extra_validations.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/extra_validations.py
new file mode 100644
index 0000000000000000000000000000000000000000..72a7132f2b564748679242facbb5ab241feffae5
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/extra_validations.py
@@ -0,0 +1,151 @@
+"""The purpose of this module is implement PEP 621 validations that are
+difficult to express as a JSON Schema (or that are not supported by the current
+JSON Schema library).
+"""
+
+import collections
+import itertools
+from inspect import cleandoc
+from typing import Generator, Iterable, Mapping, TypeVar
+
+from .error_reporting import ValidationError
+
+T = TypeVar("T", bound=Mapping)
+
+
+class RedefiningStaticFieldAsDynamic(ValidationError):
+    _DESC = """According to PEP 621:
+
+    Build back-ends MUST raise an error if the metadata specifies a field
+    statically as well as being listed in dynamic.
+    """
+    __doc__ = _DESC
+    _URL = (
+        "https://packaging.python.org/en/latest/specifications/pyproject-toml/#dynamic"
+    )
+
+
+class IncludedDependencyGroupMustExist(ValidationError):
+    _DESC = """An included dependency group must exist and must not be cyclic.
+    """
+    __doc__ = _DESC
+    _URL = "https://peps.python.org/pep-0735/"
+
+
+class ImportNameCollision(ValidationError):
+    _DESC = """According to PEP 794:
+
+    All import-names and import-namespaces items must be unique.
+    """
+    __doc__ = _DESC
+    _URL = "https://peps.python.org/pep-0794/"
+
+
+class ImportNameMissing(ValidationError):
+    _DESC = """According to PEP 794:
+
+    An import name must have all parents listed.
+    """
+    __doc__ = _DESC
+    _URL = "https://peps.python.org/pep-0794/"
+
+
+def validate_project_dynamic(pyproject: T) -> T:
+    project_table = pyproject.get("project", {})
+    dynamic = project_table.get("dynamic", [])
+
+    for field in dynamic:
+        if field in project_table:
+            raise RedefiningStaticFieldAsDynamic(
+                message=f"You cannot provide a value for `project.{field}` and "
+                "list it under `project.dynamic` at the same time",
+                value={
+                    field: project_table[field],
+                    "...": " # ...",
+                    "dynamic": dynamic,
+                },
+                name=f"data.project.{field}",
+                definition={
+                    "description": cleandoc(RedefiningStaticFieldAsDynamic._DESC),
+                    "see": RedefiningStaticFieldAsDynamic._URL,
+                },
+                rule="PEP 621",
+            )
+
+    return pyproject
+
+
+def validate_include_depenency(pyproject: T) -> T:
+    dependency_groups = pyproject.get("dependency-groups", {})
+    for key, value in dependency_groups.items():
+        for each in value:
+            if (
+                isinstance(each, dict)
+                and (include_group := each.get("include-group"))
+                and include_group not in dependency_groups
+            ):
+                raise IncludedDependencyGroupMustExist(
+                    message=f"The included dependency group {include_group} doesn't exist",
+                    value=each,
+                    name=f"data.dependency_groups.{key}",
+                    definition={
+                        "description": cleandoc(IncludedDependencyGroupMustExist._DESC),
+                        "see": IncludedDependencyGroupMustExist._URL,
+                    },
+                    rule="PEP 735",
+                )
+    # TODO: check for `include-group` cycles (can be conditional to graphlib)
+    return pyproject
+
+
+def _remove_private(items: Iterable[str]) -> Generator[str, None, None]:
+    for item in items:
+        yield item.partition(";")[0].rstrip()
+
+
+def validate_import_name_issues(pyproject: T) -> T:
+    project = pyproject.get("project", {})
+    import_names = collections.Counter(_remove_private(project.get("import-names", [])))
+    import_namespaces = collections.Counter(
+        _remove_private(project.get("import-namespaces", []))
+    )
+
+    duplicated = [k for k, v in (import_names + import_namespaces).items() if v > 1]
+
+    if duplicated:
+        raise ImportNameCollision(
+            message="Duplicated names are not allowed in import-names/import-namespaces",
+            value=duplicated,
+            name="data.project.importnames(paces)",
+            definition={
+                "description": cleandoc(ImportNameCollision._DESC),
+                "see": ImportNameCollision._URL,
+            },
+            rule="PEP 794",
+        )
+
+    names = frozenset(import_names + import_namespaces)
+    for name in names:
+        for parent in itertools.accumulate(
+            name.split(".")[:-1], lambda a, b: f"{a}.{b}"
+        ):
+            if parent not in names:
+                raise ImportNameMissing(
+                    message="All parents of an import name must also be listed in import-namespace/import-names",
+                    value=name,
+                    name="data.project.importnames(paces)",
+                    definition={
+                        "description": cleandoc(ImportNameMissing._DESC),
+                        "see": ImportNameMissing._URL,
+                    },
+                    rule="PEP 794",
+                )
+
+    return pyproject
+
+
+EXTRA_VALIDATIONS = (
+    validate_project_dynamic,
+    validate_include_depenency,
+    validate_import_name_issues,
+)
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/fastjsonschema_exceptions.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/fastjsonschema_exceptions.py
new file mode 100644
index 0000000000000000000000000000000000000000..d2dddd6a106f021a4723c1e8f5953ccc09e55e1f
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/fastjsonschema_exceptions.py
@@ -0,0 +1,51 @@
+import re
+
+
+SPLIT_RE = re.compile(r'[\.\[\]]+')
+
+
+class JsonSchemaException(ValueError):
+    """
+    Base exception of ``fastjsonschema`` library.
+    """
+
+
+class JsonSchemaValueException(JsonSchemaException):
+    """
+    Exception raised by validation function. Available properties:
+
+     * ``message`` containing human-readable information what is wrong (e.g. ``data.property[index] must be smaller than or equal to 42``),
+     * invalid ``value`` (e.g. ``60``),
+     * ``name`` of a path in the data structure (e.g. ``data.property[index]``),
+     * ``path`` as an array in the data structure (e.g. ``['data', 'property', 'index']``),
+     * the whole ``definition`` which the ``value`` has to fulfil (e.g. ``{'type': 'number', 'maximum': 42}``),
+     * ``rule`` which the ``value`` is breaking (e.g. ``maximum``)
+     * and ``rule_definition`` (e.g. ``42``).
+
+    .. versionchanged:: 2.14.0
+        Added all extra properties.
+    """
+
+    def __init__(self, message, value=None, name=None, definition=None, rule=None):
+        super().__init__(message)
+        self.message = message
+        self.value = value
+        self.name = name
+        self.definition = definition
+        self.rule = rule
+
+    @property
+    def path(self):
+        return [item for item in SPLIT_RE.split(self.name) if item != '']
+
+    @property
+    def rule_definition(self):
+        if not self.rule or not self.definition:
+            return None
+        return self.definition.get(self.rule)
+
+
+class JsonSchemaDefinitionException(JsonSchemaException):
+    """
+    Exception raised by generator of validation function.
+    """
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/fastjsonschema_validations.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/fastjsonschema_validations.py
new file mode 100644
index 0000000000000000000000000000000000000000..d8a03de9bfacf5e3401211ddb852354bb86c12f6
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/fastjsonschema_validations.py
@@ -0,0 +1,1453 @@
+# noqa
+# ruff: noqa
+# flake8: noqa
+# pylint: skip-file
+# mypy: ignore-errors
+# yapf: disable
+# pylama:skip=1
+
+
+# *** PLEASE DO NOT MODIFY DIRECTLY: Automatically generated code *** 
+
+
+VERSION = "2.21.2"
+from decimal import Decimal
+import re
+from .fastjsonschema_exceptions import JsonSchemaValueException
+
+
+REGEX_PATTERNS = {
+    '^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9._-]*[a-zA-Z0-9])$': re.compile('^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9._-]*[a-zA-Z0-9])\\Z'),
+    '^.*$': re.compile('^.*$'),
+    '.+': re.compile('.+'),
+    '^.+$': re.compile('^.+$'),
+    'idn-email_re_pattern': re.compile('^[^@]+@[^@]+\\.[^@]+\\Z')
+}
+
+NoneType = type(None)
+
+def validate(data, custom_formats={}, name_prefix=None):
+    validate_https___packaging_python_org_en_latest_specifications_declaring_build_dependencies(data, custom_formats, (name_prefix or "data") + "")
+    return data
+
+def validate_https___packaging_python_org_en_latest_specifications_declaring_build_dependencies(data, custom_formats={}, name_prefix=None):
+    if not isinstance(data, (dict)):
+        raise JsonSchemaValueException("" + (name_prefix or "data") + " must be object", value=data, name="" + (name_prefix or "data") + "", definition={'$schema': 'http://json-schema.org/draft-07/schema#', '$id': 'https://packaging.python.org/en/latest/specifications/declaring-build-dependencies/', 'title': 'Data structure for ``pyproject.toml`` files', '$$description': ['File format containing build-time configurations for the Python ecosystem. ', ':pep:`517` initially defined a build-system independent format for source trees', 'which was complemented by :pep:`518` to provide a way of specifying dependencies ', 'for building Python projects.', 'Please notice the ``project`` table (as initially defined in  :pep:`621`) is not included', 'in this schema and should be considered separately.'], 'type': 'object', 'additionalProperties': False, 'properties': {'build-system': {'type': 'object', 'description': 'Table used to store build-related data', 'additionalProperties': False, 'properties': {'requires': {'type': 'array', '$$description': ['List of dependencies in the :pep:`508` format required to execute the build', 'system. Please notice that the resulting dependency graph', '**MUST NOT contain cycles**'], 'items': {'type': 'string'}}, 'build-backend': {'type': 'string', 'description': 'Python object that will be used to perform the build according to :pep:`517`', 'format': 'pep517-backend-reference'}, 'backend-path': {'type': 'array', '$$description': ['List of directories to be prepended to ``sys.path`` when loading the', 'back-end, and running its hooks'], 'items': {'type': 'string', '$comment': 'Should be a path (TODO: enforce it with format?)'}}}, 'required': ['requires']}, 'project': {'$schema': 'http://json-schema.org/draft-07/schema#', '$id': 'https://packaging.python.org/en/latest/specifications/pyproject-toml/', 'title': 'Package metadata stored in the ``project`` table', '$$description': ['Data structure for the **project** table inside ``pyproject.toml``', '(as initially defined in :pep:`621`)'], 'type': 'object', 'properties': {'name': {'type': 'string', 'description': 'The name (primary identifier) of the project. MUST be statically defined.', 'format': 'pep508-identifier'}, 'version': {'type': 'string', 'description': 'The version of the project as supported by :pep:`440`.', 'format': 'pep440'}, 'description': {'type': 'string', '$$description': ['The `summary description of the project', '`_']}, 'readme': {'$$description': ['`Full/detailed description of the project in the form of a README', '`_', "with meaning similar to the one defined in `core metadata's Description", '`_'], 'oneOf': [{'type': 'string', '$$description': ['Relative path to a text file (UTF-8) containing the full description', 'of the project. If the file path ends in case-insensitive ``.md`` or', '``.rst`` suffixes, then the content-type is respectively', '``text/markdown`` or ``text/x-rst``']}, {'type': 'object', 'allOf': [{'anyOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to a text file containing the full description', 'of the project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', 'description': 'Full text describing the project.'}}, 'required': ['text']}]}, {'properties': {'content-type': {'type': 'string', '$$description': ['Content-type (:rfc:`1341`) of the full description', '(e.g. ``text/markdown``). The ``charset`` parameter is assumed', 'UTF-8 when not present.'], '$comment': 'TODO: add regex pattern or format?'}}, 'required': ['content-type']}]}]}, 'requires-python': {'type': 'string', 'format': 'pep508-versionspec', '$$description': ['`The Python version requirements of the project', '`_.']}, 'license': {'description': '`Project license `_.', 'oneOf': [{'type': 'string', 'description': 'An SPDX license identifier', 'format': 'SPDX'}, {'type': 'object', 'properties': {'file': {'type': 'string', '$$description': ['Relative path to the file (UTF-8) which contains the license for the', 'project.']}}, 'required': ['file']}, {'type': 'object', 'properties': {'text': {'type': 'string', '$$description': ['The license of the project whose meaning is that of the', '`License field from the core metadata', '`_.']}}, 'required': ['text']}]}, 'license-files': {'description': 'Paths or globs to paths of license files', 'type': 'array', 'items': {'type': 'string'}}, 'authors': {'type': 'array', 'items': {'$ref': '#/definitions/author'}, '$$description': ["The people or organizations considered to be the 'authors' of the project.", 'The exact meaning is open to interpretation (e.g. original or primary authors,', 'current maintainers, or owners of the package).']}, 'maintainers': {'type': 'array', 'items': {'$ref': '#/definitions/author'}, '$$description': ["The people or organizations considered to be the 'maintainers' of the project.", 'Similarly to ``authors``, the exact meaning is open to interpretation.']}, 'keywords': {'type': 'array', 'items': {'type': 'string'}, 'description': 'List of keywords to assist searching for the distribution in a larger catalog.'}, 'classifiers': {'type': 'array', 'items': {'type': 'string', 'format': 'trove-classifier', 'description': '`PyPI classifier `_.'}, '$$description': ['`Trove classifiers `_', 'which apply to the project.']}, 'urls': {'type': 'object', 'description': 'URLs associated with the project in the form ``label => value``.', 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', 'format': 'url'}}}, 'scripts': {'$ref': '#/definitions/entry-point-group', '$$description': ['Instruct the installer to create command-line wrappers for the given', '`entry points `_.']}, 'gui-scripts': {'$ref': '#/definitions/entry-point-group', '$$description': ['Instruct the installer to create GUI wrappers for the given', '`entry points `_.', 'The difference between ``scripts`` and ``gui-scripts`` is only relevant in', 'Windows.']}, 'entry-points': {'$$description': ['Instruct the installer to expose the given modules/functions via', '``entry-point`` discovery mechanism (useful for plugins).', 'More information available in the `Python packaging guide', '`_.'], 'propertyNames': {'format': 'python-entrypoint-group'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'$ref': '#/definitions/entry-point-group'}}}, 'dependencies': {'type': 'array', 'description': 'Project (mandatory) dependencies.', 'items': {'$ref': '#/definitions/dependency'}}, 'optional-dependencies': {'type': 'object', 'description': 'Optional dependency for the project', 'propertyNames': {'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'array', 'items': {'$ref': '#/definitions/dependency'}}}}, 'import-names': {'description': 'Lists import names which a project, when installed, would exclusively provide.', 'type': 'array', 'items': {'type': 'string', 'format': 'import-name'}}, 'import-namespaces': {'description': 'Lists import names that, when installed, would be provided by the project, but not exclusively.', 'type': 'array', 'items': {'type': 'string', 'format': 'import-name'}}, 'dynamic': {'type': 'array', '$$description': ['Specifies which fields are intentionally unspecified and expected to be', 'dynamically provided by build tools'], 'items': {'enum': ['version', 'description', 'readme', 'requires-python', 'license', 'license-files', 'authors', 'maintainers', 'keywords', 'classifiers', 'urls', 'scripts', 'gui-scripts', 'entry-points', 'dependencies', 'optional-dependencies', 'import-names', 'import-namespaces']}}}, 'required': ['name'], 'additionalProperties': False, 'allOf': [{'if': {'not': {'required': ['dynamic'], 'properties': {'dynamic': {'contains': {'const': 'version'}, '$$description': ['version is listed in ``dynamic``']}}}, '$$comment': ['According to :pep:`621`:', '    If the core metadata specification lists a field as "Required", then', '    the metadata MUST specify the field statically or list it in dynamic', 'In turn, `core metadata`_ defines:', '    The required fields are: Metadata-Version, Name, Version.', '    All the other fields are optional.', 'Since ``Metadata-Version`` is defined by the build back-end, ``name`` and', '``version`` are the only mandatory information in ``pyproject.toml``.', '.. _core metadata: https://packaging.python.org/specifications/core-metadata/']}, 'then': {'required': ['version'], '$$description': ['version should be statically defined in the ``version`` field']}}, {'if': {'required': ['license-files']}, 'then': {'properties': {'license': {'type': 'string'}}}}], 'definitions': {'author': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}, 'anyOf': [{'required': ['name']}, {'required': ['email']}]}, 'entry-point-group': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, 'dependency': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}}, 'tool': {'type': 'object', 'properties': {'distutils': {'$schema': 'http://json-schema.org/draft-07/schema#', '$id': 'https://setuptools.pypa.io/en/latest/deprecated/distutils/configfile.html', 'title': '``tool.distutils`` table', '$$description': ['**EXPERIMENTAL** (NOT OFFICIALLY SUPPORTED): Use ``tool.distutils``', 'subtables to configure arguments for ``distutils`` commands.', 'Originally, ``distutils`` allowed developers to configure arguments for', '``setup.py`` commands via `distutils configuration files', '`_.', 'See also `the old Python docs _`.'], 'type': 'object', 'properties': {'global': {'type': 'object', 'description': 'Global options applied to all ``distutils`` commands'}}, 'patternProperties': {'.+': {'type': 'object'}}, '$comment': 'TODO: Is there a practical way of making this schema more specific?'}, 'setuptools': {'$schema': 'http://json-schema.org/draft-07/schema#', '$id': 'https://setuptools.pypa.io/en/latest/userguide/pyproject_config.html', 'title': '``tool.setuptools`` table', '$$description': ['``setuptools``-specific configurations that can be set by users that require', 'customization.', 'These configurations are completely optional and probably can be skipped when', 'creating simple packages. They are equivalent to some of the `Keywords', '`_', 'used by the ``setup.py`` file, and can be set via the ``tool.setuptools`` table.', 'It considers only ``setuptools`` `parameters', '`_', 'that are not covered by :pep:`621`; and intentionally excludes ``dependency_links``', 'and ``setup_requires`` (incompatible with modern workflows/standards).'], 'type': 'object', 'additionalProperties': False, 'properties': {'platforms': {'type': 'array', 'items': {'type': 'string'}}, 'provides': {'$$description': ['Package and virtual package names contained within this package', '**(not supported by pip)**'], 'type': 'array', 'items': {'type': 'string', 'format': 'pep508-identifier'}}, 'obsoletes': {'$$description': ['Packages which this package renders obsolete', '**(not supported by pip)**'], 'type': 'array', 'items': {'type': 'string', 'format': 'pep508-identifier'}}, 'zip-safe': {'$$description': ['Whether the project can be safely installed and run from a zip file.', '**OBSOLETE**: only relevant for ``pkg_resources``, ``easy_install`` and', '``setup.py install`` in the context of ``eggs`` (**DEPRECATED**).'], 'type': 'boolean'}, 'script-files': {'$$description': ['Legacy way of defining scripts (entry-points are preferred).', 'Equivalent to the ``script`` keyword in ``setup.py``', '(it was renamed to avoid confusion with entry-point based ``project.scripts``', 'defined in :pep:`621`).', '**DISCOURAGED**: generic script wrappers are tricky and may not work properly.', 'Whenever possible, please use ``project.scripts`` instead.'], 'type': 'array', 'items': {'type': 'string'}, '$comment': 'TODO: is this field deprecated/should be removed?'}, 'eager-resources': {'$$description': ['Resources that should be extracted together, if any of them is needed,', 'or if any C extensions included in the project are imported.', '**OBSOLETE**: only relevant for ``pkg_resources``, ``easy_install`` and', '``setup.py install`` in the context of ``eggs`` (**DEPRECATED**).'], 'type': 'array', 'items': {'type': 'string'}}, 'packages': {'$$description': ['Packages that should be included in the distribution.', 'It can be given either as a list of package identifiers', 'or as a ``dict``-like structure with a single key ``find``', 'which corresponds to a dynamic call to', '``setuptools.config.expand.find_packages`` function.', 'The ``find`` key is associated with a nested ``dict``-like structure that can', 'contain ``where``, ``include``, ``exclude`` and ``namespaces`` keys,', 'mimicking the keyword arguments of the associated function.'], 'oneOf': [{'title': 'Array of Python package identifiers', 'type': 'array', 'items': {'$ref': '#/definitions/package-name'}}, {'$ref': '#/definitions/find-directive'}]}, 'package-dir': {'$$description': [':class:`dict`-like structure mapping from package names to directories where their', 'code can be found.', 'The empty string (as key) means that all packages are contained inside', 'the given directory will be included in the distribution.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'anyOf': [{'const': ''}, {'$ref': '#/definitions/package-name'}]}, 'patternProperties': {'^.*$': {'type': 'string'}}}, 'package-data': {'$$description': ['Mapping from package names to lists of glob patterns.', 'Usually this option is not needed when using ``include-package-data = true``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'anyOf': [{'$ref': '#/definitions/package-name'}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'include-package-data': {'$$description': ['Automatically include any data files inside the package directories', 'that are specified by ``MANIFEST.in``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'boolean'}, 'exclude-package-data': {'$$description': ['Mapping from package names to lists of glob patterns that should be excluded', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'anyOf': [{'$ref': '#/definitions/package-name'}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'namespace-packages': {'type': 'array', 'items': {'type': 'string', 'format': 'python-module-name-relaxed'}, '$comment': 'https://setuptools.pypa.io/en/latest/userguide/package_discovery.html', 'description': '**DEPRECATED**: use implicit namespaces instead (:pep:`420`).'}, 'py-modules': {'description': 'Modules that setuptools will manipulate', 'type': 'array', 'items': {'type': 'string', 'format': 'python-module-name-relaxed'}, '$comment': 'TODO: clarify the relationship with ``packages``'}, 'ext-modules': {'description': 'Extension modules to be compiled by setuptools', 'type': 'array', 'items': {'$ref': '#/definitions/ext-module'}}, 'data-files': {'$$description': ['``dict``-like structure where each key represents a directory and', 'the value is a list of glob patterns that should be installed in them.', '**DISCOURAGED**: please notice this might not work as expected with wheels.', 'Whenever possible, consider using data files inside the package directories', '(or create a new namespace package that only contains data files).', 'See `data files support', '`_.'], 'type': 'object', 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'cmdclass': {'$$description': ['Mapping of distutils-style command names to ``setuptools.Command`` subclasses', 'which in turn should be represented by strings with a qualified class name', '(i.e., "dotted" form with module), e.g.::\n\n', '    cmdclass = {mycmd = "pkg.subpkg.module.CommandClass"}\n\n', 'The command class should be a directly defined at the top-level of the', 'containing module (no class nesting).'], 'type': 'object', 'patternProperties': {'^.*$': {'type': 'string', 'format': 'python-qualified-identifier'}}}, 'license-files': {'type': 'array', 'items': {'type': 'string'}, '$$description': ['**PROVISIONAL**: list of glob patterns for all license files being distributed.', '(likely to become standard with :pep:`639`).', "By default: ``['LICEN[CS]E*', 'COPYING*', 'NOTICE*', 'AUTHORS*']``"], '$comment': 'TODO: revise if PEP 639 is accepted. Probably ``project.license-files``?'}, 'dynamic': {'type': 'object', 'description': 'Instructions for loading :pep:`621`-related metadata dynamically', 'additionalProperties': False, 'properties': {'version': {'$$description': ['A version dynamically loaded via either the ``attr:`` or ``file:``', 'directives. Please make sure the given file or attribute respects :pep:`440`.', 'Also ensure to set ``project.dynamic`` accordingly.'], 'oneOf': [{'$ref': '#/definitions/attr-directive'}, {'$ref': '#/definitions/file-directive'}]}, 'classifiers': {'$ref': '#/definitions/file-directive'}, 'description': {'$ref': '#/definitions/file-directive'}, 'entry-points': {'$ref': '#/definitions/file-directive'}, 'dependencies': {'$ref': '#/definitions/file-directive-for-dependencies'}, 'optional-dependencies': {'type': 'object', 'propertyNames': {'type': 'string', 'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'.+': {'$ref': '#/definitions/file-directive-for-dependencies'}}}, 'readme': {'type': 'object', 'anyOf': [{'$ref': '#/definitions/file-directive'}, {'type': 'object', 'properties': {'content-type': {'type': 'string'}, 'file': {'$ref': '#/definitions/file-directive/properties/file'}}, 'additionalProperties': False}], 'required': ['file']}}}}, 'definitions': {'package-name': {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}, 'ext-module': {'$id': '#/definitions/ext-module', 'title': 'Extension module', 'description': 'Parameters to construct a :class:`setuptools.Extension` object', 'type': 'object', 'required': ['name', 'sources'], 'additionalProperties': False, 'properties': {'name': {'type': 'string', 'format': 'python-module-name-relaxed'}, 'sources': {'type': 'array', 'items': {'type': 'string'}}, 'include-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'define-macros': {'type': 'array', 'items': {'type': 'array', 'items': [{'description': 'macro name', 'type': 'string'}, {'description': 'macro value', 'oneOf': [{'type': 'string'}, {'type': 'null'}]}], 'additionalItems': False}}, 'undef-macros': {'type': 'array', 'items': {'type': 'string'}}, 'library-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'libraries': {'type': 'array', 'items': {'type': 'string'}}, 'runtime-library-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'extra-objects': {'type': 'array', 'items': {'type': 'string'}}, 'extra-compile-args': {'type': 'array', 'items': {'type': 'string'}}, 'extra-link-args': {'type': 'array', 'items': {'type': 'string'}}, 'export-symbols': {'type': 'array', 'items': {'type': 'string'}}, 'swig-opts': {'type': 'array', 'items': {'type': 'string'}}, 'depends': {'type': 'array', 'items': {'type': 'string'}}, 'language': {'type': 'string'}, 'optional': {'type': 'boolean'}, 'py-limited-api': {'type': 'boolean'}}}, 'file-directive': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'file-directive-for-dependencies': {'title': "'file:' directive for dependencies", 'allOf': [{'$$description': ['**BETA**: subset of the ``requirements.txt`` format', 'without ``pip`` flags and options', '(one :pep:`508`-compliant string per line,', 'lines that are blank or start with ``#`` are excluded).', 'See `dynamic metadata', '`_.']}, {'$ref': '#/definitions/file-directive'}]}, 'attr-directive': {'title': "'attr:' directive", '$id': '#/definitions/attr-directive', '$$description': ['Value is read from a module attribute. Supports callables and iterables;', 'unsupported types are cast via ``str()``'], 'type': 'object', 'additionalProperties': False, 'properties': {'attr': {'type': 'string', 'format': 'python-qualified-identifier'}}, 'required': ['attr']}, 'find-directive': {'$id': '#/definitions/find-directive', 'title': "'find:' directive", 'type': 'object', 'additionalProperties': False, 'properties': {'find': {'type': 'object', '$$description': ['Dynamic `package discovery', '`_.'], 'additionalProperties': False, 'properties': {'where': {'description': 'Directories to be searched for packages (Unix-style relative path)', 'type': 'array', 'items': {'type': 'string'}}, 'exclude': {'type': 'array', '$$description': ['Exclude packages that match the values listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'include': {'type': 'array', '$$description': ['Restrict the found packages to just the ones listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'namespaces': {'type': 'boolean', '$$description': ['When ``True``, directories without a ``__init__.py`` file will also', 'be scanned for :pep:`420`-style implicit namespaces']}}}}}}}}}, 'dependency-groups': {'type': 'object', 'description': 'Dependency groups following PEP 735', 'additionalProperties': False, 'patternProperties': {'^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9._-]*[a-zA-Z0-9])$': {'type': 'array', 'items': {'oneOf': [{'type': 'string', 'description': 'Python package specifiers following PEP 508', 'format': 'pep508'}, {'type': 'object', 'additionalProperties': False, 'properties': {'include-group': {'description': 'Another dependency group to include in this one', 'type': 'string', 'pattern': '^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9._-]*[a-zA-Z0-9])$'}}}]}}}}}, 'project': {'$schema': 'http://json-schema.org/draft-07/schema#', '$id': 'https://packaging.python.org/en/latest/specifications/pyproject-toml/', 'title': 'Package metadata stored in the ``project`` table', '$$description': ['Data structure for the **project** table inside ``pyproject.toml``', '(as initially defined in :pep:`621`)'], 'type': 'object', 'properties': {'name': {'type': 'string', 'description': 'The name (primary identifier) of the project. MUST be statically defined.', 'format': 'pep508-identifier'}, 'version': {'type': 'string', 'description': 'The version of the project as supported by :pep:`440`.', 'format': 'pep440'}, 'description': {'type': 'string', '$$description': ['The `summary description of the project', '`_']}, 'readme': {'$$description': ['`Full/detailed description of the project in the form of a README', '`_', "with meaning similar to the one defined in `core metadata's Description", '`_'], 'oneOf': [{'type': 'string', '$$description': ['Relative path to a text file (UTF-8) containing the full description', 'of the project. If the file path ends in case-insensitive ``.md`` or', '``.rst`` suffixes, then the content-type is respectively', '``text/markdown`` or ``text/x-rst``']}, {'type': 'object', 'allOf': [{'anyOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to a text file containing the full description', 'of the project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', 'description': 'Full text describing the project.'}}, 'required': ['text']}]}, {'properties': {'content-type': {'type': 'string', '$$description': ['Content-type (:rfc:`1341`) of the full description', '(e.g. ``text/markdown``). The ``charset`` parameter is assumed', 'UTF-8 when not present.'], '$comment': 'TODO: add regex pattern or format?'}}, 'required': ['content-type']}]}]}, 'requires-python': {'type': 'string', 'format': 'pep508-versionspec', '$$description': ['`The Python version requirements of the project', '`_.']}, 'license': {'description': '`Project license `_.', 'oneOf': [{'type': 'string', 'description': 'An SPDX license identifier', 'format': 'SPDX'}, {'type': 'object', 'properties': {'file': {'type': 'string', '$$description': ['Relative path to the file (UTF-8) which contains the license for the', 'project.']}}, 'required': ['file']}, {'type': 'object', 'properties': {'text': {'type': 'string', '$$description': ['The license of the project whose meaning is that of the', '`License field from the core metadata', '`_.']}}, 'required': ['text']}]}, 'license-files': {'description': 'Paths or globs to paths of license files', 'type': 'array', 'items': {'type': 'string'}}, 'authors': {'type': 'array', 'items': {'$ref': '#/definitions/author'}, '$$description': ["The people or organizations considered to be the 'authors' of the project.", 'The exact meaning is open to interpretation (e.g. original or primary authors,', 'current maintainers, or owners of the package).']}, 'maintainers': {'type': 'array', 'items': {'$ref': '#/definitions/author'}, '$$description': ["The people or organizations considered to be the 'maintainers' of the project.", 'Similarly to ``authors``, the exact meaning is open to interpretation.']}, 'keywords': {'type': 'array', 'items': {'type': 'string'}, 'description': 'List of keywords to assist searching for the distribution in a larger catalog.'}, 'classifiers': {'type': 'array', 'items': {'type': 'string', 'format': 'trove-classifier', 'description': '`PyPI classifier `_.'}, '$$description': ['`Trove classifiers `_', 'which apply to the project.']}, 'urls': {'type': 'object', 'description': 'URLs associated with the project in the form ``label => value``.', 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', 'format': 'url'}}}, 'scripts': {'$ref': '#/definitions/entry-point-group', '$$description': ['Instruct the installer to create command-line wrappers for the given', '`entry points `_.']}, 'gui-scripts': {'$ref': '#/definitions/entry-point-group', '$$description': ['Instruct the installer to create GUI wrappers for the given', '`entry points `_.', 'The difference between ``scripts`` and ``gui-scripts`` is only relevant in', 'Windows.']}, 'entry-points': {'$$description': ['Instruct the installer to expose the given modules/functions via', '``entry-point`` discovery mechanism (useful for plugins).', 'More information available in the `Python packaging guide', '`_.'], 'propertyNames': {'format': 'python-entrypoint-group'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'$ref': '#/definitions/entry-point-group'}}}, 'dependencies': {'type': 'array', 'description': 'Project (mandatory) dependencies.', 'items': {'$ref': '#/definitions/dependency'}}, 'optional-dependencies': {'type': 'object', 'description': 'Optional dependency for the project', 'propertyNames': {'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'array', 'items': {'$ref': '#/definitions/dependency'}}}}, 'import-names': {'description': 'Lists import names which a project, when installed, would exclusively provide.', 'type': 'array', 'items': {'type': 'string', 'format': 'import-name'}}, 'import-namespaces': {'description': 'Lists import names that, when installed, would be provided by the project, but not exclusively.', 'type': 'array', 'items': {'type': 'string', 'format': 'import-name'}}, 'dynamic': {'type': 'array', '$$description': ['Specifies which fields are intentionally unspecified and expected to be', 'dynamically provided by build tools'], 'items': {'enum': ['version', 'description', 'readme', 'requires-python', 'license', 'license-files', 'authors', 'maintainers', 'keywords', 'classifiers', 'urls', 'scripts', 'gui-scripts', 'entry-points', 'dependencies', 'optional-dependencies', 'import-names', 'import-namespaces']}}}, 'required': ['name'], 'additionalProperties': False, 'allOf': [{'if': {'not': {'required': ['dynamic'], 'properties': {'dynamic': {'contains': {'const': 'version'}, '$$description': ['version is listed in ``dynamic``']}}}, '$$comment': ['According to :pep:`621`:', '    If the core metadata specification lists a field as "Required", then', '    the metadata MUST specify the field statically or list it in dynamic', 'In turn, `core metadata`_ defines:', '    The required fields are: Metadata-Version, Name, Version.', '    All the other fields are optional.', 'Since ``Metadata-Version`` is defined by the build back-end, ``name`` and', '``version`` are the only mandatory information in ``pyproject.toml``.', '.. _core metadata: https://packaging.python.org/specifications/core-metadata/']}, 'then': {'required': ['version'], '$$description': ['version should be statically defined in the ``version`` field']}}, {'if': {'required': ['license-files']}, 'then': {'properties': {'license': {'type': 'string'}}}}], 'definitions': {'author': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}, 'anyOf': [{'required': ['name']}, {'required': ['email']}]}, 'entry-point-group': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, 'dependency': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}}}, rule='type')
+    data_is_dict = isinstance(data, dict)
+    if data_is_dict:
+        data_keys = set(data.keys())
+        if "build-system" in data_keys:
+            data_keys.remove("build-system")
+            data__buildsystem = data["build-system"]
+            if not isinstance(data__buildsystem, (dict)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".build-system must be object", value=data__buildsystem, name="" + (name_prefix or "data") + ".build-system", definition={'type': 'object', 'description': 'Table used to store build-related data', 'additionalProperties': False, 'properties': {'requires': {'type': 'array', '$$description': ['List of dependencies in the :pep:`508` format required to execute the build', 'system. Please notice that the resulting dependency graph', '**MUST NOT contain cycles**'], 'items': {'type': 'string'}}, 'build-backend': {'type': 'string', 'description': 'Python object that will be used to perform the build according to :pep:`517`', 'format': 'pep517-backend-reference'}, 'backend-path': {'type': 'array', '$$description': ['List of directories to be prepended to ``sys.path`` when loading the', 'back-end, and running its hooks'], 'items': {'type': 'string', '$comment': 'Should be a path (TODO: enforce it with format?)'}}}, 'required': ['requires']}, rule='type')
+            data__buildsystem_is_dict = isinstance(data__buildsystem, dict)
+            if data__buildsystem_is_dict:
+                data__buildsystem__missing_keys = set(['requires']) - data__buildsystem.keys()
+                if data__buildsystem__missing_keys:
+                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".build-system must contain " + (str(sorted(data__buildsystem__missing_keys)) + " properties"), value=data__buildsystem, name="" + (name_prefix or "data") + ".build-system", definition={'type': 'object', 'description': 'Table used to store build-related data', 'additionalProperties': False, 'properties': {'requires': {'type': 'array', '$$description': ['List of dependencies in the :pep:`508` format required to execute the build', 'system. Please notice that the resulting dependency graph', '**MUST NOT contain cycles**'], 'items': {'type': 'string'}}, 'build-backend': {'type': 'string', 'description': 'Python object that will be used to perform the build according to :pep:`517`', 'format': 'pep517-backend-reference'}, 'backend-path': {'type': 'array', '$$description': ['List of directories to be prepended to ``sys.path`` when loading the', 'back-end, and running its hooks'], 'items': {'type': 'string', '$comment': 'Should be a path (TODO: enforce it with format?)'}}}, 'required': ['requires']}, rule='required')
+                data__buildsystem_keys = set(data__buildsystem.keys())
+                if "requires" in data__buildsystem_keys:
+                    data__buildsystem_keys.remove("requires")
+                    data__buildsystem__requires = data__buildsystem["requires"]
+                    if not isinstance(data__buildsystem__requires, (list, tuple)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".build-system.requires must be array", value=data__buildsystem__requires, name="" + (name_prefix or "data") + ".build-system.requires", definition={'type': 'array', '$$description': ['List of dependencies in the :pep:`508` format required to execute the build', 'system. Please notice that the resulting dependency graph', '**MUST NOT contain cycles**'], 'items': {'type': 'string'}}, rule='type')
+                    data__buildsystem__requires_is_list = isinstance(data__buildsystem__requires, (list, tuple))
+                    if data__buildsystem__requires_is_list:
+                        data__buildsystem__requires_len = len(data__buildsystem__requires)
+                        for data__buildsystem__requires_x, data__buildsystem__requires_item in enumerate(data__buildsystem__requires):
+                            if not isinstance(data__buildsystem__requires_item, (str)):
+                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".build-system.requires[{data__buildsystem__requires_x}]".format(**locals()) + " must be string", value=data__buildsystem__requires_item, name="" + (name_prefix or "data") + ".build-system.requires[{data__buildsystem__requires_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+                if "build-backend" in data__buildsystem_keys:
+                    data__buildsystem_keys.remove("build-backend")
+                    data__buildsystem__buildbackend = data__buildsystem["build-backend"]
+                    if not isinstance(data__buildsystem__buildbackend, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".build-system.build-backend must be string", value=data__buildsystem__buildbackend, name="" + (name_prefix or "data") + ".build-system.build-backend", definition={'type': 'string', 'description': 'Python object that will be used to perform the build according to :pep:`517`', 'format': 'pep517-backend-reference'}, rule='type')
+                    if isinstance(data__buildsystem__buildbackend, str):
+                        if not custom_formats["pep517-backend-reference"](data__buildsystem__buildbackend):
+                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".build-system.build-backend must be pep517-backend-reference", value=data__buildsystem__buildbackend, name="" + (name_prefix or "data") + ".build-system.build-backend", definition={'type': 'string', 'description': 'Python object that will be used to perform the build according to :pep:`517`', 'format': 'pep517-backend-reference'}, rule='format')
+                if "backend-path" in data__buildsystem_keys:
+                    data__buildsystem_keys.remove("backend-path")
+                    data__buildsystem__backendpath = data__buildsystem["backend-path"]
+                    if not isinstance(data__buildsystem__backendpath, (list, tuple)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".build-system.backend-path must be array", value=data__buildsystem__backendpath, name="" + (name_prefix or "data") + ".build-system.backend-path", definition={'type': 'array', '$$description': ['List of directories to be prepended to ``sys.path`` when loading the', 'back-end, and running its hooks'], 'items': {'type': 'string', '$comment': 'Should be a path (TODO: enforce it with format?)'}}, rule='type')
+                    data__buildsystem__backendpath_is_list = isinstance(data__buildsystem__backendpath, (list, tuple))
+                    if data__buildsystem__backendpath_is_list:
+                        data__buildsystem__backendpath_len = len(data__buildsystem__backendpath)
+                        for data__buildsystem__backendpath_x, data__buildsystem__backendpath_item in enumerate(data__buildsystem__backendpath):
+                            if not isinstance(data__buildsystem__backendpath_item, (str)):
+                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".build-system.backend-path[{data__buildsystem__backendpath_x}]".format(**locals()) + " must be string", value=data__buildsystem__backendpath_item, name="" + (name_prefix or "data") + ".build-system.backend-path[{data__buildsystem__backendpath_x}]".format(**locals()) + "", definition={'type': 'string', '$comment': 'Should be a path (TODO: enforce it with format?)'}, rule='type')
+                if data__buildsystem_keys:
+                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".build-system must not contain "+str(data__buildsystem_keys)+" properties", value=data__buildsystem, name="" + (name_prefix or "data") + ".build-system", definition={'type': 'object', 'description': 'Table used to store build-related data', 'additionalProperties': False, 'properties': {'requires': {'type': 'array', '$$description': ['List of dependencies in the :pep:`508` format required to execute the build', 'system. Please notice that the resulting dependency graph', '**MUST NOT contain cycles**'], 'items': {'type': 'string'}}, 'build-backend': {'type': 'string', 'description': 'Python object that will be used to perform the build according to :pep:`517`', 'format': 'pep517-backend-reference'}, 'backend-path': {'type': 'array', '$$description': ['List of directories to be prepended to ``sys.path`` when loading the', 'back-end, and running its hooks'], 'items': {'type': 'string', '$comment': 'Should be a path (TODO: enforce it with format?)'}}}, 'required': ['requires']}, rule='additionalProperties')
+        if "project" in data_keys:
+            data_keys.remove("project")
+            data__project = data["project"]
+            validate_https___packaging_python_org_en_latest_specifications_pyproject_toml(data__project, custom_formats, (name_prefix or "data") + ".project")
+        if "tool" in data_keys:
+            data_keys.remove("tool")
+            data__tool = data["tool"]
+            if not isinstance(data__tool, (dict)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".tool must be object", value=data__tool, name="" + (name_prefix or "data") + ".tool", definition={'type': 'object', 'properties': {'distutils': {'$schema': 'http://json-schema.org/draft-07/schema#', '$id': 'https://setuptools.pypa.io/en/latest/deprecated/distutils/configfile.html', 'title': '``tool.distutils`` table', '$$description': ['**EXPERIMENTAL** (NOT OFFICIALLY SUPPORTED): Use ``tool.distutils``', 'subtables to configure arguments for ``distutils`` commands.', 'Originally, ``distutils`` allowed developers to configure arguments for', '``setup.py`` commands via `distutils configuration files', '`_.', 'See also `the old Python docs _`.'], 'type': 'object', 'properties': {'global': {'type': 'object', 'description': 'Global options applied to all ``distutils`` commands'}}, 'patternProperties': {'.+': {'type': 'object'}}, '$comment': 'TODO: Is there a practical way of making this schema more specific?'}, 'setuptools': {'$schema': 'http://json-schema.org/draft-07/schema#', '$id': 'https://setuptools.pypa.io/en/latest/userguide/pyproject_config.html', 'title': '``tool.setuptools`` table', '$$description': ['``setuptools``-specific configurations that can be set by users that require', 'customization.', 'These configurations are completely optional and probably can be skipped when', 'creating simple packages. They are equivalent to some of the `Keywords', '`_', 'used by the ``setup.py`` file, and can be set via the ``tool.setuptools`` table.', 'It considers only ``setuptools`` `parameters', '`_', 'that are not covered by :pep:`621`; and intentionally excludes ``dependency_links``', 'and ``setup_requires`` (incompatible with modern workflows/standards).'], 'type': 'object', 'additionalProperties': False, 'properties': {'platforms': {'type': 'array', 'items': {'type': 'string'}}, 'provides': {'$$description': ['Package and virtual package names contained within this package', '**(not supported by pip)**'], 'type': 'array', 'items': {'type': 'string', 'format': 'pep508-identifier'}}, 'obsoletes': {'$$description': ['Packages which this package renders obsolete', '**(not supported by pip)**'], 'type': 'array', 'items': {'type': 'string', 'format': 'pep508-identifier'}}, 'zip-safe': {'$$description': ['Whether the project can be safely installed and run from a zip file.', '**OBSOLETE**: only relevant for ``pkg_resources``, ``easy_install`` and', '``setup.py install`` in the context of ``eggs`` (**DEPRECATED**).'], 'type': 'boolean'}, 'script-files': {'$$description': ['Legacy way of defining scripts (entry-points are preferred).', 'Equivalent to the ``script`` keyword in ``setup.py``', '(it was renamed to avoid confusion with entry-point based ``project.scripts``', 'defined in :pep:`621`).', '**DISCOURAGED**: generic script wrappers are tricky and may not work properly.', 'Whenever possible, please use ``project.scripts`` instead.'], 'type': 'array', 'items': {'type': 'string'}, '$comment': 'TODO: is this field deprecated/should be removed?'}, 'eager-resources': {'$$description': ['Resources that should be extracted together, if any of them is needed,', 'or if any C extensions included in the project are imported.', '**OBSOLETE**: only relevant for ``pkg_resources``, ``easy_install`` and', '``setup.py install`` in the context of ``eggs`` (**DEPRECATED**).'], 'type': 'array', 'items': {'type': 'string'}}, 'packages': {'$$description': ['Packages that should be included in the distribution.', 'It can be given either as a list of package identifiers', 'or as a ``dict``-like structure with a single key ``find``', 'which corresponds to a dynamic call to', '``setuptools.config.expand.find_packages`` function.', 'The ``find`` key is associated with a nested ``dict``-like structure that can', 'contain ``where``, ``include``, ``exclude`` and ``namespaces`` keys,', 'mimicking the keyword arguments of the associated function.'], 'oneOf': [{'title': 'Array of Python package identifiers', 'type': 'array', 'items': {'$ref': '#/definitions/package-name'}}, {'$ref': '#/definitions/find-directive'}]}, 'package-dir': {'$$description': [':class:`dict`-like structure mapping from package names to directories where their', 'code can be found.', 'The empty string (as key) means that all packages are contained inside', 'the given directory will be included in the distribution.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'anyOf': [{'const': ''}, {'$ref': '#/definitions/package-name'}]}, 'patternProperties': {'^.*$': {'type': 'string'}}}, 'package-data': {'$$description': ['Mapping from package names to lists of glob patterns.', 'Usually this option is not needed when using ``include-package-data = true``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'anyOf': [{'$ref': '#/definitions/package-name'}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'include-package-data': {'$$description': ['Automatically include any data files inside the package directories', 'that are specified by ``MANIFEST.in``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'boolean'}, 'exclude-package-data': {'$$description': ['Mapping from package names to lists of glob patterns that should be excluded', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'anyOf': [{'$ref': '#/definitions/package-name'}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'namespace-packages': {'type': 'array', 'items': {'type': 'string', 'format': 'python-module-name-relaxed'}, '$comment': 'https://setuptools.pypa.io/en/latest/userguide/package_discovery.html', 'description': '**DEPRECATED**: use implicit namespaces instead (:pep:`420`).'}, 'py-modules': {'description': 'Modules that setuptools will manipulate', 'type': 'array', 'items': {'type': 'string', 'format': 'python-module-name-relaxed'}, '$comment': 'TODO: clarify the relationship with ``packages``'}, 'ext-modules': {'description': 'Extension modules to be compiled by setuptools', 'type': 'array', 'items': {'$ref': '#/definitions/ext-module'}}, 'data-files': {'$$description': ['``dict``-like structure where each key represents a directory and', 'the value is a list of glob patterns that should be installed in them.', '**DISCOURAGED**: please notice this might not work as expected with wheels.', 'Whenever possible, consider using data files inside the package directories', '(or create a new namespace package that only contains data files).', 'See `data files support', '`_.'], 'type': 'object', 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'cmdclass': {'$$description': ['Mapping of distutils-style command names to ``setuptools.Command`` subclasses', 'which in turn should be represented by strings with a qualified class name', '(i.e., "dotted" form with module), e.g.::\n\n', '    cmdclass = {mycmd = "pkg.subpkg.module.CommandClass"}\n\n', 'The command class should be a directly defined at the top-level of the', 'containing module (no class nesting).'], 'type': 'object', 'patternProperties': {'^.*$': {'type': 'string', 'format': 'python-qualified-identifier'}}}, 'license-files': {'type': 'array', 'items': {'type': 'string'}, '$$description': ['**PROVISIONAL**: list of glob patterns for all license files being distributed.', '(likely to become standard with :pep:`639`).', "By default: ``['LICEN[CS]E*', 'COPYING*', 'NOTICE*', 'AUTHORS*']``"], '$comment': 'TODO: revise if PEP 639 is accepted. Probably ``project.license-files``?'}, 'dynamic': {'type': 'object', 'description': 'Instructions for loading :pep:`621`-related metadata dynamically', 'additionalProperties': False, 'properties': {'version': {'$$description': ['A version dynamically loaded via either the ``attr:`` or ``file:``', 'directives. Please make sure the given file or attribute respects :pep:`440`.', 'Also ensure to set ``project.dynamic`` accordingly.'], 'oneOf': [{'$ref': '#/definitions/attr-directive'}, {'$ref': '#/definitions/file-directive'}]}, 'classifiers': {'$ref': '#/definitions/file-directive'}, 'description': {'$ref': '#/definitions/file-directive'}, 'entry-points': {'$ref': '#/definitions/file-directive'}, 'dependencies': {'$ref': '#/definitions/file-directive-for-dependencies'}, 'optional-dependencies': {'type': 'object', 'propertyNames': {'type': 'string', 'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'.+': {'$ref': '#/definitions/file-directive-for-dependencies'}}}, 'readme': {'type': 'object', 'anyOf': [{'$ref': '#/definitions/file-directive'}, {'type': 'object', 'properties': {'content-type': {'type': 'string'}, 'file': {'$ref': '#/definitions/file-directive/properties/file'}}, 'additionalProperties': False}], 'required': ['file']}}}}, 'definitions': {'package-name': {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}, 'ext-module': {'$id': '#/definitions/ext-module', 'title': 'Extension module', 'description': 'Parameters to construct a :class:`setuptools.Extension` object', 'type': 'object', 'required': ['name', 'sources'], 'additionalProperties': False, 'properties': {'name': {'type': 'string', 'format': 'python-module-name-relaxed'}, 'sources': {'type': 'array', 'items': {'type': 'string'}}, 'include-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'define-macros': {'type': 'array', 'items': {'type': 'array', 'items': [{'description': 'macro name', 'type': 'string'}, {'description': 'macro value', 'oneOf': [{'type': 'string'}, {'type': 'null'}]}], 'additionalItems': False}}, 'undef-macros': {'type': 'array', 'items': {'type': 'string'}}, 'library-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'libraries': {'type': 'array', 'items': {'type': 'string'}}, 'runtime-library-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'extra-objects': {'type': 'array', 'items': {'type': 'string'}}, 'extra-compile-args': {'type': 'array', 'items': {'type': 'string'}}, 'extra-link-args': {'type': 'array', 'items': {'type': 'string'}}, 'export-symbols': {'type': 'array', 'items': {'type': 'string'}}, 'swig-opts': {'type': 'array', 'items': {'type': 'string'}}, 'depends': {'type': 'array', 'items': {'type': 'string'}}, 'language': {'type': 'string'}, 'optional': {'type': 'boolean'}, 'py-limited-api': {'type': 'boolean'}}}, 'file-directive': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'file-directive-for-dependencies': {'title': "'file:' directive for dependencies", 'allOf': [{'$$description': ['**BETA**: subset of the ``requirements.txt`` format', 'without ``pip`` flags and options', '(one :pep:`508`-compliant string per line,', 'lines that are blank or start with ``#`` are excluded).', 'See `dynamic metadata', '`_.']}, {'$ref': '#/definitions/file-directive'}]}, 'attr-directive': {'title': "'attr:' directive", '$id': '#/definitions/attr-directive', '$$description': ['Value is read from a module attribute. Supports callables and iterables;', 'unsupported types are cast via ``str()``'], 'type': 'object', 'additionalProperties': False, 'properties': {'attr': {'type': 'string', 'format': 'python-qualified-identifier'}}, 'required': ['attr']}, 'find-directive': {'$id': '#/definitions/find-directive', 'title': "'find:' directive", 'type': 'object', 'additionalProperties': False, 'properties': {'find': {'type': 'object', '$$description': ['Dynamic `package discovery', '`_.'], 'additionalProperties': False, 'properties': {'where': {'description': 'Directories to be searched for packages (Unix-style relative path)', 'type': 'array', 'items': {'type': 'string'}}, 'exclude': {'type': 'array', '$$description': ['Exclude packages that match the values listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'include': {'type': 'array', '$$description': ['Restrict the found packages to just the ones listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'namespaces': {'type': 'boolean', '$$description': ['When ``True``, directories without a ``__init__.py`` file will also', 'be scanned for :pep:`420`-style implicit namespaces']}}}}}}}}}, rule='type')
+            data__tool_is_dict = isinstance(data__tool, dict)
+            if data__tool_is_dict:
+                data__tool_keys = set(data__tool.keys())
+                if "distutils" in data__tool_keys:
+                    data__tool_keys.remove("distutils")
+                    data__tool__distutils = data__tool["distutils"]
+                    validate_https___setuptools_pypa_io_en_latest_deprecated_distutils_configfile_html(data__tool__distutils, custom_formats, (name_prefix or "data") + ".tool.distutils")
+                if "setuptools" in data__tool_keys:
+                    data__tool_keys.remove("setuptools")
+                    data__tool__setuptools = data__tool["setuptools"]
+                    validate_https___setuptools_pypa_io_en_latest_userguide_pyproject_config_html(data__tool__setuptools, custom_formats, (name_prefix or "data") + ".tool.setuptools")
+        if "dependency-groups" in data_keys:
+            data_keys.remove("dependency-groups")
+            data__dependencygroups = data["dependency-groups"]
+            if not isinstance(data__dependencygroups, (dict)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".dependency-groups must be object", value=data__dependencygroups, name="" + (name_prefix or "data") + ".dependency-groups", definition={'type': 'object', 'description': 'Dependency groups following PEP 735', 'additionalProperties': False, 'patternProperties': {'^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9._-]*[a-zA-Z0-9])$': {'type': 'array', 'items': {'oneOf': [{'type': 'string', 'description': 'Python package specifiers following PEP 508', 'format': 'pep508'}, {'type': 'object', 'additionalProperties': False, 'properties': {'include-group': {'description': 'Another dependency group to include in this one', 'type': 'string', 'pattern': '^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9._-]*[a-zA-Z0-9])$'}}}]}}}}, rule='type')
+            data__dependencygroups_is_dict = isinstance(data__dependencygroups, dict)
+            if data__dependencygroups_is_dict:
+                data__dependencygroups_keys = set(data__dependencygroups.keys())
+                for data__dependencygroups_key, data__dependencygroups_val in data__dependencygroups.items():
+                    if REGEX_PATTERNS['^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9._-]*[a-zA-Z0-9])$'].search(data__dependencygroups_key):
+                        if data__dependencygroups_key in data__dependencygroups_keys:
+                            data__dependencygroups_keys.remove(data__dependencygroups_key)
+                        if not isinstance(data__dependencygroups_val, (list, tuple)):
+                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".dependency-groups.{data__dependencygroups_key}".format(**locals()) + " must be array", value=data__dependencygroups_val, name="" + (name_prefix or "data") + ".dependency-groups.{data__dependencygroups_key}".format(**locals()) + "", definition={'type': 'array', 'items': {'oneOf': [{'type': 'string', 'description': 'Python package specifiers following PEP 508', 'format': 'pep508'}, {'type': 'object', 'additionalProperties': False, 'properties': {'include-group': {'description': 'Another dependency group to include in this one', 'type': 'string', 'pattern': '^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9._-]*[a-zA-Z0-9])$'}}}]}}, rule='type')
+                        data__dependencygroups_val_is_list = isinstance(data__dependencygroups_val, (list, tuple))
+                        if data__dependencygroups_val_is_list:
+                            data__dependencygroups_val_len = len(data__dependencygroups_val)
+                            for data__dependencygroups_val_x, data__dependencygroups_val_item in enumerate(data__dependencygroups_val):
+                                data__dependencygroups_val_item_one_of_count1 = 0
+                                if data__dependencygroups_val_item_one_of_count1 < 2:
+                                    try:
+                                        if not isinstance(data__dependencygroups_val_item, (str)):
+                                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".dependency-groups.{data__dependencygroups_key}[{data__dependencygroups_val_x}]".format(**locals()) + " must be string", value=data__dependencygroups_val_item, name="" + (name_prefix or "data") + ".dependency-groups.{data__dependencygroups_key}[{data__dependencygroups_val_x}]".format(**locals()) + "", definition={'type': 'string', 'description': 'Python package specifiers following PEP 508', 'format': 'pep508'}, rule='type')
+                                        if isinstance(data__dependencygroups_val_item, str):
+                                            if not custom_formats["pep508"](data__dependencygroups_val_item):
+                                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".dependency-groups.{data__dependencygroups_key}[{data__dependencygroups_val_x}]".format(**locals()) + " must be pep508", value=data__dependencygroups_val_item, name="" + (name_prefix or "data") + ".dependency-groups.{data__dependencygroups_key}[{data__dependencygroups_val_x}]".format(**locals()) + "", definition={'type': 'string', 'description': 'Python package specifiers following PEP 508', 'format': 'pep508'}, rule='format')
+                                        data__dependencygroups_val_item_one_of_count1 += 1
+                                    except JsonSchemaValueException: pass
+                                if data__dependencygroups_val_item_one_of_count1 < 2:
+                                    try:
+                                        if not isinstance(data__dependencygroups_val_item, (dict)):
+                                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".dependency-groups.{data__dependencygroups_key}[{data__dependencygroups_val_x}]".format(**locals()) + " must be object", value=data__dependencygroups_val_item, name="" + (name_prefix or "data") + ".dependency-groups.{data__dependencygroups_key}[{data__dependencygroups_val_x}]".format(**locals()) + "", definition={'type': 'object', 'additionalProperties': False, 'properties': {'include-group': {'description': 'Another dependency group to include in this one', 'type': 'string', 'pattern': '^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9._-]*[a-zA-Z0-9])$'}}}, rule='type')
+                                        data__dependencygroups_val_item_is_dict = isinstance(data__dependencygroups_val_item, dict)
+                                        if data__dependencygroups_val_item_is_dict:
+                                            data__dependencygroups_val_item_keys = set(data__dependencygroups_val_item.keys())
+                                            if "include-group" in data__dependencygroups_val_item_keys:
+                                                data__dependencygroups_val_item_keys.remove("include-group")
+                                                data__dependencygroups_val_item__includegroup = data__dependencygroups_val_item["include-group"]
+                                                if not isinstance(data__dependencygroups_val_item__includegroup, (str)):
+                                                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".dependency-groups.{data__dependencygroups_key}[{data__dependencygroups_val_x}].include-group".format(**locals()) + " must be string", value=data__dependencygroups_val_item__includegroup, name="" + (name_prefix or "data") + ".dependency-groups.{data__dependencygroups_key}[{data__dependencygroups_val_x}].include-group".format(**locals()) + "", definition={'description': 'Another dependency group to include in this one', 'type': 'string', 'pattern': '^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9._-]*[a-zA-Z0-9])$'}, rule='type')
+                                                if isinstance(data__dependencygroups_val_item__includegroup, str):
+                                                    if not REGEX_PATTERNS['^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9._-]*[a-zA-Z0-9])$'].search(data__dependencygroups_val_item__includegroup):
+                                                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".dependency-groups.{data__dependencygroups_key}[{data__dependencygroups_val_x}].include-group".format(**locals()) + " must match pattern ^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9._-]*[a-zA-Z0-9])$", value=data__dependencygroups_val_item__includegroup, name="" + (name_prefix or "data") + ".dependency-groups.{data__dependencygroups_key}[{data__dependencygroups_val_x}].include-group".format(**locals()) + "", definition={'description': 'Another dependency group to include in this one', 'type': 'string', 'pattern': '^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9._-]*[a-zA-Z0-9])$'}, rule='pattern')
+                                            if data__dependencygroups_val_item_keys:
+                                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".dependency-groups.{data__dependencygroups_key}[{data__dependencygroups_val_x}]".format(**locals()) + " must not contain "+str(data__dependencygroups_val_item_keys)+" properties", value=data__dependencygroups_val_item, name="" + (name_prefix or "data") + ".dependency-groups.{data__dependencygroups_key}[{data__dependencygroups_val_x}]".format(**locals()) + "", definition={'type': 'object', 'additionalProperties': False, 'properties': {'include-group': {'description': 'Another dependency group to include in this one', 'type': 'string', 'pattern': '^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9._-]*[a-zA-Z0-9])$'}}}, rule='additionalProperties')
+                                        data__dependencygroups_val_item_one_of_count1 += 1
+                                    except JsonSchemaValueException: pass
+                                if data__dependencygroups_val_item_one_of_count1 != 1:
+                                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".dependency-groups.{data__dependencygroups_key}[{data__dependencygroups_val_x}]".format(**locals()) + " must be valid exactly by one definition" + (" (" + str(data__dependencygroups_val_item_one_of_count1) + " matches found)"), value=data__dependencygroups_val_item, name="" + (name_prefix or "data") + ".dependency-groups.{data__dependencygroups_key}[{data__dependencygroups_val_x}]".format(**locals()) + "", definition={'oneOf': [{'type': 'string', 'description': 'Python package specifiers following PEP 508', 'format': 'pep508'}, {'type': 'object', 'additionalProperties': False, 'properties': {'include-group': {'description': 'Another dependency group to include in this one', 'type': 'string', 'pattern': '^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9._-]*[a-zA-Z0-9])$'}}}]}, rule='oneOf')
+                if data__dependencygroups_keys:
+                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".dependency-groups must not contain "+str(data__dependencygroups_keys)+" properties", value=data__dependencygroups, name="" + (name_prefix or "data") + ".dependency-groups", definition={'type': 'object', 'description': 'Dependency groups following PEP 735', 'additionalProperties': False, 'patternProperties': {'^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9._-]*[a-zA-Z0-9])$': {'type': 'array', 'items': {'oneOf': [{'type': 'string', 'description': 'Python package specifiers following PEP 508', 'format': 'pep508'}, {'type': 'object', 'additionalProperties': False, 'properties': {'include-group': {'description': 'Another dependency group to include in this one', 'type': 'string', 'pattern': '^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9._-]*[a-zA-Z0-9])$'}}}]}}}}, rule='additionalProperties')
+        if data_keys:
+            raise JsonSchemaValueException("" + (name_prefix or "data") + " must not contain "+str(data_keys)+" properties", value=data, name="" + (name_prefix or "data") + "", definition={'$schema': 'http://json-schema.org/draft-07/schema#', '$id': 'https://packaging.python.org/en/latest/specifications/declaring-build-dependencies/', 'title': 'Data structure for ``pyproject.toml`` files', '$$description': ['File format containing build-time configurations for the Python ecosystem. ', ':pep:`517` initially defined a build-system independent format for source trees', 'which was complemented by :pep:`518` to provide a way of specifying dependencies ', 'for building Python projects.', 'Please notice the ``project`` table (as initially defined in  :pep:`621`) is not included', 'in this schema and should be considered separately.'], 'type': 'object', 'additionalProperties': False, 'properties': {'build-system': {'type': 'object', 'description': 'Table used to store build-related data', 'additionalProperties': False, 'properties': {'requires': {'type': 'array', '$$description': ['List of dependencies in the :pep:`508` format required to execute the build', 'system. Please notice that the resulting dependency graph', '**MUST NOT contain cycles**'], 'items': {'type': 'string'}}, 'build-backend': {'type': 'string', 'description': 'Python object that will be used to perform the build according to :pep:`517`', 'format': 'pep517-backend-reference'}, 'backend-path': {'type': 'array', '$$description': ['List of directories to be prepended to ``sys.path`` when loading the', 'back-end, and running its hooks'], 'items': {'type': 'string', '$comment': 'Should be a path (TODO: enforce it with format?)'}}}, 'required': ['requires']}, 'project': {'$schema': 'http://json-schema.org/draft-07/schema#', '$id': 'https://packaging.python.org/en/latest/specifications/pyproject-toml/', 'title': 'Package metadata stored in the ``project`` table', '$$description': ['Data structure for the **project** table inside ``pyproject.toml``', '(as initially defined in :pep:`621`)'], 'type': 'object', 'properties': {'name': {'type': 'string', 'description': 'The name (primary identifier) of the project. MUST be statically defined.', 'format': 'pep508-identifier'}, 'version': {'type': 'string', 'description': 'The version of the project as supported by :pep:`440`.', 'format': 'pep440'}, 'description': {'type': 'string', '$$description': ['The `summary description of the project', '`_']}, 'readme': {'$$description': ['`Full/detailed description of the project in the form of a README', '`_', "with meaning similar to the one defined in `core metadata's Description", '`_'], 'oneOf': [{'type': 'string', '$$description': ['Relative path to a text file (UTF-8) containing the full description', 'of the project. If the file path ends in case-insensitive ``.md`` or', '``.rst`` suffixes, then the content-type is respectively', '``text/markdown`` or ``text/x-rst``']}, {'type': 'object', 'allOf': [{'anyOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to a text file containing the full description', 'of the project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', 'description': 'Full text describing the project.'}}, 'required': ['text']}]}, {'properties': {'content-type': {'type': 'string', '$$description': ['Content-type (:rfc:`1341`) of the full description', '(e.g. ``text/markdown``). The ``charset`` parameter is assumed', 'UTF-8 when not present.'], '$comment': 'TODO: add regex pattern or format?'}}, 'required': ['content-type']}]}]}, 'requires-python': {'type': 'string', 'format': 'pep508-versionspec', '$$description': ['`The Python version requirements of the project', '`_.']}, 'license': {'description': '`Project license `_.', 'oneOf': [{'type': 'string', 'description': 'An SPDX license identifier', 'format': 'SPDX'}, {'type': 'object', 'properties': {'file': {'type': 'string', '$$description': ['Relative path to the file (UTF-8) which contains the license for the', 'project.']}}, 'required': ['file']}, {'type': 'object', 'properties': {'text': {'type': 'string', '$$description': ['The license of the project whose meaning is that of the', '`License field from the core metadata', '`_.']}}, 'required': ['text']}]}, 'license-files': {'description': 'Paths or globs to paths of license files', 'type': 'array', 'items': {'type': 'string'}}, 'authors': {'type': 'array', 'items': {'$ref': '#/definitions/author'}, '$$description': ["The people or organizations considered to be the 'authors' of the project.", 'The exact meaning is open to interpretation (e.g. original or primary authors,', 'current maintainers, or owners of the package).']}, 'maintainers': {'type': 'array', 'items': {'$ref': '#/definitions/author'}, '$$description': ["The people or organizations considered to be the 'maintainers' of the project.", 'Similarly to ``authors``, the exact meaning is open to interpretation.']}, 'keywords': {'type': 'array', 'items': {'type': 'string'}, 'description': 'List of keywords to assist searching for the distribution in a larger catalog.'}, 'classifiers': {'type': 'array', 'items': {'type': 'string', 'format': 'trove-classifier', 'description': '`PyPI classifier `_.'}, '$$description': ['`Trove classifiers `_', 'which apply to the project.']}, 'urls': {'type': 'object', 'description': 'URLs associated with the project in the form ``label => value``.', 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', 'format': 'url'}}}, 'scripts': {'$ref': '#/definitions/entry-point-group', '$$description': ['Instruct the installer to create command-line wrappers for the given', '`entry points `_.']}, 'gui-scripts': {'$ref': '#/definitions/entry-point-group', '$$description': ['Instruct the installer to create GUI wrappers for the given', '`entry points `_.', 'The difference between ``scripts`` and ``gui-scripts`` is only relevant in', 'Windows.']}, 'entry-points': {'$$description': ['Instruct the installer to expose the given modules/functions via', '``entry-point`` discovery mechanism (useful for plugins).', 'More information available in the `Python packaging guide', '`_.'], 'propertyNames': {'format': 'python-entrypoint-group'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'$ref': '#/definitions/entry-point-group'}}}, 'dependencies': {'type': 'array', 'description': 'Project (mandatory) dependencies.', 'items': {'$ref': '#/definitions/dependency'}}, 'optional-dependencies': {'type': 'object', 'description': 'Optional dependency for the project', 'propertyNames': {'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'array', 'items': {'$ref': '#/definitions/dependency'}}}}, 'import-names': {'description': 'Lists import names which a project, when installed, would exclusively provide.', 'type': 'array', 'items': {'type': 'string', 'format': 'import-name'}}, 'import-namespaces': {'description': 'Lists import names that, when installed, would be provided by the project, but not exclusively.', 'type': 'array', 'items': {'type': 'string', 'format': 'import-name'}}, 'dynamic': {'type': 'array', '$$description': ['Specifies which fields are intentionally unspecified and expected to be', 'dynamically provided by build tools'], 'items': {'enum': ['version', 'description', 'readme', 'requires-python', 'license', 'license-files', 'authors', 'maintainers', 'keywords', 'classifiers', 'urls', 'scripts', 'gui-scripts', 'entry-points', 'dependencies', 'optional-dependencies', 'import-names', 'import-namespaces']}}}, 'required': ['name'], 'additionalProperties': False, 'allOf': [{'if': {'not': {'required': ['dynamic'], 'properties': {'dynamic': {'contains': {'const': 'version'}, '$$description': ['version is listed in ``dynamic``']}}}, '$$comment': ['According to :pep:`621`:', '    If the core metadata specification lists a field as "Required", then', '    the metadata MUST specify the field statically or list it in dynamic', 'In turn, `core metadata`_ defines:', '    The required fields are: Metadata-Version, Name, Version.', '    All the other fields are optional.', 'Since ``Metadata-Version`` is defined by the build back-end, ``name`` and', '``version`` are the only mandatory information in ``pyproject.toml``.', '.. _core metadata: https://packaging.python.org/specifications/core-metadata/']}, 'then': {'required': ['version'], '$$description': ['version should be statically defined in the ``version`` field']}}, {'if': {'required': ['license-files']}, 'then': {'properties': {'license': {'type': 'string'}}}}], 'definitions': {'author': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}, 'anyOf': [{'required': ['name']}, {'required': ['email']}]}, 'entry-point-group': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, 'dependency': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}}, 'tool': {'type': 'object', 'properties': {'distutils': {'$schema': 'http://json-schema.org/draft-07/schema#', '$id': 'https://setuptools.pypa.io/en/latest/deprecated/distutils/configfile.html', 'title': '``tool.distutils`` table', '$$description': ['**EXPERIMENTAL** (NOT OFFICIALLY SUPPORTED): Use ``tool.distutils``', 'subtables to configure arguments for ``distutils`` commands.', 'Originally, ``distutils`` allowed developers to configure arguments for', '``setup.py`` commands via `distutils configuration files', '`_.', 'See also `the old Python docs _`.'], 'type': 'object', 'properties': {'global': {'type': 'object', 'description': 'Global options applied to all ``distutils`` commands'}}, 'patternProperties': {'.+': {'type': 'object'}}, '$comment': 'TODO: Is there a practical way of making this schema more specific?'}, 'setuptools': {'$schema': 'http://json-schema.org/draft-07/schema#', '$id': 'https://setuptools.pypa.io/en/latest/userguide/pyproject_config.html', 'title': '``tool.setuptools`` table', '$$description': ['``setuptools``-specific configurations that can be set by users that require', 'customization.', 'These configurations are completely optional and probably can be skipped when', 'creating simple packages. They are equivalent to some of the `Keywords', '`_', 'used by the ``setup.py`` file, and can be set via the ``tool.setuptools`` table.', 'It considers only ``setuptools`` `parameters', '`_', 'that are not covered by :pep:`621`; and intentionally excludes ``dependency_links``', 'and ``setup_requires`` (incompatible with modern workflows/standards).'], 'type': 'object', 'additionalProperties': False, 'properties': {'platforms': {'type': 'array', 'items': {'type': 'string'}}, 'provides': {'$$description': ['Package and virtual package names contained within this package', '**(not supported by pip)**'], 'type': 'array', 'items': {'type': 'string', 'format': 'pep508-identifier'}}, 'obsoletes': {'$$description': ['Packages which this package renders obsolete', '**(not supported by pip)**'], 'type': 'array', 'items': {'type': 'string', 'format': 'pep508-identifier'}}, 'zip-safe': {'$$description': ['Whether the project can be safely installed and run from a zip file.', '**OBSOLETE**: only relevant for ``pkg_resources``, ``easy_install`` and', '``setup.py install`` in the context of ``eggs`` (**DEPRECATED**).'], 'type': 'boolean'}, 'script-files': {'$$description': ['Legacy way of defining scripts (entry-points are preferred).', 'Equivalent to the ``script`` keyword in ``setup.py``', '(it was renamed to avoid confusion with entry-point based ``project.scripts``', 'defined in :pep:`621`).', '**DISCOURAGED**: generic script wrappers are tricky and may not work properly.', 'Whenever possible, please use ``project.scripts`` instead.'], 'type': 'array', 'items': {'type': 'string'}, '$comment': 'TODO: is this field deprecated/should be removed?'}, 'eager-resources': {'$$description': ['Resources that should be extracted together, if any of them is needed,', 'or if any C extensions included in the project are imported.', '**OBSOLETE**: only relevant for ``pkg_resources``, ``easy_install`` and', '``setup.py install`` in the context of ``eggs`` (**DEPRECATED**).'], 'type': 'array', 'items': {'type': 'string'}}, 'packages': {'$$description': ['Packages that should be included in the distribution.', 'It can be given either as a list of package identifiers', 'or as a ``dict``-like structure with a single key ``find``', 'which corresponds to a dynamic call to', '``setuptools.config.expand.find_packages`` function.', 'The ``find`` key is associated with a nested ``dict``-like structure that can', 'contain ``where``, ``include``, ``exclude`` and ``namespaces`` keys,', 'mimicking the keyword arguments of the associated function.'], 'oneOf': [{'title': 'Array of Python package identifiers', 'type': 'array', 'items': {'$ref': '#/definitions/package-name'}}, {'$ref': '#/definitions/find-directive'}]}, 'package-dir': {'$$description': [':class:`dict`-like structure mapping from package names to directories where their', 'code can be found.', 'The empty string (as key) means that all packages are contained inside', 'the given directory will be included in the distribution.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'anyOf': [{'const': ''}, {'$ref': '#/definitions/package-name'}]}, 'patternProperties': {'^.*$': {'type': 'string'}}}, 'package-data': {'$$description': ['Mapping from package names to lists of glob patterns.', 'Usually this option is not needed when using ``include-package-data = true``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'anyOf': [{'$ref': '#/definitions/package-name'}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'include-package-data': {'$$description': ['Automatically include any data files inside the package directories', 'that are specified by ``MANIFEST.in``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'boolean'}, 'exclude-package-data': {'$$description': ['Mapping from package names to lists of glob patterns that should be excluded', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'anyOf': [{'$ref': '#/definitions/package-name'}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'namespace-packages': {'type': 'array', 'items': {'type': 'string', 'format': 'python-module-name-relaxed'}, '$comment': 'https://setuptools.pypa.io/en/latest/userguide/package_discovery.html', 'description': '**DEPRECATED**: use implicit namespaces instead (:pep:`420`).'}, 'py-modules': {'description': 'Modules that setuptools will manipulate', 'type': 'array', 'items': {'type': 'string', 'format': 'python-module-name-relaxed'}, '$comment': 'TODO: clarify the relationship with ``packages``'}, 'ext-modules': {'description': 'Extension modules to be compiled by setuptools', 'type': 'array', 'items': {'$ref': '#/definitions/ext-module'}}, 'data-files': {'$$description': ['``dict``-like structure where each key represents a directory and', 'the value is a list of glob patterns that should be installed in them.', '**DISCOURAGED**: please notice this might not work as expected with wheels.', 'Whenever possible, consider using data files inside the package directories', '(or create a new namespace package that only contains data files).', 'See `data files support', '`_.'], 'type': 'object', 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'cmdclass': {'$$description': ['Mapping of distutils-style command names to ``setuptools.Command`` subclasses', 'which in turn should be represented by strings with a qualified class name', '(i.e., "dotted" form with module), e.g.::\n\n', '    cmdclass = {mycmd = "pkg.subpkg.module.CommandClass"}\n\n', 'The command class should be a directly defined at the top-level of the', 'containing module (no class nesting).'], 'type': 'object', 'patternProperties': {'^.*$': {'type': 'string', 'format': 'python-qualified-identifier'}}}, 'license-files': {'type': 'array', 'items': {'type': 'string'}, '$$description': ['**PROVISIONAL**: list of glob patterns for all license files being distributed.', '(likely to become standard with :pep:`639`).', "By default: ``['LICEN[CS]E*', 'COPYING*', 'NOTICE*', 'AUTHORS*']``"], '$comment': 'TODO: revise if PEP 639 is accepted. Probably ``project.license-files``?'}, 'dynamic': {'type': 'object', 'description': 'Instructions for loading :pep:`621`-related metadata dynamically', 'additionalProperties': False, 'properties': {'version': {'$$description': ['A version dynamically loaded via either the ``attr:`` or ``file:``', 'directives. Please make sure the given file or attribute respects :pep:`440`.', 'Also ensure to set ``project.dynamic`` accordingly.'], 'oneOf': [{'$ref': '#/definitions/attr-directive'}, {'$ref': '#/definitions/file-directive'}]}, 'classifiers': {'$ref': '#/definitions/file-directive'}, 'description': {'$ref': '#/definitions/file-directive'}, 'entry-points': {'$ref': '#/definitions/file-directive'}, 'dependencies': {'$ref': '#/definitions/file-directive-for-dependencies'}, 'optional-dependencies': {'type': 'object', 'propertyNames': {'type': 'string', 'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'.+': {'$ref': '#/definitions/file-directive-for-dependencies'}}}, 'readme': {'type': 'object', 'anyOf': [{'$ref': '#/definitions/file-directive'}, {'type': 'object', 'properties': {'content-type': {'type': 'string'}, 'file': {'$ref': '#/definitions/file-directive/properties/file'}}, 'additionalProperties': False}], 'required': ['file']}}}}, 'definitions': {'package-name': {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}, 'ext-module': {'$id': '#/definitions/ext-module', 'title': 'Extension module', 'description': 'Parameters to construct a :class:`setuptools.Extension` object', 'type': 'object', 'required': ['name', 'sources'], 'additionalProperties': False, 'properties': {'name': {'type': 'string', 'format': 'python-module-name-relaxed'}, 'sources': {'type': 'array', 'items': {'type': 'string'}}, 'include-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'define-macros': {'type': 'array', 'items': {'type': 'array', 'items': [{'description': 'macro name', 'type': 'string'}, {'description': 'macro value', 'oneOf': [{'type': 'string'}, {'type': 'null'}]}], 'additionalItems': False}}, 'undef-macros': {'type': 'array', 'items': {'type': 'string'}}, 'library-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'libraries': {'type': 'array', 'items': {'type': 'string'}}, 'runtime-library-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'extra-objects': {'type': 'array', 'items': {'type': 'string'}}, 'extra-compile-args': {'type': 'array', 'items': {'type': 'string'}}, 'extra-link-args': {'type': 'array', 'items': {'type': 'string'}}, 'export-symbols': {'type': 'array', 'items': {'type': 'string'}}, 'swig-opts': {'type': 'array', 'items': {'type': 'string'}}, 'depends': {'type': 'array', 'items': {'type': 'string'}}, 'language': {'type': 'string'}, 'optional': {'type': 'boolean'}, 'py-limited-api': {'type': 'boolean'}}}, 'file-directive': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'file-directive-for-dependencies': {'title': "'file:' directive for dependencies", 'allOf': [{'$$description': ['**BETA**: subset of the ``requirements.txt`` format', 'without ``pip`` flags and options', '(one :pep:`508`-compliant string per line,', 'lines that are blank or start with ``#`` are excluded).', 'See `dynamic metadata', '`_.']}, {'$ref': '#/definitions/file-directive'}]}, 'attr-directive': {'title': "'attr:' directive", '$id': '#/definitions/attr-directive', '$$description': ['Value is read from a module attribute. Supports callables and iterables;', 'unsupported types are cast via ``str()``'], 'type': 'object', 'additionalProperties': False, 'properties': {'attr': {'type': 'string', 'format': 'python-qualified-identifier'}}, 'required': ['attr']}, 'find-directive': {'$id': '#/definitions/find-directive', 'title': "'find:' directive", 'type': 'object', 'additionalProperties': False, 'properties': {'find': {'type': 'object', '$$description': ['Dynamic `package discovery', '`_.'], 'additionalProperties': False, 'properties': {'where': {'description': 'Directories to be searched for packages (Unix-style relative path)', 'type': 'array', 'items': {'type': 'string'}}, 'exclude': {'type': 'array', '$$description': ['Exclude packages that match the values listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'include': {'type': 'array', '$$description': ['Restrict the found packages to just the ones listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'namespaces': {'type': 'boolean', '$$description': ['When ``True``, directories without a ``__init__.py`` file will also', 'be scanned for :pep:`420`-style implicit namespaces']}}}}}}}}}, 'dependency-groups': {'type': 'object', 'description': 'Dependency groups following PEP 735', 'additionalProperties': False, 'patternProperties': {'^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9._-]*[a-zA-Z0-9])$': {'type': 'array', 'items': {'oneOf': [{'type': 'string', 'description': 'Python package specifiers following PEP 508', 'format': 'pep508'}, {'type': 'object', 'additionalProperties': False, 'properties': {'include-group': {'description': 'Another dependency group to include in this one', 'type': 'string', 'pattern': '^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9._-]*[a-zA-Z0-9])$'}}}]}}}}}, 'project': {'$schema': 'http://json-schema.org/draft-07/schema#', '$id': 'https://packaging.python.org/en/latest/specifications/pyproject-toml/', 'title': 'Package metadata stored in the ``project`` table', '$$description': ['Data structure for the **project** table inside ``pyproject.toml``', '(as initially defined in :pep:`621`)'], 'type': 'object', 'properties': {'name': {'type': 'string', 'description': 'The name (primary identifier) of the project. MUST be statically defined.', 'format': 'pep508-identifier'}, 'version': {'type': 'string', 'description': 'The version of the project as supported by :pep:`440`.', 'format': 'pep440'}, 'description': {'type': 'string', '$$description': ['The `summary description of the project', '`_']}, 'readme': {'$$description': ['`Full/detailed description of the project in the form of a README', '`_', "with meaning similar to the one defined in `core metadata's Description", '`_'], 'oneOf': [{'type': 'string', '$$description': ['Relative path to a text file (UTF-8) containing the full description', 'of the project. If the file path ends in case-insensitive ``.md`` or', '``.rst`` suffixes, then the content-type is respectively', '``text/markdown`` or ``text/x-rst``']}, {'type': 'object', 'allOf': [{'anyOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to a text file containing the full description', 'of the project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', 'description': 'Full text describing the project.'}}, 'required': ['text']}]}, {'properties': {'content-type': {'type': 'string', '$$description': ['Content-type (:rfc:`1341`) of the full description', '(e.g. ``text/markdown``). The ``charset`` parameter is assumed', 'UTF-8 when not present.'], '$comment': 'TODO: add regex pattern or format?'}}, 'required': ['content-type']}]}]}, 'requires-python': {'type': 'string', 'format': 'pep508-versionspec', '$$description': ['`The Python version requirements of the project', '`_.']}, 'license': {'description': '`Project license `_.', 'oneOf': [{'type': 'string', 'description': 'An SPDX license identifier', 'format': 'SPDX'}, {'type': 'object', 'properties': {'file': {'type': 'string', '$$description': ['Relative path to the file (UTF-8) which contains the license for the', 'project.']}}, 'required': ['file']}, {'type': 'object', 'properties': {'text': {'type': 'string', '$$description': ['The license of the project whose meaning is that of the', '`License field from the core metadata', '`_.']}}, 'required': ['text']}]}, 'license-files': {'description': 'Paths or globs to paths of license files', 'type': 'array', 'items': {'type': 'string'}}, 'authors': {'type': 'array', 'items': {'$ref': '#/definitions/author'}, '$$description': ["The people or organizations considered to be the 'authors' of the project.", 'The exact meaning is open to interpretation (e.g. original or primary authors,', 'current maintainers, or owners of the package).']}, 'maintainers': {'type': 'array', 'items': {'$ref': '#/definitions/author'}, '$$description': ["The people or organizations considered to be the 'maintainers' of the project.", 'Similarly to ``authors``, the exact meaning is open to interpretation.']}, 'keywords': {'type': 'array', 'items': {'type': 'string'}, 'description': 'List of keywords to assist searching for the distribution in a larger catalog.'}, 'classifiers': {'type': 'array', 'items': {'type': 'string', 'format': 'trove-classifier', 'description': '`PyPI classifier `_.'}, '$$description': ['`Trove classifiers `_', 'which apply to the project.']}, 'urls': {'type': 'object', 'description': 'URLs associated with the project in the form ``label => value``.', 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', 'format': 'url'}}}, 'scripts': {'$ref': '#/definitions/entry-point-group', '$$description': ['Instruct the installer to create command-line wrappers for the given', '`entry points `_.']}, 'gui-scripts': {'$ref': '#/definitions/entry-point-group', '$$description': ['Instruct the installer to create GUI wrappers for the given', '`entry points `_.', 'The difference between ``scripts`` and ``gui-scripts`` is only relevant in', 'Windows.']}, 'entry-points': {'$$description': ['Instruct the installer to expose the given modules/functions via', '``entry-point`` discovery mechanism (useful for plugins).', 'More information available in the `Python packaging guide', '`_.'], 'propertyNames': {'format': 'python-entrypoint-group'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'$ref': '#/definitions/entry-point-group'}}}, 'dependencies': {'type': 'array', 'description': 'Project (mandatory) dependencies.', 'items': {'$ref': '#/definitions/dependency'}}, 'optional-dependencies': {'type': 'object', 'description': 'Optional dependency for the project', 'propertyNames': {'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'array', 'items': {'$ref': '#/definitions/dependency'}}}}, 'import-names': {'description': 'Lists import names which a project, when installed, would exclusively provide.', 'type': 'array', 'items': {'type': 'string', 'format': 'import-name'}}, 'import-namespaces': {'description': 'Lists import names that, when installed, would be provided by the project, but not exclusively.', 'type': 'array', 'items': {'type': 'string', 'format': 'import-name'}}, 'dynamic': {'type': 'array', '$$description': ['Specifies which fields are intentionally unspecified and expected to be', 'dynamically provided by build tools'], 'items': {'enum': ['version', 'description', 'readme', 'requires-python', 'license', 'license-files', 'authors', 'maintainers', 'keywords', 'classifiers', 'urls', 'scripts', 'gui-scripts', 'entry-points', 'dependencies', 'optional-dependencies', 'import-names', 'import-namespaces']}}}, 'required': ['name'], 'additionalProperties': False, 'allOf': [{'if': {'not': {'required': ['dynamic'], 'properties': {'dynamic': {'contains': {'const': 'version'}, '$$description': ['version is listed in ``dynamic``']}}}, '$$comment': ['According to :pep:`621`:', '    If the core metadata specification lists a field as "Required", then', '    the metadata MUST specify the field statically or list it in dynamic', 'In turn, `core metadata`_ defines:', '    The required fields are: Metadata-Version, Name, Version.', '    All the other fields are optional.', 'Since ``Metadata-Version`` is defined by the build back-end, ``name`` and', '``version`` are the only mandatory information in ``pyproject.toml``.', '.. _core metadata: https://packaging.python.org/specifications/core-metadata/']}, 'then': {'required': ['version'], '$$description': ['version should be statically defined in the ``version`` field']}}, {'if': {'required': ['license-files']}, 'then': {'properties': {'license': {'type': 'string'}}}}], 'definitions': {'author': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}, 'anyOf': [{'required': ['name']}, {'required': ['email']}]}, 'entry-point-group': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, 'dependency': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}}}, rule='additionalProperties')
+    return data
+
+def validate_https___setuptools_pypa_io_en_latest_userguide_pyproject_config_html(data, custom_formats={}, name_prefix=None):
+    if not isinstance(data, (dict)):
+        raise JsonSchemaValueException("" + (name_prefix or "data") + " must be object", value=data, name="" + (name_prefix or "data") + "", definition={'$schema': 'http://json-schema.org/draft-07/schema#', '$id': 'https://setuptools.pypa.io/en/latest/userguide/pyproject_config.html', 'title': '``tool.setuptools`` table', '$$description': ['``setuptools``-specific configurations that can be set by users that require', 'customization.', 'These configurations are completely optional and probably can be skipped when', 'creating simple packages. They are equivalent to some of the `Keywords', '`_', 'used by the ``setup.py`` file, and can be set via the ``tool.setuptools`` table.', 'It considers only ``setuptools`` `parameters', '`_', 'that are not covered by :pep:`621`; and intentionally excludes ``dependency_links``', 'and ``setup_requires`` (incompatible with modern workflows/standards).'], 'type': 'object', 'additionalProperties': False, 'properties': {'platforms': {'type': 'array', 'items': {'type': 'string'}}, 'provides': {'$$description': ['Package and virtual package names contained within this package', '**(not supported by pip)**'], 'type': 'array', 'items': {'type': 'string', 'format': 'pep508-identifier'}}, 'obsoletes': {'$$description': ['Packages which this package renders obsolete', '**(not supported by pip)**'], 'type': 'array', 'items': {'type': 'string', 'format': 'pep508-identifier'}}, 'zip-safe': {'$$description': ['Whether the project can be safely installed and run from a zip file.', '**OBSOLETE**: only relevant for ``pkg_resources``, ``easy_install`` and', '``setup.py install`` in the context of ``eggs`` (**DEPRECATED**).'], 'type': 'boolean'}, 'script-files': {'$$description': ['Legacy way of defining scripts (entry-points are preferred).', 'Equivalent to the ``script`` keyword in ``setup.py``', '(it was renamed to avoid confusion with entry-point based ``project.scripts``', 'defined in :pep:`621`).', '**DISCOURAGED**: generic script wrappers are tricky and may not work properly.', 'Whenever possible, please use ``project.scripts`` instead.'], 'type': 'array', 'items': {'type': 'string'}, '$comment': 'TODO: is this field deprecated/should be removed?'}, 'eager-resources': {'$$description': ['Resources that should be extracted together, if any of them is needed,', 'or if any C extensions included in the project are imported.', '**OBSOLETE**: only relevant for ``pkg_resources``, ``easy_install`` and', '``setup.py install`` in the context of ``eggs`` (**DEPRECATED**).'], 'type': 'array', 'items': {'type': 'string'}}, 'packages': {'$$description': ['Packages that should be included in the distribution.', 'It can be given either as a list of package identifiers', 'or as a ``dict``-like structure with a single key ``find``', 'which corresponds to a dynamic call to', '``setuptools.config.expand.find_packages`` function.', 'The ``find`` key is associated with a nested ``dict``-like structure that can', 'contain ``where``, ``include``, ``exclude`` and ``namespaces`` keys,', 'mimicking the keyword arguments of the associated function.'], 'oneOf': [{'title': 'Array of Python package identifiers', 'type': 'array', 'items': {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}}, {'$id': '#/definitions/find-directive', 'title': "'find:' directive", 'type': 'object', 'additionalProperties': False, 'properties': {'find': {'type': 'object', '$$description': ['Dynamic `package discovery', '`_.'], 'additionalProperties': False, 'properties': {'where': {'description': 'Directories to be searched for packages (Unix-style relative path)', 'type': 'array', 'items': {'type': 'string'}}, 'exclude': {'type': 'array', '$$description': ['Exclude packages that match the values listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'include': {'type': 'array', '$$description': ['Restrict the found packages to just the ones listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'namespaces': {'type': 'boolean', '$$description': ['When ``True``, directories without a ``__init__.py`` file will also', 'be scanned for :pep:`420`-style implicit namespaces']}}}}}]}, 'package-dir': {'$$description': [':class:`dict`-like structure mapping from package names to directories where their', 'code can be found.', 'The empty string (as key) means that all packages are contained inside', 'the given directory will be included in the distribution.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'anyOf': [{'const': ''}, {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}]}, 'patternProperties': {'^.*$': {'type': 'string'}}}, 'package-data': {'$$description': ['Mapping from package names to lists of glob patterns.', 'Usually this option is not needed when using ``include-package-data = true``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'anyOf': [{'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'include-package-data': {'$$description': ['Automatically include any data files inside the package directories', 'that are specified by ``MANIFEST.in``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'boolean'}, 'exclude-package-data': {'$$description': ['Mapping from package names to lists of glob patterns that should be excluded', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'anyOf': [{'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'namespace-packages': {'type': 'array', 'items': {'type': 'string', 'format': 'python-module-name-relaxed'}, '$comment': 'https://setuptools.pypa.io/en/latest/userguide/package_discovery.html', 'description': '**DEPRECATED**: use implicit namespaces instead (:pep:`420`).'}, 'py-modules': {'description': 'Modules that setuptools will manipulate', 'type': 'array', 'items': {'type': 'string', 'format': 'python-module-name-relaxed'}, '$comment': 'TODO: clarify the relationship with ``packages``'}, 'ext-modules': {'description': 'Extension modules to be compiled by setuptools', 'type': 'array', 'items': {'$id': '#/definitions/ext-module', 'title': 'Extension module', 'description': 'Parameters to construct a :class:`setuptools.Extension` object', 'type': 'object', 'required': ['name', 'sources'], 'additionalProperties': False, 'properties': {'name': {'type': 'string', 'format': 'python-module-name-relaxed'}, 'sources': {'type': 'array', 'items': {'type': 'string'}}, 'include-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'define-macros': {'type': 'array', 'items': {'type': 'array', 'items': [{'description': 'macro name', 'type': 'string'}, {'description': 'macro value', 'oneOf': [{'type': 'string'}, {'type': 'null'}]}], 'additionalItems': False}}, 'undef-macros': {'type': 'array', 'items': {'type': 'string'}}, 'library-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'libraries': {'type': 'array', 'items': {'type': 'string'}}, 'runtime-library-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'extra-objects': {'type': 'array', 'items': {'type': 'string'}}, 'extra-compile-args': {'type': 'array', 'items': {'type': 'string'}}, 'extra-link-args': {'type': 'array', 'items': {'type': 'string'}}, 'export-symbols': {'type': 'array', 'items': {'type': 'string'}}, 'swig-opts': {'type': 'array', 'items': {'type': 'string'}}, 'depends': {'type': 'array', 'items': {'type': 'string'}}, 'language': {'type': 'string'}, 'optional': {'type': 'boolean'}, 'py-limited-api': {'type': 'boolean'}}}}, 'data-files': {'$$description': ['``dict``-like structure where each key represents a directory and', 'the value is a list of glob patterns that should be installed in them.', '**DISCOURAGED**: please notice this might not work as expected with wheels.', 'Whenever possible, consider using data files inside the package directories', '(or create a new namespace package that only contains data files).', 'See `data files support', '`_.'], 'type': 'object', 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'cmdclass': {'$$description': ['Mapping of distutils-style command names to ``setuptools.Command`` subclasses', 'which in turn should be represented by strings with a qualified class name', '(i.e., "dotted" form with module), e.g.::\n\n', '    cmdclass = {mycmd = "pkg.subpkg.module.CommandClass"}\n\n', 'The command class should be a directly defined at the top-level of the', 'containing module (no class nesting).'], 'type': 'object', 'patternProperties': {'^.*$': {'type': 'string', 'format': 'python-qualified-identifier'}}}, 'license-files': {'type': 'array', 'items': {'type': 'string'}, '$$description': ['**PROVISIONAL**: list of glob patterns for all license files being distributed.', '(likely to become standard with :pep:`639`).', "By default: ``['LICEN[CS]E*', 'COPYING*', 'NOTICE*', 'AUTHORS*']``"], '$comment': 'TODO: revise if PEP 639 is accepted. Probably ``project.license-files``?'}, 'dynamic': {'type': 'object', 'description': 'Instructions for loading :pep:`621`-related metadata dynamically', 'additionalProperties': False, 'properties': {'version': {'$$description': ['A version dynamically loaded via either the ``attr:`` or ``file:``', 'directives. Please make sure the given file or attribute respects :pep:`440`.', 'Also ensure to set ``project.dynamic`` accordingly.'], 'oneOf': [{'title': "'attr:' directive", '$id': '#/definitions/attr-directive', '$$description': ['Value is read from a module attribute. Supports callables and iterables;', 'unsupported types are cast via ``str()``'], 'type': 'object', 'additionalProperties': False, 'properties': {'attr': {'type': 'string', 'format': 'python-qualified-identifier'}}, 'required': ['attr']}, {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}]}, 'classifiers': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'description': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'entry-points': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'dependencies': {'title': "'file:' directive for dependencies", 'allOf': [{'$$description': ['**BETA**: subset of the ``requirements.txt`` format', 'without ``pip`` flags and options', '(one :pep:`508`-compliant string per line,', 'lines that are blank or start with ``#`` are excluded).', 'See `dynamic metadata', '`_.']}, {'$ref': '#/definitions/file-directive'}]}, 'optional-dependencies': {'type': 'object', 'propertyNames': {'type': 'string', 'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'.+': {'title': "'file:' directive for dependencies", 'allOf': [{'$$description': ['**BETA**: subset of the ``requirements.txt`` format', 'without ``pip`` flags and options', '(one :pep:`508`-compliant string per line,', 'lines that are blank or start with ``#`` are excluded).', 'See `dynamic metadata', '`_.']}, {'$ref': '#/definitions/file-directive'}]}}}, 'readme': {'type': 'object', 'anyOf': [{'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, {'type': 'object', 'properties': {'content-type': {'type': 'string'}, 'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'additionalProperties': False}], 'required': ['file']}}}}, 'definitions': {'package-name': {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}, 'ext-module': {'$id': '#/definitions/ext-module', 'title': 'Extension module', 'description': 'Parameters to construct a :class:`setuptools.Extension` object', 'type': 'object', 'required': ['name', 'sources'], 'additionalProperties': False, 'properties': {'name': {'type': 'string', 'format': 'python-module-name-relaxed'}, 'sources': {'type': 'array', 'items': {'type': 'string'}}, 'include-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'define-macros': {'type': 'array', 'items': {'type': 'array', 'items': [{'description': 'macro name', 'type': 'string'}, {'description': 'macro value', 'oneOf': [{'type': 'string'}, {'type': 'null'}]}], 'additionalItems': False}}, 'undef-macros': {'type': 'array', 'items': {'type': 'string'}}, 'library-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'libraries': {'type': 'array', 'items': {'type': 'string'}}, 'runtime-library-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'extra-objects': {'type': 'array', 'items': {'type': 'string'}}, 'extra-compile-args': {'type': 'array', 'items': {'type': 'string'}}, 'extra-link-args': {'type': 'array', 'items': {'type': 'string'}}, 'export-symbols': {'type': 'array', 'items': {'type': 'string'}}, 'swig-opts': {'type': 'array', 'items': {'type': 'string'}}, 'depends': {'type': 'array', 'items': {'type': 'string'}}, 'language': {'type': 'string'}, 'optional': {'type': 'boolean'}, 'py-limited-api': {'type': 'boolean'}}}, 'file-directive': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'file-directive-for-dependencies': {'title': "'file:' directive for dependencies", 'allOf': [{'$$description': ['**BETA**: subset of the ``requirements.txt`` format', 'without ``pip`` flags and options', '(one :pep:`508`-compliant string per line,', 'lines that are blank or start with ``#`` are excluded).', 'See `dynamic metadata', '`_.']}, {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}]}, 'attr-directive': {'title': "'attr:' directive", '$id': '#/definitions/attr-directive', '$$description': ['Value is read from a module attribute. Supports callables and iterables;', 'unsupported types are cast via ``str()``'], 'type': 'object', 'additionalProperties': False, 'properties': {'attr': {'type': 'string', 'format': 'python-qualified-identifier'}}, 'required': ['attr']}, 'find-directive': {'$id': '#/definitions/find-directive', 'title': "'find:' directive", 'type': 'object', 'additionalProperties': False, 'properties': {'find': {'type': 'object', '$$description': ['Dynamic `package discovery', '`_.'], 'additionalProperties': False, 'properties': {'where': {'description': 'Directories to be searched for packages (Unix-style relative path)', 'type': 'array', 'items': {'type': 'string'}}, 'exclude': {'type': 'array', '$$description': ['Exclude packages that match the values listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'include': {'type': 'array', '$$description': ['Restrict the found packages to just the ones listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'namespaces': {'type': 'boolean', '$$description': ['When ``True``, directories without a ``__init__.py`` file will also', 'be scanned for :pep:`420`-style implicit namespaces']}}}}}}}, rule='type')
+    data_is_dict = isinstance(data, dict)
+    if data_is_dict:
+        data_keys = set(data.keys())
+        if "platforms" in data_keys:
+            data_keys.remove("platforms")
+            data__platforms = data["platforms"]
+            if not isinstance(data__platforms, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".platforms must be array", value=data__platforms, name="" + (name_prefix or "data") + ".platforms", definition={'type': 'array', 'items': {'type': 'string'}}, rule='type')
+            data__platforms_is_list = isinstance(data__platforms, (list, tuple))
+            if data__platforms_is_list:
+                data__platforms_len = len(data__platforms)
+                for data__platforms_x, data__platforms_item in enumerate(data__platforms):
+                    if not isinstance(data__platforms_item, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".platforms[{data__platforms_x}]".format(**locals()) + " must be string", value=data__platforms_item, name="" + (name_prefix or "data") + ".platforms[{data__platforms_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+        if "provides" in data_keys:
+            data_keys.remove("provides")
+            data__provides = data["provides"]
+            if not isinstance(data__provides, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".provides must be array", value=data__provides, name="" + (name_prefix or "data") + ".provides", definition={'$$description': ['Package and virtual package names contained within this package', '**(not supported by pip)**'], 'type': 'array', 'items': {'type': 'string', 'format': 'pep508-identifier'}}, rule='type')
+            data__provides_is_list = isinstance(data__provides, (list, tuple))
+            if data__provides_is_list:
+                data__provides_len = len(data__provides)
+                for data__provides_x, data__provides_item in enumerate(data__provides):
+                    if not isinstance(data__provides_item, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".provides[{data__provides_x}]".format(**locals()) + " must be string", value=data__provides_item, name="" + (name_prefix or "data") + ".provides[{data__provides_x}]".format(**locals()) + "", definition={'type': 'string', 'format': 'pep508-identifier'}, rule='type')
+                    if isinstance(data__provides_item, str):
+                        if not custom_formats["pep508-identifier"](data__provides_item):
+                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".provides[{data__provides_x}]".format(**locals()) + " must be pep508-identifier", value=data__provides_item, name="" + (name_prefix or "data") + ".provides[{data__provides_x}]".format(**locals()) + "", definition={'type': 'string', 'format': 'pep508-identifier'}, rule='format')
+        if "obsoletes" in data_keys:
+            data_keys.remove("obsoletes")
+            data__obsoletes = data["obsoletes"]
+            if not isinstance(data__obsoletes, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".obsoletes must be array", value=data__obsoletes, name="" + (name_prefix or "data") + ".obsoletes", definition={'$$description': ['Packages which this package renders obsolete', '**(not supported by pip)**'], 'type': 'array', 'items': {'type': 'string', 'format': 'pep508-identifier'}}, rule='type')
+            data__obsoletes_is_list = isinstance(data__obsoletes, (list, tuple))
+            if data__obsoletes_is_list:
+                data__obsoletes_len = len(data__obsoletes)
+                for data__obsoletes_x, data__obsoletes_item in enumerate(data__obsoletes):
+                    if not isinstance(data__obsoletes_item, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".obsoletes[{data__obsoletes_x}]".format(**locals()) + " must be string", value=data__obsoletes_item, name="" + (name_prefix or "data") + ".obsoletes[{data__obsoletes_x}]".format(**locals()) + "", definition={'type': 'string', 'format': 'pep508-identifier'}, rule='type')
+                    if isinstance(data__obsoletes_item, str):
+                        if not custom_formats["pep508-identifier"](data__obsoletes_item):
+                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".obsoletes[{data__obsoletes_x}]".format(**locals()) + " must be pep508-identifier", value=data__obsoletes_item, name="" + (name_prefix or "data") + ".obsoletes[{data__obsoletes_x}]".format(**locals()) + "", definition={'type': 'string', 'format': 'pep508-identifier'}, rule='format')
+        if "zip-safe" in data_keys:
+            data_keys.remove("zip-safe")
+            data__zipsafe = data["zip-safe"]
+            if not isinstance(data__zipsafe, (bool)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".zip-safe must be boolean", value=data__zipsafe, name="" + (name_prefix or "data") + ".zip-safe", definition={'$$description': ['Whether the project can be safely installed and run from a zip file.', '**OBSOLETE**: only relevant for ``pkg_resources``, ``easy_install`` and', '``setup.py install`` in the context of ``eggs`` (**DEPRECATED**).'], 'type': 'boolean'}, rule='type')
+        if "script-files" in data_keys:
+            data_keys.remove("script-files")
+            data__scriptfiles = data["script-files"]
+            if not isinstance(data__scriptfiles, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".script-files must be array", value=data__scriptfiles, name="" + (name_prefix or "data") + ".script-files", definition={'$$description': ['Legacy way of defining scripts (entry-points are preferred).', 'Equivalent to the ``script`` keyword in ``setup.py``', '(it was renamed to avoid confusion with entry-point based ``project.scripts``', 'defined in :pep:`621`).', '**DISCOURAGED**: generic script wrappers are tricky and may not work properly.', 'Whenever possible, please use ``project.scripts`` instead.'], 'type': 'array', 'items': {'type': 'string'}, '$comment': 'TODO: is this field deprecated/should be removed?'}, rule='type')
+            data__scriptfiles_is_list = isinstance(data__scriptfiles, (list, tuple))
+            if data__scriptfiles_is_list:
+                data__scriptfiles_len = len(data__scriptfiles)
+                for data__scriptfiles_x, data__scriptfiles_item in enumerate(data__scriptfiles):
+                    if not isinstance(data__scriptfiles_item, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".script-files[{data__scriptfiles_x}]".format(**locals()) + " must be string", value=data__scriptfiles_item, name="" + (name_prefix or "data") + ".script-files[{data__scriptfiles_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+        if "eager-resources" in data_keys:
+            data_keys.remove("eager-resources")
+            data__eagerresources = data["eager-resources"]
+            if not isinstance(data__eagerresources, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".eager-resources must be array", value=data__eagerresources, name="" + (name_prefix or "data") + ".eager-resources", definition={'$$description': ['Resources that should be extracted together, if any of them is needed,', 'or if any C extensions included in the project are imported.', '**OBSOLETE**: only relevant for ``pkg_resources``, ``easy_install`` and', '``setup.py install`` in the context of ``eggs`` (**DEPRECATED**).'], 'type': 'array', 'items': {'type': 'string'}}, rule='type')
+            data__eagerresources_is_list = isinstance(data__eagerresources, (list, tuple))
+            if data__eagerresources_is_list:
+                data__eagerresources_len = len(data__eagerresources)
+                for data__eagerresources_x, data__eagerresources_item in enumerate(data__eagerresources):
+                    if not isinstance(data__eagerresources_item, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".eager-resources[{data__eagerresources_x}]".format(**locals()) + " must be string", value=data__eagerresources_item, name="" + (name_prefix or "data") + ".eager-resources[{data__eagerresources_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+        if "packages" in data_keys:
+            data_keys.remove("packages")
+            data__packages = data["packages"]
+            data__packages_one_of_count2 = 0
+            if data__packages_one_of_count2 < 2:
+                try:
+                    if not isinstance(data__packages, (list, tuple)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".packages must be array", value=data__packages, name="" + (name_prefix or "data") + ".packages", definition={'title': 'Array of Python package identifiers', 'type': 'array', 'items': {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}}, rule='type')
+                    data__packages_is_list = isinstance(data__packages, (list, tuple))
+                    if data__packages_is_list:
+                        data__packages_len = len(data__packages)
+                        for data__packages_x, data__packages_item in enumerate(data__packages):
+                            validate_https___setuptools_pypa_io_en_latest_userguide_pyproject_config_html__definitions_package_name(data__packages_item, custom_formats, (name_prefix or "data") + ".packages[{data__packages_x}]".format(**locals()))
+                    data__packages_one_of_count2 += 1
+                except JsonSchemaValueException: pass
+            if data__packages_one_of_count2 < 2:
+                try:
+                    validate_https___setuptools_pypa_io_en_latest_userguide_pyproject_config_html__definitions_find_directive(data__packages, custom_formats, (name_prefix or "data") + ".packages")
+                    data__packages_one_of_count2 += 1
+                except JsonSchemaValueException: pass
+            if data__packages_one_of_count2 != 1:
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".packages must be valid exactly by one definition" + (" (" + str(data__packages_one_of_count2) + " matches found)"), value=data__packages, name="" + (name_prefix or "data") + ".packages", definition={'$$description': ['Packages that should be included in the distribution.', 'It can be given either as a list of package identifiers', 'or as a ``dict``-like structure with a single key ``find``', 'which corresponds to a dynamic call to', '``setuptools.config.expand.find_packages`` function.', 'The ``find`` key is associated with a nested ``dict``-like structure that can', 'contain ``where``, ``include``, ``exclude`` and ``namespaces`` keys,', 'mimicking the keyword arguments of the associated function.'], 'oneOf': [{'title': 'Array of Python package identifiers', 'type': 'array', 'items': {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}}, {'$id': '#/definitions/find-directive', 'title': "'find:' directive", 'type': 'object', 'additionalProperties': False, 'properties': {'find': {'type': 'object', '$$description': ['Dynamic `package discovery', '`_.'], 'additionalProperties': False, 'properties': {'where': {'description': 'Directories to be searched for packages (Unix-style relative path)', 'type': 'array', 'items': {'type': 'string'}}, 'exclude': {'type': 'array', '$$description': ['Exclude packages that match the values listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'include': {'type': 'array', '$$description': ['Restrict the found packages to just the ones listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'namespaces': {'type': 'boolean', '$$description': ['When ``True``, directories without a ``__init__.py`` file will also', 'be scanned for :pep:`420`-style implicit namespaces']}}}}}]}, rule='oneOf')
+        if "package-dir" in data_keys:
+            data_keys.remove("package-dir")
+            data__packagedir = data["package-dir"]
+            if not isinstance(data__packagedir, (dict)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-dir must be object", value=data__packagedir, name="" + (name_prefix or "data") + ".package-dir", definition={'$$description': [':class:`dict`-like structure mapping from package names to directories where their', 'code can be found.', 'The empty string (as key) means that all packages are contained inside', 'the given directory will be included in the distribution.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'anyOf': [{'const': ''}, {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}]}, 'patternProperties': {'^.*$': {'type': 'string'}}}, rule='type')
+            data__packagedir_is_dict = isinstance(data__packagedir, dict)
+            if data__packagedir_is_dict:
+                data__packagedir_keys = set(data__packagedir.keys())
+                for data__packagedir_key, data__packagedir_val in data__packagedir.items():
+                    if REGEX_PATTERNS['^.*$'].search(data__packagedir_key):
+                        if data__packagedir_key in data__packagedir_keys:
+                            data__packagedir_keys.remove(data__packagedir_key)
+                        if not isinstance(data__packagedir_val, (str)):
+                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-dir.{data__packagedir_key}".format(**locals()) + " must be string", value=data__packagedir_val, name="" + (name_prefix or "data") + ".package-dir.{data__packagedir_key}".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+                if data__packagedir_keys:
+                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-dir must not contain "+str(data__packagedir_keys)+" properties", value=data__packagedir, name="" + (name_prefix or "data") + ".package-dir", definition={'$$description': [':class:`dict`-like structure mapping from package names to directories where their', 'code can be found.', 'The empty string (as key) means that all packages are contained inside', 'the given directory will be included in the distribution.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'anyOf': [{'const': ''}, {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}]}, 'patternProperties': {'^.*$': {'type': 'string'}}}, rule='additionalProperties')
+                data__packagedir_len = len(data__packagedir)
+                if data__packagedir_len != 0:
+                    data__packagedir_property_names = True
+                    for data__packagedir_key in data__packagedir:
+                        try:
+                            data__packagedir_key_any_of_count3 = 0
+                            if not data__packagedir_key_any_of_count3:
+                                try:
+                                    if data__packagedir_key != "":
+                                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-dir must be same as const definition: ", value=data__packagedir_key, name="" + (name_prefix or "data") + ".package-dir", definition={'const': ''}, rule='const')
+                                    data__packagedir_key_any_of_count3 += 1
+                                except JsonSchemaValueException: pass
+                            if not data__packagedir_key_any_of_count3:
+                                try:
+                                    validate_https___setuptools_pypa_io_en_latest_userguide_pyproject_config_html__definitions_package_name(data__packagedir_key, custom_formats, (name_prefix or "data") + ".package-dir")
+                                    data__packagedir_key_any_of_count3 += 1
+                                except JsonSchemaValueException: pass
+                            if not data__packagedir_key_any_of_count3:
+                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-dir cannot be validated by any definition", value=data__packagedir_key, name="" + (name_prefix or "data") + ".package-dir", definition={'anyOf': [{'const': ''}, {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}]}, rule='anyOf')
+                        except JsonSchemaValueException:
+                            data__packagedir_property_names = False
+                    if not data__packagedir_property_names:
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-dir must be named by propertyName definition", value=data__packagedir, name="" + (name_prefix or "data") + ".package-dir", definition={'$$description': [':class:`dict`-like structure mapping from package names to directories where their', 'code can be found.', 'The empty string (as key) means that all packages are contained inside', 'the given directory will be included in the distribution.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'anyOf': [{'const': ''}, {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}]}, 'patternProperties': {'^.*$': {'type': 'string'}}}, rule='propertyNames')
+        if "package-data" in data_keys:
+            data_keys.remove("package-data")
+            data__packagedata = data["package-data"]
+            if not isinstance(data__packagedata, (dict)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-data must be object", value=data__packagedata, name="" + (name_prefix or "data") + ".package-data", definition={'$$description': ['Mapping from package names to lists of glob patterns.', 'Usually this option is not needed when using ``include-package-data = true``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'anyOf': [{'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, rule='type')
+            data__packagedata_is_dict = isinstance(data__packagedata, dict)
+            if data__packagedata_is_dict:
+                data__packagedata_keys = set(data__packagedata.keys())
+                for data__packagedata_key, data__packagedata_val in data__packagedata.items():
+                    if REGEX_PATTERNS['^.*$'].search(data__packagedata_key):
+                        if data__packagedata_key in data__packagedata_keys:
+                            data__packagedata_keys.remove(data__packagedata_key)
+                        if not isinstance(data__packagedata_val, (list, tuple)):
+                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-data.{data__packagedata_key}".format(**locals()) + " must be array", value=data__packagedata_val, name="" + (name_prefix or "data") + ".package-data.{data__packagedata_key}".format(**locals()) + "", definition={'type': 'array', 'items': {'type': 'string'}}, rule='type')
+                        data__packagedata_val_is_list = isinstance(data__packagedata_val, (list, tuple))
+                        if data__packagedata_val_is_list:
+                            data__packagedata_val_len = len(data__packagedata_val)
+                            for data__packagedata_val_x, data__packagedata_val_item in enumerate(data__packagedata_val):
+                                if not isinstance(data__packagedata_val_item, (str)):
+                                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-data.{data__packagedata_key}[{data__packagedata_val_x}]".format(**locals()) + " must be string", value=data__packagedata_val_item, name="" + (name_prefix or "data") + ".package-data.{data__packagedata_key}[{data__packagedata_val_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+                if data__packagedata_keys:
+                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-data must not contain "+str(data__packagedata_keys)+" properties", value=data__packagedata, name="" + (name_prefix or "data") + ".package-data", definition={'$$description': ['Mapping from package names to lists of glob patterns.', 'Usually this option is not needed when using ``include-package-data = true``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'anyOf': [{'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, rule='additionalProperties')
+                data__packagedata_len = len(data__packagedata)
+                if data__packagedata_len != 0:
+                    data__packagedata_property_names = True
+                    for data__packagedata_key in data__packagedata:
+                        try:
+                            data__packagedata_key_any_of_count4 = 0
+                            if not data__packagedata_key_any_of_count4:
+                                try:
+                                    validate_https___setuptools_pypa_io_en_latest_userguide_pyproject_config_html__definitions_package_name(data__packagedata_key, custom_formats, (name_prefix or "data") + ".package-data")
+                                    data__packagedata_key_any_of_count4 += 1
+                                except JsonSchemaValueException: pass
+                            if not data__packagedata_key_any_of_count4:
+                                try:
+                                    if data__packagedata_key != "*":
+                                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-data must be same as const definition: *", value=data__packagedata_key, name="" + (name_prefix or "data") + ".package-data", definition={'const': '*'}, rule='const')
+                                    data__packagedata_key_any_of_count4 += 1
+                                except JsonSchemaValueException: pass
+                            if not data__packagedata_key_any_of_count4:
+                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-data cannot be validated by any definition", value=data__packagedata_key, name="" + (name_prefix or "data") + ".package-data", definition={'anyOf': [{'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}, {'const': '*'}]}, rule='anyOf')
+                        except JsonSchemaValueException:
+                            data__packagedata_property_names = False
+                    if not data__packagedata_property_names:
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-data must be named by propertyName definition", value=data__packagedata, name="" + (name_prefix or "data") + ".package-data", definition={'$$description': ['Mapping from package names to lists of glob patterns.', 'Usually this option is not needed when using ``include-package-data = true``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'anyOf': [{'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, rule='propertyNames')
+        if "include-package-data" in data_keys:
+            data_keys.remove("include-package-data")
+            data__includepackagedata = data["include-package-data"]
+            if not isinstance(data__includepackagedata, (bool)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".include-package-data must be boolean", value=data__includepackagedata, name="" + (name_prefix or "data") + ".include-package-data", definition={'$$description': ['Automatically include any data files inside the package directories', 'that are specified by ``MANIFEST.in``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'boolean'}, rule='type')
+        if "exclude-package-data" in data_keys:
+            data_keys.remove("exclude-package-data")
+            data__excludepackagedata = data["exclude-package-data"]
+            if not isinstance(data__excludepackagedata, (dict)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".exclude-package-data must be object", value=data__excludepackagedata, name="" + (name_prefix or "data") + ".exclude-package-data", definition={'$$description': ['Mapping from package names to lists of glob patterns that should be excluded', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'anyOf': [{'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, rule='type')
+            data__excludepackagedata_is_dict = isinstance(data__excludepackagedata, dict)
+            if data__excludepackagedata_is_dict:
+                data__excludepackagedata_keys = set(data__excludepackagedata.keys())
+                for data__excludepackagedata_key, data__excludepackagedata_val in data__excludepackagedata.items():
+                    if REGEX_PATTERNS['^.*$'].search(data__excludepackagedata_key):
+                        if data__excludepackagedata_key in data__excludepackagedata_keys:
+                            data__excludepackagedata_keys.remove(data__excludepackagedata_key)
+                        if not isinstance(data__excludepackagedata_val, (list, tuple)):
+                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".exclude-package-data.{data__excludepackagedata_key}".format(**locals()) + " must be array", value=data__excludepackagedata_val, name="" + (name_prefix or "data") + ".exclude-package-data.{data__excludepackagedata_key}".format(**locals()) + "", definition={'type': 'array', 'items': {'type': 'string'}}, rule='type')
+                        data__excludepackagedata_val_is_list = isinstance(data__excludepackagedata_val, (list, tuple))
+                        if data__excludepackagedata_val_is_list:
+                            data__excludepackagedata_val_len = len(data__excludepackagedata_val)
+                            for data__excludepackagedata_val_x, data__excludepackagedata_val_item in enumerate(data__excludepackagedata_val):
+                                if not isinstance(data__excludepackagedata_val_item, (str)):
+                                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".exclude-package-data.{data__excludepackagedata_key}[{data__excludepackagedata_val_x}]".format(**locals()) + " must be string", value=data__excludepackagedata_val_item, name="" + (name_prefix or "data") + ".exclude-package-data.{data__excludepackagedata_key}[{data__excludepackagedata_val_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+                if data__excludepackagedata_keys:
+                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".exclude-package-data must not contain "+str(data__excludepackagedata_keys)+" properties", value=data__excludepackagedata, name="" + (name_prefix or "data") + ".exclude-package-data", definition={'$$description': ['Mapping from package names to lists of glob patterns that should be excluded', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'anyOf': [{'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, rule='additionalProperties')
+                data__excludepackagedata_len = len(data__excludepackagedata)
+                if data__excludepackagedata_len != 0:
+                    data__excludepackagedata_property_names = True
+                    for data__excludepackagedata_key in data__excludepackagedata:
+                        try:
+                            data__excludepackagedata_key_any_of_count5 = 0
+                            if not data__excludepackagedata_key_any_of_count5:
+                                try:
+                                    validate_https___setuptools_pypa_io_en_latest_userguide_pyproject_config_html__definitions_package_name(data__excludepackagedata_key, custom_formats, (name_prefix or "data") + ".exclude-package-data")
+                                    data__excludepackagedata_key_any_of_count5 += 1
+                                except JsonSchemaValueException: pass
+                            if not data__excludepackagedata_key_any_of_count5:
+                                try:
+                                    if data__excludepackagedata_key != "*":
+                                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".exclude-package-data must be same as const definition: *", value=data__excludepackagedata_key, name="" + (name_prefix or "data") + ".exclude-package-data", definition={'const': '*'}, rule='const')
+                                    data__excludepackagedata_key_any_of_count5 += 1
+                                except JsonSchemaValueException: pass
+                            if not data__excludepackagedata_key_any_of_count5:
+                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".exclude-package-data cannot be validated by any definition", value=data__excludepackagedata_key, name="" + (name_prefix or "data") + ".exclude-package-data", definition={'anyOf': [{'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}, {'const': '*'}]}, rule='anyOf')
+                        except JsonSchemaValueException:
+                            data__excludepackagedata_property_names = False
+                    if not data__excludepackagedata_property_names:
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".exclude-package-data must be named by propertyName definition", value=data__excludepackagedata, name="" + (name_prefix or "data") + ".exclude-package-data", definition={'$$description': ['Mapping from package names to lists of glob patterns that should be excluded', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'anyOf': [{'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, rule='propertyNames')
+        if "namespace-packages" in data_keys:
+            data_keys.remove("namespace-packages")
+            data__namespacepackages = data["namespace-packages"]
+            if not isinstance(data__namespacepackages, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".namespace-packages must be array", value=data__namespacepackages, name="" + (name_prefix or "data") + ".namespace-packages", definition={'type': 'array', 'items': {'type': 'string', 'format': 'python-module-name-relaxed'}, '$comment': 'https://setuptools.pypa.io/en/latest/userguide/package_discovery.html', 'description': '**DEPRECATED**: use implicit namespaces instead (:pep:`420`).'}, rule='type')
+            data__namespacepackages_is_list = isinstance(data__namespacepackages, (list, tuple))
+            if data__namespacepackages_is_list:
+                data__namespacepackages_len = len(data__namespacepackages)
+                for data__namespacepackages_x, data__namespacepackages_item in enumerate(data__namespacepackages):
+                    if not isinstance(data__namespacepackages_item, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".namespace-packages[{data__namespacepackages_x}]".format(**locals()) + " must be string", value=data__namespacepackages_item, name="" + (name_prefix or "data") + ".namespace-packages[{data__namespacepackages_x}]".format(**locals()) + "", definition={'type': 'string', 'format': 'python-module-name-relaxed'}, rule='type')
+                    if isinstance(data__namespacepackages_item, str):
+                        if not custom_formats["python-module-name-relaxed"](data__namespacepackages_item):
+                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".namespace-packages[{data__namespacepackages_x}]".format(**locals()) + " must be python-module-name-relaxed", value=data__namespacepackages_item, name="" + (name_prefix or "data") + ".namespace-packages[{data__namespacepackages_x}]".format(**locals()) + "", definition={'type': 'string', 'format': 'python-module-name-relaxed'}, rule='format')
+        if "py-modules" in data_keys:
+            data_keys.remove("py-modules")
+            data__pymodules = data["py-modules"]
+            if not isinstance(data__pymodules, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".py-modules must be array", value=data__pymodules, name="" + (name_prefix or "data") + ".py-modules", definition={'description': 'Modules that setuptools will manipulate', 'type': 'array', 'items': {'type': 'string', 'format': 'python-module-name-relaxed'}, '$comment': 'TODO: clarify the relationship with ``packages``'}, rule='type')
+            data__pymodules_is_list = isinstance(data__pymodules, (list, tuple))
+            if data__pymodules_is_list:
+                data__pymodules_len = len(data__pymodules)
+                for data__pymodules_x, data__pymodules_item in enumerate(data__pymodules):
+                    if not isinstance(data__pymodules_item, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".py-modules[{data__pymodules_x}]".format(**locals()) + " must be string", value=data__pymodules_item, name="" + (name_prefix or "data") + ".py-modules[{data__pymodules_x}]".format(**locals()) + "", definition={'type': 'string', 'format': 'python-module-name-relaxed'}, rule='type')
+                    if isinstance(data__pymodules_item, str):
+                        if not custom_formats["python-module-name-relaxed"](data__pymodules_item):
+                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".py-modules[{data__pymodules_x}]".format(**locals()) + " must be python-module-name-relaxed", value=data__pymodules_item, name="" + (name_prefix or "data") + ".py-modules[{data__pymodules_x}]".format(**locals()) + "", definition={'type': 'string', 'format': 'python-module-name-relaxed'}, rule='format')
+        if "ext-modules" in data_keys:
+            data_keys.remove("ext-modules")
+            data__extmodules = data["ext-modules"]
+            if not isinstance(data__extmodules, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".ext-modules must be array", value=data__extmodules, name="" + (name_prefix or "data") + ".ext-modules", definition={'description': 'Extension modules to be compiled by setuptools', 'type': 'array', 'items': {'$id': '#/definitions/ext-module', 'title': 'Extension module', 'description': 'Parameters to construct a :class:`setuptools.Extension` object', 'type': 'object', 'required': ['name', 'sources'], 'additionalProperties': False, 'properties': {'name': {'type': 'string', 'format': 'python-module-name-relaxed'}, 'sources': {'type': 'array', 'items': {'type': 'string'}}, 'include-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'define-macros': {'type': 'array', 'items': {'type': 'array', 'items': [{'description': 'macro name', 'type': 'string'}, {'description': 'macro value', 'oneOf': [{'type': 'string'}, {'type': 'null'}]}], 'additionalItems': False}}, 'undef-macros': {'type': 'array', 'items': {'type': 'string'}}, 'library-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'libraries': {'type': 'array', 'items': {'type': 'string'}}, 'runtime-library-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'extra-objects': {'type': 'array', 'items': {'type': 'string'}}, 'extra-compile-args': {'type': 'array', 'items': {'type': 'string'}}, 'extra-link-args': {'type': 'array', 'items': {'type': 'string'}}, 'export-symbols': {'type': 'array', 'items': {'type': 'string'}}, 'swig-opts': {'type': 'array', 'items': {'type': 'string'}}, 'depends': {'type': 'array', 'items': {'type': 'string'}}, 'language': {'type': 'string'}, 'optional': {'type': 'boolean'}, 'py-limited-api': {'type': 'boolean'}}}}, rule='type')
+            data__extmodules_is_list = isinstance(data__extmodules, (list, tuple))
+            if data__extmodules_is_list:
+                data__extmodules_len = len(data__extmodules)
+                for data__extmodules_x, data__extmodules_item in enumerate(data__extmodules):
+                    validate_https___setuptools_pypa_io_en_latest_userguide_pyproject_config_html__definitions_ext_module(data__extmodules_item, custom_formats, (name_prefix or "data") + ".ext-modules[{data__extmodules_x}]".format(**locals()))
+        if "data-files" in data_keys:
+            data_keys.remove("data-files")
+            data__datafiles = data["data-files"]
+            if not isinstance(data__datafiles, (dict)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".data-files must be object", value=data__datafiles, name="" + (name_prefix or "data") + ".data-files", definition={'$$description': ['``dict``-like structure where each key represents a directory and', 'the value is a list of glob patterns that should be installed in them.', '**DISCOURAGED**: please notice this might not work as expected with wheels.', 'Whenever possible, consider using data files inside the package directories', '(or create a new namespace package that only contains data files).', 'See `data files support', '`_.'], 'type': 'object', 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, rule='type')
+            data__datafiles_is_dict = isinstance(data__datafiles, dict)
+            if data__datafiles_is_dict:
+                data__datafiles_keys = set(data__datafiles.keys())
+                for data__datafiles_key, data__datafiles_val in data__datafiles.items():
+                    if REGEX_PATTERNS['^.*$'].search(data__datafiles_key):
+                        if data__datafiles_key in data__datafiles_keys:
+                            data__datafiles_keys.remove(data__datafiles_key)
+                        if not isinstance(data__datafiles_val, (list, tuple)):
+                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".data-files.{data__datafiles_key}".format(**locals()) + " must be array", value=data__datafiles_val, name="" + (name_prefix or "data") + ".data-files.{data__datafiles_key}".format(**locals()) + "", definition={'type': 'array', 'items': {'type': 'string'}}, rule='type')
+                        data__datafiles_val_is_list = isinstance(data__datafiles_val, (list, tuple))
+                        if data__datafiles_val_is_list:
+                            data__datafiles_val_len = len(data__datafiles_val)
+                            for data__datafiles_val_x, data__datafiles_val_item in enumerate(data__datafiles_val):
+                                if not isinstance(data__datafiles_val_item, (str)):
+                                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".data-files.{data__datafiles_key}[{data__datafiles_val_x}]".format(**locals()) + " must be string", value=data__datafiles_val_item, name="" + (name_prefix or "data") + ".data-files.{data__datafiles_key}[{data__datafiles_val_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+        if "cmdclass" in data_keys:
+            data_keys.remove("cmdclass")
+            data__cmdclass = data["cmdclass"]
+            if not isinstance(data__cmdclass, (dict)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".cmdclass must be object", value=data__cmdclass, name="" + (name_prefix or "data") + ".cmdclass", definition={'$$description': ['Mapping of distutils-style command names to ``setuptools.Command`` subclasses', 'which in turn should be represented by strings with a qualified class name', '(i.e., "dotted" form with module), e.g.::\n\n', '    cmdclass = {mycmd = "pkg.subpkg.module.CommandClass"}\n\n', 'The command class should be a directly defined at the top-level of the', 'containing module (no class nesting).'], 'type': 'object', 'patternProperties': {'^.*$': {'type': 'string', 'format': 'python-qualified-identifier'}}}, rule='type')
+            data__cmdclass_is_dict = isinstance(data__cmdclass, dict)
+            if data__cmdclass_is_dict:
+                data__cmdclass_keys = set(data__cmdclass.keys())
+                for data__cmdclass_key, data__cmdclass_val in data__cmdclass.items():
+                    if REGEX_PATTERNS['^.*$'].search(data__cmdclass_key):
+                        if data__cmdclass_key in data__cmdclass_keys:
+                            data__cmdclass_keys.remove(data__cmdclass_key)
+                        if not isinstance(data__cmdclass_val, (str)):
+                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".cmdclass.{data__cmdclass_key}".format(**locals()) + " must be string", value=data__cmdclass_val, name="" + (name_prefix or "data") + ".cmdclass.{data__cmdclass_key}".format(**locals()) + "", definition={'type': 'string', 'format': 'python-qualified-identifier'}, rule='type')
+                        if isinstance(data__cmdclass_val, str):
+                            if not custom_formats["python-qualified-identifier"](data__cmdclass_val):
+                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".cmdclass.{data__cmdclass_key}".format(**locals()) + " must be python-qualified-identifier", value=data__cmdclass_val, name="" + (name_prefix or "data") + ".cmdclass.{data__cmdclass_key}".format(**locals()) + "", definition={'type': 'string', 'format': 'python-qualified-identifier'}, rule='format')
+        if "license-files" in data_keys:
+            data_keys.remove("license-files")
+            data__licensefiles = data["license-files"]
+            if not isinstance(data__licensefiles, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".license-files must be array", value=data__licensefiles, name="" + (name_prefix or "data") + ".license-files", definition={'type': 'array', 'items': {'type': 'string'}, '$$description': ['**PROVISIONAL**: list of glob patterns for all license files being distributed.', '(likely to become standard with :pep:`639`).', "By default: ``['LICEN[CS]E*', 'COPYING*', 'NOTICE*', 'AUTHORS*']``"], '$comment': 'TODO: revise if PEP 639 is accepted. Probably ``project.license-files``?'}, rule='type')
+            data__licensefiles_is_list = isinstance(data__licensefiles, (list, tuple))
+            if data__licensefiles_is_list:
+                data__licensefiles_len = len(data__licensefiles)
+                for data__licensefiles_x, data__licensefiles_item in enumerate(data__licensefiles):
+                    if not isinstance(data__licensefiles_item, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".license-files[{data__licensefiles_x}]".format(**locals()) + " must be string", value=data__licensefiles_item, name="" + (name_prefix or "data") + ".license-files[{data__licensefiles_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+        if "dynamic" in data_keys:
+            data_keys.remove("dynamic")
+            data__dynamic = data["dynamic"]
+            if not isinstance(data__dynamic, (dict)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic must be object", value=data__dynamic, name="" + (name_prefix or "data") + ".dynamic", definition={'type': 'object', 'description': 'Instructions for loading :pep:`621`-related metadata dynamically', 'additionalProperties': False, 'properties': {'version': {'$$description': ['A version dynamically loaded via either the ``attr:`` or ``file:``', 'directives. Please make sure the given file or attribute respects :pep:`440`.', 'Also ensure to set ``project.dynamic`` accordingly.'], 'oneOf': [{'title': "'attr:' directive", '$id': '#/definitions/attr-directive', '$$description': ['Value is read from a module attribute. Supports callables and iterables;', 'unsupported types are cast via ``str()``'], 'type': 'object', 'additionalProperties': False, 'properties': {'attr': {'type': 'string', 'format': 'python-qualified-identifier'}}, 'required': ['attr']}, {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}]}, 'classifiers': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'description': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'entry-points': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'dependencies': {'title': "'file:' directive for dependencies", 'allOf': [{'$$description': ['**BETA**: subset of the ``requirements.txt`` format', 'without ``pip`` flags and options', '(one :pep:`508`-compliant string per line,', 'lines that are blank or start with ``#`` are excluded).', 'See `dynamic metadata', '`_.']}, {'$ref': '#/definitions/file-directive'}]}, 'optional-dependencies': {'type': 'object', 'propertyNames': {'type': 'string', 'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'.+': {'title': "'file:' directive for dependencies", 'allOf': [{'$$description': ['**BETA**: subset of the ``requirements.txt`` format', 'without ``pip`` flags and options', '(one :pep:`508`-compliant string per line,', 'lines that are blank or start with ``#`` are excluded).', 'See `dynamic metadata', '`_.']}, {'$ref': '#/definitions/file-directive'}]}}}, 'readme': {'type': 'object', 'anyOf': [{'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, {'type': 'object', 'properties': {'content-type': {'type': 'string'}, 'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'additionalProperties': False}], 'required': ['file']}}}, rule='type')
+            data__dynamic_is_dict = isinstance(data__dynamic, dict)
+            if data__dynamic_is_dict:
+                data__dynamic_keys = set(data__dynamic.keys())
+                if "version" in data__dynamic_keys:
+                    data__dynamic_keys.remove("version")
+                    data__dynamic__version = data__dynamic["version"]
+                    data__dynamic__version_one_of_count6 = 0
+                    if data__dynamic__version_one_of_count6 < 2:
+                        try:
+                            validate_https___setuptools_pypa_io_en_latest_userguide_pyproject_config_html__definitions_attr_directive(data__dynamic__version, custom_formats, (name_prefix or "data") + ".dynamic.version")
+                            data__dynamic__version_one_of_count6 += 1
+                        except JsonSchemaValueException: pass
+                    if data__dynamic__version_one_of_count6 < 2:
+                        try:
+                            validate_https___setuptools_pypa_io_en_latest_userguide_pyproject_config_html__definitions_file_directive(data__dynamic__version, custom_formats, (name_prefix or "data") + ".dynamic.version")
+                            data__dynamic__version_one_of_count6 += 1
+                        except JsonSchemaValueException: pass
+                    if data__dynamic__version_one_of_count6 != 1:
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic.version must be valid exactly by one definition" + (" (" + str(data__dynamic__version_one_of_count6) + " matches found)"), value=data__dynamic__version, name="" + (name_prefix or "data") + ".dynamic.version", definition={'$$description': ['A version dynamically loaded via either the ``attr:`` or ``file:``', 'directives. Please make sure the given file or attribute respects :pep:`440`.', 'Also ensure to set ``project.dynamic`` accordingly.'], 'oneOf': [{'title': "'attr:' directive", '$id': '#/definitions/attr-directive', '$$description': ['Value is read from a module attribute. Supports callables and iterables;', 'unsupported types are cast via ``str()``'], 'type': 'object', 'additionalProperties': False, 'properties': {'attr': {'type': 'string', 'format': 'python-qualified-identifier'}}, 'required': ['attr']}, {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}]}, rule='oneOf')
+                if "classifiers" in data__dynamic_keys:
+                    data__dynamic_keys.remove("classifiers")
+                    data__dynamic__classifiers = data__dynamic["classifiers"]
+                    validate_https___setuptools_pypa_io_en_latest_userguide_pyproject_config_html__definitions_file_directive(data__dynamic__classifiers, custom_formats, (name_prefix or "data") + ".dynamic.classifiers")
+                if "description" in data__dynamic_keys:
+                    data__dynamic_keys.remove("description")
+                    data__dynamic__description = data__dynamic["description"]
+                    validate_https___setuptools_pypa_io_en_latest_userguide_pyproject_config_html__definitions_file_directive(data__dynamic__description, custom_formats, (name_prefix or "data") + ".dynamic.description")
+                if "entry-points" in data__dynamic_keys:
+                    data__dynamic_keys.remove("entry-points")
+                    data__dynamic__entrypoints = data__dynamic["entry-points"]
+                    validate_https___setuptools_pypa_io_en_latest_userguide_pyproject_config_html__definitions_file_directive(data__dynamic__entrypoints, custom_formats, (name_prefix or "data") + ".dynamic.entry-points")
+                if "dependencies" in data__dynamic_keys:
+                    data__dynamic_keys.remove("dependencies")
+                    data__dynamic__dependencies = data__dynamic["dependencies"]
+                    validate_https___setuptools_pypa_io_en_latest_userguide_pyproject_config_html__definitions_file_directive_for_dependencies(data__dynamic__dependencies, custom_formats, (name_prefix or "data") + ".dynamic.dependencies")
+                if "optional-dependencies" in data__dynamic_keys:
+                    data__dynamic_keys.remove("optional-dependencies")
+                    data__dynamic__optionaldependencies = data__dynamic["optional-dependencies"]
+                    if not isinstance(data__dynamic__optionaldependencies, (dict)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic.optional-dependencies must be object", value=data__dynamic__optionaldependencies, name="" + (name_prefix or "data") + ".dynamic.optional-dependencies", definition={'type': 'object', 'propertyNames': {'type': 'string', 'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'.+': {'title': "'file:' directive for dependencies", 'allOf': [{'$$description': ['**BETA**: subset of the ``requirements.txt`` format', 'without ``pip`` flags and options', '(one :pep:`508`-compliant string per line,', 'lines that are blank or start with ``#`` are excluded).', 'See `dynamic metadata', '`_.']}, {'$ref': '#/definitions/file-directive'}]}}}, rule='type')
+                    data__dynamic__optionaldependencies_is_dict = isinstance(data__dynamic__optionaldependencies, dict)
+                    if data__dynamic__optionaldependencies_is_dict:
+                        data__dynamic__optionaldependencies_keys = set(data__dynamic__optionaldependencies.keys())
+                        for data__dynamic__optionaldependencies_key, data__dynamic__optionaldependencies_val in data__dynamic__optionaldependencies.items():
+                            if REGEX_PATTERNS['.+'].search(data__dynamic__optionaldependencies_key):
+                                if data__dynamic__optionaldependencies_key in data__dynamic__optionaldependencies_keys:
+                                    data__dynamic__optionaldependencies_keys.remove(data__dynamic__optionaldependencies_key)
+                                validate_https___setuptools_pypa_io_en_latest_userguide_pyproject_config_html__definitions_file_directive_for_dependencies(data__dynamic__optionaldependencies_val, custom_formats, (name_prefix or "data") + ".dynamic.optional-dependencies.{data__dynamic__optionaldependencies_key}".format(**locals()))
+                        if data__dynamic__optionaldependencies_keys:
+                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic.optional-dependencies must not contain "+str(data__dynamic__optionaldependencies_keys)+" properties", value=data__dynamic__optionaldependencies, name="" + (name_prefix or "data") + ".dynamic.optional-dependencies", definition={'type': 'object', 'propertyNames': {'type': 'string', 'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'.+': {'title': "'file:' directive for dependencies", 'allOf': [{'$$description': ['**BETA**: subset of the ``requirements.txt`` format', 'without ``pip`` flags and options', '(one :pep:`508`-compliant string per line,', 'lines that are blank or start with ``#`` are excluded).', 'See `dynamic metadata', '`_.']}, {'$ref': '#/definitions/file-directive'}]}}}, rule='additionalProperties')
+                        data__dynamic__optionaldependencies_len = len(data__dynamic__optionaldependencies)
+                        if data__dynamic__optionaldependencies_len != 0:
+                            data__dynamic__optionaldependencies_property_names = True
+                            for data__dynamic__optionaldependencies_key in data__dynamic__optionaldependencies:
+                                try:
+                                    if not isinstance(data__dynamic__optionaldependencies_key, (str)):
+                                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic.optional-dependencies must be string", value=data__dynamic__optionaldependencies_key, name="" + (name_prefix or "data") + ".dynamic.optional-dependencies", definition={'type': 'string', 'format': 'pep508-identifier'}, rule='type')
+                                    if isinstance(data__dynamic__optionaldependencies_key, str):
+                                        if not custom_formats["pep508-identifier"](data__dynamic__optionaldependencies_key):
+                                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic.optional-dependencies must be pep508-identifier", value=data__dynamic__optionaldependencies_key, name="" + (name_prefix or "data") + ".dynamic.optional-dependencies", definition={'type': 'string', 'format': 'pep508-identifier'}, rule='format')
+                                except JsonSchemaValueException:
+                                    data__dynamic__optionaldependencies_property_names = False
+                            if not data__dynamic__optionaldependencies_property_names:
+                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic.optional-dependencies must be named by propertyName definition", value=data__dynamic__optionaldependencies, name="" + (name_prefix or "data") + ".dynamic.optional-dependencies", definition={'type': 'object', 'propertyNames': {'type': 'string', 'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'.+': {'title': "'file:' directive for dependencies", 'allOf': [{'$$description': ['**BETA**: subset of the ``requirements.txt`` format', 'without ``pip`` flags and options', '(one :pep:`508`-compliant string per line,', 'lines that are blank or start with ``#`` are excluded).', 'See `dynamic metadata', '`_.']}, {'$ref': '#/definitions/file-directive'}]}}}, rule='propertyNames')
+                if "readme" in data__dynamic_keys:
+                    data__dynamic_keys.remove("readme")
+                    data__dynamic__readme = data__dynamic["readme"]
+                    if not isinstance(data__dynamic__readme, (dict)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic.readme must be object", value=data__dynamic__readme, name="" + (name_prefix or "data") + ".dynamic.readme", definition={'type': 'object', 'anyOf': [{'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, {'type': 'object', 'properties': {'content-type': {'type': 'string'}, 'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'additionalProperties': False}], 'required': ['file']}, rule='type')
+                    data__dynamic__readme_any_of_count7 = 0
+                    if not data__dynamic__readme_any_of_count7:
+                        try:
+                            validate_https___setuptools_pypa_io_en_latest_userguide_pyproject_config_html__definitions_file_directive(data__dynamic__readme, custom_formats, (name_prefix or "data") + ".dynamic.readme")
+                            data__dynamic__readme_any_of_count7 += 1
+                        except JsonSchemaValueException: pass
+                    if not data__dynamic__readme_any_of_count7:
+                        try:
+                            if not isinstance(data__dynamic__readme, (dict)):
+                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic.readme must be object", value=data__dynamic__readme, name="" + (name_prefix or "data") + ".dynamic.readme", definition={'type': 'object', 'properties': {'content-type': {'type': 'string'}, 'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'additionalProperties': False}, rule='type')
+                            data__dynamic__readme_is_dict = isinstance(data__dynamic__readme, dict)
+                            if data__dynamic__readme_is_dict:
+                                data__dynamic__readme_keys = set(data__dynamic__readme.keys())
+                                if "content-type" in data__dynamic__readme_keys:
+                                    data__dynamic__readme_keys.remove("content-type")
+                                    data__dynamic__readme__contenttype = data__dynamic__readme["content-type"]
+                                    if not isinstance(data__dynamic__readme__contenttype, (str)):
+                                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic.readme.content-type must be string", value=data__dynamic__readme__contenttype, name="" + (name_prefix or "data") + ".dynamic.readme.content-type", definition={'type': 'string'}, rule='type')
+                                if "file" in data__dynamic__readme_keys:
+                                    data__dynamic__readme_keys.remove("file")
+                                    data__dynamic__readme__file = data__dynamic__readme["file"]
+                                    validate_https___setuptools_pypa_io_en_latest_userguide_pyproject_config_html__definitions_file_directive_properties_file(data__dynamic__readme__file, custom_formats, (name_prefix or "data") + ".dynamic.readme.file")
+                                if data__dynamic__readme_keys:
+                                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic.readme must not contain "+str(data__dynamic__readme_keys)+" properties", value=data__dynamic__readme, name="" + (name_prefix or "data") + ".dynamic.readme", definition={'type': 'object', 'properties': {'content-type': {'type': 'string'}, 'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'additionalProperties': False}, rule='additionalProperties')
+                            data__dynamic__readme_any_of_count7 += 1
+                        except JsonSchemaValueException: pass
+                    if not data__dynamic__readme_any_of_count7:
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic.readme cannot be validated by any definition", value=data__dynamic__readme, name="" + (name_prefix or "data") + ".dynamic.readme", definition={'type': 'object', 'anyOf': [{'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, {'type': 'object', 'properties': {'content-type': {'type': 'string'}, 'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'additionalProperties': False}], 'required': ['file']}, rule='anyOf')
+                    data__dynamic__readme_is_dict = isinstance(data__dynamic__readme, dict)
+                    if data__dynamic__readme_is_dict:
+                        data__dynamic__readme__missing_keys = set(['file']) - data__dynamic__readme.keys()
+                        if data__dynamic__readme__missing_keys:
+                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic.readme must contain " + (str(sorted(data__dynamic__readme__missing_keys)) + " properties"), value=data__dynamic__readme, name="" + (name_prefix or "data") + ".dynamic.readme", definition={'type': 'object', 'anyOf': [{'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, {'type': 'object', 'properties': {'content-type': {'type': 'string'}, 'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'additionalProperties': False}], 'required': ['file']}, rule='required')
+                if data__dynamic_keys:
+                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic must not contain "+str(data__dynamic_keys)+" properties", value=data__dynamic, name="" + (name_prefix or "data") + ".dynamic", definition={'type': 'object', 'description': 'Instructions for loading :pep:`621`-related metadata dynamically', 'additionalProperties': False, 'properties': {'version': {'$$description': ['A version dynamically loaded via either the ``attr:`` or ``file:``', 'directives. Please make sure the given file or attribute respects :pep:`440`.', 'Also ensure to set ``project.dynamic`` accordingly.'], 'oneOf': [{'title': "'attr:' directive", '$id': '#/definitions/attr-directive', '$$description': ['Value is read from a module attribute. Supports callables and iterables;', 'unsupported types are cast via ``str()``'], 'type': 'object', 'additionalProperties': False, 'properties': {'attr': {'type': 'string', 'format': 'python-qualified-identifier'}}, 'required': ['attr']}, {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}]}, 'classifiers': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'description': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'entry-points': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'dependencies': {'title': "'file:' directive for dependencies", 'allOf': [{'$$description': ['**BETA**: subset of the ``requirements.txt`` format', 'without ``pip`` flags and options', '(one :pep:`508`-compliant string per line,', 'lines that are blank or start with ``#`` are excluded).', 'See `dynamic metadata', '`_.']}, {'$ref': '#/definitions/file-directive'}]}, 'optional-dependencies': {'type': 'object', 'propertyNames': {'type': 'string', 'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'.+': {'title': "'file:' directive for dependencies", 'allOf': [{'$$description': ['**BETA**: subset of the ``requirements.txt`` format', 'without ``pip`` flags and options', '(one :pep:`508`-compliant string per line,', 'lines that are blank or start with ``#`` are excluded).', 'See `dynamic metadata', '`_.']}, {'$ref': '#/definitions/file-directive'}]}}}, 'readme': {'type': 'object', 'anyOf': [{'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, {'type': 'object', 'properties': {'content-type': {'type': 'string'}, 'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'additionalProperties': False}], 'required': ['file']}}}, rule='additionalProperties')
+        if data_keys:
+            raise JsonSchemaValueException("" + (name_prefix or "data") + " must not contain "+str(data_keys)+" properties", value=data, name="" + (name_prefix or "data") + "", definition={'$schema': 'http://json-schema.org/draft-07/schema#', '$id': 'https://setuptools.pypa.io/en/latest/userguide/pyproject_config.html', 'title': '``tool.setuptools`` table', '$$description': ['``setuptools``-specific configurations that can be set by users that require', 'customization.', 'These configurations are completely optional and probably can be skipped when', 'creating simple packages. They are equivalent to some of the `Keywords', '`_', 'used by the ``setup.py`` file, and can be set via the ``tool.setuptools`` table.', 'It considers only ``setuptools`` `parameters', '`_', 'that are not covered by :pep:`621`; and intentionally excludes ``dependency_links``', 'and ``setup_requires`` (incompatible with modern workflows/standards).'], 'type': 'object', 'additionalProperties': False, 'properties': {'platforms': {'type': 'array', 'items': {'type': 'string'}}, 'provides': {'$$description': ['Package and virtual package names contained within this package', '**(not supported by pip)**'], 'type': 'array', 'items': {'type': 'string', 'format': 'pep508-identifier'}}, 'obsoletes': {'$$description': ['Packages which this package renders obsolete', '**(not supported by pip)**'], 'type': 'array', 'items': {'type': 'string', 'format': 'pep508-identifier'}}, 'zip-safe': {'$$description': ['Whether the project can be safely installed and run from a zip file.', '**OBSOLETE**: only relevant for ``pkg_resources``, ``easy_install`` and', '``setup.py install`` in the context of ``eggs`` (**DEPRECATED**).'], 'type': 'boolean'}, 'script-files': {'$$description': ['Legacy way of defining scripts (entry-points are preferred).', 'Equivalent to the ``script`` keyword in ``setup.py``', '(it was renamed to avoid confusion with entry-point based ``project.scripts``', 'defined in :pep:`621`).', '**DISCOURAGED**: generic script wrappers are tricky and may not work properly.', 'Whenever possible, please use ``project.scripts`` instead.'], 'type': 'array', 'items': {'type': 'string'}, '$comment': 'TODO: is this field deprecated/should be removed?'}, 'eager-resources': {'$$description': ['Resources that should be extracted together, if any of them is needed,', 'or if any C extensions included in the project are imported.', '**OBSOLETE**: only relevant for ``pkg_resources``, ``easy_install`` and', '``setup.py install`` in the context of ``eggs`` (**DEPRECATED**).'], 'type': 'array', 'items': {'type': 'string'}}, 'packages': {'$$description': ['Packages that should be included in the distribution.', 'It can be given either as a list of package identifiers', 'or as a ``dict``-like structure with a single key ``find``', 'which corresponds to a dynamic call to', '``setuptools.config.expand.find_packages`` function.', 'The ``find`` key is associated with a nested ``dict``-like structure that can', 'contain ``where``, ``include``, ``exclude`` and ``namespaces`` keys,', 'mimicking the keyword arguments of the associated function.'], 'oneOf': [{'title': 'Array of Python package identifiers', 'type': 'array', 'items': {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}}, {'$id': '#/definitions/find-directive', 'title': "'find:' directive", 'type': 'object', 'additionalProperties': False, 'properties': {'find': {'type': 'object', '$$description': ['Dynamic `package discovery', '`_.'], 'additionalProperties': False, 'properties': {'where': {'description': 'Directories to be searched for packages (Unix-style relative path)', 'type': 'array', 'items': {'type': 'string'}}, 'exclude': {'type': 'array', '$$description': ['Exclude packages that match the values listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'include': {'type': 'array', '$$description': ['Restrict the found packages to just the ones listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'namespaces': {'type': 'boolean', '$$description': ['When ``True``, directories without a ``__init__.py`` file will also', 'be scanned for :pep:`420`-style implicit namespaces']}}}}}]}, 'package-dir': {'$$description': [':class:`dict`-like structure mapping from package names to directories where their', 'code can be found.', 'The empty string (as key) means that all packages are contained inside', 'the given directory will be included in the distribution.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'anyOf': [{'const': ''}, {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}]}, 'patternProperties': {'^.*$': {'type': 'string'}}}, 'package-data': {'$$description': ['Mapping from package names to lists of glob patterns.', 'Usually this option is not needed when using ``include-package-data = true``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'anyOf': [{'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'include-package-data': {'$$description': ['Automatically include any data files inside the package directories', 'that are specified by ``MANIFEST.in``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'boolean'}, 'exclude-package-data': {'$$description': ['Mapping from package names to lists of glob patterns that should be excluded', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'anyOf': [{'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'namespace-packages': {'type': 'array', 'items': {'type': 'string', 'format': 'python-module-name-relaxed'}, '$comment': 'https://setuptools.pypa.io/en/latest/userguide/package_discovery.html', 'description': '**DEPRECATED**: use implicit namespaces instead (:pep:`420`).'}, 'py-modules': {'description': 'Modules that setuptools will manipulate', 'type': 'array', 'items': {'type': 'string', 'format': 'python-module-name-relaxed'}, '$comment': 'TODO: clarify the relationship with ``packages``'}, 'ext-modules': {'description': 'Extension modules to be compiled by setuptools', 'type': 'array', 'items': {'$id': '#/definitions/ext-module', 'title': 'Extension module', 'description': 'Parameters to construct a :class:`setuptools.Extension` object', 'type': 'object', 'required': ['name', 'sources'], 'additionalProperties': False, 'properties': {'name': {'type': 'string', 'format': 'python-module-name-relaxed'}, 'sources': {'type': 'array', 'items': {'type': 'string'}}, 'include-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'define-macros': {'type': 'array', 'items': {'type': 'array', 'items': [{'description': 'macro name', 'type': 'string'}, {'description': 'macro value', 'oneOf': [{'type': 'string'}, {'type': 'null'}]}], 'additionalItems': False}}, 'undef-macros': {'type': 'array', 'items': {'type': 'string'}}, 'library-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'libraries': {'type': 'array', 'items': {'type': 'string'}}, 'runtime-library-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'extra-objects': {'type': 'array', 'items': {'type': 'string'}}, 'extra-compile-args': {'type': 'array', 'items': {'type': 'string'}}, 'extra-link-args': {'type': 'array', 'items': {'type': 'string'}}, 'export-symbols': {'type': 'array', 'items': {'type': 'string'}}, 'swig-opts': {'type': 'array', 'items': {'type': 'string'}}, 'depends': {'type': 'array', 'items': {'type': 'string'}}, 'language': {'type': 'string'}, 'optional': {'type': 'boolean'}, 'py-limited-api': {'type': 'boolean'}}}}, 'data-files': {'$$description': ['``dict``-like structure where each key represents a directory and', 'the value is a list of glob patterns that should be installed in them.', '**DISCOURAGED**: please notice this might not work as expected with wheels.', 'Whenever possible, consider using data files inside the package directories', '(or create a new namespace package that only contains data files).', 'See `data files support', '`_.'], 'type': 'object', 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'cmdclass': {'$$description': ['Mapping of distutils-style command names to ``setuptools.Command`` subclasses', 'which in turn should be represented by strings with a qualified class name', '(i.e., "dotted" form with module), e.g.::\n\n', '    cmdclass = {mycmd = "pkg.subpkg.module.CommandClass"}\n\n', 'The command class should be a directly defined at the top-level of the', 'containing module (no class nesting).'], 'type': 'object', 'patternProperties': {'^.*$': {'type': 'string', 'format': 'python-qualified-identifier'}}}, 'license-files': {'type': 'array', 'items': {'type': 'string'}, '$$description': ['**PROVISIONAL**: list of glob patterns for all license files being distributed.', '(likely to become standard with :pep:`639`).', "By default: ``['LICEN[CS]E*', 'COPYING*', 'NOTICE*', 'AUTHORS*']``"], '$comment': 'TODO: revise if PEP 639 is accepted. Probably ``project.license-files``?'}, 'dynamic': {'type': 'object', 'description': 'Instructions for loading :pep:`621`-related metadata dynamically', 'additionalProperties': False, 'properties': {'version': {'$$description': ['A version dynamically loaded via either the ``attr:`` or ``file:``', 'directives. Please make sure the given file or attribute respects :pep:`440`.', 'Also ensure to set ``project.dynamic`` accordingly.'], 'oneOf': [{'title': "'attr:' directive", '$id': '#/definitions/attr-directive', '$$description': ['Value is read from a module attribute. Supports callables and iterables;', 'unsupported types are cast via ``str()``'], 'type': 'object', 'additionalProperties': False, 'properties': {'attr': {'type': 'string', 'format': 'python-qualified-identifier'}}, 'required': ['attr']}, {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}]}, 'classifiers': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'description': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'entry-points': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'dependencies': {'title': "'file:' directive for dependencies", 'allOf': [{'$$description': ['**BETA**: subset of the ``requirements.txt`` format', 'without ``pip`` flags and options', '(one :pep:`508`-compliant string per line,', 'lines that are blank or start with ``#`` are excluded).', 'See `dynamic metadata', '`_.']}, {'$ref': '#/definitions/file-directive'}]}, 'optional-dependencies': {'type': 'object', 'propertyNames': {'type': 'string', 'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'.+': {'title': "'file:' directive for dependencies", 'allOf': [{'$$description': ['**BETA**: subset of the ``requirements.txt`` format', 'without ``pip`` flags and options', '(one :pep:`508`-compliant string per line,', 'lines that are blank or start with ``#`` are excluded).', 'See `dynamic metadata', '`_.']}, {'$ref': '#/definitions/file-directive'}]}}}, 'readme': {'type': 'object', 'anyOf': [{'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, {'type': 'object', 'properties': {'content-type': {'type': 'string'}, 'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'additionalProperties': False}], 'required': ['file']}}}}, 'definitions': {'package-name': {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}, 'ext-module': {'$id': '#/definitions/ext-module', 'title': 'Extension module', 'description': 'Parameters to construct a :class:`setuptools.Extension` object', 'type': 'object', 'required': ['name', 'sources'], 'additionalProperties': False, 'properties': {'name': {'type': 'string', 'format': 'python-module-name-relaxed'}, 'sources': {'type': 'array', 'items': {'type': 'string'}}, 'include-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'define-macros': {'type': 'array', 'items': {'type': 'array', 'items': [{'description': 'macro name', 'type': 'string'}, {'description': 'macro value', 'oneOf': [{'type': 'string'}, {'type': 'null'}]}], 'additionalItems': False}}, 'undef-macros': {'type': 'array', 'items': {'type': 'string'}}, 'library-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'libraries': {'type': 'array', 'items': {'type': 'string'}}, 'runtime-library-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'extra-objects': {'type': 'array', 'items': {'type': 'string'}}, 'extra-compile-args': {'type': 'array', 'items': {'type': 'string'}}, 'extra-link-args': {'type': 'array', 'items': {'type': 'string'}}, 'export-symbols': {'type': 'array', 'items': {'type': 'string'}}, 'swig-opts': {'type': 'array', 'items': {'type': 'string'}}, 'depends': {'type': 'array', 'items': {'type': 'string'}}, 'language': {'type': 'string'}, 'optional': {'type': 'boolean'}, 'py-limited-api': {'type': 'boolean'}}}, 'file-directive': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'file-directive-for-dependencies': {'title': "'file:' directive for dependencies", 'allOf': [{'$$description': ['**BETA**: subset of the ``requirements.txt`` format', 'without ``pip`` flags and options', '(one :pep:`508`-compliant string per line,', 'lines that are blank or start with ``#`` are excluded).', 'See `dynamic metadata', '`_.']}, {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}]}, 'attr-directive': {'title': "'attr:' directive", '$id': '#/definitions/attr-directive', '$$description': ['Value is read from a module attribute. Supports callables and iterables;', 'unsupported types are cast via ``str()``'], 'type': 'object', 'additionalProperties': False, 'properties': {'attr': {'type': 'string', 'format': 'python-qualified-identifier'}}, 'required': ['attr']}, 'find-directive': {'$id': '#/definitions/find-directive', 'title': "'find:' directive", 'type': 'object', 'additionalProperties': False, 'properties': {'find': {'type': 'object', '$$description': ['Dynamic `package discovery', '`_.'], 'additionalProperties': False, 'properties': {'where': {'description': 'Directories to be searched for packages (Unix-style relative path)', 'type': 'array', 'items': {'type': 'string'}}, 'exclude': {'type': 'array', '$$description': ['Exclude packages that match the values listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'include': {'type': 'array', '$$description': ['Restrict the found packages to just the ones listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'namespaces': {'type': 'boolean', '$$description': ['When ``True``, directories without a ``__init__.py`` file will also', 'be scanned for :pep:`420`-style implicit namespaces']}}}}}}}, rule='additionalProperties')
+    return data
+
+def validate_https___setuptools_pypa_io_en_latest_userguide_pyproject_config_html__definitions_file_directive_properties_file(data, custom_formats={}, name_prefix=None):
+    data_one_of_count8 = 0
+    if data_one_of_count8 < 2:
+        try:
+            if not isinstance(data, (str)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + " must be string", value=data, name="" + (name_prefix or "data") + "", definition={'type': 'string'}, rule='type')
+            data_one_of_count8 += 1
+        except JsonSchemaValueException: pass
+    if data_one_of_count8 < 2:
+        try:
+            if not isinstance(data, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + " must be array", value=data, name="" + (name_prefix or "data") + "", definition={'type': 'array', 'items': {'type': 'string'}}, rule='type')
+            data_is_list = isinstance(data, (list, tuple))
+            if data_is_list:
+                data_len = len(data)
+                for data_x, data_item in enumerate(data):
+                    if not isinstance(data_item, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + "[{data_x}]".format(**locals()) + " must be string", value=data_item, name="" + (name_prefix or "data") + "[{data_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+            data_one_of_count8 += 1
+        except JsonSchemaValueException: pass
+    if data_one_of_count8 != 1:
+        raise JsonSchemaValueException("" + (name_prefix or "data") + " must be valid exactly by one definition" + (" (" + str(data_one_of_count8) + " matches found)"), value=data, name="" + (name_prefix or "data") + "", definition={'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}, rule='oneOf')
+    return data
+
+def validate_https___setuptools_pypa_io_en_latest_userguide_pyproject_config_html__definitions_file_directive_for_dependencies(data, custom_formats={}, name_prefix=None):
+    validate_https___setuptools_pypa_io_en_latest_userguide_pyproject_config_html__definitions_file_directive(data, custom_formats, (name_prefix or "data") + "")
+    return data
+
+def validate_https___setuptools_pypa_io_en_latest_userguide_pyproject_config_html__definitions_file_directive(data, custom_formats={}, name_prefix=None):
+    if not isinstance(data, (dict)):
+        raise JsonSchemaValueException("" + (name_prefix or "data") + " must be object", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, rule='type')
+    data_is_dict = isinstance(data, dict)
+    if data_is_dict:
+        data__missing_keys = set(['file']) - data.keys()
+        if data__missing_keys:
+            raise JsonSchemaValueException("" + (name_prefix or "data") + " must contain " + (str(sorted(data__missing_keys)) + " properties"), value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, rule='required')
+        data_keys = set(data.keys())
+        if "file" in data_keys:
+            data_keys.remove("file")
+            data__file = data["file"]
+            data__file_one_of_count9 = 0
+            if data__file_one_of_count9 < 2:
+                try:
+                    if not isinstance(data__file, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".file must be string", value=data__file, name="" + (name_prefix or "data") + ".file", definition={'type': 'string'}, rule='type')
+                    data__file_one_of_count9 += 1
+                except JsonSchemaValueException: pass
+            if data__file_one_of_count9 < 2:
+                try:
+                    if not isinstance(data__file, (list, tuple)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".file must be array", value=data__file, name="" + (name_prefix or "data") + ".file", definition={'type': 'array', 'items': {'type': 'string'}}, rule='type')
+                    data__file_is_list = isinstance(data__file, (list, tuple))
+                    if data__file_is_list:
+                        data__file_len = len(data__file)
+                        for data__file_x, data__file_item in enumerate(data__file):
+                            if not isinstance(data__file_item, (str)):
+                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".file[{data__file_x}]".format(**locals()) + " must be string", value=data__file_item, name="" + (name_prefix or "data") + ".file[{data__file_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+                    data__file_one_of_count9 += 1
+                except JsonSchemaValueException: pass
+            if data__file_one_of_count9 != 1:
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".file must be valid exactly by one definition" + (" (" + str(data__file_one_of_count9) + " matches found)"), value=data__file, name="" + (name_prefix or "data") + ".file", definition={'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}, rule='oneOf')
+        if data_keys:
+            raise JsonSchemaValueException("" + (name_prefix or "data") + " must not contain "+str(data_keys)+" properties", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, rule='additionalProperties')
+    return data
+
+def validate_https___setuptools_pypa_io_en_latest_userguide_pyproject_config_html__definitions_attr_directive(data, custom_formats={}, name_prefix=None):
+    if not isinstance(data, (dict)):
+        raise JsonSchemaValueException("" + (name_prefix or "data") + " must be object", value=data, name="" + (name_prefix or "data") + "", definition={'title': "'attr:' directive", '$id': '#/definitions/attr-directive', '$$description': ['Value is read from a module attribute. Supports callables and iterables;', 'unsupported types are cast via ``str()``'], 'type': 'object', 'additionalProperties': False, 'properties': {'attr': {'type': 'string', 'format': 'python-qualified-identifier'}}, 'required': ['attr']}, rule='type')
+    data_is_dict = isinstance(data, dict)
+    if data_is_dict:
+        data__missing_keys = set(['attr']) - data.keys()
+        if data__missing_keys:
+            raise JsonSchemaValueException("" + (name_prefix or "data") + " must contain " + (str(sorted(data__missing_keys)) + " properties"), value=data, name="" + (name_prefix or "data") + "", definition={'title': "'attr:' directive", '$id': '#/definitions/attr-directive', '$$description': ['Value is read from a module attribute. Supports callables and iterables;', 'unsupported types are cast via ``str()``'], 'type': 'object', 'additionalProperties': False, 'properties': {'attr': {'type': 'string', 'format': 'python-qualified-identifier'}}, 'required': ['attr']}, rule='required')
+        data_keys = set(data.keys())
+        if "attr" in data_keys:
+            data_keys.remove("attr")
+            data__attr = data["attr"]
+            if not isinstance(data__attr, (str)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".attr must be string", value=data__attr, name="" + (name_prefix or "data") + ".attr", definition={'type': 'string', 'format': 'python-qualified-identifier'}, rule='type')
+            if isinstance(data__attr, str):
+                if not custom_formats["python-qualified-identifier"](data__attr):
+                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".attr must be python-qualified-identifier", value=data__attr, name="" + (name_prefix or "data") + ".attr", definition={'type': 'string', 'format': 'python-qualified-identifier'}, rule='format')
+        if data_keys:
+            raise JsonSchemaValueException("" + (name_prefix or "data") + " must not contain "+str(data_keys)+" properties", value=data, name="" + (name_prefix or "data") + "", definition={'title': "'attr:' directive", '$id': '#/definitions/attr-directive', '$$description': ['Value is read from a module attribute. Supports callables and iterables;', 'unsupported types are cast via ``str()``'], 'type': 'object', 'additionalProperties': False, 'properties': {'attr': {'type': 'string', 'format': 'python-qualified-identifier'}}, 'required': ['attr']}, rule='additionalProperties')
+    return data
+
+def validate_https___setuptools_pypa_io_en_latest_userguide_pyproject_config_html__definitions_ext_module(data, custom_formats={}, name_prefix=None):
+    if not isinstance(data, (dict)):
+        raise JsonSchemaValueException("" + (name_prefix or "data") + " must be object", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/ext-module', 'title': 'Extension module', 'description': 'Parameters to construct a :class:`setuptools.Extension` object', 'type': 'object', 'required': ['name', 'sources'], 'additionalProperties': False, 'properties': {'name': {'type': 'string', 'format': 'python-module-name-relaxed'}, 'sources': {'type': 'array', 'items': {'type': 'string'}}, 'include-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'define-macros': {'type': 'array', 'items': {'type': 'array', 'items': [{'description': 'macro name', 'type': 'string'}, {'description': 'macro value', 'oneOf': [{'type': 'string'}, {'type': 'null'}]}], 'additionalItems': False}}, 'undef-macros': {'type': 'array', 'items': {'type': 'string'}}, 'library-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'libraries': {'type': 'array', 'items': {'type': 'string'}}, 'runtime-library-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'extra-objects': {'type': 'array', 'items': {'type': 'string'}}, 'extra-compile-args': {'type': 'array', 'items': {'type': 'string'}}, 'extra-link-args': {'type': 'array', 'items': {'type': 'string'}}, 'export-symbols': {'type': 'array', 'items': {'type': 'string'}}, 'swig-opts': {'type': 'array', 'items': {'type': 'string'}}, 'depends': {'type': 'array', 'items': {'type': 'string'}}, 'language': {'type': 'string'}, 'optional': {'type': 'boolean'}, 'py-limited-api': {'type': 'boolean'}}}, rule='type')
+    data_is_dict = isinstance(data, dict)
+    if data_is_dict:
+        data__missing_keys = set(['name', 'sources']) - data.keys()
+        if data__missing_keys:
+            raise JsonSchemaValueException("" + (name_prefix or "data") + " must contain " + (str(sorted(data__missing_keys)) + " properties"), value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/ext-module', 'title': 'Extension module', 'description': 'Parameters to construct a :class:`setuptools.Extension` object', 'type': 'object', 'required': ['name', 'sources'], 'additionalProperties': False, 'properties': {'name': {'type': 'string', 'format': 'python-module-name-relaxed'}, 'sources': {'type': 'array', 'items': {'type': 'string'}}, 'include-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'define-macros': {'type': 'array', 'items': {'type': 'array', 'items': [{'description': 'macro name', 'type': 'string'}, {'description': 'macro value', 'oneOf': [{'type': 'string'}, {'type': 'null'}]}], 'additionalItems': False}}, 'undef-macros': {'type': 'array', 'items': {'type': 'string'}}, 'library-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'libraries': {'type': 'array', 'items': {'type': 'string'}}, 'runtime-library-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'extra-objects': {'type': 'array', 'items': {'type': 'string'}}, 'extra-compile-args': {'type': 'array', 'items': {'type': 'string'}}, 'extra-link-args': {'type': 'array', 'items': {'type': 'string'}}, 'export-symbols': {'type': 'array', 'items': {'type': 'string'}}, 'swig-opts': {'type': 'array', 'items': {'type': 'string'}}, 'depends': {'type': 'array', 'items': {'type': 'string'}}, 'language': {'type': 'string'}, 'optional': {'type': 'boolean'}, 'py-limited-api': {'type': 'boolean'}}}, rule='required')
+        data_keys = set(data.keys())
+        if "name" in data_keys:
+            data_keys.remove("name")
+            data__name = data["name"]
+            if not isinstance(data__name, (str)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".name must be string", value=data__name, name="" + (name_prefix or "data") + ".name", definition={'type': 'string', 'format': 'python-module-name-relaxed'}, rule='type')
+            if isinstance(data__name, str):
+                if not custom_formats["python-module-name-relaxed"](data__name):
+                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".name must be python-module-name-relaxed", value=data__name, name="" + (name_prefix or "data") + ".name", definition={'type': 'string', 'format': 'python-module-name-relaxed'}, rule='format')
+        if "sources" in data_keys:
+            data_keys.remove("sources")
+            data__sources = data["sources"]
+            if not isinstance(data__sources, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".sources must be array", value=data__sources, name="" + (name_prefix or "data") + ".sources", definition={'type': 'array', 'items': {'type': 'string'}}, rule='type')
+            data__sources_is_list = isinstance(data__sources, (list, tuple))
+            if data__sources_is_list:
+                data__sources_len = len(data__sources)
+                for data__sources_x, data__sources_item in enumerate(data__sources):
+                    if not isinstance(data__sources_item, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".sources[{data__sources_x}]".format(**locals()) + " must be string", value=data__sources_item, name="" + (name_prefix or "data") + ".sources[{data__sources_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+        if "include-dirs" in data_keys:
+            data_keys.remove("include-dirs")
+            data__includedirs = data["include-dirs"]
+            if not isinstance(data__includedirs, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".include-dirs must be array", value=data__includedirs, name="" + (name_prefix or "data") + ".include-dirs", definition={'type': 'array', 'items': {'type': 'string'}}, rule='type')
+            data__includedirs_is_list = isinstance(data__includedirs, (list, tuple))
+            if data__includedirs_is_list:
+                data__includedirs_len = len(data__includedirs)
+                for data__includedirs_x, data__includedirs_item in enumerate(data__includedirs):
+                    if not isinstance(data__includedirs_item, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".include-dirs[{data__includedirs_x}]".format(**locals()) + " must be string", value=data__includedirs_item, name="" + (name_prefix or "data") + ".include-dirs[{data__includedirs_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+        if "define-macros" in data_keys:
+            data_keys.remove("define-macros")
+            data__definemacros = data["define-macros"]
+            if not isinstance(data__definemacros, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".define-macros must be array", value=data__definemacros, name="" + (name_prefix or "data") + ".define-macros", definition={'type': 'array', 'items': {'type': 'array', 'items': [{'description': 'macro name', 'type': 'string'}, {'description': 'macro value', 'oneOf': [{'type': 'string'}, {'type': 'null'}]}], 'additionalItems': False}}, rule='type')
+            data__definemacros_is_list = isinstance(data__definemacros, (list, tuple))
+            if data__definemacros_is_list:
+                data__definemacros_len = len(data__definemacros)
+                for data__definemacros_x, data__definemacros_item in enumerate(data__definemacros):
+                    if not isinstance(data__definemacros_item, (list, tuple)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".define-macros[{data__definemacros_x}]".format(**locals()) + " must be array", value=data__definemacros_item, name="" + (name_prefix or "data") + ".define-macros[{data__definemacros_x}]".format(**locals()) + "", definition={'type': 'array', 'items': [{'description': 'macro name', 'type': 'string'}, {'description': 'macro value', 'oneOf': [{'type': 'string'}, {'type': 'null'}]}], 'additionalItems': False}, rule='type')
+                    data__definemacros_item_is_list = isinstance(data__definemacros_item, (list, tuple))
+                    if data__definemacros_item_is_list:
+                        data__definemacros_item_len = len(data__definemacros_item)
+                        if data__definemacros_item_len > 0:
+                            data__definemacros_item__0 = data__definemacros_item[0]
+                            if not isinstance(data__definemacros_item__0, (str)):
+                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".define-macros[{data__definemacros_x}][0]".format(**locals()) + " must be string", value=data__definemacros_item__0, name="" + (name_prefix or "data") + ".define-macros[{data__definemacros_x}][0]".format(**locals()) + "", definition={'description': 'macro name', 'type': 'string'}, rule='type')
+                        if data__definemacros_item_len > 1:
+                            data__definemacros_item__1 = data__definemacros_item[1]
+                            data__definemacros_item__1_one_of_count10 = 0
+                            if data__definemacros_item__1_one_of_count10 < 2:
+                                try:
+                                    if not isinstance(data__definemacros_item__1, (str)):
+                                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".define-macros[{data__definemacros_x}][1]".format(**locals()) + " must be string", value=data__definemacros_item__1, name="" + (name_prefix or "data") + ".define-macros[{data__definemacros_x}][1]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+                                    data__definemacros_item__1_one_of_count10 += 1
+                                except JsonSchemaValueException: pass
+                            if data__definemacros_item__1_one_of_count10 < 2:
+                                try:
+                                    if not isinstance(data__definemacros_item__1, (NoneType)):
+                                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".define-macros[{data__definemacros_x}][1]".format(**locals()) + " must be null", value=data__definemacros_item__1, name="" + (name_prefix or "data") + ".define-macros[{data__definemacros_x}][1]".format(**locals()) + "", definition={'type': 'null'}, rule='type')
+                                    data__definemacros_item__1_one_of_count10 += 1
+                                except JsonSchemaValueException: pass
+                            if data__definemacros_item__1_one_of_count10 != 1:
+                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".define-macros[{data__definemacros_x}][1]".format(**locals()) + " must be valid exactly by one definition" + (" (" + str(data__definemacros_item__1_one_of_count10) + " matches found)"), value=data__definemacros_item__1, name="" + (name_prefix or "data") + ".define-macros[{data__definemacros_x}][1]".format(**locals()) + "", definition={'description': 'macro value', 'oneOf': [{'type': 'string'}, {'type': 'null'}]}, rule='oneOf')
+                        if data__definemacros_item_len > 2:
+                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".define-macros[{data__definemacros_x}]".format(**locals()) + " must contain only specified items", value=data__definemacros_item, name="" + (name_prefix or "data") + ".define-macros[{data__definemacros_x}]".format(**locals()) + "", definition={'type': 'array', 'items': [{'description': 'macro name', 'type': 'string'}, {'description': 'macro value', 'oneOf': [{'type': 'string'}, {'type': 'null'}]}], 'additionalItems': False}, rule='items')
+        if "undef-macros" in data_keys:
+            data_keys.remove("undef-macros")
+            data__undefmacros = data["undef-macros"]
+            if not isinstance(data__undefmacros, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".undef-macros must be array", value=data__undefmacros, name="" + (name_prefix or "data") + ".undef-macros", definition={'type': 'array', 'items': {'type': 'string'}}, rule='type')
+            data__undefmacros_is_list = isinstance(data__undefmacros, (list, tuple))
+            if data__undefmacros_is_list:
+                data__undefmacros_len = len(data__undefmacros)
+                for data__undefmacros_x, data__undefmacros_item in enumerate(data__undefmacros):
+                    if not isinstance(data__undefmacros_item, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".undef-macros[{data__undefmacros_x}]".format(**locals()) + " must be string", value=data__undefmacros_item, name="" + (name_prefix or "data") + ".undef-macros[{data__undefmacros_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+        if "library-dirs" in data_keys:
+            data_keys.remove("library-dirs")
+            data__librarydirs = data["library-dirs"]
+            if not isinstance(data__librarydirs, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".library-dirs must be array", value=data__librarydirs, name="" + (name_prefix or "data") + ".library-dirs", definition={'type': 'array', 'items': {'type': 'string'}}, rule='type')
+            data__librarydirs_is_list = isinstance(data__librarydirs, (list, tuple))
+            if data__librarydirs_is_list:
+                data__librarydirs_len = len(data__librarydirs)
+                for data__librarydirs_x, data__librarydirs_item in enumerate(data__librarydirs):
+                    if not isinstance(data__librarydirs_item, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".library-dirs[{data__librarydirs_x}]".format(**locals()) + " must be string", value=data__librarydirs_item, name="" + (name_prefix or "data") + ".library-dirs[{data__librarydirs_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+        if "libraries" in data_keys:
+            data_keys.remove("libraries")
+            data__libraries = data["libraries"]
+            if not isinstance(data__libraries, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".libraries must be array", value=data__libraries, name="" + (name_prefix or "data") + ".libraries", definition={'type': 'array', 'items': {'type': 'string'}}, rule='type')
+            data__libraries_is_list = isinstance(data__libraries, (list, tuple))
+            if data__libraries_is_list:
+                data__libraries_len = len(data__libraries)
+                for data__libraries_x, data__libraries_item in enumerate(data__libraries):
+                    if not isinstance(data__libraries_item, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".libraries[{data__libraries_x}]".format(**locals()) + " must be string", value=data__libraries_item, name="" + (name_prefix or "data") + ".libraries[{data__libraries_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+        if "runtime-library-dirs" in data_keys:
+            data_keys.remove("runtime-library-dirs")
+            data__runtimelibrarydirs = data["runtime-library-dirs"]
+            if not isinstance(data__runtimelibrarydirs, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".runtime-library-dirs must be array", value=data__runtimelibrarydirs, name="" + (name_prefix or "data") + ".runtime-library-dirs", definition={'type': 'array', 'items': {'type': 'string'}}, rule='type')
+            data__runtimelibrarydirs_is_list = isinstance(data__runtimelibrarydirs, (list, tuple))
+            if data__runtimelibrarydirs_is_list:
+                data__runtimelibrarydirs_len = len(data__runtimelibrarydirs)
+                for data__runtimelibrarydirs_x, data__runtimelibrarydirs_item in enumerate(data__runtimelibrarydirs):
+                    if not isinstance(data__runtimelibrarydirs_item, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".runtime-library-dirs[{data__runtimelibrarydirs_x}]".format(**locals()) + " must be string", value=data__runtimelibrarydirs_item, name="" + (name_prefix or "data") + ".runtime-library-dirs[{data__runtimelibrarydirs_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+        if "extra-objects" in data_keys:
+            data_keys.remove("extra-objects")
+            data__extraobjects = data["extra-objects"]
+            if not isinstance(data__extraobjects, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".extra-objects must be array", value=data__extraobjects, name="" + (name_prefix or "data") + ".extra-objects", definition={'type': 'array', 'items': {'type': 'string'}}, rule='type')
+            data__extraobjects_is_list = isinstance(data__extraobjects, (list, tuple))
+            if data__extraobjects_is_list:
+                data__extraobjects_len = len(data__extraobjects)
+                for data__extraobjects_x, data__extraobjects_item in enumerate(data__extraobjects):
+                    if not isinstance(data__extraobjects_item, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".extra-objects[{data__extraobjects_x}]".format(**locals()) + " must be string", value=data__extraobjects_item, name="" + (name_prefix or "data") + ".extra-objects[{data__extraobjects_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+        if "extra-compile-args" in data_keys:
+            data_keys.remove("extra-compile-args")
+            data__extracompileargs = data["extra-compile-args"]
+            if not isinstance(data__extracompileargs, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".extra-compile-args must be array", value=data__extracompileargs, name="" + (name_prefix or "data") + ".extra-compile-args", definition={'type': 'array', 'items': {'type': 'string'}}, rule='type')
+            data__extracompileargs_is_list = isinstance(data__extracompileargs, (list, tuple))
+            if data__extracompileargs_is_list:
+                data__extracompileargs_len = len(data__extracompileargs)
+                for data__extracompileargs_x, data__extracompileargs_item in enumerate(data__extracompileargs):
+                    if not isinstance(data__extracompileargs_item, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".extra-compile-args[{data__extracompileargs_x}]".format(**locals()) + " must be string", value=data__extracompileargs_item, name="" + (name_prefix or "data") + ".extra-compile-args[{data__extracompileargs_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+        if "extra-link-args" in data_keys:
+            data_keys.remove("extra-link-args")
+            data__extralinkargs = data["extra-link-args"]
+            if not isinstance(data__extralinkargs, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".extra-link-args must be array", value=data__extralinkargs, name="" + (name_prefix or "data") + ".extra-link-args", definition={'type': 'array', 'items': {'type': 'string'}}, rule='type')
+            data__extralinkargs_is_list = isinstance(data__extralinkargs, (list, tuple))
+            if data__extralinkargs_is_list:
+                data__extralinkargs_len = len(data__extralinkargs)
+                for data__extralinkargs_x, data__extralinkargs_item in enumerate(data__extralinkargs):
+                    if not isinstance(data__extralinkargs_item, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".extra-link-args[{data__extralinkargs_x}]".format(**locals()) + " must be string", value=data__extralinkargs_item, name="" + (name_prefix or "data") + ".extra-link-args[{data__extralinkargs_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+        if "export-symbols" in data_keys:
+            data_keys.remove("export-symbols")
+            data__exportsymbols = data["export-symbols"]
+            if not isinstance(data__exportsymbols, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".export-symbols must be array", value=data__exportsymbols, name="" + (name_prefix or "data") + ".export-symbols", definition={'type': 'array', 'items': {'type': 'string'}}, rule='type')
+            data__exportsymbols_is_list = isinstance(data__exportsymbols, (list, tuple))
+            if data__exportsymbols_is_list:
+                data__exportsymbols_len = len(data__exportsymbols)
+                for data__exportsymbols_x, data__exportsymbols_item in enumerate(data__exportsymbols):
+                    if not isinstance(data__exportsymbols_item, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".export-symbols[{data__exportsymbols_x}]".format(**locals()) + " must be string", value=data__exportsymbols_item, name="" + (name_prefix or "data") + ".export-symbols[{data__exportsymbols_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+        if "swig-opts" in data_keys:
+            data_keys.remove("swig-opts")
+            data__swigopts = data["swig-opts"]
+            if not isinstance(data__swigopts, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".swig-opts must be array", value=data__swigopts, name="" + (name_prefix or "data") + ".swig-opts", definition={'type': 'array', 'items': {'type': 'string'}}, rule='type')
+            data__swigopts_is_list = isinstance(data__swigopts, (list, tuple))
+            if data__swigopts_is_list:
+                data__swigopts_len = len(data__swigopts)
+                for data__swigopts_x, data__swigopts_item in enumerate(data__swigopts):
+                    if not isinstance(data__swigopts_item, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".swig-opts[{data__swigopts_x}]".format(**locals()) + " must be string", value=data__swigopts_item, name="" + (name_prefix or "data") + ".swig-opts[{data__swigopts_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+        if "depends" in data_keys:
+            data_keys.remove("depends")
+            data__depends = data["depends"]
+            if not isinstance(data__depends, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".depends must be array", value=data__depends, name="" + (name_prefix or "data") + ".depends", definition={'type': 'array', 'items': {'type': 'string'}}, rule='type')
+            data__depends_is_list = isinstance(data__depends, (list, tuple))
+            if data__depends_is_list:
+                data__depends_len = len(data__depends)
+                for data__depends_x, data__depends_item in enumerate(data__depends):
+                    if not isinstance(data__depends_item, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".depends[{data__depends_x}]".format(**locals()) + " must be string", value=data__depends_item, name="" + (name_prefix or "data") + ".depends[{data__depends_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+        if "language" in data_keys:
+            data_keys.remove("language")
+            data__language = data["language"]
+            if not isinstance(data__language, (str)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".language must be string", value=data__language, name="" + (name_prefix or "data") + ".language", definition={'type': 'string'}, rule='type')
+        if "optional" in data_keys:
+            data_keys.remove("optional")
+            data__optional = data["optional"]
+            if not isinstance(data__optional, (bool)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".optional must be boolean", value=data__optional, name="" + (name_prefix or "data") + ".optional", definition={'type': 'boolean'}, rule='type')
+        if "py-limited-api" in data_keys:
+            data_keys.remove("py-limited-api")
+            data__pylimitedapi = data["py-limited-api"]
+            if not isinstance(data__pylimitedapi, (bool)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".py-limited-api must be boolean", value=data__pylimitedapi, name="" + (name_prefix or "data") + ".py-limited-api", definition={'type': 'boolean'}, rule='type')
+        if data_keys:
+            raise JsonSchemaValueException("" + (name_prefix or "data") + " must not contain "+str(data_keys)+" properties", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/ext-module', 'title': 'Extension module', 'description': 'Parameters to construct a :class:`setuptools.Extension` object', 'type': 'object', 'required': ['name', 'sources'], 'additionalProperties': False, 'properties': {'name': {'type': 'string', 'format': 'python-module-name-relaxed'}, 'sources': {'type': 'array', 'items': {'type': 'string'}}, 'include-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'define-macros': {'type': 'array', 'items': {'type': 'array', 'items': [{'description': 'macro name', 'type': 'string'}, {'description': 'macro value', 'oneOf': [{'type': 'string'}, {'type': 'null'}]}], 'additionalItems': False}}, 'undef-macros': {'type': 'array', 'items': {'type': 'string'}}, 'library-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'libraries': {'type': 'array', 'items': {'type': 'string'}}, 'runtime-library-dirs': {'type': 'array', 'items': {'type': 'string'}}, 'extra-objects': {'type': 'array', 'items': {'type': 'string'}}, 'extra-compile-args': {'type': 'array', 'items': {'type': 'string'}}, 'extra-link-args': {'type': 'array', 'items': {'type': 'string'}}, 'export-symbols': {'type': 'array', 'items': {'type': 'string'}}, 'swig-opts': {'type': 'array', 'items': {'type': 'string'}}, 'depends': {'type': 'array', 'items': {'type': 'string'}}, 'language': {'type': 'string'}, 'optional': {'type': 'boolean'}, 'py-limited-api': {'type': 'boolean'}}}, rule='additionalProperties')
+    return data
+
+def validate_https___setuptools_pypa_io_en_latest_userguide_pyproject_config_html__definitions_find_directive(data, custom_formats={}, name_prefix=None):
+    if not isinstance(data, (dict)):
+        raise JsonSchemaValueException("" + (name_prefix or "data") + " must be object", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/find-directive', 'title': "'find:' directive", 'type': 'object', 'additionalProperties': False, 'properties': {'find': {'type': 'object', '$$description': ['Dynamic `package discovery', '`_.'], 'additionalProperties': False, 'properties': {'where': {'description': 'Directories to be searched for packages (Unix-style relative path)', 'type': 'array', 'items': {'type': 'string'}}, 'exclude': {'type': 'array', '$$description': ['Exclude packages that match the values listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'include': {'type': 'array', '$$description': ['Restrict the found packages to just the ones listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'namespaces': {'type': 'boolean', '$$description': ['When ``True``, directories without a ``__init__.py`` file will also', 'be scanned for :pep:`420`-style implicit namespaces']}}}}}, rule='type')
+    data_is_dict = isinstance(data, dict)
+    if data_is_dict:
+        data_keys = set(data.keys())
+        if "find" in data_keys:
+            data_keys.remove("find")
+            data__find = data["find"]
+            if not isinstance(data__find, (dict)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".find must be object", value=data__find, name="" + (name_prefix or "data") + ".find", definition={'type': 'object', '$$description': ['Dynamic `package discovery', '`_.'], 'additionalProperties': False, 'properties': {'where': {'description': 'Directories to be searched for packages (Unix-style relative path)', 'type': 'array', 'items': {'type': 'string'}}, 'exclude': {'type': 'array', '$$description': ['Exclude packages that match the values listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'include': {'type': 'array', '$$description': ['Restrict the found packages to just the ones listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'namespaces': {'type': 'boolean', '$$description': ['When ``True``, directories without a ``__init__.py`` file will also', 'be scanned for :pep:`420`-style implicit namespaces']}}}, rule='type')
+            data__find_is_dict = isinstance(data__find, dict)
+            if data__find_is_dict:
+                data__find_keys = set(data__find.keys())
+                if "where" in data__find_keys:
+                    data__find_keys.remove("where")
+                    data__find__where = data__find["where"]
+                    if not isinstance(data__find__where, (list, tuple)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".find.where must be array", value=data__find__where, name="" + (name_prefix or "data") + ".find.where", definition={'description': 'Directories to be searched for packages (Unix-style relative path)', 'type': 'array', 'items': {'type': 'string'}}, rule='type')
+                    data__find__where_is_list = isinstance(data__find__where, (list, tuple))
+                    if data__find__where_is_list:
+                        data__find__where_len = len(data__find__where)
+                        for data__find__where_x, data__find__where_item in enumerate(data__find__where):
+                            if not isinstance(data__find__where_item, (str)):
+                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".find.where[{data__find__where_x}]".format(**locals()) + " must be string", value=data__find__where_item, name="" + (name_prefix or "data") + ".find.where[{data__find__where_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+                if "exclude" in data__find_keys:
+                    data__find_keys.remove("exclude")
+                    data__find__exclude = data__find["exclude"]
+                    if not isinstance(data__find__exclude, (list, tuple)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".find.exclude must be array", value=data__find__exclude, name="" + (name_prefix or "data") + ".find.exclude", definition={'type': 'array', '$$description': ['Exclude packages that match the values listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, rule='type')
+                    data__find__exclude_is_list = isinstance(data__find__exclude, (list, tuple))
+                    if data__find__exclude_is_list:
+                        data__find__exclude_len = len(data__find__exclude)
+                        for data__find__exclude_x, data__find__exclude_item in enumerate(data__find__exclude):
+                            if not isinstance(data__find__exclude_item, (str)):
+                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".find.exclude[{data__find__exclude_x}]".format(**locals()) + " must be string", value=data__find__exclude_item, name="" + (name_prefix or "data") + ".find.exclude[{data__find__exclude_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+                if "include" in data__find_keys:
+                    data__find_keys.remove("include")
+                    data__find__include = data__find["include"]
+                    if not isinstance(data__find__include, (list, tuple)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".find.include must be array", value=data__find__include, name="" + (name_prefix or "data") + ".find.include", definition={'type': 'array', '$$description': ['Restrict the found packages to just the ones listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, rule='type')
+                    data__find__include_is_list = isinstance(data__find__include, (list, tuple))
+                    if data__find__include_is_list:
+                        data__find__include_len = len(data__find__include)
+                        for data__find__include_x, data__find__include_item in enumerate(data__find__include):
+                            if not isinstance(data__find__include_item, (str)):
+                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".find.include[{data__find__include_x}]".format(**locals()) + " must be string", value=data__find__include_item, name="" + (name_prefix or "data") + ".find.include[{data__find__include_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+                if "namespaces" in data__find_keys:
+                    data__find_keys.remove("namespaces")
+                    data__find__namespaces = data__find["namespaces"]
+                    if not isinstance(data__find__namespaces, (bool)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".find.namespaces must be boolean", value=data__find__namespaces, name="" + (name_prefix or "data") + ".find.namespaces", definition={'type': 'boolean', '$$description': ['When ``True``, directories without a ``__init__.py`` file will also', 'be scanned for :pep:`420`-style implicit namespaces']}, rule='type')
+                if data__find_keys:
+                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".find must not contain "+str(data__find_keys)+" properties", value=data__find, name="" + (name_prefix or "data") + ".find", definition={'type': 'object', '$$description': ['Dynamic `package discovery', '`_.'], 'additionalProperties': False, 'properties': {'where': {'description': 'Directories to be searched for packages (Unix-style relative path)', 'type': 'array', 'items': {'type': 'string'}}, 'exclude': {'type': 'array', '$$description': ['Exclude packages that match the values listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'include': {'type': 'array', '$$description': ['Restrict the found packages to just the ones listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'namespaces': {'type': 'boolean', '$$description': ['When ``True``, directories without a ``__init__.py`` file will also', 'be scanned for :pep:`420`-style implicit namespaces']}}}, rule='additionalProperties')
+        if data_keys:
+            raise JsonSchemaValueException("" + (name_prefix or "data") + " must not contain "+str(data_keys)+" properties", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/find-directive', 'title': "'find:' directive", 'type': 'object', 'additionalProperties': False, 'properties': {'find': {'type': 'object', '$$description': ['Dynamic `package discovery', '`_.'], 'additionalProperties': False, 'properties': {'where': {'description': 'Directories to be searched for packages (Unix-style relative path)', 'type': 'array', 'items': {'type': 'string'}}, 'exclude': {'type': 'array', '$$description': ['Exclude packages that match the values listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'include': {'type': 'array', '$$description': ['Restrict the found packages to just the ones listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'namespaces': {'type': 'boolean', '$$description': ['When ``True``, directories without a ``__init__.py`` file will also', 'be scanned for :pep:`420`-style implicit namespaces']}}}}}, rule='additionalProperties')
+    return data
+
+def validate_https___setuptools_pypa_io_en_latest_userguide_pyproject_config_html__definitions_package_name(data, custom_formats={}, name_prefix=None):
+    if not isinstance(data, (str)):
+        raise JsonSchemaValueException("" + (name_prefix or "data") + " must be string", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}, rule='type')
+    data_any_of_count11 = 0
+    if not data_any_of_count11:
+        try:
+            if not isinstance(data, (str)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + " must be string", value=data, name="" + (name_prefix or "data") + "", definition={'type': 'string', 'format': 'python-module-name-relaxed'}, rule='type')
+            if isinstance(data, str):
+                if not custom_formats["python-module-name-relaxed"](data):
+                    raise JsonSchemaValueException("" + (name_prefix or "data") + " must be python-module-name-relaxed", value=data, name="" + (name_prefix or "data") + "", definition={'type': 'string', 'format': 'python-module-name-relaxed'}, rule='format')
+            data_any_of_count11 += 1
+        except JsonSchemaValueException: pass
+    if not data_any_of_count11:
+        try:
+            if not isinstance(data, (str)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + " must be string", value=data, name="" + (name_prefix or "data") + "", definition={'type': 'string', 'format': 'pep561-stub-name'}, rule='type')
+            if isinstance(data, str):
+                if not custom_formats["pep561-stub-name"](data):
+                    raise JsonSchemaValueException("" + (name_prefix or "data") + " must be pep561-stub-name", value=data, name="" + (name_prefix or "data") + "", definition={'type': 'string', 'format': 'pep561-stub-name'}, rule='format')
+            data_any_of_count11 += 1
+        except JsonSchemaValueException: pass
+    if not data_any_of_count11:
+        raise JsonSchemaValueException("" + (name_prefix or "data") + " cannot be validated by any definition", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or :pep:`561`).', 'type': 'string', 'anyOf': [{'type': 'string', 'format': 'python-module-name-relaxed'}, {'type': 'string', 'format': 'pep561-stub-name'}]}, rule='anyOf')
+    return data
+
+def validate_https___setuptools_pypa_io_en_latest_deprecated_distutils_configfile_html(data, custom_formats={}, name_prefix=None):
+    if not isinstance(data, (dict)):
+        raise JsonSchemaValueException("" + (name_prefix or "data") + " must be object", value=data, name="" + (name_prefix or "data") + "", definition={'$schema': 'http://json-schema.org/draft-07/schema#', '$id': 'https://setuptools.pypa.io/en/latest/deprecated/distutils/configfile.html', 'title': '``tool.distutils`` table', '$$description': ['**EXPERIMENTAL** (NOT OFFICIALLY SUPPORTED): Use ``tool.distutils``', 'subtables to configure arguments for ``distutils`` commands.', 'Originally, ``distutils`` allowed developers to configure arguments for', '``setup.py`` commands via `distutils configuration files', '`_.', 'See also `the old Python docs _`.'], 'type': 'object', 'properties': {'global': {'type': 'object', 'description': 'Global options applied to all ``distutils`` commands'}}, 'patternProperties': {'.+': {'type': 'object'}}, '$comment': 'TODO: Is there a practical way of making this schema more specific?'}, rule='type')
+    data_is_dict = isinstance(data, dict)
+    if data_is_dict:
+        data_keys = set(data.keys())
+        if "global" in data_keys:
+            data_keys.remove("global")
+            data__global = data["global"]
+            if not isinstance(data__global, (dict)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".global must be object", value=data__global, name="" + (name_prefix or "data") + ".global", definition={'type': 'object', 'description': 'Global options applied to all ``distutils`` commands'}, rule='type')
+        for data_key, data_val in data.items():
+            if REGEX_PATTERNS['.+'].search(data_key):
+                if data_key in data_keys:
+                    data_keys.remove(data_key)
+                if not isinstance(data_val, (dict)):
+                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".{data_key}".format(**locals()) + " must be object", value=data_val, name="" + (name_prefix or "data") + ".{data_key}".format(**locals()) + "", definition={'type': 'object'}, rule='type')
+    return data
+
+def validate_https___packaging_python_org_en_latest_specifications_pyproject_toml(data, custom_formats={}, name_prefix=None):
+    if not isinstance(data, (dict)):
+        raise JsonSchemaValueException("" + (name_prefix or "data") + " must be object", value=data, name="" + (name_prefix or "data") + "", definition={'$schema': 'http://json-schema.org/draft-07/schema#', '$id': 'https://packaging.python.org/en/latest/specifications/pyproject-toml/', 'title': 'Package metadata stored in the ``project`` table', '$$description': ['Data structure for the **project** table inside ``pyproject.toml``', '(as initially defined in :pep:`621`)'], 'type': 'object', 'properties': {'name': {'type': 'string', 'description': 'The name (primary identifier) of the project. MUST be statically defined.', 'format': 'pep508-identifier'}, 'version': {'type': 'string', 'description': 'The version of the project as supported by :pep:`440`.', 'format': 'pep440'}, 'description': {'type': 'string', '$$description': ['The `summary description of the project', '`_']}, 'readme': {'$$description': ['`Full/detailed description of the project in the form of a README', '`_', "with meaning similar to the one defined in `core metadata's Description", '`_'], 'oneOf': [{'type': 'string', '$$description': ['Relative path to a text file (UTF-8) containing the full description', 'of the project. If the file path ends in case-insensitive ``.md`` or', '``.rst`` suffixes, then the content-type is respectively', '``text/markdown`` or ``text/x-rst``']}, {'type': 'object', 'allOf': [{'anyOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to a text file containing the full description', 'of the project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', 'description': 'Full text describing the project.'}}, 'required': ['text']}]}, {'properties': {'content-type': {'type': 'string', '$$description': ['Content-type (:rfc:`1341`) of the full description', '(e.g. ``text/markdown``). The ``charset`` parameter is assumed', 'UTF-8 when not present.'], '$comment': 'TODO: add regex pattern or format?'}}, 'required': ['content-type']}]}]}, 'requires-python': {'type': 'string', 'format': 'pep508-versionspec', '$$description': ['`The Python version requirements of the project', '`_.']}, 'license': {'description': '`Project license `_.', 'oneOf': [{'type': 'string', 'description': 'An SPDX license identifier', 'format': 'SPDX'}, {'type': 'object', 'properties': {'file': {'type': 'string', '$$description': ['Relative path to the file (UTF-8) which contains the license for the', 'project.']}}, 'required': ['file']}, {'type': 'object', 'properties': {'text': {'type': 'string', '$$description': ['The license of the project whose meaning is that of the', '`License field from the core metadata', '`_.']}}, 'required': ['text']}]}, 'license-files': {'description': 'Paths or globs to paths of license files', 'type': 'array', 'items': {'type': 'string'}}, 'authors': {'type': 'array', 'items': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}, 'anyOf': [{'required': ['name']}, {'required': ['email']}]}, '$$description': ["The people or organizations considered to be the 'authors' of the project.", 'The exact meaning is open to interpretation (e.g. original or primary authors,', 'current maintainers, or owners of the package).']}, 'maintainers': {'type': 'array', 'items': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}, 'anyOf': [{'required': ['name']}, {'required': ['email']}]}, '$$description': ["The people or organizations considered to be the 'maintainers' of the project.", 'Similarly to ``authors``, the exact meaning is open to interpretation.']}, 'keywords': {'type': 'array', 'items': {'type': 'string'}, 'description': 'List of keywords to assist searching for the distribution in a larger catalog.'}, 'classifiers': {'type': 'array', 'items': {'type': 'string', 'format': 'trove-classifier', 'description': '`PyPI classifier `_.'}, '$$description': ['`Trove classifiers `_', 'which apply to the project.']}, 'urls': {'type': 'object', 'description': 'URLs associated with the project in the form ``label => value``.', 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', 'format': 'url'}}}, 'scripts': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, 'gui-scripts': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, 'entry-points': {'$$description': ['Instruct the installer to expose the given modules/functions via', '``entry-point`` discovery mechanism (useful for plugins).', 'More information available in the `Python packaging guide', '`_.'], 'propertyNames': {'format': 'python-entrypoint-group'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}}}, 'dependencies': {'type': 'array', 'description': 'Project (mandatory) dependencies.', 'items': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}, 'optional-dependencies': {'type': 'object', 'description': 'Optional dependency for the project', 'propertyNames': {'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'array', 'items': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}}}, 'import-names': {'description': 'Lists import names which a project, when installed, would exclusively provide.', 'type': 'array', 'items': {'type': 'string', 'format': 'import-name'}}, 'import-namespaces': {'description': 'Lists import names that, when installed, would be provided by the project, but not exclusively.', 'type': 'array', 'items': {'type': 'string', 'format': 'import-name'}}, 'dynamic': {'type': 'array', '$$description': ['Specifies which fields are intentionally unspecified and expected to be', 'dynamically provided by build tools'], 'items': {'enum': ['version', 'description', 'readme', 'requires-python', 'license', 'license-files', 'authors', 'maintainers', 'keywords', 'classifiers', 'urls', 'scripts', 'gui-scripts', 'entry-points', 'dependencies', 'optional-dependencies', 'import-names', 'import-namespaces']}}}, 'required': ['name'], 'additionalProperties': False, 'allOf': [{'if': {'not': {'required': ['dynamic'], 'properties': {'dynamic': {'contains': {'const': 'version'}, '$$description': ['version is listed in ``dynamic``']}}}, '$$comment': ['According to :pep:`621`:', '    If the core metadata specification lists a field as "Required", then', '    the metadata MUST specify the field statically or list it in dynamic', 'In turn, `core metadata`_ defines:', '    The required fields are: Metadata-Version, Name, Version.', '    All the other fields are optional.', 'Since ``Metadata-Version`` is defined by the build back-end, ``name`` and', '``version`` are the only mandatory information in ``pyproject.toml``.', '.. _core metadata: https://packaging.python.org/specifications/core-metadata/']}, 'then': {'required': ['version'], '$$description': ['version should be statically defined in the ``version`` field']}}, {'if': {'required': ['license-files']}, 'then': {'properties': {'license': {'type': 'string'}}}}], 'definitions': {'author': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}, 'anyOf': [{'required': ['name']}, {'required': ['email']}]}, 'entry-point-group': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, 'dependency': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}}, rule='type')
+    try:
+        try:
+            data_is_dict = isinstance(data, dict)
+            if data_is_dict:
+                data__missing_keys = set(['dynamic']) - data.keys()
+                if data__missing_keys:
+                    raise JsonSchemaValueException("" + (name_prefix or "data") + " must contain " + (str(sorted(data__missing_keys)) + " properties"), value=data, name="" + (name_prefix or "data") + "", definition={'required': ['dynamic'], 'properties': {'dynamic': {'contains': {'const': 'version'}, '$$description': ['version is listed in ``dynamic``']}}}, rule='required')
+                data_keys = set(data.keys())
+                if "dynamic" in data_keys:
+                    data_keys.remove("dynamic")
+                    data__dynamic = data["dynamic"]
+                    data__dynamic_is_list = isinstance(data__dynamic, (list, tuple))
+                    if data__dynamic_is_list:
+                        data__dynamic_contains = False
+                        for data__dynamic_key in data__dynamic:
+                            try:
+                                if data__dynamic_key != "version":
+                                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic must be same as const definition: version", value=data__dynamic_key, name="" + (name_prefix or "data") + ".dynamic", definition={'const': 'version'}, rule='const')
+                                data__dynamic_contains = True
+                                break
+                            except JsonSchemaValueException: pass
+                        if not data__dynamic_contains:
+                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic must contain one of contains definition", value=data__dynamic, name="" + (name_prefix or "data") + ".dynamic", definition={'contains': {'const': 'version'}, '$$description': ['version is listed in ``dynamic``']}, rule='contains')
+        except JsonSchemaValueException: pass
+        else:
+            raise JsonSchemaValueException("" + (name_prefix or "data") + " must NOT match a disallowed definition", value=data, name="" + (name_prefix or "data") + "", definition={'not': {'required': ['dynamic'], 'properties': {'dynamic': {'contains': {'const': 'version'}, '$$description': ['version is listed in ``dynamic``']}}}, '$$comment': ['According to :pep:`621`:', '    If the core metadata specification lists a field as "Required", then', '    the metadata MUST specify the field statically or list it in dynamic', 'In turn, `core metadata`_ defines:', '    The required fields are: Metadata-Version, Name, Version.', '    All the other fields are optional.', 'Since ``Metadata-Version`` is defined by the build back-end, ``name`` and', '``version`` are the only mandatory information in ``pyproject.toml``.', '.. _core metadata: https://packaging.python.org/specifications/core-metadata/']}, rule='not')
+    except JsonSchemaValueException:
+        pass
+    else:
+        data_is_dict = isinstance(data, dict)
+        if data_is_dict:
+            data__missing_keys = set(['version']) - data.keys()
+            if data__missing_keys:
+                raise JsonSchemaValueException("" + (name_prefix or "data") + " must contain " + (str(sorted(data__missing_keys)) + " properties"), value=data, name="" + (name_prefix or "data") + "", definition={'required': ['version'], '$$description': ['version should be statically defined in the ``version`` field']}, rule='required')
+    try:
+        data_is_dict = isinstance(data, dict)
+        if data_is_dict:
+            data__missing_keys = set(['license-files']) - data.keys()
+            if data__missing_keys:
+                raise JsonSchemaValueException("" + (name_prefix or "data") + " must contain " + (str(sorted(data__missing_keys)) + " properties"), value=data, name="" + (name_prefix or "data") + "", definition={'required': ['license-files']}, rule='required')
+    except JsonSchemaValueException:
+        pass
+    else:
+        data_is_dict = isinstance(data, dict)
+        if data_is_dict:
+            data_keys = set(data.keys())
+            if "license" in data_keys:
+                data_keys.remove("license")
+                data__license = data["license"]
+                if not isinstance(data__license, (str)):
+                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".license must be string", value=data__license, name="" + (name_prefix or "data") + ".license", definition={'type': 'string'}, rule='type')
+    data_is_dict = isinstance(data, dict)
+    if data_is_dict:
+        data__missing_keys = set(['name']) - data.keys()
+        if data__missing_keys:
+            raise JsonSchemaValueException("" + (name_prefix or "data") + " must contain " + (str(sorted(data__missing_keys)) + " properties"), value=data, name="" + (name_prefix or "data") + "", definition={'$schema': 'http://json-schema.org/draft-07/schema#', '$id': 'https://packaging.python.org/en/latest/specifications/pyproject-toml/', 'title': 'Package metadata stored in the ``project`` table', '$$description': ['Data structure for the **project** table inside ``pyproject.toml``', '(as initially defined in :pep:`621`)'], 'type': 'object', 'properties': {'name': {'type': 'string', 'description': 'The name (primary identifier) of the project. MUST be statically defined.', 'format': 'pep508-identifier'}, 'version': {'type': 'string', 'description': 'The version of the project as supported by :pep:`440`.', 'format': 'pep440'}, 'description': {'type': 'string', '$$description': ['The `summary description of the project', '`_']}, 'readme': {'$$description': ['`Full/detailed description of the project in the form of a README', '`_', "with meaning similar to the one defined in `core metadata's Description", '`_'], 'oneOf': [{'type': 'string', '$$description': ['Relative path to a text file (UTF-8) containing the full description', 'of the project. If the file path ends in case-insensitive ``.md`` or', '``.rst`` suffixes, then the content-type is respectively', '``text/markdown`` or ``text/x-rst``']}, {'type': 'object', 'allOf': [{'anyOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to a text file containing the full description', 'of the project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', 'description': 'Full text describing the project.'}}, 'required': ['text']}]}, {'properties': {'content-type': {'type': 'string', '$$description': ['Content-type (:rfc:`1341`) of the full description', '(e.g. ``text/markdown``). The ``charset`` parameter is assumed', 'UTF-8 when not present.'], '$comment': 'TODO: add regex pattern or format?'}}, 'required': ['content-type']}]}]}, 'requires-python': {'type': 'string', 'format': 'pep508-versionspec', '$$description': ['`The Python version requirements of the project', '`_.']}, 'license': {'description': '`Project license `_.', 'oneOf': [{'type': 'string', 'description': 'An SPDX license identifier', 'format': 'SPDX'}, {'type': 'object', 'properties': {'file': {'type': 'string', '$$description': ['Relative path to the file (UTF-8) which contains the license for the', 'project.']}}, 'required': ['file']}, {'type': 'object', 'properties': {'text': {'type': 'string', '$$description': ['The license of the project whose meaning is that of the', '`License field from the core metadata', '`_.']}}, 'required': ['text']}]}, 'license-files': {'description': 'Paths or globs to paths of license files', 'type': 'array', 'items': {'type': 'string'}}, 'authors': {'type': 'array', 'items': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}, 'anyOf': [{'required': ['name']}, {'required': ['email']}]}, '$$description': ["The people or organizations considered to be the 'authors' of the project.", 'The exact meaning is open to interpretation (e.g. original or primary authors,', 'current maintainers, or owners of the package).']}, 'maintainers': {'type': 'array', 'items': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}, 'anyOf': [{'required': ['name']}, {'required': ['email']}]}, '$$description': ["The people or organizations considered to be the 'maintainers' of the project.", 'Similarly to ``authors``, the exact meaning is open to interpretation.']}, 'keywords': {'type': 'array', 'items': {'type': 'string'}, 'description': 'List of keywords to assist searching for the distribution in a larger catalog.'}, 'classifiers': {'type': 'array', 'items': {'type': 'string', 'format': 'trove-classifier', 'description': '`PyPI classifier `_.'}, '$$description': ['`Trove classifiers `_', 'which apply to the project.']}, 'urls': {'type': 'object', 'description': 'URLs associated with the project in the form ``label => value``.', 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', 'format': 'url'}}}, 'scripts': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, 'gui-scripts': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, 'entry-points': {'$$description': ['Instruct the installer to expose the given modules/functions via', '``entry-point`` discovery mechanism (useful for plugins).', 'More information available in the `Python packaging guide', '`_.'], 'propertyNames': {'format': 'python-entrypoint-group'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}}}, 'dependencies': {'type': 'array', 'description': 'Project (mandatory) dependencies.', 'items': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}, 'optional-dependencies': {'type': 'object', 'description': 'Optional dependency for the project', 'propertyNames': {'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'array', 'items': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}}}, 'import-names': {'description': 'Lists import names which a project, when installed, would exclusively provide.', 'type': 'array', 'items': {'type': 'string', 'format': 'import-name'}}, 'import-namespaces': {'description': 'Lists import names that, when installed, would be provided by the project, but not exclusively.', 'type': 'array', 'items': {'type': 'string', 'format': 'import-name'}}, 'dynamic': {'type': 'array', '$$description': ['Specifies which fields are intentionally unspecified and expected to be', 'dynamically provided by build tools'], 'items': {'enum': ['version', 'description', 'readme', 'requires-python', 'license', 'license-files', 'authors', 'maintainers', 'keywords', 'classifiers', 'urls', 'scripts', 'gui-scripts', 'entry-points', 'dependencies', 'optional-dependencies', 'import-names', 'import-namespaces']}}}, 'required': ['name'], 'additionalProperties': False, 'allOf': [{'if': {'not': {'required': ['dynamic'], 'properties': {'dynamic': {'contains': {'const': 'version'}, '$$description': ['version is listed in ``dynamic``']}}}, '$$comment': ['According to :pep:`621`:', '    If the core metadata specification lists a field as "Required", then', '    the metadata MUST specify the field statically or list it in dynamic', 'In turn, `core metadata`_ defines:', '    The required fields are: Metadata-Version, Name, Version.', '    All the other fields are optional.', 'Since ``Metadata-Version`` is defined by the build back-end, ``name`` and', '``version`` are the only mandatory information in ``pyproject.toml``.', '.. _core metadata: https://packaging.python.org/specifications/core-metadata/']}, 'then': {'required': ['version'], '$$description': ['version should be statically defined in the ``version`` field']}}, {'if': {'required': ['license-files']}, 'then': {'properties': {'license': {'type': 'string'}}}}], 'definitions': {'author': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}, 'anyOf': [{'required': ['name']}, {'required': ['email']}]}, 'entry-point-group': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, 'dependency': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}}, rule='required')
+        data_keys = set(data.keys())
+        if "name" in data_keys:
+            data_keys.remove("name")
+            data__name = data["name"]
+            if not isinstance(data__name, (str)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".name must be string", value=data__name, name="" + (name_prefix or "data") + ".name", definition={'type': 'string', 'description': 'The name (primary identifier) of the project. MUST be statically defined.', 'format': 'pep508-identifier'}, rule='type')
+            if isinstance(data__name, str):
+                if not custom_formats["pep508-identifier"](data__name):
+                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".name must be pep508-identifier", value=data__name, name="" + (name_prefix or "data") + ".name", definition={'type': 'string', 'description': 'The name (primary identifier) of the project. MUST be statically defined.', 'format': 'pep508-identifier'}, rule='format')
+        if "version" in data_keys:
+            data_keys.remove("version")
+            data__version = data["version"]
+            if not isinstance(data__version, (str)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".version must be string", value=data__version, name="" + (name_prefix or "data") + ".version", definition={'type': 'string', 'description': 'The version of the project as supported by :pep:`440`.', 'format': 'pep440'}, rule='type')
+            if isinstance(data__version, str):
+                if not custom_formats["pep440"](data__version):
+                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".version must be pep440", value=data__version, name="" + (name_prefix or "data") + ".version", definition={'type': 'string', 'description': 'The version of the project as supported by :pep:`440`.', 'format': 'pep440'}, rule='format')
+        if "description" in data_keys:
+            data_keys.remove("description")
+            data__description = data["description"]
+            if not isinstance(data__description, (str)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".description must be string", value=data__description, name="" + (name_prefix or "data") + ".description", definition={'type': 'string', '$$description': ['The `summary description of the project', '`_']}, rule='type')
+        if "readme" in data_keys:
+            data_keys.remove("readme")
+            data__readme = data["readme"]
+            data__readme_one_of_count12 = 0
+            if data__readme_one_of_count12 < 2:
+                try:
+                    if not isinstance(data__readme, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".readme must be string", value=data__readme, name="" + (name_prefix or "data") + ".readme", definition={'type': 'string', '$$description': ['Relative path to a text file (UTF-8) containing the full description', 'of the project. If the file path ends in case-insensitive ``.md`` or', '``.rst`` suffixes, then the content-type is respectively', '``text/markdown`` or ``text/x-rst``']}, rule='type')
+                    data__readme_one_of_count12 += 1
+                except JsonSchemaValueException: pass
+            if data__readme_one_of_count12 < 2:
+                try:
+                    if not isinstance(data__readme, (dict)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".readme must be object", value=data__readme, name="" + (name_prefix or "data") + ".readme", definition={'type': 'object', 'allOf': [{'anyOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to a text file containing the full description', 'of the project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', 'description': 'Full text describing the project.'}}, 'required': ['text']}]}, {'properties': {'content-type': {'type': 'string', '$$description': ['Content-type (:rfc:`1341`) of the full description', '(e.g. ``text/markdown``). The ``charset`` parameter is assumed', 'UTF-8 when not present.'], '$comment': 'TODO: add regex pattern or format?'}}, 'required': ['content-type']}]}, rule='type')
+                    data__readme_any_of_count13 = 0
+                    if not data__readme_any_of_count13:
+                        try:
+                            data__readme_is_dict = isinstance(data__readme, dict)
+                            if data__readme_is_dict:
+                                data__readme__missing_keys = set(['file']) - data__readme.keys()
+                                if data__readme__missing_keys:
+                                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".readme must contain " + (str(sorted(data__readme__missing_keys)) + " properties"), value=data__readme, name="" + (name_prefix or "data") + ".readme", definition={'properties': {'file': {'type': 'string', '$$description': ['Relative path to a text file containing the full description', 'of the project.']}}, 'required': ['file']}, rule='required')
+                                data__readme_keys = set(data__readme.keys())
+                                if "file" in data__readme_keys:
+                                    data__readme_keys.remove("file")
+                                    data__readme__file = data__readme["file"]
+                                    if not isinstance(data__readme__file, (str)):
+                                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".readme.file must be string", value=data__readme__file, name="" + (name_prefix or "data") + ".readme.file", definition={'type': 'string', '$$description': ['Relative path to a text file containing the full description', 'of the project.']}, rule='type')
+                            data__readme_any_of_count13 += 1
+                        except JsonSchemaValueException: pass
+                    if not data__readme_any_of_count13:
+                        try:
+                            data__readme_is_dict = isinstance(data__readme, dict)
+                            if data__readme_is_dict:
+                                data__readme__missing_keys = set(['text']) - data__readme.keys()
+                                if data__readme__missing_keys:
+                                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".readme must contain " + (str(sorted(data__readme__missing_keys)) + " properties"), value=data__readme, name="" + (name_prefix or "data") + ".readme", definition={'properties': {'text': {'type': 'string', 'description': 'Full text describing the project.'}}, 'required': ['text']}, rule='required')
+                                data__readme_keys = set(data__readme.keys())
+                                if "text" in data__readme_keys:
+                                    data__readme_keys.remove("text")
+                                    data__readme__text = data__readme["text"]
+                                    if not isinstance(data__readme__text, (str)):
+                                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".readme.text must be string", value=data__readme__text, name="" + (name_prefix or "data") + ".readme.text", definition={'type': 'string', 'description': 'Full text describing the project.'}, rule='type')
+                            data__readme_any_of_count13 += 1
+                        except JsonSchemaValueException: pass
+                    if not data__readme_any_of_count13:
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".readme cannot be validated by any definition", value=data__readme, name="" + (name_prefix or "data") + ".readme", definition={'anyOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to a text file containing the full description', 'of the project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', 'description': 'Full text describing the project.'}}, 'required': ['text']}]}, rule='anyOf')
+                    data__readme_is_dict = isinstance(data__readme, dict)
+                    if data__readme_is_dict:
+                        data__readme__missing_keys = set(['content-type']) - data__readme.keys()
+                        if data__readme__missing_keys:
+                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".readme must contain " + (str(sorted(data__readme__missing_keys)) + " properties"), value=data__readme, name="" + (name_prefix or "data") + ".readme", definition={'properties': {'content-type': {'type': 'string', '$$description': ['Content-type (:rfc:`1341`) of the full description', '(e.g. ``text/markdown``). The ``charset`` parameter is assumed', 'UTF-8 when not present.'], '$comment': 'TODO: add regex pattern or format?'}}, 'required': ['content-type']}, rule='required')
+                        data__readme_keys = set(data__readme.keys())
+                        if "content-type" in data__readme_keys:
+                            data__readme_keys.remove("content-type")
+                            data__readme__contenttype = data__readme["content-type"]
+                            if not isinstance(data__readme__contenttype, (str)):
+                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".readme.content-type must be string", value=data__readme__contenttype, name="" + (name_prefix or "data") + ".readme.content-type", definition={'type': 'string', '$$description': ['Content-type (:rfc:`1341`) of the full description', '(e.g. ``text/markdown``). The ``charset`` parameter is assumed', 'UTF-8 when not present.'], '$comment': 'TODO: add regex pattern or format?'}, rule='type')
+                    data__readme_one_of_count12 += 1
+                except JsonSchemaValueException: pass
+            if data__readme_one_of_count12 != 1:
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".readme must be valid exactly by one definition" + (" (" + str(data__readme_one_of_count12) + " matches found)"), value=data__readme, name="" + (name_prefix or "data") + ".readme", definition={'$$description': ['`Full/detailed description of the project in the form of a README', '`_', "with meaning similar to the one defined in `core metadata's Description", '`_'], 'oneOf': [{'type': 'string', '$$description': ['Relative path to a text file (UTF-8) containing the full description', 'of the project. If the file path ends in case-insensitive ``.md`` or', '``.rst`` suffixes, then the content-type is respectively', '``text/markdown`` or ``text/x-rst``']}, {'type': 'object', 'allOf': [{'anyOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to a text file containing the full description', 'of the project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', 'description': 'Full text describing the project.'}}, 'required': ['text']}]}, {'properties': {'content-type': {'type': 'string', '$$description': ['Content-type (:rfc:`1341`) of the full description', '(e.g. ``text/markdown``). The ``charset`` parameter is assumed', 'UTF-8 when not present.'], '$comment': 'TODO: add regex pattern or format?'}}, 'required': ['content-type']}]}]}, rule='oneOf')
+        if "requires-python" in data_keys:
+            data_keys.remove("requires-python")
+            data__requirespython = data["requires-python"]
+            if not isinstance(data__requirespython, (str)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".requires-python must be string", value=data__requirespython, name="" + (name_prefix or "data") + ".requires-python", definition={'type': 'string', 'format': 'pep508-versionspec', '$$description': ['`The Python version requirements of the project', '`_.']}, rule='type')
+            if isinstance(data__requirespython, str):
+                if not custom_formats["pep508-versionspec"](data__requirespython):
+                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".requires-python must be pep508-versionspec", value=data__requirespython, name="" + (name_prefix or "data") + ".requires-python", definition={'type': 'string', 'format': 'pep508-versionspec', '$$description': ['`The Python version requirements of the project', '`_.']}, rule='format')
+        if "license" in data_keys:
+            data_keys.remove("license")
+            data__license = data["license"]
+            data__license_one_of_count14 = 0
+            if data__license_one_of_count14 < 2:
+                try:
+                    if not isinstance(data__license, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".license must be string", value=data__license, name="" + (name_prefix or "data") + ".license", definition={'type': 'string', 'description': 'An SPDX license identifier', 'format': 'SPDX'}, rule='type')
+                    if isinstance(data__license, str):
+                        if not custom_formats["SPDX"](data__license):
+                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".license must be SPDX", value=data__license, name="" + (name_prefix or "data") + ".license", definition={'type': 'string', 'description': 'An SPDX license identifier', 'format': 'SPDX'}, rule='format')
+                    data__license_one_of_count14 += 1
+                except JsonSchemaValueException: pass
+            if data__license_one_of_count14 < 2:
+                try:
+                    if not isinstance(data__license, (dict)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".license must be object", value=data__license, name="" + (name_prefix or "data") + ".license", definition={'type': 'object', 'properties': {'file': {'type': 'string', '$$description': ['Relative path to the file (UTF-8) which contains the license for the', 'project.']}}, 'required': ['file']}, rule='type')
+                    data__license_is_dict = isinstance(data__license, dict)
+                    if data__license_is_dict:
+                        data__license__missing_keys = set(['file']) - data__license.keys()
+                        if data__license__missing_keys:
+                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".license must contain " + (str(sorted(data__license__missing_keys)) + " properties"), value=data__license, name="" + (name_prefix or "data") + ".license", definition={'type': 'object', 'properties': {'file': {'type': 'string', '$$description': ['Relative path to the file (UTF-8) which contains the license for the', 'project.']}}, 'required': ['file']}, rule='required')
+                        data__license_keys = set(data__license.keys())
+                        if "file" in data__license_keys:
+                            data__license_keys.remove("file")
+                            data__license__file = data__license["file"]
+                            if not isinstance(data__license__file, (str)):
+                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".license.file must be string", value=data__license__file, name="" + (name_prefix or "data") + ".license.file", definition={'type': 'string', '$$description': ['Relative path to the file (UTF-8) which contains the license for the', 'project.']}, rule='type')
+                    data__license_one_of_count14 += 1
+                except JsonSchemaValueException: pass
+            if data__license_one_of_count14 < 2:
+                try:
+                    if not isinstance(data__license, (dict)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".license must be object", value=data__license, name="" + (name_prefix or "data") + ".license", definition={'type': 'object', 'properties': {'text': {'type': 'string', '$$description': ['The license of the project whose meaning is that of the', '`License field from the core metadata', '`_.']}}, 'required': ['text']}, rule='type')
+                    data__license_is_dict = isinstance(data__license, dict)
+                    if data__license_is_dict:
+                        data__license__missing_keys = set(['text']) - data__license.keys()
+                        if data__license__missing_keys:
+                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".license must contain " + (str(sorted(data__license__missing_keys)) + " properties"), value=data__license, name="" + (name_prefix or "data") + ".license", definition={'type': 'object', 'properties': {'text': {'type': 'string', '$$description': ['The license of the project whose meaning is that of the', '`License field from the core metadata', '`_.']}}, 'required': ['text']}, rule='required')
+                        data__license_keys = set(data__license.keys())
+                        if "text" in data__license_keys:
+                            data__license_keys.remove("text")
+                            data__license__text = data__license["text"]
+                            if not isinstance(data__license__text, (str)):
+                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".license.text must be string", value=data__license__text, name="" + (name_prefix or "data") + ".license.text", definition={'type': 'string', '$$description': ['The license of the project whose meaning is that of the', '`License field from the core metadata', '`_.']}, rule='type')
+                    data__license_one_of_count14 += 1
+                except JsonSchemaValueException: pass
+            if data__license_one_of_count14 != 1:
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".license must be valid exactly by one definition" + (" (" + str(data__license_one_of_count14) + " matches found)"), value=data__license, name="" + (name_prefix or "data") + ".license", definition={'description': '`Project license `_.', 'oneOf': [{'type': 'string', 'description': 'An SPDX license identifier', 'format': 'SPDX'}, {'type': 'object', 'properties': {'file': {'type': 'string', '$$description': ['Relative path to the file (UTF-8) which contains the license for the', 'project.']}}, 'required': ['file']}, {'type': 'object', 'properties': {'text': {'type': 'string', '$$description': ['The license of the project whose meaning is that of the', '`License field from the core metadata', '`_.']}}, 'required': ['text']}]}, rule='oneOf')
+        if "license-files" in data_keys:
+            data_keys.remove("license-files")
+            data__licensefiles = data["license-files"]
+            if not isinstance(data__licensefiles, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".license-files must be array", value=data__licensefiles, name="" + (name_prefix or "data") + ".license-files", definition={'description': 'Paths or globs to paths of license files', 'type': 'array', 'items': {'type': 'string'}}, rule='type')
+            data__licensefiles_is_list = isinstance(data__licensefiles, (list, tuple))
+            if data__licensefiles_is_list:
+                data__licensefiles_len = len(data__licensefiles)
+                for data__licensefiles_x, data__licensefiles_item in enumerate(data__licensefiles):
+                    if not isinstance(data__licensefiles_item, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".license-files[{data__licensefiles_x}]".format(**locals()) + " must be string", value=data__licensefiles_item, name="" + (name_prefix or "data") + ".license-files[{data__licensefiles_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+        if "authors" in data_keys:
+            data_keys.remove("authors")
+            data__authors = data["authors"]
+            if not isinstance(data__authors, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".authors must be array", value=data__authors, name="" + (name_prefix or "data") + ".authors", definition={'type': 'array', 'items': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}, 'anyOf': [{'required': ['name']}, {'required': ['email']}]}, '$$description': ["The people or organizations considered to be the 'authors' of the project.", 'The exact meaning is open to interpretation (e.g. original or primary authors,', 'current maintainers, or owners of the package).']}, rule='type')
+            data__authors_is_list = isinstance(data__authors, (list, tuple))
+            if data__authors_is_list:
+                data__authors_len = len(data__authors)
+                for data__authors_x, data__authors_item in enumerate(data__authors):
+                    validate_https___packaging_python_org_en_latest_specifications_pyproject_toml___definitions_author(data__authors_item, custom_formats, (name_prefix or "data") + ".authors[{data__authors_x}]".format(**locals()))
+        if "maintainers" in data_keys:
+            data_keys.remove("maintainers")
+            data__maintainers = data["maintainers"]
+            if not isinstance(data__maintainers, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".maintainers must be array", value=data__maintainers, name="" + (name_prefix or "data") + ".maintainers", definition={'type': 'array', 'items': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}, 'anyOf': [{'required': ['name']}, {'required': ['email']}]}, '$$description': ["The people or organizations considered to be the 'maintainers' of the project.", 'Similarly to ``authors``, the exact meaning is open to interpretation.']}, rule='type')
+            data__maintainers_is_list = isinstance(data__maintainers, (list, tuple))
+            if data__maintainers_is_list:
+                data__maintainers_len = len(data__maintainers)
+                for data__maintainers_x, data__maintainers_item in enumerate(data__maintainers):
+                    validate_https___packaging_python_org_en_latest_specifications_pyproject_toml___definitions_author(data__maintainers_item, custom_formats, (name_prefix or "data") + ".maintainers[{data__maintainers_x}]".format(**locals()))
+        if "keywords" in data_keys:
+            data_keys.remove("keywords")
+            data__keywords = data["keywords"]
+            if not isinstance(data__keywords, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".keywords must be array", value=data__keywords, name="" + (name_prefix or "data") + ".keywords", definition={'type': 'array', 'items': {'type': 'string'}, 'description': 'List of keywords to assist searching for the distribution in a larger catalog.'}, rule='type')
+            data__keywords_is_list = isinstance(data__keywords, (list, tuple))
+            if data__keywords_is_list:
+                data__keywords_len = len(data__keywords)
+                for data__keywords_x, data__keywords_item in enumerate(data__keywords):
+                    if not isinstance(data__keywords_item, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".keywords[{data__keywords_x}]".format(**locals()) + " must be string", value=data__keywords_item, name="" + (name_prefix or "data") + ".keywords[{data__keywords_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
+        if "classifiers" in data_keys:
+            data_keys.remove("classifiers")
+            data__classifiers = data["classifiers"]
+            if not isinstance(data__classifiers, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".classifiers must be array", value=data__classifiers, name="" + (name_prefix or "data") + ".classifiers", definition={'type': 'array', 'items': {'type': 'string', 'format': 'trove-classifier', 'description': '`PyPI classifier `_.'}, '$$description': ['`Trove classifiers `_', 'which apply to the project.']}, rule='type')
+            data__classifiers_is_list = isinstance(data__classifiers, (list, tuple))
+            if data__classifiers_is_list:
+                data__classifiers_len = len(data__classifiers)
+                for data__classifiers_x, data__classifiers_item in enumerate(data__classifiers):
+                    if not isinstance(data__classifiers_item, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".classifiers[{data__classifiers_x}]".format(**locals()) + " must be string", value=data__classifiers_item, name="" + (name_prefix or "data") + ".classifiers[{data__classifiers_x}]".format(**locals()) + "", definition={'type': 'string', 'format': 'trove-classifier', 'description': '`PyPI classifier `_.'}, rule='type')
+                    if isinstance(data__classifiers_item, str):
+                        if not custom_formats["trove-classifier"](data__classifiers_item):
+                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".classifiers[{data__classifiers_x}]".format(**locals()) + " must be trove-classifier", value=data__classifiers_item, name="" + (name_prefix or "data") + ".classifiers[{data__classifiers_x}]".format(**locals()) + "", definition={'type': 'string', 'format': 'trove-classifier', 'description': '`PyPI classifier `_.'}, rule='format')
+        if "urls" in data_keys:
+            data_keys.remove("urls")
+            data__urls = data["urls"]
+            if not isinstance(data__urls, (dict)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".urls must be object", value=data__urls, name="" + (name_prefix or "data") + ".urls", definition={'type': 'object', 'description': 'URLs associated with the project in the form ``label => value``.', 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', 'format': 'url'}}}, rule='type')
+            data__urls_is_dict = isinstance(data__urls, dict)
+            if data__urls_is_dict:
+                data__urls_keys = set(data__urls.keys())
+                for data__urls_key, data__urls_val in data__urls.items():
+                    if REGEX_PATTERNS['^.+$'].search(data__urls_key):
+                        if data__urls_key in data__urls_keys:
+                            data__urls_keys.remove(data__urls_key)
+                        if not isinstance(data__urls_val, (str)):
+                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".urls.{data__urls_key}".format(**locals()) + " must be string", value=data__urls_val, name="" + (name_prefix or "data") + ".urls.{data__urls_key}".format(**locals()) + "", definition={'type': 'string', 'format': 'url'}, rule='type')
+                        if isinstance(data__urls_val, str):
+                            if not custom_formats["url"](data__urls_val):
+                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".urls.{data__urls_key}".format(**locals()) + " must be url", value=data__urls_val, name="" + (name_prefix or "data") + ".urls.{data__urls_key}".format(**locals()) + "", definition={'type': 'string', 'format': 'url'}, rule='format')
+                if data__urls_keys:
+                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".urls must not contain "+str(data__urls_keys)+" properties", value=data__urls, name="" + (name_prefix or "data") + ".urls", definition={'type': 'object', 'description': 'URLs associated with the project in the form ``label => value``.', 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', 'format': 'url'}}}, rule='additionalProperties')
+        if "scripts" in data_keys:
+            data_keys.remove("scripts")
+            data__scripts = data["scripts"]
+            validate_https___packaging_python_org_en_latest_specifications_pyproject_toml___definitions_entry_point_group(data__scripts, custom_formats, (name_prefix or "data") + ".scripts")
+        if "gui-scripts" in data_keys:
+            data_keys.remove("gui-scripts")
+            data__guiscripts = data["gui-scripts"]
+            validate_https___packaging_python_org_en_latest_specifications_pyproject_toml___definitions_entry_point_group(data__guiscripts, custom_formats, (name_prefix or "data") + ".gui-scripts")
+        if "entry-points" in data_keys:
+            data_keys.remove("entry-points")
+            data__entrypoints = data["entry-points"]
+            data__entrypoints_is_dict = isinstance(data__entrypoints, dict)
+            if data__entrypoints_is_dict:
+                data__entrypoints_keys = set(data__entrypoints.keys())
+                for data__entrypoints_key, data__entrypoints_val in data__entrypoints.items():
+                    if REGEX_PATTERNS['^.+$'].search(data__entrypoints_key):
+                        if data__entrypoints_key in data__entrypoints_keys:
+                            data__entrypoints_keys.remove(data__entrypoints_key)
+                        validate_https___packaging_python_org_en_latest_specifications_pyproject_toml___definitions_entry_point_group(data__entrypoints_val, custom_formats, (name_prefix or "data") + ".entry-points.{data__entrypoints_key}".format(**locals()))
+                if data__entrypoints_keys:
+                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".entry-points must not contain "+str(data__entrypoints_keys)+" properties", value=data__entrypoints, name="" + (name_prefix or "data") + ".entry-points", definition={'$$description': ['Instruct the installer to expose the given modules/functions via', '``entry-point`` discovery mechanism (useful for plugins).', 'More information available in the `Python packaging guide', '`_.'], 'propertyNames': {'format': 'python-entrypoint-group'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}}}, rule='additionalProperties')
+                data__entrypoints_len = len(data__entrypoints)
+                if data__entrypoints_len != 0:
+                    data__entrypoints_property_names = True
+                    for data__entrypoints_key in data__entrypoints:
+                        try:
+                            if isinstance(data__entrypoints_key, str):
+                                if not custom_formats["python-entrypoint-group"](data__entrypoints_key):
+                                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".entry-points must be python-entrypoint-group", value=data__entrypoints_key, name="" + (name_prefix or "data") + ".entry-points", definition={'format': 'python-entrypoint-group'}, rule='format')
+                        except JsonSchemaValueException:
+                            data__entrypoints_property_names = False
+                    if not data__entrypoints_property_names:
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".entry-points must be named by propertyName definition", value=data__entrypoints, name="" + (name_prefix or "data") + ".entry-points", definition={'$$description': ['Instruct the installer to expose the given modules/functions via', '``entry-point`` discovery mechanism (useful for plugins).', 'More information available in the `Python packaging guide', '`_.'], 'propertyNames': {'format': 'python-entrypoint-group'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}}}, rule='propertyNames')
+        if "dependencies" in data_keys:
+            data_keys.remove("dependencies")
+            data__dependencies = data["dependencies"]
+            if not isinstance(data__dependencies, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".dependencies must be array", value=data__dependencies, name="" + (name_prefix or "data") + ".dependencies", definition={'type': 'array', 'description': 'Project (mandatory) dependencies.', 'items': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}, rule='type')
+            data__dependencies_is_list = isinstance(data__dependencies, (list, tuple))
+            if data__dependencies_is_list:
+                data__dependencies_len = len(data__dependencies)
+                for data__dependencies_x, data__dependencies_item in enumerate(data__dependencies):
+                    validate_https___packaging_python_org_en_latest_specifications_pyproject_toml___definitions_dependency(data__dependencies_item, custom_formats, (name_prefix or "data") + ".dependencies[{data__dependencies_x}]".format(**locals()))
+        if "optional-dependencies" in data_keys:
+            data_keys.remove("optional-dependencies")
+            data__optionaldependencies = data["optional-dependencies"]
+            if not isinstance(data__optionaldependencies, (dict)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".optional-dependencies must be object", value=data__optionaldependencies, name="" + (name_prefix or "data") + ".optional-dependencies", definition={'type': 'object', 'description': 'Optional dependency for the project', 'propertyNames': {'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'array', 'items': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}}}, rule='type')
+            data__optionaldependencies_is_dict = isinstance(data__optionaldependencies, dict)
+            if data__optionaldependencies_is_dict:
+                data__optionaldependencies_keys = set(data__optionaldependencies.keys())
+                for data__optionaldependencies_key, data__optionaldependencies_val in data__optionaldependencies.items():
+                    if REGEX_PATTERNS['^.+$'].search(data__optionaldependencies_key):
+                        if data__optionaldependencies_key in data__optionaldependencies_keys:
+                            data__optionaldependencies_keys.remove(data__optionaldependencies_key)
+                        if not isinstance(data__optionaldependencies_val, (list, tuple)):
+                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".optional-dependencies.{data__optionaldependencies_key}".format(**locals()) + " must be array", value=data__optionaldependencies_val, name="" + (name_prefix or "data") + ".optional-dependencies.{data__optionaldependencies_key}".format(**locals()) + "", definition={'type': 'array', 'items': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}, rule='type')
+                        data__optionaldependencies_val_is_list = isinstance(data__optionaldependencies_val, (list, tuple))
+                        if data__optionaldependencies_val_is_list:
+                            data__optionaldependencies_val_len = len(data__optionaldependencies_val)
+                            for data__optionaldependencies_val_x, data__optionaldependencies_val_item in enumerate(data__optionaldependencies_val):
+                                validate_https___packaging_python_org_en_latest_specifications_pyproject_toml___definitions_dependency(data__optionaldependencies_val_item, custom_formats, (name_prefix or "data") + ".optional-dependencies.{data__optionaldependencies_key}[{data__optionaldependencies_val_x}]".format(**locals()))
+                if data__optionaldependencies_keys:
+                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".optional-dependencies must not contain "+str(data__optionaldependencies_keys)+" properties", value=data__optionaldependencies, name="" + (name_prefix or "data") + ".optional-dependencies", definition={'type': 'object', 'description': 'Optional dependency for the project', 'propertyNames': {'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'array', 'items': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}}}, rule='additionalProperties')
+                data__optionaldependencies_len = len(data__optionaldependencies)
+                if data__optionaldependencies_len != 0:
+                    data__optionaldependencies_property_names = True
+                    for data__optionaldependencies_key in data__optionaldependencies:
+                        try:
+                            if isinstance(data__optionaldependencies_key, str):
+                                if not custom_formats["pep508-identifier"](data__optionaldependencies_key):
+                                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".optional-dependencies must be pep508-identifier", value=data__optionaldependencies_key, name="" + (name_prefix or "data") + ".optional-dependencies", definition={'format': 'pep508-identifier'}, rule='format')
+                        except JsonSchemaValueException:
+                            data__optionaldependencies_property_names = False
+                    if not data__optionaldependencies_property_names:
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".optional-dependencies must be named by propertyName definition", value=data__optionaldependencies, name="" + (name_prefix or "data") + ".optional-dependencies", definition={'type': 'object', 'description': 'Optional dependency for the project', 'propertyNames': {'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'array', 'items': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}}}, rule='propertyNames')
+        if "import-names" in data_keys:
+            data_keys.remove("import-names")
+            data__importnames = data["import-names"]
+            if not isinstance(data__importnames, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".import-names must be array", value=data__importnames, name="" + (name_prefix or "data") + ".import-names", definition={'description': 'Lists import names which a project, when installed, would exclusively provide.', 'type': 'array', 'items': {'type': 'string', 'format': 'import-name'}}, rule='type')
+            data__importnames_is_list = isinstance(data__importnames, (list, tuple))
+            if data__importnames_is_list:
+                data__importnames_len = len(data__importnames)
+                for data__importnames_x, data__importnames_item in enumerate(data__importnames):
+                    if not isinstance(data__importnames_item, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".import-names[{data__importnames_x}]".format(**locals()) + " must be string", value=data__importnames_item, name="" + (name_prefix or "data") + ".import-names[{data__importnames_x}]".format(**locals()) + "", definition={'type': 'string', 'format': 'import-name'}, rule='type')
+                    if isinstance(data__importnames_item, str):
+                        if not custom_formats["import-name"](data__importnames_item):
+                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".import-names[{data__importnames_x}]".format(**locals()) + " must be import-name", value=data__importnames_item, name="" + (name_prefix or "data") + ".import-names[{data__importnames_x}]".format(**locals()) + "", definition={'type': 'string', 'format': 'import-name'}, rule='format')
+        if "import-namespaces" in data_keys:
+            data_keys.remove("import-namespaces")
+            data__importnamespaces = data["import-namespaces"]
+            if not isinstance(data__importnamespaces, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".import-namespaces must be array", value=data__importnamespaces, name="" + (name_prefix or "data") + ".import-namespaces", definition={'description': 'Lists import names that, when installed, would be provided by the project, but not exclusively.', 'type': 'array', 'items': {'type': 'string', 'format': 'import-name'}}, rule='type')
+            data__importnamespaces_is_list = isinstance(data__importnamespaces, (list, tuple))
+            if data__importnamespaces_is_list:
+                data__importnamespaces_len = len(data__importnamespaces)
+                for data__importnamespaces_x, data__importnamespaces_item in enumerate(data__importnamespaces):
+                    if not isinstance(data__importnamespaces_item, (str)):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".import-namespaces[{data__importnamespaces_x}]".format(**locals()) + " must be string", value=data__importnamespaces_item, name="" + (name_prefix or "data") + ".import-namespaces[{data__importnamespaces_x}]".format(**locals()) + "", definition={'type': 'string', 'format': 'import-name'}, rule='type')
+                    if isinstance(data__importnamespaces_item, str):
+                        if not custom_formats["import-name"](data__importnamespaces_item):
+                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".import-namespaces[{data__importnamespaces_x}]".format(**locals()) + " must be import-name", value=data__importnamespaces_item, name="" + (name_prefix or "data") + ".import-namespaces[{data__importnamespaces_x}]".format(**locals()) + "", definition={'type': 'string', 'format': 'import-name'}, rule='format')
+        if "dynamic" in data_keys:
+            data_keys.remove("dynamic")
+            data__dynamic = data["dynamic"]
+            if not isinstance(data__dynamic, (list, tuple)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic must be array", value=data__dynamic, name="" + (name_prefix or "data") + ".dynamic", definition={'type': 'array', '$$description': ['Specifies which fields are intentionally unspecified and expected to be', 'dynamically provided by build tools'], 'items': {'enum': ['version', 'description', 'readme', 'requires-python', 'license', 'license-files', 'authors', 'maintainers', 'keywords', 'classifiers', 'urls', 'scripts', 'gui-scripts', 'entry-points', 'dependencies', 'optional-dependencies', 'import-names', 'import-namespaces']}}, rule='type')
+            data__dynamic_is_list = isinstance(data__dynamic, (list, tuple))
+            if data__dynamic_is_list:
+                data__dynamic_len = len(data__dynamic)
+                for data__dynamic_x, data__dynamic_item in enumerate(data__dynamic):
+                    if data__dynamic_item not in ['version', 'description', 'readme', 'requires-python', 'license', 'license-files', 'authors', 'maintainers', 'keywords', 'classifiers', 'urls', 'scripts', 'gui-scripts', 'entry-points', 'dependencies', 'optional-dependencies', 'import-names', 'import-namespaces']:
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic[{data__dynamic_x}]".format(**locals()) + " must be one of ['version', 'description', 'readme', 'requires-python', 'license', 'license-files', 'authors', 'maintainers', 'keywords', 'classifiers', 'urls', 'scripts', 'gui-scripts', 'entry-points', 'dependencies', 'optional-dependencies', 'import-names', 'import-namespaces']", value=data__dynamic_item, name="" + (name_prefix or "data") + ".dynamic[{data__dynamic_x}]".format(**locals()) + "", definition={'enum': ['version', 'description', 'readme', 'requires-python', 'license', 'license-files', 'authors', 'maintainers', 'keywords', 'classifiers', 'urls', 'scripts', 'gui-scripts', 'entry-points', 'dependencies', 'optional-dependencies', 'import-names', 'import-namespaces']}, rule='enum')
+        if data_keys:
+            raise JsonSchemaValueException("" + (name_prefix or "data") + " must not contain "+str(data_keys)+" properties", value=data, name="" + (name_prefix or "data") + "", definition={'$schema': 'http://json-schema.org/draft-07/schema#', '$id': 'https://packaging.python.org/en/latest/specifications/pyproject-toml/', 'title': 'Package metadata stored in the ``project`` table', '$$description': ['Data structure for the **project** table inside ``pyproject.toml``', '(as initially defined in :pep:`621`)'], 'type': 'object', 'properties': {'name': {'type': 'string', 'description': 'The name (primary identifier) of the project. MUST be statically defined.', 'format': 'pep508-identifier'}, 'version': {'type': 'string', 'description': 'The version of the project as supported by :pep:`440`.', 'format': 'pep440'}, 'description': {'type': 'string', '$$description': ['The `summary description of the project', '`_']}, 'readme': {'$$description': ['`Full/detailed description of the project in the form of a README', '`_', "with meaning similar to the one defined in `core metadata's Description", '`_'], 'oneOf': [{'type': 'string', '$$description': ['Relative path to a text file (UTF-8) containing the full description', 'of the project. If the file path ends in case-insensitive ``.md`` or', '``.rst`` suffixes, then the content-type is respectively', '``text/markdown`` or ``text/x-rst``']}, {'type': 'object', 'allOf': [{'anyOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to a text file containing the full description', 'of the project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', 'description': 'Full text describing the project.'}}, 'required': ['text']}]}, {'properties': {'content-type': {'type': 'string', '$$description': ['Content-type (:rfc:`1341`) of the full description', '(e.g. ``text/markdown``). The ``charset`` parameter is assumed', 'UTF-8 when not present.'], '$comment': 'TODO: add regex pattern or format?'}}, 'required': ['content-type']}]}]}, 'requires-python': {'type': 'string', 'format': 'pep508-versionspec', '$$description': ['`The Python version requirements of the project', '`_.']}, 'license': {'description': '`Project license `_.', 'oneOf': [{'type': 'string', 'description': 'An SPDX license identifier', 'format': 'SPDX'}, {'type': 'object', 'properties': {'file': {'type': 'string', '$$description': ['Relative path to the file (UTF-8) which contains the license for the', 'project.']}}, 'required': ['file']}, {'type': 'object', 'properties': {'text': {'type': 'string', '$$description': ['The license of the project whose meaning is that of the', '`License field from the core metadata', '`_.']}}, 'required': ['text']}]}, 'license-files': {'description': 'Paths or globs to paths of license files', 'type': 'array', 'items': {'type': 'string'}}, 'authors': {'type': 'array', 'items': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}, 'anyOf': [{'required': ['name']}, {'required': ['email']}]}, '$$description': ["The people or organizations considered to be the 'authors' of the project.", 'The exact meaning is open to interpretation (e.g. original or primary authors,', 'current maintainers, or owners of the package).']}, 'maintainers': {'type': 'array', 'items': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}, 'anyOf': [{'required': ['name']}, {'required': ['email']}]}, '$$description': ["The people or organizations considered to be the 'maintainers' of the project.", 'Similarly to ``authors``, the exact meaning is open to interpretation.']}, 'keywords': {'type': 'array', 'items': {'type': 'string'}, 'description': 'List of keywords to assist searching for the distribution in a larger catalog.'}, 'classifiers': {'type': 'array', 'items': {'type': 'string', 'format': 'trove-classifier', 'description': '`PyPI classifier `_.'}, '$$description': ['`Trove classifiers `_', 'which apply to the project.']}, 'urls': {'type': 'object', 'description': 'URLs associated with the project in the form ``label => value``.', 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', 'format': 'url'}}}, 'scripts': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, 'gui-scripts': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, 'entry-points': {'$$description': ['Instruct the installer to expose the given modules/functions via', '``entry-point`` discovery mechanism (useful for plugins).', 'More information available in the `Python packaging guide', '`_.'], 'propertyNames': {'format': 'python-entrypoint-group'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}}}, 'dependencies': {'type': 'array', 'description': 'Project (mandatory) dependencies.', 'items': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}, 'optional-dependencies': {'type': 'object', 'description': 'Optional dependency for the project', 'propertyNames': {'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'array', 'items': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}}}, 'import-names': {'description': 'Lists import names which a project, when installed, would exclusively provide.', 'type': 'array', 'items': {'type': 'string', 'format': 'import-name'}}, 'import-namespaces': {'description': 'Lists import names that, when installed, would be provided by the project, but not exclusively.', 'type': 'array', 'items': {'type': 'string', 'format': 'import-name'}}, 'dynamic': {'type': 'array', '$$description': ['Specifies which fields are intentionally unspecified and expected to be', 'dynamically provided by build tools'], 'items': {'enum': ['version', 'description', 'readme', 'requires-python', 'license', 'license-files', 'authors', 'maintainers', 'keywords', 'classifiers', 'urls', 'scripts', 'gui-scripts', 'entry-points', 'dependencies', 'optional-dependencies', 'import-names', 'import-namespaces']}}}, 'required': ['name'], 'additionalProperties': False, 'allOf': [{'if': {'not': {'required': ['dynamic'], 'properties': {'dynamic': {'contains': {'const': 'version'}, '$$description': ['version is listed in ``dynamic``']}}}, '$$comment': ['According to :pep:`621`:', '    If the core metadata specification lists a field as "Required", then', '    the metadata MUST specify the field statically or list it in dynamic', 'In turn, `core metadata`_ defines:', '    The required fields are: Metadata-Version, Name, Version.', '    All the other fields are optional.', 'Since ``Metadata-Version`` is defined by the build back-end, ``name`` and', '``version`` are the only mandatory information in ``pyproject.toml``.', '.. _core metadata: https://packaging.python.org/specifications/core-metadata/']}, 'then': {'required': ['version'], '$$description': ['version should be statically defined in the ``version`` field']}}, {'if': {'required': ['license-files']}, 'then': {'properties': {'license': {'type': 'string'}}}}], 'definitions': {'author': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}, 'anyOf': [{'required': ['name']}, {'required': ['email']}]}, 'entry-point-group': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, 'dependency': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}}, rule='additionalProperties')
+    return data
+
+def validate_https___packaging_python_org_en_latest_specifications_pyproject_toml___definitions_dependency(data, custom_formats={}, name_prefix=None):
+    if not isinstance(data, (str)):
+        raise JsonSchemaValueException("" + (name_prefix or "data") + " must be string", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}, rule='type')
+    if isinstance(data, str):
+        if not custom_formats["pep508"](data):
+            raise JsonSchemaValueException("" + (name_prefix or "data") + " must be pep508", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}, rule='format')
+    return data
+
+def validate_https___packaging_python_org_en_latest_specifications_pyproject_toml___definitions_entry_point_group(data, custom_formats={}, name_prefix=None):
+    if not isinstance(data, (dict)):
+        raise JsonSchemaValueException("" + (name_prefix or "data") + " must be object", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, rule='type')
+    data_is_dict = isinstance(data, dict)
+    if data_is_dict:
+        data_keys = set(data.keys())
+        for data_key, data_val in data.items():
+            if REGEX_PATTERNS['^.+$'].search(data_key):
+                if data_key in data_keys:
+                    data_keys.remove(data_key)
+                if not isinstance(data_val, (str)):
+                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".{data_key}".format(**locals()) + " must be string", value=data_val, name="" + (name_prefix or "data") + ".{data_key}".format(**locals()) + "", definition={'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}, rule='type')
+                if isinstance(data_val, str):
+                    if not custom_formats["python-entrypoint-reference"](data_val):
+                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".{data_key}".format(**locals()) + " must be python-entrypoint-reference", value=data_val, name="" + (name_prefix or "data") + ".{data_key}".format(**locals()) + "", definition={'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}, rule='format')
+        if data_keys:
+            raise JsonSchemaValueException("" + (name_prefix or "data") + " must not contain "+str(data_keys)+" properties", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, rule='additionalProperties')
+        data_len = len(data)
+        if data_len != 0:
+            data_property_names = True
+            for data_key in data:
+                try:
+                    if isinstance(data_key, str):
+                        if not custom_formats["python-entrypoint-name"](data_key):
+                            raise JsonSchemaValueException("" + (name_prefix or "data") + " must be python-entrypoint-name", value=data_key, name="" + (name_prefix or "data") + "", definition={'format': 'python-entrypoint-name'}, rule='format')
+                except JsonSchemaValueException:
+                    data_property_names = False
+            if not data_property_names:
+                raise JsonSchemaValueException("" + (name_prefix or "data") + " must be named by propertyName definition", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, rule='propertyNames')
+    return data
+
+def validate_https___packaging_python_org_en_latest_specifications_pyproject_toml___definitions_author(data, custom_formats={}, name_prefix=None):
+    if not isinstance(data, (dict)):
+        raise JsonSchemaValueException("" + (name_prefix or "data") + " must be object", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}, 'anyOf': [{'required': ['name']}, {'required': ['email']}]}, rule='type')
+    data_any_of_count15 = 0
+    if not data_any_of_count15:
+        try:
+            data_is_dict = isinstance(data, dict)
+            if data_is_dict:
+                data__missing_keys = set(['name']) - data.keys()
+                if data__missing_keys:
+                    raise JsonSchemaValueException("" + (name_prefix or "data") + " must contain " + (str(sorted(data__missing_keys)) + " properties"), value=data, name="" + (name_prefix or "data") + "", definition={'required': ['name']}, rule='required')
+            data_any_of_count15 += 1
+        except JsonSchemaValueException: pass
+    if not data_any_of_count15:
+        try:
+            data_is_dict = isinstance(data, dict)
+            if data_is_dict:
+                data__missing_keys = set(['email']) - data.keys()
+                if data__missing_keys:
+                    raise JsonSchemaValueException("" + (name_prefix or "data") + " must contain " + (str(sorted(data__missing_keys)) + " properties"), value=data, name="" + (name_prefix or "data") + "", definition={'required': ['email']}, rule='required')
+            data_any_of_count15 += 1
+        except JsonSchemaValueException: pass
+    if not data_any_of_count15:
+        raise JsonSchemaValueException("" + (name_prefix or "data") + " cannot be validated by any definition", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}, 'anyOf': [{'required': ['name']}, {'required': ['email']}]}, rule='anyOf')
+    data_is_dict = isinstance(data, dict)
+    if data_is_dict:
+        data_keys = set(data.keys())
+        if "name" in data_keys:
+            data_keys.remove("name")
+            data__name = data["name"]
+            if not isinstance(data__name, (str)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".name must be string", value=data__name, name="" + (name_prefix or "data") + ".name", definition={'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, rule='type')
+        if "email" in data_keys:
+            data_keys.remove("email")
+            data__email = data["email"]
+            if not isinstance(data__email, (str)):
+                raise JsonSchemaValueException("" + (name_prefix or "data") + ".email must be string", value=data__email, name="" + (name_prefix or "data") + ".email", definition={'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}, rule='type')
+            if isinstance(data__email, str):
+                if not REGEX_PATTERNS["idn-email_re_pattern"].match(data__email):
+                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".email must be idn-email", value=data__email, name="" + (name_prefix or "data") + ".email", definition={'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}, rule='format')
+        if data_keys:
+            raise JsonSchemaValueException("" + (name_prefix or "data") + " must not contain "+str(data_keys)+" properties", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}, 'anyOf': [{'required': ['name']}, {'required': ['email']}]}, rule='additionalProperties')
+    return data
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/formats.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/formats.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe958cc52a4a6477686231a6bfe4cb8c15357162
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/formats.py
@@ -0,0 +1,464 @@
+"""
+The functions in this module are used to validate schemas with the
+`format JSON Schema keyword
+`_.
+
+The correspondence is given by replacing the ``_`` character in the name of the
+function with a ``-`` to obtain the format name and vice versa.
+"""
+
+from __future__ import annotations
+
+import keyword
+import logging
+import os
+import re
+import string
+import typing
+from itertools import chain as _chain
+
+if typing.TYPE_CHECKING:
+    import builtins
+
+    from typing_extensions import Literal
+
+_logger = logging.getLogger(__name__)
+
+# -------------------------------------------------------------------------------------
+# PEP 440
+
+VERSION_PATTERN = r"""
+    v?
+    (?:
+        (?:(?P[0-9]+)!)?                           # epoch
+        (?P[0-9]+(?:\.[0-9]+)*)                  # release segment
+        (?P
                                              # pre-release
+            [-_\.]?
+            (?Palpha|a|beta|b|preview|pre|c|rc)
+            [-_\.]?
+            (?P[0-9]+)?
+        )?
+        (?P                                         # post release
+            (?:-(?P[0-9]+))
+            |
+            (?:
+                [-_\.]?
+                (?Ppost|rev|r)
+                [-_\.]?
+                (?P[0-9]+)?
+            )
+        )?
+        (?P                                          # dev release
+            [-_\.]?
+            (?Pdev)
+            [-_\.]?
+            (?P[0-9]+)?
+        )?
+    )
+    (?:\+(?P[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
+"""
+
+VERSION_REGEX = re.compile(
+    r"^\s*" + VERSION_PATTERN + r"\s*$", re.VERBOSE | re.IGNORECASE
+)
+
+
+def pep440(version: str) -> bool:
+    """See :ref:`PyPA's version specification `
+    (initially introduced in :pep:`440`).
+    """
+    return VERSION_REGEX.match(version) is not None
+
+
+# -------------------------------------------------------------------------------------
+# PEP 508
+
+PEP508_IDENTIFIER_PATTERN = r"([A-Z0-9]|[A-Z0-9][A-Z0-9._-]*[A-Z0-9])"
+PEP508_IDENTIFIER_REGEX = re.compile(f"^{PEP508_IDENTIFIER_PATTERN}$", re.IGNORECASE)
+
+
+def pep508_identifier(name: str) -> bool:
+    """See :ref:`PyPA's name specification `
+    (initially introduced in :pep:`508#names`).
+    """
+    return PEP508_IDENTIFIER_REGEX.match(name) is not None
+
+
+try:
+    try:
+        from packaging import requirements as _req
+    except ImportError:  # pragma: no cover
+        # let's try setuptools vendored version
+        from setuptools._vendor.packaging import (  # type: ignore[no-redef]
+            requirements as _req,
+        )
+
+    def pep508(value: str) -> bool:
+        """See :ref:`PyPA's dependency specifiers `
+        (initially introduced in :pep:`508`).
+        """
+        try:
+            _req.Requirement(value)
+        except _req.InvalidRequirement:
+            return False
+        return True
+
+except ImportError:  # pragma: no cover
+    _logger.warning(
+        "Could not find an installation of `packaging`. Requirements, dependencies and "
+        "versions might not be validated. "
+        "To enforce validation, please install `packaging`."
+    )
+
+    def pep508(value: str) -> bool:  # noqa: ARG001
+        return True
+
+
+def pep508_versionspec(value: str) -> bool:
+    """Expression that can be used to specify/lock versions (including ranges)
+    See ``versionspec`` in :ref:`PyPA's dependency specifiers
+    ` (initially introduced in :pep:`508`).
+    """
+    if any(c in value for c in (";", "]", "@")):
+        # In PEP 508:
+        # conditional markers, extras and URL specs are not included in the
+        # versionspec
+        return False
+    # Let's pretend we have a dependency called `requirement` with the given
+    # version spec, then we can reuse the pep508 function for validation:
+    return pep508(f"requirement{value}")
+
+
+# -------------------------------------------------------------------------------------
+# PEP 517
+
+
+def pep517_backend_reference(value: str) -> bool:
+    """See PyPA's specification for defining build-backend references
+    introduced in :pep:`517#source-trees`.
+
+    This is similar to an entry-point reference (e.g., ``package.module:object``).
+    """
+    module, _, obj = value.partition(":")
+    identifiers = (i.strip() for i in _chain(module.split("."), obj.split(".")))
+    return all(python_identifier(i) for i in identifiers if i)
+
+
+# -------------------------------------------------------------------------------------
+# Classifiers - PEP 301
+
+
+def _download_classifiers() -> str:
+    import ssl
+    from email.message import Message
+    from urllib.request import urlopen
+
+    url = "https://pypi.org/pypi?:action=list_classifiers"
+    context = ssl.create_default_context()
+    with urlopen(url, context=context) as response:  # noqa: S310 (audit URLs)
+        headers = Message()
+        headers["content_type"] = response.getheader("content-type", "text/plain")
+        return response.read().decode(headers.get_param("charset", "utf-8"))  # type: ignore[no-any-return]
+
+
+class _TroveClassifier:
+    """The ``trove_classifiers`` package is the official way of validating classifiers,
+    however this package might not be always available.
+    As a workaround we can still download a list from PyPI.
+    We also don't want to be over strict about it, so simply skipping silently is an
+    option (classifiers will be validated anyway during the upload to PyPI).
+    """
+
+    downloaded: None | Literal[False] | set[str]
+    """
+    None => not cached yet
+    False => unavailable
+    set => cached values
+    """
+
+    def __init__(self) -> None:
+        self.downloaded = None
+        self._skip_download = False
+        self.__name__ = "trove_classifier"  # Emulate a public function
+
+    def _disable_download(self) -> None:
+        # This is a private API. Only setuptools has the consent of using it.
+        self._skip_download = True
+
+    def __call__(self, value: str) -> bool:
+        if self.downloaded is False or self._skip_download is True:
+            return True
+
+        if os.getenv("NO_NETWORK") or os.getenv("VALIDATE_PYPROJECT_NO_NETWORK"):
+            self.downloaded = False
+            msg = (
+                "Install ``trove-classifiers`` to ensure proper validation. "
+                "Skipping download of classifiers list from PyPI (NO_NETWORK)."
+            )
+            _logger.debug(msg)
+            return True
+
+        if self.downloaded is None:
+            msg = (
+                "Install ``trove-classifiers`` to ensure proper validation. "
+                "Meanwhile a list of classifiers will be downloaded from PyPI."
+            )
+            _logger.debug(msg)
+            try:
+                self.downloaded = set(_download_classifiers().splitlines())
+            except Exception:  # noqa: BLE001
+                self.downloaded = False
+                _logger.debug("Problem with download, skipping validation")
+                return True
+
+        return value in self.downloaded or value.lower().startswith("private ::")
+
+
+try:
+    from trove_classifiers import classifiers as _trove_classifiers
+
+    def trove_classifier(value: str) -> bool:
+        """See https://pypi.org/classifiers/"""
+        return value in _trove_classifiers or value.lower().startswith("private ::")
+
+except ImportError:  # pragma: no cover
+    trove_classifier = _TroveClassifier()
+
+
+# -------------------------------------------------------------------------------------
+# Stub packages - PEP 561
+
+
+def pep561_stub_name(value: str) -> bool:
+    """Name of a directory containing type stubs.
+    It must follow the name scheme ``-stubs`` as defined in
+    :pep:`561#stub-only-packages`.
+    """
+    top, *children = value.split(".")
+    if not top.endswith("-stubs"):
+        return False
+    return python_module_name(".".join([top[: -len("-stubs")], *children]))
+
+
+# -------------------------------------------------------------------------------------
+# Non-PEP related
+
+
+def url(value: str) -> bool:
+    """Valid URL (validation uses :obj:`urllib.parse`).
+    For maximum compatibility please make sure to include a ``scheme`` prefix
+    in your URL (e.g. ``http://``).
+    """
+    from urllib.parse import urlparse
+
+    try:
+        parts = urlparse(value)
+        if not parts.scheme:
+            _logger.warning(
+                "For maximum compatibility please make sure to include a "
+                "`scheme` prefix in your URL (e.g. 'http://'). "
+                f"Given value: {value}"
+            )
+            if not (value.startswith(("/", "\\")) or "@" in value):
+                parts = urlparse(f"http://{value}")
+
+        return bool(parts.scheme and parts.netloc)
+    except Exception:  # noqa: BLE001
+        return False
+
+
+# https://packaging.python.org/specifications/entry-points/
+ENTRYPOINT_PATTERN = r"[^\[\s=]([^=]*[^\s=])?"
+ENTRYPOINT_REGEX = re.compile(f"^{ENTRYPOINT_PATTERN}$", re.IGNORECASE)
+RECOMMEDED_ENTRYPOINT_PATTERN = r"[\w.-]+"
+RECOMMEDED_ENTRYPOINT_REGEX = re.compile(
+    f"^{RECOMMEDED_ENTRYPOINT_PATTERN}$", re.IGNORECASE
+)
+ENTRYPOINT_GROUP_PATTERN = r"\w+(\.\w+)*"
+ENTRYPOINT_GROUP_REGEX = re.compile(f"^{ENTRYPOINT_GROUP_PATTERN}$", re.IGNORECASE)
+
+
+def python_identifier(value: str) -> bool:
+    """Can be used as identifier in Python.
+    (Validation uses :obj:`str.isidentifier`).
+    """
+    return value.isidentifier()
+
+
+def python_qualified_identifier(value: str) -> bool:
+    """
+    Python "dotted identifier", i.e. a sequence of :obj:`python_identifier`
+    concatenated with ``"."`` (e.g.: ``package.module.submodule``).
+    """
+    if value.startswith(".") or value.endswith("."):
+        return False
+    return all(python_identifier(m) for m in value.split("."))
+
+
+def python_module_name(value: str) -> bool:
+    """Module name that can be used in an ``import``-statement in Python.
+    See :obj:`python_qualified_identifier`.
+    """
+    return python_qualified_identifier(value)
+
+
+def python_module_name_relaxed(value: str) -> bool:
+    """Similar to :obj:`python_module_name`, but relaxed to also accept
+    dash characters (``-``) and cover special cases like ``pip-run``.
+
+    It is recommended, however, that beginners avoid dash characters,
+    as they require advanced knowledge about Python internals.
+
+    The following are disallowed:
+
+    * names starting/ending in dashes,
+    * names ending in ``-stubs`` (potentially collide with :obj:`pep561_stub_name`).
+    """
+    if value.startswith("-") or value.endswith("-"):
+        return False
+    if value.endswith("-stubs"):
+        return False  # Avoid collision with PEP 561
+    return python_module_name(value.replace("-", "_"))
+
+
+def python_entrypoint_group(value: str) -> bool:
+    """See ``Data model > group`` in the :ref:`PyPA's entry-points specification
+    `.
+    """
+    return ENTRYPOINT_GROUP_REGEX.match(value) is not None
+
+
+def python_entrypoint_name(value: str) -> bool:
+    """See ``Data model > name`` in the :ref:`PyPA's entry-points specification
+    `.
+    """
+    if not ENTRYPOINT_REGEX.match(value):
+        return False
+    if not RECOMMEDED_ENTRYPOINT_REGEX.match(value):
+        msg = f"Entry point `{value}` does not follow recommended pattern: "
+        msg += RECOMMEDED_ENTRYPOINT_PATTERN
+        _logger.warning(msg)
+    return True
+
+
+def python_entrypoint_reference(value: str) -> bool:
+    """Reference to a Python object using in the format::
+
+        importable.module:object.attr
+
+    See ``Data model >object reference`` in the :ref:`PyPA's entry-points specification
+    `.
+    """
+    module, _, rest = value.partition(":")
+    if "[" in rest:
+        obj, _, extras_ = rest.partition("[")
+        if extras_.strip()[-1] != "]":
+            return False
+        extras = (x.strip() for x in extras_.strip(string.whitespace + "[]").split(","))
+        if not all(pep508_identifier(e) for e in extras):
+            return False
+        _logger.warning(f"`{value}` - using extras for entry points is not recommended")
+    else:
+        obj = rest
+
+    module_parts = module.split(".")
+    identifiers = _chain(module_parts, obj.split(".")) if rest else iter(module_parts)
+    return all(python_identifier(i.strip()) for i in identifiers)
+
+
+def uint8(value: builtins.int) -> bool:
+    r"""Unsigned 8-bit integer (:math:`0 \leq x < 2^8`)"""
+    return 0 <= value < 2**8
+
+
+def uint16(value: builtins.int) -> bool:
+    r"""Unsigned 16-bit integer (:math:`0 \leq x < 2^{16}`)"""
+    return 0 <= value < 2**16
+
+
+def uint32(value: builtins.int) -> bool:
+    r"""Unsigned 32-bit integer (:math:`0 \leq x < 2^{32}`)"""
+    return 0 <= value < 2**32
+
+
+def uint64(value: builtins.int) -> bool:
+    r"""Unsigned 64-bit integer (:math:`0 \leq x < 2^{64}`)"""
+    return 0 <= value < 2**64
+
+
+def uint(value: builtins.int) -> bool:
+    r"""Signed 64-bit integer (:math:`0 \leq x < 2^{64}`)"""
+    return 0 <= value < 2**64
+
+
+def int8(value: builtins.int) -> bool:
+    r"""Signed 8-bit integer (:math:`-2^{7} \leq x < 2^{7}`)"""
+    return -(2**7) <= value < 2**7
+
+
+def int16(value: builtins.int) -> bool:
+    r"""Signed 16-bit integer (:math:`-2^{15} \leq x < 2^{15}`)"""
+    return -(2**15) <= value < 2**15
+
+
+def int32(value: builtins.int) -> bool:
+    r"""Signed 32-bit integer (:math:`-2^{31} \leq x < 2^{31}`)"""
+    return -(2**31) <= value < 2**31
+
+
+def int64(value: builtins.int) -> bool:
+    r"""Signed 64-bit integer (:math:`-2^{63} \leq x < 2^{63}`)"""
+    return -(2**63) <= value < 2**63
+
+
+def int(value: builtins.int) -> bool:
+    r"""Signed 64-bit integer (:math:`-2^{63} \leq x < 2^{63}`)"""
+    return -(2**63) <= value < 2**63
+
+
+try:
+    from packaging import licenses as _licenses
+
+    def SPDX(value: str) -> bool:
+        """See :ref:`PyPA's License-Expression specification
+        ` (added in :pep:`639`).
+        """
+        try:
+            _licenses.canonicalize_license_expression(value)
+        except _licenses.InvalidLicenseExpression:
+            return False
+        return True
+
+except ImportError:  # pragma: no cover
+    _logger.warning(
+        "Could not find an up-to-date installation of `packaging`. "
+        "License expressions might not be validated. "
+        "To enforce validation, please install `packaging>=24.2`."
+    )
+
+    def SPDX(value: str) -> bool:  # noqa: ARG001
+        return True
+
+
+VALID_IMPORT_NAME = re.compile(
+    r"""
+    ^                                  # start of string
+        [A-Za-z_][A-Za-z_0-9]+         # a valid Python identifier
+        (?:\.[A-Za-z_][A-Za-z_0-9]*)*  # optionally followed by .identifier's
+    (?:\s*;\s*private)?                # optionally followed by ; private
+    $                                  # end of string
+    """,
+    re.VERBOSE,
+)
+
+
+def import_name(value: str) -> bool:
+    """This is a valid import name. It has to be series of python identifiers
+    (not keywords), separated by dots, optionally followed by a semicolon and
+    the keyword "private".
+    """
+    if VALID_IMPORT_NAME.match(value) is None:
+        return False
+
+    idents, _, _ = value.partition(";")
+    return all(not keyword.iskeyword(ident) for ident in idents.rstrip().split("."))
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/config/distutils.schema.json b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/distutils.schema.json
new file mode 100644
index 0000000000000000000000000000000000000000..93cd2e868acdaf41bf8b1f77026e84c02a5af3f8
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/distutils.schema.json
@@ -0,0 +1,26 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+
+  "$id": "https://setuptools.pypa.io/en/latest/deprecated/distutils/configfile.html",
+  "title": "``tool.distutils`` table",
+  "$$description": [
+    "**EXPERIMENTAL** (NOT OFFICIALLY SUPPORTED): Use ``tool.distutils``",
+    "subtables to configure arguments for ``distutils`` commands.",
+    "Originally, ``distutils`` allowed developers to configure arguments for",
+    "``setup.py`` commands via `distutils configuration files",
+    "`_.",
+    "See also `the old Python docs _`."
+  ],
+
+  "type": "object",
+  "properties": {
+    "global": {
+      "type": "object",
+      "description": "Global options applied to all ``distutils`` commands"
+    }
+  },
+  "patternProperties": {
+    ".+": {"type": "object"}
+  },
+  "$comment": "TODO: Is there a practical way of making this schema more specific?"
+}
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/config/expand.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/expand.py
new file mode 100644
index 0000000000000000000000000000000000000000..d9a2ded430eb2720d2dac0da125105befe9e222e
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/expand.py
@@ -0,0 +1,452 @@
+"""Utility functions to expand configuration directives or special values
+(such glob patterns).
+
+We can split the process of interpreting configuration files into 2 steps:
+
+1. The parsing the file contents from strings to value objects
+   that can be understand by Python (for example a string with a comma
+   separated list of keywords into an actual Python list of strings).
+
+2. The expansion (or post-processing) of these values according to the
+   semantics ``setuptools`` assign to them (for example a configuration field
+   with the ``file:`` directive should be expanded from a list of file paths to
+   a single string with the contents of those files concatenated)
+
+This module focus on the second step, and therefore allow sharing the expansion
+functions among several configuration file formats.
+
+**PRIVATE MODULE**: API reserved for setuptools internal usage only.
+"""
+
+from __future__ import annotations
+
+import ast
+import importlib
+import os
+import pathlib
+import sys
+from collections.abc import Iterable, Iterator, Mapping
+from configparser import ConfigParser
+from glob import iglob
+from importlib.machinery import ModuleSpec, all_suffixes
+from itertools import chain
+from pathlib import Path
+from types import ModuleType, TracebackType
+from typing import TYPE_CHECKING, Any, Callable, TypeVar
+
+from .. import _static
+from .._path import StrPath, same_path as _same_path
+from ..discovery import find_package_path
+from ..warnings import SetuptoolsWarning
+
+from distutils.errors import DistutilsOptionError
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+    from setuptools.dist import Distribution
+
+_K = TypeVar("_K")
+_V_co = TypeVar("_V_co", covariant=True)
+
+
+class StaticModule:
+    """Proxy to a module object that avoids executing arbitrary code."""
+
+    def __init__(self, name: str, spec: ModuleSpec) -> None:
+        module = ast.parse(pathlib.Path(spec.origin).read_bytes())  # type: ignore[arg-type] # Let it raise an error on None
+        vars(self).update(locals())
+        del self.self
+
+    def _find_assignments(self) -> Iterator[tuple[ast.AST, ast.AST]]:
+        for statement in self.module.body:
+            if isinstance(statement, ast.Assign):
+                yield from ((target, statement.value) for target in statement.targets)
+            elif isinstance(statement, ast.AnnAssign) and statement.value:
+                yield (statement.target, statement.value)
+
+    def __getattr__(self, attr: str) -> Any:
+        """Attempt to load an attribute "statically", via :func:`ast.literal_eval`."""
+        try:
+            return next(
+                ast.literal_eval(value)
+                for target, value in self._find_assignments()
+                if isinstance(target, ast.Name) and target.id == attr
+            )
+        except Exception as e:
+            raise AttributeError(f"{self.name} has no attribute {attr}") from e
+
+
+def glob_relative(
+    patterns: Iterable[str], root_dir: StrPath | None = None
+) -> list[str]:
+    """Expand the list of glob patterns, but preserving relative paths.
+
+    :param list[str] patterns: List of glob patterns
+    :param str root_dir: Path to which globs should be relative
+                         (current directory by default)
+    :rtype: list
+    """
+    glob_characters = {'*', '?', '[', ']', '{', '}'}
+    expanded_values = []
+    root_dir = root_dir or os.getcwd()
+    for value in patterns:
+        # Has globby characters?
+        if any(char in value for char in glob_characters):
+            # then expand the glob pattern while keeping paths *relative*:
+            glob_path = os.path.abspath(os.path.join(root_dir, value))
+            expanded_values.extend(
+                sorted(
+                    os.path.relpath(path, root_dir).replace(os.sep, "/")
+                    for path in iglob(glob_path, recursive=True)
+                )
+            )
+
+        else:
+            # take the value as-is
+            path = os.path.relpath(value, root_dir).replace(os.sep, "/")
+            expanded_values.append(path)
+
+    return expanded_values
+
+
+def read_files(
+    filepaths: StrPath | Iterable[StrPath], root_dir: StrPath | None = None
+) -> str:
+    """Return the content of the files concatenated using ``\n`` as str
+
+    This function is sandboxed and won't reach anything outside ``root_dir``
+
+    (By default ``root_dir`` is the current directory).
+    """
+    from more_itertools import always_iterable
+
+    root_dir = os.path.abspath(root_dir or os.getcwd())
+    _filepaths = (os.path.join(root_dir, path) for path in always_iterable(filepaths))
+    return '\n'.join(
+        _read_file(path)
+        for path in _filter_existing_files(_filepaths)
+        if _assert_local(path, root_dir)
+    )
+
+
+def _filter_existing_files(filepaths: Iterable[StrPath]) -> Iterator[StrPath]:
+    for path in filepaths:
+        if os.path.isfile(path):
+            yield path
+        else:
+            SetuptoolsWarning.emit(f"File {path!r} cannot be found")
+
+
+def _read_file(filepath: bytes | StrPath) -> str:
+    with open(filepath, encoding='utf-8') as f:
+        return f.read()
+
+
+def _assert_local(filepath: StrPath, root_dir: str):
+    if Path(os.path.abspath(root_dir)) not in Path(os.path.abspath(filepath)).parents:
+        msg = f"Cannot access {filepath!r} (or anything outside {root_dir!r})"
+        raise DistutilsOptionError(msg)
+
+    return True
+
+
+def read_attr(
+    attr_desc: str,
+    package_dir: Mapping[str, str] | None = None,
+    root_dir: StrPath | None = None,
+) -> Any:
+    """Reads the value of an attribute from a module.
+
+    This function will try to read the attributed statically first
+    (via :func:`ast.literal_eval`), and only evaluate the module if it fails.
+
+    Examples:
+        read_attr("package.attr")
+        read_attr("package.module.attr")
+
+    :param str attr_desc: Dot-separated string describing how to reach the
+        attribute (see examples above)
+    :param dict[str, str] package_dir: Mapping of package names to their
+        location in disk (represented by paths relative to ``root_dir``).
+    :param str root_dir: Path to directory containing all the packages in
+        ``package_dir`` (current directory by default).
+    :rtype: str
+    """
+    root_dir = root_dir or os.getcwd()
+    attrs_path = attr_desc.strip().split('.')
+    attr_name = attrs_path.pop()
+    module_name = '.'.join(attrs_path)
+    module_name = module_name or '__init__'
+    path = _find_module(module_name, package_dir, root_dir)
+    spec = _find_spec(module_name, path)
+
+    try:
+        value = getattr(StaticModule(module_name, spec), attr_name)
+        # XXX: Is marking as static contents coming from modules too optimistic?
+        return _static.attempt_conversion(value)
+    except Exception:
+        # fallback to evaluate module
+        module = _load_spec(spec, module_name)
+        return getattr(module, attr_name)
+
+
+def _find_spec(module_name: str, module_path: StrPath | None) -> ModuleSpec:
+    spec = importlib.util.spec_from_file_location(module_name, module_path)
+    spec = spec or importlib.util.find_spec(module_name)
+
+    if spec is None:
+        raise ModuleNotFoundError(module_name)
+
+    return spec
+
+
+def _load_spec(spec: ModuleSpec, module_name: str) -> ModuleType:
+    name = getattr(spec, "__name__", module_name)
+    if name in sys.modules:
+        return sys.modules[name]
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module  # cache (it also ensures `==` works on loaded items)
+    assert spec.loader is not None
+    spec.loader.exec_module(module)
+    return module
+
+
+def _find_module(
+    module_name: str, package_dir: Mapping[str, str] | None, root_dir: StrPath
+) -> str | None:
+    """Find the path to the module named ``module_name``,
+    considering the ``package_dir`` in the build configuration and ``root_dir``.
+
+    >>> tmp = getfixture('tmpdir')
+    >>> _ = tmp.ensure("a/b/c.py")
+    >>> _ = tmp.ensure("a/b/d/__init__.py")
+    >>> r = lambda x: x.replace(str(tmp), "tmp").replace(os.sep, "/")
+    >>> r(_find_module("a.b.c", None, tmp))
+    'tmp/a/b/c.py'
+    >>> r(_find_module("f.g.h", {"": "1", "f": "2", "f.g": "3", "f.g.h": "a/b/d"}, tmp))
+    'tmp/a/b/d/__init__.py'
+    """
+    path_start = find_package_path(module_name, package_dir or {}, root_dir)
+    candidates = chain.from_iterable(
+        (f"{path_start}{ext}", os.path.join(path_start, f"__init__{ext}"))
+        for ext in all_suffixes()
+    )
+    return next((x for x in candidates if os.path.isfile(x)), None)
+
+
+def resolve_class(
+    qualified_class_name: str,
+    package_dir: Mapping[str, str] | None = None,
+    root_dir: StrPath | None = None,
+) -> Callable:
+    """Given a qualified class name, return the associated class object"""
+    root_dir = root_dir or os.getcwd()
+    idx = qualified_class_name.rfind('.')
+    class_name = qualified_class_name[idx + 1 :]
+    pkg_name = qualified_class_name[:idx]
+
+    path = _find_module(pkg_name, package_dir, root_dir)
+    module = _load_spec(_find_spec(pkg_name, path), pkg_name)
+    return getattr(module, class_name)
+
+
+def cmdclass(
+    values: dict[str, str],
+    package_dir: Mapping[str, str] | None = None,
+    root_dir: StrPath | None = None,
+) -> dict[str, Callable]:
+    """Given a dictionary mapping command names to strings for qualified class
+    names, apply :func:`resolve_class` to the dict values.
+    """
+    return {k: resolve_class(v, package_dir, root_dir) for k, v in values.items()}
+
+
+def find_packages(
+    *,
+    namespaces=True,
+    fill_package_dir: dict[str, str] | None = None,
+    root_dir: StrPath | None = None,
+    **kwargs,
+) -> list[str]:
+    """Works similarly to :func:`setuptools.find_packages`, but with all
+    arguments given as keyword arguments. Moreover, ``where`` can be given
+    as a list (the results will be simply concatenated).
+
+    When the additional keyword argument ``namespaces`` is ``True``, it will
+    behave like :func:`setuptools.find_namespace_packages`` (i.e. include
+    implicit namespaces as per :pep:`420`).
+
+    The ``where`` argument will be considered relative to ``root_dir`` (or the current
+    working directory when ``root_dir`` is not given).
+
+    If the ``fill_package_dir`` argument is passed, this function will consider it as a
+    similar data structure to the ``package_dir`` configuration parameter add fill-in
+    any missing package location.
+
+    :rtype: list
+    """
+    from more_itertools import always_iterable, unique_everseen
+
+    from setuptools.discovery import construct_package_dir
+
+    # check "not namespaces" first due to python/mypy#6232
+    if not namespaces:
+        from setuptools.discovery import PackageFinder
+    else:
+        from setuptools.discovery import PEP420PackageFinder as PackageFinder
+
+    root_dir = root_dir or os.curdir
+    where = kwargs.pop('where', ['.'])
+    packages: list[str] = []
+    fill_package_dir = {} if fill_package_dir is None else fill_package_dir
+    search = list(unique_everseen(always_iterable(where)))
+
+    if len(search) == 1 and all(not _same_path(search[0], x) for x in (".", root_dir)):
+        fill_package_dir.setdefault("", search[0])
+
+    for path in search:
+        package_path = _nest_path(root_dir, path)
+        pkgs = PackageFinder.find(package_path, **kwargs)
+        packages.extend(pkgs)
+        if pkgs and not (
+            fill_package_dir.get("") == path or os.path.samefile(package_path, root_dir)
+        ):
+            fill_package_dir.update(construct_package_dir(pkgs, path))
+
+    return packages
+
+
+def _nest_path(parent: StrPath, path: StrPath) -> str:
+    path = parent if path in {".", ""} else os.path.join(parent, path)
+    return os.path.normpath(path)
+
+
+def version(value: Callable | Iterable[str | int] | str) -> str:
+    """When getting the version directly from an attribute,
+    it should be normalised to string.
+    """
+    _value = value() if callable(value) else value
+
+    if isinstance(_value, str):
+        return _value
+    if hasattr(_value, '__iter__'):
+        return '.'.join(map(str, _value))
+    return f'{_value}'
+
+
+def canonic_package_data(package_data: dict) -> dict:
+    if "*" in package_data:
+        package_data[""] = package_data.pop("*")
+    return package_data
+
+
+def canonic_data_files(
+    data_files: list | dict, root_dir: StrPath | None = None
+) -> list[tuple[str, list[str]]]:
+    """For compatibility with ``setup.py``, ``data_files`` should be a list
+    of pairs instead of a dict.
+
+    This function also expands glob patterns.
+    """
+    if isinstance(data_files, list):
+        return data_files
+
+    return [
+        (dest, glob_relative(patterns, root_dir))
+        for dest, patterns in data_files.items()
+    ]
+
+
+def entry_points(
+    text: str, text_source: str = "entry-points"
+) -> dict[str, dict[str, str]]:
+    """Given the contents of entry-points file,
+    process it into a 2-level dictionary (``dict[str, dict[str, str]]``).
+    The first level keys are entry-point groups, the second level keys are
+    entry-point names, and the second level values are references to objects
+    (that correspond to the entry-point value).
+    """
+    # Using undocumented behaviour, see python/typeshed#12700
+    parser = ConfigParser(default_section=None, delimiters=("=",))  # type: ignore[call-overload]
+    parser.optionxform = str  # case sensitive
+    parser.read_string(text, text_source)
+    groups = {k: dict(v.items()) for k, v in parser.items()}
+    groups.pop(parser.default_section, None)
+    return groups
+
+
+class EnsurePackagesDiscovered:
+    """Some expand functions require all the packages to already be discovered before
+    they run, e.g. :func:`read_attr`, :func:`resolve_class`, :func:`cmdclass`.
+
+    Therefore in some cases we will need to run autodiscovery during the evaluation of
+    the configuration. However, it is better to postpone calling package discovery as
+    much as possible, because some parameters can influence it (e.g. ``package_dir``),
+    and those might not have been processed yet.
+    """
+
+    def __init__(self, distribution: Distribution) -> None:
+        self._dist = distribution
+        self._called = False
+
+    def __call__(self) -> None:
+        """Trigger the automatic package discovery, if it is still necessary."""
+        if not self._called:
+            self._called = True
+            self._dist.set_defaults(name=False)  # Skip name, we can still be parsing
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        if self._called:
+            self._dist.set_defaults.analyse_name()  # Now we can set a default name
+
+    def _get_package_dir(self) -> Mapping[str, str]:
+        self()
+        pkg_dir = self._dist.package_dir
+        return {} if pkg_dir is None else pkg_dir
+
+    @property
+    def package_dir(self) -> Mapping[str, str]:
+        """Proxy to ``package_dir`` that may trigger auto-discovery when used."""
+        return LazyMappingProxy(self._get_package_dir)
+
+
+class LazyMappingProxy(Mapping[_K, _V_co]):
+    """Mapping proxy that delays resolving the target object, until really needed.
+
+    >>> def obtain_mapping():
+    ...     print("Running expensive function!")
+    ...     return {"key": "value", "other key": "other value"}
+    >>> mapping = LazyMappingProxy(obtain_mapping)
+    >>> mapping["key"]
+    Running expensive function!
+    'value'
+    >>> mapping["other key"]
+    'other value'
+    """
+
+    def __init__(self, obtain_mapping_value: Callable[[], Mapping[_K, _V_co]]) -> None:
+        self._obtain = obtain_mapping_value
+        self._value: Mapping[_K, _V_co] | None = None
+
+    def _target(self) -> Mapping[_K, _V_co]:
+        if self._value is None:
+            self._value = self._obtain()
+        return self._value
+
+    def __getitem__(self, key: _K) -> _V_co:
+        return self._target()[key]
+
+    def __len__(self) -> int:
+        return len(self._target())
+
+    def __iter__(self) -> Iterator[_K]:
+        return iter(self._target())
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/config/pyprojecttoml.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/pyprojecttoml.py
new file mode 100644
index 0000000000000000000000000000000000000000..3dfc46dd97e0a50b457b7f291cf4f40612acfd56
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/pyprojecttoml.py
@@ -0,0 +1,477 @@
+"""
+Load setuptools configuration from ``pyproject.toml`` files.
+
+**PRIVATE MODULE**: API reserved for setuptools internal usage only.
+
+To read project metadata, consider using
+``build.util.project_wheel_metadata`` (https://pypi.org/project/build/).
+For simple scenarios, you can also try parsing the file directly
+with the help of ``tomllib`` or ``tomli``.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from collections.abc import Mapping
+from contextlib import contextmanager
+from functools import partial
+from types import TracebackType
+from typing import TYPE_CHECKING, Any, Callable
+
+from .._path import StrPath
+from ..errors import FileError, InvalidConfigError
+from ..warnings import SetuptoolsWarning
+from . import expand as _expand
+from ._apply_pyprojecttoml import _PREVIOUSLY_DEFINED, _MissingDynamic, apply as _apply
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+    from setuptools.dist import Distribution
+
+_logger = logging.getLogger(__name__)
+
+
+def load_file(filepath: StrPath) -> dict:
+    from ..compat.py310 import tomllib
+
+    with open(filepath, "rb") as file:
+        return tomllib.load(file)
+
+
+def validate(config: dict, filepath: StrPath) -> bool:
+    from . import _validate_pyproject as validator
+
+    trove_classifier = validator.FORMAT_FUNCTIONS.get("trove-classifier")
+    if hasattr(trove_classifier, "_disable_download"):
+        # Improve reproducibility by default. See abravalheri/validate-pyproject#31
+        trove_classifier._disable_download()  # type: ignore[union-attr]
+
+    try:
+        return validator.validate(config)
+    except validator.ValidationError as ex:
+        summary = f"configuration error: {ex.summary}"
+        if ex.name.strip("`") != "project":
+            # Probably it is just a field missing/misnamed, not worthy the verbosity...
+            _logger.debug(summary)
+            _logger.debug(ex.details)
+
+        error = f"invalid pyproject.toml config: {ex.name}."
+        raise ValueError(f"{error}\n{summary}") from None
+
+
+def apply_configuration(
+    dist: Distribution,
+    filepath: StrPath,
+    ignore_option_errors: bool = False,
+) -> Distribution:
+    """Apply the configuration from a ``pyproject.toml`` file into an existing
+    distribution object.
+    """
+    config = read_configuration(filepath, True, ignore_option_errors, dist)
+    return _apply(dist, config, filepath)
+
+
+def read_configuration(
+    filepath: StrPath,
+    expand: bool = True,
+    ignore_option_errors: bool = False,
+    dist: Distribution | None = None,
+) -> dict[str, Any]:
+    """Read given configuration file and returns options from it as a dict.
+
+    :param str|unicode filepath: Path to configuration file in the ``pyproject.toml``
+        format.
+
+    :param bool expand: Whether to expand directives and other computed values
+        (i.e. post-process the given configuration)
+
+    :param bool ignore_option_errors: Whether to silently ignore
+        options, values of which could not be resolved (e.g. due to exceptions
+        in directives such as file:, attr:, etc.).
+        If False exceptions are propagated as expected.
+
+    :param Distribution|None: Distribution object to which the configuration refers.
+        If not given a dummy object will be created and discarded after the
+        configuration is read. This is used for auto-discovery of packages and in the
+        case a dynamic configuration (e.g. ``attr`` or ``cmdclass``) is expanded.
+        When ``expand=False`` this object is simply ignored.
+
+    :rtype: dict
+    """
+    filepath = os.path.abspath(filepath)
+
+    if not os.path.isfile(filepath):
+        raise FileError(f"Configuration file {filepath!r} does not exist.")
+
+    asdict = load_file(filepath) or {}
+    project_table = asdict.get("project", {})
+    tool_table = asdict.get("tool", {})
+    setuptools_table = tool_table.get("setuptools", {})
+    if not asdict or not (project_table or setuptools_table):
+        return {}  # User is not using pyproject to configure setuptools
+
+    if "setuptools" in asdict.get("tools", {}):
+        # let the user know they probably have a typo in their metadata
+        _ToolsTypoInMetadata.emit()
+
+    if "distutils" in tool_table:
+        _ExperimentalConfiguration.emit(subject="[tool.distutils]")
+
+    # There is an overall sense in the community that making include_package_data=True
+    # the default would be an improvement.
+    # `ini2toml` backfills include_package_data=False when nothing is explicitly given,
+    # therefore setting a default here is backwards compatible.
+    if dist and dist.include_package_data is not None:
+        setuptools_table.setdefault("include-package-data", dist.include_package_data)
+    else:
+        setuptools_table.setdefault("include-package-data", True)
+    # Persist changes:
+    asdict["tool"] = tool_table
+    tool_table["setuptools"] = setuptools_table
+
+    if "ext-modules" in setuptools_table:
+        _ExperimentalConfiguration.emit(subject="[tool.setuptools.ext-modules]")
+
+    fields = ("import-names", "import-namespaces")
+    places = (project_table, project_table.get("dynamic", []))
+    if any(field in place for field in fields for place in places):
+        raise NotImplementedError(
+            "Setuptools does not support `import-names` and `import-namespaces`"
+            " in `pyproject.toml` yet. If your are interested in this feature, "
+            " please consider submitting a contribution via pull requests."
+        )
+
+    with _ignore_errors(ignore_option_errors):
+        # Don't complain about unrelated errors (e.g. tools not using the "tool" table)
+        subset = {"project": project_table, "tool": {"setuptools": setuptools_table}}
+        validate(subset, filepath)
+
+    if expand:
+        root_dir = os.path.dirname(filepath)
+        return expand_configuration(asdict, root_dir, ignore_option_errors, dist)
+
+    return asdict
+
+
+def expand_configuration(
+    config: dict,
+    root_dir: StrPath | None = None,
+    ignore_option_errors: bool = False,
+    dist: Distribution | None = None,
+) -> dict:
+    """Given a configuration with unresolved fields (e.g. dynamic, cmdclass, ...)
+    find their final values.
+
+    :param dict config: Dict containing the configuration for the distribution
+    :param str root_dir: Top-level directory for the distribution/project
+        (the same directory where ``pyproject.toml`` is place)
+    :param bool ignore_option_errors: see :func:`read_configuration`
+    :param Distribution|None: Distribution object to which the configuration refers.
+        If not given a dummy object will be created and discarded after the
+        configuration is read. Used in the case a dynamic configuration
+        (e.g. ``attr`` or ``cmdclass``).
+
+    :rtype: dict
+    """
+    return _ConfigExpander(config, root_dir, ignore_option_errors, dist).expand()
+
+
+class _ConfigExpander:
+    def __init__(
+        self,
+        config: dict,
+        root_dir: StrPath | None = None,
+        ignore_option_errors: bool = False,
+        dist: Distribution | None = None,
+    ) -> None:
+        self.config = config
+        self.root_dir = root_dir or os.getcwd()
+        self.project_cfg = config.get("project", {})
+        self.dynamic = self.project_cfg.get("dynamic", [])
+        self.setuptools_cfg = config.get("tool", {}).get("setuptools", {})
+        self.dynamic_cfg = self.setuptools_cfg.get("dynamic", {})
+        self.ignore_option_errors = ignore_option_errors
+        self._dist = dist
+        self._referenced_files = set[str]()
+
+    def _ensure_dist(self) -> Distribution:
+        from setuptools.dist import Distribution
+
+        attrs = {"src_root": self.root_dir, "name": self.project_cfg.get("name", None)}
+        return self._dist or Distribution(attrs)
+
+    def _process_field(self, container: dict, field: str, fn: Callable):
+        if field in container:
+            with _ignore_errors(self.ignore_option_errors):
+                container[field] = fn(container[field])
+
+    def _canonic_package_data(self, field="package-data"):
+        package_data = self.setuptools_cfg.get(field, {})
+        return _expand.canonic_package_data(package_data)
+
+    def expand(self):
+        self._expand_packages()
+        self._canonic_package_data()
+        self._canonic_package_data("exclude-package-data")
+
+        # A distribution object is required for discovering the correct package_dir
+        dist = self._ensure_dist()
+        ctx = _EnsurePackagesDiscovered(dist, self.project_cfg, self.setuptools_cfg)
+        with ctx as ensure_discovered:
+            package_dir = ensure_discovered.package_dir
+            self._expand_data_files()
+            self._expand_cmdclass(package_dir)
+            self._expand_all_dynamic(dist, package_dir)
+
+        dist._referenced_files.update(self._referenced_files)
+        return self.config
+
+    def _expand_packages(self):
+        packages = self.setuptools_cfg.get("packages")
+        if packages is None or isinstance(packages, (list, tuple)):
+            return
+
+        find = packages.get("find")
+        if isinstance(find, dict):
+            find["root_dir"] = self.root_dir
+            find["fill_package_dir"] = self.setuptools_cfg.setdefault("package-dir", {})
+            with _ignore_errors(self.ignore_option_errors):
+                self.setuptools_cfg["packages"] = _expand.find_packages(**find)
+
+    def _expand_data_files(self):
+        data_files = partial(_expand.canonic_data_files, root_dir=self.root_dir)
+        self._process_field(self.setuptools_cfg, "data-files", data_files)
+
+    def _expand_cmdclass(self, package_dir: Mapping[str, str]):
+        root_dir = self.root_dir
+        cmdclass = partial(_expand.cmdclass, package_dir=package_dir, root_dir=root_dir)
+        self._process_field(self.setuptools_cfg, "cmdclass", cmdclass)
+
+    def _expand_all_dynamic(self, dist: Distribution, package_dir: Mapping[str, str]):
+        special = (  # need special handling
+            "version",
+            "readme",
+            "entry-points",
+            "scripts",
+            "gui-scripts",
+            "classifiers",
+            "dependencies",
+            "optional-dependencies",
+        )
+        # `_obtain` functions are assumed to raise appropriate exceptions/warnings.
+        obtained_dynamic = {
+            field: self._obtain(dist, field, package_dir)
+            for field in self.dynamic
+            if field not in special
+        }
+        obtained_dynamic.update(
+            self._obtain_entry_points(dist, package_dir) or {},
+            version=self._obtain_version(dist, package_dir),
+            readme=self._obtain_readme(dist),
+            classifiers=self._obtain_classifiers(dist),
+            dependencies=self._obtain_dependencies(dist),
+            optional_dependencies=self._obtain_optional_dependencies(dist),
+        )
+        # `None` indicates there is nothing in `tool.setuptools.dynamic` but the value
+        # might have already been set by setup.py/extensions, so avoid overwriting.
+        updates = {k: v for k, v in obtained_dynamic.items() if v is not None}
+        self.project_cfg.update(updates)
+
+    def _ensure_previously_set(self, dist: Distribution, field: str):
+        previous = _PREVIOUSLY_DEFINED[field](dist)
+        if previous is None and not self.ignore_option_errors:
+            msg = (
+                f"No configuration found for dynamic {field!r}.\n"
+                "Some dynamic fields need to be specified via `tool.setuptools.dynamic`"
+                "\nothers must be specified via the equivalent attribute in `setup.py`."
+            )
+            raise InvalidConfigError(msg)
+
+    def _expand_directive(
+        self, specifier: str, directive, package_dir: Mapping[str, str]
+    ):
+        from more_itertools import always_iterable
+
+        with _ignore_errors(self.ignore_option_errors):
+            root_dir = self.root_dir
+            if "file" in directive:
+                self._referenced_files.update(always_iterable(directive["file"]))
+                return _expand.read_files(directive["file"], root_dir)
+            if "attr" in directive:
+                return _expand.read_attr(directive["attr"], package_dir, root_dir)
+            raise ValueError(f"invalid `{specifier}`: {directive!r}")
+        return None
+
+    def _obtain(self, dist: Distribution, field: str, package_dir: Mapping[str, str]):
+        if field in self.dynamic_cfg:
+            return self._expand_directive(
+                f"tool.setuptools.dynamic.{field}",
+                self.dynamic_cfg[field],
+                package_dir,
+            )
+        self._ensure_previously_set(dist, field)
+        return None
+
+    def _obtain_version(self, dist: Distribution, package_dir: Mapping[str, str]):
+        # Since plugins can set version, let's silently skip if it cannot be obtained
+        if "version" in self.dynamic and "version" in self.dynamic_cfg:
+            return _expand.version(
+                # We already do an early check for the presence of "version"
+                self._obtain(dist, "version", package_dir)  # pyright: ignore[reportArgumentType]
+            )
+        return None
+
+    def _obtain_readme(self, dist: Distribution) -> dict[str, str] | None:
+        if "readme" not in self.dynamic:
+            return None
+
+        dynamic_cfg = self.dynamic_cfg
+        if "readme" in dynamic_cfg:
+            return {
+                # We already do an early check for the presence of "readme"
+                "text": self._obtain(dist, "readme", {}),
+                "content-type": dynamic_cfg["readme"].get("content-type", "text/x-rst"),
+            }  # pyright: ignore[reportReturnType]
+
+        self._ensure_previously_set(dist, "readme")
+        return None
+
+    def _obtain_entry_points(
+        self, dist: Distribution, package_dir: Mapping[str, str]
+    ) -> dict[str, dict[str, Any]] | None:
+        fields = ("entry-points", "scripts", "gui-scripts")
+        if not any(field in self.dynamic for field in fields):
+            return None
+
+        text = self._obtain(dist, "entry-points", package_dir)
+        if text is None:
+            return None
+
+        groups = _expand.entry_points(text)
+        # Any is str | dict[str, str], but causes variance issues
+        expanded: dict[str, dict[str, Any]] = {"entry-points": groups}
+
+        def _set_scripts(field: str, group: str):
+            if group in groups:
+                value = groups.pop(group)
+                if field not in self.dynamic:
+                    raise InvalidConfigError(_MissingDynamic.details(field, value))
+                expanded[field] = value
+
+        _set_scripts("scripts", "console_scripts")
+        _set_scripts("gui-scripts", "gui_scripts")
+
+        return expanded
+
+    def _obtain_classifiers(self, dist: Distribution):
+        if "classifiers" in self.dynamic:
+            value = self._obtain(dist, "classifiers", {})
+            if value:
+                return value.splitlines()
+        return None
+
+    def _obtain_dependencies(self, dist: Distribution):
+        if "dependencies" in self.dynamic:
+            value = self._obtain(dist, "dependencies", {})
+            if value:
+                return _parse_requirements_list(value)
+        return None
+
+    def _obtain_optional_dependencies(self, dist: Distribution):
+        if "optional-dependencies" not in self.dynamic:
+            return None
+        if "optional-dependencies" in self.dynamic_cfg:
+            optional_dependencies_map = self.dynamic_cfg["optional-dependencies"]
+            assert isinstance(optional_dependencies_map, dict)
+            return {
+                group: _parse_requirements_list(
+                    self._expand_directive(
+                        f"tool.setuptools.dynamic.optional-dependencies.{group}",
+                        directive,
+                        {},
+                    )
+                )
+                for group, directive in optional_dependencies_map.items()
+            }
+        self._ensure_previously_set(dist, "optional-dependencies")
+        return None
+
+
+def _parse_requirements_list(value):
+    return [
+        line
+        for line in value.splitlines()
+        if line.strip() and not line.strip().startswith("#")
+    ]
+
+
+@contextmanager
+def _ignore_errors(ignore_option_errors: bool):
+    if not ignore_option_errors:
+        yield
+        return
+
+    try:
+        yield
+    except Exception as ex:
+        _logger.debug(f"ignored error: {ex.__class__.__name__} - {ex}")
+
+
+class _EnsurePackagesDiscovered(_expand.EnsurePackagesDiscovered):
+    def __init__(
+        self, distribution: Distribution, project_cfg: dict, setuptools_cfg: dict
+    ) -> None:
+        super().__init__(distribution)
+        self._project_cfg = project_cfg
+        self._setuptools_cfg = setuptools_cfg
+
+    def __enter__(self) -> Self:
+        """When entering the context, the values of ``packages``, ``py_modules`` and
+        ``package_dir`` that are missing in ``dist`` are copied from ``setuptools_cfg``.
+        """
+        dist, cfg = self._dist, self._setuptools_cfg
+        package_dir: dict[str, str] = cfg.setdefault("package-dir", {})
+        package_dir.update(dist.package_dir or {})
+        dist.package_dir = package_dir  # needs to be the same object
+
+        dist.set_defaults._ignore_ext_modules()  # pyproject.toml-specific behaviour
+
+        # Set `name`, `py_modules` and `packages` in dist to short-circuit
+        # auto-discovery, but avoid overwriting empty lists purposefully set by users.
+        if dist.metadata.name is None:
+            dist.metadata.name = self._project_cfg.get("name")
+        if dist.py_modules is None:
+            dist.py_modules = cfg.get("py-modules")
+        if dist.packages is None:
+            dist.packages = cfg.get("packages")
+
+        return super().__enter__()
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        """When exiting the context, if values of ``packages``, ``py_modules`` and
+        ``package_dir`` are missing in ``setuptools_cfg``, copy from ``dist``.
+        """
+        # If anything was discovered set them back, so they count in the final config.
+        self._setuptools_cfg.setdefault("packages", self._dist.packages)
+        self._setuptools_cfg.setdefault("py-modules", self._dist.py_modules)
+        return super().__exit__(exc_type, exc_value, traceback)
+
+
+class _ExperimentalConfiguration(SetuptoolsWarning):
+    _SUMMARY = (
+        "`{subject}` in `pyproject.toml` is still *experimental* "
+        "and likely to change in future releases."
+    )
+
+
+class _ToolsTypoInMetadata(SetuptoolsWarning):
+    _SUMMARY = (
+        "Ignoring [tools.setuptools] in pyproject.toml, did you mean [tool.setuptools]?"
+    )
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/config/setupcfg.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/setupcfg.py
new file mode 100644
index 0000000000000000000000000000000000000000..121a0febda1b37523da5074f14cc04301efa60bf
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/setupcfg.py
@@ -0,0 +1,782 @@
+"""
+Load setuptools configuration from ``setup.cfg`` files.
+
+**API will be made private in the future**
+
+To read project metadata, consider using
+``build.util.project_wheel_metadata`` (https://pypi.org/project/build/).
+For simple scenarios, you can also try parsing the file directly
+with the help of ``configparser``.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import functools
+import os
+from abc import abstractmethod
+from collections import defaultdict
+from collections.abc import Iterable, Iterator
+from functools import partial, wraps
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Generic, TypeVar, cast
+
+from packaging.markers import default_environment as marker_env
+from packaging.requirements import InvalidRequirement, Requirement
+from packaging.version import InvalidVersion, Version
+
+from .. import _static
+from .._path import StrPath
+from ..errors import FileError, OptionError
+from ..warnings import SetuptoolsDeprecationWarning
+from . import expand
+
+if TYPE_CHECKING:
+    from typing_extensions import TypeAlias
+
+    from setuptools.dist import Distribution
+
+    from distutils.dist import DistributionMetadata
+
+SingleCommandOptions: TypeAlias = dict[str, tuple[str, Any]]
+"""Dict that associate the name of the options of a particular command to a
+tuple. The first element of the tuple indicates the origin of the option value
+(e.g. the name of the configuration file where it was read from),
+while the second element of the tuple is the option value itself
+"""
+AllCommandOptions: TypeAlias = dict[str, SingleCommandOptions]
+"""cmd name => its options"""
+Target = TypeVar("Target", "Distribution", "DistributionMetadata")
+
+
+def read_configuration(
+    filepath: StrPath, find_others: bool = False, ignore_option_errors: bool = False
+) -> dict:
+    """Read given configuration file and returns options from it as a dict.
+
+    :param str|unicode filepath: Path to configuration file
+        to get options from.
+
+    :param bool find_others: Whether to search for other configuration files
+        which could be on in various places.
+
+    :param bool ignore_option_errors: Whether to silently ignore
+        options, values of which could not be resolved (e.g. due to exceptions
+        in directives such as file:, attr:, etc.).
+        If False exceptions are propagated as expected.
+
+    :rtype: dict
+    """
+    from setuptools.dist import Distribution
+
+    dist = Distribution()
+    filenames = dist.find_config_files() if find_others else []
+    handlers = _apply(dist, filepath, filenames, ignore_option_errors)
+    return configuration_to_dict(handlers)
+
+
+def apply_configuration(dist: Distribution, filepath: StrPath) -> Distribution:
+    """Apply the configuration from a ``setup.cfg`` file into an existing
+    distribution object.
+    """
+    _apply(dist, filepath)
+    dist._finalize_requires()
+    return dist
+
+
+def _apply(
+    dist: Distribution,
+    filepath: StrPath,
+    other_files: Iterable[StrPath] = (),
+    ignore_option_errors: bool = False,
+) -> tuple[ConfigMetadataHandler, ConfigOptionsHandler]:
+    """Read configuration from ``filepath`` and applies to the ``dist`` object."""
+    from setuptools.dist import _Distribution
+
+    filepath = os.path.abspath(filepath)
+
+    if not os.path.isfile(filepath):
+        raise FileError(f'Configuration file {filepath} does not exist.')
+
+    current_directory = os.getcwd()
+    os.chdir(os.path.dirname(filepath))
+    filenames = [*other_files, filepath]
+
+    try:
+        # TODO: Temporary cast until mypy 1.12 is released with upstream fixes from typeshed
+        _Distribution.parse_config_files(dist, filenames=cast(list[str], filenames))
+        handlers = parse_configuration(
+            dist, dist.command_options, ignore_option_errors=ignore_option_errors
+        )
+        dist._finalize_license_files()
+    finally:
+        os.chdir(current_directory)
+
+    return handlers
+
+
+def _get_option(target_obj: Distribution | DistributionMetadata, key: str):
+    """
+    Given a target object and option key, get that option from
+    the target object, either through a get_{key} method or
+    from an attribute directly.
+    """
+    getter_name = f'get_{key}'
+    by_attribute = functools.partial(getattr, target_obj, key)
+    getter = getattr(target_obj, getter_name, by_attribute)
+    return getter()
+
+
+def configuration_to_dict(
+    handlers: Iterable[
+        ConfigHandler[Distribution] | ConfigHandler[DistributionMetadata]
+    ],
+) -> dict:
+    """Returns configuration data gathered by given handlers as a dict.
+
+    :param Iterable[ConfigHandler] handlers: Handlers list,
+        usually from parse_configuration()
+
+    :rtype: dict
+    """
+    config_dict: dict = defaultdict(dict)
+
+    for handler in handlers:
+        for option in handler.set_options:
+            value = _get_option(handler.target_obj, option)
+            config_dict[handler.section_prefix][option] = value
+
+    return config_dict
+
+
+def parse_configuration(
+    distribution: Distribution,
+    command_options: AllCommandOptions,
+    ignore_option_errors: bool = False,
+) -> tuple[ConfigMetadataHandler, ConfigOptionsHandler]:
+    """Performs additional parsing of configuration options
+    for a distribution.
+
+    Returns a list of used option handlers.
+
+    :param Distribution distribution:
+    :param dict command_options:
+    :param bool ignore_option_errors: Whether to silently ignore
+        options, values of which could not be resolved (e.g. due to exceptions
+        in directives such as file:, attr:, etc.).
+        If False exceptions are propagated as expected.
+    :rtype: list
+    """
+    with expand.EnsurePackagesDiscovered(distribution) as ensure_discovered:
+        options = ConfigOptionsHandler(
+            distribution,
+            command_options,
+            ignore_option_errors,
+            ensure_discovered,
+        )
+
+        options.parse()
+        if not distribution.package_dir:
+            distribution.package_dir = options.package_dir  # Filled by `find_packages`
+
+        meta = ConfigMetadataHandler(
+            distribution.metadata,
+            command_options,
+            ignore_option_errors,
+            ensure_discovered,
+            distribution.package_dir,
+            distribution.src_root,
+        )
+        meta.parse()
+        distribution._referenced_files.update(
+            options._referenced_files, meta._referenced_files
+        )
+
+    return meta, options
+
+
+def _warn_accidental_env_marker_misconfig(label: str, orig_value: str, parsed: list):
+    """Because users sometimes misinterpret this configuration:
+
+    [options.extras_require]
+    foo = bar;python_version<"4"
+
+    It looks like one requirement with an environment marker
+    but because there is no newline, it's parsed as two requirements
+    with a semicolon as separator.
+
+    Therefore, if:
+        * input string does not contain a newline AND
+        * parsed result contains two requirements AND
+        * parsing of the two parts from the result (";")
+        leads in a valid Requirement with a valid marker
+    a UserWarning is shown to inform the user about the possible problem.
+    """
+    if "\n" in orig_value or len(parsed) != 2:
+        return
+
+    markers = marker_env().keys()
+
+    try:
+        req = Requirement(parsed[1])
+        if req.name in markers:
+            _AmbiguousMarker.emit(field=label, req=parsed[1])
+    except InvalidRequirement as ex:
+        if any(parsed[1].startswith(marker) for marker in markers):
+            msg = _AmbiguousMarker.message(field=label, req=parsed[1])
+            raise InvalidRequirement(msg) from ex
+
+
+class ConfigHandler(Generic[Target]):
+    """Handles metadata supplied in configuration files."""
+
+    section_prefix: str
+    """Prefix for config sections handled by this handler.
+    Must be provided by class heirs.
+
+    """
+
+    aliases: ClassVar[dict[str, str]] = {}
+    """Options aliases.
+    For compatibility with various packages. E.g.: d2to1 and pbr.
+    Note: `-` in keys is replaced with `_` by config parser.
+
+    """
+
+    def __init__(
+        self,
+        target_obj: Target,
+        options: AllCommandOptions,
+        ignore_option_errors,
+        ensure_discovered: expand.EnsurePackagesDiscovered,
+    ) -> None:
+        self.ignore_option_errors = ignore_option_errors
+        self.target_obj: Target = target_obj
+        self.sections = dict(self._section_options(options))
+        self.set_options: list[str] = []
+        self.ensure_discovered = ensure_discovered
+        self._referenced_files = set[str]()
+        """After parsing configurations, this property will enumerate
+        all files referenced by the "file:" directive. Private API for setuptools only.
+        """
+
+    @classmethod
+    def _section_options(
+        cls, options: AllCommandOptions
+    ) -> Iterator[tuple[str, SingleCommandOptions]]:
+        for full_name, value in options.items():
+            pre, _sep, name = full_name.partition(cls.section_prefix)
+            if pre:
+                continue
+            yield name.lstrip('.'), value
+
+    @property
+    @abstractmethod
+    def parsers(self) -> dict[str, Callable]:
+        """Metadata item name to parser function mapping."""
+        raise NotImplementedError(
+            f'{self.__class__.__name__} must provide .parsers property'
+        )
+
+    def __setitem__(self, option_name, value) -> None:
+        target_obj = self.target_obj
+
+        # Translate alias into real name.
+        option_name = self.aliases.get(option_name, option_name)
+
+        try:
+            current_value = getattr(target_obj, option_name)
+        except AttributeError as e:
+            raise KeyError(option_name) from e
+
+        if current_value:
+            # Already inhabited. Skipping.
+            return
+
+        try:
+            parsed = self.parsers.get(option_name, lambda x: x)(value)
+        except (Exception,) * self.ignore_option_errors:
+            return
+
+        simple_setter = functools.partial(target_obj.__setattr__, option_name)
+        setter = getattr(target_obj, f"set_{option_name}", simple_setter)
+        setter(parsed)
+
+        self.set_options.append(option_name)
+
+    @classmethod
+    def _parse_list(cls, value, separator=','):
+        """Represents value as a list.
+
+        Value is split either by separator (defaults to comma) or by lines.
+
+        :param value:
+        :param separator: List items separator character.
+        :rtype: list
+        """
+        if isinstance(value, list):  # _get_parser_compound case
+            return value
+
+        if '\n' in value:
+            value = value.splitlines()
+        else:
+            value = value.split(separator)
+
+        return [chunk.strip() for chunk in value if chunk.strip()]
+
+    @classmethod
+    def _parse_dict(cls, value):
+        """Represents value as a dict.
+
+        :param value:
+        :rtype: dict
+        """
+        separator = '='
+        result = {}
+        for line in cls._parse_list(value):
+            key, sep, val = line.partition(separator)
+            if sep != separator:
+                raise OptionError(f"Unable to parse option value to dict: {value}")
+            result[key.strip()] = val.strip()
+
+        return result
+
+    @classmethod
+    def _parse_bool(cls, value):
+        """Represents value as boolean.
+
+        :param value:
+        :rtype: bool
+        """
+        value = value.lower()
+        return value in ('1', 'true', 'yes')
+
+    @classmethod
+    def _exclude_files_parser(cls, key):
+        """Returns a parser function to make sure field inputs
+        are not files.
+
+        Parses a value after getting the key so error messages are
+        more informative.
+
+        :param key:
+        :rtype: callable
+        """
+
+        def parser(value):
+            exclude_directive = 'file:'
+            if value.startswith(exclude_directive):
+                raise ValueError(
+                    f'Only strings are accepted for the {key} field, '
+                    'files are not accepted'
+                )
+            return _static.Str(value)
+
+        return parser
+
+    def _parse_file(self, value, root_dir: StrPath | None):
+        """Represents value as a string, allowing including text
+        from nearest files using `file:` directive.
+
+        Directive is sandboxed and won't reach anything outside
+        directory with setup.py.
+
+        Examples:
+            file: README.rst, CHANGELOG.md, src/file.txt
+
+        :param str value:
+        :rtype: str
+        """
+        include_directive = 'file:'
+
+        if not isinstance(value, str):
+            return value
+
+        if not value.startswith(include_directive):
+            return _static.Str(value)
+
+        spec = value[len(include_directive) :]
+        filepaths = [path.strip() for path in spec.split(',')]
+        self._referenced_files.update(filepaths)
+        # XXX: Is marking as static contents coming from files too optimistic?
+        return _static.Str(expand.read_files(filepaths, root_dir))
+
+    def _parse_attr(self, value, package_dir, root_dir: StrPath):
+        """Represents value as a module attribute.
+
+        Examples:
+            attr: package.attr
+            attr: package.module.attr
+
+        :param str value:
+        :rtype: str
+        """
+        attr_directive = 'attr:'
+        if not value.startswith(attr_directive):
+            return _static.Str(value)
+
+        attr_desc = value.replace(attr_directive, '')
+
+        # Make sure package_dir is populated correctly, so `attr:` directives can work
+        package_dir.update(self.ensure_discovered.package_dir)
+        return expand.read_attr(attr_desc, package_dir, root_dir)
+
+    @classmethod
+    def _get_parser_compound(cls, *parse_methods):
+        """Returns parser function to represents value as a list.
+
+        Parses a value applying given methods one after another.
+
+        :param parse_methods:
+        :rtype: callable
+        """
+
+        def parse(value):
+            parsed = value
+
+            for method in parse_methods:
+                parsed = method(parsed)
+
+            return parsed
+
+        return parse
+
+    @classmethod
+    def _parse_section_to_dict_with_key(cls, section_options, values_parser):
+        """Parses section options into a dictionary.
+
+        Applies a given parser to each option in a section.
+
+        :param dict section_options:
+        :param callable values_parser: function with 2 args corresponding to key, value
+        :rtype: dict
+        """
+        value = {}
+        for key, (_, val) in section_options.items():
+            value[key] = values_parser(key, val)
+        return value
+
+    @classmethod
+    def _parse_section_to_dict(cls, section_options, values_parser=None):
+        """Parses section options into a dictionary.
+
+        Optionally applies a given parser to each value.
+
+        :param dict section_options:
+        :param callable values_parser: function with 1 arg corresponding to option value
+        :rtype: dict
+        """
+        parser = (lambda _, v: values_parser(v)) if values_parser else (lambda _, v: v)
+        return cls._parse_section_to_dict_with_key(section_options, parser)
+
+    def parse_section(self, section_options) -> None:
+        """Parses configuration file section.
+
+        :param dict section_options:
+        """
+        for name, (_, value) in section_options.items():
+            with contextlib.suppress(KeyError):
+                # Keep silent for a new option may appear anytime.
+                self[name] = value
+
+    def parse(self) -> None:
+        """Parses configuration file items from one
+        or more related sections.
+
+        """
+        for section_name, section_options in self.sections.items():
+            method_postfix = ''
+            if section_name:  # [section.option] variant
+                method_postfix = f"_{section_name}"
+
+            section_parser_method: Callable | None = getattr(
+                self,
+                # Dots in section names are translated into dunderscores.
+                f'parse_section{method_postfix}'.replace('.', '__'),
+                None,
+            )
+
+            if section_parser_method is None:
+                raise OptionError(
+                    "Unsupported distribution option section: "
+                    f"[{self.section_prefix}.{section_name}]"
+                )
+
+            section_parser_method(section_options)
+
+    def _deprecated_config_handler(self, func, msg, **kw):
+        """this function will wrap around parameters that are deprecated
+
+        :param msg: deprecation message
+        :param func: function to be wrapped around
+        """
+
+        @wraps(func)
+        def config_handler(*args, **kwargs):
+            kw.setdefault("stacklevel", 2)
+            _DeprecatedConfig.emit("Deprecated config in `setup.cfg`", msg, **kw)
+            return func(*args, **kwargs)
+
+        return config_handler
+
+
+class ConfigMetadataHandler(ConfigHandler["DistributionMetadata"]):
+    section_prefix = 'metadata'
+
+    aliases = {
+        'home_page': 'url',
+        'summary': 'description',
+        'classifier': 'classifiers',
+        'platform': 'platforms',
+    }
+
+    strict_mode = False
+    """We need to keep it loose, to be partially compatible with
+    `pbr` and `d2to1` packages which also uses `metadata` section.
+
+    """
+
+    def __init__(
+        self,
+        target_obj: DistributionMetadata,
+        options: AllCommandOptions,
+        ignore_option_errors: bool,
+        ensure_discovered: expand.EnsurePackagesDiscovered,
+        package_dir: dict | None = None,
+        root_dir: StrPath | None = os.curdir,
+    ) -> None:
+        super().__init__(target_obj, options, ignore_option_errors, ensure_discovered)
+        self.package_dir = package_dir
+        self.root_dir = root_dir
+
+    @property
+    def parsers(self) -> dict[str, Callable]:
+        """Metadata item name to parser function mapping."""
+        parse_list_static = self._get_parser_compound(self._parse_list, _static.List)
+        parse_dict_static = self._get_parser_compound(self._parse_dict, _static.Dict)
+        parse_file = partial(self._parse_file, root_dir=self.root_dir)
+        exclude_files_parser = self._exclude_files_parser
+
+        return {
+            'author': _static.Str,
+            'author_email': _static.Str,
+            'maintainer': _static.Str,
+            'maintainer_email': _static.Str,
+            'platforms': parse_list_static,
+            'keywords': parse_list_static,
+            'provides': parse_list_static,
+            'obsoletes': parse_list_static,
+            'classifiers': self._get_parser_compound(parse_file, parse_list_static),
+            'license': exclude_files_parser('license'),
+            'license_files': parse_list_static,
+            'description': parse_file,
+            'long_description': parse_file,
+            'long_description_content_type': _static.Str,
+            'version': self._parse_version,  # Cannot be marked as dynamic
+            'url': _static.Str,
+            'project_urls': parse_dict_static,
+        }
+
+    def _parse_version(self, value):
+        """Parses `version` option value.
+
+        :param value:
+        :rtype: str
+
+        """
+        version = self._parse_file(value, self.root_dir)
+
+        if version != value:
+            version = version.strip()
+            # Be strict about versions loaded from file because it's easy to
+            # accidentally include newlines and other unintended content
+            try:
+                Version(version)
+            except InvalidVersion as e:
+                raise OptionError(
+                    f'Version loaded from {value} does not '
+                    f'comply with PEP 440: {version}'
+                ) from e
+
+            return version
+
+        return expand.version(self._parse_attr(value, self.package_dir, self.root_dir))
+
+
+class ConfigOptionsHandler(ConfigHandler["Distribution"]):
+    section_prefix = 'options'
+
+    def __init__(
+        self,
+        target_obj: Distribution,
+        options: AllCommandOptions,
+        ignore_option_errors: bool,
+        ensure_discovered: expand.EnsurePackagesDiscovered,
+    ) -> None:
+        super().__init__(target_obj, options, ignore_option_errors, ensure_discovered)
+        self.root_dir = target_obj.src_root
+        self.package_dir: dict[str, str] = {}  # To be filled by `find_packages`
+
+    @classmethod
+    def _parse_list_semicolon(cls, value):
+        return cls._parse_list(value, separator=';')
+
+    def _parse_file_in_root(self, value):
+        return self._parse_file(value, root_dir=self.root_dir)
+
+    def _parse_requirements_list(self, label: str, value: str):
+        # Parse a requirements list, either by reading in a `file:`, or a list.
+        parsed = self._parse_list_semicolon(self._parse_file_in_root(value))
+        _warn_accidental_env_marker_misconfig(label, value, parsed)
+        # Filter it to only include lines that are not comments. `parse_list`
+        # will have stripped each line and filtered out empties.
+        return _static.List(line for line in parsed if not line.startswith("#"))
+        # ^-- Use `_static.List` to mark a non-`Dynamic` Core Metadata
+
+    @property
+    def parsers(self) -> dict[str, Callable]:
+        """Metadata item name to parser function mapping."""
+        parse_list = self._parse_list
+        parse_bool = self._parse_bool
+        parse_cmdclass = self._parse_cmdclass
+
+        return {
+            'zip_safe': parse_bool,
+            'include_package_data': parse_bool,
+            'package_dir': self._parse_dict,
+            'scripts': parse_list,
+            'eager_resources': parse_list,
+            'dependency_links': parse_list,
+            'namespace_packages': self._deprecated_config_handler(
+                parse_list,
+                "The namespace_packages parameter is deprecated, "
+                "consider using implicit namespaces instead (PEP 420).",
+                # TODO: define due date, see setuptools.dist:check_nsp.
+            ),
+            'install_requires': partial(  # Core Metadata
+                self._parse_requirements_list, "install_requires"
+            ),
+            'setup_requires': self._parse_list_semicolon,
+            'packages': self._parse_packages,
+            'entry_points': self._parse_file_in_root,
+            'py_modules': parse_list,
+            'python_requires': _static.SpecifierSet,  # Core Metadata
+            'cmdclass': parse_cmdclass,
+        }
+
+    def _parse_cmdclass(self, value):
+        package_dir = self.ensure_discovered.package_dir
+        return expand.cmdclass(self._parse_dict(value), package_dir, self.root_dir)
+
+    def _parse_packages(self, value):
+        """Parses `packages` option value.
+
+        :param value:
+        :rtype: list
+        """
+        find_directives = ['find:', 'find_namespace:']
+        trimmed_value = value.strip()
+
+        if trimmed_value not in find_directives:
+            return self._parse_list(value)
+
+        # Read function arguments from a dedicated section.
+        find_kwargs = self.parse_section_packages__find(
+            self.sections.get('packages.find', {})
+        )
+
+        find_kwargs.update(
+            namespaces=(trimmed_value == find_directives[1]),
+            root_dir=self.root_dir,
+            fill_package_dir=self.package_dir,
+        )
+
+        return expand.find_packages(**find_kwargs)
+
+    def parse_section_packages__find(self, section_options):
+        """Parses `packages.find` configuration file section.
+
+        To be used in conjunction with _parse_packages().
+
+        :param dict section_options:
+        """
+        section_data = self._parse_section_to_dict(section_options, self._parse_list)
+
+        valid_keys = ['where', 'include', 'exclude']
+        find_kwargs = {k: v for k, v in section_data.items() if k in valid_keys and v}
+
+        where = find_kwargs.get('where')
+        if where is not None:
+            find_kwargs['where'] = where[0]  # cast list to single val
+
+        return find_kwargs
+
+    def parse_section_entry_points(self, section_options) -> None:
+        """Parses `entry_points` configuration file section.
+
+        :param dict section_options:
+        """
+        parsed = self._parse_section_to_dict(section_options, self._parse_list)
+        self['entry_points'] = parsed
+
+    def _parse_package_data(self, section_options):
+        package_data = self._parse_section_to_dict(section_options, self._parse_list)
+        return expand.canonic_package_data(package_data)
+
+    def parse_section_package_data(self, section_options) -> None:
+        """Parses `package_data` configuration file section.
+
+        :param dict section_options:
+        """
+        self['package_data'] = self._parse_package_data(section_options)
+
+    def parse_section_exclude_package_data(self, section_options) -> None:
+        """Parses `exclude_package_data` configuration file section.
+
+        :param dict section_options:
+        """
+        self['exclude_package_data'] = self._parse_package_data(section_options)
+
+    def parse_section_extras_require(self, section_options) -> None:  # Core Metadata
+        """Parses `extras_require` configuration file section.
+
+        :param dict section_options:
+        """
+        parsed = self._parse_section_to_dict_with_key(
+            section_options,
+            lambda k, v: self._parse_requirements_list(f"extras_require[{k}]", v),
+        )
+
+        self['extras_require'] = _static.Dict(parsed)
+        # ^-- Use `_static.Dict` to mark a non-`Dynamic` Core Metadata
+
+    def parse_section_data_files(self, section_options) -> None:
+        """Parses `data_files` configuration file section.
+
+        :param dict section_options:
+        """
+        parsed = self._parse_section_to_dict(section_options, self._parse_list)
+        self['data_files'] = expand.canonic_data_files(parsed, self.root_dir)
+
+
+class _AmbiguousMarker(SetuptoolsDeprecationWarning):
+    _SUMMARY = "Ambiguous requirement marker."
+    _DETAILS = """
+    One of the parsed requirements in `{field}` looks like a valid environment marker:
+
+        {req!r}
+
+    Please make sure that the configuration file is correct.
+    You can use dangling lines to avoid this problem.
+    """
+    _SEE_DOCS = "userguide/declarative_config.html#opt-2"
+    # TODO: should we include due_date here? Initially introduced in 6 Aug 2022.
+    # Does this make sense with latest version of packaging?
+
+    @classmethod
+    def message(cls, **kw):
+        docs = f"https://setuptools.pypa.io/en/latest/{cls._SEE_DOCS}"
+        return cls._format(cls._SUMMARY, cls._DETAILS, see_url=docs, format_args=kw)
+
+
+class _DeprecatedConfig(SetuptoolsDeprecationWarning):
+    _SEE_DOCS = "userguide/declarative_config.html"
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/config/setuptools.schema.json b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/setuptools.schema.json
new file mode 100644
index 0000000000000000000000000000000000000000..6146abde60cf74089882b8d60bcdcbf60f8cedc0
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/config/setuptools.schema.json
@@ -0,0 +1,433 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+
+  "$id": "https://setuptools.pypa.io/en/latest/userguide/pyproject_config.html",
+  "title": "``tool.setuptools`` table",
+  "$$description": [
+    "``setuptools``-specific configurations that can be set by users that require",
+    "customization.",
+    "These configurations are completely optional and probably can be skipped when",
+    "creating simple packages. They are equivalent to some of the `Keywords",
+    "`_",
+    "used by the ``setup.py`` file, and can be set via the ``tool.setuptools`` table.",
+    "It considers only ``setuptools`` `parameters",
+    "`_",
+    "that are not covered by :pep:`621`; and intentionally excludes ``dependency_links``",
+    "and ``setup_requires`` (incompatible with modern workflows/standards)."
+  ],
+
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "platforms": {
+      "type": "array",
+      "items": {"type": "string"}
+    },
+    "provides": {
+      "$$description": [
+        "Package and virtual package names contained within this package",
+        "**(not supported by pip)**"
+      ],
+      "type": "array",
+      "items": {"type": "string", "format": "pep508-identifier"}
+    },
+    "obsoletes": {
+      "$$description": [
+        "Packages which this package renders obsolete",
+        "**(not supported by pip)**"
+      ],
+      "type": "array",
+      "items": {"type": "string", "format": "pep508-identifier"}
+    },
+    "zip-safe": {
+      "$$description": [
+        "Whether the project can be safely installed and run from a zip file.",
+        "**OBSOLETE**: only relevant for ``pkg_resources``, ``easy_install`` and",
+        "``setup.py install`` in the context of ``eggs`` (**DEPRECATED**)."
+      ],
+      "type": "boolean"
+    },
+    "script-files": {
+      "$$description": [
+        "Legacy way of defining scripts (entry-points are preferred).",
+        "Equivalent to the ``script`` keyword in ``setup.py``",
+        "(it was renamed to avoid confusion with entry-point based ``project.scripts``",
+        "defined in :pep:`621`).",
+        "**DISCOURAGED**: generic script wrappers are tricky and may not work properly.",
+        "Whenever possible, please use ``project.scripts`` instead."
+      ],
+      "type": "array",
+      "items": {"type": "string"},
+      "$comment": "TODO: is this field deprecated/should be removed?"
+    },
+    "eager-resources": {
+      "$$description": [
+        "Resources that should be extracted together, if any of them is needed,",
+        "or if any C extensions included in the project are imported.",
+        "**OBSOLETE**: only relevant for ``pkg_resources``, ``easy_install`` and",
+        "``setup.py install`` in the context of ``eggs`` (**DEPRECATED**)."
+      ],
+      "type": "array",
+      "items": {"type": "string"}
+    },
+    "packages": {
+      "$$description": [
+        "Packages that should be included in the distribution.",
+        "It can be given either as a list of package identifiers",
+        "or as a ``dict``-like structure with a single key ``find``",
+        "which corresponds to a dynamic call to",
+        "``setuptools.config.expand.find_packages`` function.",
+        "The ``find`` key is associated with a nested ``dict``-like structure that can",
+        "contain ``where``, ``include``, ``exclude`` and ``namespaces`` keys,",
+        "mimicking the keyword arguments of the associated function."
+      ],
+      "oneOf": [
+        {
+          "title": "Array of Python package identifiers",
+          "type": "array",
+          "items": {"$ref": "#/definitions/package-name"}
+        },
+        {"$ref": "#/definitions/find-directive"}
+      ]
+    },
+    "package-dir": {
+      "$$description": [
+        ":class:`dict`-like structure mapping from package names to directories where their",
+        "code can be found.",
+        "The empty string (as key) means that all packages are contained inside",
+        "the given directory will be included in the distribution."
+      ],
+      "type": "object",
+      "additionalProperties": false,
+      "propertyNames": {
+        "anyOf": [{"const": ""}, {"$ref": "#/definitions/package-name"}]
+      },
+      "patternProperties": {
+        "^.*$": {"type": "string" }
+      }
+    },
+    "package-data": {
+      "$$description": [
+        "Mapping from package names to lists of glob patterns.",
+        "Usually this option is not needed when using ``include-package-data = true``",
+        "For more information on how to include data files, check ``setuptools`` `docs",
+        "`_."
+      ],
+      "type": "object",
+      "additionalProperties": false,
+      "propertyNames": {
+        "anyOf": [{"$ref": "#/definitions/package-name"}, {"const": "*"}]
+      },
+      "patternProperties": {
+        "^.*$": {"type": "array", "items": {"type": "string"}}
+      }
+    },
+    "include-package-data": {
+      "$$description": [
+        "Automatically include any data files inside the package directories",
+        "that are specified by ``MANIFEST.in``",
+        "For more information on how to include data files, check ``setuptools`` `docs",
+        "`_."
+      ],
+      "type": "boolean"
+    },
+    "exclude-package-data": {
+      "$$description": [
+        "Mapping from package names to lists of glob patterns that should be excluded",
+        "For more information on how to include data files, check ``setuptools`` `docs",
+        "`_."
+      ],
+      "type": "object",
+      "additionalProperties": false,
+      "propertyNames": {
+        "anyOf": [{"$ref": "#/definitions/package-name"}, {"const": "*"}]
+      },
+      "patternProperties": {
+          "^.*$": {"type": "array", "items": {"type": "string"}}
+      }
+    },
+    "namespace-packages": {
+      "type": "array",
+      "items": {"type": "string", "format": "python-module-name-relaxed"},
+      "$comment": "https://setuptools.pypa.io/en/latest/userguide/package_discovery.html",
+      "description": "**DEPRECATED**: use implicit namespaces instead (:pep:`420`)."
+    },
+    "py-modules": {
+      "description": "Modules that setuptools will manipulate",
+      "type": "array",
+      "items": {"type": "string", "format": "python-module-name-relaxed"},
+      "$comment": "TODO: clarify the relationship with ``packages``"
+    },
+    "ext-modules": {
+      "description": "Extension modules to be compiled by setuptools",
+      "type": "array",
+      "items": {"$ref": "#/definitions/ext-module"}
+    },
+    "data-files": {
+      "$$description": [
+        "``dict``-like structure where each key represents a directory and",
+        "the value is a list of glob patterns that should be installed in them.",
+        "**DISCOURAGED**: please notice this might not work as expected with wheels.",
+        "Whenever possible, consider using data files inside the package directories",
+        "(or create a new namespace package that only contains data files).",
+        "See `data files support",
+        "`_."
+      ],
+      "type": "object",
+      "patternProperties": {
+          "^.*$": {"type": "array", "items": {"type": "string"}}
+      }
+    },
+    "cmdclass": {
+      "$$description": [
+        "Mapping of distutils-style command names to ``setuptools.Command`` subclasses",
+        "which in turn should be represented by strings with a qualified class name",
+        "(i.e., \"dotted\" form with module), e.g.::\n\n",
+        "    cmdclass = {mycmd = \"pkg.subpkg.module.CommandClass\"}\n\n",
+        "The command class should be a directly defined at the top-level of the",
+        "containing module (no class nesting)."
+      ],
+      "type": "object",
+      "patternProperties": {
+          "^.*$": {"type": "string", "format": "python-qualified-identifier"}
+      }
+    },
+    "license-files": {
+      "type": "array",
+      "items": {"type": "string"},
+      "$$description": [
+        "**PROVISIONAL**: list of glob patterns for all license files being distributed.",
+        "(likely to become standard with :pep:`639`).",
+        "By default: ``['LICEN[CS]E*', 'COPYING*', 'NOTICE*', 'AUTHORS*']``"
+      ],
+      "$comment": "TODO: revise if PEP 639 is accepted. Probably ``project.license-files``?"
+    },
+    "dynamic": {
+      "type": "object",
+      "description": "Instructions for loading :pep:`621`-related metadata dynamically",
+      "additionalProperties": false,
+      "properties": {
+        "version": {
+          "$$description": [
+            "A version dynamically loaded via either the ``attr:`` or ``file:``",
+            "directives. Please make sure the given file or attribute respects :pep:`440`.",
+            "Also ensure to set ``project.dynamic`` accordingly."
+          ],
+          "oneOf": [
+            {"$ref": "#/definitions/attr-directive"},
+            {"$ref": "#/definitions/file-directive"}
+          ]
+        },
+        "classifiers": {"$ref": "#/definitions/file-directive"},
+        "description": {"$ref": "#/definitions/file-directive"},
+        "entry-points": {"$ref": "#/definitions/file-directive"},
+        "dependencies": {"$ref": "#/definitions/file-directive-for-dependencies"},
+        "optional-dependencies": {
+          "type": "object",
+          "propertyNames": {"type": "string", "format": "pep508-identifier"},
+          "additionalProperties": false,
+          "patternProperties": {
+            ".+": {"$ref": "#/definitions/file-directive-for-dependencies"}
+          }
+        },
+        "readme": {
+          "type": "object",
+          "anyOf": [
+            {"$ref": "#/definitions/file-directive"},
+            {
+              "type": "object",
+              "properties": {
+                "content-type": {"type": "string"},
+                "file": { "$ref": "#/definitions/file-directive/properties/file" }
+              },
+              "additionalProperties": false}
+          ],
+          "required": ["file"]
+        }
+      }
+    }
+  },
+
+  "definitions": {
+    "package-name": {
+      "$id": "#/definitions/package-name",
+      "title": "Valid package name",
+      "description": "Valid package name (importable or :pep:`561`).",
+      "type": "string",
+      "anyOf": [
+        {"type": "string", "format": "python-module-name-relaxed"},
+        {"type": "string", "format": "pep561-stub-name"}
+      ]
+    },
+    "ext-module": {
+      "$id": "#/definitions/ext-module",
+      "title": "Extension module",
+      "description": "Parameters to construct a :class:`setuptools.Extension` object",
+      "type": "object",
+      "required": ["name", "sources"],
+      "additionalProperties": false,
+      "properties": {
+        "name": {
+          "type": "string",
+          "format": "python-module-name-relaxed"
+        },
+        "sources": {
+          "type": "array",
+          "items": {"type": "string"}
+        },
+        "include-dirs":{
+          "type": "array",
+          "items": {"type": "string"}
+        },
+        "define-macros": {
+          "type": "array",
+          "items": {
+            "type": "array",
+            "items": [
+              {"description": "macro name", "type": "string"},
+              {"description": "macro value", "oneOf": [{"type": "string"}, {"type": "null"}]}
+            ],
+            "additionalItems": false
+          }
+        },
+        "undef-macros": {
+          "type": "array",
+          "items": {"type": "string"}
+        },
+        "library-dirs": {
+          "type": "array",
+          "items": {"type": "string"}
+        },
+        "libraries": {
+          "type": "array",
+          "items": {"type": "string"}
+        },
+        "runtime-library-dirs": {
+          "type": "array",
+          "items": {"type": "string"}
+        },
+        "extra-objects": {
+          "type": "array",
+          "items": {"type": "string"}
+        },
+        "extra-compile-args": {
+          "type": "array",
+          "items": {"type": "string"}
+        },
+        "extra-link-args": {
+          "type": "array",
+          "items": {"type": "string"}
+        },
+        "export-symbols": {
+          "type": "array",
+          "items": {"type": "string"}
+        },
+        "swig-opts": {
+          "type": "array",
+          "items": {"type": "string"}
+        },
+        "depends": {
+          "type": "array",
+          "items": {"type": "string"}
+        },
+        "language": {"type": "string"},
+        "optional": {"type": "boolean"},
+        "py-limited-api": {"type": "boolean"}
+      }
+    },
+    "file-directive": {
+      "$id": "#/definitions/file-directive",
+      "title": "'file:' directive",
+      "description":
+        "Value is read from a file (or list of files and then concatenated)",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "file": {
+          "oneOf": [
+            {"type": "string"},
+            {"type": "array", "items": {"type": "string"}}
+          ]
+        }
+      },
+      "required": ["file"]
+    },
+    "file-directive-for-dependencies": {
+      "title": "'file:' directive for dependencies",
+      "allOf": [
+        {
+          "$$description": [
+            "**BETA**: subset of the ``requirements.txt`` format",
+            "without ``pip`` flags and options",
+            "(one :pep:`508`-compliant string per line,",
+            "lines that are blank or start with ``#`` are excluded).",
+            "See `dynamic metadata",
+            "`_."
+          ]
+        },
+        {"$ref": "#/definitions/file-directive"}
+      ]
+    },
+    "attr-directive": {
+      "title": "'attr:' directive",
+      "$id": "#/definitions/attr-directive",
+      "$$description": [
+        "Value is read from a module attribute. Supports callables and iterables;",
+        "unsupported types are cast via ``str()``"
+      ],
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "attr": {"type": "string", "format": "python-qualified-identifier"}
+      },
+      "required": ["attr"]
+    },
+    "find-directive": {
+      "$id": "#/definitions/find-directive",
+      "title": "'find:' directive",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "find": {
+          "type": "object",
+          "$$description": [
+            "Dynamic `package discovery",
+            "`_."
+          ],
+          "additionalProperties": false,
+          "properties": {
+            "where": {
+              "description":
+                "Directories to be searched for packages (Unix-style relative path)",
+              "type": "array",
+              "items": {"type": "string"}
+            },
+            "exclude": {
+              "type": "array",
+              "$$description": [
+                "Exclude packages that match the values listed in this field.",
+                "Can container shell-style wildcards (e.g. ``'pkg.*'``)"
+              ],
+              "items": {"type": "string"}
+            },
+            "include": {
+              "type": "array",
+              "$$description": [
+                "Restrict the found packages to just the ones listed in this field.",
+                "Can container shell-style wildcards (e.g. ``'pkg.*'``)"
+              ],
+              "items": {"type": "string"}
+            },
+            "namespaces": {
+              "type": "boolean",
+              "$$description": [
+                "When ``True``, directories without a ``__init__.py`` file will also",
+                "be scanned for :pep:`420`-style implicit namespaces"
+              ]
+            }
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f46b9332e158b8a716be7bc75f3a926f41f1770a
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/contexts.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/contexts.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..909db1821847340f97e32c04740f185369c670de
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/contexts.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/environment.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/environment.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9f3486c4302041bfd703191c59ccc5bf4086f1fe
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/environment.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/fixtures.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/fixtures.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c40c3290a8c56632c257dd5476713bf3dcd1239c
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/fixtures.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/mod_with_constant.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/mod_with_constant.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5fc14633fedb871469aecfcdc3358dad8dfe5c89
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/mod_with_constant.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/namespaces.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/namespaces.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f76d8fb1e17b9fb837b313ad33c017d510ba3bb0
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/namespaces.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/script-with-bom.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/script-with-bom.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..02f018bc81b32b69dfc4a1be142e928584994c36
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/script-with-bom.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_archive_util.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_archive_util.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ed3b8f182ea183c103d7688b0656f673aeae2490
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_archive_util.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_bdist_deprecations.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_bdist_deprecations.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5b787e4d2e0de76ecf8898c6bec9cd85b1b225ae
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_bdist_deprecations.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_bdist_egg.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_bdist_egg.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6355dceb34aa51b320e3a58b6d43054119b4e3c4
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_bdist_egg.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_bdist_wheel.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_bdist_wheel.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c2c77c1e5897b76634aa1b9a9cf53c514c4209fe
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_bdist_wheel.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_build.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_build.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..07029976b46c31f9abc65ae837b54262413e8ea5
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_build.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_build_clib.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_build_clib.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3b1df86c935563729a88e44b0373be4775a4ef4f
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_build_clib.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_build_ext.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_build_ext.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..07384b781d0d07fe3576447c4724e2f841518363
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_build_ext.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_build_meta.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_build_meta.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..35ca451fedcb28a06741583321f4f996dceb18f0
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_build_meta.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_build_py.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_build_py.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..30022a7b49248ee5b4650103a08720107c0d5219
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_build_py.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_config_discovery.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_config_discovery.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fa98c00c9614df5044b1e304f4b58ddf962853e8
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_config_discovery.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_core_metadata.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_core_metadata.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5c223e8f07b569118037b00b164020ce3eea9f99
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_core_metadata.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_depends.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_depends.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..422f0020aeb4f7b6e8ec7050c7b4a2897df589e6
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_depends.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_develop.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_develop.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d7af40f3931cf3047806ca87ad02a0bd4f520ce3
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_develop.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_dist.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_dist.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1529f9e45369ef182f9141193fc0e6db53dfe27c
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_dist.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_dist_info.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_dist_info.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..44df415f18c50ea7f3bc7cc8613ee1b525dcf200
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_dist_info.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_distutils_adoption.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_distutils_adoption.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3daf4a27bbfa636badf8bf4029d654559fea92a5
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_distutils_adoption.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_editable_install.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_editable_install.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..29659c4188a14ff6ebaec0752b64c5745929d560
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_editable_install.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_egg_info.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_egg_info.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..18ae574b005d7d370c83fe064f2ce14492a8569f
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_egg_info.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_extern.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_extern.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..74aaa27644e06868085c03e7121e4d7adffb1c59
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_extern.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_find_packages.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_find_packages.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bdd3cb6ae45dec5c61cc7542e4df4bf29eabf001
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_find_packages.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_find_py_modules.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_find_py_modules.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2f7237a0d4059931f0302aee3cf20b3d72c25967
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_find_py_modules.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_glob.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_glob.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e540e995367b1982b7522e487f16974760e4775b
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_glob.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_install_scripts.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_install_scripts.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8e8037d2462e37e04e48091399c3e3f49f626847
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_install_scripts.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_logging.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_logging.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bd3e3458a81f0dd3e4bcae3ddf1e35fd33592054
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_logging.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_manifest.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_manifest.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e5bd1f508d87700dd5a13c1eb1d4ea4f67948609
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_manifest.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_namespaces.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_namespaces.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..23028d0211a26cb2c072d21d8ed99cfd3467e0f0
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_namespaces.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_scripts.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_scripts.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..35d9b1cc20aefd22dafcb635fa5c206ad99a76c4
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_scripts.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_sdist.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_sdist.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3967af950462e06fe26c51bcd0e0ff9cae439bea
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_sdist.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_setopt.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_setopt.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..87d61508f5b776c90b0585b6bf3654010fb2e7e3
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_setopt.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_setuptools.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_setuptools.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9c75c9d866b619f94e8a48fe3041f047aeb414b4
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_setuptools.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_shutil_wrapper.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_shutil_wrapper.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..233cd2863a5ccfc7492697111de6f3a32b7954dd
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_shutil_wrapper.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_unicode_utils.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_unicode_utils.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b0d386135c217fd322c0451ab560cf57437bb0ec
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_unicode_utils.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_virtualenv.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_virtualenv.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..77e1fcd68337b4810fbd80312bcc0d9edf607064
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_virtualenv.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_warnings.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_warnings.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a4e591f49dac63a08d33a89d6666abbfe59ebb1c
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_warnings.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_wheel.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_wheel.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0a533425c558d41feddd47bc2a028337a6cf6076
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_wheel.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_windows_wrappers.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_windows_wrappers.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..729778c29fc8842963dcfda9728f4a4ea58f15a6
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/test_windows_wrappers.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/text.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/text.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..53f15ebe1a379e8e424c382fc2d5757c3b1720cb
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/text.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/textwrap.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/textwrap.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..00e8abb2e9f4f1e23ebc544db7c5b95ed5a78bad
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/__pycache__/textwrap.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/compat/__init__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/compat/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/compat/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/compat/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..54b91e6d8962d0958fc06e6a33bb8d7d4ba38566
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/compat/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/compat/__pycache__/py39.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/compat/__pycache__/py39.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b5e209674b64e308fc6490ba6b0f816c70ad6e8f
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/compat/__pycache__/py39.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/compat/py39.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/compat/py39.py
new file mode 100644
index 0000000000000000000000000000000000000000..1fdb9dac1fa3f121a634082515d1a305fc09793c
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/compat/py39.py
@@ -0,0 +1,3 @@
+from jaraco.test.cpython import from_test_support, try_import
+
+os_helper = try_import('os_helper') or from_test_support('can_symlink')
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/__init__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9beb46cc5686207d8dbc0627e414f85e1db4603e
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/__pycache__/test_apply_pyprojecttoml.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/__pycache__/test_apply_pyprojecttoml.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..23ca35e3149d0749db6cbd90ce480bdb4ec1bce3
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/__pycache__/test_apply_pyprojecttoml.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/__pycache__/test_expand.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/__pycache__/test_expand.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7d96d938f173d189e9c2e59511ee97b306304f17
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/__pycache__/test_expand.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/__pycache__/test_pyprojecttoml.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/__pycache__/test_pyprojecttoml.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f4a634304bf08e18bec14661900d0eb14408cbf1
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/__pycache__/test_pyprojecttoml.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/__pycache__/test_pyprojecttoml_dynamic_deps.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/__pycache__/test_pyprojecttoml_dynamic_deps.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..db3ee3eb9073e443975819a5f46ef0f4a7062a1c
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/__pycache__/test_pyprojecttoml_dynamic_deps.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/__pycache__/test_setupcfg.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/__pycache__/test_setupcfg.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6ab1392a0d97d8d1c4ae826cacd005bd1e8dbff4
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/__pycache__/test_setupcfg.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/downloads/__init__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/downloads/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..00a16423f448e7773f5e6dc9b365efe80f40a778
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/downloads/__init__.py
@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import re
+import time
+from pathlib import Path
+from urllib.error import HTTPError
+from urllib.request import urlopen
+
+__all__ = ["DOWNLOAD_DIR", "retrieve_file", "output_file", "urls_from_file"]
+
+
+NAME_REMOVE = ("http://", "https://", "github.com/", "/raw/")
+DOWNLOAD_DIR = Path(__file__).parent
+
+
+# ----------------------------------------------------------------------
+# Please update ./preload.py accordingly when modifying this file
+# ----------------------------------------------------------------------
+
+
+def output_file(url: str, download_dir: Path = DOWNLOAD_DIR) -> Path:
+    file_name = url.strip()
+    for part in NAME_REMOVE:
+        file_name = file_name.replace(part, '').strip().strip('/:').strip()
+    return Path(download_dir, re.sub(r"[^\-_\.\w\d]+", "_", file_name))
+
+
+def retrieve_file(url: str, download_dir: Path = DOWNLOAD_DIR, wait: float = 5) -> Path:
+    path = output_file(url, download_dir)
+    if path.exists():
+        print(f"Skipping {url} (already exists: {path})")
+    else:
+        download_dir.mkdir(exist_ok=True, parents=True)
+        print(f"Downloading {url} to {path}")
+        try:
+            download(url, path)
+        except HTTPError:
+            time.sleep(wait)  # wait a few seconds and try again.
+            download(url, path)
+    return path
+
+
+def urls_from_file(list_file: Path) -> list[str]:
+    """``list_file`` should be a text file where each line corresponds to a URL to
+    download.
+    """
+    print(f"file: {list_file}")
+    content = list_file.read_text(encoding="utf-8")
+    return [url for url in content.splitlines() if not url.startswith("#")]
+
+
+def download(url: str, dest: Path):
+    with urlopen(url) as f:
+        data = f.read()
+
+    with open(dest, "wb") as f:
+        f.write(data)
+
+    assert Path(dest).exists()
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/downloads/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/downloads/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2a9c2d0f1ff48f102f25425c5957dba2ddb5c7d5
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/downloads/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/downloads/__pycache__/preload.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/downloads/__pycache__/preload.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..509ee9ea00e776d17565848d024242b9c6626c17
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/downloads/__pycache__/preload.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/downloads/preload.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/downloads/preload.py
new file mode 100644
index 0000000000000000000000000000000000000000..8eeb5dd75d3dcb375cee5acaf11ad385084bff5a
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/downloads/preload.py
@@ -0,0 +1,18 @@
+"""This file can be used to preload files needed for testing.
+
+For example you can use::
+
+    cd setuptools/tests/config
+    python -m downloads.preload setupcfg_examples.txt
+
+to make sure the `setup.cfg` examples are downloaded before starting the tests.
+"""
+
+import sys
+from pathlib import Path
+
+from . import retrieve_file, urls_from_file
+
+if __name__ == "__main__":
+    urls = urls_from_file(Path(sys.argv[1]))
+    list(map(retrieve_file, urls))
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/setupcfg_examples.txt b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/setupcfg_examples.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6aab887ff1fe631d97f1abea90a8448040746a12
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/setupcfg_examples.txt
@@ -0,0 +1,22 @@
+# ====================================================================
+# Some popular packages that use setup.cfg (and others not so popular)
+# Reference: https://hugovk.github.io/top-pypi-packages/
+# ====================================================================
+https://github.com/pypa/setuptools/raw/52c990172fec37766b3566679724aa8bf70ae06d/setup.cfg
+https://github.com/pypa/wheel/raw/0acd203cd896afec7f715aa2ff5980a403459a3b/setup.cfg
+https://github.com/python/importlib_metadata/raw/2f05392ca980952a6960d82b2f2d2ea10aa53239/setup.cfg
+https://github.com/jaraco/skeleton/raw/d9008b5c510cd6969127a6a2ab6f832edddef296/setup.cfg
+https://github.com/jaraco/zipp/raw/700d3a96390e970b6b962823bfea78b4f7e1c537/setup.cfg
+https://github.com/pallets/jinja/raw/7d72eb7fefb7dce065193967f31f805180508448/setup.cfg
+https://github.com/tkem/cachetools/raw/2fd87a94b8d3861d80e9e4236cd480bfdd21c90d/setup.cfg
+https://github.com/aio-libs/aiohttp/raw/5e0e6b7080f2408d5f1dd544c0e1cf88378b7b10/setup.cfg
+https://github.com/pallets/flask/raw/9486b6cf57bd6a8a261f67091aca8ca78eeec1e3/setup.cfg
+https://github.com/pallets/click/raw/6411f425fae545f42795665af4162006b36c5e4a/setup.cfg
+https://github.com/sqlalchemy/sqlalchemy/raw/533f5718904b620be8d63f2474229945d6f8ba5d/setup.cfg
+https://github.com/pytest-dev/pluggy/raw/461ef63291d13589c4e21aa182cd1529257e9a0a/setup.cfg
+https://github.com/pytest-dev/pytest/raw/c7be96dae487edbd2f55b561b31b68afac1dabe6/setup.cfg
+https://github.com/platformdirs/platformdirs/raw/7b7852128dd6f07511b618d6edea35046bd0c6ff/setup.cfg
+https://github.com/pandas-dev/pandas/raw/bc17343f934a33dc231c8c74be95d8365537c376/setup.cfg
+https://github.com/django/django/raw/4e249d11a6e56ca8feb4b055b681cec457ef3a3d/setup.cfg
+https://github.com/pyscaffold/pyscaffold/raw/de7aa5dc059fbd04307419c667cc4961bc9df4b8/setup.cfg
+https://github.com/pypa/virtualenv/raw/f92eda6e3da26a4d28c2663ffb85c4960bdb990c/setup.cfg
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/test_apply_pyprojecttoml.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/test_apply_pyprojecttoml.py
new file mode 100644
index 0000000000000000000000000000000000000000..b6b21a3e9bb176b06208a1e9d4c6424aa77d0e82
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/test_apply_pyprojecttoml.py
@@ -0,0 +1,794 @@
+"""Make sure that applying the configuration from pyproject.toml is equivalent to
+applying a similar configuration from setup.cfg
+
+To run these tests offline, please have a look on ``./downloads/preload.py``
+"""
+
+from __future__ import annotations
+
+import io
+import re
+import tarfile
+from inspect import cleandoc
+from pathlib import Path
+from unittest.mock import Mock
+
+import pytest
+from ini2toml.api import LiteTranslator
+from packaging.metadata import Metadata
+
+import setuptools  # noqa: F401 # ensure monkey patch to metadata
+from setuptools._static import is_static
+from setuptools.command.egg_info import write_requirements
+from setuptools.config import expand, pyprojecttoml, setupcfg
+from setuptools.config._apply_pyprojecttoml import _MissingDynamic, _some_attrgetter
+from setuptools.dist import Distribution
+from setuptools.errors import InvalidConfigError, RemovedConfigError
+from setuptools.warnings import InformationOnly, SetuptoolsDeprecationWarning
+
+from .downloads import retrieve_file, urls_from_file
+
+HERE = Path(__file__).parent
+EXAMPLES_FILE = "setupcfg_examples.txt"
+
+
+def makedist(path, **attrs):
+    return Distribution({"src_root": path, **attrs})
+
+
+def _mock_expand_patterns(patterns, *_, **__):
+    """
+    Allow comparing the given patterns for 2 dist objects.
+    We need to strip special chars to avoid errors when validating.
+    """
+    return [
+        re.sub("[^a-z0-9]+", "", p, flags=re.IGNORECASE) or "empty" for p in patterns
+    ]
+
+
+@pytest.mark.parametrize("url", urls_from_file(HERE / EXAMPLES_FILE))
+@pytest.mark.filterwarnings("ignore")
+@pytest.mark.uses_network
+def test_apply_pyproject_equivalent_to_setupcfg(url, monkeypatch, tmp_path):
+    monkeypatch.setattr(expand, "read_attr", Mock(return_value="0.0.1"))
+    monkeypatch.setattr(
+        Distribution, "_expand_patterns", Mock(side_effect=_mock_expand_patterns)
+    )
+    setupcfg_example = retrieve_file(url)
+    pyproject_example = Path(tmp_path, "pyproject.toml")
+    setupcfg_text = setupcfg_example.read_text(encoding="utf-8")
+    toml_config = LiteTranslator().translate(setupcfg_text, "setup.cfg")
+    pyproject_example.write_text(toml_config, encoding="utf-8")
+
+    dist_toml = pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject_example)
+    dist_cfg = setupcfg.apply_configuration(makedist(tmp_path), setupcfg_example)
+
+    pkg_info_toml = core_metadata(dist_toml)
+    pkg_info_cfg = core_metadata(dist_cfg)
+    assert pkg_info_toml == pkg_info_cfg
+
+    if any(getattr(d, "license_files", None) for d in (dist_toml, dist_cfg)):
+        assert set(dist_toml.license_files) == set(dist_cfg.license_files)
+
+    if any(getattr(d, "entry_points", None) for d in (dist_toml, dist_cfg)):
+        print(dist_cfg.entry_points)
+        ep_toml = {
+            (k, *sorted(i.replace(" ", "") for i in v))
+            for k, v in dist_toml.entry_points.items()
+        }
+        ep_cfg = {
+            (k, *sorted(i.replace(" ", "") for i in v))
+            for k, v in dist_cfg.entry_points.items()
+        }
+        assert ep_toml == ep_cfg
+
+    if any(getattr(d, "package_data", None) for d in (dist_toml, dist_cfg)):
+        pkg_data_toml = {(k, *sorted(v)) for k, v in dist_toml.package_data.items()}
+        pkg_data_cfg = {(k, *sorted(v)) for k, v in dist_cfg.package_data.items()}
+        assert pkg_data_toml == pkg_data_cfg
+
+    if any(getattr(d, "data_files", None) for d in (dist_toml, dist_cfg)):
+        data_files_toml = {(k, *sorted(v)) for k, v in dist_toml.data_files}
+        data_files_cfg = {(k, *sorted(v)) for k, v in dist_cfg.data_files}
+        assert data_files_toml == data_files_cfg
+
+    assert set(dist_toml.install_requires) == set(dist_cfg.install_requires)
+    if any(getattr(d, "extras_require", None) for d in (dist_toml, dist_cfg)):
+        extra_req_toml = {(k, *sorted(v)) for k, v in dist_toml.extras_require.items()}
+        extra_req_cfg = {(k, *sorted(v)) for k, v in dist_cfg.extras_require.items()}
+        assert extra_req_toml == extra_req_cfg
+
+
+PEP621_EXAMPLE = """\
+[project]
+name = "spam"
+version = "2020.0.0"
+description = "Lovely Spam! Wonderful Spam!"
+readme = "README.rst"
+requires-python = ">=3.8"
+license-files = ["LICENSE.txt"]  # Updated to be PEP 639 compliant
+keywords = ["egg", "bacon", "sausage", "tomatoes", "Lobster Thermidor"]
+authors = [
+  {email = "hi@pradyunsg.me"},
+  {name = "Tzu-Ping Chung"}
+]
+maintainers = [
+  {name = "Brett Cannon", email = "brett@python.org"},
+  {name = "John X. Ãørçeč", email = "john@utf8.org"},
+  {name = "Γαμα קּ 東", email = "gama@utf8.org"},
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Programming Language :: Python"
+]
+
+dependencies = [
+  "httpx",
+  "gidgethub[httpx]>4.0.0",
+  "django>2.1; os_name != 'nt'",
+  "django>2.0; os_name == 'nt'"
+]
+
+[project.optional-dependencies]
+test = [
+  "pytest < 5.0.0",
+  "pytest-cov[all]"
+]
+
+[project.urls]
+homepage = "http://example.com"
+documentation = "http://readthedocs.org"
+repository = "http://github.com"
+changelog = "http://github.com/me/spam/blob/master/CHANGELOG.md"
+
+[project.scripts]
+spam-cli = "spam:main_cli"
+
+[project.gui-scripts]
+spam-gui = "spam:main_gui"
+
+[project.entry-points."spam.magical"]
+tomatoes = "spam:main_tomatoes"
+"""
+
+PEP621_INTERNATIONAL_EMAIL_EXAMPLE = """\
+[project]
+name = "spam"
+version = "2020.0.0"
+authors = [
+  {email = "hi@pradyunsg.me"},
+  {name = "Tzu-Ping Chung"}
+]
+maintainers = [
+  {name = "अंकित अहलावत", email = "ankit@example.com"},
+]
+"""
+
+PEP621_EXAMPLE_SCRIPT = """
+def main_cli(): pass
+def main_gui(): pass
+def main_tomatoes(): pass
+"""
+
+PEP639_LICENSE_TEXT = """\
+[project]
+name = "spam"
+version = "2020.0.0"
+authors = [
+  {email = "hi@pradyunsg.me"},
+  {name = "Tzu-Ping Chung"}
+]
+license = {text = "MIT"}
+"""
+
+PEP639_LICENSE_EXPRESSION = """\
+[project]
+name = "spam"
+version = "2020.0.0"
+authors = [
+  {email = "hi@pradyunsg.me"},
+  {name = "Tzu-Ping Chung"}
+]
+license = "mit or apache-2.0"  # should be normalized in metadata
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Programming Language :: Python",
+]
+"""
+
+
+def _pep621_example_project(
+    tmp_path,
+    readme="README.rst",
+    pyproject_text=PEP621_EXAMPLE,
+):
+    pyproject = tmp_path / "pyproject.toml"
+    text = pyproject_text
+    replacements = {'readme = "README.rst"': f'readme = "{readme}"'}
+    for orig, subst in replacements.items():
+        text = text.replace(orig, subst)
+    pyproject.write_text(text, encoding="utf-8")
+
+    (tmp_path / readme).write_text("hello world", encoding="utf-8")
+    (tmp_path / "LICENSE.txt").write_text("--- LICENSE stub ---", encoding="utf-8")
+    (tmp_path / "spam.py").write_text(PEP621_EXAMPLE_SCRIPT, encoding="utf-8")
+    return pyproject
+
+
+def test_pep621_example(tmp_path):
+    """Make sure the example in PEP 621 works"""
+    pyproject = _pep621_example_project(tmp_path)
+    dist = pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
+    assert set(dist.metadata.license_files) == {"LICENSE.txt"}
+
+
+@pytest.mark.parametrize(
+    ("readme", "ctype"),
+    [
+        ("Readme.txt", "text/plain"),
+        ("readme.md", "text/markdown"),
+        ("text.rst", "text/x-rst"),
+    ],
+)
+def test_readme_content_type(tmp_path, readme, ctype):
+    pyproject = _pep621_example_project(tmp_path, readme)
+    dist = pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
+    assert dist.metadata.long_description_content_type == ctype
+
+
+def test_undefined_content_type(tmp_path):
+    pyproject = _pep621_example_project(tmp_path, "README.tex")
+    with pytest.raises(ValueError, match="Undefined content type for README.tex"):
+        pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
+
+
+def test_no_explicit_content_type_for_missing_extension(tmp_path):
+    pyproject = _pep621_example_project(tmp_path, "README")
+    dist = pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
+    assert dist.metadata.long_description_content_type is None
+
+
+@pytest.mark.parametrize(
+    ("pyproject_text", "expected_maintainers_meta_value"),
+    (
+        pytest.param(
+            PEP621_EXAMPLE,
+            (
+                'Brett Cannon , "John X. Ãørçeč" , '
+                'Γαμα קּ 東 '
+            ),
+            id='non-international-emails',
+        ),
+        pytest.param(
+            PEP621_INTERNATIONAL_EMAIL_EXAMPLE,
+            'Ankit Ahlawat <अंकित@उदाहरण.भारत>',
+            marks=pytest.mark.xfail(
+                reason="CPython's `email.headerregistry.Address` only supports "
+                'RFC 5322, as of Oct 20, 2025 and latest Python 3.13.0',
+                strict=True,
+            ),
+            id='international-email',
+        ),
+    ),
+)
+def test_utf8_maintainer_in_metadata(  # issue-3663
+    expected_maintainers_meta_value,
+    pyproject_text,
+    tmp_path,
+):
+    pyproject = _pep621_example_project(
+        tmp_path,
+        "README",
+        pyproject_text=pyproject_text,
+    )
+    dist = pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
+    assert dist.metadata.maintainer_email == expected_maintainers_meta_value
+    pkg_file = tmp_path / "PKG-FILE"
+    with open(pkg_file, "w", encoding="utf-8") as fh:
+        dist.metadata.write_pkg_file(fh)
+    content = pkg_file.read_text(encoding="utf-8")
+    assert f"Maintainer-email: {expected_maintainers_meta_value}" in content
+
+
+@pytest.mark.parametrize(
+    (
+        'pyproject_text',
+        'license',
+        'license_expression',
+        'content_str',
+        'not_content_str',
+    ),
+    (
+        pytest.param(
+            PEP639_LICENSE_TEXT,
+            'MIT',
+            None,
+            'License: MIT',
+            'License-Expression: ',
+            id='license-text',
+            marks=[
+                pytest.mark.filterwarnings(
+                    "ignore:.project.license. as a TOML table is deprecated",
+                )
+            ],
+        ),
+        pytest.param(
+            PEP639_LICENSE_EXPRESSION,
+            None,
+            'MIT OR Apache-2.0',
+            'License-Expression: MIT OR Apache-2.0',
+            'License: ',
+            id='license-expression',
+        ),
+    ),
+)
+def test_license_in_metadata(
+    license,
+    license_expression,
+    content_str,
+    not_content_str,
+    pyproject_text,
+    tmp_path,
+):
+    pyproject = _pep621_example_project(
+        tmp_path,
+        "README",
+        pyproject_text=pyproject_text,
+    )
+    dist = pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
+    assert dist.metadata.license == license
+    assert dist.metadata.license_expression == license_expression
+    pkg_file = tmp_path / "PKG-FILE"
+    with open(pkg_file, "w", encoding="utf-8") as fh:
+        dist.metadata.write_pkg_file(fh)
+    content = pkg_file.read_text(encoding="utf-8")
+    assert "Metadata-Version: 2.4" in content
+    assert content_str in content
+    assert not_content_str not in content
+
+
+def test_license_classifier_with_license_expression(tmp_path):
+    text = PEP639_LICENSE_EXPRESSION.rsplit("\n", 2)[0]
+    pyproject = _pep621_example_project(
+        tmp_path,
+        "README",
+        f"{text}\n    \"License :: OSI Approved :: MIT License\"\n]",
+    )
+    msg = "License classifiers have been superseded by license expressions"
+    with pytest.raises(InvalidConfigError, match=msg) as exc:
+        pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
+
+    assert "License :: OSI Approved :: MIT License" in str(exc.value)
+
+
+def test_license_classifier_without_license_expression(tmp_path):
+    text = """\
+    [project]
+    name = "spam"
+    version = "2020.0.0"
+    license = {text = "mit or apache-2.0"}
+    classifiers = ["License :: OSI Approved :: MIT License"]
+    """
+    pyproject = _pep621_example_project(tmp_path, "README", text)
+
+    msg1 = "License classifiers are deprecated(?:.|\n)*MIT License"
+    msg2 = ".project.license. as a TOML table is deprecated"
+    with (
+        pytest.warns(SetuptoolsDeprecationWarning, match=msg1),
+        pytest.warns(SetuptoolsDeprecationWarning, match=msg2),
+    ):
+        dist = pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
+
+    # Check license classifier is still included
+    assert dist.metadata.get_classifiers() == ["License :: OSI Approved :: MIT License"]
+
+
+class TestLicenseFiles:
+    def base_pyproject(
+        self,
+        tmp_path,
+        additional_text="",
+        license_toml='license = {file = "LICENSE.txt"}\n',
+    ):
+        text = PEP639_LICENSE_EXPRESSION
+
+        # Sanity-check
+        assert 'license = "mit or apache-2.0"' in text
+        assert 'license-files' not in text
+        assert "[tool.setuptools]" not in text
+
+        text = re.sub(
+            r"(license = .*)\n",
+            license_toml,
+            text,
+            count=1,
+        )
+        assert license_toml in text  # sanity check
+        text = f"{text}\n{additional_text}\n"
+        pyproject = _pep621_example_project(tmp_path, "README", pyproject_text=text)
+        return pyproject
+
+    def base_pyproject_license_pep639(self, tmp_path, additional_text=""):
+        return self.base_pyproject(
+            tmp_path,
+            additional_text=additional_text,
+            license_toml='license = "licenseref-Proprietary"'
+            '\nlicense-files = ["_FILE*"]\n',
+        )
+
+    def test_both_license_and_license_files_defined(self, tmp_path):
+        setuptools_config = '[tool.setuptools]\nlicense-files = ["_FILE*"]'
+        pyproject = self.base_pyproject(tmp_path, setuptools_config)
+
+        (tmp_path / "_FILE.txt").touch()
+        (tmp_path / "_FILE.rst").touch()
+
+        # Would normally match the `license_files` patterns, but we want to exclude it
+        # by being explicit. On the other hand, contents should be added to `license`
+        license = tmp_path / "LICENSE.txt"
+        license.write_text("LicenseRef-Proprietary\n", encoding="utf-8")
+
+        msg1 = "'tool.setuptools.license-files' is deprecated in favor of 'project.license-files'"
+        msg2 = ".project.license. as a TOML table is deprecated"
+        with (
+            pytest.warns(SetuptoolsDeprecationWarning, match=msg1),
+            pytest.warns(SetuptoolsDeprecationWarning, match=msg2),
+        ):
+            dist = pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
+        assert set(dist.metadata.license_files) == {"_FILE.rst", "_FILE.txt"}
+        assert dist.metadata.license == "LicenseRef-Proprietary\n"
+
+    def test_both_license_and_license_files_defined_pep639(self, tmp_path):
+        # Set license and license-files
+        pyproject = self.base_pyproject_license_pep639(tmp_path)
+
+        (tmp_path / "_FILE.txt").touch()
+        (tmp_path / "_FILE.rst").touch()
+
+        msg = "Normalizing.*LicenseRef"
+        with pytest.warns(InformationOnly, match=msg):
+            dist = pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
+
+        assert set(dist.metadata.license_files) == {"_FILE.rst", "_FILE.txt"}
+        assert dist.metadata.license is None
+        assert dist.metadata.license_expression == "LicenseRef-Proprietary"
+
+    def test_license_files_defined_twice(self, tmp_path):
+        # Set project.license-files and tools.setuptools.license-files
+        setuptools_config = '[tool.setuptools]\nlicense-files = ["_FILE*"]'
+        pyproject = self.base_pyproject_license_pep639(tmp_path, setuptools_config)
+
+        msg = "'project.license-files' is defined already. Remove 'tool.setuptools.license-files'"
+        with pytest.raises(InvalidConfigError, match=msg):
+            pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
+
+    def test_default_patterns(self, tmp_path):
+        setuptools_config = '[tool.setuptools]\nzip-safe = false'
+        # ^ used just to trigger section validation
+        pyproject = self.base_pyproject(tmp_path, setuptools_config, license_toml="")
+
+        license_files = "LICENCE-a.html COPYING-abc.txt AUTHORS-xyz NOTICE,def".split()
+
+        for fname in license_files:
+            (tmp_path / fname).write_text(f"{fname}\n", encoding="utf-8")
+
+        dist = pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
+
+        assert (tmp_path / "LICENSE.txt").exists()  # from base example
+        assert set(dist.metadata.license_files) == {*license_files, "LICENSE.txt"}
+
+    def test_missing_patterns(self, tmp_path):
+        pyproject = self.base_pyproject_license_pep639(tmp_path)
+        assert list(tmp_path.glob("_FILE*")) == []  # sanity check
+
+        msg1 = "Cannot find any files for the given pattern.*"
+        msg2 = "Normalizing 'licenseref-Proprietary' to 'LicenseRef-Proprietary'"
+        with (
+            pytest.warns(SetuptoolsDeprecationWarning, match=msg1),
+            pytest.warns(InformationOnly, match=msg2),
+        ):
+            pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
+
+    def test_deprecated_file_expands_to_text(self, tmp_path):
+        """Make sure the old example with ``license = {text = ...}`` works"""
+
+        assert 'license-files = ["LICENSE.txt"]' in PEP621_EXAMPLE  # sanity check
+        text = PEP621_EXAMPLE.replace(
+            'license-files = ["LICENSE.txt"]',
+            'license = {file = "LICENSE.txt"}',
+        )
+        pyproject = _pep621_example_project(tmp_path, pyproject_text=text)
+
+        msg = ".project.license. as a TOML table is deprecated"
+        with pytest.warns(SetuptoolsDeprecationWarning, match=msg):
+            dist = pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
+
+        assert dist.metadata.license == "--- LICENSE stub ---"
+        assert set(dist.metadata.license_files) == {"LICENSE.txt"}  # auto-filled
+
+
+class TestPyModules:
+    # https://github.com/pypa/setuptools/issues/4316
+
+    def dist(self, name):
+        toml_config = f"""
+        [project]
+        name = "test"
+        version = "42.0"
+        [tool.setuptools]
+        py-modules = [{name!r}]
+        """
+        pyproject = Path("pyproject.toml")
+        pyproject.write_text(cleandoc(toml_config), encoding="utf-8")
+        return pyprojecttoml.apply_configuration(Distribution({}), pyproject)
+
+    @pytest.mark.parametrize("module", ["pip-run", "abc-d.λ-xyz-e"])
+    def test_valid_module_name(self, tmp_path, monkeypatch, module):
+        monkeypatch.chdir(tmp_path)
+        assert module in self.dist(module).py_modules
+
+    @pytest.mark.parametrize("module", ["pip run", "-pip-run", "pip-run-stubs"])
+    def test_invalid_module_name(self, tmp_path, monkeypatch, module):
+        monkeypatch.chdir(tmp_path)
+        with pytest.raises(ValueError, match="py-modules"):
+            self.dist(module).py_modules
+
+
+class TestExtModules:
+    def make_dist(self, toml_config):
+        pyproject = Path("pyproject.toml")
+        pyproject.write_text(cleandoc(toml_config), encoding="utf-8")
+        with pytest.warns(pyprojecttoml._ExperimentalConfiguration):
+            return pyprojecttoml.apply_configuration(Distribution({}), pyproject)
+
+    def test_pyproject_sets_attribute(self, tmp_path, monkeypatch):
+        monkeypatch.chdir(tmp_path)
+        toml_config = """
+        [project]
+        name = "test"
+        version = "42.0"
+        [tool.setuptools]
+        ext-modules = [
+          {name = "my.ext", sources = ["hello.c", "world.c"]}
+        ]
+        """
+        dist = self.make_dist(toml_config)
+        assert len(dist.ext_modules) == 1
+        assert dist.ext_modules[0].name == "my.ext"
+        assert set(dist.ext_modules[0].sources) == {"hello.c", "world.c"}
+
+    def test_pyproject_define_macros_as_tuples(self, tmp_path, monkeypatch):
+        # https://github.com/pypa/setuptools/issues/4810
+        monkeypatch.chdir(tmp_path)
+        toml_config = """
+        [project]
+        name = "test"
+        version = "42.0"
+        [[tool.setuptools.ext-modules]]
+        name = "my.ext"
+        sources = ["hello.c", "world.c"]
+        define-macros = [["FIRST_SINGLE"], ["SECOND_TWO", "1"]]
+        """
+        dist = self.make_dist(toml_config)
+        assert isinstance(dist.ext_modules[0].define_macros[0], tuple)
+        assert dist.ext_modules[0].define_macros[0] == ("FIRST_SINGLE",)
+        assert dist.ext_modules[0].define_macros[1] == ("SECOND_TWO", "1")
+
+
+class TestDeprecatedFields:
+    def test_namespace_packages(self, tmp_path):
+        pyproject = tmp_path / "pyproject.toml"
+        config = """
+        [project]
+        name = "myproj"
+        version = "42"
+        [tool.setuptools]
+        namespace-packages = ["myproj.pkg"]
+        """
+        pyproject.write_text(cleandoc(config), encoding="utf-8")
+        with pytest.raises(RemovedConfigError, match="namespace-packages"):
+            pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
+
+
+class TestPresetField:
+    def pyproject(self, tmp_path, dynamic, extra_content=""):
+        content = f"[project]\nname = 'proj'\ndynamic = {dynamic!r}\n"
+        if "version" not in dynamic:
+            content += "version = '42'\n"
+        file = tmp_path / "pyproject.toml"
+        file.write_text(content + extra_content, encoding="utf-8")
+        return file
+
+    @pytest.mark.parametrize(
+        ("attr", "field", "value"),
+        [
+            ("license_expression", "license", "MIT"),
+            pytest.param(
+                *("license", "license", "Not SPDX"),
+                marks=[pytest.mark.filterwarnings("ignore:.*license. overwritten")],
+            ),
+            ("classifiers", "classifiers", ["Private :: Classifier"]),
+            ("entry_points", "scripts", {"console_scripts": ["foobar=foobar:main"]}),
+            ("entry_points", "gui-scripts", {"gui_scripts": ["bazquux=bazquux:main"]}),
+            pytest.param(
+                *("install_requires", "dependencies", ["six"]),
+                marks=[
+                    pytest.mark.filterwarnings("ignore:.*install_requires. overwritten")
+                ],
+            ),
+        ],
+    )
+    def test_not_listed_in_dynamic(self, tmp_path, attr, field, value):
+        """Setuptools cannot set a field if not listed in ``dynamic``"""
+        pyproject = self.pyproject(tmp_path, [])
+        dist = makedist(tmp_path, **{attr: value})
+        msg = re.compile(f"defined outside of `pyproject.toml`:.*{field}", re.DOTALL)
+        with pytest.warns(_MissingDynamic, match=msg):
+            dist = pyprojecttoml.apply_configuration(dist, pyproject)
+
+        dist_value = _some_attrgetter(f"metadata.{attr}", attr)(dist)
+        assert not dist_value
+
+    @pytest.mark.parametrize(
+        ("attr", "field", "value"),
+        [
+            ("license_expression", "license", "MIT"),
+            ("install_requires", "dependencies", []),
+            ("extras_require", "optional-dependencies", {}),
+            ("install_requires", "dependencies", ["six"]),
+            ("classifiers", "classifiers", ["Private :: Classifier"]),
+        ],
+    )
+    def test_listed_in_dynamic(self, tmp_path, attr, field, value):
+        pyproject = self.pyproject(tmp_path, [field])
+        dist = makedist(tmp_path, **{attr: value})
+        dist = pyprojecttoml.apply_configuration(dist, pyproject)
+        dist_value = _some_attrgetter(f"metadata.{attr}", attr)(dist)
+        assert dist_value == value
+
+    def test_license_files_exempt_from_dynamic(self, monkeypatch, tmp_path):
+        """
+        license-file is currently not considered in the context of dynamic.
+        As per 2025-02-19, https://packaging.python.org/en/latest/specifications/pyproject-toml/#license-files
+        allows setuptools to fill-in `license-files` the way it sees fit:
+
+        > If the license-files key is not defined, tools can decide how to handle license files.
+        > For example they can choose not to include any files or use their own
+        > logic to discover the appropriate files in the distribution.
+
+        Using license_files from setup.py to fill-in the value is in accordance
+        with this rule.
+        """
+        monkeypatch.chdir(tmp_path)
+        pyproject = self.pyproject(tmp_path, [])
+        dist = makedist(tmp_path, license_files=["LIC*"])
+        (tmp_path / "LIC1").write_text("42", encoding="utf-8")
+        dist = pyprojecttoml.apply_configuration(dist, pyproject)
+        assert dist.metadata.license_files == ["LIC1"]
+
+    def test_warning_overwritten_dependencies(self, tmp_path):
+        src = "[project]\nname='pkg'\nversion='0.1'\ndependencies=['click']\n"
+        pyproject = tmp_path / "pyproject.toml"
+        pyproject.write_text(src, encoding="utf-8")
+        dist = makedist(tmp_path, install_requires=["wheel"])
+        with pytest.warns(match="`install_requires` overwritten"):
+            dist = pyprojecttoml.apply_configuration(dist, pyproject)
+        assert "wheel" not in dist.install_requires
+
+    def test_optional_dependencies_dont_remove_env_markers(self, tmp_path):
+        """
+        Internally setuptools converts dependencies with markers to "extras".
+        If ``install_requires`` is given by ``setup.py``, we have to ensure that
+        applying ``optional-dependencies`` does not overwrite the mandatory
+        dependencies with markers (see #3204).
+        """
+        # If setuptools replace its internal mechanism that uses `requires.txt`
+        # this test has to be rewritten to adapt accordingly
+        extra = "\n[project.optional-dependencies]\nfoo = ['bar>1']\n"
+        pyproject = self.pyproject(tmp_path, ["dependencies"], extra)
+        install_req = ['importlib-resources (>=3.0.0) ; python_version < "3.7"']
+        dist = makedist(tmp_path, install_requires=install_req)
+        dist = pyprojecttoml.apply_configuration(dist, pyproject)
+        assert "foo" in dist.extras_require
+        egg_info = dist.get_command_obj("egg_info")
+        write_requirements(egg_info, tmp_path, tmp_path / "requires.txt")
+        reqs = (tmp_path / "requires.txt").read_text(encoding="utf-8")
+        assert "importlib-resources" in reqs
+        assert "bar" in reqs
+        assert ':python_version < "3.7"' in reqs
+
+    @pytest.mark.parametrize(
+        ("field", "group"),
+        [("scripts", "console_scripts"), ("gui-scripts", "gui_scripts")],
+    )
+    @pytest.mark.filterwarnings("error")
+    def test_scripts_dont_require_dynamic_entry_points(self, tmp_path, field, group):
+        # Issue 3862
+        pyproject = self.pyproject(tmp_path, [field])
+        dist = makedist(tmp_path, entry_points={group: ["foobar=foobar:main"]})
+        dist = pyprojecttoml.apply_configuration(dist, pyproject)
+        assert group in dist.entry_points
+
+
+class TestMeta:
+    def test_example_file_in_sdist(self, setuptools_sdist):
+        """Meta test to ensure tests can run from sdist"""
+        with tarfile.open(setuptools_sdist) as tar:
+            assert any(name.endswith(EXAMPLES_FILE) for name in tar.getnames())
+
+
+class TestInteropCommandLineParsing:
+    def test_version(self, tmp_path, monkeypatch, capsys):
+        # See pypa/setuptools#4047
+        # This test can be removed once the CLI interface of setup.py is removed
+        monkeypatch.chdir(tmp_path)
+        toml_config = """
+        [project]
+        name = "test"
+        version = "42.0"
+        """
+        pyproject = Path(tmp_path, "pyproject.toml")
+        pyproject.write_text(cleandoc(toml_config), encoding="utf-8")
+        opts = {"script_args": ["--version"]}
+        dist = pyprojecttoml.apply_configuration(Distribution(opts), pyproject)
+        dist.parse_command_line()  # <-- there should be no exception here.
+        captured = capsys.readouterr()
+        assert "42.0" in captured.out
+
+
+class TestStaticConfig:
+    def test_mark_static_fields(self, tmp_path, monkeypatch):
+        monkeypatch.chdir(tmp_path)
+        toml_config = """
+        [project]
+        name = "test"
+        version = "42.0"
+        dependencies = ["hello"]
+        keywords = ["world"]
+        classifiers = ["private :: hello world"]
+        [tool.setuptools]
+        obsoletes = ["abcd"]
+        provides = ["abcd"]
+        platforms = ["abcd"]
+        """
+        pyproject = Path(tmp_path, "pyproject.toml")
+        pyproject.write_text(cleandoc(toml_config), encoding="utf-8")
+        dist = pyprojecttoml.apply_configuration(Distribution({}), pyproject)
+        assert is_static(dist.install_requires)
+        assert is_static(dist.metadata.keywords)
+        assert is_static(dist.metadata.classifiers)
+        assert is_static(dist.metadata.obsoletes)
+        assert is_static(dist.metadata.provides)
+        assert is_static(dist.metadata.platforms)
+
+
+# --- Auxiliary Functions ---
+
+
+def core_metadata(dist) -> str:
+    with io.StringIO() as buffer:
+        dist.metadata.write_pkg_file(buffer)
+        pkg_file_txt = buffer.getvalue()
+
+    # Make sure core metadata is valid
+    Metadata.from_email(pkg_file_txt, validate=True)  # can raise exceptions
+
+    skip_prefixes: tuple[str, ...] = ()
+    skip_lines = set()
+    # ---- DIFF NORMALISATION ----
+    # PEP 621 is very particular about author/maintainer metadata conversion, so skip
+    skip_prefixes += ("Author:", "Author-email:", "Maintainer:", "Maintainer-email:")
+    # May be redundant with Home-page
+    skip_prefixes += ("Project-URL: Homepage,", "Home-page:")
+    # May be missing in original (relying on default) but backfilled in the TOML
+    skip_prefixes += ("Description-Content-Type:",)
+    # Remove empty lines
+    skip_lines.add("")
+
+    result = []
+    for line in pkg_file_txt.splitlines():
+        if line.startswith(skip_prefixes) or line in skip_lines:
+            continue
+        result.append(line + "\n")
+
+    return "".join(result)
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/test_expand.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/test_expand.py
new file mode 100644
index 0000000000000000000000000000000000000000..c5710ec63d7d9d4ed7b709203bb2fc4b512f2093
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/test_expand.py
@@ -0,0 +1,247 @@
+import os
+import sys
+from pathlib import Path
+
+import pytest
+
+from setuptools._static import is_static
+from setuptools.config import expand
+from setuptools.discovery import find_package_path
+
+from distutils.errors import DistutilsOptionError
+
+
+def write_files(files, root_dir):
+    for file, content in files.items():
+        path = root_dir / file
+        path.parent.mkdir(exist_ok=True, parents=True)
+        path.write_text(content, encoding="utf-8")
+
+
+def test_glob_relative(tmp_path, monkeypatch):
+    files = {
+        "dir1/dir2/dir3/file1.txt",
+        "dir1/dir2/file2.txt",
+        "dir1/file3.txt",
+        "a.ini",
+        "b.ini",
+        "dir1/c.ini",
+        "dir1/dir2/a.ini",
+    }
+
+    write_files({k: "" for k in files}, tmp_path)
+    patterns = ["**/*.txt", "[ab].*", "**/[ac].ini"]
+    monkeypatch.chdir(tmp_path)
+    assert set(expand.glob_relative(patterns)) == files
+    # Make sure the same APIs work outside cwd
+    assert set(expand.glob_relative(patterns, tmp_path)) == files
+
+
+def test_read_files(tmp_path, monkeypatch):
+    dir_ = tmp_path / "dir_"
+    (tmp_path / "_dir").mkdir(exist_ok=True)
+    (tmp_path / "a.txt").touch()
+    files = {"a.txt": "a", "dir1/b.txt": "b", "dir1/dir2/c.txt": "c"}
+    write_files(files, dir_)
+
+    secrets = Path(str(dir_) + "secrets")
+    secrets.mkdir(exist_ok=True)
+    write_files({"secrets.txt": "secret keys"}, secrets)
+
+    with monkeypatch.context() as m:
+        m.chdir(dir_)
+        assert expand.read_files(list(files)) == "a\nb\nc"
+
+        cannot_access_msg = r"Cannot access '.*\.\..a\.txt'"
+        with pytest.raises(DistutilsOptionError, match=cannot_access_msg):
+            expand.read_files(["../a.txt"])
+
+        cannot_access_secrets_msg = r"Cannot access '.*secrets\.txt'"
+        with pytest.raises(DistutilsOptionError, match=cannot_access_secrets_msg):
+            expand.read_files(["../dir_secrets/secrets.txt"])
+
+    # Make sure the same APIs work outside cwd
+    assert expand.read_files(list(files), dir_) == "a\nb\nc"
+    with pytest.raises(DistutilsOptionError, match=cannot_access_msg):
+        expand.read_files(["../a.txt"], dir_)
+
+
+class TestReadAttr:
+    @pytest.mark.parametrize(
+        "example",
+        [
+            # No cookie means UTF-8:
+            b"__version__ = '\xc3\xa9'\nraise SystemExit(1)\n",
+            # If a cookie is present, honor it:
+            b"# -*- coding: utf-8 -*-\n__version__ = '\xc3\xa9'\nraise SystemExit(1)\n",
+            b"# -*- coding: latin1 -*-\n__version__ = '\xe9'\nraise SystemExit(1)\n",
+        ],
+    )
+    def test_read_attr_encoding_cookie(self, example, tmp_path):
+        (tmp_path / "mod.py").write_bytes(example)
+        assert expand.read_attr('mod.__version__', root_dir=tmp_path) == 'é'
+
+    def test_read_attr(self, tmp_path, monkeypatch):
+        files = {
+            "pkg/__init__.py": "",
+            "pkg/sub/__init__.py": "VERSION = '0.1.1'",
+            "pkg/sub/mod.py": (
+                "VALUES = {'a': 0, 'b': {42}, 'c': (0, 1, 1)}\nraise SystemExit(1)"
+            ),
+        }
+        write_files(files, tmp_path)
+
+        with monkeypatch.context() as m:
+            m.chdir(tmp_path)
+            # Make sure it can read the attr statically without evaluating the module
+            version = expand.read_attr('pkg.sub.VERSION')
+            values = expand.read_attr('lib.mod.VALUES', {'lib': 'pkg/sub'})
+
+        assert version == '0.1.1'
+        assert is_static(values)
+
+        assert values['a'] == 0
+        assert values['b'] == {42}
+        assert is_static(values)
+
+        # Make sure the same APIs work outside cwd
+        assert expand.read_attr('pkg.sub.VERSION', root_dir=tmp_path) == '0.1.1'
+        values = expand.read_attr('lib.mod.VALUES', {'lib': 'pkg/sub'}, tmp_path)
+        assert values['c'] == (0, 1, 1)
+
+    @pytest.mark.parametrize(
+        "example",
+        [
+            "VERSION: str\nVERSION = '0.1.1'\nraise SystemExit(1)\n",
+            "VERSION: str = '0.1.1'\nraise SystemExit(1)\n",
+        ],
+    )
+    def test_read_annotated_attr(self, tmp_path, example):
+        files = {
+            "pkg/__init__.py": "",
+            "pkg/sub/__init__.py": example,
+        }
+        write_files(files, tmp_path)
+        # Make sure this attribute can be read statically
+        version = expand.read_attr('pkg.sub.VERSION', root_dir=tmp_path)
+        assert version == '0.1.1'
+        assert is_static(version)
+
+    @pytest.mark.parametrize(
+        "example",
+        [
+            "VERSION = (lambda: '0.1.1')()\n",
+            "def fn(): return '0.1.1'\nVERSION = fn()\n",
+            "VERSION: str = (lambda: '0.1.1')()\n",
+        ],
+    )
+    def test_read_dynamic_attr(self, tmp_path, monkeypatch, example):
+        files = {
+            "pkg/__init__.py": "",
+            "pkg/sub/__init__.py": example,
+        }
+        write_files(files, tmp_path)
+        monkeypatch.chdir(tmp_path)
+        version = expand.read_attr('pkg.sub.VERSION')
+        assert version == '0.1.1'
+        assert not is_static(version)
+
+    def test_import_order(self, tmp_path):
+        """
+        Sometimes the import machinery will import the parent package of a nested
+        module, which triggers side-effects and might create problems (see issue #3176)
+
+        ``read_attr`` should bypass these limitations by resolving modules statically
+        (via ast.literal_eval).
+        """
+        files = {
+            "src/pkg/__init__.py": "from .main import func\nfrom .about import version",
+            "src/pkg/main.py": "import super_complicated_dep\ndef func(): return 42",
+            "src/pkg/about.py": "version = '42'",
+        }
+        write_files(files, tmp_path)
+        attr_desc = "pkg.about.version"
+        package_dir = {"": "src"}
+        # `import super_complicated_dep` should not run, otherwise the build fails
+        assert expand.read_attr(attr_desc, package_dir, tmp_path) == "42"
+
+
+@pytest.mark.parametrize(
+    ("package_dir", "file", "module", "return_value"),
+    [
+        ({"": "src"}, "src/pkg/main.py", "pkg.main", 42),
+        ({"pkg": "lib"}, "lib/main.py", "pkg.main", 13),
+        ({}, "single_module.py", "single_module", 70),
+        ({}, "flat_layout/pkg.py", "flat_layout.pkg", 836),
+    ],
+)
+def test_resolve_class(monkeypatch, tmp_path, package_dir, file, module, return_value):
+    monkeypatch.setattr(sys, "modules", {})  # reproducibility
+    files = {file: f"class Custom:\n    def testing(self): return {return_value}"}
+    write_files(files, tmp_path)
+    cls = expand.resolve_class(f"{module}.Custom", package_dir, tmp_path)
+    assert cls().testing() == return_value
+
+
+@pytest.mark.parametrize(
+    ("args", "pkgs"),
+    [
+        ({"where": ["."], "namespaces": False}, {"pkg", "other"}),
+        ({"where": [".", "dir1"], "namespaces": False}, {"pkg", "other", "dir2"}),
+        ({"namespaces": True}, {"pkg", "other", "dir1", "dir1.dir2"}),
+        ({}, {"pkg", "other", "dir1", "dir1.dir2"}),  # default value for `namespaces`
+    ],
+)
+def test_find_packages(tmp_path, args, pkgs):
+    files = {
+        "pkg/__init__.py",
+        "other/__init__.py",
+        "dir1/dir2/__init__.py",
+    }
+    write_files({k: "" for k in files}, tmp_path)
+
+    package_dir = {}
+    kwargs = {"root_dir": tmp_path, "fill_package_dir": package_dir, **args}
+    where = kwargs.get("where", ["."])
+    assert set(expand.find_packages(**kwargs)) == pkgs
+    for pkg in pkgs:
+        pkg_path = find_package_path(pkg, package_dir, tmp_path)
+        assert os.path.exists(pkg_path)
+
+    # Make sure the same APIs work outside cwd
+    where = [
+        str((tmp_path / p).resolve()).replace(os.sep, "/")  # ensure posix-style paths
+        for p in args.pop("where", ["."])
+    ]
+
+    assert set(expand.find_packages(where=where, **args)) == pkgs
+
+
+@pytest.mark.parametrize(
+    ("files", "where", "expected_package_dir"),
+    [
+        (["pkg1/__init__.py", "pkg1/other.py"], ["."], {}),
+        (["pkg1/__init__.py", "pkg2/__init__.py"], ["."], {}),
+        (["src/pkg1/__init__.py", "src/pkg1/other.py"], ["src"], {"": "src"}),
+        (["src/pkg1/__init__.py", "src/pkg2/__init__.py"], ["src"], {"": "src"}),
+        (
+            ["src1/pkg1/__init__.py", "src2/pkg2/__init__.py"],
+            ["src1", "src2"],
+            {"pkg1": "src1/pkg1", "pkg2": "src2/pkg2"},
+        ),
+        (
+            ["src/pkg1/__init__.py", "pkg2/__init__.py"],
+            ["src", "."],
+            {"pkg1": "src/pkg1"},
+        ),
+    ],
+)
+def test_fill_package_dir(tmp_path, files, where, expected_package_dir):
+    write_files({k: "" for k in files}, tmp_path)
+    pkg_dir = {}
+    kwargs = {"root_dir": tmp_path, "fill_package_dir": pkg_dir, "namespaces": False}
+    pkgs = expand.find_packages(where=where, **kwargs)
+    assert set(pkg_dir.items()) == set(expected_package_dir.items())
+    for pkg in pkgs:
+        pkg_path = find_package_path(pkg, pkg_dir, tmp_path)
+        assert os.path.exists(pkg_path)
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/test_pyprojecttoml.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/test_pyprojecttoml.py
new file mode 100644
index 0000000000000000000000000000000000000000..e031ea810bcac94f54e5cd4e6515470233a9189d
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/test_pyprojecttoml.py
@@ -0,0 +1,421 @@
+import re
+from configparser import ConfigParser
+from inspect import cleandoc
+
+import jaraco.path
+import pytest
+import tomli_w
+from path import Path
+
+import setuptools  # noqa: F401 # force distutils.core to be patched
+from setuptools.config.pyprojecttoml import (
+    _ToolsTypoInMetadata,
+    apply_configuration,
+    expand_configuration,
+    read_configuration,
+    validate,
+)
+from setuptools.dist import Distribution
+from setuptools.errors import OptionError
+
+import distutils.core
+
+EXAMPLE = """
+[project]
+name = "myproj"
+keywords = ["some", "key", "words"]
+dynamic = ["version", "readme"]
+requires-python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+dependencies = [
+    'importlib-metadata>=0.12;python_version<"3.8"',
+    'importlib-resources>=1.0;python_version<"3.7"',
+    'pathlib2>=2.3.3,<3;python_version < "3.4" and sys.platform != "win32"',
+]
+
+[project.optional-dependencies]
+docs = [
+    "sphinx>=3",
+    "sphinx-argparse>=0.2.5",
+    "sphinx-rtd-theme>=0.4.3",
+]
+testing = [
+    "pytest>=1",
+    "coverage>=3,<5",
+]
+
+[project.scripts]
+exec = "pkg.__main__:exec"
+
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+zip-safe = true
+platforms = ["any"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.cmdclass]
+sdist = "pkg.mod.CustomSdist"
+
+[tool.setuptools.dynamic.version]
+attr = "pkg.__version__.VERSION"
+
+[tool.setuptools.dynamic.readme]
+file = ["README.md"]
+content-type = "text/markdown"
+
+[tool.setuptools.package-data]
+"*" = ["*.txt"]
+
+[tool.setuptools.data-files]
+"data" = ["_files/*.txt"]
+
+[tool.distutils.sdist]
+formats = "gztar"
+
+[tool.distutils.bdist_wheel]
+universal = true
+"""
+
+
+def create_example(path, pkg_root):
+    files = {
+        "pyproject.toml": EXAMPLE,
+        "README.md": "hello world",
+        "_files": {
+            "file.txt": "",
+        },
+    }
+    packages = {
+        "pkg": {
+            "__init__.py": "",
+            "mod.py": "class CustomSdist: pass",
+            "__version__.py": "VERSION = (3, 10)",
+            "__main__.py": "def exec(): print('hello')",
+        },
+    }
+
+    assert pkg_root  # Meta-test: cannot be empty string.
+
+    if pkg_root == ".":
+        files = {**files, **packages}
+        # skip other files: flat-layout will raise error for multi-package dist
+    else:
+        # Use this opportunity to ensure namespaces are discovered
+        files[pkg_root] = {**packages, "other": {"nested": {"__init__.py": ""}}}
+
+    jaraco.path.build(files, prefix=path)
+
+
+def verify_example(config, path, pkg_root):
+    pyproject = path / "pyproject.toml"
+    pyproject.write_text(tomli_w.dumps(config), encoding="utf-8")
+    expanded = expand_configuration(config, path)
+    expanded_project = expanded["project"]
+    assert read_configuration(pyproject, expand=True) == expanded
+    assert expanded_project["version"] == "3.10"
+    assert expanded_project["readme"]["text"] == "hello world"
+    assert "packages" in expanded["tool"]["setuptools"]
+    if pkg_root == ".":
+        # Auto-discovery will raise error for multi-package dist
+        assert set(expanded["tool"]["setuptools"]["packages"]) == {"pkg"}
+    else:
+        assert set(expanded["tool"]["setuptools"]["packages"]) == {
+            "pkg",
+            "other",
+            "other.nested",
+        }
+    assert expanded["tool"]["setuptools"]["include-package-data"] is True
+    assert "" in expanded["tool"]["setuptools"]["package-data"]
+    assert "*" not in expanded["tool"]["setuptools"]["package-data"]
+    assert expanded["tool"]["setuptools"]["data-files"] == [
+        ("data", ["_files/file.txt"])
+    ]
+
+
+def test_read_configuration(tmp_path):
+    create_example(tmp_path, "src")
+    pyproject = tmp_path / "pyproject.toml"
+
+    config = read_configuration(pyproject, expand=False)
+    assert config["project"].get("version") is None
+    assert config["project"].get("readme") is None
+
+    verify_example(config, tmp_path, "src")
+
+
+@pytest.mark.parametrize(
+    ("pkg_root", "opts"),
+    [
+        (".", {}),
+        ("src", {}),
+        ("lib", {"packages": {"find": {"where": ["lib"]}}}),
+    ],
+)
+def test_discovered_package_dir_with_attr_directive_in_config(tmp_path, pkg_root, opts):
+    create_example(tmp_path, pkg_root)
+
+    pyproject = tmp_path / "pyproject.toml"
+
+    config = read_configuration(pyproject, expand=False)
+    assert config["project"].get("version") is None
+    assert config["project"].get("readme") is None
+    config["tool"]["setuptools"].pop("packages", None)
+    config["tool"]["setuptools"].pop("package-dir", None)
+
+    config["tool"]["setuptools"].update(opts)
+    verify_example(config, tmp_path, pkg_root)
+
+
+ENTRY_POINTS = {
+    "console_scripts": {"a": "mod.a:func"},
+    "gui_scripts": {"b": "mod.b:func"},
+    "other": {"c": "mod.c:func [extra]"},
+}
+
+
+class TestEntryPoints:
+    def write_entry_points(self, tmp_path):
+        entry_points = ConfigParser()
+        entry_points.read_dict(ENTRY_POINTS)
+        with open(tmp_path / "entry-points.txt", "w", encoding="utf-8") as f:
+            entry_points.write(f)
+
+    def pyproject(self, dynamic=None):
+        project = {"dynamic": dynamic or ["scripts", "gui-scripts", "entry-points"]}
+        tool = {"dynamic": {"entry-points": {"file": "entry-points.txt"}}}
+        return {"project": project, "tool": {"setuptools": tool}}
+
+    def test_all_listed_in_dynamic(self, tmp_path):
+        self.write_entry_points(tmp_path)
+        expanded = expand_configuration(self.pyproject(), tmp_path)
+        expanded_project = expanded["project"]
+        assert len(expanded_project["scripts"]) == 1
+        assert expanded_project["scripts"]["a"] == "mod.a:func"
+        assert len(expanded_project["gui-scripts"]) == 1
+        assert expanded_project["gui-scripts"]["b"] == "mod.b:func"
+        assert len(expanded_project["entry-points"]) == 1
+        assert expanded_project["entry-points"]["other"]["c"] == "mod.c:func [extra]"
+
+    @pytest.mark.parametrize("missing_dynamic", ("scripts", "gui-scripts"))
+    def test_scripts_not_listed_in_dynamic(self, tmp_path, missing_dynamic):
+        self.write_entry_points(tmp_path)
+        dynamic = {"scripts", "gui-scripts", "entry-points"} - {missing_dynamic}
+
+        msg = f"defined outside of `pyproject.toml`:.*{missing_dynamic}"
+        with pytest.raises(OptionError, match=re.compile(msg, re.DOTALL)):
+            expand_configuration(self.pyproject(dynamic), tmp_path)
+
+
+class TestClassifiers:
+    def test_dynamic(self, tmp_path):
+        # Let's create a project example that has dynamic classifiers
+        # coming from a txt file.
+        create_example(tmp_path, "src")
+        classifiers = cleandoc(
+            """
+            Framework :: Flask
+            Programming Language :: Haskell
+            """
+        )
+        (tmp_path / "classifiers.txt").write_text(classifiers, encoding="utf-8")
+
+        pyproject = tmp_path / "pyproject.toml"
+        config = read_configuration(pyproject, expand=False)
+        dynamic = config["project"]["dynamic"]
+        config["project"]["dynamic"] = list({*dynamic, "classifiers"})
+        dynamic_config = config["tool"]["setuptools"]["dynamic"]
+        dynamic_config["classifiers"] = {"file": "classifiers.txt"}
+
+        # When the configuration is expanded,
+        # each line of the file should be an different classifier.
+        validate(config, pyproject)
+        expanded = expand_configuration(config, tmp_path)
+
+        assert set(expanded["project"]["classifiers"]) == {
+            "Framework :: Flask",
+            "Programming Language :: Haskell",
+        }
+
+    def test_dynamic_without_config(self, tmp_path):
+        config = """
+        [project]
+        name = "myproj"
+        version = '42'
+        dynamic = ["classifiers"]
+        """
+
+        pyproject = tmp_path / "pyproject.toml"
+        pyproject.write_text(cleandoc(config), encoding="utf-8")
+        with pytest.raises(OptionError, match="No configuration .* .classifiers."):
+            read_configuration(pyproject)
+
+    def test_dynamic_readme_from_setup_script_args(self, tmp_path):
+        config = """
+        [project]
+        name = "myproj"
+        version = '42'
+        dynamic = ["readme"]
+        """
+        pyproject = tmp_path / "pyproject.toml"
+        pyproject.write_text(cleandoc(config), encoding="utf-8")
+        dist = Distribution(attrs={"long_description": "42"})
+        # No error should occur because of missing `readme`
+        dist = apply_configuration(dist, pyproject)
+        assert dist.metadata.long_description == "42"
+
+    def test_dynamic_without_file(self, tmp_path):
+        config = """
+        [project]
+        name = "myproj"
+        version = '42'
+        dynamic = ["classifiers"]
+
+        [tool.setuptools.dynamic]
+        classifiers = {file = ["classifiers.txt"]}
+        """
+
+        pyproject = tmp_path / "pyproject.toml"
+        pyproject.write_text(cleandoc(config), encoding="utf-8")
+        with pytest.warns(UserWarning, match="File .*classifiers.txt. cannot be found"):
+            expanded = read_configuration(pyproject)
+        assert "classifiers" not in expanded["project"]
+
+
+class TestImportNames:
+    EXAMPLES = [
+        'import-names = ["hello", "world"]',
+        'import-namespaces = ["hello", "world"]',
+        'dynamic = ["import-names"]',
+        'dynamic = ["import-namespaces"]',
+    ]
+
+    @pytest.mark.parametrize("example", EXAMPLES)
+    def test_not_implemented(self, monkeypatch, tmp_path, example):
+        monkeypatch.chdir(tmp_path)
+        pyproject = Path("pyproject.toml")
+        toml_config = f"""
+        [project]
+        name = 'proj'
+        version = '42'
+        {example}
+        """
+        pyproject.write_text(cleandoc(toml_config), encoding="utf-8")
+        with pytest.raises(NotImplementedError, match='import-names'):
+            apply_configuration(Distribution({}), pyproject)
+
+
+@pytest.mark.parametrize(
+    "example",
+    (
+        """
+        [project]
+        name = "myproj"
+        version = "1.2"
+
+        [my-tool.that-disrespect.pep518]
+        value = 42
+        """,
+    ),
+)
+def test_ignore_unrelated_config(tmp_path, example):
+    pyproject = tmp_path / "pyproject.toml"
+    pyproject.write_text(cleandoc(example), encoding="utf-8")
+
+    # Make sure no error is raised due to 3rd party configs in pyproject.toml
+    assert read_configuration(pyproject) is not None
+
+
+@pytest.mark.parametrize(
+    ("example", "error_msg"),
+    [
+        (
+            """
+            [project]
+            name = "myproj"
+            version = "1.2"
+            requires = ['pywin32; platform_system=="Windows"' ]
+            """,
+            "configuration error: .project. must not contain ..requires.. properties",
+        ),
+    ],
+)
+def test_invalid_example(tmp_path, example, error_msg):
+    pyproject = tmp_path / "pyproject.toml"
+    pyproject.write_text(cleandoc(example), encoding="utf-8")
+
+    pattern = re.compile(
+        f"invalid pyproject.toml.*{error_msg}.*", re.MULTILINE | re.DOTALL
+    )
+    with pytest.raises(ValueError, match=pattern):
+        read_configuration(pyproject)
+
+
+@pytest.mark.parametrize("config", ("", "[tool.something]\nvalue = 42"))
+def test_empty(tmp_path, config):
+    pyproject = tmp_path / "pyproject.toml"
+    pyproject.write_text(config, encoding="utf-8")
+
+    # Make sure no error is raised
+    assert read_configuration(pyproject) == {}
+
+
+@pytest.mark.parametrize("config", ("[project]\nname = 'myproj'\nversion='42'\n",))
+def test_include_package_data_by_default(tmp_path, config):
+    """Builds with ``pyproject.toml`` should consider ``include-package-data=True`` as
+    default.
+    """
+    pyproject = tmp_path / "pyproject.toml"
+    pyproject.write_text(config, encoding="utf-8")
+
+    config = read_configuration(pyproject)
+    assert config["tool"]["setuptools"]["include-package-data"] is True
+
+
+def test_include_package_data_in_setuppy(tmp_path):
+    """Builds with ``pyproject.toml`` should consider ``include_package_data`` set in
+    ``setup.py``.
+
+    See https://github.com/pypa/setuptools/issues/3197#issuecomment-1079023889
+    """
+    files = {
+        "pyproject.toml": "[project]\nname = 'myproj'\nversion='42'\n",
+        "setup.py": "__import__('setuptools').setup(include_package_data=False)",
+    }
+    jaraco.path.build(files, prefix=tmp_path)
+
+    with Path(tmp_path):
+        dist = distutils.core.run_setup("setup.py", {}, stop_after="config")
+
+    assert dist.get_name() == "myproj"
+    assert dist.get_version() == "42"
+    assert dist.include_package_data is False
+
+
+def test_warn_tools_typo(tmp_path):
+    """Test that the common ``tools.setuptools`` typo in ``pyproject.toml`` issues a warning
+
+    See https://github.com/pypa/setuptools/issues/4150
+    """
+    config = """
+    [build-system]
+    requires = ["setuptools"]
+    build-backend = "setuptools.build_meta"
+
+    [project]
+    name = "myproj"
+    version = '42'
+
+    [tools.setuptools]
+    packages = ["package"]
+    """
+
+    pyproject = tmp_path / "pyproject.toml"
+    pyproject.write_text(cleandoc(config), encoding="utf-8")
+
+    with pytest.warns(_ToolsTypoInMetadata):
+        read_configuration(pyproject)
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/test_pyprojecttoml_dynamic_deps.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/test_pyprojecttoml_dynamic_deps.py
new file mode 100644
index 0000000000000000000000000000000000000000..9fc8050743c4b1a8497d5ea20c571b565d074e59
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/test_pyprojecttoml_dynamic_deps.py
@@ -0,0 +1,111 @@
+from inspect import cleandoc
+
+import pytest
+from jaraco import path
+
+from setuptools.config.pyprojecttoml import apply_configuration
+from setuptools.dist import Distribution
+from setuptools.warnings import SetuptoolsWarning
+
+
+def test_dynamic_dependencies(tmp_path):
+    files = {
+        "requirements.txt": "six\n  # comment\n",
+        "pyproject.toml": cleandoc(
+            """
+            [project]
+            name = "myproj"
+            version = "1.0"
+            dynamic = ["dependencies"]
+
+            [build-system]
+            requires = ["setuptools", "wheel"]
+            build-backend = "setuptools.build_meta"
+
+            [tool.setuptools.dynamic.dependencies]
+            file = ["requirements.txt"]
+            """
+        ),
+    }
+    path.build(files, prefix=tmp_path)
+    dist = Distribution()
+    dist = apply_configuration(dist, tmp_path / "pyproject.toml")
+    assert dist.install_requires == ["six"]
+
+
+def test_dynamic_optional_dependencies(tmp_path):
+    files = {
+        "requirements-docs.txt": "sphinx\n  # comment\n",
+        "pyproject.toml": cleandoc(
+            """
+            [project]
+            name = "myproj"
+            version = "1.0"
+            dynamic = ["optional-dependencies"]
+
+            [tool.setuptools.dynamic.optional-dependencies.docs]
+            file = ["requirements-docs.txt"]
+
+            [build-system]
+            requires = ["setuptools", "wheel"]
+            build-backend = "setuptools.build_meta"
+            """
+        ),
+    }
+    path.build(files, prefix=tmp_path)
+    dist = Distribution()
+    dist = apply_configuration(dist, tmp_path / "pyproject.toml")
+    assert dist.extras_require == {"docs": ["sphinx"]}
+
+
+def test_mixed_dynamic_optional_dependencies(tmp_path):
+    """
+    Test that if PEP 621 was loosened to allow mixing of dynamic and static
+    configurations in the case of fields containing sub-fields (groups),
+    things would work out.
+    """
+    files = {
+        "requirements-images.txt": "pillow~=42.0\n  # comment\n",
+        "pyproject.toml": cleandoc(
+            """
+            [project]
+            name = "myproj"
+            version = "1.0"
+            dynamic = ["optional-dependencies"]
+
+            [project.optional-dependencies]
+            docs = ["sphinx"]
+
+            [tool.setuptools.dynamic.optional-dependencies.images]
+            file = ["requirements-images.txt"]
+            """
+        ),
+    }
+
+    path.build(files, prefix=tmp_path)
+    pyproject = tmp_path / "pyproject.toml"
+    with pytest.raises(ValueError, match="project.optional-dependencies"):
+        apply_configuration(Distribution(), pyproject)
+
+
+def test_mixed_extras_require_optional_dependencies(tmp_path):
+    files = {
+        "pyproject.toml": cleandoc(
+            """
+            [project]
+            name = "myproj"
+            version = "1.0"
+            optional-dependencies.docs = ["sphinx"]
+            """
+        ),
+    }
+
+    path.build(files, prefix=tmp_path)
+    pyproject = tmp_path / "pyproject.toml"
+
+    dist = Distribution({"extras_require": {"hello": ["world"]}})
+
+    with pytest.warns(SetuptoolsWarning, match=".extras_require. overwritten"):
+        dist = apply_configuration(dist, pyproject)
+
+    assert dist.extras_require == {"docs": ["sphinx"]}
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/test_setupcfg.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/test_setupcfg.py
new file mode 100644
index 0000000000000000000000000000000000000000..495337a9a5815e3d2a0aefa584b8ee81f5136d95
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/config/test_setupcfg.py
@@ -0,0 +1,987 @@
+import configparser
+import contextlib
+import inspect
+import re
+import sys
+from pathlib import Path
+from unittest.mock import Mock, patch
+
+import pytest
+from packaging.requirements import InvalidRequirement
+
+from setuptools.config.setupcfg import ConfigHandler, Target, read_configuration
+from setuptools.dist import Distribution, _Distribution
+from setuptools.warnings import SetuptoolsDeprecationWarning
+
+from ..textwrap import DALS
+
+from distutils.errors import DistutilsFileError, DistutilsOptionError
+
+IS_PYPY = '__pypy__' in sys.builtin_module_names
+
+
+class ErrConfigHandler(ConfigHandler[Target]):
+    """Erroneous handler. Fails to implement required methods."""
+
+    section_prefix = "**err**"
+
+
+def make_package_dir(name, base_dir, ns=False):
+    dir_package = base_dir
+    for dir_name in name.split('/'):
+        dir_package = dir_package.mkdir(dir_name)
+    init_file = None
+    if not ns:
+        init_file = dir_package.join('__init__.py')
+        init_file.write('')
+    return dir_package, init_file
+
+
+def fake_env(
+    tmpdir, setup_cfg, setup_py=None, encoding='ascii', package_path='fake_package'
+):
+    if setup_py is None:
+        setup_py = 'from setuptools import setup\nsetup()\n'
+
+    tmpdir.join('setup.py').write(setup_py)
+    config = tmpdir.join('setup.cfg')
+    config.write(setup_cfg.encode(encoding), mode='wb')
+
+    package_dir, init_file = make_package_dir(package_path, tmpdir)
+
+    init_file.write(
+        'VERSION = (1, 2, 3)\n'
+        '\n'
+        'VERSION_MAJOR = 1'
+        '\n'
+        'def get_version():\n'
+        '    return [3, 4, 5, "dev"]\n'
+        '\n'
+    )
+
+    return package_dir, config
+
+
+@contextlib.contextmanager
+def get_dist(tmpdir, kwargs_initial=None, parse=True):
+    kwargs_initial = kwargs_initial or {}
+
+    with tmpdir.as_cwd():
+        dist = Distribution(kwargs_initial)
+        dist.script_name = 'setup.py'
+        parse and dist.parse_config_files()
+
+        yield dist
+
+
+def test_parsers_implemented():
+    with pytest.raises(NotImplementedError):
+        handler = ErrConfigHandler(None, {}, False, Mock())
+        handler.parsers
+
+
+class TestConfigurationReader:
+    def test_basic(self, tmpdir):
+        _, config = fake_env(
+            tmpdir,
+            '[metadata]\n'
+            'version = 10.1.1\n'
+            'keywords = one, two\n'
+            '\n'
+            '[options]\n'
+            'scripts = bin/a.py, bin/b.py\n',
+        )
+        config_dict = read_configuration(str(config))
+        assert config_dict['metadata']['version'] == '10.1.1'
+        assert config_dict['metadata']['keywords'] == ['one', 'two']
+        assert config_dict['options']['scripts'] == ['bin/a.py', 'bin/b.py']
+
+    def test_no_config(self, tmpdir):
+        with pytest.raises(DistutilsFileError):
+            read_configuration(str(tmpdir.join('setup.cfg')))
+
+    def test_ignore_errors(self, tmpdir):
+        _, config = fake_env(
+            tmpdir,
+            '[metadata]\nversion = attr: none.VERSION\nkeywords = one, two\n',
+        )
+        with pytest.raises(ImportError):
+            read_configuration(str(config))
+
+        config_dict = read_configuration(str(config), ignore_option_errors=True)
+
+        assert config_dict['metadata']['keywords'] == ['one', 'two']
+        assert 'version' not in config_dict['metadata']
+
+        config.remove()
+
+
+class TestMetadata:
+    def test_basic(self, tmpdir):
+        fake_env(
+            tmpdir,
+            '[metadata]\n'
+            'version = 10.1.1\n'
+            'description = Some description\n'
+            'long_description_content_type = text/something\n'
+            'long_description = file: README\n'
+            'name = fake_name\n'
+            'keywords = one, two\n'
+            'provides = package, package.sub\n'
+            'license = otherlic\n'
+            'download_url = http://test.test.com/test/\n'
+            'maintainer_email = test@test.com\n',
+        )
+
+        tmpdir.join('README').write('readme contents\nline2')
+
+        meta_initial = {
+            # This will be used so `otherlic` won't replace it.
+            'license': 'BSD 3-Clause License',
+        }
+
+        with get_dist(tmpdir, meta_initial) as dist:
+            metadata = dist.metadata
+
+            assert metadata.version == '10.1.1'
+            assert metadata.description == 'Some description'
+            assert metadata.long_description_content_type == 'text/something'
+            assert metadata.long_description == 'readme contents\nline2'
+            assert metadata.provides == ['package', 'package.sub']
+            assert metadata.license == 'BSD 3-Clause License'
+            assert metadata.name == 'fake_name'
+            assert metadata.keywords == ['one', 'two']
+            assert metadata.download_url == 'http://test.test.com/test/'
+            assert metadata.maintainer_email == 'test@test.com'
+
+    def test_license_cfg(self, tmpdir):
+        fake_env(
+            tmpdir,
+            DALS(
+                """
+            [metadata]
+            name=foo
+            version=0.0.1
+            license=Apache 2.0
+            """
+            ),
+        )
+
+        with get_dist(tmpdir) as dist:
+            metadata = dist.metadata
+
+            assert metadata.name == "foo"
+            assert metadata.version == "0.0.1"
+            assert metadata.license == "Apache 2.0"
+
+    def test_file_mixed(self, tmpdir):
+        fake_env(
+            tmpdir,
+            '[metadata]\nlong_description = file: README.rst, CHANGES.rst\n\n',
+        )
+
+        tmpdir.join('README.rst').write('readme contents\nline2')
+        tmpdir.join('CHANGES.rst').write('changelog contents\nand stuff')
+
+        with get_dist(tmpdir) as dist:
+            assert dist.metadata.long_description == (
+                'readme contents\nline2\nchangelog contents\nand stuff'
+            )
+
+    def test_file_sandboxed(self, tmpdir):
+        tmpdir.ensure("README")
+        project = tmpdir.join('depth1', 'depth2')
+        project.ensure(dir=True)
+        fake_env(project, '[metadata]\nlong_description = file: ../../README\n')
+
+        with get_dist(project, parse=False) as dist:
+            with pytest.raises(DistutilsOptionError):
+                dist.parse_config_files()  # file: out of sandbox
+
+    def test_aliases(self, tmpdir):
+        fake_env(
+            tmpdir,
+            '[metadata]\n'
+            'author_email = test@test.com\n'
+            'home_page = http://test.test.com/test/\n'
+            'summary = Short summary\n'
+            'platform = a, b\n'
+            'classifier =\n'
+            '  Framework :: Django\n'
+            '  Programming Language :: Python :: 3.5\n',
+        )
+
+        with get_dist(tmpdir) as dist:
+            metadata = dist.metadata
+            assert metadata.author_email == 'test@test.com'
+            assert metadata.url == 'http://test.test.com/test/'
+            assert metadata.description == 'Short summary'
+            assert metadata.platforms == ['a', 'b']
+            assert metadata.classifiers == [
+                'Framework :: Django',
+                'Programming Language :: Python :: 3.5',
+            ]
+
+    def test_multiline(self, tmpdir):
+        fake_env(
+            tmpdir,
+            '[metadata]\n'
+            'name = fake_name\n'
+            'keywords =\n'
+            '  one\n'
+            '  two\n'
+            'classifiers =\n'
+            '  Framework :: Django\n'
+            '  Programming Language :: Python :: 3.5\n',
+        )
+        with get_dist(tmpdir) as dist:
+            metadata = dist.metadata
+            assert metadata.keywords == ['one', 'two']
+            assert metadata.classifiers == [
+                'Framework :: Django',
+                'Programming Language :: Python :: 3.5',
+            ]
+
+    def test_dict(self, tmpdir):
+        fake_env(
+            tmpdir,
+            '[metadata]\n'
+            'project_urls =\n'
+            '  Link One = https://example.com/one/\n'
+            '  Link Two = https://example.com/two/\n',
+        )
+        with get_dist(tmpdir) as dist:
+            metadata = dist.metadata
+            assert metadata.project_urls == {
+                'Link One': 'https://example.com/one/',
+                'Link Two': 'https://example.com/two/',
+            }
+
+    def test_version(self, tmpdir):
+        package_dir, config = fake_env(
+            tmpdir, '[metadata]\nversion = attr: fake_package.VERSION\n'
+        )
+
+        sub_a = package_dir.mkdir('subpkg_a')
+        sub_a.join('__init__.py').write('')
+        sub_a.join('mod.py').write('VERSION = (2016, 11, 26)')
+
+        sub_b = package_dir.mkdir('subpkg_b')
+        sub_b.join('__init__.py').write('')
+        sub_b.join('mod.py').write(
+            'import third_party_module\nVERSION = (2016, 11, 26)'
+        )
+
+        with get_dist(tmpdir) as dist:
+            assert dist.metadata.version == '1.2.3'
+
+        config.write('[metadata]\nversion = attr: fake_package.get_version\n')
+        with get_dist(tmpdir) as dist:
+            assert dist.metadata.version == '3.4.5.dev'
+
+        config.write('[metadata]\nversion = attr: fake_package.VERSION_MAJOR\n')
+        with get_dist(tmpdir) as dist:
+            assert dist.metadata.version == '1'
+
+        config.write('[metadata]\nversion = attr: fake_package.subpkg_a.mod.VERSION\n')
+        with get_dist(tmpdir) as dist:
+            assert dist.metadata.version == '2016.11.26'
+
+        config.write('[metadata]\nversion = attr: fake_package.subpkg_b.mod.VERSION\n')
+        with get_dist(tmpdir) as dist:
+            assert dist.metadata.version == '2016.11.26'
+
+    def test_version_file(self, tmpdir):
+        fake_env(tmpdir, '[metadata]\nversion = file: fake_package/version.txt\n')
+        tmpdir.join('fake_package', 'version.txt').write('1.2.3\n')
+
+        with get_dist(tmpdir) as dist:
+            assert dist.metadata.version == '1.2.3'
+
+        tmpdir.join('fake_package', 'version.txt').write('1.2.3\n4.5.6\n')
+        with pytest.raises(DistutilsOptionError):
+            with get_dist(tmpdir) as dist:
+                dist.metadata.version
+
+    def test_version_with_package_dir_simple(self, tmpdir):
+        fake_env(
+            tmpdir,
+            '[metadata]\n'
+            'version = attr: fake_package_simple.VERSION\n'
+            '[options]\n'
+            'package_dir =\n'
+            '    = src\n',
+            package_path='src/fake_package_simple',
+        )
+
+        with get_dist(tmpdir) as dist:
+            assert dist.metadata.version == '1.2.3'
+
+    def test_version_with_package_dir_rename(self, tmpdir):
+        fake_env(
+            tmpdir,
+            '[metadata]\n'
+            'version = attr: fake_package_rename.VERSION\n'
+            '[options]\n'
+            'package_dir =\n'
+            '    fake_package_rename = fake_dir\n',
+            package_path='fake_dir',
+        )
+
+        with get_dist(tmpdir) as dist:
+            assert dist.metadata.version == '1.2.3'
+
+    def test_version_with_package_dir_complex(self, tmpdir):
+        fake_env(
+            tmpdir,
+            '[metadata]\n'
+            'version = attr: fake_package_complex.VERSION\n'
+            '[options]\n'
+            'package_dir =\n'
+            '    fake_package_complex = src/fake_dir\n',
+            package_path='src/fake_dir',
+        )
+
+        with get_dist(tmpdir) as dist:
+            assert dist.metadata.version == '1.2.3'
+
+    def test_unknown_meta_item(self, tmpdir):
+        fake_env(tmpdir, '[metadata]\nname = fake_name\nunknown = some\n')
+        with get_dist(tmpdir, parse=False) as dist:
+            dist.parse_config_files()  # Skip unknown.
+
+    def test_usupported_section(self, tmpdir):
+        fake_env(tmpdir, '[metadata.some]\nkey = val\n')
+        with get_dist(tmpdir, parse=False) as dist:
+            with pytest.raises(DistutilsOptionError):
+                dist.parse_config_files()
+
+    def test_classifiers(self, tmpdir):
+        expected = set([
+            'Framework :: Django',
+            'Programming Language :: Python :: 3',
+            'Programming Language :: Python :: 3.5',
+        ])
+
+        # From file.
+        _, config = fake_env(tmpdir, '[metadata]\nclassifiers = file: classifiers\n')
+
+        tmpdir.join('classifiers').write(
+            'Framework :: Django\n'
+            'Programming Language :: Python :: 3\n'
+            'Programming Language :: Python :: 3.5\n'
+        )
+
+        with get_dist(tmpdir) as dist:
+            assert set(dist.metadata.classifiers) == expected
+
+        # From list notation
+        config.write(
+            '[metadata]\n'
+            'classifiers =\n'
+            '    Framework :: Django\n'
+            '    Programming Language :: Python :: 3\n'
+            '    Programming Language :: Python :: 3.5\n'
+        )
+        with get_dist(tmpdir) as dist:
+            assert set(dist.metadata.classifiers) == expected
+
+    def test_interpolation(self, tmpdir):
+        fake_env(tmpdir, '[metadata]\ndescription = %(message)s\n')
+        with pytest.raises(configparser.InterpolationMissingOptionError):
+            with get_dist(tmpdir):
+                pass
+
+    def test_non_ascii_1(self, tmpdir):
+        fake_env(tmpdir, '[metadata]\ndescription = éàïôñ\n', encoding='utf-8')
+        with get_dist(tmpdir):
+            pass
+
+    def test_non_ascii_3(self, tmpdir):
+        fake_env(tmpdir, '\n# -*- coding: invalid\n')
+        with get_dist(tmpdir):
+            pass
+
+    def test_non_ascii_4(self, tmpdir):
+        fake_env(
+            tmpdir,
+            '# -*- coding: utf-8\n[metadata]\ndescription = éàïôñ\n',
+            encoding='utf-8',
+        )
+        with get_dist(tmpdir) as dist:
+            assert dist.metadata.description == 'éàïôñ'
+
+    def test_not_utf8(self, tmpdir):
+        """
+        Config files encoded not in UTF-8 will fail
+        """
+        fake_env(
+            tmpdir,
+            '# vim: set fileencoding=iso-8859-15 :\n[metadata]\ndescription = éàïôñ\n',
+            encoding='iso-8859-15',
+        )
+        with pytest.raises(UnicodeDecodeError):
+            with get_dist(tmpdir):
+                pass
+
+    @pytest.mark.parametrize(
+        ("error_msg", "config", "invalid"),
+        [
+            (
+                "Invalid dash-separated key 'author-email' in 'metadata' (setup.cfg)",
+                DALS(
+                    """
+                    [metadata]
+                    author-email = test@test.com
+                    maintainer_email = foo@foo.com
+                    """
+                ),
+                {"author-email": "test@test.com"},
+            ),
+            (
+                "Invalid uppercase key 'Name' in 'metadata' (setup.cfg)",
+                DALS(
+                    """
+                    [metadata]
+                    Name = foo
+                    description = Some description
+                    """
+                ),
+                {"Name": "foo"},
+            ),
+        ],
+    )
+    def test_invalid_options_previously_deprecated(
+        self, tmpdir, error_msg, config, invalid
+    ):
+        # This test and related methods can be removed when no longer needed.
+        # Deprecation postponed due to push-back from the community in
+        # https://github.com/pypa/setuptools/issues/4910
+        fake_env(tmpdir, config)
+        with pytest.warns(SetuptoolsDeprecationWarning, match=re.escape(error_msg)):
+            dist = get_dist(tmpdir).__enter__()
+
+        tmpdir.join('setup.cfg').remove()
+
+        for field, value in invalid.items():
+            attr = field.replace("-", "_").lower()
+            assert getattr(dist.metadata, attr) == value
+
+
+class TestOptions:
+    def test_basic(self, tmpdir):
+        fake_env(
+            tmpdir,
+            '[options]\n'
+            'zip_safe = True\n'
+            'include_package_data = yes\n'
+            'package_dir = b=c, =src\n'
+            'packages = pack_a, pack_b.subpack\n'
+            'namespace_packages = pack1, pack2\n'
+            'scripts = bin/one.py, bin/two.py\n'
+            'eager_resources = bin/one.py, bin/two.py\n'
+            'install_requires = docutils>=0.3; pack ==1.1, ==1.3; hey\n'
+            'setup_requires = docutils>=0.3; spack ==1.1, ==1.3; there\n'
+            'dependency_links = http://some.com/here/1, '
+            'http://some.com/there/2\n'
+            'python_requires = >=1.0, !=2.8\n'
+            'py_modules = module1, module2\n',
+        )
+        deprec = pytest.warns(SetuptoolsDeprecationWarning, match="namespace_packages")
+        with deprec, get_dist(tmpdir) as dist:
+            assert dist.zip_safe
+            assert dist.include_package_data
+            assert dist.package_dir == {'': 'src', 'b': 'c'}
+            assert dist.packages == ['pack_a', 'pack_b.subpack']
+            assert dist.namespace_packages == ['pack1', 'pack2']
+            assert dist.scripts == ['bin/one.py', 'bin/two.py']
+            assert dist.dependency_links == ([
+                'http://some.com/here/1',
+                'http://some.com/there/2',
+            ])
+            assert dist.install_requires == ([
+                'docutils>=0.3',
+                'pack==1.1,==1.3',
+                'hey',
+            ])
+            assert dist.setup_requires == ([
+                'docutils>=0.3',
+                'spack ==1.1, ==1.3',
+                'there',
+            ])
+            assert dist.python_requires == '>=1.0, !=2.8'
+            assert dist.py_modules == ['module1', 'module2']
+
+    def test_multiline(self, tmpdir):
+        fake_env(
+            tmpdir,
+            '[options]\n'
+            'package_dir = \n'
+            '  b=c\n'
+            '  =src\n'
+            'packages = \n'
+            '  pack_a\n'
+            '  pack_b.subpack\n'
+            'namespace_packages = \n'
+            '  pack1\n'
+            '  pack2\n'
+            'scripts = \n'
+            '  bin/one.py\n'
+            '  bin/two.py\n'
+            'eager_resources = \n'
+            '  bin/one.py\n'
+            '  bin/two.py\n'
+            'install_requires = \n'
+            '  docutils>=0.3\n'
+            '  pack ==1.1, ==1.3\n'
+            '  hey\n'
+            'setup_requires = \n'
+            '  docutils>=0.3\n'
+            '  spack ==1.1, ==1.3\n'
+            '  there\n'
+            'dependency_links = \n'
+            '  http://some.com/here/1\n'
+            '  http://some.com/there/2\n',
+        )
+        deprec = pytest.warns(SetuptoolsDeprecationWarning, match="namespace_packages")
+        with deprec, get_dist(tmpdir) as dist:
+            assert dist.package_dir == {'': 'src', 'b': 'c'}
+            assert dist.packages == ['pack_a', 'pack_b.subpack']
+            assert dist.namespace_packages == ['pack1', 'pack2']
+            assert dist.scripts == ['bin/one.py', 'bin/two.py']
+            assert dist.dependency_links == ([
+                'http://some.com/here/1',
+                'http://some.com/there/2',
+            ])
+            assert dist.install_requires == ([
+                'docutils>=0.3',
+                'pack==1.1,==1.3',
+                'hey',
+            ])
+            assert dist.setup_requires == ([
+                'docutils>=0.3',
+                'spack ==1.1, ==1.3',
+                'there',
+            ])
+
+    def test_package_dir_fail(self, tmpdir):
+        fake_env(tmpdir, '[options]\npackage_dir = a b\n')
+        with get_dist(tmpdir, parse=False) as dist:
+            with pytest.raises(DistutilsOptionError):
+                dist.parse_config_files()
+
+    def test_package_data(self, tmpdir):
+        fake_env(
+            tmpdir,
+            '[options.package_data]\n'
+            '* = *.txt, *.rst\n'
+            'hello = *.msg\n'
+            '\n'
+            '[options.exclude_package_data]\n'
+            '* = fake1.txt, fake2.txt\n'
+            'hello = *.dat\n',
+        )
+
+        with get_dist(tmpdir) as dist:
+            assert dist.package_data == {
+                '': ['*.txt', '*.rst'],
+                'hello': ['*.msg'],
+            }
+            assert dist.exclude_package_data == {
+                '': ['fake1.txt', 'fake2.txt'],
+                'hello': ['*.dat'],
+            }
+
+    def test_packages(self, tmpdir):
+        fake_env(tmpdir, '[options]\npackages = find:\n')
+
+        with get_dist(tmpdir) as dist:
+            assert dist.packages == ['fake_package']
+
+    def test_find_directive(self, tmpdir):
+        dir_package, config = fake_env(tmpdir, '[options]\npackages = find:\n')
+
+        make_package_dir('sub_one', dir_package)
+        make_package_dir('sub_two', dir_package)
+
+        with get_dist(tmpdir) as dist:
+            assert set(dist.packages) == set([
+                'fake_package',
+                'fake_package.sub_two',
+                'fake_package.sub_one',
+            ])
+
+        config.write(
+            '[options]\n'
+            'packages = find:\n'
+            '\n'
+            '[options.packages.find]\n'
+            'where = .\n'
+            'include =\n'
+            '    fake_package.sub_one\n'
+            '    two\n'
+        )
+        with get_dist(tmpdir) as dist:
+            assert dist.packages == ['fake_package.sub_one']
+
+        config.write(
+            '[options]\n'
+            'packages = find:\n'
+            '\n'
+            '[options.packages.find]\n'
+            'exclude =\n'
+            '    fake_package.sub_one\n'
+        )
+        with get_dist(tmpdir) as dist:
+            assert set(dist.packages) == set(['fake_package', 'fake_package.sub_two'])
+
+    def test_find_namespace_directive(self, tmpdir):
+        dir_package, config = fake_env(
+            tmpdir, '[options]\npackages = find_namespace:\n'
+        )
+
+        make_package_dir('sub_one', dir_package)
+        make_package_dir('sub_two', dir_package, ns=True)
+
+        with get_dist(tmpdir) as dist:
+            assert set(dist.packages) == {
+                'fake_package',
+                'fake_package.sub_two',
+                'fake_package.sub_one',
+            }
+
+        config.write(
+            '[options]\n'
+            'packages = find_namespace:\n'
+            '\n'
+            '[options.packages.find]\n'
+            'where = .\n'
+            'include =\n'
+            '    fake_package.sub_one\n'
+            '    two\n'
+        )
+        with get_dist(tmpdir) as dist:
+            assert dist.packages == ['fake_package.sub_one']
+
+        config.write(
+            '[options]\n'
+            'packages = find_namespace:\n'
+            '\n'
+            '[options.packages.find]\n'
+            'exclude =\n'
+            '    fake_package.sub_one\n'
+        )
+        with get_dist(tmpdir) as dist:
+            assert set(dist.packages) == {'fake_package', 'fake_package.sub_two'}
+
+    def test_extras_require(self, tmpdir):
+        fake_env(
+            tmpdir,
+            '[options.extras_require]\n'
+            'pdf = ReportLab>=1.2; RXP\n'
+            'rest = \n'
+            '  docutils>=0.3\n'
+            '  pack ==1.1, ==1.3\n',
+        )
+
+        with get_dist(tmpdir) as dist:
+            assert dist.extras_require == {
+                'pdf': ['ReportLab>=1.2', 'RXP'],
+                'rest': ['docutils>=0.3', 'pack==1.1,==1.3'],
+            }
+            assert set(dist.metadata.provides_extras) == {'pdf', 'rest'}
+
+    @pytest.mark.parametrize(
+        "config",
+        [
+            "[options.extras_require]\nfoo = bar;python_version<'3'",
+            "[options.extras_require]\nfoo = bar;os_name=='linux'",
+            "[options.extras_require]\nfoo = bar;python_version<'3'\n",
+            "[options.extras_require]\nfoo = bar;os_name=='linux'\n",
+            "[options]\ninstall_requires = bar;python_version<'3'",
+            "[options]\ninstall_requires = bar;os_name=='linux'",
+            "[options]\ninstall_requires = bar;python_version<'3'\n",
+            "[options]\ninstall_requires = bar;os_name=='linux'\n",
+        ],
+    )
+    @pytest.mark.xfail(IS_PYPY, reason="Exceptions missing on PyPy")
+    # TODO: investigate PyPy problem
+    def test_raises_accidental_env_marker_misconfig(self, config, tmpdir):
+        fake_env(tmpdir, config)
+        match = (
+            r"One of the parsed requirements in `(install_requires|extras_require.+)` "
+            "looks like a valid environment marker.*"
+        )
+        with pytest.raises(InvalidRequirement, match=match):
+            with get_dist(tmpdir) as _:
+                pass
+
+    @pytest.mark.parametrize(
+        "config",
+        [
+            "[options.extras_require]\nfoo = bar;python_version<3",
+            "[options.extras_require]\nfoo = bar;python_version<3\n",
+            "[options]\ninstall_requires = bar;python_version<3",
+            "[options]\ninstall_requires = bar;python_version<3\n",
+        ],
+    )
+    @pytest.mark.xfail(IS_PYPY, reason="Warnings missing on PyPy (minor issue)")
+    # TODO: investigate PyPy problem
+    def test_warn_accidental_env_marker_misconfig(self, config, tmpdir):
+        fake_env(tmpdir, config)
+        match = (
+            r"One of the parsed requirements in `(install_requires|extras_require.+)` "
+            "looks like a valid environment marker.*"
+        )
+        with pytest.warns(SetuptoolsDeprecationWarning, match=match):
+            with get_dist(tmpdir) as _:
+                pass
+
+    @pytest.mark.parametrize(
+        "config",
+        [
+            "[options.extras_require]\nfoo =\n    bar;python_version<'3'",
+            "[options.extras_require]\nfoo = bar;baz\nboo = xxx;yyy",
+            "[options.extras_require]\nfoo =\n    bar;python_version<'3'\n",
+            "[options.extras_require]\nfoo = bar;baz\nboo = xxx;yyy\n",
+            "[options.extras_require]\nfoo =\n    bar\n    python_version<3\n",
+            "[options]\ninstall_requires =\n    bar;python_version<'3'",
+            "[options]\ninstall_requires = bar;baz\nboo = xxx;yyy",
+            "[options]\ninstall_requires =\n    bar;python_version<'3'\n",
+            "[options]\ninstall_requires = bar;baz\nboo = xxx;yyy\n",
+            "[options]\ninstall_requires =\n    bar\n    python_version<3\n",
+        ],
+    )
+    @pytest.mark.filterwarnings("error::setuptools.SetuptoolsDeprecationWarning")
+    def test_nowarn_accidental_env_marker_misconfig(self, config, tmpdir, recwarn):
+        fake_env(tmpdir, config)
+        num_warnings = len(recwarn)
+        with get_dist(tmpdir) as _:
+            pass
+        # The examples are valid, no warnings shown
+        assert len(recwarn) == num_warnings
+
+    def test_dash_preserved_extras_require(self, tmpdir):
+        fake_env(tmpdir, '[options.extras_require]\nfoo-a = foo\nfoo_b = test\n')
+
+        with get_dist(tmpdir) as dist:
+            assert dist.extras_require == {'foo-a': ['foo'], 'foo_b': ['test']}
+
+    def test_entry_points(self, tmpdir):
+        _, config = fake_env(
+            tmpdir,
+            '[options.entry_points]\n'
+            'group1 = point1 = pack.module:func, '
+            '.point2 = pack.module2:func_rest [rest]\n'
+            'group2 = point3 = pack.module:func2\n',
+        )
+
+        with get_dist(tmpdir) as dist:
+            assert dist.entry_points == {
+                'group1': [
+                    'point1 = pack.module:func',
+                    '.point2 = pack.module2:func_rest [rest]',
+                ],
+                'group2': ['point3 = pack.module:func2'],
+            }
+
+        expected = (
+            '[blogtool.parsers]\n'
+            '.rst = some.nested.module:SomeClass.some_classmethod[reST]\n'
+        )
+
+        tmpdir.join('entry_points').write(expected)
+
+        # From file.
+        config.write('[options]\nentry_points = file: entry_points\n')
+
+        with get_dist(tmpdir) as dist:
+            assert dist.entry_points == expected
+
+    def test_case_sensitive_entry_points(self, tmpdir):
+        fake_env(
+            tmpdir,
+            '[options.entry_points]\n'
+            'GROUP1 = point1 = pack.module:func, '
+            '.point2 = pack.module2:func_rest [rest]\n'
+            'group2 = point3 = pack.module:func2\n',
+        )
+
+        with get_dist(tmpdir) as dist:
+            assert dist.entry_points == {
+                'GROUP1': [
+                    'point1 = pack.module:func',
+                    '.point2 = pack.module2:func_rest [rest]',
+                ],
+                'group2': ['point3 = pack.module:func2'],
+            }
+
+    def test_data_files(self, tmpdir):
+        fake_env(
+            tmpdir,
+            '[options.data_files]\n'
+            'cfg =\n'
+            '      a/b.conf\n'
+            '      c/d.conf\n'
+            'data = e/f.dat, g/h.dat\n',
+        )
+
+        with get_dist(tmpdir) as dist:
+            expected = [
+                ('cfg', ['a/b.conf', 'c/d.conf']),
+                ('data', ['e/f.dat', 'g/h.dat']),
+            ]
+            assert sorted(dist.data_files) == sorted(expected)
+
+    def test_data_files_globby(self, tmpdir):
+        fake_env(
+            tmpdir,
+            '[options.data_files]\n'
+            'cfg =\n'
+            '      a/b.conf\n'
+            '      c/d.conf\n'
+            'data = *.dat\n'
+            'icons = \n'
+            '      *.ico\n'
+            'audio = \n'
+            '      *.wav\n'
+            '      sounds.db\n',
+        )
+
+        # Create dummy files for glob()'s sake:
+        tmpdir.join('a.dat').write('')
+        tmpdir.join('b.dat').write('')
+        tmpdir.join('c.dat').write('')
+        tmpdir.join('a.ico').write('')
+        tmpdir.join('b.ico').write('')
+        tmpdir.join('c.ico').write('')
+        tmpdir.join('beep.wav').write('')
+        tmpdir.join('boop.wav').write('')
+        tmpdir.join('sounds.db').write('')
+
+        with get_dist(tmpdir) as dist:
+            expected = [
+                ('cfg', ['a/b.conf', 'c/d.conf']),
+                ('data', ['a.dat', 'b.dat', 'c.dat']),
+                ('icons', ['a.ico', 'b.ico', 'c.ico']),
+                ('audio', ['beep.wav', 'boop.wav', 'sounds.db']),
+            ]
+            assert sorted(dist.data_files) == sorted(expected)
+
+    def test_python_requires_simple(self, tmpdir):
+        fake_env(
+            tmpdir,
+            DALS(
+                """
+            [options]
+            python_requires=>=2.7
+            """
+            ),
+        )
+        with get_dist(tmpdir) as dist:
+            dist.parse_config_files()
+
+    def test_python_requires_compound(self, tmpdir):
+        fake_env(
+            tmpdir,
+            DALS(
+                """
+            [options]
+            python_requires=>=2.7,!=3.0.*
+            """
+            ),
+        )
+        with get_dist(tmpdir) as dist:
+            dist.parse_config_files()
+
+    def test_python_requires_invalid(self, tmpdir):
+        fake_env(
+            tmpdir,
+            DALS(
+                """
+            [options]
+            python_requires=invalid
+            """
+            ),
+        )
+        with pytest.raises(Exception):
+            with get_dist(tmpdir) as dist:
+                dist.parse_config_files()
+
+    def test_cmdclass(self, tmpdir):
+        module_path = Path(tmpdir, "src/custom_build.py")  # auto discovery for src
+        module_path.parent.mkdir(parents=True, exist_ok=True)
+        module_path.write_text(
+            "from distutils.core import Command\nclass CustomCmd(Command): pass\n",
+            encoding="utf-8",
+        )
+
+        setup_cfg = """
+            [options]
+            cmdclass =
+                customcmd = custom_build.CustomCmd
+        """
+        fake_env(tmpdir, inspect.cleandoc(setup_cfg))
+
+        with get_dist(tmpdir) as dist:
+            cmdclass = dist.cmdclass['customcmd']
+            assert cmdclass.__name__ == "CustomCmd"
+            assert cmdclass.__module__ == "custom_build"
+            assert module_path.samefile(inspect.getfile(cmdclass))
+
+    def test_requirements_file(self, tmpdir):
+        fake_env(
+            tmpdir,
+            DALS(
+                """
+            [options]
+            install_requires = file:requirements.txt
+            [options.extras_require]
+            colors = file:requirements-extra.txt
+            """
+            ),
+        )
+
+        tmpdir.join('requirements.txt').write('\ndocutils>=0.3\n\n')
+        tmpdir.join('requirements-extra.txt').write('colorama')
+
+        with get_dist(tmpdir) as dist:
+            assert dist.install_requires == ['docutils>=0.3']
+            assert dist.extras_require == {'colors': ['colorama']}
+
+
+saved_dist_init = _Distribution.__init__
+
+
+class TestExternalSetters:
+    # During creation of the setuptools Distribution() object, we call
+    # the init of the parent distutils Distribution object via
+    # _Distribution.__init__ ().
+    #
+    # It's possible distutils calls out to various keyword
+    # implementations (i.e. distutils.setup_keywords entry points)
+    # that may set a range of variables.
+    #
+    # This wraps distutil's Distribution.__init__ and simulates
+    # pbr or something else setting these values.
+    def _fake_distribution_init(self, dist, attrs):
+        saved_dist_init(dist, attrs)
+        # see self._DISTUTILS_UNSUPPORTED_METADATA
+        dist.metadata.long_description_content_type = 'text/something'
+        # Test overwrite setup() args
+        dist.metadata.project_urls = {
+            'Link One': 'https://example.com/one/',
+            'Link Two': 'https://example.com/two/',
+        }
+
+    @patch.object(_Distribution, '__init__', autospec=True)
+    def test_external_setters(self, mock_parent_init, tmpdir):
+        mock_parent_init.side_effect = self._fake_distribution_init
+
+        dist = Distribution(attrs={'project_urls': {'will_be': 'ignored'}})
+
+        assert dist.metadata.long_description_content_type == 'text/something'
+        assert dist.metadata.project_urls == {
+            'Link One': 'https://example.com/one/',
+            'Link Two': 'https://example.com/two/',
+        }
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/indexes/test_links_priority/external.html b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/indexes/test_links_priority/external.html
new file mode 100644
index 0000000000000000000000000000000000000000..92e4702f634dfb37a404bec3103b76f6afcaa917
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/indexes/test_links_priority/external.html
@@ -0,0 +1,3 @@
+
+bad old link
+
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/indexes/test_links_priority/simple/foobar/index.html b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/indexes/test_links_priority/simple/foobar/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..fefb028bd3ee7d45a414d6e96a7b2a21ffd7eda7
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/indexes/test_links_priority/simple/foobar/index.html
@@ -0,0 +1,4 @@
+
+foobar-0.1.tar.gz
    
+external homepage
    
+
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/integration/__init__.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/integration/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/integration/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/integration/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3eef0ecc0580f58991cecce928b697aa95f800b4
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/integration/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/integration/__pycache__/helpers.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/integration/__pycache__/helpers.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f8a82848975bc934c7e6c712c9f09d4ee5a6ebd5
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/integration/__pycache__/helpers.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/integration/__pycache__/test_pbr.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/integration/__pycache__/test_pbr.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f2619bef389cb49ebc8e3fad9fac5df72d20858f
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/integration/__pycache__/test_pbr.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/integration/__pycache__/test_pip_install_sdist.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/integration/__pycache__/test_pip_install_sdist.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ccdfdeeb37451bce0c6b1cd7b81db57b7e8f5a83
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/integration/__pycache__/test_pip_install_sdist.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/integration/helpers.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/integration/helpers.py
new file mode 100644
index 0000000000000000000000000000000000000000..16b13022913f62ba86df6b2480d22e3119cdb8cc
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/integration/helpers.py
@@ -0,0 +1,80 @@
+"""Reusable functions and classes for different types of integration tests.
+
+For example ``Archive`` can be used to check the contents of distribution built
+with setuptools, and ``run`` will always try to be as verbose as possible to
+facilitate debugging.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import tarfile
+from collections.abc import Iterator
+from pathlib import Path
+from zipfile import ZipFile, ZipInfo
+
+
+def run(cmd, env=None):
+    r = subprocess.run(
+        cmd,
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        env={**os.environ, **(env or {})},
+        # ^-- allow overwriting instead of discarding the current env
+    )
+
+    out = r.stdout + "\n" + r.stderr
+    # pytest omits stdout/err by default, if the test fails they help debugging
+    print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
+    print(f"Command: {cmd}\nreturn code: {r.returncode}\n\n{out}")
+
+    if r.returncode == 0:
+        return out
+    raise subprocess.CalledProcessError(r.returncode, cmd, r.stdout, r.stderr)
+
+
+class Archive:
+    """Compatibility layer for ZipFile/Info and TarFile/Info"""
+
+    def __init__(self, filename) -> None:
+        self._filename = filename
+        if filename.endswith("tar.gz"):
+            self._obj: tarfile.TarFile | ZipFile = tarfile.open(filename, "r:gz")
+        elif filename.endswith("zip"):
+            self._obj = ZipFile(filename)
+        else:
+            raise ValueError(f"{filename} doesn't seem to be a zip or tar.gz")
+
+    def __iter__(self) -> Iterator[ZipInfo] | Iterator[tarfile.TarInfo]:
+        if hasattr(self._obj, "infolist"):
+            return iter(self._obj.infolist())
+        return iter(self._obj)
+
+    def get_name(self, zip_or_tar_info):
+        if hasattr(zip_or_tar_info, "filename"):
+            return zip_or_tar_info.filename
+        return zip_or_tar_info.name
+
+    def get_content(self, zip_or_tar_info):
+        if hasattr(self._obj, "extractfile"):
+            content = self._obj.extractfile(zip_or_tar_info)
+            if content is None:
+                msg = f"Invalid {zip_or_tar_info.name} in {self._filename}"
+                raise ValueError(msg)
+            return str(content.read(), "utf-8")
+        return str(self._obj.read(zip_or_tar_info), "utf-8")
+
+
+def get_sdist_members(sdist_path):
+    with tarfile.open(sdist_path, "r:gz") as tar:
+        files = [Path(f) for f in tar.getnames()]
+    # remove root folder
+    relative_files = ("/".join(f.parts[1:]) for f in files)
+    return {f for f in relative_files if f}
+
+
+def get_wheel_members(wheel_path):
+    with ZipFile(wheel_path) as zipfile:
+        return set(zipfile.namelist())
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/integration/test_pbr.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/integration/test_pbr.py
new file mode 100644
index 0000000000000000000000000000000000000000..f89e5b8b2151430d0994836dd609f1b75490a336
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/integration/test_pbr.py
@@ -0,0 +1,20 @@
+import subprocess
+
+import pytest
+
+
+@pytest.mark.uses_network
+def test_pbr_integration(pbr_package, venv):
+    """Ensure pbr packages install."""
+    cmd = [
+        'python',
+        '-m',
+        'pip',
+        '-v',
+        'install',
+        '--no-build-isolation',
+        pbr_package,
+    ]
+    venv.run(cmd, stderr=subprocess.STDOUT)
+    out = venv.run(["python", "-c", "import mypkg.hello"])
+    assert "Hello world!" in out
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/integration/test_pip_install_sdist.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/integration/test_pip_install_sdist.py
new file mode 100644
index 0000000000000000000000000000000000000000..4e84f218323e6ad67adfbce07cea5a16e91a311c
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/integration/test_pip_install_sdist.py
@@ -0,0 +1,223 @@
+# https://github.com/python/mypy/issues/16936
+# mypy: disable-error-code="has-type"
+"""Integration tests for setuptools that focus on building packages via pip.
+
+The idea behind these tests is not to exhaustively check all the possible
+combinations of packages, operating systems, supporting libraries, etc, but
+rather check a limited number of popular packages and how they interact with
+the exposed public API. This way if any change in API is introduced, we hope to
+identify backward compatibility problems before publishing a release.
+
+The number of tested packages is purposefully kept small, to minimise duration
+and the associated maintenance cost (changes in the way these packages define
+their build process may require changes in the tests).
+"""
+
+import json
+import os
+import shutil
+import sys
+from enum import Enum
+from glob import glob
+from hashlib import md5
+from urllib.request import urlopen
+
+import pytest
+from packaging.requirements import Requirement
+
+from .helpers import Archive, run
+
+pytestmark = pytest.mark.integration
+
+
+(LATEST,) = Enum("v", "LATEST")  # type: ignore[misc] # https://github.com/python/mypy/issues/16936
+"""Default version to be checked"""
+# There are positive and negative aspects of checking the latest version of the
+# packages.
+# The main positive aspect is that the latest version might have already
+# removed the use of APIs deprecated in previous releases of setuptools.
+
+
+# Packages to be tested:
+# (Please notice the test environment cannot support EVERY library required for
+# compiling binary extensions. In Ubuntu/Debian nomenclature, we only assume
+# that `build-essential`, `gfortran` and `libopenblas-dev` are installed,
+# due to their relevance to the numerical/scientific programming ecosystem)
+EXAMPLES = [
+    ("pip", LATEST),  # just in case...
+    ("pytest", LATEST),  # uses setuptools_scm
+    ("mypy", LATEST),  # custom build_py + ext_modules
+    # --- Popular packages: https://hugovk.github.io/top-pypi-packages/ ---
+    ("botocore", LATEST),
+    ("kiwisolver", LATEST),  # build_ext
+    ("brotli", LATEST),  # not in the list but used by urllib3
+    ("pyyaml", LATEST),  # cython + custom build_ext + custom distclass
+    ("charset-normalizer", LATEST),  # uses mypyc, used by aiohttp
+    ("protobuf", LATEST),
+    # ("requests", LATEST),  # XXX: https://github.com/psf/requests/pull/6920
+    ("celery", LATEST),
+    # When adding packages to this list, make sure they expose a `__version__`
+    # attribute, or modify the tests below
+]
+
+
+# Some packages have "optional" dependencies that modify their build behaviour
+# and are not listed in pyproject.toml, others still use `setup_requires`
+EXTRA_BUILD_DEPS = {
+    "pyyaml": ("Cython<3.0",),  # constraint to avoid errors
+    "charset-normalizer": ("mypy>=1.4.1",),  # no pyproject.toml available
+}
+
+EXTRA_ENV_VARS = {
+    "pyyaml": {"PYYAML_FORCE_CYTHON": "1"},
+    "charset-normalizer": {"CHARSET_NORMALIZER_USE_MYPYC": "1"},
+}
+
+IMPORT_NAME = {
+    "pyyaml": "yaml",
+    "protobuf": "google.protobuf",
+}
+
+
+VIRTUALENV = (sys.executable, "-m", "virtualenv")
+
+
+# By default, pip will try to build packages in isolation (PEP 517), which
+# means it will download the previous stable version of setuptools.
+# `pip` flags can avoid that (the version of setuptools under test
+# should be the one to be used)
+INSTALL_OPTIONS = (
+    "--ignore-installed",
+    "--no-build-isolation",
+    # Omit "--no-binary :all:" the sdist is supplied directly.
+    # Allows dependencies as wheels.
+)
+# The downside of `--no-build-isolation` is that pip will not download build
+# dependencies. The test script will have to also handle that.
+
+
+@pytest.fixture
+def venv_python(tmp_path):
+    run([*VIRTUALENV, str(tmp_path / ".venv")])
+    possible_path = (str(p.parent) for p in tmp_path.glob(".venv/*/python*"))
+    return shutil.which("python", path=os.pathsep.join(possible_path))
+
+
+@pytest.fixture(autouse=True)
+def _prepare(tmp_path, venv_python, monkeypatch):
+    download_path = os.getenv("DOWNLOAD_PATH", str(tmp_path))
+    os.makedirs(download_path, exist_ok=True)
+
+    # Environment vars used for building some of the packages
+    monkeypatch.setenv("USE_MYPYC", "1")
+
+    yield
+
+    # Let's provide the maximum amount of information possible in the case
+    # it is necessary to debug the tests directly from the CI logs.
+    print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
+    print("Temporary directory:")
+    map(print, tmp_path.glob("*"))
+    print("Virtual environment:")
+    run([venv_python, "-m", "pip", "freeze"])
+
+
+@pytest.mark.parametrize(("package", "version"), EXAMPLES)
+@pytest.mark.uses_network
+def test_install_sdist(package, version, tmp_path, venv_python, setuptools_wheel):
+    venv_pip = (venv_python, "-m", "pip")
+    sdist = retrieve_sdist(package, version, tmp_path)
+    deps = build_deps(package, sdist)
+    if deps:
+        print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
+        print("Dependencies:", deps)
+        run([*venv_pip, "install", *deps])
+
+    # Use a virtualenv to simulate PEP 517 isolation
+    # but install fresh setuptools wheel to ensure the version under development
+    env = EXTRA_ENV_VARS.get(package, {})
+    run([*venv_pip, "install", "--force-reinstall", setuptools_wheel])
+    run([*venv_pip, "install", *INSTALL_OPTIONS, sdist], env)
+
+    # Execute a simple script to make sure the package was installed correctly
+    pkg = IMPORT_NAME.get(package, package).replace("-", "_")
+    script = f"import {pkg}; print(getattr({pkg}, '__version__', 0))"
+    run([venv_python, "-c", script])
+
+
+# ---- Helper Functions ----
+
+
+def retrieve_sdist(package, version, tmp_path):
+    """Either use cached sdist file or download it from PyPI"""
+    # `pip download` cannot be used due to
+    # https://github.com/pypa/pip/issues/1884
+    # https://discuss.python.org/t/pep-625-file-name-of-a-source-distribution/4686
+    # We have to find the correct distribution file and download it
+    download_path = os.getenv("DOWNLOAD_PATH", str(tmp_path))
+    dist = retrieve_pypi_sdist_metadata(package, version)
+
+    # Remove old files to prevent cache to grow indefinitely
+    for file in glob(os.path.join(download_path, f"{package}*")):
+        if dist["filename"] != file:
+            os.unlink(file)
+
+    dist_file = os.path.join(download_path, dist["filename"])
+    if not os.path.exists(dist_file):
+        download(dist["url"], dist_file, dist["md5_digest"])
+    return dist_file
+
+
+def retrieve_pypi_sdist_metadata(package, version):
+    # https://warehouse.pypa.io/api-reference/json.html
+    id_ = package if version is LATEST else f"{package}/{version}"
+    with urlopen(f"https://pypi.org/pypi/{id_}/json") as f:
+        metadata = json.load(f)
+
+    if metadata["info"]["yanked"]:
+        raise ValueError(f"Release for {package} {version} was yanked")
+
+    version = metadata["info"]["version"]
+    release = metadata["releases"][version] if version is LATEST else metadata["urls"]
+    (sdist,) = filter(lambda d: d["packagetype"] == "sdist", release)
+    return sdist
+
+
+def download(url, dest, md5_digest):
+    with urlopen(url) as f:
+        data = f.read()
+
+    assert md5(data).hexdigest() == md5_digest
+
+    with open(dest, "wb") as f:
+        f.write(data)
+
+    assert os.path.exists(dest)
+
+
+def build_deps(package, sdist_file):
+    """Find out what are the build dependencies for a package.
+
+    "Manually" install them, since pip will not install build
+    deps with `--no-build-isolation`.
+    """
+    # delay importing, since pytest discovery phase may hit this file from a
+    # testenv without tomli
+    from setuptools.compat.py310 import tomllib
+
+    archive = Archive(sdist_file)
+    info = tomllib.loads(_read_pyproject(archive))
+    deps = info.get("build-system", {}).get("requires", [])
+    deps += EXTRA_BUILD_DEPS.get(package, [])
+    # Remove setuptools from requirements (and deduplicate)
+    requirements = {Requirement(d).name: d for d in deps}
+    return [v for k, v in requirements.items() if k != "setuptools"]
+
+
+def _read_pyproject(archive):
+    contents = (
+        archive.get_content(member)
+        for member in archive
+        if os.path.basename(archive.get_name(member)) == "pyproject.toml"
+    )
+    return next(contents, "")
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/test_bdist_deprecations.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/test_bdist_deprecations.py
new file mode 100644
index 0000000000000000000000000000000000000000..d9d67b06161a2b36e7b15fab09f797c5c15575c2
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/test_bdist_deprecations.py
@@ -0,0 +1,28 @@
+"""develop tests"""
+
+import sys
+from unittest import mock
+
+import pytest
+
+from setuptools import SetuptoolsDeprecationWarning
+from setuptools.dist import Distribution
+
+
+@pytest.mark.skipif(sys.platform == 'win32', reason='non-Windows only')
+@pytest.mark.xfail(reason="bdist_rpm is long deprecated, should we remove it? #1988")
+@mock.patch('distutils.command.bdist_rpm.bdist_rpm')
+def test_bdist_rpm_warning(distutils_cmd, tmpdir_cwd):
+    dist = Distribution(
+        dict(
+            script_name='setup.py',
+            script_args=['bdist_rpm'],
+            name='foo',
+            py_modules=['hi'],
+        )
+    )
+    dist.parse_command_line()
+    with pytest.warns(SetuptoolsDeprecationWarning):
+        dist.run_commands()
+
+    distutils_cmd.run.assert_called_once()
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/test_build_meta.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/test_build_meta.py
new file mode 100644
index 0000000000000000000000000000000000000000..2cd0a0a8ede8ecb8d0c5ae55c8c3b09559239ed5
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/test_build_meta.py
@@ -0,0 +1,959 @@
+import contextlib
+import importlib
+import os
+import re
+import shutil
+import signal
+import sys
+import tarfile
+import warnings
+from concurrent import futures
+from pathlib import Path
+from typing import Any, Callable
+from zipfile import ZipFile
+
+import pytest
+from jaraco import path
+from packaging.requirements import Requirement
+
+from setuptools.warnings import SetuptoolsDeprecationWarning
+
+from .textwrap import DALS
+
+SETUP_SCRIPT_STUB = "__import__('setuptools').setup()"
+
+
+TIMEOUT = int(os.getenv("TIMEOUT_BACKEND_TEST", "180"))  # in seconds
+IS_PYPY = '__pypy__' in sys.builtin_module_names
+
+
+pytestmark = pytest.mark.skipif(
+    sys.platform == "win32" and IS_PYPY,
+    reason="The combination of PyPy + Windows + pytest-xdist + ProcessPoolExecutor "
+    "is flaky and problematic",
+)
+
+
+class BuildBackendBase:
+    def __init__(self, cwd='.', env=None, backend_name='setuptools.build_meta') -> None:
+        self.cwd = cwd
+        self.env = env or {}
+        self.backend_name = backend_name
+
+
+class BuildBackend(BuildBackendBase):
+    """PEP 517 Build Backend"""
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.pool = futures.ProcessPoolExecutor(max_workers=1)
+
+    def __getattr__(self, name: str) -> Callable[..., Any]:
+        """Handles arbitrary function invocations on the build backend."""
+
+        def method(*args, **kw):
+            root = os.path.abspath(self.cwd)
+            caller = BuildBackendCaller(root, self.env, self.backend_name)
+            pid = None
+            try:
+                pid = self.pool.submit(os.getpid).result(TIMEOUT)
+                return self.pool.submit(caller, name, *args, **kw).result(TIMEOUT)
+            except futures.TimeoutError:
+                self.pool.shutdown(wait=False)  # doesn't stop already running processes
+                self._kill(pid)
+                pytest.xfail(f"Backend did not respond before timeout ({TIMEOUT} s)")
+            except (futures.process.BrokenProcessPool, MemoryError, OSError):
+                if IS_PYPY:
+                    pytest.xfail("PyPy frequently fails tests with ProcessPoolExector")
+                raise
+
+        return method
+
+    def _kill(self, pid):
+        if pid is None:
+            return
+        with contextlib.suppress(ProcessLookupError, OSError):
+            os.kill(pid, signal.SIGTERM if os.name == "nt" else signal.SIGKILL)
+
+
+class BuildBackendCaller(BuildBackendBase):
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+
+        (self.backend_name, _, self.backend_obj) = self.backend_name.partition(':')
+
+    def __call__(self, name, *args, **kw) -> Any:
+        """Handles arbitrary function invocations on the build backend."""
+        os.chdir(self.cwd)
+        os.environ.update(self.env)
+        mod = importlib.import_module(self.backend_name)
+
+        if self.backend_obj:
+            backend = getattr(mod, self.backend_obj)
+        else:
+            backend = mod
+
+        return getattr(backend, name)(*args, **kw)
+
+
+defns = [
+    {  # simple setup.py script
+        'setup.py': DALS(
+            """
+            __import__('setuptools').setup(
+                name='foo',
+                version='0.0.0',
+                py_modules=['hello'],
+                setup_requires=['six'],
+            )
+            """
+        ),
+        'hello.py': DALS(
+            """
+            def run():
+                print('hello')
+            """
+        ),
+    },
+    {  # setup.py that relies on __name__
+        'setup.py': DALS(
+            """
+            assert __name__ == '__main__'
+            __import__('setuptools').setup(
+                name='foo',
+                version='0.0.0',
+                py_modules=['hello'],
+                setup_requires=['six'],
+            )
+            """
+        ),
+        'hello.py': DALS(
+            """
+            def run():
+                print('hello')
+            """
+        ),
+    },
+    {  # setup.py script that runs arbitrary code
+        'setup.py': DALS(
+            """
+            variable = True
+            def function():
+                return variable
+            assert variable
+            __import__('setuptools').setup(
+                name='foo',
+                version='0.0.0',
+                py_modules=['hello'],
+                setup_requires=['six'],
+            )
+            """
+        ),
+        'hello.py': DALS(
+            """
+            def run():
+                print('hello')
+            """
+        ),
+    },
+    {  # setup.py script that constructs temp files to be included in the distribution
+        'setup.py': DALS(
+            """
+            # Some packages construct files on the fly, include them in the package,
+            # and immediately remove them after `setup()` (e.g. pybind11==2.9.1).
+            # Therefore, we cannot use `distutils.core.run_setup(..., stop_after=...)`
+            # to obtain a distribution object first, and then run the distutils
+            # commands later, because these files will be removed in the meantime.
+
+            with open('world.py', 'w', encoding="utf-8") as f:
+                f.write('x = 42')
+
+            try:
+                __import__('setuptools').setup(
+                    name='foo',
+                    version='0.0.0',
+                    py_modules=['world'],
+                    setup_requires=['six'],
+                )
+            finally:
+                # Some packages will clean temporary files
+                __import__('os').unlink('world.py')
+            """
+        ),
+    },
+    {  # setup.cfg only
+        'setup.cfg': DALS(
+            """
+        [metadata]
+        name = foo
+        version = 0.0.0
+
+        [options]
+        py_modules=hello
+        setup_requires=six
+        """
+        ),
+        'hello.py': DALS(
+            """
+        def run():
+            print('hello')
+        """
+        ),
+    },
+    {  # setup.cfg and setup.py
+        'setup.cfg': DALS(
+            """
+        [metadata]
+        name = foo
+        version = 0.0.0
+
+        [options]
+        py_modules=hello
+        setup_requires=six
+        """
+        ),
+        'setup.py': "__import__('setuptools').setup()",
+        'hello.py': DALS(
+            """
+        def run():
+            print('hello')
+        """
+        ),
+    },
+]
+
+
+class TestBuildMetaBackend:
+    backend_name = 'setuptools.build_meta'
+
+    def get_build_backend(self):
+        return BuildBackend(backend_name=self.backend_name)
+
+    @pytest.fixture(params=defns)
+    def build_backend(self, tmpdir, request):
+        path.build(request.param, prefix=str(tmpdir))
+        with tmpdir.as_cwd():
+            yield self.get_build_backend()
+
+    def test_get_requires_for_build_wheel(self, build_backend):
+        actual = build_backend.get_requires_for_build_wheel()
+        expected = ['six']
+        assert sorted(actual) == sorted(expected)
+
+    def test_get_requires_for_build_sdist(self, build_backend):
+        actual = build_backend.get_requires_for_build_sdist()
+        expected = ['six']
+        assert sorted(actual) == sorted(expected)
+
+    def test_build_wheel(self, build_backend):
+        dist_dir = os.path.abspath('pip-wheel')
+        os.makedirs(dist_dir)
+        wheel_name = build_backend.build_wheel(dist_dir)
+
+        wheel_file = os.path.join(dist_dir, wheel_name)
+        assert os.path.isfile(wheel_file)
+
+        # Temporary files should be removed
+        assert not os.path.isfile('world.py')
+
+        with ZipFile(wheel_file) as zipfile:
+            wheel_contents = set(zipfile.namelist())
+
+        # Each one of the examples have a single module
+        # that should be included in the distribution
+        python_scripts = (f for f in wheel_contents if f.endswith('.py'))
+        modules = [f for f in python_scripts if not f.endswith('setup.py')]
+        assert len(modules) == 1
+
+    @pytest.mark.parametrize('build_type', ('wheel', 'sdist'))
+    def test_build_with_existing_file_present(self, build_type, tmpdir_cwd):
+        # Building a sdist/wheel should still succeed if there's
+        # already a sdist/wheel in the destination directory.
+        files = {
+            'setup.py': "from setuptools import setup\nsetup()",
+            'VERSION': "0.0.1",
+            'setup.cfg': DALS(
+                """
+                [metadata]
+                name = foo
+                version = file: VERSION
+                """
+            ),
+            'pyproject.toml': DALS(
+                """
+                [build-system]
+                requires = ["setuptools", "wheel"]
+                build-backend = "setuptools.build_meta"
+                """
+            ),
+        }
+
+        path.build(files)
+
+        dist_dir = os.path.abspath('preexisting-' + build_type)
+
+        build_backend = self.get_build_backend()
+        build_method = getattr(build_backend, 'build_' + build_type)
+
+        # Build a first sdist/wheel.
+        # Note: this also check the destination directory is
+        # successfully created if it does not exist already.
+        first_result = build_method(dist_dir)
+
+        # Change version.
+        with open("VERSION", "wt", encoding="utf-8") as version_file:
+            version_file.write("0.0.2")
+
+        # Build a *second* sdist/wheel.
+        second_result = build_method(dist_dir)
+
+        assert os.path.isfile(os.path.join(dist_dir, first_result))
+        assert first_result != second_result
+
+        # And if rebuilding the exact same sdist/wheel?
+        open(os.path.join(dist_dir, second_result), 'wb').close()
+        third_result = build_method(dist_dir)
+        assert third_result == second_result
+        assert os.path.getsize(os.path.join(dist_dir, third_result)) > 0
+
+    @pytest.mark.parametrize("setup_script", [None, SETUP_SCRIPT_STUB])
+    def test_build_with_pyproject_config(self, tmpdir, setup_script):
+        files = {
+            'pyproject.toml': DALS(
+                """
+                [build-system]
+                requires = ["setuptools", "wheel"]
+                build-backend = "setuptools.build_meta"
+
+                [project]
+                name = "foo"
+                license = {text = "MIT"}
+                description = "This is a Python package"
+                dynamic = ["version", "readme"]
+                classifiers = [
+                    "Development Status :: 5 - Production/Stable",
+                    "Intended Audience :: Developers"
+                ]
+                urls = {Homepage = "http://github.com"}
+                dependencies = [
+                    "appdirs",
+                ]
+
+                [project.optional-dependencies]
+                all = [
+                    "tomli>=1",
+                    "pyscaffold>=4,<5",
+                    'importlib; python_version == "2.6"',
+                ]
+
+                [project.scripts]
+                foo = "foo.cli:main"
+
+                [tool.setuptools]
+                zip-safe = false
+                package-dir = {"" = "src"}
+                packages = {find = {where = ["src"]}}
+                license-files = ["LICENSE*"]
+
+                [tool.setuptools.dynamic]
+                version = {attr = "foo.__version__"}
+                readme = {file = "README.rst"}
+
+                [tool.distutils.sdist]
+                formats = "gztar"
+                """
+            ),
+            "MANIFEST.in": DALS(
+                """
+                global-include *.py *.txt
+                global-exclude *.py[cod]
+                """
+            ),
+            "README.rst": "This is a ``README``",
+            "LICENSE.txt": "---- placeholder MIT license ----",
+            "src": {
+                "foo": {
+                    "__init__.py": "__version__ = '0.1'",
+                    "__init__.pyi": "__version__: str",
+                    "cli.py": "def main(): print('hello world')",
+                    "data.txt": "def main(): print('hello world')",
+                    "py.typed": "",
+                }
+            },
+        }
+        if setup_script:
+            files["setup.py"] = setup_script
+
+        build_backend = self.get_build_backend()
+        with tmpdir.as_cwd():
+            path.build(files)
+            msgs = [
+                "'tool.setuptools.license-files' is deprecated in favor of 'project.license-files'",
+                "`project.license` as a TOML table is deprecated",
+            ]
+            with warnings.catch_warnings():
+                for msg in msgs:
+                    warnings.filterwarnings("ignore", msg, SetuptoolsDeprecationWarning)
+                sdist_path = build_backend.build_sdist("temp")
+                wheel_file = build_backend.build_wheel("temp")
+
+        with tarfile.open(os.path.join(tmpdir, "temp", sdist_path)) as tar:
+            sdist_contents = set(tar.getnames())
+
+        with ZipFile(os.path.join(tmpdir, "temp", wheel_file)) as zipfile:
+            wheel_contents = set(zipfile.namelist())
+            metadata = str(zipfile.read("foo-0.1.dist-info/METADATA"), "utf-8")
+            license = str(
+                zipfile.read("foo-0.1.dist-info/licenses/LICENSE.txt"), "utf-8"
+            )
+            epoints = str(zipfile.read("foo-0.1.dist-info/entry_points.txt"), "utf-8")
+
+        assert sdist_contents - {"foo-0.1/setup.py"} == {
+            'foo-0.1',
+            'foo-0.1/LICENSE.txt',
+            'foo-0.1/MANIFEST.in',
+            'foo-0.1/PKG-INFO',
+            'foo-0.1/README.rst',
+            'foo-0.1/pyproject.toml',
+            'foo-0.1/setup.cfg',
+            'foo-0.1/src',
+            'foo-0.1/src/foo',
+            'foo-0.1/src/foo/__init__.py',
+            'foo-0.1/src/foo/__init__.pyi',
+            'foo-0.1/src/foo/cli.py',
+            'foo-0.1/src/foo/data.txt',
+            'foo-0.1/src/foo/py.typed',
+            'foo-0.1/src/foo.egg-info',
+            'foo-0.1/src/foo.egg-info/PKG-INFO',
+            'foo-0.1/src/foo.egg-info/SOURCES.txt',
+            'foo-0.1/src/foo.egg-info/dependency_links.txt',
+            'foo-0.1/src/foo.egg-info/entry_points.txt',
+            'foo-0.1/src/foo.egg-info/requires.txt',
+            'foo-0.1/src/foo.egg-info/top_level.txt',
+            'foo-0.1/src/foo.egg-info/not-zip-safe',
+        }
+        assert wheel_contents == {
+            "foo/__init__.py",
+            "foo/__init__.pyi",  # include type information by default
+            "foo/cli.py",
+            "foo/data.txt",  # include_package_data defaults to True
+            "foo/py.typed",  # include type information by default
+            "foo-0.1.dist-info/licenses/LICENSE.txt",
+            "foo-0.1.dist-info/METADATA",
+            "foo-0.1.dist-info/WHEEL",
+            "foo-0.1.dist-info/entry_points.txt",
+            "foo-0.1.dist-info/top_level.txt",
+            "foo-0.1.dist-info/RECORD",
+        }
+        assert license == "---- placeholder MIT license ----"
+
+        for line in (
+            "Summary: This is a Python package",
+            "License: MIT",
+            "License-File: LICENSE.txt",
+            "Classifier: Intended Audience :: Developers",
+            "Requires-Dist: appdirs",
+            "Requires-Dist: " + str(Requirement('tomli>=1 ; extra == "all"')),
+            "Requires-Dist: "
+            + str(Requirement('importlib; python_version=="2.6" and extra =="all"')),
+        ):
+            assert line in metadata, (line, metadata)
+
+        assert metadata.strip().endswith("This is a ``README``")
+        assert epoints.strip() == "[console_scripts]\nfoo = foo.cli:main"
+
+    def test_static_metadata_in_pyproject_config(self, tmpdir):
+        # Make sure static metadata in pyproject.toml is not overwritten by setup.py
+        # as required by PEP 621
+        files = {
+            'pyproject.toml': DALS(
+                """
+                [build-system]
+                requires = ["setuptools", "wheel"]
+                build-backend = "setuptools.build_meta"
+
+                [project]
+                name = "foo"
+                description = "This is a Python package"
+                version = "42"
+                dependencies = ["six"]
+                """
+            ),
+            'hello.py': DALS(
+                """
+                def run():
+                    print('hello')
+                """
+            ),
+            'setup.py': DALS(
+                """
+                __import__('setuptools').setup(
+                    name='bar',
+                    version='13',
+                )
+                """
+            ),
+        }
+        build_backend = self.get_build_backend()
+        with tmpdir.as_cwd():
+            path.build(files)
+            sdist_path = build_backend.build_sdist("temp")
+            wheel_file = build_backend.build_wheel("temp")
+
+        assert (tmpdir / "temp/foo-42.tar.gz").exists()
+        assert (tmpdir / "temp/foo-42-py3-none-any.whl").exists()
+        assert not (tmpdir / "temp/bar-13.tar.gz").exists()
+        assert not (tmpdir / "temp/bar-42.tar.gz").exists()
+        assert not (tmpdir / "temp/foo-13.tar.gz").exists()
+        assert not (tmpdir / "temp/bar-13-py3-none-any.whl").exists()
+        assert not (tmpdir / "temp/bar-42-py3-none-any.whl").exists()
+        assert not (tmpdir / "temp/foo-13-py3-none-any.whl").exists()
+
+        with tarfile.open(os.path.join(tmpdir, "temp", sdist_path)) as tar:
+            pkg_info = str(tar.extractfile('foo-42/PKG-INFO').read(), "utf-8")
+            members = tar.getnames()
+            assert "bar-13/PKG-INFO" not in members
+
+        with ZipFile(os.path.join(tmpdir, "temp", wheel_file)) as zipfile:
+            metadata = str(zipfile.read("foo-42.dist-info/METADATA"), "utf-8")
+            members = zipfile.namelist()
+            assert "bar-13.dist-info/METADATA" not in members
+
+        for file in pkg_info, metadata:
+            for line in ("Name: foo", "Version: 42"):
+                assert line in file
+            for line in ("Name: bar", "Version: 13"):
+                assert line not in file
+
+    def test_build_sdist(self, build_backend):
+        dist_dir = os.path.abspath('pip-sdist')
+        os.makedirs(dist_dir)
+        sdist_name = build_backend.build_sdist(dist_dir)
+
+        assert os.path.isfile(os.path.join(dist_dir, sdist_name))
+
+    def test_prepare_metadata_for_build_wheel(self, build_backend):
+        dist_dir = os.path.abspath('pip-dist-info')
+        os.makedirs(dist_dir)
+
+        dist_info = build_backend.prepare_metadata_for_build_wheel(dist_dir)
+
+        assert os.path.isfile(os.path.join(dist_dir, dist_info, 'METADATA'))
+
+    def test_prepare_metadata_inplace(self, build_backend):
+        """
+        Some users might pass metadata_directory pre-populated with `.tox` or `.venv`.
+        See issue #3523.
+        """
+        for pre_existing in [
+            ".tox/python/lib/python3.10/site-packages/attrs-22.1.0.dist-info",
+            ".tox/python/lib/python3.10/site-packages/autocommand-2.2.1.dist-info",
+            ".nox/python/lib/python3.10/site-packages/build-0.8.0.dist-info",
+            ".venv/python3.10/site-packages/click-8.1.3.dist-info",
+            "venv/python3.10/site-packages/distlib-0.3.5.dist-info",
+            "env/python3.10/site-packages/docutils-0.19.dist-info",
+        ]:
+            os.makedirs(pre_existing, exist_ok=True)
+        dist_info = build_backend.prepare_metadata_for_build_wheel(".")
+        assert os.path.isfile(os.path.join(dist_info, 'METADATA'))
+
+    def test_build_sdist_explicit_dist(self, build_backend):
+        # explicitly specifying the dist folder should work
+        # the folder sdist_directory and the ``--dist-dir`` can be the same
+        dist_dir = os.path.abspath('dist')
+        sdist_name = build_backend.build_sdist(dist_dir)
+        assert os.path.isfile(os.path.join(dist_dir, sdist_name))
+
+    def test_build_sdist_version_change(self, build_backend):
+        sdist_into_directory = os.path.abspath("out_sdist")
+        os.makedirs(sdist_into_directory)
+
+        sdist_name = build_backend.build_sdist(sdist_into_directory)
+        assert os.path.isfile(os.path.join(sdist_into_directory, sdist_name))
+
+        # if the setup.py changes subsequent call of the build meta
+        # should still succeed, given the
+        # sdist_directory the frontend specifies is empty
+        setup_loc = os.path.abspath("setup.py")
+        if not os.path.exists(setup_loc):
+            setup_loc = os.path.abspath("setup.cfg")
+
+        with open(setup_loc, 'rt', encoding="utf-8") as file_handler:
+            content = file_handler.read()
+        with open(setup_loc, 'wt', encoding="utf-8") as file_handler:
+            file_handler.write(content.replace("version='0.0.0'", "version='0.0.1'"))
+
+        shutil.rmtree(sdist_into_directory)
+        os.makedirs(sdist_into_directory)
+
+        sdist_name = build_backend.build_sdist("out_sdist")
+        assert os.path.isfile(os.path.join(os.path.abspath("out_sdist"), sdist_name))
+
+    def test_build_sdist_pyproject_toml_exists(self, tmpdir_cwd):
+        files = {
+            'setup.py': DALS(
+                """
+                __import__('setuptools').setup(
+                    name='foo',
+                    version='0.0.0',
+                    py_modules=['hello']
+                )"""
+            ),
+            'hello.py': '',
+            'pyproject.toml': DALS(
+                """
+                [build-system]
+                requires = ["setuptools", "wheel"]
+                build-backend = "setuptools.build_meta"
+                """
+            ),
+        }
+        path.build(files)
+        build_backend = self.get_build_backend()
+        targz_path = build_backend.build_sdist("temp")
+        with tarfile.open(os.path.join("temp", targz_path)) as tar:
+            assert any('pyproject.toml' in name for name in tar.getnames())
+
+    def test_build_sdist_setup_py_exists(self, tmpdir_cwd):
+        # If build_sdist is called from a script other than setup.py,
+        # ensure setup.py is included
+        path.build(defns[0])
+
+        build_backend = self.get_build_backend()
+        targz_path = build_backend.build_sdist("temp")
+        with tarfile.open(os.path.join("temp", targz_path)) as tar:
+            assert any('setup.py' in name for name in tar.getnames())
+
+    def test_build_sdist_setup_py_manifest_excluded(self, tmpdir_cwd):
+        # Ensure that MANIFEST.in can exclude setup.py
+        files = {
+            'setup.py': DALS(
+                """
+        __import__('setuptools').setup(
+            name='foo',
+            version='0.0.0',
+            py_modules=['hello']
+        )"""
+            ),
+            'hello.py': '',
+            'MANIFEST.in': DALS(
+                """
+        exclude setup.py
+        """
+            ),
+        }
+
+        path.build(files)
+
+        build_backend = self.get_build_backend()
+        targz_path = build_backend.build_sdist("temp")
+        with tarfile.open(os.path.join("temp", targz_path)) as tar:
+            assert not any('setup.py' in name for name in tar.getnames())
+
+    def test_build_sdist_builds_targz_even_if_zip_indicated(self, tmpdir_cwd):
+        files = {
+            'setup.py': DALS(
+                """
+                __import__('setuptools').setup(
+                    name='foo',
+                    version='0.0.0',
+                    py_modules=['hello']
+                )"""
+            ),
+            'hello.py': '',
+            'setup.cfg': DALS(
+                """
+                [sdist]
+                formats=zip
+                """
+            ),
+        }
+
+        path.build(files)
+
+        build_backend = self.get_build_backend()
+        build_backend.build_sdist("temp")
+
+    _relative_path_import_files = {
+        'setup.py': DALS(
+            """
+            __import__('setuptools').setup(
+                name='foo',
+                version=__import__('hello').__version__,
+                py_modules=['hello']
+            )"""
+        ),
+        'hello.py': '__version__ = "0.0.0"',
+        'setup.cfg': DALS(
+            """
+            [sdist]
+            formats=zip
+            """
+        ),
+    }
+
+    def test_build_sdist_relative_path_import(self, tmpdir_cwd):
+        path.build(self._relative_path_import_files)
+        build_backend = self.get_build_backend()
+        with pytest.raises(ImportError, match="^No module named 'hello'$"):
+            build_backend.build_sdist("temp")
+
+    _simple_pyproject_example = {
+        "pyproject.toml": DALS(
+            """
+            [project]
+            name = "proj"
+            version = "42"
+            """
+        ),
+        "src": {"proj": {"__init__.py": ""}},
+    }
+
+    def _assert_link_tree(self, parent_dir):
+        """All files in the directory should be either links or hard links"""
+        files = list(Path(parent_dir).glob("**/*"))
+        assert files  # Should not be empty
+        for file in files:
+            assert file.is_symlink() or os.stat(file).st_nlink > 0
+
+    def test_editable_without_config_settings(self, tmpdir_cwd):
+        """
+        Sanity check to ensure tests with --mode=strict are different from the ones
+        without --mode.
+
+        --mode=strict should create a local directory with a package tree.
+        The directory should not get created otherwise.
+        """
+        path.build(self._simple_pyproject_example)
+        build_backend = self.get_build_backend()
+        assert not Path("build").exists()
+        build_backend.build_editable("temp")
+        assert not Path("build").exists()
+
+    def test_build_wheel_inplace(self, tmpdir_cwd):
+        config_settings = {"--build-option": ["build_ext", "--inplace"]}
+        path.build(self._simple_pyproject_example)
+        build_backend = self.get_build_backend()
+        assert not Path("build").exists()
+        Path("build").mkdir()
+        build_backend.prepare_metadata_for_build_wheel("build", config_settings)
+        build_backend.build_wheel("build", config_settings)
+        assert Path("build/proj-42-py3-none-any.whl").exists()
+
+    @pytest.mark.parametrize("config_settings", [{"editable-mode": "strict"}])
+    def test_editable_with_config_settings(self, tmpdir_cwd, config_settings):
+        path.build({**self._simple_pyproject_example, '_meta': {}})
+        assert not Path("build").exists()
+        build_backend = self.get_build_backend()
+        build_backend.prepare_metadata_for_build_editable("_meta", config_settings)
+        build_backend.build_editable("temp", config_settings, "_meta")
+        self._assert_link_tree(next(Path("build").glob("__editable__.*")))
+
+    @pytest.mark.parametrize(
+        ("setup_literal", "requirements"),
+        [
+            ("'foo'", ['foo']),
+            ("['foo']", ['foo']),
+            (r"'foo\n'", ['foo']),
+            (r"'foo\n\n'", ['foo']),
+            ("['foo', 'bar']", ['foo', 'bar']),
+            (r"'# Has a comment line\nfoo'", ['foo']),
+            (r"'foo # Has an inline comment'", ['foo']),
+            (r"'foo \\\n >=3.0'", ['foo>=3.0']),
+            (r"'foo\nbar'", ['foo', 'bar']),
+            (r"'foo\nbar\n'", ['foo', 'bar']),
+            (r"['foo\n', 'bar\n']", ['foo', 'bar']),
+        ],
+    )
+    @pytest.mark.parametrize('use_wheel', [True, False])
+    def test_setup_requires(self, setup_literal, requirements, use_wheel, tmpdir_cwd):
+        files = {
+            'setup.py': DALS(
+                """
+                from setuptools import setup
+
+                setup(
+                    name="qux",
+                    version="0.0.0",
+                    py_modules=["hello"],
+                    setup_requires={setup_literal},
+                )
+            """
+            ).format(setup_literal=setup_literal),
+            'hello.py': DALS(
+                """
+            def run():
+                print('hello')
+            """
+            ),
+        }
+
+        path.build(files)
+
+        build_backend = self.get_build_backend()
+
+        if use_wheel:
+            get_requires = build_backend.get_requires_for_build_wheel
+        else:
+            get_requires = build_backend.get_requires_for_build_sdist
+
+        # Ensure that the build requirements are properly parsed
+        expected = sorted(requirements)
+        actual = get_requires()
+
+        assert expected == sorted(actual)
+
+    def test_setup_requires_with_auto_discovery(self, tmpdir_cwd):
+        # Make sure patches introduced to retrieve setup_requires don't accidentally
+        # activate auto-discovery and cause problems due to the incomplete set of
+        # attributes passed to MinimalDistribution
+        files = {
+            'pyproject.toml': DALS(
+                """
+                [project]
+                name = "proj"
+                version = "42"
+            """
+            ),
+            "setup.py": DALS(
+                """
+                __import__('setuptools').setup(
+                    setup_requires=["foo"],
+                    py_modules = ["hello", "world"]
+                )
+            """
+            ),
+            'hello.py': "'hello'",
+            'world.py': "'world'",
+        }
+        path.build(files)
+        build_backend = self.get_build_backend()
+        setup_requires = build_backend.get_requires_for_build_wheel()
+        assert setup_requires == ["foo"]
+
+    def test_dont_install_setup_requires(self, tmpdir_cwd):
+        files = {
+            'setup.py': DALS(
+                """
+                        from setuptools import setup
+
+                        setup(
+                            name="qux",
+                            version="0.0.0",
+                            py_modules=["hello"],
+                            setup_requires=["does-not-exist >99"],
+                        )
+                    """
+            ),
+            'hello.py': DALS(
+                """
+                    def run():
+                        print('hello')
+                    """
+            ),
+        }
+
+        path.build(files)
+
+        build_backend = self.get_build_backend()
+
+        dist_dir = os.path.abspath('pip-dist-info')
+        os.makedirs(dist_dir)
+
+        # does-not-exist can't be satisfied, so if it attempts to install
+        # setup_requires, it will fail.
+        build_backend.prepare_metadata_for_build_wheel(dist_dir)
+
+    _sys_argv_0_passthrough = {
+        'setup.py': DALS(
+            """
+            import os
+            import sys
+
+            __import__('setuptools').setup(
+                name='foo',
+                version='0.0.0',
+            )
+
+            sys_argv = os.path.abspath(sys.argv[0])
+            file_path = os.path.abspath('setup.py')
+            assert sys_argv == file_path
+            """
+        )
+    }
+
+    def test_sys_argv_passthrough(self, tmpdir_cwd):
+        path.build(self._sys_argv_0_passthrough)
+        build_backend = self.get_build_backend()
+        with pytest.raises(AssertionError):
+            build_backend.build_sdist("temp")
+
+    _setup_py_file_abspath = {
+        'setup.py': DALS(
+            """
+            import os
+            assert os.path.isabs(__file__)
+            __import__('setuptools').setup(
+                name='foo',
+                version='0.0.0',
+                py_modules=['hello'],
+                setup_requires=['six'],
+            )
+            """
+        )
+    }
+
+    def test_setup_py_file_abspath(self, tmpdir_cwd):
+        path.build(self._setup_py_file_abspath)
+        build_backend = self.get_build_backend()
+        build_backend.build_sdist("temp")
+
+    @pytest.mark.parametrize('build_hook', ('build_sdist', 'build_wheel'))
+    def test_build_with_empty_setuppy(self, build_backend, build_hook):
+        files = {'setup.py': ''}
+        path.build(files)
+
+        msg = re.escape('No distribution was found.')
+        with pytest.raises(ValueError, match=msg):
+            getattr(build_backend, build_hook)("temp")
+
+
+class TestBuildMetaLegacyBackend(TestBuildMetaBackend):
+    backend_name = 'setuptools.build_meta:__legacy__'
+
+    # build_meta_legacy-specific tests
+    def test_build_sdist_relative_path_import(self, tmpdir_cwd):
+        # This must fail in build_meta, but must pass in build_meta_legacy
+        path.build(self._relative_path_import_files)
+
+        build_backend = self.get_build_backend()
+        build_backend.build_sdist("temp")
+
+    def test_sys_argv_passthrough(self, tmpdir_cwd):
+        path.build(self._sys_argv_0_passthrough)
+
+        build_backend = self.get_build_backend()
+        build_backend.build_sdist("temp")
+
+
+@pytest.mark.filterwarnings("ignore::setuptools.SetuptoolsDeprecationWarning")
+def test_sys_exit_0_in_setuppy(monkeypatch, tmp_path):
+    """Setuptools should be resilient to setup.py with ``sys.exit(0)`` (#3973)."""
+    monkeypatch.chdir(tmp_path)
+    setuppy = """
+        import sys, setuptools
+        setuptools.setup(name='foo', version='0.0.0')
+        sys.exit(0)
+        """
+    (tmp_path / "setup.py").write_text(DALS(setuppy), encoding="utf-8")
+    backend = BuildBackend(backend_name="setuptools.build_meta")
+    assert backend.get_requires_for_build_wheel() == []
+
+
+def test_system_exit_in_setuppy(monkeypatch, tmp_path):
+    monkeypatch.chdir(tmp_path)
+    setuppy = "import sys; sys.exit('some error')"
+    (tmp_path / "setup.py").write_text(setuppy, encoding="utf-8")
+    with pytest.raises(SystemExit, match="some error"):
+        backend = BuildBackend(backend_name="setuptools.build_meta")
+        backend.get_requires_for_build_wheel()
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/test_build_py.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/test_build_py.py
new file mode 100644
index 0000000000000000000000000000000000000000..78848f718281cce38df5deb82b7afa855c6e0d07
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/test_build_py.py
@@ -0,0 +1,480 @@
+import os
+import shutil
+import stat
+import warnings
+from pathlib import Path
+from unittest.mock import Mock
+
+import jaraco.path
+import pytest
+
+from setuptools import SetuptoolsDeprecationWarning
+from setuptools.dist import Distribution
+
+from .textwrap import DALS
+
+
+def test_directories_in_package_data_glob(tmpdir_cwd):
+    """
+    Directories matching the glob in package_data should
+    not be included in the package data.
+
+    Regression test for #261.
+    """
+    dist = Distribution(
+        dict(
+            script_name='setup.py',
+            script_args=['build_py'],
+            packages=[''],
+            package_data={'': ['path/*']},
+        )
+    )
+    os.makedirs('path/subpath')
+    dist.parse_command_line()
+    dist.run_commands()
+
+
+def test_recursive_in_package_data_glob(tmpdir_cwd):
+    """
+    Files matching recursive globs (**) in package_data should
+    be included in the package data.
+
+    #1806
+    """
+    dist = Distribution(
+        dict(
+            script_name='setup.py',
+            script_args=['build_py'],
+            packages=[''],
+            package_data={'': ['path/**/data']},
+        )
+    )
+    os.makedirs('path/subpath/subsubpath')
+    open('path/subpath/subsubpath/data', 'wb').close()
+
+    dist.parse_command_line()
+    dist.run_commands()
+
+    assert stat.S_ISREG(os.stat('build/lib/path/subpath/subsubpath/data').st_mode), (
+        "File is not included"
+    )
+
+
+def test_read_only(tmpdir_cwd):
+    """
+    Ensure read-only flag is not preserved in copy
+    for package modules and package data, as that
+    causes problems with deleting read-only files on
+    Windows.
+
+    #1451
+    """
+    dist = Distribution(
+        dict(
+            script_name='setup.py',
+            script_args=['build_py'],
+            packages=['pkg'],
+            package_data={'pkg': ['data.dat']},
+        )
+    )
+    os.makedirs('pkg')
+    open('pkg/__init__.py', 'wb').close()
+    open('pkg/data.dat', 'wb').close()
+    os.chmod('pkg/__init__.py', stat.S_IREAD)
+    os.chmod('pkg/data.dat', stat.S_IREAD)
+    dist.parse_command_line()
+    dist.run_commands()
+    shutil.rmtree('build')
+
+
+@pytest.mark.xfail(
+    'platform.system() == "Windows"',
+    reason="On Windows, files do not have executable bits",
+    raises=AssertionError,
+    strict=True,
+)
+def test_executable_data(tmpdir_cwd):
+    """
+    Ensure executable bit is preserved in copy for
+    package data, as users rely on it for scripts.
+
+    #2041
+    """
+    dist = Distribution(
+        dict(
+            script_name='setup.py',
+            script_args=['build_py'],
+            packages=['pkg'],
+            package_data={'pkg': ['run-me']},
+        )
+    )
+    os.makedirs('pkg')
+    open('pkg/__init__.py', 'wb').close()
+    open('pkg/run-me', 'wb').close()
+    os.chmod('pkg/run-me', 0o700)
+
+    dist.parse_command_line()
+    dist.run_commands()
+
+    assert os.stat('build/lib/pkg/run-me').st_mode & stat.S_IEXEC, (
+        "Script is not executable"
+    )
+
+
+EXAMPLE_WITH_MANIFEST = {
+    "setup.cfg": DALS(
+        """
+        [metadata]
+        name = mypkg
+        version = 42
+
+        [options]
+        include_package_data = True
+        packages = find:
+
+        [options.packages.find]
+        exclude = *.tests*
+        """
+    ),
+    "mypkg": {
+        "__init__.py": "",
+        "resource_file.txt": "",
+        "tests": {
+            "__init__.py": "",
+            "test_mypkg.py": "",
+            "test_file.txt": "",
+        },
+    },
+    "MANIFEST.in": DALS(
+        """
+        global-include *.py *.txt
+        global-exclude *.py[cod]
+        prune dist
+        prune build
+        prune *.egg-info
+        """
+    ),
+}
+
+
+def test_excluded_subpackages(tmpdir_cwd):
+    jaraco.path.build(EXAMPLE_WITH_MANIFEST)
+    dist = Distribution({"script_name": "%PEP 517%"})
+    dist.parse_config_files()
+
+    build_py = dist.get_command_obj("build_py")
+
+    msg = r"Python recognizes 'mypkg\.tests' as an importable package"
+    with pytest.warns(SetuptoolsDeprecationWarning, match=msg):  # noqa: PT031
+        # TODO: To fix #3260 we need some transition period to deprecate the
+        # existing behavior of `include_package_data`. After the transition, we
+        # should remove the warning and fix the behavior.
+
+        if os.getenv("SETUPTOOLS_USE_DISTUTILS") == "stdlib":
+            # pytest.warns reset the warning filter temporarily
+            # https://github.com/pytest-dev/pytest/issues/4011#issuecomment-423494810
+            warnings.filterwarnings(
+                "ignore",
+                "'encoding' argument not specified",
+                module="distutils.text_file",
+                # This warning is already fixed in pypa/distutils but not in stdlib
+            )
+
+        build_py.finalize_options()
+        build_py.run()
+
+    build_dir = Path(dist.get_command_obj("build_py").build_lib)
+    assert (build_dir / "mypkg/__init__.py").exists()
+    assert (build_dir / "mypkg/resource_file.txt").exists()
+
+    # Setuptools is configured to ignore `mypkg.tests`, therefore the following
+    # files/dirs should not be included in the distribution.
+    for f in [
+        "mypkg/tests/__init__.py",
+        "mypkg/tests/test_mypkg.py",
+        "mypkg/tests/test_file.txt",
+        "mypkg/tests",
+    ]:
+        with pytest.raises(AssertionError):
+            # TODO: Enforce the following assertion once #3260 is fixed
+            # (remove context manager and the following xfail).
+            assert not (build_dir / f).exists()
+
+    pytest.xfail("#3260")
+
+
+@pytest.mark.filterwarnings("ignore::setuptools.SetuptoolsDeprecationWarning")
+def test_existing_egg_info(tmpdir_cwd, monkeypatch):
+    """When provided with the ``existing_egg_info_dir`` attribute, build_py should not
+    attempt to run egg_info again.
+    """
+    # == Pre-condition ==
+    # Generate an egg-info dir
+    jaraco.path.build(EXAMPLE_WITH_MANIFEST)
+    dist = Distribution({"script_name": "%PEP 517%"})
+    dist.parse_config_files()
+    assert dist.include_package_data
+
+    egg_info = dist.get_command_obj("egg_info")
+    dist.run_command("egg_info")
+    egg_info_dir = next(Path(egg_info.egg_base).glob("*.egg-info"))
+    assert egg_info_dir.is_dir()
+
+    # == Setup ==
+    build_py = dist.get_command_obj("build_py")
+    build_py.finalize_options()
+    egg_info = dist.get_command_obj("egg_info")
+    egg_info_run = Mock(side_effect=egg_info.run)
+    monkeypatch.setattr(egg_info, "run", egg_info_run)
+
+    # == Remove caches ==
+    # egg_info is called when build_py looks for data_files, which gets cached.
+    # We need to ensure it is not cached yet, otherwise it may impact on the tests
+    build_py.__dict__.pop('data_files', None)
+    dist.reinitialize_command(egg_info)
+
+    # == Sanity check ==
+    # Ensure that if existing_egg_info is not given, build_py attempts to run egg_info
+    build_py.existing_egg_info_dir = None
+    build_py.run()
+    egg_info_run.assert_called()
+
+    # == Remove caches ==
+    egg_info_run.reset_mock()
+    build_py.__dict__.pop('data_files', None)
+    dist.reinitialize_command(egg_info)
+
+    # == Actual test ==
+    # Ensure that if existing_egg_info_dir is given, egg_info doesn't run
+    build_py.existing_egg_info_dir = egg_info_dir
+    build_py.run()
+    egg_info_run.assert_not_called()
+    assert build_py.data_files
+
+    # Make sure the list of outputs is actually OK
+    outputs = map(lambda x: x.replace(os.sep, "/"), build_py.get_outputs())
+    assert outputs
+    example = str(Path(build_py.build_lib, "mypkg/__init__.py")).replace(os.sep, "/")
+    assert example in outputs
+
+
+EXAMPLE_ARBITRARY_MAPPING = {
+    "pyproject.toml": DALS(
+        """
+        [project]
+        name = "mypkg"
+        version = "42"
+
+        [tool.setuptools]
+        packages = ["mypkg", "mypkg.sub1", "mypkg.sub2", "mypkg.sub2.nested"]
+
+        [tool.setuptools.package-dir]
+        "" = "src"
+        "mypkg.sub2" = "src/mypkg/_sub2"
+        "mypkg.sub2.nested" = "other"
+        """
+    ),
+    "src": {
+        "mypkg": {
+            "__init__.py": "",
+            "resource_file.txt": "",
+            "sub1": {
+                "__init__.py": "",
+                "mod1.py": "",
+            },
+            "_sub2": {
+                "mod2.py": "",
+            },
+        },
+    },
+    "other": {
+        "__init__.py": "",
+        "mod3.py": "",
+    },
+    "MANIFEST.in": DALS(
+        """
+        global-include *.py *.txt
+        global-exclude *.py[cod]
+        """
+    ),
+}
+
+
+def test_get_outputs(tmpdir_cwd):
+    jaraco.path.build(EXAMPLE_ARBITRARY_MAPPING)
+    dist = Distribution({"script_name": "%test%"})
+    dist.parse_config_files()
+
+    build_py = dist.get_command_obj("build_py")
+    build_py.editable_mode = True
+    build_py.ensure_finalized()
+    build_lib = build_py.build_lib.replace(os.sep, "/")
+    outputs = {x.replace(os.sep, "/") for x in build_py.get_outputs()}
+    assert outputs == {
+        f"{build_lib}/mypkg/__init__.py",
+        f"{build_lib}/mypkg/resource_file.txt",
+        f"{build_lib}/mypkg/sub1/__init__.py",
+        f"{build_lib}/mypkg/sub1/mod1.py",
+        f"{build_lib}/mypkg/sub2/mod2.py",
+        f"{build_lib}/mypkg/sub2/nested/__init__.py",
+        f"{build_lib}/mypkg/sub2/nested/mod3.py",
+    }
+    mapping = {
+        k.replace(os.sep, "/"): v.replace(os.sep, "/")
+        for k, v in build_py.get_output_mapping().items()
+    }
+    assert mapping == {
+        f"{build_lib}/mypkg/__init__.py": "src/mypkg/__init__.py",
+        f"{build_lib}/mypkg/resource_file.txt": "src/mypkg/resource_file.txt",
+        f"{build_lib}/mypkg/sub1/__init__.py": "src/mypkg/sub1/__init__.py",
+        f"{build_lib}/mypkg/sub1/mod1.py": "src/mypkg/sub1/mod1.py",
+        f"{build_lib}/mypkg/sub2/mod2.py": "src/mypkg/_sub2/mod2.py",
+        f"{build_lib}/mypkg/sub2/nested/__init__.py": "other/__init__.py",
+        f"{build_lib}/mypkg/sub2/nested/mod3.py": "other/mod3.py",
+    }
+
+
+class TestTypeInfoFiles:
+    PYPROJECTS = {
+        "default_pyproject": DALS(
+            """
+            [project]
+            name = "foo"
+            version = "1"
+            """
+        ),
+        "dont_include_package_data": DALS(
+            """
+            [project]
+            name = "foo"
+            version = "1"
+
+            [tool.setuptools]
+            include-package-data = false
+            """
+        ),
+        "exclude_type_info": DALS(
+            """
+            [project]
+            name = "foo"
+            version = "1"
+
+            [tool.setuptools]
+            include-package-data = false
+
+            [tool.setuptools.exclude-package-data]
+            "*" = ["py.typed", "*.pyi"]
+            """
+        ),
+    }
+
+    EXAMPLES = {
+        "simple_namespace": {
+            "directory_structure": {
+                "foo": {
+                    "bar.pyi": "",
+                    "py.typed": "",
+                    "__init__.py": "",
+                }
+            },
+            "expected_type_files": {"foo/bar.pyi", "foo/py.typed"},
+        },
+        "nested_inside_namespace": {
+            "directory_structure": {
+                "foo": {
+                    "bar": {
+                        "py.typed": "",
+                        "mod.pyi": "",
+                    }
+                }
+            },
+            "expected_type_files": {"foo/bar/mod.pyi", "foo/bar/py.typed"},
+        },
+        "namespace_nested_inside_regular": {
+            "directory_structure": {
+                "foo": {
+                    "namespace": {
+                        "foo.pyi": "",
+                    },
+                    "__init__.pyi": "",
+                    "py.typed": "",
+                }
+            },
+            "expected_type_files": {
+                "foo/namespace/foo.pyi",
+                "foo/__init__.pyi",
+                "foo/py.typed",
+            },
+        },
+    }
+
+    @pytest.mark.parametrize(
+        "pyproject",
+        [
+            "default_pyproject",
+            pytest.param(
+                "dont_include_package_data",
+                marks=pytest.mark.xfail(reason="pypa/setuptools#4350"),
+            ),
+        ],
+    )
+    @pytest.mark.parametrize("example", EXAMPLES.keys())
+    def test_type_files_included_by_default(self, tmpdir_cwd, pyproject, example):
+        structure = {
+            **self.EXAMPLES[example]["directory_structure"],
+            "pyproject.toml": self.PYPROJECTS[pyproject],
+        }
+        expected_type_files = self.EXAMPLES[example]["expected_type_files"]
+        jaraco.path.build(structure)
+
+        build_py = get_finalized_build_py()
+        outputs = get_outputs(build_py)
+        assert expected_type_files <= outputs
+
+    @pytest.mark.parametrize("pyproject", ["exclude_type_info"])
+    @pytest.mark.parametrize("example", EXAMPLES.keys())
+    def test_type_files_can_be_excluded(self, tmpdir_cwd, pyproject, example):
+        structure = {
+            **self.EXAMPLES[example]["directory_structure"],
+            "pyproject.toml": self.PYPROJECTS[pyproject],
+        }
+        expected_type_files = self.EXAMPLES[example]["expected_type_files"]
+        jaraco.path.build(structure)
+
+        build_py = get_finalized_build_py()
+        outputs = get_outputs(build_py)
+        assert expected_type_files.isdisjoint(outputs)
+
+    def test_stub_only_package(self, tmpdir_cwd):
+        structure = {
+            "pyproject.toml": DALS(
+                """
+                [project]
+                name = "foo-stubs"
+                version = "1"
+                """
+            ),
+            "foo-stubs": {"__init__.pyi": "", "bar.pyi": ""},
+        }
+        expected_type_files = {"foo-stubs/__init__.pyi", "foo-stubs/bar.pyi"}
+        jaraco.path.build(structure)
+
+        build_py = get_finalized_build_py()
+        outputs = get_outputs(build_py)
+        assert expected_type_files <= outputs
+
+
+def get_finalized_build_py(script_name="%build_py-test%"):
+    dist = Distribution({"script_name": script_name})
+    dist.parse_config_files()
+    build_py = dist.get_command_obj("build_py")
+    build_py.finalize_options()
+    return build_py
+
+
+def get_outputs(build_py):
+    build_dir = Path(build_py.build_lib)
+    return {
+        os.path.relpath(x, build_dir).replace(os.sep, "/")
+        for x in build_py.get_outputs()
+    }
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/test_logging.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/test_logging.py
new file mode 100644
index 0000000000000000000000000000000000000000..5d487bda2df44ae79053f927f2bb703d0216f123
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/test_logging.py
@@ -0,0 +1,76 @@
+import functools
+import inspect
+import logging
+import sys
+
+import pytest
+
+IS_PYPY = '__pypy__' in sys.builtin_module_names
+
+
+setup_py = """\
+from setuptools import setup
+
+setup(
+    name="test_logging",
+    version="0.0"
+)
+"""
+
+
+@pytest.mark.parametrize(
+    ('flags', 'expected_level'), [([], "INFO"), (["--verbose"], "DEBUG")]
+)
+def test_verbosity_level(tmp_path, monkeypatch, flags, expected_level):
+    """Make sure the correct verbosity level is set (issue #3038)"""
+    import setuptools  # noqa: F401  # import setuptools to monkeypatch distutils
+
+    import distutils  # <- load distutils after all the patches take place
+
+    logger = logging.Logger(__name__)
+    monkeypatch.setattr(logging, "root", logger)
+    unset_log_level = logger.getEffectiveLevel()
+    assert logging.getLevelName(unset_log_level) == "NOTSET"
+
+    setup_script = tmp_path / "setup.py"
+    setup_script.write_text(setup_py, encoding="utf-8")
+    dist = distutils.core.run_setup(setup_script, stop_after="init")
+    dist.script_args = flags + ["sdist"]
+    dist.parse_command_line()  # <- where the log level is set
+    log_level = logger.getEffectiveLevel()
+    log_level_name = logging.getLevelName(log_level)
+    assert log_level_name == expected_level
+
+
+def flaky_on_pypy(func):
+    @functools.wraps(func)
+    def _func():
+        try:
+            func()
+        except AssertionError:  # pragma: no cover
+            if IS_PYPY:
+                msg = "Flaky monkeypatch on PyPy (#4124)"
+                pytest.xfail(f"{msg}. Original discussion in #3707, #3709.")
+            raise
+
+    return _func
+
+
+@flaky_on_pypy
+def test_patching_does_not_cause_problems():
+    # Ensure `dist.log` is only patched if necessary
+
+    import _distutils_hack
+
+    import setuptools.logging
+
+    from distutils import dist
+
+    setuptools.logging.configure()
+
+    if _distutils_hack.enabled():
+        # Modern logging infra, no problematic patching.
+        assert dist.__file__ is None or "setuptools" in dist.__file__
+        assert isinstance(dist.log, logging.Logger)
+    else:
+        assert inspect.ismodule(dist.log)
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/test_virtualenv.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/test_virtualenv.py
new file mode 100644
index 0000000000000000000000000000000000000000..b02949baf9cef8eb4df9c697add28f79a93b64d4
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/test_virtualenv.py
@@ -0,0 +1,113 @@
+import os
+import subprocess
+import sys
+from urllib.error import URLError
+from urllib.request import urlopen
+
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def pytest_virtualenv_works(venv):
+    """
+    pytest_virtualenv may not work. if it doesn't, skip these
+    tests. See #1284.
+    """
+    venv_prefix = venv.run(["python", "-c", "import sys; print(sys.prefix)"]).strip()
+    if venv_prefix == sys.prefix:
+        pytest.skip("virtualenv is broken (see pypa/setuptools#1284)")
+
+
+def test_clean_env_install(venv_without_setuptools, setuptools_wheel):
+    """
+    Check setuptools can be installed in a clean environment.
+    """
+    cmd = ["python", "-m", "pip", "install", str(setuptools_wheel)]
+    venv_without_setuptools.run(cmd)
+
+
+def access_pypi():
+    # Detect if tests are being run without connectivity
+    if not os.environ.get('NETWORK_REQUIRED', False):  # pragma: nocover
+        try:
+            urlopen('https://pypi.org', timeout=1)
+        except URLError:
+            # No network, disable most of these tests
+            return False
+
+    return True
+
+
+@pytest.mark.skipif(
+    'platform.python_implementation() == "PyPy"',
+    reason="https://github.com/pypa/setuptools/pull/2865#issuecomment-965834995",
+)
+@pytest.mark.skipif(not access_pypi(), reason="no network")
+# ^-- Even when it is not necessary to install a different version of `pip`
+#     the build process will still try to download `wheel`, see #3147 and #2986.
+@pytest.mark.parametrize(
+    'pip_version',
+    [
+        None,
+        pytest.param(
+            'pip<20.1',
+            marks=pytest.mark.xfail(
+                'sys.version_info >= (3, 12)',
+                reason="pip 23.1.2 required for Python 3.12 and later",
+            ),
+        ),
+        pytest.param(
+            'pip<21',
+            marks=pytest.mark.xfail(
+                'sys.version_info >= (3, 12)',
+                reason="pip 23.1.2 required for Python 3.12 and later",
+            ),
+        ),
+        pytest.param(
+            'pip<22',
+            marks=pytest.mark.xfail(
+                'sys.version_info >= (3, 12)',
+                reason="pip 23.1.2 required for Python 3.12 and later",
+            ),
+        ),
+        pytest.param(
+            'pip<23',
+            marks=pytest.mark.xfail(
+                'sys.version_info >= (3, 12)',
+                reason="pip 23.1.2 required for Python 3.12 and later",
+            ),
+        ),
+        pytest.param(
+            'https://github.com/pypa/pip/archive/main.zip',
+            marks=pytest.mark.xfail(reason='#2975'),
+        ),
+    ],
+)
+def test_pip_upgrade_from_source(
+    pip_version, venv_without_setuptools, setuptools_wheel, setuptools_sdist
+):
+    """
+    Check pip can upgrade setuptools from source.
+    """
+    # Install pip/wheel, in a venv without setuptools (as it
+    # should not be needed for bootstrapping from source)
+    venv = venv_without_setuptools
+    venv.run(["pip", "install", "-U", "wheel"])
+    if pip_version is not None:
+        venv.run(["python", "-m", "pip", "install", "-U", pip_version, "--retries=1"])
+    with pytest.raises(subprocess.CalledProcessError):
+        # Meta-test to make sure setuptools is not installed
+        venv.run(["python", "-c", "import setuptools"])
+
+    # Then install from wheel.
+    venv.run(["pip", "install", str(setuptools_wheel)])
+    # And finally try to upgrade from source.
+    venv.run(["pip", "install", "--no-cache-dir", "--upgrade", str(setuptools_sdist)])
+
+
+def test_no_missing_dependencies(bare_venv, request):
+    """
+    Quick and dirty test to ensure all external dependencies are vendored.
+    """
+    setuptools_dir = request.config.rootdir
+    bare_venv.run(['python', 'setup.py', '--help'], cwd=setuptools_dir)
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/test_warnings.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/test_warnings.py
new file mode 100644
index 0000000000000000000000000000000000000000..41193d4f717344546f8c70ad18b268a04740129b
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/test_warnings.py
@@ -0,0 +1,106 @@
+from inspect import cleandoc
+
+import pytest
+
+from setuptools.warnings import SetuptoolsDeprecationWarning, SetuptoolsWarning
+
+_EXAMPLES = {
+    "default": dict(
+        args=("Hello {x}", "\n\t{target} {v:.1f}"),
+        kwargs={"x": 5, "v": 3, "target": "World"},
+        expected="""
+    Hello 5
+    !!
+
+            ********************************************************************************
+            World 3.0
+            ********************************************************************************
+
+    !!
+    """,
+    ),
+    "futue_due_date": dict(
+        args=("Summary", "Lorem ipsum"),
+        kwargs={"due_date": (9999, 11, 22)},
+        expected="""
+    Summary
+    !!
+
+            ********************************************************************************
+            Lorem ipsum
+
+            By 9999-Nov-22, you need to update your project and remove deprecated calls
+            or your builds will no longer be supported.
+            ********************************************************************************
+
+    !!
+    """,
+    ),
+    "past_due_date_with_docs": dict(
+        args=("Summary", "Lorem ipsum"),
+        kwargs={"due_date": (2000, 11, 22), "see_docs": "some_page.html"},
+        expected="""
+    Summary
+    !!
+
+            ********************************************************************************
+            Lorem ipsum
+
+            This deprecation is overdue, please update your project and remove deprecated
+            calls to avoid build errors in the future.
+
+            See https://setuptools.pypa.io/en/latest/some_page.html for details.
+            ********************************************************************************
+
+    !!
+    """,
+    ),
+}
+
+
+@pytest.mark.parametrize("example_name", _EXAMPLES.keys())
+def test_formatting(monkeypatch, example_name):
+    """
+    It should automatically handle indentation, interpolation and things like due date.
+    """
+    args = _EXAMPLES[example_name]["args"]
+    kwargs = _EXAMPLES[example_name]["kwargs"]
+    expected = _EXAMPLES[example_name]["expected"]
+
+    monkeypatch.setenv("SETUPTOOLS_ENFORCE_DEPRECATION", "false")
+    with pytest.warns(SetuptoolsWarning) as warn_info:
+        SetuptoolsWarning.emit(*args, **kwargs)
+    assert _get_message(warn_info) == cleandoc(expected)
+
+
+def test_due_date_enforcement(monkeypatch):
+    class _MyDeprecation(SetuptoolsDeprecationWarning):
+        _SUMMARY = "Summary"
+        _DETAILS = "Lorem ipsum"
+        _DUE_DATE = (2000, 11, 22)
+        _SEE_DOCS = "some_page.html"
+
+    monkeypatch.setenv("SETUPTOOLS_ENFORCE_DEPRECATION", "true")
+    with pytest.raises(SetuptoolsDeprecationWarning) as exc_info:
+        _MyDeprecation.emit()
+
+    expected = """
+    Summary
+    !!
+
+            ********************************************************************************
+            Lorem ipsum
+
+            This deprecation is overdue, please update your project and remove deprecated
+            calls to avoid build errors in the future.
+
+            See https://setuptools.pypa.io/en/latest/some_page.html for details.
+            ********************************************************************************
+
+    !!
+    """
+    assert str(exc_info.value) == cleandoc(expected)
+
+
+def _get_message(warn_info):
+    return next(warn.message.args[0] for warn in warn_info)
diff --git a/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/textwrap.py b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/textwrap.py
new file mode 100644
index 0000000000000000000000000000000000000000..5e39618dca4ad6c3f0d4c8cb20af59ab85fb0eba
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/setuptools/tests/textwrap.py
@@ -0,0 +1,6 @@
+import textwrap
+
+
+def DALS(s):
+    "dedent and left-strip"
+    return textwrap.dedent(s).lstrip()
diff --git a/.venv_haddock/lib/python3.12/site-packages/tzdata-2026.1.dist-info/licenses/LICENSE b/.venv_haddock/lib/python3.12/site-packages/tzdata-2026.1.dist-info/licenses/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..c2f84aeb06f7a520b7cf17bdd9c9c3854dc4c469
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/tzdata-2026.1.dist-info/licenses/LICENSE
@@ -0,0 +1,15 @@
+Apache Software License 2.0
+
+Copyright (c) 2020, Paul Ganssle (Google)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/.venv_haddock/lib/python3.12/site-packages/tzdata-2026.1.dist-info/licenses/licenses/LICENSE_APACHE b/.venv_haddock/lib/python3.12/site-packages/tzdata-2026.1.dist-info/licenses/licenses/LICENSE_APACHE
new file mode 100644
index 0000000000000000000000000000000000000000..261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64
--- /dev/null
+++ b/.venv_haddock/lib/python3.12/site-packages/tzdata-2026.1.dist-info/licenses/licenses/LICENSE_APACHE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/__init__.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..292710a1c852b85888779376d4b5bd01cd3cf9ad
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/composer.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/composer.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2244bba90160822044ec4f594c80fc22eb50f0b8
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/composer.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/constructor.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/constructor.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8f09ca91da78a28a7f6bc0ac9fe2f269c0adc064
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/constructor.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/cyaml.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/cyaml.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7f7c8af952e7772efd81258a849fbc9ea2925717
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/cyaml.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/dumper.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/dumper.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1283c90dbb2d05fa4037ea2914852b36d9bb807b
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/dumper.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/emitter.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/emitter.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b6de08dbbc7ba228295b96134cacde72e2bb714e
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/emitter.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/error.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/error.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9e717d633a669035020231b172e7c0978ff21cde
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/error.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/events.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/events.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4802519e7a201aee0bd265414ee577060acda148
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/events.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/loader.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/loader.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..15fb99929d9e3233bdf298bc2cd711c7360db97a
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/loader.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/nodes.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/nodes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1442f6b740b706153a237e079fc96a353c3670d6
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/nodes.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/parser.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/parser.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5bd71352ac8ce4844ced0c37d2edd47c64ad753d
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/parser.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/reader.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/reader.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..14dc4470e4f3f367f442beab0917453b43520637
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/reader.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/representer.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/representer.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ca1020ef85effe6a0919ffaf23e9102612f0438a
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/representer.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/resolver.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/resolver.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1780bbdb0a9ed03cf8f72ab1346ada06ecff3dbd
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/resolver.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/scanner.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/scanner.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8323f58d04ad7b294930ad95b0e49f31e8190c65
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/scanner.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/serializer.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/serializer.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..36c5f8a124f272d5be94ad342dcea104eeec1753
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/serializer.cpython-312.pyc differ
diff --git a/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/tokens.cpython-312.pyc b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/tokens.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b563f11a1587ee5cdb7b5665ef212cec3e88794c
Binary files /dev/null and b/.venv_haddock/lib/python3.12/site-packages/yaml/__pycache__/tokens.cpython-312.pyc differ