|
|
|
|
|
"""
|
|
|
Created on Thu Sep 5 21:42:51 2024
|
|
|
|
|
|
@author: BM109X32G-10GPU-02
|
|
|
"""
|
|
|
|
|
|
from langchain.tools import BaseTool
|
|
|
from rdkit import Chem
|
|
|
from rdkit.Chem import rdMolDescriptors
|
|
|
from rdkit.Chem import Descriptors
|
|
|
from utils import *
|
|
|
from rdkit.Chem import RDConfig
|
|
|
from rdkit.ML.Descriptors import MoleculeDescriptors
|
|
|
|
|
|
from rdkit.Contrib.SA_Score import sascorer
|
|
|
|
|
|
|
|
|
class MolSimilarity(BaseTool):
|
|
|
name: str = "MolSimilarity"
|
|
|
description: str = (
|
|
|
"Input two molecule SMILES (separated by '.'), returns Tanimoto similarity."
|
|
|
)
|
|
|
|
|
|
def __init__(self):
|
|
|
super().__init__()
|
|
|
|
|
|
def _run(self, smiles_pair: str) -> str:
|
|
|
smi_list = smiles_pair.split(".")
|
|
|
if len(smi_list) != 2:
|
|
|
return "Input error, please input two smiles strings separated by '.'"
|
|
|
else:
|
|
|
smiles1, smiles2 = smi_list
|
|
|
|
|
|
similarity = tanimoto(smiles1, smiles2)
|
|
|
|
|
|
if isinstance(similarity, str):
|
|
|
return similarity
|
|
|
|
|
|
if similarity == 1:
|
|
|
return "Error: Input Molecules Are Identical"
|
|
|
else:
|
|
|
|
|
|
message = f"The Tanimoto similarity between {smiles1} and {smiles2} is {round(similarity, 4)}"
|
|
|
return message
|
|
|
|
|
|
async def _arun(self, smiles_pair: str) -> str:
|
|
|
"""Use the tool asynchronously."""
|
|
|
raise NotImplementedError()
|
|
|
|
|
|
|
|
|
class SMILES2Weight(BaseTool):
|
|
|
name: str = "SMILES2Weight"
|
|
|
description: str = "Input SMILES, returns molecular weight."
|
|
|
|
|
|
def __init__(
|
|
|
self,
|
|
|
):
|
|
|
super().__init__()
|
|
|
|
|
|
def _run(self, smiles: str) -> str:
|
|
|
mol = Chem.MolFromSmiles(smiles)
|
|
|
if mol is None:
|
|
|
return "Invalid SMILES string"
|
|
|
mol_weight = rdMolDescriptors.CalcExactMolWt(mol)
|
|
|
return mol_weight
|
|
|
|
|
|
async def _arun(self, smiles: str) -> str:
|
|
|
"""Use the tool asynchronously."""
|
|
|
raise NotImplementedError()
|
|
|
|
|
|
class SMILES2LogP(BaseTool):
|
|
|
name: str = "SMILES2LogP"
|
|
|
description: str = "Input SMILES, returns molecular LogP."
|
|
|
|
|
|
def __init__(
|
|
|
self,
|
|
|
):
|
|
|
super().__init__()
|
|
|
|
|
|
def _run(self, smiles: str) -> str:
|
|
|
mol = Chem.MolFromSmiles(smiles)
|
|
|
if mol is None:
|
|
|
return "Invalid SMILES string"
|
|
|
MolLogP = Descriptors.MolLogP(mol)
|
|
|
return MolLogP
|
|
|
|
|
|
async def _arun(self, smiles: str) -> str:
|
|
|
"""Use the tool asynchronously."""
|
|
|
raise NotImplementedError()
|
|
|
|
|
|
class SMILES2SAScore(BaseTool):
|
|
|
name: str = "SMILES2SAScore"
|
|
|
description: str = "Input SMILES, returns synthetic accessibility score to evaluate the difficulty of molecular synthesis."
|
|
|
|
|
|
def __init__(
|
|
|
self,
|
|
|
):
|
|
|
super().__init__()
|
|
|
|
|
|
def _run(self, smiles: str) -> str:
|
|
|
mol = Chem.MolFromSmiles(smiles)
|
|
|
if mol is None:
|
|
|
return "Invalid SMILES string"
|
|
|
SAScore = sascorer.calculateScore(mol)
|
|
|
return f"This SAScore of the molecule is {SAScore}."
|
|
|
|
|
|
async def _arun(self, smiles: str) -> str:
|
|
|
"""Use the tool asynchronously."""
|
|
|
raise NotImplementedError()
|
|
|
|
|
|
class SMILES2Properties(BaseTool):
|
|
|
name: str = "SMILES2Properties"
|
|
|
description: str = "Input SMILES, returns basic physical and chemical properties."
|
|
|
|
|
|
def __init__(
|
|
|
self,
|
|
|
):
|
|
|
super().__init__()
|
|
|
|
|
|
def _run(self, smiles: str) -> str:
|
|
|
mol = Chem.MolFromSmiles(smiles)
|
|
|
if mol is None:
|
|
|
return "Invalid SMILES string"
|
|
|
SAScore = sascorer.calculateScore(mol)
|
|
|
des_list = ['MolWt','NOCount', 'NumHAcceptors', 'NumHDonors', 'MolLogP', 'NumRotatableBonds','RingCount','NumAromaticRings','TPSA']
|
|
|
calculator = MoleculeDescriptors.MolecularDescriptorCalculator(des_list)
|
|
|
results = calculator.CalcDescriptors(mol)
|
|
|
|
|
|
|
|
|
return f"SAScore: {'{:.2f}'.format(SAScore)}; molecular weight: {'{:.2f}'.format(results[0])}; number of Nitrogens and Oxygens: {results[1]}; number of Hydrogen Bond Acceptors: {results[2]}; number of Hydrogen Bond Donors:{results[3]}; LogP:{'{:.2f}'.format(results[4])}; number of Rotatable Bonds: {results[5]}; Ring count: {results[6]}; number of aromatic rings: {results[7]}; TPSA: {'{:.2f}'.format(results[8])}."
|
|
|
|
|
|
async def _arun(self, smiles: str) -> str:
|
|
|
"""Use the tool asynchronously."""
|
|
|
raise NotImplementedError()
|
|
|
|
|
|
class FuncGroups(BaseTool):
|
|
|
name: str = "FunctionalGroups"
|
|
|
description: str = "Input SMILES, return list of functional groups in the molecule."
|
|
|
dict_fgs: dict = None
|
|
|
|
|
|
def __init__(
|
|
|
self,
|
|
|
):
|
|
|
super().__init__()
|
|
|
|
|
|
|
|
|
self.dict_fgs = {
|
|
|
"furan": "o1cccc1",
|
|
|
"aldehydes": " [CX3H1](=O)[#6]",
|
|
|
"esters": " [#6][CX3](=O)[OX2H0][#6]",
|
|
|
"ketones": " [#6][CX3](=O)[#6]",
|
|
|
"amides": " C(=O)-N",
|
|
|
"thiol groups": " [SH]",
|
|
|
"alcohol groups": " [OH]",
|
|
|
"methylamide": "*-[N;D2]-[C;D3](=O)-[C;D1;H3]",
|
|
|
"carboxylic acids": "*-C(=O)[O;D1]",
|
|
|
"carbonyl methylester": "*-C(=O)[O;D2]-[C;D1;H3]",
|
|
|
"terminal aldehyde": "*-C(=O)-[C;D1]",
|
|
|
"amide": "*-C(=O)-[N;D1]",
|
|
|
"carbonyl methyl": "*-C(=O)-[C;D1;H3]",
|
|
|
"isocyanate": "*-[N;D2]=[C;D2]=[O;D1]",
|
|
|
"isothiocyanate": "*-[N;D2]=[C;D2]=[S;D1]",
|
|
|
"nitro": "*-[N;D3](=[O;D1])[O;D1]",
|
|
|
"nitroso": "*-[N;R0]=[O;D1]",
|
|
|
"oximes": "*=[N;R0]-[O;D1]",
|
|
|
"Imines": "*-[N;R0]=[C;D1;H2]",
|
|
|
"terminal azo": "*-[N;D2]=[N;D2]-[C;D1;H3]",
|
|
|
"hydrazines": "*-[N;D2]=[N;D1]",
|
|
|
"diazo": "*-[N;D2]#[N;D1]",
|
|
|
"cyano": "*-[C;D2]#[N;D1]",
|
|
|
"primary sulfonamide": "*-[S;D4](=[O;D1])(=[O;D1])-[N;D1]",
|
|
|
"methyl sulfonamide": "*-[N;D2]-[S;D4](=[O;D1])(=[O;D1])-[C;D1;H3]",
|
|
|
"sulfonic acid": "*-[S;D4](=O)(=O)-[O;D1]",
|
|
|
"methyl ester sulfonyl": "*-[S;D4](=O)(=O)-[O;D2]-[C;D1;H3]",
|
|
|
"methyl sulfonyl": "*-[S;D4](=O)(=O)-[C;D1;H3]",
|
|
|
"sulfonyl chloride": "*-[S;D4](=O)(=O)-[Cl]",
|
|
|
"methyl sulfinyl": "*-[S;D3](=O)-[C;D1]",
|
|
|
"methyl thio": "*-[S;D2]-[C;D1;H3]",
|
|
|
"thiols": "*-[S;D1]",
|
|
|
"thio carbonyls": "*=[S;D1]",
|
|
|
"halogens": "*-[#9,#17,#35,#53]",
|
|
|
"t-butyl": "*-[C;D4]([C;D1])([C;D1])-[C;D1]",
|
|
|
"tri fluoromethyl": "*-[C;D4](F)(F)F",
|
|
|
"acetylenes": "*-[C;D2]#[C;D1;H]",
|
|
|
"cyclopropyl": "*-[C;D3]1-[C;D2]-[C;D2]1",
|
|
|
"ethoxy": "*-[O;D2]-[C;D2]-[C;D1;H3]",
|
|
|
"methoxy": "*-[O;D2]-[C;D1;H3]",
|
|
|
"side-chain hydroxyls": "*-[O;D1]",
|
|
|
"ketones": "*=[O;D1]",
|
|
|
"primary amines": "*-[N;D1]",
|
|
|
"nitriles": "*#[N;D1]",
|
|
|
}
|
|
|
|
|
|
def _is_fg_in_mol(self, mol, fg):
|
|
|
fgmol = Chem.MolFromSmarts(fg)
|
|
|
mol = Chem.MolFromSmiles(mol.strip())
|
|
|
return len(Chem.Mol.GetSubstructMatches(mol, fgmol, uniquify=True)) > 0
|
|
|
|
|
|
def _run(self, smiles: str) -> str:
|
|
|
"""
|
|
|
Input a molecule SMILES or name.
|
|
|
Returns a list of functional groups identified by their common name (in natural language).
|
|
|
"""
|
|
|
try:
|
|
|
fgs_in_molec = [
|
|
|
name
|
|
|
for name, fg in self.dict_fgs.items()
|
|
|
if self._is_fg_in_mol(smiles, fg)
|
|
|
]
|
|
|
if len(fgs_in_molec) > 1:
|
|
|
return f"This molecule contains {', '.join(fgs_in_molec[:-1])}, and {fgs_in_molec[-1]}."
|
|
|
else:
|
|
|
return f"This molecule contains {fgs_in_molec[0]}."
|
|
|
except:
|
|
|
return "Wrong argument. Please input a valid molecular SMILES."
|
|
|
|
|
|
async def _arun(self, smiles: str) -> str:
|
|
|
"""Use the tool asynchronously."""
|
|
|
raise NotImplementedError()
|
|
|
|
