from __future__ import annotations import argparse import csv import json import os import shutil import sys import time import urllib.parse import urllib.request from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor, as_completed from pathlib import Path try: # pragma: no cover from rdkit import Chem, DataStructs from rdkit.Chem import rdMolDescriptors from rdkit.Chem import rdFingerprintGenerator from rdkit.Chem.Scaffolds import MurckoScaffold RDKIT_AVAILABLE = True except Exception: # pragma: no cover Chem = None # type: ignore[assignment] DataStructs = None # type: ignore[assignment] rdMolDescriptors = None # type: ignore[assignment] rdFingerprintGenerator = None # type: ignore[assignment] MurckoScaffold = None # type: ignore[assignment] RDKIT_AVAILABLE = False try: # pragma: no cover from tqdm import tqdm except Exception: # pragma: no cover tqdm = None # type: ignore[assignment] ROOT = Path(__file__).resolve().parents[1] if str(ROOT) not in sys.path: sys.path.insert(0, str(ROOT)) from docking_pipeline.dataset import ( auto_detect_reference_ligand, count_sdf_records, create_dataset_manifest, download_pdb_structure, extract_receptor_and_reference_ligand, list_hetero_ligands, list_known_good_complexes, prepare_dataset_target_with_rdock, resolve_known_good_defaults, validate_dataset_dir, ) from docking_pipeline.provenance import CommandRunner, RDockPipelineError, fail_if_bad_command, probe_version, require_executable, require_file from docking_pipeline.sdf import split_sdf_text from docking_pipeline.validation import resolve_jobs KNOWN_GOOD = ROOT / "configs" / "known_good_pdb_complexes.yaml" DEFAULT_THRESHOLD_LADDER = [95, 90, 85, 80, 75, 70] DEFAULT_BUNDLED_EXAMPLE = ROOT / "data" / "examples" / "example_smiles.smi" DEFAULT_EXAMPLE_1000 = ROOT / "data" / "examples" / "example_smiles_1000.smi" def _read_smiles(path: Path, n_ligands: int) -> list[tuple[str, str]]: rows: list[tuple[str, str]] = [] for idx, line in enumerate(path.read_text(encoding="utf-8").splitlines()): text = line.strip() if not text or text.startswith("#"): continue parts = text.replace(",", " ").split() smiles = parts[0] ligand_id = parts[1] if len(parts) > 1 else f"lig_{idx:05d}" rows.append((smiles, ligand_id)) if len(rows) >= n_ligands: break return rows def _read_all_smiles(path: Path) -> list[tuple[str, str]]: rows: list[tuple[str, str]] = [] for idx, line in enumerate(path.read_text(encoding="utf-8").splitlines()): text = line.strip() if not text or text.startswith("#"): continue parts = text.replace(",", " ").split() smiles = parts[0] ligand_id = parts[1] if len(parts) > 1 else f"lig_{idx:05d}" rows.append((smiles, ligand_id)) return rows def _default_ligand_jobs() -> int: cpu_total = os.cpu_count() or 8 return max(1, cpu_total - 4) def _mkdir_or_fail(path: Path) -> None: try: path.mkdir(parents=True, exist_ok=True) except PermissionError as exc: suggestion = Path.home() / "datasets" / path.name raise RDockPipelineError( f"Cannot create output directory {path}: permission denied. " f"Use a writable path such as {suggestion} or a relative path under your home/project directory." ) from exc def _http_json(url: str, timeout: int, retries: int = 3, pause_seconds: float = 1.0) -> dict[str, object]: last_error: Exception | None = None for attempt in range(1, retries + 1): try: request = urllib.request.Request(url, headers={"User-Agent": "portable-rdock-pipeline/1.0"}) with urllib.request.urlopen(request, timeout=timeout) as response: payload = response.read().decode("utf-8") return json.loads(payload) except Exception as exc: # pragma: no cover - network-dependent last_error = exc if attempt < retries: time.sleep(pause_seconds * attempt) raise RDockPipelineError(f"HTTP JSON request failed after {retries} attempts for {url}: {last_error}") def _http_post_json( url: str, data: bytes, content_type: str, timeout: int, retries: int = 3, pause_seconds: float = 1.0, ) -> dict[str, object]: last_error: Exception | None = None for attempt in range(1, retries + 1): try: request = urllib.request.Request( url, data=data, headers={"User-Agent": "portable-rdock-pipeline/1.0", "Content-Type": content_type}, method="POST", ) with urllib.request.urlopen(request, timeout=timeout) as response: payload = response.read().decode("utf-8") return json.loads(payload) except Exception as exc: # pragma: no cover - network-dependent last_error = exc if attempt < retries: time.sleep(pause_seconds * attempt) raise RDockPipelineError(f"HTTP POST JSON request failed after {retries} attempts for {url}: {last_error}") def _http_post_form_json( url: str, form: dict[str, str], timeout: int, retries: int = 3, pause_seconds: float = 1.0, ) -> dict[str, object]: body = urllib.parse.urlencode(form).encode("utf-8") return _http_post_json(url, body, "application/x-www-form-urlencoded", timeout, retries=retries, pause_seconds=pause_seconds) def _write_smi(rows: list[tuple[str, str]], path: Path) -> Path: path.parent.mkdir(parents=True, exist_ok=True) path.write_text("\n".join(f"{smiles} {ligand_id}" for smiles, ligand_id in rows) + "\n", encoding="utf-8") return path def _count_sdf_records_lenient(path: Path) -> int: if not path.exists() or path.stat().st_size <= 0: return 0 text = path.read_text(encoding="utf-8", errors="ignore") return len(split_sdf_text(text)) def _progress_log(out: Path, message: str, payload: dict[str, object] | None = None) -> None: line = message print(line, file=sys.stderr, flush=True) log_path = out / "logs" / "pubchem_progress.log" log_path.parent.mkdir(parents=True, exist_ok=True) with log_path.open("a", encoding="utf-8") as handle: handle.write(line + "\n") if payload is not None: status_path = out / "logs" / "pubchem_progress.json" status_path.write_text(json.dumps(payload, indent=2), encoding="utf-8") def _write_partial_pubchem_hits( out: Path, rows: list[tuple[str, str]], metadata_rows: list[dict[str, object]], ) -> None: if not rows: return _write_smi(rows, out / "ligands" / "pubchem_partial_hits.smi") _write_csv(out / "ligands" / "pubchem_partial_metadata.csv", metadata_rows) def _obabel_convert(runner: CommandRunner, stage: str, input_path: Path, output_path: Path, extra_args: list[str], cwd: Path) -> Path: obabel = require_executable("obabel") rec = runner.run( stage, [obabel, str(input_path.resolve()), *extra_args, "-O", str(output_path.resolve())], cwd, cwd / "logs" / f"{stage}.stdout.log", cwd / "logs" / f"{stage}.stderr.log", ) fail_if_bad_command(rec, f"OpenBabel {stage}") return require_file(output_path, f"OpenBabel output {stage}") def _merge_sdf_files(inputs: list[Path], output_path: Path) -> Path: output_path.parent.mkdir(parents=True, exist_ok=True) with output_path.open("w", encoding="utf-8") as handle: for path in inputs: if not path.exists() or path.stat().st_size <= 0: continue text = path.read_text(encoding="utf-8", errors="ignore") if text and not text.endswith("\n"): text += "\n" handle.write(text) return output_path def _convert_single_ligand_with_obabel( runner: CommandRunner, row: tuple[str, str], work_dir: Path, ) -> tuple[Path | None, dict[str, object] | None]: smiles, ligand_id = row smi_path = work_dir / f"{ligand_id}.smi" sdf_path = work_dir / f"{ligand_id}.sdf" smi_path.write_text(f"{smiles} {ligand_id}\n", encoding="utf-8") try: _obabel_convert(runner, f"single_{ligand_id}_to_sdf", smi_path, sdf_path, ["--gen3d", "-h"], work_dir) if _count_sdf_records_lenient(sdf_path) != 1: raise RDockPipelineError(f"Expected 1 SDF record for ligand {ligand_id}, got {_count_sdf_records_lenient(sdf_path)}") return sdf_path, None except Exception as exc: return None, {"ligand_id": ligand_id, "smiles": smiles, "reason": str(exc), "stage": "single_ligand_fallback"} def _convert_batch_with_obabel( runner: CommandRunner, batch_rows: list[tuple[str, str]], batch_dir: Path, batch_name: str, single_fallback_workers: int, ) -> tuple[Path, list[dict[str, object]]]: batch_dir.mkdir(parents=True, exist_ok=True) batch_smi = _write_smi(batch_rows, batch_dir / f"{batch_name}.smi") batch_sdf = batch_dir / f"{batch_name}.sdf" invalid_rows: list[dict[str, object]] = [] try: _obabel_convert(runner, f"{batch_name}_to_sdf", batch_smi, batch_sdf, ["--gen3d", "-h"], batch_dir) if _count_sdf_records_lenient(batch_sdf) == len(batch_rows): return batch_sdf, invalid_rows except Exception as exc: invalid_rows.append({"ligand_id": batch_name, "smiles": "", "reason": str(exc), "stage": "batch_conversion"}) single_dir = batch_dir / f"{batch_name}_single" single_dir.mkdir(parents=True, exist_ok=True) single_outputs: dict[str, Path] = {} with ThreadPoolExecutor(max_workers=min(max(1, single_fallback_workers), len(batch_rows))) as pool: futures = { pool.submit(_convert_single_ligand_with_obabel, runner, row, single_dir): row for row in batch_rows } for future in as_completed(futures): row = futures[future] output_path, invalid = future.result() if output_path is not None: single_outputs[row[1]] = output_path if invalid is not None: invalid_rows.append(invalid) ordered_outputs = [single_outputs[ligand_id] for _, ligand_id in batch_rows if ligand_id in single_outputs] _merge_sdf_files(ordered_outputs, batch_sdf) return batch_sdf, invalid_rows def _convert_batch_with_obabel_worker( batch_rows: list[tuple[str, str]], batch_dir: str, batch_name: str, single_fallback_workers: int, ) -> tuple[str, list[dict[str, object]]]: batch_path = Path(batch_dir) runner = CommandRunner(batch_path / "logs" / "commands.log") sdf_path, invalid_rows = _convert_batch_with_obabel( runner, batch_rows, batch_path, batch_name, single_fallback_workers, ) return str(sdf_path), invalid_rows def _prepare_ligands_from_existing_smi( out: Path, runner: CommandRunner, batch_size: int, jobs: int | str, cpu_fraction: float, force_rebuild: bool = False, metadata_rows: list[dict[str, object]] | None = None, ) -> dict[str, object]: lig_root = out / "ligands" smi_path = require_file(lig_root / "all_ligands.smi", "all_ligands.smi for ligand preparation") rows = _read_all_smiles(smi_path) if not rows: raise RDockPipelineError(f"No usable SMILES rows found in {smi_path}") expected_total = len(rows) final_sdf = lig_root / "all_ligands.sdf" existing_final = _count_sdf_records_lenient(final_sdf) if existing_final > expected_total: raise RDockPipelineError( f"Existing {final_sdf} contains {existing_final} records but {smi_path} contains only {expected_total} ligands. " "Refuse to resume from an inconsistent dataset." ) if not force_rebuild and existing_final == expected_total: metadata_path = lig_root / "ligand_metadata.csv" if not metadata_path.exists(): _write_csv(metadata_path, [{"ligand_id": ligand_id, "smiles": smiles, "source": "smiles_file"} for smiles, ligand_id in rows]) invalid_path = lig_root / "invalid_ligands.csv" if not invalid_path.exists(): _write_csv(invalid_path, []) return { "mode": "prepare_ligands_only", "status": "already_complete", "expected_ligands": expected_total, "prepared_ligands": existing_final, "batch_size": batch_size, "jobs": _default_ligand_jobs() if str(jobs).strip().lower() == "auto" else resolve_jobs(jobs, cpu_fraction), "final_sdf": str(final_sdf), } batch_root = lig_root / "obabel_batches" batch_root.mkdir(parents=True, exist_ok=True) progress_path = lig_root / "ligand_preparation_progress.json" resume_prefix_count = 0 recovered_prefix_sdf: Path | None = None if not force_rebuild and existing_final > 0: existing_batch_files = list(batch_root.glob("batch_*/*.sdf")) if not existing_batch_files: resume_prefix_count = existing_final recovered_prefix_sdf = batch_root / "recovered_prefix.sdf" shutil.copy2(final_sdf, recovered_prefix_sdf) batches: list[tuple[str, list[tuple[str, str]]]] = [] for batch_index, start in enumerate(range(0, expected_total, batch_size), start=1): batches.append((f"batch_{batch_index:05d}", rows[start : start + batch_size])) resolved_jobs = _default_ligand_jobs() if str(jobs).strip().lower() == "auto" else resolve_jobs(jobs, cpu_fraction) invalid_rows: list[dict[str, object]] = [] completed_batch_outputs: dict[str, Path] = {} if recovered_prefix_sdf is not None: completed_batch_outputs["__recovered_prefix__"] = recovered_prefix_sdf pending_batches: list[tuple[str, list[tuple[str, str]]]] = [] ligands_skipped_by_prefix = 0 for batch_number, (batch_name, batch_rows) in enumerate(batches, start=1): batch_start = (batch_number - 1) * batch_size batch_end = batch_start + len(batch_rows) if resume_prefix_count and batch_end <= resume_prefix_count: ligands_skipped_by_prefix += len(batch_rows) continue if resume_prefix_count and batch_start < resume_prefix_count < batch_end: prefix_skip = resume_prefix_count - batch_start ligands_skipped_by_prefix += prefix_skip batch_rows = batch_rows[prefix_skip:] if not batch_rows: continue batch_dir = batch_root / batch_name batch_sdf = batch_dir / f"{batch_name}.sdf" if (not force_rebuild) and _count_sdf_records_lenient(batch_sdf) == len(batch_rows): completed_batch_outputs[batch_name] = batch_sdf continue pending_batches.append((batch_name, batch_rows)) progress_path.write_text( json.dumps( { "expected_ligands": expected_total, "prepared_batches": len(completed_batch_outputs), "total_batches": len(batches), "pending_batches": [name for name, _ in pending_batches[:1000]], "resumed_from_existing_final_sdf_records": resume_prefix_count, "ligands_skipped_by_prefix_resume": ligands_skipped_by_prefix, "jobs": resolved_jobs, "batch_size": batch_size, }, indent=2, ), encoding="utf-8", ) if pending_batches: progress = tqdm(total=len(pending_batches), desc="Ligand 3D batches", unit="batch") if tqdm is not None else None ligand_progress = tqdm(total=expected_total, desc="Ligands prepared", unit="lig") if tqdm is not None else None if ligand_progress is not None: ligand_progress.update(sum(_count_sdf_records_lenient(path) for path in completed_batch_outputs.values())) max_workers = min(resolved_jobs, len(pending_batches)) executor_cls = ProcessPoolExecutor pool = None try: pool = executor_cls(max_workers=max_workers) except Exception: executor_cls = ThreadPoolExecutor pool = executor_cls(max_workers=max_workers) with pool: futures = { pool.submit( _convert_batch_with_obabel_worker, batch_rows, str(batch_root / batch_name), batch_name, max(1, min(4, resolved_jobs)), ): batch_name for batch_name, batch_rows in pending_batches } for future in as_completed(futures): batch_name = futures[future] batch_sdf, batch_invalid = future.result() completed_batch_outputs[batch_name] = Path(batch_sdf) invalid_rows.extend(batch_invalid) batch_prepared = _count_sdf_records_lenient(Path(batch_sdf)) if progress is not None: progress.update(1) progress.set_postfix(last_batch=batch_name, invalid=len(invalid_rows), worker=executor_cls.__name__) if ligand_progress is not None: ligand_progress.update(batch_prepared) ligand_progress.set_postfix(last_batch=batch_name, invalid=len(invalid_rows), worker=executor_cls.__name__) prepared_count = sum(_count_sdf_records_lenient(path) for path in completed_batch_outputs.values()) progress_path.write_text( json.dumps( { "expected_ligands": expected_total, "prepared_batches": len(completed_batch_outputs), "total_batches": len(batches), "prepared_ligands_estimate": prepared_count, "resumed_from_existing_final_sdf_records": resume_prefix_count, "ligands_skipped_by_prefix_resume": ligands_skipped_by_prefix, "jobs": resolved_jobs, "batch_size": batch_size, "worker_backend": executor_cls.__name__, "last_completed_batch": batch_name, "invalid_count": len(invalid_rows), }, indent=2, ), encoding="utf-8", ) if progress is not None: progress.close() if ligand_progress is not None: ligand_progress.close() ordered_outputs: list[Path] = [] if "__recovered_prefix__" in completed_batch_outputs: ordered_outputs.append(completed_batch_outputs["__recovered_prefix__"]) ordered_outputs.extend(completed_batch_outputs[batch_name] for batch_name, _ in batches if batch_name in completed_batch_outputs) _merge_sdf_files(ordered_outputs, final_sdf) prepared_count = _count_sdf_records_lenient(final_sdf) metadata_payload = metadata_rows or _existing_ligand_metadata_payload(lig_root, expected_total) if metadata_payload is None: metadata_payload = [{"ligand_id": ligand_id, "smiles": smiles, "source": "smiles_file"} for smiles, ligand_id in rows] _write_csv(lig_root / "ligand_metadata.csv", metadata_payload) _write_csv(lig_root / "invalid_ligands.csv", invalid_rows) progress_path.write_text( json.dumps( { "expected_ligands": expected_total, "prepared_ligands": prepared_count, "invalid_ligands": len(invalid_rows), "prepared_batches": len(ordered_outputs), "total_batches": len(batches), "resumed_from_existing_final_sdf_records": resume_prefix_count, "ligands_skipped_by_prefix_resume": ligands_skipped_by_prefix, "jobs": resolved_jobs, "batch_size": batch_size, "final_sdf": str(final_sdf), "status": "complete" if prepared_count > 0 else "empty", }, indent=2, ), encoding="utf-8", ) return { "mode": "prepare_ligands_only", "status": "complete" if prepared_count > 0 else "empty", "expected_ligands": expected_total, "prepared_ligands": prepared_count, "invalid_ligands": len(invalid_rows), "batch_size": batch_size, "jobs": resolved_jobs, "resumed_from_existing_final_sdf_records": resume_prefix_count, "ligands_skipped_by_prefix_resume": ligands_skipped_by_prefix, "final_sdf": str(final_sdf), "progress_json": str(progress_path), } def _reference_ligand_to_smiles(runner: CommandRunner, reference_sdf: Path, cwd: Path) -> str: obabel = require_executable("obabel") stdout_log = cwd / "logs" / "reference_ligand_to_smiles.stdout.log" stderr_log = cwd / "logs" / "reference_ligand_to_smiles.stderr.log" rec = runner.run( "reference_ligand_to_smiles", [obabel, str(reference_sdf.resolve()), "-osmi"], cwd, stdout_log, stderr_log, ) fail_if_bad_command(rec, "OpenBabel reference ligand to SMILES") text = stdout_log.read_text(encoding="utf-8", errors="ignore").strip() if not text: raise RDockPipelineError(f"OpenBabel did not produce SMILES for reference ligand {reference_sdf}") first = text.splitlines()[0].strip() parts = first.split() if not parts: raise RDockPipelineError(f"Could not parse OpenBabel SMILES output for {reference_sdf}: {first!r}") return parts[0] def _reference_ligand_sdf_block(reference_sdf: Path) -> str: text = reference_sdf.read_text(encoding="utf-8", errors="ignore") first = text.split("$$$$", 1)[0].strip() if not first: raise RDockPipelineError(f"Reference ligand SDF is empty or unreadable: {reference_sdf}") return first + "\n$$$$\n" def _canonicalize_smiles_for_filter(smiles: str) -> str: return smiles.strip() def _looks_organic_smiles(smiles: str) -> bool: text = _canonicalize_smiles_for_filter(smiles) if not text or "." in text: return False return "C" in text or "c" in text def _parse_threshold_ladder(text: str) -> list[int]: try: values = [int(part.strip()) for part in text.split(",") if part.strip()] except Exception as exc: raise RDockPipelineError(f"Invalid --pubchem-threshold-ladder value {text!r}: {exc}") from exc if not values: raise RDockPipelineError("Empty --pubchem-threshold-ladder") return values def _resolve_threshold_ladder(args: argparse.Namespace) -> list[int]: ladder_override = str(getattr(args, "similarity_thresholds", "") or "").strip() if ladder_override: return _parse_threshold_ladder(ladder_override) start = getattr(args, "pubchem_threshold_start", None) stop = getattr(args, "pubchem_threshold_stop", None) step = int(getattr(args, "pubchem_threshold_step", 1) or 1) if start is not None or stop is not None: start_value = int(99 if start is None else start) stop_value = int(70 if stop is None else stop) if step <= 0: raise RDockPipelineError("--pubchem-threshold-step must be a positive integer") if start_value < stop_value: raise RDockPipelineError( f"Invalid PubChem threshold range: start {start_value} is lower than stop {stop_value}. " "Use a descending range such as --pubchem-threshold-start 99 --pubchem-threshold-stop 80." ) return list(range(start_value, stop_value - 1, -step)) return _parse_threshold_ladder(args.pubchem_threshold_ladder) def _pubchem_similarity_cids_from_sdf(reference_sdf_block: str, threshold: int, max_records: int, timeout: int) -> list[int]: url = ( "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/fastsimilarity_2d/" f"sdf/cids/JSON?Threshold={int(threshold)}&MaxRecords={int(max_records)}&MaxSeconds={int(timeout)}" ) payload = _http_post_form_json(url, {"sdf": reference_sdf_block}, timeout) info = payload.get("IdentifierList", {}) if isinstance(payload, dict) else {} cids = info.get("CID", []) if isinstance(info, dict) else [] return [int(cid) for cid in cids] def _pubchem_identity_cids_from_sdf(reference_sdf_block: str, timeout: int) -> list[int]: url = ( "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/fastidentity/" f"sdf/cids/JSON?identity_type=same_connectivity&MaxRecords=10&MaxSeconds={int(timeout)}" ) payload = _http_post_form_json(url, {"sdf": reference_sdf_block}, timeout) info = payload.get("IdentifierList", {}) if isinstance(payload, dict) else {} cids = info.get("CID", []) if isinstance(info, dict) else [] return [int(cid) for cid in cids] def _pubchem_identity_cids_from_smiles(reference_smiles: str, timeout: int) -> list[int]: encoded = urllib.parse.quote(reference_smiles, safe="") identity_url = ( "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/fastidentity/" f"smiles/{encoded}/cids/JSON?identity_type=same_connectivity&MaxRecords=10&MaxSeconds={int(timeout)}" ) identity_payload = _http_json(identity_url, timeout) identity_info = identity_payload.get("IdentifierList", {}) if isinstance(identity_payload, dict) else {} identity_cids = identity_info.get("CID", []) if isinstance(identity_info, dict) else [] return [int(cid) for cid in identity_cids] def _pubchem_reference_cid( reference_smiles: str, timeout: int, reference_sdf_block: str | None = None, ) -> int | None: try: identity_cids = _pubchem_identity_cids_from_smiles(reference_smiles, timeout) if identity_cids: return int(identity_cids[0]) except Exception: # pragma: no cover - network-dependent pass if reference_sdf_block: try: identity_cids = _pubchem_identity_cids_from_sdf(reference_sdf_block, timeout) if identity_cids: return int(identity_cids[0]) except Exception: # pragma: no cover - network-dependent pass return None def _pubchem_similarity_cids_from_cid(reference_cid: int, threshold: int, max_records: int, timeout: int) -> list[int]: cid_url = ( "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/fastsimilarity_2d/" f"cid/{int(reference_cid)}/cids/JSON?Threshold={int(threshold)}&MaxRecords={int(max_records)}&MaxSeconds={int(timeout)}" ) cid_payload = _http_json(cid_url, timeout) cid_info = cid_payload.get("IdentifierList", {}) if isinstance(cid_payload, dict) else {} cid_hits = cid_info.get("CID", []) if isinstance(cid_info, dict) else [] return [int(cid) for cid in cid_hits] def _pubchem_similarity_cids( reference_smiles: str, threshold: int, max_records: int, timeout: int, reference_sdf_block: str | None = None, reference_cid: int | None = None, ) -> list[int]: errors: list[str] = [] if reference_cid is not None: try: parsed = _pubchem_similarity_cids_from_cid(reference_cid, threshold, max_records, timeout) if parsed: return parsed except Exception as exc: # pragma: no cover - network-dependent errors.append(f"cid_fastsim:{exc}") if reference_sdf_block: try: parsed = _pubchem_similarity_cids_from_sdf(reference_sdf_block, threshold, max_records, timeout) if parsed: return parsed except Exception as exc: # pragma: no cover - network-dependent errors.append(f"sdf_fastsim:{exc}") try: identity_cids = _pubchem_identity_cids_from_sdf(reference_sdf_block, timeout) except Exception as exc: # pragma: no cover - network-dependent identity_cids = [] errors.append(f"sdf_identity:{exc}") if identity_cids: ref_cid = int(identity_cids[0]) cid_url = ( "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/fastsimilarity_2d/" f"cid/{ref_cid}/cids/JSON?Threshold={int(threshold)}&MaxRecords={int(max_records)}&MaxSeconds={int(timeout)}" ) try: cid_payload = _http_json(cid_url, timeout) cid_info = cid_payload.get("IdentifierList", {}) if isinstance(cid_payload, dict) else {} cid_hits = cid_info.get("CID", []) if isinstance(cid_info, dict) else [] parsed = [int(cid) for cid in cid_hits] if parsed: return parsed except Exception as exc: # pragma: no cover - network-dependent errors.append(f"cid_fastsim_from_sdf:{exc}") encoded = urllib.parse.quote(reference_smiles, safe="") url = ( "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/fastsimilarity_2d/" f"smiles/{encoded}/cids/JSON?Threshold={int(threshold)}&MaxRecords={int(max_records)}&MaxSeconds={int(timeout)}" ) try: payload = _http_json(url, timeout) info = payload.get("IdentifierList", {}) if isinstance(payload, dict) else {} cids = info.get("CID", []) if isinstance(info, dict) else [] parsed = [int(cid) for cid in cids] if parsed: return parsed except Exception as exc: # pragma: no cover - network-dependent errors.append(f"smiles_fastsim:{exc}") identity_url = ( "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/fastidentity/" f"smiles/{encoded}/cids/JSON?identity_type=same_connectivity&MaxRecords=10&MaxSeconds={int(timeout)}" ) try: identity_payload = _http_json(identity_url, timeout) identity_info = identity_payload.get("IdentifierList", {}) if isinstance(identity_payload, dict) else {} identity_cids = identity_info.get("CID", []) if isinstance(identity_info, dict) else [] except Exception as exc: # pragma: no cover - network-dependent identity_cids = [] errors.append(f"smiles_identity:{exc}") if not identity_cids: return [] try: return _pubchem_similarity_cids_from_cid(int(identity_cids[0]), threshold, max_records, timeout) except Exception: # pragma: no cover - network-dependent return [] def _pubchem_name_search_cids(query: str, max_records: int, timeout: int) -> list[int]: encoded = urllib.parse.quote(query.strip(), safe="") url = f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{encoded}/cids/JSON?MaxRecords={int(max_records)}" payload = _http_json(url, timeout) info = payload.get("IdentifierList", {}) if isinstance(payload, dict) else {} cids = info.get("CID", []) if isinstance(info, dict) else [] return [int(cid) for cid in cids] def _default_pubchem_workers() -> int: cpu_count = os.cpu_count() or 4 return max(2, min(8, cpu_count // 2 or 1)) def _pubchem_fetch_properties_chunk(chunk: list[int], timeout: int) -> list[dict[str, object]]: cid_text = ",".join(str(cid) for cid in chunk) url = ( "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/cid/" f"{cid_text}/property/SMILES,ConnectivitySMILES,IUPACName,Title,MolecularFormula,MolecularWeight," "XLogP,TPSA,HBondDonorCount,HBondAcceptorCount,RotatableBondCount,HeavyAtomCount/JSON" ) payload = _http_json(url, timeout) table = payload.get("PropertyTable", {}) if isinstance(payload, dict) else {} props = table.get("Properties", []) if isinstance(table, dict) else [] return [item for item in props if isinstance(item, dict)] def _pubchem_fetch_properties_chunk_resilient( chunk: list[int], timeout: int, out: Path | None = None, progress_prefix: str = "", chunk_label: str = "", ) -> list[dict[str, object]]: if not chunk: return [] try: return _pubchem_fetch_properties_chunk(chunk, timeout) except Exception as exc: # pragma: no cover - network-dependent if len(chunk) <= 1: if out is not None: _progress_log( out, f"{progress_prefix} property fetch failed for single CID chunk {chunk_label}: {exc}", ) return [] mid = max(1, len(chunk) // 2) left = chunk[:mid] right = chunk[mid:] if out is not None: _progress_log( out, f"{progress_prefix} property chunk {chunk_label} failed ({exc}); splitting {len(chunk)} CIDs into {len(left)} + {len(right)}", ) left_rows = _pubchem_fetch_properties_chunk_resilient( left, timeout, out=out, progress_prefix=progress_prefix, chunk_label=f"{chunk_label}.L", ) right_rows = _pubchem_fetch_properties_chunk_resilient( right, timeout, out=out, progress_prefix=progress_prefix, chunk_label=f"{chunk_label}.R", ) return left_rows + right_rows def _pubchem_fetch_properties( cids: list[int], timeout: int, out: Path | None = None, progress_prefix: str = "", workers: int = 1, chunk_size: int = 200, ) -> list[dict[str, object]]: if not cids: return [] chunk_size = max(1, int(chunk_size)) workers = max(1, int(workers)) chunks = [cids[start : start + chunk_size] for start in range(0, len(cids), chunk_size)] rows: list[dict[str, object]] = [] if workers == 1 or len(chunks) == 1: for index, chunk in enumerate(chunks, start=1): if out is not None: _progress_log( out, f"{progress_prefix} fetching properties chunk {index}/{len(chunks)} ({len(chunk)} CIDs)", ) rows.extend( _pubchem_fetch_properties_chunk_resilient( chunk, timeout, out=out, progress_prefix=progress_prefix, chunk_label=f"{index}/{len(chunks)}", ) ) return rows with ThreadPoolExecutor(max_workers=min(workers, len(chunks))) as pool: futures = { pool.submit(_pubchem_fetch_properties_chunk, chunk, timeout): (index, chunk) for index, chunk in enumerate(chunks, start=1) } for future in as_completed(futures): index, chunk = futures[future] if out is not None: _progress_log( out, f"{progress_prefix} fetching properties chunk {index}/{len(chunks)} ({len(chunk)} CIDs)", ) try: rows.extend(future.result()) except Exception as exc: # pragma: no cover - network-dependent if out is not None: _progress_log( out, f"{progress_prefix} property chunk {index}/{len(chunks)} failed asynchronously ({exc}); retrying with recursive split", ) rows.extend( _pubchem_fetch_properties_chunk_resilient( chunk, timeout, out=out, progress_prefix=progress_prefix, chunk_label=f"{index}/{len(chunks)}", ) ) return rows def _resolve_pubchem_max_records( needed: int, record_multiplier: int, min_records_per_threshold: int, max_records_per_threshold: int, ) -> int: candidate = max(int(needed) * int(record_multiplier), int(min_records_per_threshold)) return max(1, min(candidate, int(max_records_per_threshold))) def _pubchem_similarity_rows( reference_smiles: str, reference_sdf_block: str, n_ligands: int, threshold_ladder: list[int], timeout: int, allow_partial: bool = False, out: Path | None = None, property_workers: int = 1, property_chunk_size: int = 200, record_multiplier: int = 8, min_records_per_threshold: int = 1000, max_records_per_threshold: int = 5000, ) -> tuple[list[tuple[str, str]], list[dict[str, object]], list[dict[str, object]], str | None]: collected_smiles: dict[str, tuple[str, str]] = {} metadata: list[dict[str, object]] = [] diagnostics: list[dict[str, object]] = [] reference_cid = _pubchem_reference_cid(reference_smiles, timeout, reference_sdf_block=reference_sdf_block) if out is not None: _progress_log( out, f"PubChem reference CID resolution: {'resolved to CID ' + str(reference_cid) if reference_cid is not None else 'not resolved; using direct similarity fallbacks'}", { "mode": "pubchem_similarity", "reference_cid": reference_cid, "reference_cid_resolved": reference_cid is not None, }, ) for threshold in threshold_ladder: needed = max(0, n_ligands - len(collected_smiles)) if needed <= 0: break max_records = _resolve_pubchem_max_records( needed, record_multiplier=record_multiplier, min_records_per_threshold=min_records_per_threshold, max_records_per_threshold=max_records_per_threshold, ) if out is not None: _progress_log( out, f"PubChem similarity threshold {threshold}: requesting up to {max_records} records; collected so far {len(collected_smiles)}/{n_ligands}", { "mode": "pubchem_similarity", "threshold": threshold, "requested_ligands": n_ligands, "collected_ligands": len(collected_smiles), "needed_ligands": needed, "max_records": max_records, }, ) similarity_kwargs: dict[str, object] = { "max_records": max_records, "timeout": timeout, "reference_sdf_block": reference_sdf_block, } if reference_cid is not None: similarity_kwargs["reference_cid"] = reference_cid try: cids = _pubchem_similarity_cids( reference_smiles, threshold, **similarity_kwargs, ) except Exception as exc: # pragma: no cover - network-dependent diagnostics.append( { "threshold": threshold, "returned_cids": 0, "accepted_new_smiles": 0, "collected_total": len(collected_smiles), "error": str(exc), } ) if out is not None: _progress_log( out, f"PubChem similarity threshold {threshold}: failed ({exc}); continuing to next threshold", ) continue if out is not None: _progress_log(out, f"PubChem similarity threshold {threshold}: received {len(cids)} CIDs") try: props = _pubchem_fetch_properties( cids, timeout, out=out, progress_prefix=f"PubChem threshold {threshold}:", workers=property_workers, chunk_size=property_chunk_size, ) except Exception as exc: # pragma: no cover - network-dependent diagnostics.append( { "threshold": threshold, "returned_cids": len(cids), "accepted_new_smiles": 0, "collected_total": len(collected_smiles), "error": f"property_fetch_failed: {exc}", } ) if out is not None: _progress_log( out, f"PubChem similarity threshold {threshold}: property fetch failed ({exc}); continuing to next threshold", ) continue accepted = 0 for item in props: smiles = str( item.get("SMILES") or item.get("ConnectivitySMILES") or item.get("CanonicalSMILES", "") ).strip() cid = int(item.get("CID", 0) or 0) if not smiles or cid <= 0 or not _looks_organic_smiles(smiles): continue ligand_id = f"pubchem_cid_{cid}" if ligand_id in collected_smiles: continue collected_smiles[ligand_id] = (smiles, ligand_id) metadata.append( { "ligand_id": ligand_id, "smiles": smiles, "source": "pubchem_similarity", "pubchem_cid": cid, "pubchem_threshold": threshold, "pubchem_title": item.get("Title", ""), "iupac_name": item.get("IUPACName", ""), "molecular_formula": item.get("MolecularFormula", ""), "molecular_weight": item.get("MolecularWeight", ""), "xlogp": item.get("XLogP", ""), "tpsa": item.get("TPSA", ""), "hbd": item.get("HBondDonorCount", ""), "hba": item.get("HBondAcceptorCount", ""), "rotatable_bonds": item.get("RotatableBondCount", ""), "heavy_atom_count": item.get("HeavyAtomCount", ""), } ) accepted += 1 if len(collected_smiles) >= n_ligands: break diagnostics.append( { "threshold": threshold, "returned_cids": len(cids), "accepted_new_smiles": accepted, "collected_total": len(collected_smiles), } ) if out is not None: _write_partial_pubchem_hits(out, list(collected_smiles.values()), metadata) _progress_log( out, f"PubChem similarity threshold {threshold}: accepted {accepted} new ligands; total {len(collected_smiles)}/{n_ligands}", { "mode": "pubchem_similarity", "threshold": threshold, "requested_ligands": n_ligands, "collected_ligands": len(collected_smiles), "accepted_new_smiles": accepted, "returned_cids": len(cids), }, ) if len(collected_smiles) >= n_ligands: _progress_log( out, f"PubChem similarity target reached: collected {len(collected_smiles)}/{n_ligands} ligands", { "mode": "pubchem_similarity", "threshold": threshold, "requested_ligands": n_ligands, "collected_ligands": len(collected_smiles), "target_reached": True, }, ) warning: str | None = None if len(collected_smiles) < n_ligands: warning = ( f"PubChem similarity search collected {len(collected_smiles)} ligands after thresholds {threshold_ladder}. " f"Requested {n_ligands}." ) if len(collected_smiles) < n_ligands and not allow_partial: raise RDockPipelineError( f"PubChem similarity search collected only {len(collected_smiles)} ligands for reference SMILES after thresholds " f"{threshold_ladder}. Requested {n_ligands}. Lower the threshold ladder, request fewer ligands, or provide --smiles-file." ) rows = list(collected_smiles.values())[:n_ligands] if out is not None: _write_partial_pubchem_hits(out, rows, metadata[:n_ligands]) return rows, metadata[:n_ligands], diagnostics, warning def _pubchem_name_rows( queries: list[str], n_ligands: int, timeout: int, ) -> tuple[list[tuple[str, str]], list[dict[str, object]], list[dict[str, object]]]: collected_smiles: dict[str, tuple[str, str]] = {} metadata: list[dict[str, object]] = [] diagnostics: list[dict[str, object]] = [] for query in [item.strip() for item in queries if item.strip()]: needed = max(0, n_ligands - len(collected_smiles)) if needed <= 0: break cids = _pubchem_name_search_cids(query, max_records=max(needed * 4, needed), timeout=timeout) props = _pubchem_fetch_properties(cids, timeout) accepted = 0 for item in props: smiles = str( item.get("SMILES") or item.get("ConnectivitySMILES") or item.get("CanonicalSMILES", "") ).strip() cid = int(item.get("CID", 0) or 0) if not smiles or cid <= 0 or not _looks_organic_smiles(smiles): continue ligand_id = f"pubchem_cid_{cid}" if ligand_id in collected_smiles: continue collected_smiles[ligand_id] = (smiles, ligand_id) metadata.append( { "ligand_id": ligand_id, "smiles": smiles, "source": "pubchem_compound_search", "pubchem_cid": cid, "pubchem_query": query, "pubchem_title": item.get("Title", ""), "iupac_name": item.get("IUPACName", ""), "molecular_formula": item.get("MolecularFormula", ""), "molecular_weight": item.get("MolecularWeight", ""), "xlogp": item.get("XLogP", ""), "tpsa": item.get("TPSA", ""), "hbd": item.get("HBondDonorCount", ""), "hba": item.get("HBondAcceptorCount", ""), "rotatable_bonds": item.get("RotatableBondCount", ""), "heavy_atom_count": item.get("HeavyAtomCount", ""), } ) accepted += 1 if len(collected_smiles) >= n_ligands: break diagnostics.append( { "query": query, "returned_cids": len(cids), "accepted_new_smiles": accepted, "collected_total": len(collected_smiles), } ) return list(collected_smiles.values())[:n_ligands], metadata[:n_ligands], diagnostics def _known_good_entry(pdb_id: str) -> dict[str, object] | None: for item in list_known_good_complexes(KNOWN_GOOD): if str(item.get("pdb_id", "")).upper() == pdb_id.upper(): return item return None def _pubchem_diagnostics_payload( source_name: str, reference_smiles: str, threshold_ladder: list[int], diagnostics: list[dict[str, object]], errors: list[str], ) -> dict[str, object]: return { "source": source_name, "reference_smiles": reference_smiles, "thresholds_tried": threshold_ladder, "requested_ligands": None, "collected_ligands": None, "endpoints_tried": [ "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/fastsimilarity_2d/sdf/cids/JSON (POST form field: sdf=...)", "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/fastidentity/sdf/cids/JSON (POST form field: sdf=...)", "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/fastsimilarity_2d/smiles/{smiles}/cids/JSON", "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{query}/cids/JSON", "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/cid/{cids}/property/.../JSON", ], "diagnostics": diagnostics, "errors": errors, } def _write_pubchem_diagnostics(out: Path, payload: dict[str, object]) -> Path: target = out / "logs" / "pubchem_diagnostics.json" target.parent.mkdir(parents=True, exist_ok=True) target.write_text(json.dumps(payload, indent=2), encoding="utf-8") qc_target = out / "qc" / "similarity_collection_diagnostics.json" qc_target.parent.mkdir(parents=True, exist_ok=True) qc_target.write_text(json.dumps(payload, indent=2), encoding="utf-8") return target def _resolve_smiles_source(args: argparse.Namespace) -> Path | None: if args.smiles_file: return Path(args.smiles_file) if args.ligand_source == "bundled_example": return DEFAULT_BUNDLED_EXAMPLE return None def _write_csv(path: Path, rows: list[dict[str, object]]) -> Path: path.parent.mkdir(parents=True, exist_ok=True) fields: list[str] = [] for row in rows: for key in row: if key not in fields: fields.append(key) with path.open("w", encoding="utf-8", newline="") as handle: writer = csv.DictWriter(handle, fieldnames=fields) writer.writeheader() writer.writerows(rows) return path def _mol_from_smiles(smiles: str): if not RDKIT_AVAILABLE: return None try: return Chem.MolFromSmiles(str(smiles)) except Exception: return None def _canonical_smiles(smiles: str) -> str: mol = _mol_from_smiles(smiles) if mol is None: return str(smiles).strip() try: return str(Chem.MolToSmiles(mol, canonical=True)) except Exception: return str(smiles).strip() def _scaffold_smiles(mol) -> str: if not RDKIT_AVAILABLE or mol is None: return "" try: return str(MurckoScaffold.MurckoScaffoldSmiles(mol=mol) or "") except Exception: return "" def _morgan_fp(mol): if not RDKIT_AVAILABLE or mol is None: return None try: generator = rdFingerprintGenerator.GetMorganGenerator(radius=2, fpSize=1024) return generator.GetFingerprint(mol) except Exception: try: return rdMolDescriptors.GetMorganFingerprintAsBitVect(mol, 2, nBits=1024) except Exception: return None def _existing_ligand_metadata_payload(lig_root: Path, expected_total: int) -> list[dict[str, object]] | None: metadata_path = lig_root / "ligand_metadata.csv" if not metadata_path.exists(): return None try: with metadata_path.open(newline="", encoding="utf-8") as handle: rows = list(csv.DictReader(handle)) except Exception: return None return rows if len(rows) == expected_total else None def _annotate_near_duplicate_analogs( metadata_rows: list[dict[str, object]], *, tanimoto_threshold: float = 0.55, max_heavy_atom_delta: int = 3, ) -> tuple[list[dict[str, object]], dict[str, object]]: if not metadata_rows: return metadata_rows, {"analog_group_count": 0, "analog_grouped_ligands": 0, "analog_grouping_available": bool(RDKIT_AVAILABLE)} enriched: list[dict[str, object]] = [] representatives_by_scaffold: dict[str, list[int]] = {} groups: dict[str, list[int]] = {} group_parent: dict[str, str] = {} for idx, row in enumerate(metadata_rows): item = dict(row) ligand_id = str(item.get("ligand_id", f"lig_{idx:05d}")) smiles = str(item.get("smiles", "")).strip() mol = _mol_from_smiles(smiles) canonical = _canonical_smiles(smiles) scaffold = _scaffold_smiles(mol) or canonical heavy = int(mol.GetNumHeavyAtoms()) if mol is not None else 0 fp = _morgan_fp(mol) group_id = "" rule = "singleton" for rep_idx in representatives_by_scaffold.get(scaffold, []): rep = enriched[rep_idx] if canonical and canonical == str(rep.get("canonical_smiles", "")): group_id = str(rep["analog_group_id"]) rule = "canonical_duplicate" break rep_heavy = int(rep.get("heavy_atom_count_for_grouping", 0) or 0) rep_fp = rep.get("_analog_fp") if fp is None or rep_fp is None: continue if abs(heavy - rep_heavy) > max_heavy_atom_delta: continue try: sim = float(DataStructs.TanimotoSimilarity(fp, rep_fp)) except Exception: sim = 0.0 if sim >= tanimoto_threshold: group_id = str(rep["analog_group_id"]) rule = f"same_scaffold_tanimoto_{sim:.3f}" break if not group_id: group_id = f"analog_group_{len(groups) + 1:06d}" representatives_by_scaffold.setdefault(scaffold, []).append(idx) group_parent[group_id] = ligand_id item["canonical_smiles"] = canonical item["scaffold_core"] = scaffold item["heavy_atom_count_for_grouping"] = heavy item["analog_group_id"] = group_id item["analog_parent_id"] = group_parent.get(group_id, ligand_id) item["analog_group_rule"] = rule item["_analog_fp"] = fp groups.setdefault(group_id, []).append(idx) enriched.append(item) for group_id, indices in groups.items(): size = len(indices) parent_id = str(enriched[indices[0]].get("analog_parent_id", enriched[indices[0]].get("ligand_id", ""))) for variant_idx, row_idx in enumerate(indices, start=1): enriched[row_idx]["analog_group_size"] = size enriched[row_idx]["analog_variant_index"] = variant_idx enriched[row_idx]["analog_group_weight"] = 1.0 / max(1, size) enriched[row_idx]["analog_parent_id"] = parent_id enriched[row_idx].pop("_analog_fp", None) summary = { "analog_grouping_available": bool(RDKIT_AVAILABLE), "analog_group_count": len(groups), "analog_grouped_ligands": sum(len(indices) for indices in groups.values() if len(indices) > 1), "analog_largest_group_size": max((len(indices) for indices in groups.values()), default=0), "analog_tanimoto_threshold": float(tanimoto_threshold), "analog_max_heavy_atom_delta": int(max_heavy_atom_delta), } return enriched, summary def _dataset_uniqueness_summary(metadata_rows: list[dict[str, object]]) -> dict[str, object]: seen_smiles: set[str] = set() total = 0 for row in metadata_rows: smiles = str(row.get("smiles", "")).strip() if not smiles: continue total += 1 seen_smiles.add(smiles) duplicate_count = max(0, total - len(seen_smiles)) duplicate_fraction = (duplicate_count / total) if total else 0.0 warnings: list[str] = [] if duplicate_fraction > 0.01: warnings.append( f"duplicate parent fraction is {duplicate_fraction:.4f} (>1%); inspect ligand source and deduplication settings before scientific benchmarking" ) return { "n_input_smiles": total, "n_unique_parent_ligands": len(seen_smiles), "duplicate_parent_count": duplicate_count, "duplicate_parent_fraction": duplicate_fraction, "warnings": warnings, "deduplication_method": "exact_smiles", } def _infer_existing_dataset_manifest(out: Path, prepared_ligands: int, warnings: list[str] | None = None) -> dict[str, object]: warnings = list(warnings or []) raw_dir = out / "raw" pdb_candidates = sorted(list(raw_dir.glob("*.pdb")) + list(raw_dir.glob("*.cif")) + list(raw_dir.glob("*.mmcif"))) pdb_id = pdb_candidates[0].stem[:4].upper() if pdb_candidates else "" resolved = resolve_known_good_defaults(KNOWN_GOOD, pdb_id or "UNKN", None, None, None) ligand_source = "smiles_file" reference_smiles = "" pubchem_payload: dict[str, object] = {} pubchem_path = out / "logs" / "pubchem_diagnostics.json" if pubchem_path.exists(): try: pubchem_payload = json.loads(pubchem_path.read_text(encoding="utf-8")) except Exception: pubchem_payload = {} ligand_source = str(pubchem_payload.get("source") or "pubchem_similarity") reference_smiles = str(pubchem_payload.get("reference_smiles") or "") else: ref_smiles_log = out / "logs" / "reference_ligand_to_smiles.stdout.log" if ref_smiles_log.exists(): first = ref_smiles_log.read_text(encoding="utf-8", errors="ignore").splitlines() if first: reference_smiles = first[0].split()[0].strip() manifest = { "pdb_id": resolved["pdb_id"] or pdb_id, "receptor_chain": resolved["receptor_chain"], "reference_ligand_resname": resolved["reference_ligand_resname"], "reference_ligand_chain": resolved["reference_ligand_chain"], "n_ligands_requested": len(_read_all_smiles(require_file(out / "ligands" / "all_ligands.smi", "all_ligands.smi"))), "ligands_prepared": int(prepared_ligands), "paths": { "target_mol2": str(out / "target" / "target.mol2"), "reference_ligand_sdf": str(out / "target" / "reference_ligand.sdf"), "all_ligands_sdf": str(out / "ligands" / "all_ligands.sdf"), "all_ligands_smi": str(out / "ligands" / "all_ligands.smi"), "rdock_prm_dir": str(out / "target" / "rdock_prm"), "target_config_yaml": str(out / "target" / "rdock_prm" / "target_config.yaml"), }, "versions": { "obabel": probe_version(require_executable("obabel")) if shutil.which("obabel") else "", "rbdock": probe_version(require_executable("rbdock")) if shutil.which("rbdock") else "", "rbcavity": probe_version(require_executable("rbcavity")) if shutil.which("rbcavity") else "", }, "ligand_source": ligand_source, "reference_ligand_smiles": reference_smiles, "pubchem_threshold_ladder": pubchem_payload.get("thresholds_tried", []) if pubchem_payload else [], "pubchem_diagnostics": pubchem_payload, "rbcavity_status": "success" if (out / "target" / "rdock_prm").exists() else "unknown", "warnings": warnings, "available_hetero_ligands": [], "auto_reference_ligand": False, "auto_reference_candidates": [], "auto_reference_selected": {}, } return manifest def _ensure_dataset_metadata_files(out: Path, prepared_ligands: int, warnings: list[str] | None = None) -> None: manifest_path = out / "dataset_manifest.json" if manifest_path.exists(): manifest = json.loads(manifest_path.read_text(encoding="utf-8")) manifest["ligands_prepared"] = int(prepared_ligands) manifest.setdefault("paths", {}) manifest["paths"]["all_ligands_sdf"] = str(out / "ligands" / "all_ligands.sdf") manifest["paths"]["all_ligands_smi"] = str(out / "ligands" / "all_ligands.smi") if warnings: manifest["warnings"] = list(dict.fromkeys(list(manifest.get("warnings", [])) + list(warnings))) create_dataset_manifest(out, manifest) else: synth_warnings = ["dataset_manifest.json was missing and was reconstructed from existing dataset files"] if warnings: synth_warnings.extend(warnings) create_dataset_manifest(out, _infer_existing_dataset_manifest(out, prepared_ligands, warnings=synth_warnings)) report_path = out / "qc" / "preparation_report.md" if not report_path.exists(): report_lines = [ f"# Dataset Preparation Report: {out.name}", "", "- report_status: `reconstructed`", f"- ligands_prepared: `{prepared_ligands}`", f"- target_mol2: `{out / 'target' / 'target.mol2'}`", f"- reference_ligand_sdf: `{out / 'target' / 'reference_ligand.sdf'}`", f"- all_ligands_sdf: `{out / 'ligands' / 'all_ligands.sdf'}`", f"- all_ligands_smi: `{out / 'ligands' / 'all_ligands.smi'}`", ] if warnings: report_lines.extend(["", "## Warnings", *[f"- {item}" for item in warnings]]) report_path.parent.mkdir(parents=True, exist_ok=True) report_path.write_text("\n".join(report_lines) + "\n", encoding="utf-8") def _list_known_good() -> int: complexes = list_known_good_complexes(KNOWN_GOOD) print(json.dumps(complexes, indent=2)) return 0 def _list_hetero_for_pdb(args: argparse.Namespace) -> int: temp_root = Path(args.out) if args.out else ROOT / ".tmp_list_hetero" _mkdir_or_fail(temp_root) pdb_path = download_pdb_structure(str(args.pdb_id), temp_root / "raw", force=False) payload = { "pdb_id": str(args.pdb_id).upper(), "hetero_ligands": list_hetero_ligands(pdb_path, min_reference_ligand_atoms=args.min_reference_ligand_atoms), } print(json.dumps(payload, indent=2)) return 0 def _validate_only(dataset_dir: Path) -> int: print(json.dumps(validate_dataset_dir(dataset_dir, check_rdock_tools=False), indent=2)) return 0 def _plan(args: argparse.Namespace, resolved: dict[str, str], smiles_file: Path | None) -> dict[str, object]: if smiles_file is None: ligand_count = None smiles_repr = "" elif not smiles_file.exists(): ligand_count = 0 smiles_repr = str(smiles_file) else: ligand_count = len(_read_smiles(smiles_file, args.n_ligands)) smiles_repr = str(smiles_file) missing_tools = [tool for tool in ("obabel", "rbcavity", "rbdock") if shutil.which(tool) is None] return { "pdb_id": resolved["pdb_id"], "receptor_chain": resolved["receptor_chain"], "reference_ligand_resname": resolved["reference_ligand_resname"], "reference_ligand_chain": resolved["reference_ligand_chain"], "n_ligands_requested": args.n_ligands, "ligand_source": args.ligand_source, "auto_reference_ligand": bool(args.auto_reference_ligand), "min_reference_ligand_atoms": int(args.min_reference_ligand_atoms), "smiles_file": smiles_repr, "detected_smiles_rows": ligand_count, "out": str(args.out), "missing_dependencies": missing_tools, "commands": [ "download PDB structure if absent", "extract receptor chain and reference ligand from PDB", "convert reference ligand and receptor with OpenBabel", "resolve ligand source via smiles file or PubChem when --smiles-file is not provided", "prepare target with rbcavity", "convert SMILES to 3D SDF", "write dataset_manifest.json and qc/preparation_report.md", ], } def _reference_selection_error( exc: RDockPipelineError, pdb_id: str, receptor_chain: str, out: Path, ) -> RDockPipelineError: known = _known_good_entry(pdb_id) lines = [str(exc)] if known: lines.append( "Known-good suggestion: " f"--receptor-chain {known.get('receptor_chain')} " f"--reference-ligand-resname {known.get('reference_ligand_resname')} " f"--reference-ligand-chain {known.get('reference_ligand_chain')}" ) lines.append( "Recommended correction: " f"python scripts/prepare_pdb_ligand_dataset.py --pdb-id {pdb_id} --receptor-chain {receptor_chain} " f"--auto-reference-ligand --n-ligands 1000 --ligand-source smiles_file " f"--smiles-file data/examples/example_smiles_1000.smi --out {out} --force" ) lines.append( "You can inspect candidate hetero ligands with: " f"python scripts/prepare_pdb_ligand_dataset.py --list-hetero --pdb-id {pdb_id}" ) return RDockPipelineError("\n".join(lines)) def _select_reference_ligand(args: argparse.Namespace, resolved: dict[str, str], pdb_path: Path) -> tuple[dict[str, str], list[dict[str, object]], dict[str, object] | None]: if args.auto_reference_ligand or not resolved["reference_ligand_resname"]: selected, candidates = auto_detect_reference_ligand( pdb_path, resolved["receptor_chain"], min_reference_ligand_atoms=args.min_reference_ligand_atoms, ) resolved = dict(resolved) resolved["reference_ligand_resname"] = str(selected["resname"]) resolved["reference_ligand_chain"] = str(selected["chain"]) return resolved, candidates, selected return resolved, [], None def _resolve_ligand_rows( args: argparse.Namespace, resolved: dict[str, str], runner: CommandRunner, reference_sdf: Path, out: Path, ) -> tuple[list[tuple[str, str]], list[dict[str, object]], str, dict[str, object] | None, str, list[str]]: smiles_file = _resolve_smiles_source(args) source = args.ligand_source if args.smiles_file: source = "smiles_file" if source == "smiles_file" and smiles_file is None: raise RDockPipelineError("`--ligand-source smiles_file` requires --smiles-file /path/to/library.smi.") if source in {"pubchem_random_compounds", "zinc_file"}: raise RDockPipelineError( f"Ligand source `{source}` is not enabled in this portable bundle. " "Use --ligand-source smiles_file --smiles-file /path/to/real_library.smi." ) if source == "bundled_example": if args.n_ligands > 50: raise RDockPipelineError( f"`bundled_example` contains only 50 ligands. Requested {args.n_ligands}. " f"Use --ligand-source smiles_file --smiles-file data/examples/example_smiles_1000.smi or a larger real library." ) if args.n_ligands > 5000 and source not in {"smiles_file", "pubchem_similarity"}: raise RDockPipelineError( f"Requested {args.n_ligands} ligands with source `{source}`. For libraries larger than 5000 ligands, " "provide a real large library via --ligand-source smiles_file --smiles-file /path/to/library.smi." ) if smiles_file is not None: rows = _read_smiles(smiles_file, args.n_ligands) if len(rows) < args.n_ligands: raise RDockPipelineError( f"Requested {args.n_ligands} ligands but {smiles_file} contains only {len(rows)} usable rows. " f"Provide a larger --smiles-file. Example: --smiles-file /data/libraries/real_50k_library.smi" ) metadata_rows = [{"ligand_id": ligand_id, "smiles": smiles, "source": "smiles_file"} for smiles, ligand_id in rows] return rows, metadata_rows, "", None, source, [] reference_smiles = _reference_ligand_to_smiles(runner, reference_sdf, out) reference_sdf_block = _reference_ligand_sdf_block(reference_sdf) threshold_ladder = _resolve_threshold_ladder(args) diagnostics_errors: list[str] = [] combined_diagnostics: list[dict[str, object]] = [] warnings: list[str] = [] if source in {"auto", "pubchem_similarity"}: try: rows, metadata_rows, diagnostics, warning = _pubchem_similarity_rows( reference_smiles, reference_sdf_block, args.n_ligands, threshold_ladder, timeout=args.pubchem_timeout, allow_partial=bool(getattr(args, "allow_partial_ligand_set", False)), out=out, property_workers=int(getattr(args, "pubchem_property_workers", _default_pubchem_workers())), property_chunk_size=int(getattr(args, "pubchem_property_chunk_size", 200)), record_multiplier=int(getattr(args, "pubchem_record_multiplier", 8)), min_records_per_threshold=int(getattr(args, "pubchem_min_records_per_threshold", 1000)), max_records_per_threshold=int(getattr(args, "pubchem_max_records_per_threshold", 5000)), ) combined_diagnostics.extend(diagnostics) payload = _pubchem_diagnostics_payload("pubchem_similarity", reference_smiles, threshold_ladder, combined_diagnostics, diagnostics_errors) payload["requested_ligands"] = args.n_ligands payload["collected_ligands"] = len(rows) if warning: warnings.append(warning) return rows, metadata_rows, reference_smiles, payload, "pubchem_similarity", warnings except RDockPipelineError as exc: diagnostics_errors.append(str(exc)) if source in {"auto", "pubchem_compound_search"}: queries = [ resolved["reference_ligand_resname"], f"{resolved['pdb_id']} {resolved['reference_ligand_resname']}", str((_known_good_entry(resolved["pdb_id"]) or {}).get("target_name", "")), ] rows, metadata_rows, diagnostics = _pubchem_name_rows(queries, args.n_ligands, timeout=args.pubchem_timeout) combined_diagnostics.extend(diagnostics) if len(rows) >= args.n_ligands: payload = _pubchem_diagnostics_payload("pubchem_compound_search", reference_smiles, threshold_ladder, combined_diagnostics, diagnostics_errors) payload["requested_ligands"] = args.n_ligands payload["collected_ligands"] = len(rows) return rows, metadata_rows, reference_smiles, payload, "pubchem_compound_search", warnings diagnostics_errors.append( f"PubChem compound search collected only {len(rows)} ligands for queries {queries}. Requested {args.n_ligands}." ) if rows and bool(getattr(args, "allow_partial_ligand_set", False)): payload = _pubchem_diagnostics_payload("pubchem_compound_search", reference_smiles, threshold_ladder, combined_diagnostics, diagnostics_errors) payload["requested_ligands"] = args.n_ligands payload["collected_ligands"] = len(rows) warnings.append( f"PubChem compound search collected {len(rows)} ligands for queries {queries}. Requested {args.n_ligands}." ) return rows, metadata_rows, reference_smiles, payload, "pubchem_compound_search", warnings payload = _pubchem_diagnostics_payload(source, reference_smiles, threshold_ladder, combined_diagnostics, diagnostics_errors) payload["requested_ligands"] = args.n_ligands payload["collected_ligands"] = 0 _write_pubchem_diagnostics(out, payload) raise RDockPipelineError( f"Could not collect {args.n_ligands} ligands from source `{source}` for {resolved['pdb_id']}. " f"Diagnostics were written to {out / 'logs' / 'pubchem_diagnostics.json'}. " "Use --ligand-source smiles_file --smiles-file /path/to/real_library.smi for a stable large-library workflow." ) def run(args: argparse.Namespace) -> int: if args.list_known_good: return _list_known_good() if args.list_hetero: return _list_hetero_for_pdb(args) if args.validate_only: return _validate_only(Path(args.out)) if args.prepare_ligands_only: out = Path(args.out) _mkdir_or_fail(out) for name in ("ligands", "logs", "qc"): _mkdir_or_fail(out / name) runner = CommandRunner(out / "logs" / "commands.log") result = _prepare_ligands_from_existing_smi( out, runner, batch_size=int(args.ligand_batch_size), jobs=args.ligand_jobs, cpu_fraction=float(args.ligand_cpu_fraction), force_rebuild=bool(args.force), ) metadata_warnings: list[str] = [] if not (out / "dataset_manifest.json").exists(): metadata_warnings.append("dataset_manifest.json was missing before ligand resume") if not (out / "qc" / "preparation_report.md").exists(): metadata_warnings.append("qc/preparation_report.md was missing before ligand resume") _ensure_dataset_metadata_files(out, int(result["prepared_ligands"]), warnings=metadata_warnings) print(json.dumps(result, indent=2)) return 0 resolved = resolve_known_good_defaults( KNOWN_GOOD, args.pdb_id, args.receptor_chain, args.reference_ligand_resname, args.reference_ligand_chain, ) if not resolved["receptor_chain"] or (not resolved["reference_ligand_resname"] and not args.auto_reference_ligand): raise RDockPipelineError( "Missing receptor chain or reference ligand resname. Provide them explicitly, use --auto-reference-ligand, or use a known-good PDB entry." ) smiles_file = _resolve_smiles_source(args) plan = _plan(args, resolved, smiles_file) plan["ligand_source"] = args.ligand_source plan["pubchem_threshold_ladder"] = _resolve_threshold_ladder(args) plan["uses_pubchem_similarity"] = smiles_file is None out = Path(args.out) _mkdir_or_fail(out) if args.dry_run: (out / "dataset_plan.json").write_text(json.dumps(plan, indent=2), encoding="utf-8") print(json.dumps(plan, indent=2)) return 0 if out.exists() and args.force: shutil.rmtree(out) _mkdir_or_fail(out) for name in ("raw", "target", "ligands", "logs", "qc"): _mkdir_or_fail(out / name) runner = CommandRunner(out / "logs" / "commands.log") pdb_path = download_pdb_structure(resolved["pdb_id"], out / "raw", force=args.force) resolved, auto_candidates, auto_selected = _select_reference_ligand(args, resolved, pdb_path) (out / "raw" / "download_metadata.json").write_text( json.dumps({"pdb_id": resolved["pdb_id"], "source": str(pdb_path), "status": "downloaded_or_reused"}, indent=2), encoding="utf-8", ) try: receptor_pdb, ligand_pdb, hetero = extract_receptor_and_reference_ligand( pdb_path, resolved["receptor_chain"], resolved["reference_ligand_resname"], resolved["reference_ligand_chain"], out / "target", min_reference_ligand_atoms=args.min_reference_ligand_atoms, ) except RDockPipelineError as exc: raise _reference_selection_error(exc, resolved["pdb_id"], resolved["receptor_chain"], out) from exc reference_raw_sdf = out / "target" / "reference_ligand_raw.sdf" reference_sdf = out / "target" / "reference_ligand.sdf" _obabel_convert(runner, "reference_ligand_raw_to_sdf", ligand_pdb, reference_raw_sdf, [], out) shutil.copy2(reference_raw_sdf, reference_sdf) rows, metadata_rows, reference_smiles, pubchem_payload, ligand_source_used, ligand_warnings = _resolve_ligand_rows(args, resolved, runner, reference_sdf, out) if pubchem_payload is not None: _write_pubchem_diagnostics(out, pubchem_payload) if ligand_warnings: for warning in ligand_warnings: print(f"WARNING: {warning}", file=sys.stderr) if not rows: diagnostics_path = out / "logs" / "pubchem_diagnostics.json" raise RDockPipelineError( f"PubChem returned zero usable ligands for {resolved['pdb_id']} with source `{ligand_source_used}` and thresholds " f"{_resolve_threshold_ladder(args)}. No docking dataset can be created from zero ligands. " f"See diagnostics: {diagnostics_path}. " "Lower --identity-threshold-stop, try a different reference complex, or provide --smiles-file with a real library." ) metadata_rows, analog_summary = _annotate_near_duplicate_analogs(metadata_rows) metadata_by_id = {str(row.get("ligand_id", "")): row for row in metadata_rows} rows = [(smiles, ligand_id) for smiles, ligand_id in rows if str(ligand_id) in metadata_by_id] target_prm_dir = out / "target" / "rdock_prm" prep = prepare_dataset_target_with_rdock(receptor_pdb, reference_sdf, target_prm_dir, jobs="auto", cpu_fraction=0.85) target_mol2 = require_file(target_prm_dir / "receptor.mol2", "prepared receptor mol2") shutil.copy2(target_mol2, out / "target" / "target.mol2") smi_path = _write_smi(rows, out / "ligands" / "all_ligands.smi") _write_csv(out / "ligands" / "ligand_metadata.csv", metadata_rows) _write_csv(out / "ligands" / "invalid_ligands.csv", []) if args.stop_after_ligand_collection: collection_summary = { "status": "ligand_collection_complete", "pdb_id": resolved["pdb_id"], "ligands_requested": args.n_ligands, "ligands_collected": len(rows), "reference_ligand_smiles": reference_smiles, "ligand_source": ligand_source_used, "all_ligands_smi": str(smi_path), "ligand_metadata_csv": str(out / "ligands" / "ligand_metadata.csv"), "analog_grouping": analog_summary, "pubchem_diagnostics_json": str(out / "logs" / "pubchem_diagnostics.json"), "next_stage": "openbabel_ligand_preparation", } (out / "qc" / "collection_summary.json").write_text(json.dumps(collection_summary, indent=2), encoding="utf-8") print( f"Collected {len(rows)}/{args.n_ligands} ligands and wrote {smi_path}. " "Stopping before OpenBabel ligand preparation as requested.", file=sys.stderr, ) print(json.dumps(collection_summary, indent=2)) return 0 ligand_prep = _prepare_ligands_from_existing_smi( out, runner, batch_size=int(args.ligand_batch_size), jobs=args.ligand_jobs, cpu_fraction=float(args.ligand_cpu_fraction), force_rebuild=bool(args.force), metadata_rows=metadata_rows, ) ligands_sdf = require_file(Path(str(ligand_prep["final_sdf"])), "prepared ligand sdf") uniqueness = _dataset_uniqueness_summary(metadata_rows) manifest_warnings = list(ligand_warnings) + [str(item) for item in uniqueness.get("warnings", [])] manifest = { "pdb_id": resolved["pdb_id"], "receptor_chain": resolved["receptor_chain"], "reference_ligand_resname": resolved["reference_ligand_resname"], "reference_ligand_chain": resolved["reference_ligand_chain"], "reference_ligand_pubchem_cid": (pubchem_payload or {}).get("reference_pubchem_cid", ""), "n_ligands_requested": args.n_ligands, "n_collected_raw": len(rows), "n_input_smiles": int(uniqueness["n_input_smiles"]), "n_unique_parent_ligands": int(uniqueness["n_unique_parent_ligands"]), "ligands_prepared": len(rows), "n_prepared_ligands": len(rows), "n_invalid": 0, "deduplication_method": str(uniqueness["deduplication_method"]), "source": ligand_source_used, "synthetic_expansion": False, "synthetic_stress_test_only": False, "similarity_thresholds": _resolve_threshold_ladder(args) if pubchem_payload is not None else [], "min_similarity": float(getattr(args, "min_similarity", 0.70)), "max_similarity": float(getattr(args, "max_similarity", 0.99)), "deduplicate_canonical_smiles": _bool_arg(getattr(args, "deduplicate_canonical_smiles", "true"), True), "deduplicate_inchikey": _bool_arg(getattr(args, "deduplicate_inchikey", "true"), True), "paths": { "target_mol2": str(out / "target" / "target.mol2"), "reference_ligand_sdf": str(reference_sdf), "all_ligands_sdf": str(ligands_sdf), "rdock_prm_dir": str(target_prm_dir), "target_config_yaml": str(target_prm_dir / "target_config.yaml"), }, "versions": { "obabel": probe_version(require_executable("obabel")), "rbdock": probe_version(require_executable("rbdock")), "rbcavity": probe_version(require_executable("rbcavity")), }, "ligand_source": ligand_source_used, "analog_grouping": analog_summary, "reference_ligand_smiles": reference_smiles, "pubchem_threshold_ladder": _resolve_threshold_ladder(args) if pubchem_payload is not None else [], "pubchem_diagnostics": pubchem_payload or {}, "rbcavity_status": "success", "warnings": manifest_warnings, "ligand_preparation": ligand_prep, "available_hetero_ligands": hetero[:50], "auto_reference_ligand": bool(args.auto_reference_ligand), "auto_reference_candidates": auto_candidates[:50], "auto_reference_selected": auto_selected or {}, "prepared_target": prep, "copied_target_bundle": {path.name: str(path) for path in target_prm_dir.iterdir() if path.is_file()}, } create_dataset_manifest(out, manifest) _write_csv( out / "qc" / "deduplication_report.tsv", [ { "n_input_smiles": int(uniqueness["n_input_smiles"]), "n_unique_parent_ligands": int(uniqueness["n_unique_parent_ligands"]), "duplicate_parent_fraction": float(uniqueness["duplicate_parent_fraction"]), "deduplication_method": str(uniqueness["deduplication_method"]), "synthetic_expansion": "false", } ], ) qc_report = [ f"# Dataset Preparation Report: {resolved['pdb_id']}", "", f"- receptor_chain: `{resolved['receptor_chain']}`", f"- reference_ligand: `{resolved['reference_ligand_resname']}` chain `{resolved['reference_ligand_chain']}`", f"- ligands_prepared: `{len(rows)}`", f"- ligands_requested: `{args.n_ligands}`", f"- ligand_source: `{ligand_source_used}`", f"- n_input_smiles: `{uniqueness['n_input_smiles']}`", f"- n_unique_parent_ligands: `{uniqueness['n_unique_parent_ligands']}`", f"- duplicate_parent_fraction: `{float(uniqueness['duplicate_parent_fraction']):.4f}`", f"- analog_group_count: `{analog_summary['analog_group_count']}`", f"- analog_grouped_ligands: `{analog_summary['analog_grouped_ligands']}`", f"- analog_largest_group_size: `{analog_summary['analog_largest_group_size']}`", f"- deduplication_method: `{uniqueness['deduplication_method']}`", "- synthetic_expansion: `false`", f"- reference_ligand_smiles: `{reference_smiles}`", f"- pubchem_threshold_ladder: `{_resolve_threshold_ladder(args) if pubchem_payload is not None else []}`", f"- target_mol2: `{out / 'target' / 'target.mol2'}`", f"- reference_ligand_sdf: `{reference_sdf}`", f"- all_ligands_sdf: `{ligands_sdf}`", f"- target_config_yaml: `{target_prm_dir / 'target_config.yaml'}`", ] if auto_selected: qc_report.extend( [ "", "## Auto reference ligand selection", f"- selected_resname: `{auto_selected.get('resname', '')}`", f"- selected_chain: `{auto_selected.get('chain', '')}`", f"- selected_residue_id: `{auto_selected.get('residue_id', '')}`", f"- heavy_atom_count: `{auto_selected.get('heavy_atom_count', '')}`", f"- min_distance_to_receptor: `{auto_selected.get('min_distance_to_receptor', '')}`", ] ) if manifest_warnings: qc_report.extend(["", "## Ligand Collection Warnings", *[f"- {warning}" for warning in manifest_warnings]]) (out / "qc" / "preparation_report.md").write_text("\n".join(qc_report) + "\n", encoding="utf-8") print(json.dumps(validate_dataset_dir(out, check_rdock_tools=False), indent=2)) return 0 def build_parser() -> argparse.ArgumentParser: parser = argparse.ArgumentParser(description="Prepare a portable PDB + ligand dataset for rDock production runs.") parser.add_argument("--pdb-id") parser.add_argument("--receptor-chain") parser.add_argument("--reference-ligand-resname") parser.add_argument("--reference-ligand-chain") parser.add_argument("--auto-reference-ligand", action="store_true") parser.add_argument("--min-reference-ligand-atoms", type=int, default=8) parser.add_argument("--n-ligands", type=int, default=1000) parser.add_argument( "--ligand-source", default="auto", choices=[ "auto", "smiles_file", "pubchem_similarity", "pubchem_compound_search", "pubchem_random_compounds", "zinc_file", "bundled_example", ], ) parser.add_argument("--source", dest="ligand_source") parser.add_argument("--smiles-file") parser.add_argument("--similarity-thresholds", default="") parser.add_argument("--min-similarity", type=float, default=0.70) parser.add_argument("--max-similarity", type=float, default=0.99) parser.add_argument("--deduplicate-canonical-smiles", default="true") parser.add_argument("--deduplicate-inchikey", default="true") parser.add_argument("--pubchem-threshold-ladder", default="95,90,85,80,75,70") parser.add_argument("--pubchem-threshold-start", "--identity-threshold-start", dest="pubchem_threshold_start", type=int, default=None) parser.add_argument("--pubchem-threshold-stop", "--identity-threshold-stop", dest="pubchem_threshold_stop", type=int, default=None) parser.add_argument("--pubchem-threshold-step", type=int, default=1) parser.add_argument("--pubchem-timeout", type=int, default=60) parser.add_argument("--pubchem-property-workers", type=int, default=_default_pubchem_workers()) parser.add_argument("--pubchem-property-chunk-size", type=int, default=200) parser.add_argument("--pubchem-record-multiplier", type=int, default=8) parser.add_argument("--pubchem-min-records-per-threshold", type=int, default=1000) parser.add_argument("--pubchem-max-records-per-threshold", type=int, default=5000) parser.add_argument("--allow-partial-ligand-set", action="store_true") parser.add_argument("--prepare-ligands-only", action="store_true") parser.add_argument("--stop-after-ligand-collection", action="store_true") parser.add_argument("--ligand-batch-size", type=int, default=250) parser.add_argument("--ligand-jobs", default=str(_default_ligand_jobs())) parser.add_argument("--ligand-cpu-fraction", type=float, default=0.85) parser.add_argument("--out") parser.add_argument("--ph", type=float, default=7.4) parser.add_argument("--seed", type=int, default=42) parser.add_argument("--force", action="store_true") parser.add_argument("--dry-run", action="store_true") parser.add_argument("--list-known-good", action="store_true") parser.add_argument("--list-hetero", action="store_true") parser.add_argument("--validate-only", action="store_true") return parser def main() -> int: parser = build_parser() args = parser.parse_args() if not args.list_known_good and not args.validate_only and not args.list_hetero and not args.prepare_ligands_only and not args.pdb_id: parser.error("--pdb-id is required unless --list-known-good, --list-hetero, or --validate-only is used") if not args.list_known_good and not args.list_hetero and not args.out: parser.error("--out is required unless --list-known-good or --list-hetero is used") return run(args) if __name__ == "__main__": raise SystemExit(main())