jupytermind 0.3.0

package/src/ai_chemistry_scientist/drug_likeness_rules.py

@@ -0,0 +1,84 @@
+"""Drug-likeness rule screening module (DES-ACHEM-060 / REQ-ACHEM-060)."""
+
+from __future__ import annotations
+
+from rdkit.Chem import Descriptors, rdMolDescriptors
+
+from ai_chemistry_scientist.molecular_descriptors import compute_descriptors, parse_smiles
+from ai_chemistry_scientist.validation import fail, ok, register_validator
+
+_MODULE_NAME = "drug-likeness-rules"
+
+# Named Ghose/Egan threshold constants (DES-ACHEM-060) so the fixed rule
+# boundaries are documented in one place instead of as inline magic numbers.
+GHOSE_MOLWT_MIN, GHOSE_MOLWT_MAX = 160, 480
+GHOSE_MOLLOGP_MIN, GHOSE_MOLLOGP_MAX = -0.4, 5.6
+GHOSE_MOLMR_MIN, GHOSE_MOLMR_MAX = 40, 130
+GHOSE_HEAVY_ATOM_COUNT_MIN, GHOSE_HEAVY_ATOM_COUNT_MAX = 20, 70
+EGAN_TPSA_MAX = 131.6
+EGAN_MOLLOGP_MAX = 5.88
+
+_GHOSE_CRITERIA = (
+    (
+        "MolWt",
+        lambda d, heavy_atom_count, mol_mr: GHOSE_MOLWT_MIN <= d["mol_wt"] <= GHOSE_MOLWT_MAX,
+    ),
+    (
+        "MolLogP",
+        lambda d, heavy_atom_count, mol_mr: GHOSE_MOLLOGP_MIN <= d["mol_logp"] <= GHOSE_MOLLOGP_MAX,
+    ),
+    ("MolMR", lambda d, heavy_atom_count, mol_mr: GHOSE_MOLMR_MIN <= mol_mr <= GHOSE_MOLMR_MAX),
+    (
+        "heavy_atom_count",
+        lambda d, heavy_atom_count, mol_mr: (
+            GHOSE_HEAVY_ATOM_COUNT_MIN <= heavy_atom_count <= GHOSE_HEAVY_ATOM_COUNT_MAX
+        ),
+    ),
+)
+_EGAN_CRITERIA = (
+    ("TPSA", lambda d: d["tpsa"] <= EGAN_TPSA_MAX),
+    ("MolLogP", lambda d: d["mol_logp"] <= EGAN_MOLLOGP_MAX),
+)
+
+
+# @id CODE-ACHEM-917
+# @implements REQ-ACHEM-003 REQ-ACHEM-060
+# @design DES-ACHEM-002
+def _drug_likeness_rules_validator(params: dict) -> dict:
+    if "smiles" not in params:
+        return fail("smiles", "is required")
+    if parse_smiles(params["smiles"]) is None:
+        return fail("smiles", "must parse to a valid RDKit molecule")
+    return ok()
+
+
+register_validator(_MODULE_NAME, _drug_likeness_rules_validator)
+
+
+# @id CODE-ACHEM-060
+# @implements REQ-ACHEM-060
+# @design DES-ACHEM-060
+def run_drug_likeness_rules(smiles: str) -> dict:
+    """Compute fixed-threshold Ghose and Egan rule outcomes for ``smiles``."""
+    mol = parse_smiles(smiles)
+    if mol is None:
+        raise ValueError("smiles must already be validated by the handler wrapper")
+    descriptors = compute_descriptors(mol)
+    aromatic_ring_count = int(rdMolDescriptors.CalcNumAromaticRings(mol))
+    mol_mr = float(Descriptors.MolMR(mol))
+    heavy_atom_count = int(mol.GetNumHeavyAtoms())
+
+    ghose_violations = [
+        name for name, check in _GHOSE_CRITERIA if not check(descriptors, heavy_atom_count, mol_mr)
+    ]
+    egan_violations = [name for name, check in _EGAN_CRITERIA if not check(descriptors)]
+
+    return {
+        "aromatic_ring_count": aromatic_ring_count,
+        "mol_mr": mol_mr,
+        "heavy_atom_count": heavy_atom_count,
+        "ghose_violations": ghose_violations,
+        "ghose_pass": len(ghose_violations) == 0,
+        "egan_violations": egan_violations,
+        "egan_pass": len(egan_violations) == 0,
+    }

package/src/ai_chemistry_scientist/evidence.py

@@ -0,0 +1,41 @@
+"""Run evidence recorder (DES-ACHEM-003 / REQ-ACHEM-004)."""
+
+from __future__ import annotations
+
+import copy
+from typing import Any
+
+SCHEMA_VERSION = 1
+
+
+# @id CODE-ACHEM-003
+# @implements REQ-ACHEM-004
+# @design DES-ACHEM-003
+def record_run(
+    module_name: str,
+    params: dict[str, Any],
+    result: Any,
+    *,
+    rdkit_version: str,
+    scikit_learn_version: str | None = None,
+) -> dict:
+    """Build a RunRecord with exactly `metadata`, `parameters`, `result`.
+
+    Every module's ``result`` is already JSON-safe (scalars, strings, lists,
+    and nested dicts of these), so no ndarray codec is needed here (unlike
+    `ai_materials_scientist.evidence`, ADR-0027). ``scikit_learn_version`` is
+    included in `metadata` only when supplied (the QSAR module always
+    supplies it; the other 4 modules omit it).
+    """
+    metadata: dict[str, Any] = {
+        "module": module_name,
+        "schema_version": SCHEMA_VERSION,
+        "rdkit_version": rdkit_version,
+    }
+    if scikit_learn_version is not None:
+        metadata["scikit_learn_version"] = scikit_learn_version
+    return {
+        "metadata": metadata,
+        "parameters": dict(params),
+        "result": copy.deepcopy(result),
+    }

package/src/ai_chemistry_scientist/molecular_descriptors.py

@@ -0,0 +1,97 @@
+"""Molecular descriptor calculation module (DES-ACHEM-010 / REQ-ACHEM-010)."""
+
+from __future__ import annotations
+
+from rdkit import Chem
+from rdkit.Chem import Descriptors, rdMolDescriptors
+
+from ai_chemistry_scientist.validation import (
+    fail,
+    ok,
+    register_batch_item_validator,
+    validate_batch_item,
+)
+
+_MODULE_NAME = "molecular-descriptors"
+
+#: The 7 descriptors every molecule in this skill is characterized by
+#: (REQ-ACHEM-010). Reused by the descriptor needs of DES-ACHEM-020/030.
+DESCRIPTOR_NAMES = (
+    "mol_wt",
+    "mol_logp",
+    "tpsa",
+    "num_h_donors",
+    "num_h_acceptors",
+    "num_rotatable_bonds",
+    "num_rings",
+)
+
+
+def parse_smiles(smiles: str):
+    """Parse ``smiles`` with RDKit, returning ``None`` on failure."""
+    if not isinstance(smiles, str) or not smiles:
+        return None
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        return None
+    if any(atom.GetAtomicNum() == 0 for atom in mol.GetAtoms()):
+        return None
+    return mol
+
+
+def compute_descriptors(mol) -> dict:
+    """Compute the 7 documented descriptors for an already-parsed ``mol``."""
+    return {
+        "mol_wt": float(Descriptors.MolWt(mol)),
+        "mol_logp": float(Descriptors.MolLogP(mol)),
+        "tpsa": float(Descriptors.TPSA(mol)),
+        "num_h_donors": int(Descriptors.NumHDonors(mol)),
+        "num_h_acceptors": int(Descriptors.NumHAcceptors(mol)),
+        "num_rotatable_bonds": int(Descriptors.NumRotatableBonds(mol)),
+        "num_rings": int(rdMolDescriptors.CalcNumRings(mol)),
+    }
+
+
+def _molecular_descriptors_batch_item_validator(item_params: dict) -> dict:
+    """DES-ACHEM-002 registered per-item validator for this module."""
+    if "smiles" not in item_params:
+        return fail("smiles", "is required")
+    smiles = item_params["smiles"]
+    if parse_smiles(smiles) is None:
+        return fail("smiles", "must parse to a valid RDKit molecule")
+    return ok()
+
+
+register_batch_item_validator(_MODULE_NAME, _molecular_descriptors_batch_item_validator)
+
+
+# @id CODE-ACHEM-010
+# @implements REQ-ACHEM-010 REQ-ACHEM-003
+# @design DES-ACHEM-010
+def run_molecular_descriptors(smiles_list: list[str]) -> list[dict]:
+    """Parse and compute descriptors for each SMILES, in input order.
+
+    An invalid item is reported as a per-item rejection (naming the
+    ``smiles`` parameter and the violated constraint) without aborting
+    computation of the rest of the batch (REQ-ACHEM-003's per-item
+    granularity for this module).
+    """
+    if not smiles_list:
+        return []
+    results = []
+    for smiles in smiles_list:
+        validation = validate_batch_item(_MODULE_NAME, {"smiles": smiles})
+        if not validation["ok"]:
+            results.append(
+                {
+                    "smiles": smiles,
+                    "ok": False,
+                    "parameter": validation["parameter"],
+                    "constraint": validation["constraint"],
+                }
+            )
+            continue
+        mol = parse_smiles(smiles)
+        descriptors = compute_descriptors(mol)
+        results.append({"smiles": smiles, **descriptors})
+    return results

package/src/ai_chemistry_scientist/molecular_formula_mass.py

@@ -0,0 +1,40 @@
+"""Molecular formula and exact mass module (DES-ACHEM-080 / REQ-ACHEM-080)."""
+
+from __future__ import annotations
+
+from rdkit.Chem import Descriptors, rdMolDescriptors
+
+from ai_chemistry_scientist.molecular_descriptors import parse_smiles
+from ai_chemistry_scientist.validation import fail, ok, register_validator
+
+_MODULE_NAME = "molecular-formula-mass"
+
+
+# @id CODE-ACHEM-919
+# @implements REQ-ACHEM-003 REQ-ACHEM-080
+# @design DES-ACHEM-002
+def _molecular_formula_mass_validator(params: dict) -> dict:
+    if "smiles" not in params:
+        return fail("smiles", "is required")
+    if parse_smiles(params["smiles"]) is None:
+        return fail("smiles", "must parse to a valid RDKit molecule")
+    return ok()
+
+
+register_validator(_MODULE_NAME, _molecular_formula_mass_validator)
+
+
+# @id CODE-ACHEM-080
+# @implements REQ-ACHEM-080
+# @design DES-ACHEM-080
+def run_molecular_formula_mass(smiles: str) -> dict:
+    """Compute the molecular formula and exact mass for ``smiles``."""
+    mol = parse_smiles(smiles)
+    if mol is None:
+        raise ValueError("smiles must already be validated by the handler wrapper")
+    molecular_formula = rdMolDescriptors.CalcMolFormula(mol)
+    exact_mass = float(Descriptors.ExactMolWt(mol))
+    return {
+        "molecular_formula": molecular_formula,
+        "exact_mass": exact_mass,
+    }

package/src/ai_chemistry_scientist/molecular_similarity.py

@@ -0,0 +1,78 @@
+"""Molecular similarity search module (DES-ACHEM-040 / REQ-ACHEM-040)."""
+
+from __future__ import annotations
+
+import csv
+from pathlib import Path
+
+from rdkit import DataStructs
+from rdkit.Chem import rdFingerprintGenerator
+
+from ai_chemistry_scientist.molecular_descriptors import parse_smiles
+from ai_chemistry_scientist.validation import fail, ok, register_validator
+
+_MODULE_NAME = "molecular-similarity"
+_DATA_PATH = Path(__file__).resolve().parent / "data" / "sample_molecules.csv"
+_MIN_K = 1
+_MAX_K = 20
+_MORGAN_GENERATOR = rdFingerprintGenerator.GetMorganGenerator(radius=2, fpSize=2048)
+
+_dataset_cache: list[dict] | None = None
+
+
+def _load_dataset() -> list[dict]:
+    """Load and cache the bundled 20-row dataset (module-level, read-only)."""
+    global _dataset_cache
+    if _dataset_cache is None:
+        with _DATA_PATH.open(encoding="utf-8", newline="") as handle:
+            rows = list(csv.DictReader(handle))
+        _dataset_cache = [
+            {
+                "name": row["name"],
+                "smiles": row["smiles"],
+                "fingerprint": _MORGAN_GENERATOR.GetFingerprint(parse_smiles(row["smiles"])),
+            }
+            for row in rows
+        ]
+    return _dataset_cache
+
+
+def _molecular_similarity_validator(params: dict) -> dict:
+    """DES-ACHEM-002 registered atomic validator for this module."""
+    if "query_smiles" not in params:
+        return fail("query_smiles", "is required")
+    if "k" not in params:
+        return fail("k", "is required")
+    if parse_smiles(params["query_smiles"]) is None:
+        return fail("smiles", "must parse to a valid RDKit molecule")
+    k = params["k"]
+    if not isinstance(k, int) or isinstance(k, bool) or not (_MIN_K <= k <= _MAX_K):
+        return fail("k", "must be an integer in [1, 20]")
+    return ok()
+
+
+register_validator(_MODULE_NAME, _molecular_similarity_validator)
+
+
+# @id CODE-ACHEM-040
+# @implements REQ-ACHEM-040
+# @design DES-ACHEM-040
+def run_molecular_similarity(query_smiles: str, k: int = 5) -> dict:
+    """Return the top-``k`` dataset entries by descending Tanimoto similarity.
+
+    Receives ``query_smiles``/``k`` already validated atomically by its
+    handler wrapper; performs no revalidation of its own.
+    """
+    query_mol = parse_smiles(query_smiles)
+    query_fp = _MORGAN_GENERATOR.GetFingerprint(query_mol)
+
+    scored = [
+        {
+            "name": entry["name"],
+            "similarity": DataStructs.TanimotoSimilarity(query_fp, entry["fingerprint"]),
+        }
+        for entry in _load_dataset()
+    ]
+    scored.sort(key=lambda entry: (-entry["similarity"], entry["name"]))
+
+    return {"query_smiles": query_smiles, "results": scored[:k]}

package/src/ai_chemistry_scientist/qsar_modeling.py

@@ -0,0 +1,105 @@
+"""QSAR linear-regression module (DES-ACHEM-030 / REQ-ACHEM-030)."""
+
+from __future__ import annotations
+
+import numpy as np
+from sklearn.linear_model import LinearRegression
+
+from ai_chemistry_scientist.molecular_descriptors import compute_descriptors, parse_smiles
+from ai_chemistry_scientist.validation import fail, ok, register_validator
+
+_MODULE_NAME = "qsar-modeling"
+_MIN_TRAINING_COMPOUNDS = 5
+
+
+def _design_row(descriptors: dict) -> list[float]:
+    return [1.0, descriptors["mol_wt"], descriptors["mol_logp"], descriptors["tpsa"]]
+
+
+def _qsar_modeling_validator(params: dict) -> dict:
+    """DES-ACHEM-002 registered atomic validator for this module.
+
+    Validates every training/query SMILES parses, the training set has at
+    least 5 compounds, and its augmented design matrix is full column rank
+    4. This descriptor extraction is part of validation itself, distinct
+    from the governed "model fit" computation (REQ-ACHEM-003, ADR-0030).
+    """
+    training_set = params.get("training_set")
+    query_smiles_list = params.get("query_smiles_list")
+
+    if training_set is None:
+        return fail("training_set", "is required")
+    if query_smiles_list is None:
+        return fail("query_smiles_list", "is required")
+
+    if len(training_set) < _MIN_TRAINING_COMPOUNDS:
+        return fail(
+            "training_set",
+            "must contain at least 5 compounds with a full-rank descriptor matrix",
+        )
+
+    design_matrix = []
+    for compound in training_set:
+        mol = parse_smiles(compound["smiles"])
+        if mol is None:
+            return fail("training_set", "must parse to a valid RDKit molecule")
+        design_matrix.append(_design_row(compute_descriptors(mol)))
+
+    rank = np.linalg.matrix_rank(np.array(design_matrix, dtype=np.float64))
+    if rank < 4:
+        return fail(
+            "training_set",
+            "must contain at least 5 compounds with a full-rank descriptor matrix",
+        )
+
+    for query_smiles in query_smiles_list:
+        if parse_smiles(query_smiles) is None:
+            return fail("query_smiles_list", "must parse to a valid RDKit molecule")
+
+    return ok()
+
+
+register_validator(_MODULE_NAME, _qsar_modeling_validator)
+
+
+# @id CODE-ACHEM-030
+# @implements REQ-ACHEM-030
+# @design DES-ACHEM-030
+def run_qsar_modeling(training_set: list[dict], query_smiles_list: list[str]) -> dict:
+    """Fit an OLS linear regression and predict each query's activity.
+
+    Receives ``training_set``/``query_smiles_list`` already validated
+    atomically by its handler wrapper; independently (re)computes each
+    molecule's descriptors here for the actual fit/prediction, since
+    `validate_parameters`'s boolean-shaped return carries no descriptor
+    payload to reuse (ADR-0030) — this duplication is intentional and
+    always agrees, since REQ-ACHEM-004 requires every computation to be a
+    deterministic pure function of its inputs.
+    """
+    features = []
+    activities = []
+    for compound in training_set:
+        mol = parse_smiles(compound["smiles"])
+        descriptors = compute_descriptors(mol)
+        features.append([descriptors["mol_wt"], descriptors["mol_logp"], descriptors["tpsa"]])
+        activities.append(compound["activity"])
+
+    model = LinearRegression()
+    model.fit(np.array(features, dtype=np.float64), np.array(activities, dtype=np.float64))
+
+    predictions = []
+    for query_smiles in query_smiles_list:
+        mol = parse_smiles(query_smiles)
+        descriptors = compute_descriptors(mol)
+        feature_row = np.array(
+            [[descriptors["mol_wt"], descriptors["mol_logp"], descriptors["tpsa"]]],
+            dtype=np.float64,
+        )
+        predicted_activity = float(model.predict(feature_row)[0])
+        predictions.append({"smiles": query_smiles, "predicted_activity": predicted_activity})
+
+    return {
+        "coefficients": [float(c) for c in model.coef_],
+        "intercept": float(model.intercept_),
+        "predictions": predictions,
+    }

package/src/ai_chemistry_scientist/salt_standardization.py

@@ -0,0 +1,81 @@
+"""SMILES salt removal / structure standardization module (DES-ACHEM-100 / REQ-ACHEM-100)."""
+
+from __future__ import annotations
+
+from rdkit import Chem
+
+from ai_chemistry_scientist.molecular_descriptors import parse_smiles
+from ai_chemistry_scientist.validation import fail, ok, register_validator
+
+_MODULE_NAME = "salt-removal"
+
+LIMITATION_LABEL_KEY = "salt_removal_heuristic_limitation"
+LIMITATION_LABEL_TEXT = {
+    "en": (
+        "Heuristic only: treats every disconnected fragment except the one "
+        "with the greatest heavy-atom count as removable salt/solvent; not "
+        "always chemically correct (e.g. for a genuine covalent "
+        "multi-component cocrystal)."
+    ),
+    "ja": (
+        "ヒューリスティックのみ: 最大重原子数を持つフラグメント以外のすべての"
+        "分離フラグメントを除去可能な塩・溶媒として扱うが、常に化学的に"
+        "正しいとは限らない（例: 真の共有結合性多成分共結晶の場合）。"
+    ),
+}
+
+
+# @id CODE-ACHEM-921
+# @implements REQ-ACHEM-003 REQ-ACHEM-100
+# @design DES-ACHEM-002
+def _salt_removal_validator(params: dict) -> dict:
+    """Reject a missing/unparseable/dummy-atom ``smiles`` via `parse_smiles`.
+
+    Unlike `structure_format_conversion._parse_structure`'s Molblock parser,
+    `parse_smiles` never needs an explicit zero-atom-molecule guard: RDKit's
+    SMILES parser rejects the only syntactically valid empty input (the
+    empty string) before reaching `Chem.MolFromSmiles` (the leading
+    not-`smiles` check), so every string it accepts yields at least one atom.
+
+    The required-key check runs first so a missing ``smiles`` parameter is
+    reported as a missing-parameter error rather than a parse failure.
+    """
+    if "smiles" not in params:
+        return fail("smiles", "is required")
+    if parse_smiles(params["smiles"]) is None:
+        return fail("smiles", "must parse to a valid RDKit molecule")
+    return ok()
+
+
+register_validator(_MODULE_NAME, _salt_removal_validator)
+
+
+def _fragment_sort_key(fragment) -> tuple[int, str]:
+    """`(-heavy_atom_count, canonical_smiles)` ascending (REQ-ACHEM-100/ADR-0105)."""
+    return (-fragment.GetNumHeavyAtoms(), Chem.MolToSmiles(fragment))
+
+
+# @id CODE-ACHEM-100
+# @implements REQ-ACHEM-100
+# @design DES-ACHEM-100
+def run_salt_removal(smiles: str) -> dict:
+    """Select the dominant fragment of ``smiles`` and report the rest as removed.
+
+    Fragment selection follows the fixed sort key
+    ``(-heavy_atom_count, canonical_smiles)`` (ADR-0105), not RDKit's
+    built-in ``rdMolStandardize.LargestFragmentChooser`` heuristic.
+    """
+    mol = parse_smiles(smiles)
+    if mol is None:
+        raise ValueError("smiles must already be validated by the handler wrapper")
+
+    fragments = Chem.GetMolFrags(mol, asMols=True, sanitizeFrags=False)
+    ranked = sorted(fragments, key=_fragment_sort_key)
+    ranked_smiles = [Chem.MolToSmiles(fragment) for fragment in ranked]
+
+    return {
+        "standardized_smiles": ranked_smiles[0],
+        "removed_fragments": ranked_smiles[1:],
+        "fragments_removed": len(ranked_smiles) > 1,
+        "limitation_label_key": LIMITATION_LABEL_KEY,
+    }

package/src/ai_chemistry_scientist/structural_alerts.py

@@ -0,0 +1,76 @@
+"""Structural alert screening module (DES-ACHEM-070 / REQ-ACHEM-070)."""
+
+from __future__ import annotations
+
+from rdkit import Chem
+
+from ai_chemistry_scientist.molecular_descriptors import parse_smiles
+from ai_chemistry_scientist.validation import fail, ok, register_validator
+
+_MODULE_NAME = "structural-alerts"
+ALERT_SMARTS = (
+    ("nitro_group", "[NX3](=O)=O"),
+    ("aldehyde", "[CX3H1](=O)"),
+    ("michael_acceptor_enone", "C=CC(=O)"),
+    ("epoxide", "C1OC1"),
+    ("free_thiol", "[SX2H]"),
+)
+
+
+def _compile_alert_queries():
+    compiled_queries = []
+    for name, smarts in ALERT_SMARTS:
+        query = Chem.MolFromSmarts(smarts)
+        if query is None:
+            raise ValueError(f"structural alert SMARTS for {name!r} failed to compile: {smarts}")
+        compiled_queries.append((name, query))
+    return tuple(compiled_queries)
+
+
+# Pre-compiled once at import time (the DES-ACHEM-070 fixed alert list never
+# changes at runtime), rather than re-parsing every SMARTS pattern string on
+# every call.
+_ALERT_QUERIES = _compile_alert_queries()
+LIMITATION_LABEL_KEY = "structural_alerts_heuristic_limitation"
+LIMITATION_LABEL_TEXT = {
+    "en": "Heuristic only: a small fixed illustrative SMARTS alert list, not the validated PAINS/Brenk filter catalog.",
+    "ja": (
+        "ヒューリスティックのみ: 固定の小規模な例示用SMARTSアラート一覧であり、"
+        "検証済みのPAINS/Brenkフィルタ・カタログではない。"
+    ),
+}
+
+
+# @id CODE-ACHEM-918
+# @implements REQ-ACHEM-003 REQ-ACHEM-070
+# @design DES-ACHEM-002
+def _structural_alerts_validator(params: dict) -> dict:
+    if "smiles" not in params:
+        return fail("smiles", "is required")
+    if parse_smiles(params["smiles"]) is None:
+        return fail("smiles", "must parse to a valid RDKit molecule")
+    return ok()
+
+
+register_validator(_MODULE_NAME, _structural_alerts_validator)
+
+
+# @id CODE-ACHEM-070
+# @implements REQ-ACHEM-070
+# @design DES-ACHEM-070
+def run_structural_alerts(smiles: str) -> dict:
+    """Match the fixed SMARTS alert list against ``smiles``.
+
+    ``_ALERT_QUERIES`` is guaranteed non-``None`` for every entry by
+    ``_compile_alert_queries()`` at import time (CHANGE-013 hardening), so
+    this function never needs to re-check for a malformed SMARTS query.
+    """
+    mol = parse_smiles(smiles)
+    if mol is None:
+        raise ValueError("smiles must already be validated by the handler wrapper")
+    alerts_matched = [name for name, query in _ALERT_QUERIES if mol.HasSubstructMatch(query)]
+    return {
+        "alerts_matched": alerts_matched,
+        "alert_count": len(alerts_matched),
+        "limitation_label_key": LIMITATION_LABEL_KEY,
+    }