feat: implement RdKit based np likeliness score

app/config.py

@@ -1,10 +1,12 @@
 from pydantic import BaseSettings, Field, PostgresDsn
 
+
 class Settings(BaseSettings):
     PGPASSWORD: str = Field(..., env="PGPASSWORD")
     POSTGRES_DB: str = Field(..., env="POSTGRES_DB")
     POSTGRES_USER: str = Field(..., env="POSTGRES_USER")
     POSTGRES_PASSWORD: str = Field(..., env="POSTGRES_PASSWORD")
     POSTGRES_PORT: str = Field(..., env="POSTGRES_PORT")
 
-settings = Settings()
+
+settings = Settings()

app/database.py

@@ -1,6 +1,7 @@
 from .config import settings
 import psycopg2
 
+
 class Database:
     def __init__(self):
         self.conn = self.connect()
@@ -12,16 +13,17 @@ def connect(self):
         print("Connecting to PostgreSQL Database...")
         try:
             conn = psycopg2.connect(
-                host = 'pgsql',
-                dbname = settings.POSTGRES_DB,
-                user = settings.POSTGRES_USER,
-                password = settings.POSTGRES_PASSWORD,
-                port = settings.POSTGRES_PORT
+                host="pgsql",
+                dbname=settings.POSTGRES_DB,
+                user=settings.POSTGRES_USER,
+                password=settings.POSTGRES_PASSWORD,
+                port=settings.POSTGRES_PORT,
             )
         except psycopg2.OperationalError as e:
             print(f"Could not connect to Database: {e}")
             sys.exit(1)
 
         return conn
 
-db = Database()
+
+db = Database()

app/main.py

@@ -1,13 +1,12 @@
 from fastapi import Depends, FastAPI
+
 # from .config import settings
 from .routers import converters, chem, compose
 from fastapi.middleware.cors import CORSMiddleware
 
 app = FastAPI()
 
-origins = [
-    "*"
-]
+origins = ["*"]
 
 app.add_middleware(
     CORSMiddleware,
@@ -19,4 +18,4 @@
 
 app.include_router(converters.router)
 app.include_router(chem.router)
-app.include_router(compose.router)
+app.include_router(compose.router)

app/routers/chem.py

@@ -1,9 +1,13 @@
-from fastapi import  Request, APIRouter, Depends, HTTPException
+from fastapi import Request, APIRouter, Depends, HTTPException
 from typing import Optional
 from rdkit import Chem
+
 # from ..database import db
 from fastapi_pagination import Page, add_pagination, paginate
-from rdkit.Chem.EnumerateStereoisomers import EnumerateStereoisomers, StereoEnumerationOptions
+from rdkit.Chem.EnumerateStereoisomers import (
+    EnumerateStereoisomers,
+    StereoEnumerationOptions,
+)
 from chembl_structure_pipeline import standardizer
 from fastapi.responses import JSONResponse
 from rdkit.Chem.Scaffolds import MurckoScaffold
@@ -18,9 +22,10 @@
     responses={404: {"description": "Not found"}},
 )
 
+
 @router.get("/")
 async def chem_index():
-    return  {"message": "Hello Chem Router!"}
+    return {"message": "Hello Chem Router!"}
 
 
 @router.get("/{smiles}/mol")
@@ -30,55 +35,63 @@ async def smiles_mol(smiles: str):
         return Chem.MolToMolBlock(m)
     else:
         return None
-    
+
 
 @router.get("/{smiles}/convert")
 async def smiles_convert(smiles: str):
     if smiles:
         m = Chem.MolFromSmiles(smiles)
         response = {}
-        response['mol'] = Chem.MolToMolBlock(m)
-        response['cannonicalsmiles'] = Chem.MolToSmiles(m)
-        response['inchi'] = Chem.inchi.MolToInchi(m)
-        response['inchikey'] = Chem.inchi.MolToInchiKey(m)
+        response["mol"] = Chem.MolToMolBlock(m)
+        response["cannonicalsmiles"] = Chem.MolToSmiles(m)
+        response["inchi"] = Chem.inchi.MolToInchi(m)
+        response["inchikey"] = Chem.inchi.MolToInchiKey(m)
         return response
     else:
         return None
-
+
+
 @router.get("/{smiles}/stereoisomers")
 async def smiles_stereoisomers(smiles: Optional[str]):
     m = Chem.MolFromSmiles(smiles)
     isomers = tuple(EnumerateStereoisomers(m))
     smilesArray = []
-    for smi in sorted(Chem.MolToSmiles(x,isomericSmiles=True) for x in isomers):
+    for smi in sorted(Chem.MolToSmiles(x, isomericSmiles=True) for x in isomers):
         smilesArray.append(smi)
     return smilesArray
 
+
 @router.get("/search/{smiles}")
 async def smiles_search(smiles: Optional[str]):
     if smiles:
         curs = db.connect().cursor()
-        curs.execute("select id, standard_inchi from mols where smiles@>'"+smiles+"' limit 5;")
+        curs.execute(
+            "select id, standard_inchi from mols where smiles@>'"
+            + smiles
+            + "' limit 5;"
+        )
         rows = paginate(curs.fetchall())
         return rows
-
+
+
 @router.post("/standardise")
 async def standardise_mol(request: Request):
     body = await request.json()
-    mol = body['mol']
+    mol = body["mol"]
     if mol:
         standardised_mol = standardizer.standardize_molblock(mol)
         rdkit_mol = Chem.MolFromMolBlock(standardised_mol)
         smiles = Chem.MolToSmiles(rdkit_mol)
         response = {}
-        response['standardised_mol'] = standardised_mol
-        response['cannonical_smiles'] = smiles
-        response['inchi'] = Chem.inchi.MolToInchi(rdkit_mol)
-        response['inchikey'] = Chem.inchi.MolToInchiKey(rdkit_mol)
+        response["standardised_mol"] = standardised_mol
+        response["cannonical_smiles"] = smiles
+        response["inchi"] = Chem.inchi.MolToInchi(rdkit_mol)
+        response["inchikey"] = Chem.inchi.MolToInchiKey(rdkit_mol)
         core = MurckoScaffold.GetScaffoldForMol(rdkit_mol)
-        response['murcko_scaffold'] = Chem.MolToSmiles(core)
+        response["murcko_scaffold"] = Chem.MolToSmiles(core)
         return response
-
+
+
 @router.get("/{smiles}/descriptors")
 async def smiles_descriptors(smiles: Optional[str]):
     if smiles:
@@ -91,18 +104,24 @@ async def smiles_iupac(smiles: Optional[str]):
     if smiles:
         iupac = translate_forward(smiles)
         return iupac
-    
+
 
 @router.post("/iupac/smiles")
 async def standardise_mol(request: Request):
     body = await request.json()
-    query = body['query']
+    query = body["query"]
     if query:
         return translate_reverse(query)
-
+
+
+@router.get("/{smiles}/npscore")
+async def nplikeliness_score(smiles: Optional[str]):
+    if smiles:
+        np_score = getnp_score(smiles)
+        return np_score
+
+
 # @app.get("/molecules/", response_model=List[schemas.Molecule])
 # def read_molecules(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
 #     molecules = crud.get_molecules(db, skip=skip, limit=limit)
 #     return molecules
-
-