molfp 0.2.0__tar.gz

molfp-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Chanin Nantasenamat
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

molfp-0.2.0/PKG-INFO

@@ -0,0 +1,216 @@
+Metadata-Version: 2.4
+Name: molfp
+Version: 0.2.0
+Summary: Interpretable molecular fingerprints with SHAP-driven chemical explanations
+Author: Chanin Nantasenamat
+License: MIT
+Project-URL: Homepage, https://github.com/dataprofessor/molfp
+Project-URL: Repository, https://github.com/dataprofessor/molfp
+Keywords: cheminformatics,molecular-fingerprints,drug-discovery,QSAR,RDKit,SHAP,interpretability,scikit-learn
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.22
+Requires-Dist: rdkit>=2023.03
+Requires-Dist: scikit-learn>=1.2
+Requires-Dist: scipy>=1.9
+Requires-Dist: joblib>=1.2
+Provides-Extra: shap
+Requires-Dist: shap>=0.42; extra == "shap"
+Provides-Extra: all
+Requires-Dist: shap>=0.42; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: shap>=0.42; extra == "dev"
+Dynamic: license-file
+
+# molfp
+
+**Interpretable molecular fingerprints with SHAP-driven chemical explanations.**
+
+A native Python/RDKit library that computes 13 molecular fingerprint types and provides built-in tools for interpretation, collision detection, activity cliff analysis, bioactivity profiling, and SHAP-based feature explanation — capabilities not found in any other fingerprint library.
+
+## Install
+
+```bash
+pip install molfp            # core (RDKit + scikit-learn)
+pip install molfp[shap]      # + SHAP interpretation
+pip install molfp[all]       # everything
+```
+
+## Quick Start
+
+```python
+import molfp
+
+# Compute fingerprints
+fp = molfp.maccs("CCO")                        # → list of 166 ints
+fp = molfp.ecfp4("c1ccccc1", n_bits=2048)      # → list of 2048 ints
+fps = molfp.maccs_batch(["CCO", "c1ccccc1"])    # → numpy (2, 166)
+
+# All 13 types
+molfp.available()
+# ['maccs', 'ecfp4', 'pubchem', 'substructure', 'substructure_count',
+#  'klekota_roth', 'klekota_roth_count', 'estate', 'atompairs2d',
+#  'atompairs2d_count', 'rdk', 'rdk_ext', 'rdk_graphonly']
+```
+
+## Features
+
+### 13 Fingerprint Types
+
+| Type | Bits | Function |
+|------|------|----------|
+| MACCS Keys | 166 | `molfp.maccs()` |
+| ECFP4 (Morgan r=2) | 1024 | `molfp.ecfp4()` |
+| PubChem/CACTVS | 881 | `molfp.pubchem()` |
+| SubstructureFP | 307 | `molfp.substructure()` |
+| Substructure Count | 307 | `molfp.substructure_count()` |
+| Klekota-Roth | 4860 | `molfp.klekota_roth()` |
+| Klekota-Roth Count | 4860 | `molfp.klekota_roth_count()` |
+| E-State | 79 | `molfp.estate()` |
+| AtomPairs2D | 780 | `molfp.atompairs2d()` |
+| AtomPairs2D Count | 780 | `molfp.atompairs2d_count()` |
+| RDKit path-based | 1024 | `molfp.rdk()` |
+| RDKit Extended | 1024 | `molfp.rdk_ext()` |
+| RDKit GraphOnly | 1024 | `molfp.rdk_graphonly()` |
+
+### Bit-Level Explainability
+
+Map each ON bit to the atoms/bonds that triggered it — across all 13 FP types:
+
+```python
+molfp.explain("CC(=O)Oc1ccccc1C(=O)O", "ecfp4")
+# {11: [(1, 1)], 33: [(0, 0)], 64: [(6, 1), (7, 1)], ...}
+# bit 64 → center atoms 6 and 7 at radius 1
+```
+
+### Chemical Annotation
+
+Human-readable names for every fingerprint bit:
+
+```python
+molfp.annotate("substructure", 83)
+# {'name': 'Carboxylic_acid', 'smarts': '[CX3...](=[OX1])...', 'category': 'functional_group'}
+
+molfp.annotate("pubchem", 9)
+# {'description': 'Element count: C >= 2', 'category': 'element_count'}
+```
+
+### SHAP Interpretation with Chemical Meaning
+
+One call: fingerprint → model → SHAP → chemical annotation → per-class SAR:
+
+```python
+result = molfp.interpret(smiles, activities, fp_type="maccs", metric="pchembl")
+
+# Per-class drivers with present/absent effect:
+# ACTIVE:
+#   ↑ present  methyl group (-CH3)     SHAP +0.004  (freq 23% vs 19%)
+#   ↓ present  oxygen atom             SHAP -0.003  (freq 13% vs 17%)
+```
+
+### Hash Collision Detection
+
+Detect when different substructures hash to the same bit:
+
+```python
+molfp.detect_collisions("c1ccccc1", "ecfp4", n_bits=256)
+# {63: [2360741695, 3976623167]}  → 2 hashes collided at bit 63
+
+molfp.collision_rate(smiles_list, "ecfp4", n_bits=1024)
+# {'collision_rate': 0.027, 'collided_bits': 15, ...}
+```
+
+### Activity Cliff Detection
+
+Find structurally similar molecules with large activity differences:
+
+```python
+cliffs = molfp.activity_cliffs(smiles, activities, "maccs",
+                                sim_threshold=0.8, activity_threshold=2.0)
+```
+
+### Bioactivity Class Profiling
+
+Classify molecules, analyze intra/inter-class similarity, find enriched bits:
+
+```python
+labels = molfp.classify(pchembl_values, metric="pchembl")
+result = molfp.class_similarity(smiles, labels, "maccs")
+enriched = molfp.enriched_bits(smiles, labels, "maccs")
+```
+
+### Structure Standardization
+
+Desalt, neutralize, canonicalize tautomers, deduplicate by InChIKey:
+
+```python
+molfp.standardize_smiles("CC(=O)Oc1ccccc1C(=O)[O-].[Na+]")
+# → "CC(=O)Oc1ccccc1C(=O)O"  (desalted + neutralized)
+
+result = molfp.preprocess(smiles_list)
+# n_input: 1000 → n_after_standardization: 985 → n_after_deduplication: 923
+```
+
+### Distance Functions
+
+Vectorized Tanimoto, Dice, Cosine, Sokal-Michener, Russel-Rao:
+
+```python
+molfp.tanimoto(fp_a, fp_b)           # single pair → float
+molfp.pairwise(X, metric="tanimoto") # (N, N_bits) → (N, N) matrix (vectorized)
+```
+
+### scikit-learn Compatible
+
+All 13 FP types as sklearn transformers with Pipeline, GridSearchCV, and FeatureUnion support:
+
+```python
+from sklearn.pipeline import make_pipeline
+from sklearn.ensemble import RandomForestClassifier
+
+pipe = make_pipeline(
+    molfp.ECFPTransformer(n_bits=2048, n_jobs=-1),
+    RandomForestClassifier()
+)
+pipe.fit(smiles_train, y_train)
+```
+
+### Sparse Matrix & Parallelism
+
+```python
+molfp.klekota_roth_batch(smiles, sparse=True, n_jobs=-1)
+# → scipy.sparse.csr_matrix, 97% memory savings for KR 4860-bit FPs
+```
+
+## Comparison with scikit-fingerprints (skfp)
+
+| Feature | molfp | skfp |
+|---------|-------|------|
+| Fingerprint types | 13 | 35 |
+| Bit-level explainability | All 13 FPs | None |
+| Chemical annotation | Built-in | Feature names only |
+| SHAP + chemical meaning | `interpret()` | None |
+| Hash collision detection | `detect_collisions()` | None |
+| Activity cliff detection | `activity_cliffs()` | None |
+| Bioactivity profiling | `classify()`, `enriched_bits()` | None |
+| Consensus fingerprints | `fuse()` | None |
+| Structure standardization | Full pipeline | Basic |
+| sklearn compatible | Yes | Yes |
+| Sparse + parallel | Yes | Yes |
+
+## License
+
+MIT

molfp-0.2.0/README.md

@@ -0,0 +1,179 @@
+# molfp
+
+**Interpretable molecular fingerprints with SHAP-driven chemical explanations.**
+
+A native Python/RDKit library that computes 13 molecular fingerprint types and provides built-in tools for interpretation, collision detection, activity cliff analysis, bioactivity profiling, and SHAP-based feature explanation — capabilities not found in any other fingerprint library.
+
+## Install
+
+```bash
+pip install molfp            # core (RDKit + scikit-learn)
+pip install molfp[shap]      # + SHAP interpretation
+pip install molfp[all]       # everything
+```
+
+## Quick Start
+
+```python
+import molfp
+
+# Compute fingerprints
+fp = molfp.maccs("CCO")                        # → list of 166 ints
+fp = molfp.ecfp4("c1ccccc1", n_bits=2048)      # → list of 2048 ints
+fps = molfp.maccs_batch(["CCO", "c1ccccc1"])    # → numpy (2, 166)
+
+# All 13 types
+molfp.available()
+# ['maccs', 'ecfp4', 'pubchem', 'substructure', 'substructure_count',
+#  'klekota_roth', 'klekota_roth_count', 'estate', 'atompairs2d',
+#  'atompairs2d_count', 'rdk', 'rdk_ext', 'rdk_graphonly']
+```
+
+## Features
+
+### 13 Fingerprint Types
+
+| Type | Bits | Function |
+|------|------|----------|
+| MACCS Keys | 166 | `molfp.maccs()` |
+| ECFP4 (Morgan r=2) | 1024 | `molfp.ecfp4()` |
+| PubChem/CACTVS | 881 | `molfp.pubchem()` |
+| SubstructureFP | 307 | `molfp.substructure()` |
+| Substructure Count | 307 | `molfp.substructure_count()` |
+| Klekota-Roth | 4860 | `molfp.klekota_roth()` |
+| Klekota-Roth Count | 4860 | `molfp.klekota_roth_count()` |
+| E-State | 79 | `molfp.estate()` |
+| AtomPairs2D | 780 | `molfp.atompairs2d()` |
+| AtomPairs2D Count | 780 | `molfp.atompairs2d_count()` |
+| RDKit path-based | 1024 | `molfp.rdk()` |
+| RDKit Extended | 1024 | `molfp.rdk_ext()` |
+| RDKit GraphOnly | 1024 | `molfp.rdk_graphonly()` |
+
+### Bit-Level Explainability
+
+Map each ON bit to the atoms/bonds that triggered it — across all 13 FP types:
+
+```python
+molfp.explain("CC(=O)Oc1ccccc1C(=O)O", "ecfp4")
+# {11: [(1, 1)], 33: [(0, 0)], 64: [(6, 1), (7, 1)], ...}
+# bit 64 → center atoms 6 and 7 at radius 1
+```
+
+### Chemical Annotation
+
+Human-readable names for every fingerprint bit:
+
+```python
+molfp.annotate("substructure", 83)
+# {'name': 'Carboxylic_acid', 'smarts': '[CX3...](=[OX1])...', 'category': 'functional_group'}
+
+molfp.annotate("pubchem", 9)
+# {'description': 'Element count: C >= 2', 'category': 'element_count'}
+```
+
+### SHAP Interpretation with Chemical Meaning
+
+One call: fingerprint → model → SHAP → chemical annotation → per-class SAR:
+
+```python
+result = molfp.interpret(smiles, activities, fp_type="maccs", metric="pchembl")
+
+# Per-class drivers with present/absent effect:
+# ACTIVE:
+#   ↑ present  methyl group (-CH3)     SHAP +0.004  (freq 23% vs 19%)
+#   ↓ present  oxygen atom             SHAP -0.003  (freq 13% vs 17%)
+```
+
+### Hash Collision Detection
+
+Detect when different substructures hash to the same bit:
+
+```python
+molfp.detect_collisions("c1ccccc1", "ecfp4", n_bits=256)
+# {63: [2360741695, 3976623167]}  → 2 hashes collided at bit 63
+
+molfp.collision_rate(smiles_list, "ecfp4", n_bits=1024)
+# {'collision_rate': 0.027, 'collided_bits': 15, ...}
+```
+
+### Activity Cliff Detection
+
+Find structurally similar molecules with large activity differences:
+
+```python
+cliffs = molfp.activity_cliffs(smiles, activities, "maccs",
+                                sim_threshold=0.8, activity_threshold=2.0)
+```
+
+### Bioactivity Class Profiling
+
+Classify molecules, analyze intra/inter-class similarity, find enriched bits:
+
+```python
+labels = molfp.classify(pchembl_values, metric="pchembl")
+result = molfp.class_similarity(smiles, labels, "maccs")
+enriched = molfp.enriched_bits(smiles, labels, "maccs")
+```
+
+### Structure Standardization
+
+Desalt, neutralize, canonicalize tautomers, deduplicate by InChIKey:
+
+```python
+molfp.standardize_smiles("CC(=O)Oc1ccccc1C(=O)[O-].[Na+]")
+# → "CC(=O)Oc1ccccc1C(=O)O"  (desalted + neutralized)
+
+result = molfp.preprocess(smiles_list)
+# n_input: 1000 → n_after_standardization: 985 → n_after_deduplication: 923
+```
+
+### Distance Functions
+
+Vectorized Tanimoto, Dice, Cosine, Sokal-Michener, Russel-Rao:
+
+```python
+molfp.tanimoto(fp_a, fp_b)           # single pair → float
+molfp.pairwise(X, metric="tanimoto") # (N, N_bits) → (N, N) matrix (vectorized)
+```
+
+### scikit-learn Compatible
+
+All 13 FP types as sklearn transformers with Pipeline, GridSearchCV, and FeatureUnion support:
+
+```python
+from sklearn.pipeline import make_pipeline
+from sklearn.ensemble import RandomForestClassifier
+
+pipe = make_pipeline(
+    molfp.ECFPTransformer(n_bits=2048, n_jobs=-1),
+    RandomForestClassifier()
+)
+pipe.fit(smiles_train, y_train)
+```
+
+### Sparse Matrix & Parallelism
+
+```python
+molfp.klekota_roth_batch(smiles, sparse=True, n_jobs=-1)
+# → scipy.sparse.csr_matrix, 97% memory savings for KR 4860-bit FPs
+```
+
+## Comparison with scikit-fingerprints (skfp)
+
+| Feature | molfp | skfp |
+|---------|-------|------|
+| Fingerprint types | 13 | 35 |
+| Bit-level explainability | All 13 FPs | None |
+| Chemical annotation | Built-in | Feature names only |
+| SHAP + chemical meaning | `interpret()` | None |
+| Hash collision detection | `detect_collisions()` | None |
+| Activity cliff detection | `activity_cliffs()` | None |
+| Bioactivity profiling | `classify()`, `enriched_bits()` | None |
+| Consensus fingerprints | `fuse()` | None |
+| Structure standardization | Full pipeline | Basic |
+| sklearn compatible | Yes | Yes |
+| Sparse + parallel | Yes | Yes |
+
+## License
+
+MIT

molfp-0.2.0/molfp/__init__.py

@@ -0,0 +1,103 @@
+"""
+molfp — Native Python/RDKit molecular fingerprint library.
+
+13 fingerprint types + 7 novel analysis modules:
+  - explain: bit-level explainability (which atoms set which bits)
+  - annotate: chemical names/descriptions for every bit
+  - collisions: hash collision detection for hashed FPs
+  - similarity: similarity distribution diagnostics
+  - cliffs: activity cliff detection
+  - fusion: consensus fingerprint construction
+  - isomers: structural isomer awareness
+
+Usage:
+    import molfp
+
+    # Compute fingerprints
+    fp = molfp.maccs("CCO")
+    fps = molfp.maccs_batch(["CCO", "c1ccccc1"])
+
+    # Explain which atoms set which bits
+    molfp.explain("CCO", "ecfp4")
+
+    # Get chemical annotation for a bit
+    molfp.annotate("substructure", 1)
+
+    # Detect hash collisions
+    molfp.detect_collisions("c1ccccc1", "ecfp4")
+
+    # Find activity cliffs
+    molfp.activity_cliffs(smiles, activities, "ecfp4")
+
+    # Build optimal fusion fingerprint
+    molfp.fuse(smiles, activities, ["ecfp4", "maccs", "pubchem"])
+
+    # Check discriminative power
+    molfp.discriminative_power(smiles)
+"""
+
+__version__ = "0.2.0"
+
+# ── Core fingerprint functions ────────────────────────────────────────────────
+from .fingerprints import (
+    maccs,
+    ecfp4,
+    pubchem,
+    substructure,
+    substructure_count,
+    klekota_roth,
+    klekota_roth_count,
+    estate,
+    atompairs2d,
+    atompairs2d_count,
+    rdk,
+    rdk_ext,
+    rdk_graphonly,
+    maccs_batch,
+    ecfp4_batch,
+    pubchem_batch,
+    substructure_batch,
+    substructure_count_batch,
+    klekota_roth_batch,
+    klekota_roth_count_batch,
+    estate_batch,
+    atompairs2d_batch,
+    atompairs2d_count_batch,
+    rdk_batch,
+    rdk_ext_batch,
+    rdk_graphonly_batch,
+    available,
+    get,
+    compute_batch,
+    FINGERPRINTS,
+)
+
+# ── Novel analysis modules ────────────────────────────────────────────────────
+from .explain import explain
+from .annotate import annotate, get_annotations
+from .collisions import detect_collisions, collision_rate, collision_pairs
+from .similarity import similarity_matrix, similarity_profile, compare_fps
+from .cliffs import activity_cliffs, cliff_summary
+from .fusion import fuse, complementarity
+from .isomers import find_identical_fps, discriminative_power, isomer_sensitivity
+from .bioactivity import (
+    classify, class_similarity, enriched_bits, depleted_bits, profile as bioactivity_profile,
+)
+from .standardize import (
+    standardize_mol, standardize_smiles, get_inchikey,
+    desalt, neutralize, canonicalize_tautomer,
+    standardize_batch, deduplicate, preprocess,
+)
+from .sklearn import (
+    MACCSTransformer, ECFPTransformer, PubChemTransformer,
+    SubstructureTransformer, SubstructureCountTransformer,
+    KlekotaRothTransformer, KlekotaRothCountTransformer,
+    EStateTransformer, AtomPairs2DTransformer, AtomPairs2DCountTransformer,
+    RDKTransformer, RDKExtTransformer, RDKGraphOnlyTransformer,
+    get_transformer, TRANSFORMERS,
+)
+from .interpret import interpret, interpret_molecule, compare_molecules
+from .distance import (
+    tanimoto, dice, cosine, sokal_michener, russel_rao,
+    distance, pairwise, pairwise_distance, available_metrics,
+)

molfp-0.2.0/molfp/_pubchem.py

@@ -0,0 +1,157 @@
+"""
+PubChem/CACTVS fingerprint (881 bits) — internal implementation.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from rdkit import Chem
+
+from . import _smarts
+
+
+_ELEMENT_TO_ANUM = {}
+for _z in range(1, 119):
+    _sym = Chem.GetPeriodicTable().GetElementSymbol(_z)
+    _ELEMENT_TO_ANUM[_sym] = _z
+
+
+def _classify_rings(mol):
+    """Classify SSSR rings by size and type. Returns {(type, size): count}."""
+    ri = mol.GetRingInfo()
+    counts = {}
+
+    for ring in ri.AtomRings():
+        size = len(ring)
+        atomic_nums = [mol.GetAtomWithIdx(i).GetAtomicNum() for i in ring]
+
+        all_carbon = all(z == 6 for z in atomic_nums)
+        has_nitrogen = any(z == 7 for z in atomic_nums)
+        has_hetero = any(z not in (1, 6) for z in atomic_nums)
+
+        bonds = []
+        for i in range(size):
+            b = mol.GetBondBetweenAtoms(ring[i], ring[(i + 1) % size])
+            if b:
+                bonds.append(b)
+
+        is_aromatic = all(b.GetIsAromatic() for b in bonds)
+        is_saturated = all(b.GetBondType() == Chem.BondType.SINGLE for b in bonds)
+        is_sat_or_arom = is_saturated or is_aromatic
+        is_unsaturated = not is_saturated and not is_aromatic
+
+        counts[("countAnyRing", size)] = counts.get(("countAnyRing", size), 0) + 1
+
+        if is_sat_or_arom:
+            if all_carbon:
+                k = ("countSaturatedOrAromaticCarbonOnlyRing", size)
+                counts[k] = counts.get(k, 0) + 1
+            if has_nitrogen:
+                k = ("countSaturatedOrAromaticNitrogenContainingRing", size)
+                counts[k] = counts.get(k, 0) + 1
+            if has_hetero:
+                k = ("countSaturatedOrAromaticHeteroContainingRing", size)
+                counts[k] = counts.get(k, 0) + 1
+
+        if is_unsaturated:
+            if all_carbon:
+                k = ("countUnsaturatedCarbonOnlyRing", size)
+                counts[k] = counts.get(k, 0) + 1
+            if has_nitrogen:
+                k = ("countUnsaturatedNitrogenContainingRing", size)
+                counts[k] = counts.get(k, 0) + 1
+            if has_hetero:
+                k = ("countUnsaturatedHeteroContainingRing", size)
+                counts[k] = counts.get(k, 0) + 1
+
+        if is_aromatic:
+            counts[("countAromaticRing", "any")] = counts.get(("countAromaticRing", "any"), 0) + 1
+            if has_hetero:
+                counts[("countHeteroAromaticRing", "any")] = counts.get(("countHeteroAromaticRing", "any"), 0) + 1
+
+    return counts
+
+
+def load_definitions() -> tuple[list[tuple[int, int, int]], list[tuple[int, str, int | str, int]], list[tuple[int, Chem.rdchem.Mol]]]:
+    """Parse pubchem_fingerprint_definitions.txt.
+
+    Returns (section1, section2, smarts_bits).
+    """
+    path = _smarts._data_path("pubchem_fingerprint_definitions.txt")
+    section1, section2, smarts_bits = [], [], []
+    current_section = None
+
+    with open(path, encoding="utf-8") as f:
+        for line in f:
+            line = line.rstrip()
+            if not line or line.startswith("#") or line.startswith("====="):
+                continue
+            if "SECTION 1" in line:
+                current_section = 1; continue
+            elif "SECTION 2" in line:
+                current_section = 2; continue
+            elif any(f"SECTION {i}" in line for i in range(3, 8)):
+                current_section = "smarts"; continue
+            if line.startswith("Format:") or line.startswith("Ring type") or line.startswith("  "):
+                continue
+
+            parts = line.split()
+            if not parts or not parts[0].isdigit():
+                continue
+            bit = int(parts[0])
+
+            if current_section == 1:
+                anum = _ELEMENT_TO_ANUM.get(parts[1], 0)
+                section1.append((bit, anum, int(parts[3])))
+            elif current_section == 2:
+                ring_size = parts[2] if parts[2] == "any" else int(parts[2])
+                section2.append((bit, parts[1], ring_size, int(parts[4])))
+            elif current_section == "smarts" and len(parts) > 1:
+                pat = Chem.MolFromSmarts(parts[1])
+                if pat is not None:
+                    smarts_bits.append((bit, pat))
+
+    return section1, section2, smarts_bits
+
+
+class PubChemComputer:
+    """Lazy-loaded PubChem FP computer."""
+
+    def __init__(self):
+        self._loaded = False
+        self._s1 = self._s2 = self._smarts = None
+
+    def _ensure_loaded(self):
+        if not self._loaded:
+            self._s1, self._s2, self._smarts = load_definitions()
+            self._loaded = True
+
+    def compute(self, mol: Chem.rdchem.Mol) -> list[int]:
+        """Compute 881-bit PubChem FP for an RDKit Mol. Returns list of ints."""
+        self._ensure_loaded()
+        bits = [0] * 881
+
+        # Section 1: element counts
+        elem_counts = {}
+        for atom in mol.GetAtoms():
+            anum = atom.GetAtomicNum()
+            elem_counts[anum] = elem_counts.get(anum, 0) + 1
+        elem_counts[1] = sum(a.GetTotalNumHs() for a in mol.GetAtoms())
+
+        for bit, anum, threshold in self._s1:
+            if elem_counts.get(anum, 0) >= threshold:
+                bits[bit] = 1
+
+        # Section 2: ring counts
+        ring_counts = _classify_rings(mol)
+        for bit, ring_type, ring_size, threshold in self._s2:
+            if ring_counts.get((ring_type, ring_size), 0) >= threshold:
+                bits[bit] = 1
+
+        # Sections 3-7: SMARTS
+        for bit, pat in self._smarts:
+            if mol.HasSubstructMatch(pat):
+                bits[bit] = 1
+
+        return bits