leishmania-screen 1.0.0__tar.gz

leishmania_screen-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Belaguppa Manjunath Ashwin Desai (CEO, AikyaNova), Pronama Biswas, and Madhavi Bhatt
+
+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.

leishmania_screen-1.0.0/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: leishmania-screen
+Version: 1.0.0
+Summary: Neural network virtual screening for antileishmanial activity against Leishmania donovani
+Author: Pronama Biswas, Madhavi Bhatt
+Author-email: Belaguppa Manjunath Ashwin Desai <ceo@aikyanova.com>
+License: MIT
+Project-URL: Source Code, https://github.com/AikyaNova-Pvt-Ltd/leishmania-screen
+Project-URL: Bug Tracker, https://github.com/AikyaNova-Pvt-Ltd/leishmania-screen/issues
+Keywords: leishmania,drug discovery,virtual screening,cheminformatics,deep learning,QSAR
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: License :: OSI Approved :: MIT License
+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
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.0
+Requires-Dist: scikit-learn>=1.7
+Requires-Dist: numpy>=1.24
+Requires-Dist: pandas>=1.5
+Requires-Dist: joblib>=1.2
+Requires-Dist: rdkit>=2023.3
+Dynamic: license-file
+
+# leishmania-screen
+
+Neural network–based virtual screening for antileishmanial activity against *Leishmania donovani*.
+
+Trained on a curated dataset of 6,699 compounds. Achieves **ROC-AUC 0.884** on the held-out test set.
+
+---
+
+## Installation
+
+```bash
+pip install leishmania-screen
+```
+
+> **RDKit note:** RDKit is listed as a dependency (`rdkit>=2023.3`). If your environment manages RDKit via conda, install it there first:
+> ```bash
+> conda install -c conda-forge rdkit
+> pip install leishmania-screen
+> ```
+
+---
+
+## Quick start — Python API
+
+```python
+from leishmania_screen import predict
+
+# Single compound
+result = predict("CCO")
+print(result.label)        # "Active" or "Inactive"
+print(result.probability)  # float in [0, 1]
+
+# Batch
+results = predict(["CCO", "CC(=O)Oc1ccccc1C(=O)O", "not_valid"])
+for r in results:
+    print(r.smiles, r.label, r.probability, r.error)
+```
+
+### `PredictionResult` fields
+
+| Field | Type | Description |
+|---|---|---|
+| `smiles` | `str` | The input SMILES string |
+| `label` | `str` | `"Active"`, `"Inactive"`, or `"Invalid"` |
+| `probability` | `float \| None` | Sigmoid output of the model (0–1); `None` for invalid inputs |
+| `error` | `str \| None` | Reason for invalidity; `None` for valid inputs |
+
+---
+
+## Quick start — Command line
+
+```bash
+# Single SMILES
+leishscreen --smiles "CC(=O)Oc1ccccc1C(=O)O"
+
+# Batch from CSV (must have a column named 'smiles')
+leishscreen --file compounds.csv --output results.csv
+
+# Batch from plain text (one SMILES per line)
+leishscreen --file smiles.txt --output results.csv
+
+# Custom column name
+leishscreen --file library.csv --smiles-col SMILES --output results.csv
+
+# Version
+leishscreen --version
+```
+
+---
+
+## Model details
+
+| Item | Value |
+|---|---|
+| Target | *Leishmania donovani* (binary: Active / Inactive) |
+| Training dataset | 6,699 compounds (2,574 active, 4,125 inactive) |
+| Feature pipeline | 218 RDKit descriptors + 2,728 fingerprint bits → 900-feature MI selection → StandardScaler → PCA (100 components) |
+| Architecture | Linear(100→512)→BN→GELU→Drop(0.30) → Linear(512→256)→BN→GELU→Drop(0.25) → Linear(256→128)→GELU→Drop(0.15) → Linear(128→1) |
+| Loss | `BCEWithLogitsLoss` with class-imbalance `pos_weight` |
+| Optimizer | AdamW (lr=8e-4, weight_decay=2e-4) + gradient clipping |
+| Scheduler | ReduceLROnPlateau (factor=0.5, patience=5) |
+| Training strategy | Multi-seed ensemble (seeds 42, 52, 62); early stopping (patience=18) |
+| Classification threshold | **0.60** (optimised on validation set: precision ≥ 0.70, max F1) |
+| Test ROC-AUC | **0.884** |
+| Test PR-AUC | **0.828** |
+| Test Accuracy | **0.815** |
+| Test Balanced Accuracy | **0.810** |
+
+### Fingerprints used
+
+| Type | Parameters | Bits |
+|---|---|---|
+| Morgan (ECFP-like) | radius=2 | 512 |
+| Avalon | — | 512 |
+| Topological Torsion | — | 512 |
+| Atom Pair | — | 512 |
+| MACCS Keys | — | 167 |
+| RDKit Path-Based | minPath=5, maxPath=7 | 512 |
+
+---
+
+## Citation
+
+If you use this package in your research, please cite:
+
+```
+[Citation to be added upon publication]
+```
+
+---
+
+## License
+
+MIT

leishmania_screen-1.0.0/README.md

@@ -0,0 +1,114 @@
+# leishmania-screen
+
+Neural network–based virtual screening for antileishmanial activity against *Leishmania donovani*.
+
+Trained on a curated dataset of 6,699 compounds. Achieves **ROC-AUC 0.884** on the held-out test set.
+
+---
+
+## Installation
+
+```bash
+pip install leishmania-screen
+```
+
+> **RDKit note:** RDKit is listed as a dependency (`rdkit>=2023.3`). If your environment manages RDKit via conda, install it there first:
+> ```bash
+> conda install -c conda-forge rdkit
+> pip install leishmania-screen
+> ```
+
+---
+
+## Quick start — Python API
+
+```python
+from leishmania_screen import predict
+
+# Single compound
+result = predict("CCO")
+print(result.label)        # "Active" or "Inactive"
+print(result.probability)  # float in [0, 1]
+
+# Batch
+results = predict(["CCO", "CC(=O)Oc1ccccc1C(=O)O", "not_valid"])
+for r in results:
+    print(r.smiles, r.label, r.probability, r.error)
+```
+
+### `PredictionResult` fields
+
+| Field | Type | Description |
+|---|---|---|
+| `smiles` | `str` | The input SMILES string |
+| `label` | `str` | `"Active"`, `"Inactive"`, or `"Invalid"` |
+| `probability` | `float \| None` | Sigmoid output of the model (0–1); `None` for invalid inputs |
+| `error` | `str \| None` | Reason for invalidity; `None` for valid inputs |
+
+---
+
+## Quick start — Command line
+
+```bash
+# Single SMILES
+leishscreen --smiles "CC(=O)Oc1ccccc1C(=O)O"
+
+# Batch from CSV (must have a column named 'smiles')
+leishscreen --file compounds.csv --output results.csv
+
+# Batch from plain text (one SMILES per line)
+leishscreen --file smiles.txt --output results.csv
+
+# Custom column name
+leishscreen --file library.csv --smiles-col SMILES --output results.csv
+
+# Version
+leishscreen --version
+```
+
+---
+
+## Model details
+
+| Item | Value |
+|---|---|
+| Target | *Leishmania donovani* (binary: Active / Inactive) |
+| Training dataset | 6,699 compounds (2,574 active, 4,125 inactive) |
+| Feature pipeline | 218 RDKit descriptors + 2,728 fingerprint bits → 900-feature MI selection → StandardScaler → PCA (100 components) |
+| Architecture | Linear(100→512)→BN→GELU→Drop(0.30) → Linear(512→256)→BN→GELU→Drop(0.25) → Linear(256→128)→GELU→Drop(0.15) → Linear(128→1) |
+| Loss | `BCEWithLogitsLoss` with class-imbalance `pos_weight` |
+| Optimizer | AdamW (lr=8e-4, weight_decay=2e-4) + gradient clipping |
+| Scheduler | ReduceLROnPlateau (factor=0.5, patience=5) |
+| Training strategy | Multi-seed ensemble (seeds 42, 52, 62); early stopping (patience=18) |
+| Classification threshold | **0.60** (optimised on validation set: precision ≥ 0.70, max F1) |
+| Test ROC-AUC | **0.884** |
+| Test PR-AUC | **0.828** |
+| Test Accuracy | **0.815** |
+| Test Balanced Accuracy | **0.810** |
+
+### Fingerprints used
+
+| Type | Parameters | Bits |
+|---|---|---|
+| Morgan (ECFP-like) | radius=2 | 512 |
+| Avalon | — | 512 |
+| Topological Torsion | — | 512 |
+| Atom Pair | — | 512 |
+| MACCS Keys | — | 167 |
+| RDKit Path-Based | minPath=5, maxPath=7 | 512 |
+
+---
+
+## Citation
+
+If you use this package in your research, please cite:
+
+```
+[Citation to be added upon publication]
+```
+
+---
+
+## License
+
+MIT

leishmania_screen-1.0.0/leishmania_screen/__init__.py

@@ -0,0 +1,20 @@
+"""
+leishmania-screen
+=================
+Neural network–based virtual screening for antileishmanial activity
+against *Leishmania donovani*.
+
+Quick start
+-----------
+>>> from leishmania_screen import predict
+>>> result = predict("CCO")
+>>> print(result.label, result.probability)
+
+>>> results = predict(["CCO", "c1ccccc1"])
+"""
+
+from ._predict import predict, PredictionResult, THRESHOLD
+
+__version__ = "1.0.0"
+__author__  = "Madhavi et al."
+__all__     = ["predict", "PredictionResult", "THRESHOLD"]

leishmania_screen-1.0.0/leishmania_screen/_features.py

@@ -0,0 +1,133 @@
+"""
+Molecular feature generation — replicates the training pipeline exactly.
+
+Feature vector layout (2,946 columns total):
+  [0:218]    RDKit descriptors          (218)
+  [218:730]  Morgan r=2 512-bit (Mfpt_) (512)
+  [730:1242] Avalon 512-bit             (512)
+  [1242:1754] Topological Torsion 512-bit (512)
+  [1754:2266] Atom Pair 512-bit         (512)
+  [2266:2433] MACCS keys               (167)
+  [2433:2945] RDKit path-based 512-bit  (512)
+  [2944:2946] ID column (dropped before model; kept here for tracing)
+"""
+
+from __future__ import annotations
+
+import warnings
+from typing import List, Tuple
+
+import numpy as np
+import pandas as pd
+
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore")
+    from rdkit import Chem
+    from rdkit.Chem import AllChem, Descriptors, rdMolDescriptors, DataStructs
+    from rdkit.Chem import rdFingerprintGenerator
+    try:
+        from rdkit.Avalon import pyAvalonTools
+        _AVALON_OK = True
+    except ImportError:
+        _AVALON_OK = False
+
+
+_DESCRIPTOR_NAMES: list[str] | None = None
+
+
+def _descriptor_names() -> list[str]:
+    global _DESCRIPTOR_NAMES
+    if _DESCRIPTOR_NAMES is None:
+        _DESCRIPTOR_NAMES = [n for n, _ in Descriptors.descList]
+    return _DESCRIPTOR_NAMES
+
+
+def validate_smiles(smiles: str) -> Tuple[Chem.Mol | None, str | None]:
+    """
+    Return (mol, None) on success or (None, error_message) on failure.
+    Applies both MolFromSmiles and SanitizeMol checks.
+    """
+    if not smiles or not isinstance(smiles, str):
+        return None, "Input is empty or not a string."
+    mol = Chem.MolFromSmiles(smiles.strip())
+    if mol is None:
+        return None, f"RDKit could not parse SMILES: '{smiles}'"
+    try:
+        Chem.SanitizeMol(mol)
+    except Exception as exc:
+        return None, f"Sanitization failed: {exc}"
+    return mol, None
+
+
+def _rdkit_descriptors(mol: Chem.Mol) -> np.ndarray:
+    desc_dict = Descriptors.CalcMolDescriptors(mol)
+    return np.array([desc_dict[n] for n in _descriptor_names()], dtype=np.float64)
+
+
+def _bitvect_to_array(bv) -> np.ndarray:
+    arr = np.zeros(bv.GetNumBits(), dtype=np.uint8)
+    DataStructs.ConvertToNumpyArray(bv, arr)
+    return arr
+
+
+def _morgan(mol: Chem.Mol) -> np.ndarray:
+    bv = AllChem.GetMorganFingerprintAsBitVect(mol, radius=2, nBits=512)
+    return _bitvect_to_array(bv)
+
+
+def _avalon(smiles: str) -> np.ndarray:
+    if _AVALON_OK:
+        bv = pyAvalonTools.GetAvalonFP(smiles, isSmiles=True, nBits=512)
+        return _bitvect_to_array(bv)
+    # Fallback: zero vector if Avalon not available
+    return np.zeros(512, dtype=np.uint8)
+
+
+def _topo_torsion(mol: Chem.Mol) -> np.ndarray:
+    bv = rdMolDescriptors.GetHashedTopologicalTorsionFingerprintAsBitVect(mol, nBits=512)
+    return _bitvect_to_array(bv)
+
+
+def _atom_pair(mol: Chem.Mol) -> np.ndarray:
+    bv = rdMolDescriptors.GetHashedAtomPairFingerprintAsBitVect(mol, nBits=512)
+    return _bitvect_to_array(bv)
+
+
+def _maccs(mol: Chem.Mol) -> np.ndarray:
+    bv = rdMolDescriptors.GetMACCSKeysFingerprint(mol)
+    return _bitvect_to_array(bv)
+
+
+def _rdkit_path(mol: Chem.Mol) -> np.ndarray:
+    bv = AllChem.RDKFingerprint(mol, minPath=5, maxPath=7, fpSize=512)
+    return _bitvect_to_array(bv)
+
+
+def _column_names() -> List[str]:
+    desc_names = _descriptor_names()
+    morgan_names  = [f"Mfpt_{i}"   for i in range(512)]
+    avalon_names  = [f"Avfpt_{i}"  for i in range(512)]
+    tt_names      = [f"TT_fpt_{i}" for i in range(512)]
+    ap_names      = [f"AP_fpt_{i}" for i in range(512)]
+    mc_names      = [f"MC_fpt_{i}" for i in range(167)]
+    rd_names      = [f"RD_fpt_{i}" for i in range(512)]
+    return desc_names + morgan_names + avalon_names + tt_names + ap_names + mc_names + rd_names
+
+
+def compute_features(smiles: str, mol: Chem.Mol) -> pd.DataFrame:
+    """
+    Build the full 2,946-column feature row for one molecule.
+    Returns a single-row DataFrame with named columns.
+    """
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        desc  = _rdkit_descriptors(mol)
+        mfp   = _morgan(mol)
+        avfp  = _avalon(smiles)
+        ttfp  = _topo_torsion(mol)
+        apfp  = _atom_pair(mol)
+        mcfp  = _maccs(mol)
+        rdfp  = _rdkit_path(mol)
+
+    row = np.concatenate([desc, mfp, avfp, ttfp, apfp, mcfp, rdfp])
+    return pd.DataFrame([row], columns=_column_names())

leishmania_screen-1.0.0/leishmania_screen/_model.py

@@ -0,0 +1,29 @@
+import torch
+import torch.nn as nn
+
+
+class _LeishNet(nn.Module):
+    """Neural network architecture — must match training exactly."""
+
+    def __init__(self, d: int = 100):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(d, 512),
+            nn.BatchNorm1d(512),
+            nn.GELU(),
+            nn.Dropout(0.30),
+
+            nn.Linear(512, 256),
+            nn.BatchNorm1d(256),
+            nn.GELU(),
+            nn.Dropout(0.25),
+
+            nn.Linear(256, 128),
+            nn.GELU(),
+            nn.Dropout(0.15),
+
+            nn.Linear(128, 1),
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.net(x)

leishmania_screen-1.0.0/leishmania_screen/_predict.py

@@ -0,0 +1,166 @@
+"""
+Core inference engine. Loads all artefacts once (lazy, thread-safe singleton)
+and exposes a predict() function that accepts one or many SMILES strings.
+"""
+
+from __future__ import annotations
+
+import importlib.resources
+import threading
+import warnings
+from dataclasses import dataclass
+from typing import List, Union
+
+import joblib
+import numpy as np
+import pandas as pd
+import torch
+
+from ._model import _LeishNet
+from ._features import validate_smiles, compute_features
+
+THRESHOLD: float = 0.6
+_LOCK = threading.Lock()
+_ARTEFACTS: "_Artefacts | None" = None
+
+
+@dataclass
+class PredictionResult:
+    smiles: str
+    label: str            # "Active" | "Inactive" | "Invalid"
+    probability: float | None
+    error: str | None = None
+
+    def to_dict(self) -> dict:
+        return {
+            "smiles": self.smiles,
+            "label": self.label,
+            "probability": round(self.probability, 4) if self.probability is not None else None,
+            "error": self.error,
+        }
+
+
+class _Artefacts:
+    """Holds all loaded model artefacts. Instantiated once."""
+
+    def __init__(self):
+        data_pkg = importlib.resources.files("leishmania_screen") / "data"
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            self.selected_features: list[str] = list(
+                joblib.load(str(data_pkg / "selected_features_LD.pkl"))
+            )
+            self.train_columns: list[str] = joblib.load(
+                str(data_pkg / "train_columns_LD.pkl")
+            )
+            # Per-feature scalers: dict[feature_name -> StandardScaler]
+            # Only the 129 features that were scaled during training are included.
+            self.scalers: dict = joblib.load(str(data_pkg / "scalers_LD.pkl"))
+            self.pca = joblib.load(str(data_pkg / "pca_100_LD.pkl"))
+
+        self.model = _LeishNet(d=100)
+        state = torch.load(
+            str(data_pkg / "NN_model.pth"),
+            map_location="cpu",
+            weights_only=True,
+        )
+        self.model.load_state_dict(state)
+        self.model.eval()
+
+
+def _get_artefacts() -> _Artefacts:
+    global _ARTEFACTS
+    if _ARTEFACTS is None:
+        with _LOCK:
+            if _ARTEFACTS is None:
+                _ARTEFACTS = _Artefacts()
+    return _ARTEFACTS
+
+
+def _transform(raw_df: pd.DataFrame, art: _Artefacts) -> np.ndarray:
+    """Apply feature selection → per-feature scaling → PCA."""
+    # Align to the 900 training features; missing columns filled with 0
+    missing = {col: 0.0 for col in art.selected_features if col not in raw_df.columns}
+    if missing:
+        raw_df = pd.concat([raw_df, pd.DataFrame(missing, index=raw_df.index)], axis=1)
+
+    X_df = raw_df[art.train_columns].copy()
+
+    # Apply per-feature scalers only to features that were scaled during training
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        for feature, scaler in art.scalers.items():
+            if feature in X_df.columns:
+                X_df[feature] = scaler.transform(X_df[[feature]])
+        X_pca = art.pca.transform(X_df.values.astype(np.float64))
+
+    return X_pca.astype(np.float32)
+
+
+def _run_model(X_pca: np.ndarray, art: _Artefacts) -> np.ndarray:
+    tensor = torch.tensor(X_pca, dtype=torch.float32)
+    with torch.no_grad():
+        logits = art.model(tensor)
+        probs  = torch.sigmoid(logits).cpu().numpy().ravel()
+    return probs
+
+
+def predict(
+    smiles: Union[str, List[str]],
+) -> Union[PredictionResult, List[PredictionResult]]:
+    """
+    Predict antileishmanial activity for one or more SMILES strings.
+
+    Parameters
+    ----------
+    smiles : str or list of str
+        SMILES string(s) to screen.
+
+    Returns
+    -------
+    PredictionResult or list of PredictionResult
+        Each result contains .smiles, .label, .probability, .error.
+    """
+    single = isinstance(smiles, str)
+    inputs: list[str] = [smiles] if single else list(smiles)
+
+    art = _get_artefacts()
+
+    # --- validate all SMILES ---
+    valid_idx:   list[int]        = []
+    valid_mols:  list            = []
+    valid_smi:   list[str]       = []
+    results: list[PredictionResult | None] = [None] * len(inputs)
+
+    for i, smi in enumerate(inputs):
+        mol, err = validate_smiles(smi)
+        if err:
+            results[i] = PredictionResult(
+                smiles=smi, label="Invalid", probability=None, error=err
+            )
+        else:
+            valid_idx.append(i)
+            valid_mols.append(mol)
+            valid_smi.append(smi)
+
+    # --- feature generation for valid molecules ---
+    if valid_mols:
+        feature_rows = [
+            compute_features(smi, mol)
+            for smi, mol in zip(valid_smi, valid_mols)
+        ]
+        raw_df = pd.concat(feature_rows, ignore_index=True)
+        X_pca  = _transform(raw_df, art)
+        probs  = _run_model(X_pca, art)
+
+        for local_j, global_i in enumerate(valid_idx):
+            p = float(probs[local_j])
+            results[global_i] = PredictionResult(
+                smiles=valid_smi[local_j],
+                label="Active" if p >= THRESHOLD else "Inactive",
+                probability=p,
+            )
+
+    out = [r for r in results]  # type: list[PredictionResult]
+    return out[0] if single else out

leishmania_screen-1.0.0/leishmania_screen/cli.py

@@ -0,0 +1,136 @@
+"""
+Command-line interface for leishmania-screen.
+
+Usage examples
+--------------
+Single SMILES:
+    leishscreen --smiles "CCO"
+
+Batch from CSV (must have a 'smiles' column):
+    leishscreen --file compounds.csv --output results.csv
+
+Batch from plain text (one SMILES per line):
+    leishscreen --file smiles.txt --output results.csv
+
+Print version:
+    leishscreen --version
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import sys
+from pathlib import Path
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="leishscreen",
+        description=(
+            "Virtual screening for antileishmanial activity against "
+            "Leishmania donovani using a trained neural network."
+        ),
+    )
+    p.add_argument("--version", action="store_true", help="Print version and exit.")
+
+    group = p.add_mutually_exclusive_group()
+    group.add_argument("--smiles", type=str, metavar="SMILES",
+                       help="A single SMILES string to predict.")
+    group.add_argument("--file", type=Path, metavar="FILE",
+                       help="Path to a CSV (with 'smiles' column) or plain-text file (one SMILES per line).")
+
+    p.add_argument("--output", type=Path, metavar="FILE", default=None,
+                   help="Output CSV path. If omitted, results are printed to stdout.")
+    p.add_argument("--smiles-col", type=str, default="smiles", metavar="COL",
+                   help="Column name to read SMILES from in a CSV input (default: 'smiles').")
+    return p
+
+
+def _read_smiles_from_file(path: Path, smiles_col: str) -> list[str]:
+    suffix = path.suffix.lower()
+    if suffix == ".csv":
+        with open(path, newline="", encoding="utf-8") as fh:
+            reader = csv.DictReader(fh)
+            if smiles_col not in (reader.fieldnames or []):
+                sys.exit(
+                    f"Error: column '{smiles_col}' not found in {path}.\n"
+                    f"Available columns: {reader.fieldnames}\n"
+                    f"Use --smiles-col to specify the correct column name."
+                )
+            return [row[smiles_col] for row in reader if row[smiles_col].strip()]
+    else:
+        # Plain text: one SMILES per line
+        lines = path.read_text(encoding="utf-8").splitlines()
+        return [ln.strip() for ln in lines if ln.strip() and not ln.startswith("#")]
+
+
+def _write_results(results, output: Path | None) -> None:
+    rows = [r.to_dict() for r in results]
+    fieldnames = ["smiles", "label", "probability", "error"]
+
+    if output is None:
+        writer = csv.DictWriter(sys.stdout, fieldnames=fieldnames)
+        writer.writeheader()
+        writer.writerows(rows)
+    else:
+        with open(output, "w", newline="", encoding="utf-8") as fh:
+            writer = csv.DictWriter(fh, fieldnames=fieldnames)
+            writer.writeheader()
+            writer.writerows(rows)
+        print(f"Results saved to: {output}")
+        _print_summary(results)
+
+
+def _print_summary(results) -> None:
+    total    = len(results)
+    active   = sum(1 for r in results if r.label == "Active")
+    inactive = sum(1 for r in results if r.label == "Inactive")
+    invalid  = sum(1 for r in results if r.label == "Invalid")
+    print(f"\nSummary: {total} compounds — {active} Active | {inactive} Inactive | {invalid} Invalid")
+
+
+def main() -> None:
+    parser = _build_parser()
+    args   = parser.parse_args()
+
+    if args.version:
+        from leishmania_screen import __version__
+        print(f"leishmania-screen {__version__}")
+        return
+
+    if args.smiles is None and args.file is None:
+        parser.print_help()
+        sys.exit(0)
+
+    # Lazy import so --version/--help don't pay the torch/rdkit load cost
+    from leishmania_screen import predict
+
+    if args.smiles:
+        result = predict(args.smiles)
+        if args.output:
+            _write_results([result], args.output)
+        else:
+            print(f"SMILES      : {result.smiles}")
+            print(f"Label       : {result.label}")
+            if result.probability is not None:
+                print(f"Probability : {result.probability:.4f}")
+            if result.error:
+                print(f"Error       : {result.error}")
+        return
+
+    # Batch mode
+    if not args.file.exists():
+        sys.exit(f"Error: file not found: {args.file}")
+
+    smiles_list = _read_smiles_from_file(args.file, args.smiles_col)
+    if not smiles_list:
+        sys.exit("Error: no SMILES found in the input file.")
+
+    print(f"Screening {len(smiles_list)} compounds …", file=sys.stderr)
+    results = predict(smiles_list)
+    _write_results(results, args.output)
+
+
+if __name__ == "__main__":
+    main()

leishmania_screen-1.0.0/leishmania_screen.egg-info/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: leishmania-screen
+Version: 1.0.0
+Summary: Neural network virtual screening for antileishmanial activity against Leishmania donovani
+Author: Pronama Biswas, Madhavi Bhatt
+Author-email: Belaguppa Manjunath Ashwin Desai <ceo@aikyanova.com>
+License: MIT
+Project-URL: Source Code, https://github.com/AikyaNova-Pvt-Ltd/leishmania-screen
+Project-URL: Bug Tracker, https://github.com/AikyaNova-Pvt-Ltd/leishmania-screen/issues
+Keywords: leishmania,drug discovery,virtual screening,cheminformatics,deep learning,QSAR
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: License :: OSI Approved :: MIT License
+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
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.0
+Requires-Dist: scikit-learn>=1.7
+Requires-Dist: numpy>=1.24
+Requires-Dist: pandas>=1.5
+Requires-Dist: joblib>=1.2
+Requires-Dist: rdkit>=2023.3
+Dynamic: license-file
+
+# leishmania-screen
+
+Neural network–based virtual screening for antileishmanial activity against *Leishmania donovani*.
+
+Trained on a curated dataset of 6,699 compounds. Achieves **ROC-AUC 0.884** on the held-out test set.
+
+---
+
+## Installation
+
+```bash
+pip install leishmania-screen
+```
+
+> **RDKit note:** RDKit is listed as a dependency (`rdkit>=2023.3`). If your environment manages RDKit via conda, install it there first:
+> ```bash
+> conda install -c conda-forge rdkit
+> pip install leishmania-screen
+> ```
+
+---
+
+## Quick start — Python API
+
+```python
+from leishmania_screen import predict
+
+# Single compound
+result = predict("CCO")
+print(result.label)        # "Active" or "Inactive"
+print(result.probability)  # float in [0, 1]
+
+# Batch
+results = predict(["CCO", "CC(=O)Oc1ccccc1C(=O)O", "not_valid"])
+for r in results:
+    print(r.smiles, r.label, r.probability, r.error)
+```
+
+### `PredictionResult` fields
+
+| Field | Type | Description |
+|---|---|---|
+| `smiles` | `str` | The input SMILES string |
+| `label` | `str` | `"Active"`, `"Inactive"`, or `"Invalid"` |
+| `probability` | `float \| None` | Sigmoid output of the model (0–1); `None` for invalid inputs |
+| `error` | `str \| None` | Reason for invalidity; `None` for valid inputs |
+
+---
+
+## Quick start — Command line
+
+```bash
+# Single SMILES
+leishscreen --smiles "CC(=O)Oc1ccccc1C(=O)O"
+
+# Batch from CSV (must have a column named 'smiles')
+leishscreen --file compounds.csv --output results.csv
+
+# Batch from plain text (one SMILES per line)
+leishscreen --file smiles.txt --output results.csv
+
+# Custom column name
+leishscreen --file library.csv --smiles-col SMILES --output results.csv
+
+# Version
+leishscreen --version
+```
+
+---
+
+## Model details
+
+| Item | Value |
+|---|---|
+| Target | *Leishmania donovani* (binary: Active / Inactive) |
+| Training dataset | 6,699 compounds (2,574 active, 4,125 inactive) |
+| Feature pipeline | 218 RDKit descriptors + 2,728 fingerprint bits → 900-feature MI selection → StandardScaler → PCA (100 components) |
+| Architecture | Linear(100→512)→BN→GELU→Drop(0.30) → Linear(512→256)→BN→GELU→Drop(0.25) → Linear(256→128)→GELU→Drop(0.15) → Linear(128→1) |
+| Loss | `BCEWithLogitsLoss` with class-imbalance `pos_weight` |
+| Optimizer | AdamW (lr=8e-4, weight_decay=2e-4) + gradient clipping |
+| Scheduler | ReduceLROnPlateau (factor=0.5, patience=5) |
+| Training strategy | Multi-seed ensemble (seeds 42, 52, 62); early stopping (patience=18) |
+| Classification threshold | **0.60** (optimised on validation set: precision ≥ 0.70, max F1) |
+| Test ROC-AUC | **0.884** |
+| Test PR-AUC | **0.828** |
+| Test Accuracy | **0.815** |
+| Test Balanced Accuracy | **0.810** |
+
+### Fingerprints used
+
+| Type | Parameters | Bits |
+|---|---|---|
+| Morgan (ECFP-like) | radius=2 | 512 |
+| Avalon | — | 512 |
+| Topological Torsion | — | 512 |
+| Atom Pair | — | 512 |
+| MACCS Keys | — | 167 |
+| RDKit Path-Based | minPath=5, maxPath=7 | 512 |
+
+---
+
+## Citation
+
+If you use this package in your research, please cite:
+
+```
+[Citation to be added upon publication]
+```
+
+---
+
+## License
+
+MIT

leishmania_screen-1.0.0/leishmania_screen.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+LICENSE
+README.md
+pyproject.toml
+leishmania_screen/__init__.py
+leishmania_screen/_features.py
+leishmania_screen/_model.py
+leishmania_screen/_predict.py
+leishmania_screen/cli.py
+leishmania_screen.egg-info/PKG-INFO
+leishmania_screen.egg-info/SOURCES.txt
+leishmania_screen.egg-info/dependency_links.txt
+leishmania_screen.egg-info/entry_points.txt
+leishmania_screen.egg-info/requires.txt
+leishmania_screen.egg-info/top_level.txt
+leishmania_screen/data/NN_model.pth
+leishmania_screen/data/__init__.py
+leishmania_screen/data/pca_100_LD.pkl
+leishmania_screen/data/scalers_LD.pkl
+leishmania_screen/data/selected_features_LD.pkl
+leishmania_screen/data/train_columns_LD.pkl
+tests/__init__.py
+tests/test_predict.py

leishmania_screen-1.0.0/leishmania_screen.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

leishmania_screen-1.0.0/leishmania_screen.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+leishscreen = leishmania_screen.cli:main

leishmania_screen-1.0.0/leishmania_screen.egg-info/requires.txt

@@ -0,0 +1,6 @@
+torch>=2.0
+scikit-learn>=1.7
+numpy>=1.24
+pandas>=1.5
+joblib>=1.2
+rdkit>=2023.3

leishmania_screen-1.0.0/leishmania_screen.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+dist
+leishmania_screen

leishmania_screen-1.0.0/pyproject.toml

@@ -0,0 +1,62 @@
+[build-system]
+requires      = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name        = "leishmania-screen"
+version     = "1.0.0"
+description = "Neural network virtual screening for antileishmanial activity against Leishmania donovani"
+readme      = "README.md"
+license     = { text = "MIT" }
+requires-python = ">=3.9"
+
+authors = [
+  { name = "Belaguppa Manjunath Ashwin Desai", email = "ceo@aikyanova.com" },
+  { name = "Pronama Biswas" },
+  { name = "Madhavi Bhatt" },
+]
+
+keywords = [
+  "leishmania",
+  "drug discovery",
+  "virtual screening",
+  "cheminformatics",
+  "deep learning",
+  "QSAR",
+]
+
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Intended Audience :: Science/Research",
+  "Topic :: Scientific/Engineering :: Chemistry",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+]
+
+dependencies = [
+  "torch>=2.0",
+  "scikit-learn>=1.7",
+  "numpy>=1.24",
+  "pandas>=1.5",
+  "joblib>=1.2",
+  "rdkit>=2023.3",
+]
+
+[project.scripts]
+leishscreen = "leishmania_screen.cli:main"
+
+[project.urls]
+"Source Code" = "https://github.com/AikyaNova-Pvt-Ltd/leishmania-screen"
+"Bug Tracker"  = "https://github.com/AikyaNova-Pvt-Ltd/leishmania-screen/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+exclude = ["tests*"]
+
+[tool.setuptools.package-data]
+leishmania_screen = ["data/*.pkl", "data/*.pth", "data/*.py"]

leishmania_screen-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

leishmania_screen-1.0.0/tests/test_predict.py

@@ -0,0 +1,111 @@
+"""
+Tests for leishmania-screen.
+
+Run with:  pytest tests/ -v
+"""
+
+import pytest
+from leishmania_screen import predict, PredictionResult, THRESHOLD
+
+
+# ---------------------------------------------------------------------------
+# Known SMILES used across tests
+# ---------------------------------------------------------------------------
+ASPIRIN   = "CC(=O)Oc1ccccc1C(=O)O"   # aspirin
+ETHANOL   = "CCO"                       # ethanol
+INVALID_1 = "not_a_smiles"
+INVALID_2 = ""
+INVALID_3 = "C(C)(C)(C)(C)(C)(C)"      # over-valenced carbon
+
+
+class TestSinglePrediction:
+
+    def test_returns_prediction_result(self):
+        r = predict(ASPIRIN)
+        assert isinstance(r, PredictionResult)
+
+    def test_label_is_active_or_inactive(self):
+        r = predict(ASPIRIN)
+        assert r.label in ("Active", "Inactive")
+
+    def test_probability_is_float_in_range(self):
+        r = predict(ASPIRIN)
+        assert r.probability is not None
+        assert 0.0 <= r.probability <= 1.0
+
+    def test_probability_consistent_with_label(self):
+        r = predict(ASPIRIN)
+        if r.label == "Active":
+            assert r.probability >= THRESHOLD
+        else:
+            assert r.probability < THRESHOLD
+
+    def test_smiles_preserved_in_output(self):
+        r = predict(ASPIRIN)
+        assert r.smiles == ASPIRIN
+
+    def test_deterministic(self):
+        r1 = predict(ETHANOL)
+        r2 = predict(ETHANOL)
+        assert r1.label == r2.label
+        assert r1.probability == r2.probability
+
+
+class TestInvalidSmiles:
+
+    def test_nonsense_string(self):
+        r = predict(INVALID_1)
+        assert r.label == "Invalid"
+        assert r.probability is None
+        assert r.error is not None
+
+    def test_empty_string(self):
+        r = predict(INVALID_2)
+        assert r.label == "Invalid"
+
+    def test_over_valenced(self):
+        r = predict(INVALID_3)
+        assert r.label == "Invalid"
+
+
+class TestBatchPrediction:
+
+    def test_returns_list(self):
+        results = predict([ASPIRIN, ETHANOL])
+        assert isinstance(results, list)
+        assert len(results) == 2
+
+    def test_each_element_is_prediction_result(self):
+        results = predict([ASPIRIN, ETHANOL])
+        for r in results:
+            assert isinstance(r, PredictionResult)
+
+    def test_mixed_valid_invalid(self):
+        results = predict([ASPIRIN, INVALID_1, ETHANOL])
+        assert results[0].label in ("Active", "Inactive")
+        assert results[1].label == "Invalid"
+        assert results[2].label in ("Active", "Inactive")
+
+    def test_single_element_list_matches_scalar(self):
+        scalar = predict(ASPIRIN)
+        batch  = predict([ASPIRIN])
+        assert batch[0].label == scalar.label
+        assert batch[0].probability == scalar.probability
+
+    def test_all_invalid_batch(self):
+        results = predict([INVALID_1, INVALID_2])
+        assert all(r.label == "Invalid" for r in results)
+
+
+class TestToDict:
+
+    def test_to_dict_keys(self):
+        r = predict(ASPIRIN)
+        d = r.to_dict()
+        assert set(d.keys()) == {"smiles", "label", "probability", "error"}
+
+    def test_to_dict_probability_rounded(self):
+        r = predict(ASPIRIN)
+        d = r.to_dict()
+        if d["probability"] is not None:
+            assert d["probability"] == round(r.probability, 4)