workbench 0.8.415__tar.gz → 0.8.421__tar.gz

workbench-0.8.421/Makefile

@@ -0,0 +1,34 @@
+.PHONY: help clean clean-pyc clean-build list
+
+# Prune virtualenv and git internals so cleans never touch installed packages
+PRUNE := \( -path ./.venv -o -path ./.git \) -prune -o
+
+help:
+	@echo "clean - remove ALL build/python/misc artifacts"
+	@echo "clean-build - remove build artifacts"
+	@echo "clean-pyc - remove Python Complied file artifacts"
+	@echo "clean-misc - remove misc artifacts"
+
+clean: clean-build clean-pyc clean-misc
+
+clean-build:
+	find . $(PRUNE) -name 'build' -exec rm -rf {} +
+	find . $(PRUNE) -name '_build' -exec rm -rf {} +
+	find . $(PRUNE) -name 'dist' -exec rm -rf {} +
+	find . $(PRUNE) -name '*.egg-info' -exec rm -rf {} +
+	find . $(PRUNE) -name '*.eggs' -exec rm -rf {} +
+	find . $(PRUNE) -name '*.tar.gz' -exec rm -rf {} +
+	find . $(PRUNE) -name '.tox' -exec rm -rf {} +
+	find . $(PRUNE) -name '.coverage' -exec rm -rf {} +
+	find . $(PRUNE) -name '.cache' -exec rm -rf {} +
+	find . $(PRUNE) -name '__pycache__' -exec rm -rf {} +
+	find . $(PRUNE) -name 'cdk.out' -exec rm -rf {} +
+
+clean-pyc:
+	find . $(PRUNE) -name '*.pyc' -exec rm -rf {} +
+	find . $(PRUNE) -name '*.pyo' -exec rm -rf {} +
+	find . $(PRUNE) -name '*~' -exec rm -rf {} +
+
+clean-misc:
+	find . $(PRUNE) -name '.ipynb_checkpoints' -exec rm -rf {} +
+

{workbench-0.8.415 → workbench-0.8.421}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workbench
-Version: 0.8.415
+Version: 0.8.421
 Summary: Workbench: A Dashboard and Python API for creating and deploying AWS SageMaker Model Pipelines
 Author-email: SuperCowPowers LLC <support@supercowpowers.com>
 License: MIT License
@@ -71,6 +71,7 @@ Provides-Extra: training
 Requires-Dist: ray[tune]; extra == "training"
 Requires-Dist: optuna; extra == "training"
 Provides-Extra: dev
+Requires-Dist: tox; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-sugar; extra == "dev"
 Requires-Dist: pytest-xdist; extra == "dev"

{workbench-0.8.415 → workbench-0.8.421}/applications/aws_dashboard/Dockerfile

@@ -29,7 +29,7 @@ RUN --mount=type=cache,target=/root/.cache/uv \
         -r /tmp/requirements.lock
 
 # Layer 2: Workbench only (changes often, ~20 MB)
-ARG WORKBENCH_VERSION=0.8.414
+ARG WORKBENCH_VERSION=0.8.420
 RUN pip install --no-deps "workbench==${WORKBENCH_VERSION}"
 
 # Copy app code and configuration (after pip installs to avoid cache invalidation)

{workbench-0.8.415 → workbench-0.8.421}/ci/endpoint_import_smoke.py

@@ -46,6 +46,7 @@ PYPROJECT = REPO_ROOT / "pyproject.toml"
 _FRAMEWORK_SPECIFIC = {
     "workbench.endpoints.pytorch_utils": {"torch"},
     "workbench.endpoints.chemprop_shap_utils": {"torch", "chemprop"},
+    "workbench.endpoints.chemprop_utils": {"chemprop"},
 }
 
 # Extras that don't ship to any container at runtime and aren't relevant to

workbench-0.8.421/docs/admin/pypi_release.md

@@ -0,0 +1,117 @@
+# PyPI Release Notes
+
+Releases normally happen automatically: pushing a `v*` tag triggers the
+`.github/workflows/publish.yml` GitHub Action, which lints, builds,
+publishes to PyPI via trusted publishing (OIDC), and creates a GitHub Release. These
+notes cover doing the same thing **manually from a laptop** when the Action is
+unavailable or you need to bypass it.
+
+For full details on packaging see the
+[Packaging tutorial](https://packaging.python.org/tutorials/packaging-projects/#packaging-your-project).
+
+> **Heads up — the tag triggers the Action.** `git push --tags` is what fires
+> `publish.yml`. If the tag is already pushed, the Action is already publishing that
+> version, so don't also publish manually — you'll just get a "file already exists" 400
+> from PyPI. Do a manual release either (a) as a **fallback** after the Action failed on
+> an already-pushed tag, or (b) as a **full bypass** where you build and upload *before*
+> pushing the tag.
+
+### Package Requirements
+
+```bash
+pip install --upgrade build twine tox
+```
+
+### How the version is set
+
+The version is derived from the git tag by `setuptools_scm` (see `[tool.setuptools_scm]`
+in `pyproject.toml`) — there is no hardcoded version string. The build must run from a
+**tagged commit**, otherwise you get a `.devN` version instead of the clean release
+version.
+
+### Set up ~/.pypirc
+
+The Action uses OIDC trusted publishing and needs no token. A manual upload from your
+laptop still needs an API token. Put it in `~/.pypirc`:
+
+```ini
+[distutils]
+index-servers =
+  pypi
+  testpypi
+
+[pypi]
+username = __token__
+password = pypi-AgEIcH...
+
+[testpypi]
+username = __token__
+password = pypi-AgENdG...
+```
+
+### Lint (matches the Action's gate)
+
+The Action publishes only if lint passes, so run the same checks locally first:
+
+```bash
+black --check --line-length=120 src/workbench applications tests
+flake8 --exclude '*generated*' src/workbench applications tests
+```
+
+Optionally run the full test suite via tox, which installs the built package into a clean
+virtualenv and runs the tests against it:
+
+```bash
+tox
+```
+
+### Clean previous distribution files
+
+```bash
+make clean
+```
+
+### Tag the new version
+
+```bash
+git tag v0.1.8   # or whatever the next version is
+```
+
+Push the tag **now** only if you want the GitHub Action to do the release. For a manual
+bypass, hold off on pushing until after the upload (see the last step).
+
+### Build
+
+`setuptools_scm` reads the version from the tag you just created.
+
+```bash
+python -m build
+```
+
+### (Optional) Test PyPI dry run
+
+```bash
+twine upload dist/* -r testpypi
+pip install --index-url https://test.pypi.org/simple workbench
+```
+
+### Publish to PyPI
+
+```bash
+twine upload dist/* -r pypi
+```
+
+### Push the tag and any changes
+
+```bash
+git push
+git push --tags
+```
+
+If you published manually as a **full bypass**, pushing the tag here will still trigger
+the Action. It will fail at the PyPI upload step (version already exists) but will still
+create the GitHub Release — or create that release yourself:
+
+```bash
+gh release create v0.1.8 dist/* --title v0.1.8 --generate-notes
+```

{workbench-0.8.415 → workbench-0.8.421}/docs/aws_setup/bedrock_security.md

@@ -28,14 +28,14 @@ The common alternative — an agent calling a vendor-hosted model API — moves
 several controls outside your account. This table is the concrete difference,
 stated so you can check each row against your own requirements.
 
-| | Vendor-hosted model API | Bedrock |
+| Control | Vendor-hosted model API | Bedrock |
 |---|---|---|
-| Account boundary | Vendor's | Yours |
-| Credential | Shared API key in a config file | Your existing IAM role |
-| Attribution | One key for the whole team | Per-user, via `sts:AssumeRole` |
-| Revocation | Rotate a key everyone shares | Remove a role assignment |
-| Audit trail | Vendor's dashboard | Your CloudTrail |
-| Egress | Public internet to a third party | AWS network, in your region |
+| **Account boundary** | ✗ Vendor's | ✓ Yours |
+| **Credential** | ✗ Shared API key in a config file | ✓ Your existing IAM role |
+| **Attribution** | ✗ One key for the whole team | ✓ Per-user, via `sts:AssumeRole` |
+| **Revocation** | ✗ Rotate a key everyone shares | ✓ Remove a role assignment |
+| **Audit trail** | ✗ Vendor's dashboard | ✓ Your CloudTrail |
+| **Egress** | ✗ Public internet to a third party | ✓ AWS network, in your region |
 
 The credential row is the one that matters most in practice. A public API key
 is a long-lived secret that has to live on every analyst's laptop, grants the
@@ -46,18 +46,13 @@ revokes their model access at the same time.
 
 ## Where the model actually runs
 
-A Bedrock foundation model does not run in your account, and it does not run on
-Anthropic's servers either.
-
 Anthropic supplies the model weights and inference software to AWS. AWS deploys
 a copy into an AWS-owned account operated by the Bedrock service team, in the
 region you call. Anthropic has no access to that account — no network path, no
 credentials, no logs.
 
 !!! note "The practical consequence"
-    Your prompts are never handled by the model vendor's infrastructure. This
-    is a structural property of how Bedrock is built, not a promise about
-    conduct.
+    Your prompts are never handled by the model provider's infrastructure. This is a structural property of how AWS Bedrock is managed. The model provider cannot see your data, and you do not have to trust them to keep it private.
 
 ## What the agent can do
 
@@ -91,7 +86,7 @@ Under the AWS service terms for third-party models on Bedrock, you retain all
 rights to your inputs, you own the outputs, and the model provider may not
 train on them.
 
-Bedrock runs a zero operator access model: no AWS operator can read your
+Bedrock enforces a **zero-operator-access** model: no AWS operator can read your
 inputs or outputs. Under the default retention setting AWS may retain them for
 safety and abuse prevention, but the model provider never receives them.
 

workbench-0.8.421/examples/models/chemprop.py

@@ -0,0 +1,37 @@
+"""Baseline example: a plain 5-fold Chemprop regressor on the AQSol feature set.
+
+The hyperparameter-searched counterpart is ``chemprop_hpo.py`` — this is the same
+model and feature set with the ``hpo`` block dropped, so the two are directly
+comparable (the search should match or beat this baseline). Open-ADMET multi-task /
+hybrid / classifier examples live in ``chemprop_open_admet.py``.
+"""
+
+from workbench.api import Endpoint, FeatureSet, Model, ModelFramework, ModelType
+
+# Recreate flag in case you want to recreate the artifacts
+recreate = True
+model_name = "aqsol-chemprop"
+
+# =============================================================================
+# Chemprop Regression Model (baseline for the HPO comparison)
+# =============================================================================
+if recreate or not Model(model_name).exists():
+    fs = FeatureSet("aqsol_features")
+    m = fs.to_model(
+        name=model_name,
+        model_type=ModelType.UQ_REGRESSOR,
+        model_framework=ModelFramework.CHEMPROP,
+        target_column="solubility",
+        feature_list=["smiles"],
+        description="AQSol Chemprop regressor (hand-tuned baseline)",
+        tags=["aqsol", "chemprop"],
+        hyperparameters={"uq_version": "v1"},
+    )
+    m.set_owner("BW")
+
+# Create an Endpoint for the model
+if recreate or not Endpoint(model_name).exists():
+    end = Model(model_name).to_endpoint(tags=["aqsol", "chemprop"])
+    end.set_owner("BW")
+    end.test_inference()
+    end.cross_fold_inference()

{workbench-0.8.415 → workbench-0.8.421}/examples/models/chemprop_hpo.py

@@ -28,9 +28,17 @@ if recreate or not Model(model_name).exists():
         hyperparameters={
             "uq_version": "v1",
             "hpo": {
-                "backend": "optuna",  # serial; flip to "ray" for parallel trials + ASHA on the 4 GPUs
-                "n_trials": 40,  # 5 baseline trials (pruner warmup) + 35 pruned candidates
-                "search_space": "basic",  # "basic" (architecture + dropout) | "basic+lr"
+                # "ray" + max_parallel > 1 runs trials concurrently (ASHA) and puts the job
+                # on a 4-GPU instance; "optuna" is the serial single-GPU path.
+                "backend": "ray",
+                "max_parallel": 8,  # 4 GPUs x 2 trials each (see gpus_per_trial)
+                "n_trials": 60,  # 5 baseline trials (pruner warmup) + 55 pruned candidates
+                # search_space defaults to "basic+lr" (capacity + LR schedule + batch size);
+                # pass "basic" to search architecture capacity only.
+                # The search only shortlists: its top rerank_top_k configs are then re-scored
+                # against these hyperparameters as-is, and the winner of *that* is published.
+                # So a search that finds nothing real publishes the untuned baseline.
+                "rerank_top_k": 5,
             },
         },
         # For an honest out-of-distribution objective, pass validation_ids=[...]: those

workbench-0.8.421/ml_pipelines/OpenADMET/pxr/phase1/pxr_chemprop_hpo_phase1.py

@@ -0,0 +1,61 @@
+"""PXR phase-1 model: hyperparameter-searched Chemprop on the shared FeatureSet.
+
+Same held-out setup as pxr_chemprop_phase1.py (the phase1_test rows are held out of
+training via validation_ids and captured), but the Chemprop knobs are searched rather
+than hand-picked. The search runs inside the single training job — trials are ephemeral,
+so only the winning config is published as this model.
+
+The search objective is `cv_mae` on scaffold folds of the *training* rows, forced with
+hpo["metric"]. Without that override the designated validation rows would become the
+objective, which would tune the model on Analog Set 1 and make the pxr_phase1_test
+capture optimistic — and unfair against the other phase-1 models, which never see those
+labels during fitting.
+
+Build the FeatureSet first: python ../pxr_feature_sets.py
+"""
+
+from workbench.api import FeatureSet, ModelFramework, ModelType
+
+fs_name = "openadmet_pxr_f1"
+model_name = "pxr-reg-chemprop-hpo-phase1"
+tags = ["openadmet_pxr", "chemprop", "hpo", "phase1"]
+
+fs = FeatureSet(fs_name)
+df = fs.pull_dataframe()
+phase1 = df[df["split"] == "phase1_test"]
+
+m = fs.to_model(
+    name=model_name,
+    model_type=ModelType.UQ_REGRESSOR,
+    model_framework=ModelFramework.CHEMPROP,
+    feature_list=["smiles"],
+    target_column="pec50",
+    description="PXR phase-1 pEC50 Chemprop (hyperparameter-searched; phase1_test held out of training)",
+    tags=tags,
+    hyperparameters={
+        "uq_version": "v1",
+        "hpo": {
+            # "ray" + max_parallel > 1 runs trials concurrently (ASHA) on a 4-GPU instance.
+            "backend": "ray",
+            "max_parallel": 8,  # 4 GPUs x 2 trials each
+            "n_trials": 60,
+            # Score on scaffold folds of the training rows, NOT on the held-out phase1_test
+            # rows — see the module docstring.
+            "metric": "cv_mae",
+            # search_space defaults to "basic+lr" (capacity + LR schedule + batch size).
+            # The search only shortlists: its top rerank_top_k configs are re-scored against
+            # these hyperparameters as-is, and the winner of *that* is published. So a search
+            # that finds nothing real publishes the untuned baseline.
+            "rerank_top_k": 5,
+        },
+    },
+    validation_ids=list(phase1["molecule_name"]),  # held-out validation set (not trained)
+)
+m.set_owner("open_admet_pxr")
+end = m.to_endpoint(tags=tags)
+end.set_owner("open_admet_pxr")
+end.test_inference()
+end.cross_fold_inference()
+
+# Held-out capture on the phase1_test rows (the model never trained on them)
+end.inference(phase1[["molecule_name", "smiles", "pec50"]], capture_name="pxr_phase1_hpo_test")

{workbench-0.8.415 → workbench-0.8.421}/ml_pipelines/OpenADMET/pxr/pipelines.json

@@ -8,6 +8,8 @@
        "outputs": ["model:pxr-reg-chemprop-phase1", "endpoint:pxr-reg-chemprop-phase1"]},
       {"script": "phase1/pxr_chemprop_tuned_phase1.py", "inputs": ["fs:openadmet_pxr_f1"],
        "outputs": ["model:pxr-reg-chemprop-tuned-phase1", "endpoint:pxr-reg-chemprop-tuned-phase1"]},
+      {"script": "phase1/pxr_chemprop_hpo_phase1.py", "inputs": ["fs:openadmet_pxr_f1"],
+       "outputs": ["model:pxr-reg-chemprop-hpo-phase1", "endpoint:pxr-reg-chemprop-hpo-phase1"]},
       {"script": "phase2/pxr_chemprop_phase2.py", "inputs": ["fs:openadmet_pxr_f1"],
        "outputs": ["model:pxr-reg-chemprop-phase2", "endpoint:pxr-reg-chemprop-phase2"]},
       {"script": "phase1/pxr_chemprop_chemeleon_phase1.py", "inputs": ["fs:openadmet_pxr_f1"],
@@ -29,6 +31,7 @@
                    "model:pxr-2d-3dv2-reg-pytorch-100", "endpoint:pxr-2d-3dv2-reg-pytorch-100"]},
       {"script": "workbench:models/model_promotion.py",
        "inputs": ["model:pxr-reg-chemprop-phase1", "model:pxr-reg-chemprop-tuned-phase1",
+                  "model:pxr-reg-chemprop-hpo-phase1",
                   "model:pxr-reg-chemprop-phase2", "model:pxr-reg-chemprop-chemeleon-phase1-frz0",
                   "model:pxr-reg-chemprop-chemeleon-phase1-frz10", "model:pxr-reg-chemprop-chemeleon-phase1-frz20",
                   "model:pxr-reg-chemprop-mt-logp", "model:pxr-reg-chemprop-mt-logd",

{workbench-0.8.415 → workbench-0.8.421}/pyproject.toml

@@ -92,7 +92,7 @@ training = [
     "ray[tune]",
     "optuna",
 ]
-dev = ["pytest", "pytest-sugar", "pytest-xdist", "coverage", "pytest-cov", "flake8", "black", "aws-cdk-lib"]
+dev = ["tox", "pytest", "pytest-sugar", "pytest-xdist", "coverage", "pytest-cov", "flake8", "black", "aws-cdk-lib"]
 # Docs toolchain (mkdocs site + mkdocstrings API reference). Kept in sync with .github/workflows/deploy-docs.yml
 docs = [
     # Cap mkdocs/material below 2.0/10 — MkDocs 2.0 is a breaking rewrite that Material 10 will require

{workbench-0.8.415 → workbench-0.8.421}/sagemaker_images/base/inference/Dockerfile

@@ -36,7 +36,7 @@ COPY --from=builder /usr/local/bin /usr/local/bin
 # workbench-bridges==0.2.10 retained for backward compat with existing
 # deployed-endpoint model bundles; drop in a future image rev once no
 # production endpoint references workbench_bridges.
-ARG WORKBENCH_VERSION=0.8.414
+ARG WORKBENCH_VERSION=0.8.420
 RUN pip install --no-deps "workbench==${WORKBENCH_VERSION}" && \
     pip install --no-deps "workbench-bridges==0.2.10"
 

{workbench-0.8.415 → workbench-0.8.421}/sagemaker_images/base/training/Dockerfile

@@ -35,6 +35,6 @@ COPY --from=builder /usr/local/bin /usr/local/bin
 # workbench-bridges==0.2.10 is retained for backward compatibility with
 # existing deployed-endpoint model bundles; drop in a future image rev once
 # no production endpoint references workbench_bridges.
-ARG WORKBENCH_VERSION=0.8.414
+ARG WORKBENCH_VERSION=0.8.420
 RUN pip install --no-deps "workbench==${WORKBENCH_VERSION}" && \
     pip install --no-deps "workbench-bridges==0.2.10"

{workbench-0.8.415 → workbench-0.8.421}/sagemaker_images/ml_pipelines/Dockerfile

@@ -48,7 +48,7 @@ COPY --from=builder /usr/local/bin /usr/local/bin
 # Layer 2: Workbench + Bridges (changes often, small layer)
 # workbench-bridges==0.2.10 pinned for reproducibility while we still depend
 # on it; on track for deprecation once nothing references workbench_bridges.
-ARG WORKBENCH_VERSION=0.8.414
+ARG WORKBENCH_VERSION=0.8.420
 RUN pip install --no-deps "workbench==${WORKBENCH_VERSION}" && \
     pip install --no-deps "workbench-bridges==0.2.10"
 

{workbench-0.8.415 → workbench-0.8.421}/sagemaker_images/pytorch_chem/inference/Dockerfile

@@ -40,7 +40,7 @@ COPY --from=builder /usr/local/bin /usr/local/bin
 # Layer 2: Workbench + bridges — rebuilds per version bump, ~20 MB delta.
 # workbench-bridges==0.2.10 retained for backward compat with existing
 # deployed-endpoint model bundles.
-ARG WORKBENCH_VERSION=0.8.414
+ARG WORKBENCH_VERSION=0.8.420
 RUN pip install --no-deps "workbench==${WORKBENCH_VERSION}" && \
     pip install --no-deps "workbench-bridges==0.2.10"
 

{workbench-0.8.415 → workbench-0.8.421}/sagemaker_images/pytorch_chem/training/Dockerfile

@@ -34,6 +34,6 @@ RUN --mount=type=cache,target=/root/.cache/uv \
 # Layer 2: Workbench + bridges — rebuilds per version bump, ~20 MB delta.
 # workbench-bridges==0.2.10 retained for backward compat with existing
 # deployed-endpoint model bundles.
-ARG WORKBENCH_VERSION=0.8.414
+ARG WORKBENCH_VERSION=0.8.420
 RUN pip install --no-deps "workbench==${WORKBENCH_VERSION}" && \
     pip install --no-deps "workbench-bridges==0.2.10"

{workbench-0.8.415 → workbench-0.8.421}/src/workbench/agent/guides/cheminformatics.md

@@ -28,13 +28,13 @@ and `dir(module)` in the REPL are the documentation. Reach for them freely.
 
 ## How Workbench computes fingerprints
 
-`chem_utils/fingerprints.py` → `compute_morgan_fingerprints(df, radius=2, n_bits=2048)`.
+`chem_utils/fingerprints.py` → `compute_morgan_fingerprints(df, radius=2, n_bits=4096)`.
 The choices that aren't obvious:
 
 - **Count, not binary.** Each bit holds how many times the substructure appears
   (clamped to 0–255), stored as a comma-separated string. Count fingerprints beat
   binary for ADMET property prediction — the citation is in the module docstring.
-- **radius=2** is ECFP4-equivalent; **2048 bits**.
+- **radius=2** is ECFP4-equivalent; **4096 bits**.
 - **Largest fragment first.** Salts/counterions are stripped
   (`rdMolStandardize.LargestFragmentChooser`) before hashing, so the fingerprint
   describes the parent, not the salt.

{workbench-0.8.415 → workbench-0.8.421}/src/workbench/agent/guides/compounds.md

@@ -36,7 +36,8 @@ SMILES string**, not a DataFrame or a Series:
 ```python
 show(df["smiles"].iloc[0])              # first compound
 show("CN1C=NC2=C1C(=O)N(C(=O)N2C)C")    # caffeine
-show(smiles, width=800, height=800)     # bigger; default is 500x500
+show(smiles, width=300, height=300)     # smaller; default is 500x500
+show(smiles, background="rgba(255, 255, 255, 0.5)")   # white/half alpha; default is dark grey
 ```
 
 To look at several, loop — but keep it to a handful, since each opens an image:

{workbench-0.8.415 → workbench-0.8.421}/src/workbench/agent/guides/proximity.md

@@ -52,7 +52,7 @@ FeatureSpaceProximity(df, id_column="id", features=[...])
 ## Neighbors of a compound in the set
 
 ```python
-nbrs = prox.neighbors(compound_id, n_neighbors=6, include_self=False)
+nbrs = prox.neighbors(compound_id, n_neighbors=6)
 ```
 
 One row per neighbor:
@@ -64,13 +64,6 @@ One row per neighbor:
 | `similarity` / `distance` | Tanimoto similarity 0–1 (FingerprintProximity) or standardized Euclidean distance (FeatureSpaceProximity) |
 | `<target>` | the neighbor's target value (may be `NaN` for a multi-task model's off-task rows) |
 
-Two gotchas:
-
-- **`include_self` defaults to `True`.** A compound is its own closest neighbor, so
-  pass `include_self=False` to get real neighbors.
-- **`n_neighbors` counts before self is dropped.** With `include_self=False`, request
-  `k + 1` to get `k` neighbors back.
-
 Don't hardcode the query id column — it's `prox.id_column`. `neighbor_id` is stable.
 
 ## Neighbors of a novel compound
@@ -89,8 +82,8 @@ with a warning rather than raising.
 ## Controlling the search
 
 ```python
-prox.neighbors(cid, min_similarity=0.5, include_self=False)   # FingerprintProximity: all >= 0.5 Tanimoto
-prox.neighbors(cid, radius=2.0, include_self=False)           # FeatureSpaceProximity: all within distance
+prox.neighbors(cid, min_similarity=0.5)   # FingerprintProximity: all >= 0.5 Tanimoto
+prox.neighbors(cid, radius=2.0)           # FeatureSpaceProximity: all within distance
 ```
 
 The threshold overrides `n_neighbors` — use it when "how many are actually close"

workbench-0.8.421/src/workbench/endpoints/chemprop_utils.py

@@ -0,0 +1,74 @@
+"""Dual-use ChemProp dataset helpers — shared by training and endpoint inference.
+
+Lives on the endpoint import surface (per the :mod:`workbench.endpoints` contract)
+because the serving ``predict_fn`` builds datapoints the same way training does.
+Top-level deps are numpy + chemprop; ``create_molecule_datapoints`` additionally needs
+rdkit at call time (imported inside the function). All three ship in the ``pytorch_chem``
+base image.
+"""
+
+import numpy as np
+
+from chemprop import data
+
+
+def safe_batch_size(dataset_len: int, batch_size: int) -> int:
+    """Compute a batch size that avoids ChemProp's drop_last behavior.
+
+    ChemProp's build_dataloader sets drop_last=True when len(dataset) % batch_size == 1
+    to avoid batch norm issues with single-sample batches. For prediction/inference this
+    drops a sample, causing misalignment with the source DataFrame. Bumping batch_size
+    by 1 in that case makes the last batch 2 samples instead of 1, avoiding both problems.
+    """
+    if dataset_len % batch_size == 1:
+        return batch_size + 1
+    return batch_size
+
+
+def find_smiles_column(columns: list[str]) -> str:
+    """Find SMILES column (case-insensitive match for 'smiles')."""
+    smiles_col = next((c for c in columns if c.lower() == "smiles"), None)
+    if smiles_col is None:
+        raise ValueError("Column list must contain a 'smiles' column (case-insensitive)")
+    return smiles_col
+
+
+def create_molecule_datapoints(
+    smiles_list: list[str],
+    targets: np.ndarray | None = None,
+    extra_descriptors: np.ndarray | None = None,
+    gt_mask: np.ndarray | None = None,
+    lt_mask: np.ndarray | None = None,
+) -> tuple[list[data.MoleculeDatapoint], list[int]]:
+    """Create ChemProp MoleculeDatapoints from SMILES strings.
+
+    gt_mask/lt_mask are per-(row, target) boolean arrays for bounded-loss training:
+    gt_mask[i, j] == True means target j on row i is right-censored (true value >= y).
+    lt_mask[i, j] == True means target j on row i is left-censored (true value <= y).
+
+    Returns the datapoints plus the indices of the SMILES RDKit could parse (rows that
+    fail to parse are dropped, so callers must align downstream arrays on these indices).
+    """
+    from rdkit import Chem
+
+    datapoints, valid_indices = [], []
+    if targets is not None:
+        targets = np.asarray(targets)
+        if targets.ndim == 1:
+            targets = np.atleast_2d(targets).T
+
+    for i, smi in enumerate(smiles_list):
+        # Guard the RDKit call: MolFromSmiles(None) raises, and blank strings parse to None.
+        if not isinstance(smi, str) or not smi.strip() or Chem.MolFromSmiles(smi) is None:
+            continue
+        y = targets[i].tolist() if targets is not None else None
+        x_d = extra_descriptors[i] if extra_descriptors is not None else None
+        kwargs = {"y": y, "x_d": x_d}
+        if gt_mask is not None:
+            kwargs["gt_mask"] = gt_mask[i]
+        if lt_mask is not None:
+            kwargs["lt_mask"] = lt_mask[i]
+        datapoints.append(data.MoleculeDatapoint.from_smi(smi, **kwargs))
+        valid_indices.append(i)
+
+    return datapoints, valid_indices