init

.env_template

@@ -0,0 +1,2 @@
+HF_TOKEN=token
+MODELS_DIR=models

.gitignore

@@ -0,0 +1 @@
+.env

.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,12 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="PyUnresolvedReferencesInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredIdentifiers">
+        <list>
+          <option value="dict.*" />
+        </list>
+      </option>
+    </inspection_tool>
+  </profile>
+</component>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.13 (clickerapp)" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/molecular.iml" filepath="$PROJECT_DIR$/.idea/molecular.iml" />
+    </modules>
+  </component>
+</project>

.idea/molecular.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

Dockerfile

@@ -0,0 +1,16 @@
+# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+# you will also find guides on how best to write your Dockerfile
+
+FROM python:3.9
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["uvicorn", "app.app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,12 +1,10 @@
 ---
-title: Molecular
-emoji: 🔥
-colorFrom: gray
-colorTo: purple
+title: Molecular Features Prediction
+emoji: 😻
+colorFrom: yellow
+colorTo: indigo
 sdk: docker
 pinned: false
-license: mit
-short_description: ML module for "MoleMap" molecular prediction project
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app/app.py

@@ -0,0 +1,19 @@
+from dotenv import load_dotenv
+load_dotenv()
+
+from fastapi import FastAPI  # noqa: E402
+from app.routers import predict  # noqa: E402
+from app.routers import descriptors  # noqa: E402
+from app.routers import name  # noqa: E402
+
+
+app = FastAPI(title="Molecular Prediction API")
+
+app.include_router(predict.router, prefix="/api")
+app.include_router(descriptors.router, prefix="/api")
+app.include_router(name.router, prefix="/api")
+
+
+@app.get("/")
+async def root():
+    return {"message": "Molecular Prediction API. Use POST /api/predict"}

app/routers/__init__.py

@@ -0,0 +1 @@
+from . import predict  # noqa: F401

app/routers/descriptors.py

@@ -0,0 +1,17 @@
+from .schemas import MoleculeDescriptors, InputData
+from fastapi import APIRouter, HTTPException
+from molecule import get_molecule_properties
+
+router = APIRouter()
+
+
+@router.post("/descriptor", response_model=MoleculeDescriptors)
+async def descriptor(payload: InputData):
+    try:
+        props_dict = get_molecule_properties(payload.smiles)
+        props_model = MoleculeDescriptors(**props_dict)
+        return props_model
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Ошибка сервера: {e}")

app/routers/name.py

@@ -0,0 +1,10 @@
+from fastapi import APIRouter
+from .schemas import InputData, NameResponse
+from molecule import get_name
+
+router = APIRouter()
+
+
+@router.post("/get_name", response_model=NameResponse)
+async def get_name_function(payload: InputData):
+    return NameResponse(name=get_name(payload.smiles))

app/routers/predict.py

@@ -0,0 +1,26 @@
+from fastapi import APIRouter, HTTPException
+from .schemas import InputData, PredictionResponse, PredictionShapResponse
+from molecule import predict as predict_properties
+
+router = APIRouter()
+
+
+@router.post("/predict", response_model=PredictionResponse)
+async def predict(payload: InputData):
+    try:
+        props = predict_properties(payload.smiles, shap=False)
+        print(props)
+        response = PredictionResponse(**props)
+        return response
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    
+@router.post("/predict_shap", response_model=PredictionShapResponse)
+async def predict_shap(payload: InputData):
+    try:
+        props = predict_properties(payload.smiles, shap=True)
+        print(props)
+        response = PredictionShapResponse(**props)
+        return response
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))

app/routers/schemas.py

@@ -0,0 +1,126 @@
+from typing import List, Optional
+from pydantic import BaseModel, ConfigDict
+
+
+class BaseProperties(BaseModel):
+    n_atoms: int
+    n_bonds: int
+    canonical_smiles: str
+    aromatic_rings: int
+    aliphatic_rings: int
+    heterocycles: int
+
+
+class PhysChemProperties(BaseModel):
+    mol_weight: float
+    logp: float
+    tpsa: float
+    h_donors: int
+    h_acceptors: int
+    rotatable_bonds: int
+    fraction_csp3: float
+
+
+class ChargeStats(BaseModel):
+    mean: float
+    max: float
+    min: float
+
+
+class PharmacophoreProperties(BaseModel):
+    n_features: int
+    types: List[str]
+
+
+class LipinskiProperties(BaseModel):
+    mw_ok: bool
+    logp_ok: bool
+    h_donors_ok: bool
+    h_acceptors_ok: bool
+    pass_: bool
+
+    class Config:
+        fields = {"pass_": "pass"}
+
+
+class FingerprintInfo(BaseModel):
+    n_bits: int
+    bits_on: int
+
+
+class ExtraDescriptors(BaseModel):
+    names: List[str]
+    values: List[float]
+
+
+# ========================================================================
+
+
+class MoleculeDescriptors(BaseModel):
+    smiles: str
+    base: BaseProperties
+    physchem: PhysChemProperties
+    charges: Optional[ChargeStats]
+    pharmacophore: PharmacophoreProperties
+    qed: Optional[float]
+    lipinski: LipinskiProperties
+    fingerprint: FingerprintInfo
+    extra_descriptors: ExtraDescriptors
+
+class InputData(BaseModel):
+    smiles: str
+
+class NameResponse(BaseModel):
+    name: str
+
+class PredictionResponse(BaseModel):
+    solubility: float
+    logp: float
+    clintox: float
+    fdaapprov: float
+    cardiotoxicity: float
+
+    # Конфигурация модели
+    model_config = ConfigDict(
+        extra='allow',
+        json_schema_extra={
+            'examples': [
+                {
+                    'solubility': -0.16123154,
+                    'logp': -1.2341234,
+                    'clintox': 1,
+                    'fdaapprov': 0,
+                    'cardiotoxicity': 0.12341234
+                }
+            ]
+        }
+    )
+
+
+class ShapResponse(BaseModel):
+    pred: float
+    atom_shap: List[float]
+
+
+class PredictionShapResponse(BaseModel):
+    solubility: ShapResponse
+    logp: ShapResponse
+    clintox: ShapResponse
+    fdaapprov: ShapResponse
+    cardiotoxicity: ShapResponse
+
+    # Конфигурация модели
+    model_config = ConfigDict(
+        extra='allow',
+        json_schema_extra={
+            'examples': [
+                {
+                    'solubility': {'pred': -0.16123154, 'atom_shap': [0.0, 0.1, -0.05]},
+                    'logp': {'pred': -1.2341234, 'atom_shap': [0.0, 0.1, -0.05]},
+                    'clintox': {'pred': 1, 'atom_shap': [0.0, 0.1, -0.05]},
+                    'fdaapprov': {'pred': 0, 'atom_shap': [0.0, 0.1, -0.05]},
+                    'cardiotoxicity': {'pred': 0.1234567, 'atom_shap': [0.0, 0.1, -0.05]}
+                }
+            ]
+        }
+    )

models/cardiotoxicity.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:55edf9b904ad80fb9710975a4136be567106f2664b0a54a45c011714b25d263e
+size 5592855

models/clintox.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2f001f049256112b96742554f0d57df7fa791ba76b2458d7865ccf86082281d5
+size 646573

models/fdaapprov.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8ab63da51d4b38a5724ed7b45de991b6f56494c04ca433f8edf02722a154379f
+size 646713

models/logp.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:97c37285ea763d0fe981bacc9a565e7417b1741b21f8f95c8a07bfd6ecd1af78
+size 4387995

models/solubility.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8e54651bb859ee8b497884624bce9dc05a6c03ee6dbbda0240cf86e187132f3b
+size 1134271

molecule/__init__.py

@@ -0,0 +1,3 @@
+from .descriptors import get_molecule_properties # noqa: F401
+from .predict import predict # noqa: F401
+from .name import get_name # noqa: F401

molecule/descriptors.py

@@ -0,0 +1,133 @@
+from rdkit import Chem
+from rdkit.Chem import (
+    Descriptors, rdMolDescriptors, Crippen, Lipinski, QED, AllChem,
+    ChemicalFeatures
+)
+from rdkit.ML.Descriptors import MoleculeDescriptors
+from rdkit.Chem import rdMolDescriptors as rdmd
+import numpy as np
+import os
+
+
+def load_feature_factory():
+    """Загружает стандартный RDKit FeatureFactory."""
+    from rdkit import RDConfig
+
+    fdef = os.path.join(RDConfig.RDDataDir, "BaseFeatures.fdef")
+    return ChemicalFeatures.BuildFeatureFactory(fdef)
+
+
+def compute_gasteiger_stats(mol):
+    """Возвращает статистику по Gasteiger-зарядам или None."""
+    try:
+        AllChem.ComputeGasteigerCharges(mol)
+        charges = [a.GetDoubleProp("_GasteigerCharge") for a in mol.GetAtoms()]
+        return {
+            "mean": float(np.mean(charges)),
+            "max": float(max(charges)),
+            "min": float(min(charges)),
+        }
+    except Exception:
+        return None
+
+
+def compute_morgan_fp(mol, radius=2, n_bits=2048):
+    fp = AllChem.GetMorganFingerprintAsBitVect(mol, radius=radius, nBits=n_bits)
+    bitstring = fp.ToBitString()
+    return {
+        "n_bits": n_bits,
+        "bits_on": bitstring.count("1"),
+    }
+
+
+def compute_extra_descriptors(mol, n_show=10):
+    calc = MoleculeDescriptors.MolecularDescriptorCalculator(
+        [name for name, _ in Descriptors._descList]
+    )
+    names = calc.GetDescriptorNames()
+    values = calc.CalcDescriptors(mol)
+    return {
+        "names": names[:n_show],
+        "values": values[:n_show],
+    }
+
+
+def get_molecule_properties(smiles):
+    """Возвращает дескрипторы и свойства молекулы по SMILES."""
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        raise ValueError("Не удалось создать молекулу из SMILES.")
+
+    mol = Chem.AddHs(mol)
+
+    # --- Базовые свойства ---
+    base = {
+        "n_atoms": mol.GetNumAtoms(),
+        "n_bonds": mol.GetNumBonds(),
+        "canonical_smiles": Chem.MolToSmiles(Chem.RemoveHs(mol), canonical=True),
+        "aromatic_rings": rdmd.CalcNumAromaticRings(mol),
+        "aliphatic_rings": rdmd.CalcNumAliphaticRings(mol),
+        "heterocycles": rdmd.CalcNumHeterocycles(mol),
+    }
+
+    # --- Физико-химические ---
+    physchem = {
+        "mol_weight": Descriptors.MolWt(mol),
+        "logp": Crippen.MolLogP(mol),
+        "tpsa": Descriptors.TPSA(mol),
+        "h_donors": Lipinski.NumHDonors(mol),
+        "h_acceptors": Lipinski.NumHAcceptors(mol),
+        "rotatable_bonds": Descriptors.NumRotatableBonds(mol),
+        "fraction_csp3": rdMolDescriptors.CalcFractionCSP3(mol),
+    }
+
+    charges = compute_gasteiger_stats(mol)
+
+    factory = load_feature_factory()
+    feats = factory.GetFeaturesForMol(mol)
+    pharm = {
+        "n_features": len(feats),
+        "types": sorted({f.GetFamily() for f in feats}),
+    }
+
+    try:
+        qed_val = QED.qed(mol)
+    except Exception:
+        qed_val = None
+
+    lipinski_pass = (
+        physchem["mol_weight"] <= 500
+        and physchem["logp"] <= 5
+        and physchem["h_donors"] <= 5
+        and physchem["h_acceptors"] <= 10
+    )
+
+    lipinski = {
+        "mw_ok": physchem["mol_weight"] <= 500,
+        "logp_ok": physchem["logp"] <= 5,
+        "h_donors_ok": physchem["h_donors"] <= 5,
+        "h_acceptors_ok": physchem["h_acceptors"] <= 10,
+        "pass_": lipinski_pass,
+    }
+
+    fp = compute_morgan_fp(mol)
+    extra = compute_extra_descriptors(mol)
+
+    return {
+        "smiles": smiles,
+        "base": base,
+        "physchem": physchem,
+        "charges": charges,
+        "pharmacophore": pharm,
+        "qed": qed_val,
+        "lipinski": lipinski,
+        "fingerprint": fp,
+        "extra_descriptors": extra,
+    }
+
+# Пример вывода
+if __name__ == "__main__":
+    data = get_molecule_properties("CC(=O)OC1=CC=CC=C1C(=O)O")
+    for section, value in data.items():
+        print(f"\n=== {section.upper()} ===")
+        print(value)

molecule/model.py

@@ -0,0 +1,47 @@
+import numpy as np
+import os
+import torch
+from rdkit import Chem
+from rdkit.Chem import AllChem, DataStructs
+
+def smiles_to_ecfp(smiles, radius=2, n_bits=1024):
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        return np.zeros(n_bits)
+    fp = AllChem.GetMorganFingerprintAsBitVect(mol, radius, nBits=n_bits)
+    arr = np.zeros(n_bits, dtype=int)
+    DataStructs.ConvertToNumpyArray(fp, arr)
+    return arr
+
+class ModelWrapper:
+
+    def __init__(self, model_name: str = None):
+        self.model = None
+    
+        model_name = os.path.join(os.environ.get("MODELS_DIR"), model_name)
+
+        print(model_name)
+
+        if model_name and os.path.exists(model_name):
+            try: 
+                self.model = torch.load(model_name, map_location="cpu", weights_only=False)
+            except Exception as e:
+                print(e)
+                self.model = None
+        print(self.model)
+        self.featurizer = smiles_to_ecfp
+
+    def predict(self, X):
+
+        X = self.featurizer(X)
+        
+        X = np.asarray(X, dtype=float)
+
+        
+
+        # self.model.eval()
+        with torch.no_grad():
+            t = torch.tensor(X, dtype=torch.float32)
+            out = self.model(t)
+            # print(out.cpu().numpy().item())
+            return out.cpu().numpy().item()

molecule/name.py

@@ -0,0 +1,58 @@
+import requests
+from rdkit import Chem
+
+def get_pubchem_name(smiles):
+    url = f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/smiles/{smiles}/property/IUPACName/JSON"
+    r = requests.get(url)
+    if r.status_code == 200:
+        data = r.json()
+        try:
+            cid = data['PropertyTable']['Properties'][0]['CID']
+            url = f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/cid/{cid}/synonyms/JSON"
+            r = requests.get(url)
+            if r.status_code == 200:
+                data = r.json()
+                name = data['InformationList']['Information'][0]['Synonym'][0]
+                return name
+        except (KeyError, IndexError):
+            return None
+    return None
+
+def generate_readable_name(smiles):
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        return "UnknownMolecule"
+    atoms = [atom.GetSymbol() for atom in mol.GetAtoms()]
+    # пример: C-C-O → CCO
+    return "".join(atoms)
+
+def generate_short_signature(smiles, n=6):
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        return "MolX"
+    atoms = [atom.GetSymbol() for atom in mol.GetAtoms()]
+    signature = "".join(atoms[:n])
+    return f"{signature}-{len(atoms)}"
+
+
+def get_name(smiles):
+
+    name = get_pubchem_name(smiles=smiles)
+
+    if name is None:
+        return "UnknownMolecule"
+
+        try:
+            name = generate_readable_name(smiles=smiles)
+        except Exception:
+            return "UnknownMolecule"
+    return name
+
+
+
+if __name__ == '__main__':
+    smiles = "CCC1:C:C:C(CCOC2:C:C:C(CC3SC(=O)NC3=O):C:C:2):N:C:1"
+    print(get_name(smiles))
+    print(generate_readable_name(smiles))
+    print(generate_short_signature(smiles))
+    print(get_pubchem_name(smiles))

molecule/predict.py

@@ -0,0 +1,317 @@
+from .model import ModelWrapper
+import numpy as np
+from rdkit import Chem
+from rdkit.Chem import AllChem, DataStructs
+import shap
+
+def smiles_to_ecfp(smiles, radius=2, n_bits=1024):
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        return np.zeros(n_bits)
+    fp = AllChem.GetMorganFingerprintAsBitVect(mol, radius, nBits=n_bits)
+    arr = np.zeros(n_bits, dtype=int)
+    DataStructs.ConvertToNumpyArray(fp, arr)
+    return arr
+
+models = [
+    ModelWrapper("solubility.pth"),
+    ModelWrapper("logp.pth"),
+    ModelWrapper("clintox.pth"),
+    ModelWrapper("fdaapprov.pth"),
+    ModelWrapper("cardiotoxicity.pth"),
+]
+
+def solubility(X):
+    try:
+        X = smiles_to_ecfp(X)
+        X = np.asarray(X, dtype=float)
+        return models[0].model.predict([X]).item()
+    except Exception as e:
+        print(e)
+        return 0
+
+
+def logp(X):
+    try:
+        X = smiles_to_ecfp(X)
+        X = np.asarray(X, dtype=float)
+        return models[1].model.predict([X]).item()
+    except Exception as e:
+        print(e)
+        return 0
+
+def clintox(X):
+    try:
+        X = smiles_to_ecfp(X)
+        X = np.asarray(X, dtype=float)
+        return models[2].model.predict([X]).item()
+    except Exception as e:
+        print(e)
+        return 0
+
+def fdaapprov(X):
+    try:
+        X = smiles_to_ecfp(X)
+        X = np.asarray(X, dtype=float)
+        return models[3].model.predict([X]).item()
+    except Exception as e:
+        print(e)
+        return 0
+
+def cardiotoxicity(X):
+    try:
+        X = smiles_to_ecfp(X)
+        X = np.asarray(X, dtype=float)
+        return models[4].model.predict([X]).item()
+    except Exception as e:
+        print(e)
+        return 0
+    
+def solubility_shap(X, model_wrapper=models[0]):
+    """
+    Возвращает предсказание растворимости + данные для фронтенда:
+    atom_shap
+    """
+    try:
+        # 1. Morgan FP + bitInfo
+        mol = Chem.MolFromSmiles(X)
+        if mol is None:
+            return {"pred": 0, "atom_shap": [], "fp": [], "bitInfo": {}, "shap_values_bits": []}
+
+        bitInfo = {}
+        fp_vect = AllChem.GetMorganFingerprintAsBitVect(mol, radius=2, nBits=1024, bitInfo=bitInfo)
+        fp = np.zeros(1024, dtype=int)
+        DataStructs.ConvertToNumpyArray(fp_vect, fp)
+
+        # 2. Предсказание модели
+        X_input = np.asarray(fp, dtype=float).reshape(1,-1)
+        pred = model_wrapper.model.predict(X_input).item()
+
+        # 3. SHAP
+        if not hasattr(model_wrapper, "shap_explainer"):
+            # создаем explainer один раз
+            model_wrapper.shap_explainer = shap.TreeExplainer(model_wrapper.model)
+        shap_vals_bits = model_wrapper.shap_explainer.shap_values(X_input)[0]
+
+        # 4. Mapping SHAP -> атомы
+        atom_scores = np.zeros(mol.GetNumAtoms(), dtype=float)
+        for bit, val in enumerate(shap_vals_bits):
+            if bit in bitInfo:
+                atoms = [a for (a,r) in bitInfo[bit]]
+                for a in atoms:
+                    atom_scores[a] += val
+
+        return {
+            "pred": pred,
+            "atom_shap": atom_scores.tolist()
+        }
+
+    except Exception as e:
+        print(e)
+        return {"pred": 0, "atom_shap": []}
+    
+def logp_shap(X, model_wrapper=models[1]):
+    """
+    Возвращает предсказание растворимости + данные для фронтенда:
+    atom_shap
+    """
+    try:
+        # 1. Morgan FP + bitInfo
+        mol = Chem.MolFromSmiles(X)
+        if mol is None:
+            return {"pred": 0, "atom_shap": [], "fp": [], "bitInfo": {}, "shap_values_bits": []}
+
+        bitInfo = {}
+        fp_vect = AllChem.GetMorganFingerprintAsBitVect(mol, radius=2, nBits=1024, bitInfo=bitInfo)
+        fp = np.zeros(1024, dtype=int)
+        DataStructs.ConvertToNumpyArray(fp_vect, fp)
+
+        # 2. Предсказание модели
+        X_input = np.asarray(fp, dtype=float).reshape(1,-1)
+        pred = model_wrapper.model.predict(X_input).item()
+
+        # 3. SHAP
+        if not hasattr(model_wrapper, "shap_explainer"):
+            # создаем explainer один раз
+            model_wrapper.shap_explainer = shap.TreeExplainer(model_wrapper.model)
+        shap_vals_bits = model_wrapper.shap_explainer.shap_values(X_input)[0]
+
+        # 4. Mapping SHAP -> атомы
+        atom_scores = np.zeros(mol.GetNumAtoms(), dtype=float)
+        for bit, val in enumerate(shap_vals_bits):
+            if bit in bitInfo:
+                atoms = [a for (a,r) in bitInfo[bit]]
+                for a in atoms:
+                    atom_scores[a] += val
+
+        return {
+            "pred": pred,
+            "atom_shap": atom_scores.tolist()
+        }
+
+    except Exception as e:
+        print(e)
+        return {"pred": 0, "atom_shap": []}
+    
+def clintox_shap(X, model_wrapper=models[2]):
+    """
+    Возвращает предсказание ��астворимости + данные для фронтенда:
+    atom_shap
+    """
+    try:
+        # 1. Morgan FP + bitInfo
+        mol = Chem.MolFromSmiles(X)
+        if mol is None:
+            return {"pred": 0, "atom_shap": [], "fp": [], "bitInfo": {}, "shap_values_bits": []}
+
+        bitInfo = {}
+        fp_vect = AllChem.GetMorganFingerprintAsBitVect(mol, radius=2, nBits=1024, bitInfo=bitInfo)
+        fp = np.zeros(1024, dtype=int)
+        DataStructs.ConvertToNumpyArray(fp_vect, fp)
+
+        # 2. Предсказание модели
+        X_input = np.asarray(fp, dtype=float).reshape(1,-1)
+        pred = model_wrapper.model.predict(X_input).item()
+
+        # 3. SHAP
+        if not hasattr(model_wrapper, "shap_explainer"):
+            # создаем explainer один раз
+            model_wrapper.shap_explainer = shap.TreeExplainer(model_wrapper.model)
+        shap_vals_bits = model_wrapper.shap_explainer.shap_values(X_input)[0]
+
+        # 4. Mapping SHAP -> атомы
+        atom_scores = np.zeros(mol.GetNumAtoms(), dtype=float)
+        for bit, val in enumerate(shap_vals_bits):
+            if bit in bitInfo:
+                atoms = [a for (a,r) in bitInfo[bit]]
+                for a in atoms:
+                    atom_scores[a] += val
+
+        return {
+            "pred": pred,
+            "atom_shap": atom_scores.tolist()
+        }
+
+    except Exception as e:
+        print(e)
+        return {"pred": 0, "atom_shap": []}
+    
+def fdaapprov_shap(X, model_wrapper=models[3]):
+    """
+    Возвращает предсказание растворимости + данные для фронтенда:
+    atom_shap
+    """
+    try:
+        # 1. Morgan FP + bitInfo
+        mol = Chem.MolFromSmiles(X)
+        if mol is None:
+            return {"pred": 0, "atom_shap": [], "fp": [], "bitInfo": {}, "shap_values_bits": []}
+
+        bitInfo = {}
+        fp_vect = AllChem.GetMorganFingerprintAsBitVect(mol, radius=2, nBits=1024, bitInfo=bitInfo)
+        fp = np.zeros(1024, dtype=int)
+        DataStructs.ConvertToNumpyArray(fp_vect, fp)
+
+        # 2. Предсказание модели
+        X_input = np.asarray(fp, dtype=float).reshape(1,-1)
+        pred = model_wrapper.model.predict(X_input).item()
+
+        # 3. SHAP
+        if not hasattr(model_wrapper, "shap_explainer"):
+            # создаем explainer один раз
+            model_wrapper.shap_explainer = shap.TreeExplainer(model_wrapper.model)
+        shap_vals_bits = model_wrapper.shap_explainer.shap_values(X_input)[0]
+
+        # 4. Mapping SHAP -> атомы
+        atom_scores = np.zeros(mol.GetNumAtoms(), dtype=float)
+        for bit, val in enumerate(shap_vals_bits):
+            if bit in bitInfo:
+                atoms = [a for (a,r) in bitInfo[bit]]
+                for a in atoms:
+                    atom_scores[a] += val
+
+        return {
+            "pred": pred,
+            "atom_shap": atom_scores.tolist()
+        }
+
+    except Exception as e:
+        print(e)
+        return {"pred": 0, "atom_shap": []}
+    
+
+def cardiotoxicity_shap(X, model_wrapper=models[4]):
+    """
+    Возвращает предсказание растворимости + данные для фронтенда:
+    atom_shap
+    """
+    try:
+        # 1. Morgan FP + bitInfo
+        mol = Chem.MolFromSmiles(X)
+        if mol is None:
+            return {"pred": 0, "atom_shap": [], "fp": [], "bitInfo": {}, "shap_values_bits": []}
+
+        bitInfo = {}
+        fp_vect = AllChem.GetMorganFingerprintAsBitVect(mol, radius=2, nBits=1024, bitInfo=bitInfo)
+        fp = np.zeros(1024, dtype=int)
+        DataStructs.ConvertToNumpyArray(fp_vect, fp)
+
+        # 2. Предсказание модели
+        X_input = np.asarray(fp, dtype=float).reshape(1,-1)
+        pred = model_wrapper.model.predict(X_input).item()
+
+        # 3. SHAP
+        if not hasattr(model_wrapper, "shap_explainer"):
+            # создаем explainer один раз
+            model_wrapper.shap_explainer = shap.TreeExplainer(model_wrapper.model)
+        shap_vals_bits = model_wrapper.shap_explainer.shap_values(X_input)[0]
+
+        # 4. Mapping SHAP -> атомы
+        atom_scores = np.zeros(mol.GetNumAtoms(), dtype=float)
+        for bit, val in enumerate(shap_vals_bits):
+            if bit in bitInfo:
+                atoms = [a for (a,r) in bitInfo[bit]]
+                for a in atoms:
+                    atom_scores[a] += val
+
+        return {
+            "pred": pred,
+            "atom_shap": atom_scores.tolist()
+        }
+
+    except Exception as e:
+        print(e)
+        return {"pred": 0, "atom_shap": []}
+
+
+property_predictors = {
+    "solubility": solubility,
+    "logp": logp,
+    "clintox": clintox,
+    "fdaapprov": fdaapprov,
+    "cardiotoxicity": cardiotoxicity,
+}
+
+property_predictors_shap = {
+    "solubility": solubility_shap,
+    "logp": logp_shap,
+    "clintox": clintox_shap,
+    "fdaapprov": fdaapprov_shap,
+    "cardiotoxicity": cardiotoxicity_shap,
+}
+
+
+def predict(X, shap=False):
+    props = {}
+    try:
+        if shap:
+            for property in property_predictors_shap.keys():
+                props[property] = property_predictors_shap[property](X)
+            return props
+        else:
+            for property in property_predictors.keys():
+                props[property] = property_predictors[property](X)
+            return props
+    except Exception as e:
+        print(e)
+        return None

requirements.txt

@@ -0,0 +1,10 @@
+fastapi
+uvicorn[standard]
+numpy
+joblib
+torch
+rdkit
+xgboost
+scikit-learn
+shap
+requests