D4CMPP2 0.4.0__tar.gz → 1.0.0__tar.gz

{d4cmpp2-0.4.0 → d4cmpp2-1.0.0}/D4CMPP2.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: D4CMPP2
-Version: 0.4.0
+Version: 1.0.0
 Summary: PyTorch Geometric molecular property prediction models
 License-Expression: MIT
 Requires-Python: <3.13,>=3.10
@@ -25,9 +25,24 @@ Dynamic: license-file
 
 # D4CMPP2
 
-D4CMPP2 is a PyTorch Geometric package for molecular-property regression. It
-supports ordinary molecular graphs, compound/solvent pairs, and interpretable
-ISA models through one training and inference API.
+D4CMPP2 is the next-generation implementation of the D4CMPP framework. It is based on the original [D4CMPP](https://github.com/ACCA-KU/DeepMPP) project and was extensively redeveloped with OpenAI Codex through an AI-assisted, test-driven engineering workflow.
+
+The package provides a unified PyTorch Geometric framework for molecular property prediction, supporting ordinary molecular graphs, compound–solvent pairs, and interpretable ISA models.
+
+Key advantages of D4CMPP2 include:
+
+- **Unified model interface** — Train general molecular, solvent-aware, and ISA-based models through a consistent Python API and command-line interface.
+- **Multiple graph neural network architectures** — Use GCN, MPNN, DMPNN, AttentiveFP, GAT, graph-contribution, and ISA model families within the same workflow.
+- **Interpretable molecular predictions** — Analyze fragment- and atom-level contributions with ISA models while preserving alignment between molecular structures and attribution scores.
+- **Reliable data handling** — Detect invalid SMILES, missing columns, non-numeric targets, misaligned inputs, incompatible graph caches, and invalid dataset splits before they silently affect training.
+- **Efficient repeated experiments** — Reuse fingerprinted graph caches and optionally skip previously completed data-quality and per-graph cache checks.
+- **Transfer learning and training resumption** — Initialize compatible model parameters from existing models or resume complete optimizer and scheduler states from checkpoints.
+- **Reproducible experimentation** — Control random seeds, deterministic execution, dataset splitting, and run metadata across CPU and CUDA environments.
+- **Multi-target and multi-input support** — Train on multiple target properties, compound–solvent pairs, and additional numeric features without changing the overall workflow.
+- **Saved-model analysis** — Reload trained models through `Analyzer` for single or batch prediction while retaining invalid and duplicate input rows.
+- **Experiment tracking and optimization** — Record run manifests, compare completed experiments, and perform grid or Bayesian hyperparameter optimization.
+- **Backward compatibility** — Preserve established D4CMPP APIs, model assets, configuration conventions, and legacy loading paths where practical.
+- **Deployment-oriented validation** — Test source execution, packaged distributions, CLI entry points, model persistence, Analyzer workflows, and CPU-based end-to-end training.
 
 ## Requirements and installation
 
@@ -240,6 +255,32 @@ The cache policies are:
 
 DGL caches are preserved but never loaded.
 
+Data preparation reports when CSV validation and graph-cache loading start and
+finish, so a large cache no longer looks stalled before graph generation. Full
+per-graph tensor validation remains the default. After a cache has already been
+verified and the same data is trained repeatedly, it can be skipped explicitly:
+
+```python
+train(
+    data="data.csv",
+    target=["target"],
+    network="GCN",
+    data_quality_report=False,
+    validate_graph_cache=False,
+)
+```
+
+`data_quality_report=False` skips the slower canonical-SMILES duplicate,
+split-overlap, and issue report after that dataset has already been reviewed.
+Required CSV columns, numeric values, split labels, row alignment, and nonempty
+targets are still checked. `validate_graph_cache=False` still checks the cache
+recipe, ordered SMILES, and graph count; it only skips tensor shape, dtype,
+finite-value, and edge-alignment checks inside each cached graph. Newly generated
+graphs are always validated before saving.
+
+The CLI equivalents are `--skip-data-quality-report` and
+`--skip-graph-cache-validation`.
+
 ## Prediction and analysis
 
 ```python

{d4cmpp2-0.4.0 → d4cmpp2-1.0.0}/D4CMPP2.egg-info/SOURCES.txt

@@ -84,6 +84,12 @@ pyproject.toml
 ./src/TrainManager/TrainManager.py
 ./src/TrainManager/__init__.py
 ./src/TrainManager/callbacks.py
+./src/api/__init__.py
+./src/api/command.py
+./src/api/errors.py
+./src/api/legacy_grid_search.py
+./src/api/optimization.py
+./src/api/training.py
 ./src/utils/PATH.py
 ./src/utils/__init__.py
 ./src/utils/argparser.py
@@ -137,6 +143,11 @@ examples/inference/01_prediction.py
 examples/inference/02_csv_prediction.py
 examples/inference/03_uncertainty_ensemble.py
 examples/inference/04_isa_interpretation.py
+examples/integration/README.md
+examples/integration/common.py
+examples/integration/run_all.py
+examples/integration/solvent_analyzer.py
+examples/integration/transfer_learning.py
 examples/training/01_basic_cpu.py
 examples/training/02_solvent.py
 examples/training/03_multitarget.py
@@ -202,6 +213,12 @@ src/TrainManager/ISATrainManager.py
 src/TrainManager/TrainManager.py
 src/TrainManager/__init__.py
 src/TrainManager/callbacks.py
+src/api/__init__.py
+src/api/command.py
+src/api/errors.py
+src/api/legacy_grid_search.py
+src/api/optimization.py
+src/api/training.py
 src/utils/PATH.py
 src/utils/__init__.py
 src/utils/argparser.py
@@ -250,6 +267,7 @@ tests/test_pyg_isa_models.py
 tests/test_pyg_mpnn_gat.py
 tests/test_runtime_environment.py
 tests/test_scaler_alignment.py
+tests/test_solvent_analyzer_end_to_end.py
 tests/test_state_dict_contract.py
 tests/test_t3_checkpoint_policy.py
 tests/test_t3_data_quality.py

d4cmpp2-1.0.0/D4CMPP2.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+d4cmpp2 = D4CMPP2.src.api.command:main

{d4cmpp2-0.4.0 → d4cmpp2-1.0.0}/MANIFEST.in

@@ -8,3 +8,4 @@ recursive-include examples/inference *.py
 recursive-include examples/experiments *.py
 recursive-include examples/extensions *.py
 recursive-include examples/cli *.md
+recursive-include examples/integration *.py *.md

{d4cmpp2-0.4.0 → d4cmpp2-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: D4CMPP2
-Version: 0.4.0
+Version: 1.0.0
 Summary: PyTorch Geometric molecular property prediction models
 License-Expression: MIT
 Requires-Python: <3.13,>=3.10
@@ -25,9 +25,24 @@ Dynamic: license-file
 
 # D4CMPP2
 
-D4CMPP2 is a PyTorch Geometric package for molecular-property regression. It
-supports ordinary molecular graphs, compound/solvent pairs, and interpretable
-ISA models through one training and inference API.
+D4CMPP2 is the next-generation implementation of the D4CMPP framework. It is based on the original [D4CMPP](https://github.com/ACCA-KU/DeepMPP) project and was extensively redeveloped with OpenAI Codex through an AI-assisted, test-driven engineering workflow.
+
+The package provides a unified PyTorch Geometric framework for molecular property prediction, supporting ordinary molecular graphs, compound–solvent pairs, and interpretable ISA models.
+
+Key advantages of D4CMPP2 include:
+
+- **Unified model interface** — Train general molecular, solvent-aware, and ISA-based models through a consistent Python API and command-line interface.
+- **Multiple graph neural network architectures** — Use GCN, MPNN, DMPNN, AttentiveFP, GAT, graph-contribution, and ISA model families within the same workflow.
+- **Interpretable molecular predictions** — Analyze fragment- and atom-level contributions with ISA models while preserving alignment between molecular structures and attribution scores.
+- **Reliable data handling** — Detect invalid SMILES, missing columns, non-numeric targets, misaligned inputs, incompatible graph caches, and invalid dataset splits before they silently affect training.
+- **Efficient repeated experiments** — Reuse fingerprinted graph caches and optionally skip previously completed data-quality and per-graph cache checks.
+- **Transfer learning and training resumption** — Initialize compatible model parameters from existing models or resume complete optimizer and scheduler states from checkpoints.
+- **Reproducible experimentation** — Control random seeds, deterministic execution, dataset splitting, and run metadata across CPU and CUDA environments.
+- **Multi-target and multi-input support** — Train on multiple target properties, compound–solvent pairs, and additional numeric features without changing the overall workflow.
+- **Saved-model analysis** — Reload trained models through `Analyzer` for single or batch prediction while retaining invalid and duplicate input rows.
+- **Experiment tracking and optimization** — Record run manifests, compare completed experiments, and perform grid or Bayesian hyperparameter optimization.
+- **Backward compatibility** — Preserve established D4CMPP APIs, model assets, configuration conventions, and legacy loading paths where practical.
+- **Deployment-oriented validation** — Test source execution, packaged distributions, CLI entry points, model persistence, Analyzer workflows, and CPU-based end-to-end training.
 
 ## Requirements and installation
 
@@ -240,6 +255,32 @@ The cache policies are:
 
 DGL caches are preserved but never loaded.
 
+Data preparation reports when CSV validation and graph-cache loading start and
+finish, so a large cache no longer looks stalled before graph generation. Full
+per-graph tensor validation remains the default. After a cache has already been
+verified and the same data is trained repeatedly, it can be skipped explicitly:
+
+```python
+train(
+    data="data.csv",
+    target=["target"],
+    network="GCN",
+    data_quality_report=False,
+    validate_graph_cache=False,
+)
+```
+
+`data_quality_report=False` skips the slower canonical-SMILES duplicate,
+split-overlap, and issue report after that dataset has already been reviewed.
+Required CSV columns, numeric values, split labels, row alignment, and nonempty
+targets are still checked. `validate_graph_cache=False` still checks the cache
+recipe, ordered SMILES, and graph count; it only skips tensor shape, dtype,
+finite-value, and edge-alignment checks inside each cached graph. Newly generated
+graphs are always validated before saving.
+
+The CLI equivalents are `--skip-data-quality-report` and
+`--skip-graph-cache-validation`.
+
 ## Prediction and analysis
 
 ```python

{d4cmpp2-0.4.0 → d4cmpp2-1.0.0}/README.md

@@ -1,8 +1,23 @@
 # D4CMPP2
 
-D4CMPP2 is a PyTorch Geometric package for molecular-property regression. It
-supports ordinary molecular graphs, compound/solvent pairs, and interpretable
-ISA models through one training and inference API.
+D4CMPP2 is the next-generation implementation of the D4CMPP framework. It is based on the original [D4CMPP](https://github.com/ACCA-KU/DeepMPP) project and was extensively redeveloped with OpenAI Codex through an AI-assisted, test-driven engineering workflow.
+
+The package provides a unified PyTorch Geometric framework for molecular property prediction, supporting ordinary molecular graphs, compound–solvent pairs, and interpretable ISA models.
+
+Key advantages of D4CMPP2 include:
+
+- **Unified model interface** — Train general molecular, solvent-aware, and ISA-based models through a consistent Python API and command-line interface.
+- **Multiple graph neural network architectures** — Use GCN, MPNN, DMPNN, AttentiveFP, GAT, graph-contribution, and ISA model families within the same workflow.
+- **Interpretable molecular predictions** — Analyze fragment- and atom-level contributions with ISA models while preserving alignment between molecular structures and attribution scores.
+- **Reliable data handling** — Detect invalid SMILES, missing columns, non-numeric targets, misaligned inputs, incompatible graph caches, and invalid dataset splits before they silently affect training.
+- **Efficient repeated experiments** — Reuse fingerprinted graph caches and optionally skip previously completed data-quality and per-graph cache checks.
+- **Transfer learning and training resumption** — Initialize compatible model parameters from existing models or resume complete optimizer and scheduler states from checkpoints.
+- **Reproducible experimentation** — Control random seeds, deterministic execution, dataset splitting, and run metadata across CPU and CUDA environments.
+- **Multi-target and multi-input support** — Train on multiple target properties, compound–solvent pairs, and additional numeric features without changing the overall workflow.
+- **Saved-model analysis** — Reload trained models through `Analyzer` for single or batch prediction while retaining invalid and duplicate input rows.
+- **Experiment tracking and optimization** — Record run manifests, compare completed experiments, and perform grid or Bayesian hyperparameter optimization.
+- **Backward compatibility** — Preserve established D4CMPP APIs, model assets, configuration conventions, and legacy loading paths where practical.
+- **Deployment-oriented validation** — Test source execution, packaged distributions, CLI entry points, model persistence, Analyzer workflows, and CPU-based end-to-end training.
 
 ## Requirements and installation
 
@@ -215,6 +230,32 @@ The cache policies are:
 
 DGL caches are preserved but never loaded.
 
+Data preparation reports when CSV validation and graph-cache loading start and
+finish, so a large cache no longer looks stalled before graph generation. Full
+per-graph tensor validation remains the default. After a cache has already been
+verified and the same data is trained repeatedly, it can be skipped explicitly:
+
+```python
+train(
+    data="data.csv",
+    target=["target"],
+    network="GCN",
+    data_quality_report=False,
+    validate_graph_cache=False,
+)
+```
+
+`data_quality_report=False` skips the slower canonical-SMILES duplicate,
+split-overlap, and issue report after that dataset has already been reviewed.
+Required CSV columns, numeric values, split labels, row alignment, and nonempty
+targets are still checked. `validate_graph_cache=False` still checks the cache
+recipe, ordered SMILES, and graph count; it only skips tensor shape, dtype,
+finite-value, and edge-alignment checks inside each cached graph. Newly generated
+graphs are always validated before saving.
+
+The CLI equivalents are `--skip-data-quality-report` and
+`--skip-graph-cache-validation`.
+
 ## Prediction and analysis
 
 ```python

{d4cmpp2-0.4.0 → d4cmpp2-1.0.0}/__init__.py

@@ -1,8 +1,8 @@
-__version__ = "0.4.0"
-
-from D4CMPP2._main import train as train
-from D4CMPP2.grid_search import grid_search as grid_search
-from D4CMPP2.optimize import optimize as optimize
+__version__ = "1.0.0"
+
+from D4CMPP2.src.api.training import train as train
+from D4CMPP2.src.api.legacy_grid_search import grid_search as grid_search
+from D4CMPP2.src.api.optimization import optimize as optimize
 from D4CMPP2.src.utils.leaderboard import compare_experiments as compare_experiments
 from D4CMPP2.src.Analyzer import Analyzer as Analyzer
 from D4CMPP2.src.utils.sculptor import Segmentator as Segmentator
@@ -13,4 +13,4 @@ from D4CMPP2.networks import (
     MolecularNetwork as MolecularNetwork,
     register_network as register_network,
 )
-
+

d4cmpp2-1.0.0/__main__.py

@@ -0,0 +1,5 @@
+from D4CMPP2.src.api.command import main
+
+
+if __name__ == "__main__":
+    main()

d4cmpp2-1.0.0/_main.py

@@ -0,0 +1,7 @@
+"""Compatibility alias for :mod:`D4CMPP2.src.api.training`."""
+
+from importlib import import_module as _import_module
+import sys as _sys
+
+
+_sys.modules[__name__] = _import_module("D4CMPP2.src.api.training")

d4cmpp2-1.0.0/cli.py

@@ -0,0 +1,7 @@
+"""Compatibility alias for :mod:`D4CMPP2.src.api.command`."""
+
+from importlib import import_module as _import_module
+import sys as _sys
+
+
+_sys.modules[__name__] = _import_module("D4CMPP2.src.api.command")

{d4cmpp2-0.4.0 → d4cmpp2-1.0.0}/examples/AGENTS.md

@@ -27,3 +27,7 @@ fixture를 제공한다.
 - 2026-07-20: 학습, 모델 변형, 저장 모델 모드, inference, 불확실성, ISA 해석,
   실험 비교·최적화, callback, custom network 및 CLI를 기능별 Python 예제로
   분리하고 `examples/README.md`에 실행 비용과 산출물 경계를 기록했다.
+- 2026-07-21: `integration/`에 solvent 5종 train-save-Analyzer와
+  general/solvent/ISA transfer-save-Analyzer public workflow를 추가했다.
+  `run_all.py`는 각 workflow를 임시 cwd subprocess로 격리하고 선택적 artifact
+  보존, 실행 시간 요약과 실패 exit status를 제공한다.

{d4cmpp2-0.4.0 → d4cmpp2-1.0.0}/examples/README.md

@@ -43,6 +43,7 @@ target 이름을 자신의 데이터에 맞게 바꾼다.
 | callback | `extensions/01_callbacks.py` | 학습 loop를 바꾸지 않는 관찰자 |
 | custom network | `custom_network.py`, `extensions/02_custom_network_training.py` | 등록·학습·재로딩 가능한 사용자 모델 |
 | numeric input | `extensions/03_numeric_inputs.py` | named numeric batch key와 predefined split |
+| heavy 통합 실행 | `integration/run_all.py` | solvent Analyzer와 계열별 transfer를 실제 학습·저장·재로딩으로 일괄 검증 |
 | CLI | `cli/README.md` | 설치, 학습, resume/load/transfer 명령 |
 | ISA segmentation | `ISA/segment.py` | 학습 전 fragmentation 규칙 확인 |
 
@@ -79,3 +80,24 @@ target 이름을 자신의 데이터에 맞게 바꾼다.
 ISA 학습, scaffold split, grid search와 Bayesian optimization은 데이터 크기와
 trial 수에 따라 오래 걸린다. 최적화 예제의 기본 trial/grid는 설명을 위해 작게
 설정했지만 각 trial은 완전한 학습·저장 작업이다.
+
+## Heavy integration runner
+
+단위 테스트가 manager, 저장, Analyzer 경계를 우회하는 문제를 막기 위해 실제
+public API만 사용하는 무거운 workflow는 `integration/`에 둔다. 다음 한 명령은
+각 workflow를 별도 subprocess와 임시 작업 폴더에서 실행하고 성공/실패 및
+소요 시간을 요약한다. 기본 산출물은 종료 시 자동 제거된다.
+
+```sh
+python examples/integration/run_all.py
+```
+
+모델, `transfer_report.json`, manifest를 직접 확인하려면 보존 경로를 지정한다.
+
+```sh
+python examples/integration/run_all.py --keep-output integration-output
+```
+
+세부 workflow와 선택 실행 방법은 `integration/README.md`를 참고한다.
+개별 실행 파일은 `integration/solvent_analyzer.py`와
+`integration/transfer_learning.py`다.

d4cmpp2-1.0.0/examples/integration/README.md

@@ -0,0 +1,34 @@
+# Heavy integration examples
+
+These examples execute real public workflows rather than mocking training or
+calling networks directly. They are intentionally excluded from the fast test
+layer because they train and reload multiple models on CPU.
+
+Run everything with self-cleaning temporary outputs:
+
+```sh
+python examples/integration/run_all.py
+```
+
+Keep generated models, transfer reports, and manifests for inspection:
+
+```sh
+python examples/integration/run_all.py --keep-output integration-output
+```
+
+Run one workflow:
+
+```sh
+python examples/integration/run_all.py --only transfer-learning
+```
+
+The workflows are:
+
+- `solvent-analyzer`: all five solvent models, from one-epoch public training
+  through saved artifacts and row-preserving Analyzer prediction.
+- `transfer-learning`: representative GCN, GCNwS, and ISAT source/target runs;
+  compatible backbone loading, resized-head reporting, saved-model reload, and
+  Analyzer prediction.
+
+The data is generated locally, no download is performed, and CPU is used by
+default. The command exits nonzero if any workflow fails.

d4cmpp2-1.0.0/examples/integration/common.py

@@ -0,0 +1,93 @@
+"""Shared helpers for isolated public-API integration examples."""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import sys
+import tempfile
+from pathlib import Path
+
+
+PACKAGE_ROOT = Path(__file__).resolve().parents[2]
+if str(PACKAGE_ROOT.parent) not in sys.path:
+    sys.path.insert(0, str(PACKAGE_ROOT.parent))
+
+
+@contextlib.contextmanager
+def workflow_workspace(name: str, output_root: str | None):
+    """Run in an explicit output folder or a self-cleaning temporary folder."""
+
+    original = Path.cwd()
+    if output_root is None:
+        with tempfile.TemporaryDirectory(prefix=f"d4cmpp2-{name}-") as temporary:
+            root = Path(temporary).resolve()
+            os.chdir(root)
+            try:
+                yield root
+            finally:
+                os.chdir(original)
+        return
+
+    root = Path(output_root).resolve()
+    root.mkdir(parents=True, exist_ok=True)
+    os.chdir(root)
+    try:
+        yield root
+    finally:
+        os.chdir(original)
+
+
+def write_tiny_dataset(root: Path) -> Path:
+    """Write one small predefined-split dataset shared by all workflows."""
+
+    path = root / "tiny_integration.csv"
+    path.write_text(
+        "\n".join(
+            (
+                "compound,solvent,target_a,target_b,set",
+                "CC,O,1.0,12.0,train",
+                "CCC,CO,2.0,11.0,train",
+                "CCO,O,3.0,10.0,train",
+                "CCN,CO,4.0,9.0,train",
+                "c1ccccc1,O,5.0,8.0,train",
+                "CCCl,CCO,6.0,7.0,train",
+                "CCBr,O,7.0,6.0,train",
+                "CC(=O)O,CO,8.0,5.0,train",
+                "C1CCCCC1,O,9.0,4.0,val",
+                "COC,CCO,10.0,3.0,val",
+                "CN,O,11.0,2.0,test",
+                "CC(C)O,CO,12.0,1.0,test",
+            )
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+    return path
+
+
+def base_train_kwargs(root: Path, data_path: Path) -> dict:
+    """Return small deterministic settings while using only public train options."""
+
+    model_dir = root / "models"
+    graph_dir = root / "graphs"
+    model_dir.mkdir(exist_ok=True)
+    graph_dir.mkdir(exist_ok=True)
+    return {
+        "data": str(data_path),
+        "device": "cpu",
+        "max_epoch": 1,
+        "batch_size": 4,
+        "hidden_dim": 8,
+        "conv_layers": 1,
+        "linear_layers": 1,
+        "dropout": 0.0,
+        "random_seed": 42,
+        "num_workers": 0,
+        "MODEL_DIR": str(model_dir),
+        "GRAPH_DIR": str(graph_dir),
+        "NET_DIR": str(PACKAGE_ROOT / "networks"),
+        "NET_REFER": str(PACKAGE_ROOT / "network_refer.yaml"),
+        "save_prediction": False,
+        "verbose": False,
+    }

d4cmpp2-1.0.0/examples/integration/run_all.py

@@ -0,0 +1,84 @@
+"""Run every heavy integration example in an isolated subprocess."""
+
+from __future__ import annotations
+
+import argparse
+import subprocess
+import sys
+import tempfile
+import time
+from pathlib import Path
+
+
+HERE = Path(__file__).resolve().parent
+WORKFLOWS = (
+    ("solvent-analyzer", HERE / "solvent_analyzer.py"),
+    ("transfer-learning", HERE / "transfer_learning.py"),
+)
+
+
+def run_all(base: Path, selected: set[str]) -> int:
+    """Run selected workflows and return a process-compatible status code."""
+
+    summary = []
+    for name, script in WORKFLOWS:
+        if selected and name not in selected:
+            continue
+        output_root = base / name
+        working_directory = base / f".{name}-cwd"
+        output_root.mkdir(parents=True, exist_ok=True)
+        working_directory.mkdir(parents=True, exist_ok=True)
+        command = [
+            sys.executable,
+            str(script),
+            "--output-root",
+            str(output_root),
+        ]
+        print(f"\n=== Running {name} ===", flush=True)
+        started = time.monotonic()
+        completed = subprocess.run(command, cwd=working_directory, check=False)
+        elapsed = time.monotonic() - started
+        summary.append((name, completed.returncode, elapsed, output_root))
+
+    print("\n=== Integration summary ===")
+    for name, returncode, elapsed, output_root in summary:
+        status = "PASS" if returncode == 0 else "FAIL"
+        print(f"{status:4} {name:20} {elapsed:7.2f}s  {output_root}")
+    failures = [name for name, returncode, _, _ in summary if returncode != 0]
+    if failures:
+        print(f"Failed workflows: {failures}", file=sys.stderr)
+        return 1
+    return 0
+
+
+def main() -> None:
+    names = {name for name, _ in WORKFLOWS}
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--only",
+        action="append",
+        choices=sorted(names),
+        default=[],
+        help="Run only this workflow; repeat the option to select more than one.",
+    )
+    parser.add_argument(
+        "--keep-output",
+        type=Path,
+        help="Keep generated models and reports under this directory.",
+    )
+    args = parser.parse_args()
+
+    if args.keep_output is not None:
+        base = args.keep_output.resolve()
+        base.mkdir(parents=True, exist_ok=True)
+        raise SystemExit(run_all(base, set(args.only)))
+
+    with tempfile.TemporaryDirectory(prefix="d4cmpp2-integration-") as temporary:
+        base = Path(temporary).resolve()
+        status = run_all(base, set(args.only))
+        print(f"Temporary outputs removed from {base}")
+        raise SystemExit(status)
+
+
+if __name__ == "__main__":
+    main()

d4cmpp2-1.0.0/examples/integration/solvent_analyzer.py

@@ -0,0 +1,85 @@
+"""Train, save, reload, and predict with every solvent-aware model.
+
+Run directly with temporary outputs::
+
+    python examples/integration/solvent_analyzer.py
+
+Keep artifacts for inspection::
+
+    python examples/integration/solvent_analyzer.py --output-root integration-output/solvent
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+
+from common import base_train_kwargs, workflow_workspace, write_tiny_dataset
+
+
+NETWORK_IDS = ("GCNwS", "MPNNwS", "DMPNNwS", "AFPwS", "GATwS")
+
+
+def run(output_root: str | None = None) -> dict:
+    """Execute the five-model public train-to-Analyzer workflow."""
+
+    from D4CMPP2 import Analyzer, train
+    from rdkit import rdBase
+
+    results = {}
+    with workflow_workspace("solvent-analyzer", output_root) as root:
+        data_path = write_tiny_dataset(root)
+        common = base_train_kwargs(root, data_path)
+        for network_id in NETWORK_IDS:
+            model_path = root / f"saved-{network_id}"
+            trained_path = train(
+                **common,
+                network=network_id,
+                target=["target_a"],
+                molecule_columns=["compound", "solvent"],
+                MODEL_PATH=str(model_path),
+            )
+            required = ("network.py", "config.yaml", "final.pth", "scaler.pkl")
+            missing = [name for name in required if not (model_path / name).is_file()]
+            if missing:
+                raise RuntimeError(
+                    f"{network_id} completed training but is missing artifacts {missing}."
+                )
+            analyzer = Analyzer(trained_path, save_result=False, device="cpu")
+            # Invalid input is intentional here. Keep the Analyzer's structured
+            # error result while suppressing RDKit's expected parser diagnostics.
+            with rdBase.BlockLogs():
+                rows = analyzer.predict_rows(
+                    compound=["CC", "CC", "not-a-smiles"],
+                    solvent=["O", "O", "O"],
+                )
+            statuses = [row.status for row in rows]
+            if statuses != ["ok", "ok", "invalid"]:
+                raise RuntimeError(
+                    f"{network_id} returned unexpected row statuses {statuses}."
+                )
+            first = float(rows[0].prediction[0])
+            duplicate = float(rows[1].prediction[0])
+            if not math.isfinite(first) or abs(first - duplicate) > 1e-6:
+                raise RuntimeError(
+                    f"{network_id} returned inconsistent duplicate predictions "
+                    f"{first} and {duplicate}."
+                )
+            results[network_id] = {
+                "model_path": str(model_path),
+                "prediction": first,
+                "invalid_error": rows[2].error,
+            }
+    return results
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output-root")
+    args = parser.parse_args()
+    print(json.dumps(run(args.output_root), indent=2, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()