def testDetails(self):
Crippen._Init()
with open(self.detailName, 'rb') as inF:
if 0:
outF = open('tmp.pkl', 'wb+')
self._writeDetailFile(inF, outF)
self._doDetailFile(inF)
def testIssue80(self):
from rdkit.Chem import Lipinski
m = Chem.MolFromSmiles('CCOC')
ref = Crippen.MolLogP(m)
Lipinski.NHOHCount(m)
probe = Crippen.MolLogP(m)
self.failUnless(probe == ref)
def canonicalize(smi_list, showprogress=False):
mol_list = []
if showprogress:
print('Canonicalising mols')
for smi in tqdm(smi_list):
mol = MolFromSmiles(smi)
if mol is not None:
mol_list.append(MolToSmiles(mol))
else:
for smi in smi_list:
mol = MolFromSmiles(smi)
if mol is not None:
mol_list.append(MolToSmiles(mol))
mol_list = list(set(mol_list))
final_list = []
if showprogress:
print('Size of unfiltered final library: {}'.format(len(mol_list)))
print('Filtering by n_heavy and logP:')
for smi in tqdm(mol_list):
mol = MolFromSmiles(smi)
n_heavy = mol.GetNumHeavyAtoms()
if n_heavy > 17:
logP = Crippen.MolLogP(mol)
if logP <= 5:
final_list.append(smi)
else:
for smi in mol_list:
mol = MolFromSmiles(smi)
n_heavy = mol.GetNumHeavyAtoms()
if n_heavy > 17:
logP = Crippen.MolLogP(mol)
if logP <= 5:
final_list.append(smi)
return final_list
def check_ligand(file_path):
bool = False
if os.path.isfile(file_path):
suppl = Chem.SDMolSupplier(file_path)
for mol in suppl:
if mol is not None:
# components of rule
hydrogen_bond_doner = True if Lipinski.NumHDonors(
mol) <= 5 else False
hydrogen_bond_acceptors = True if Lipinski.NumHAcceptors(
mol) <= 10 else False
molecular_mass = True if Descriptors.ExactMolWt(
mol) <= 500 else False
octanol_water_partition_coefficient_logP = True if Crippen.MolLogP(
mol) <= 5 else False
components_rank = hydrogen_bond_doner + hydrogen_bond_acceptors + molecular_mass + octanol_water_partition_coefficient_logP
# variants
partition_coefficient_logP = True if -0.4 <= Crippen.MolLogP(
mol) <= 5.6 else False
molar_refractivity = True if 40 <= Crippen.MolMR(
mol) <= 130 else False
molecular_weight = True if 180 <= Descriptors.ExactMolWt(
mol) <= 500 else False
number_of_atoms = True if 20 <= Lipinski.HeavyAtomCount(
mol) <= 70 else False
polar_surface_area = True if MolSurf.TPSA(
mol) <= 140 else False
variants_rank = partition_coefficient_logP + molar_refractivity + molecular_weight + number_of_atoms + polar_surface_area
if (components_rank == 4) and (variants_rank == 4
or variants_rank == 5):
bool = True
return bool
def pySlogP_VSA_(mol, bins=None, force=1):
""" *Internal Use Only*
"""
if not force:
try:
res = mol._slogpVSA
except AttributeError:
pass
else:
if res.all():
return res
if bins is None:
bins = logpBins
Crippen._Init()
propContribs = Crippen._GetAtomContribs(mol, force=force)
volContribs = _LabuteHelper(mol)
ans = numpy.zeros(len(bins) + 1, 'd')
for i in range(len(propContribs)):
prop = propContribs[i]
vol = volContribs[i + 1]
if prop is not None:
bin = bisect.bisect_right(bins, prop[0])
ans[bin] += vol
mol._slogpVSA = ans
return ans
def pySlogP_VSA_(mol,bins=None,force=1):
""" *Internal Use Only*
"""
if not force:
try:
res = mol._slogpVSA
except AttributeError:
pass
else:
if res.all():
return res
if bins is None: bins = logpBins
Crippen._Init()
propContribs = Crippen._GetAtomContribs(mol,force=force)
volContribs = _LabuteHelper(mol)
ans = numpy.zeros(len(bins)+1,'d')
for i in range(len(propContribs)):
prop = propContribs[i]
vol = volContribs[i+1]
if prop is not None:
bin = bisect.bisect_right(bins,prop[0])
ans[bin] += vol
mol._slogpVSA=ans
return ans
def testDetails(self):
Crippen._Init()
with open(self.detailName,'rb') as inF:
if 0:
outF = open('tmp.pkl','wb+')
self._writeDetailFile(inF,outF)
self._doDetailFile(inF)
def testDetails2(self):
Crippen._Init()
inF = open(self.detailName2, 'rb')
if 0:
outF = open('tmp.pkl', 'wb+')
self._writeDetailFile(inF, outF)
self._doDetailFile(inF)
def testDetails2(self):
Crippen._Init()
inF = open(self.detailName2,'rb')
if 0:
outF = open('tmp.pkl','wb+')
self._writeDetailFile(inF,outF)
self._doDetailFile(inF)
def testDetails2(self):
Crippen._Init()
with open(self.detailName2,'r') as inTF:
buf = inTF.read().replace('\r\n', '\n').encode('utf-8')
inTF.close()
with io.BytesIO(buf) as inF:
if 0:
outF = open('tmp.pkl','wb+')
self._writeDetailFile(inF,outF)
self._doDetailFile(inF)
def testDetails2(self):
Crippen._Init()
with open(self.detailName2, 'r') as inTF:
buf = inTF.read().replace('\r\n', '\n').encode('utf-8')
inTF.close()
with io.BytesIO(buf) as inF:
if 0:
outF = open('tmp.pkl', 'wb+')
self._writeDetailFile(inF, outF)
self._doDetailFile(inF)
def _doDetailFile(self, inF, nFailsAllowed=1):
done = 0
verbose = 0
nFails = 0
while not done:
if verbose: print '---------------'
try:
smi, refContribs = cPickle.load(inF)
except EOFError:
done = 1
else:
refContribs = [x[0] for x in refContribs]
refOrder = numpy.argsort(refContribs)
try:
mol = Chem.MolFromSmiles(smi)
except:
import traceback
traceback.print_exc()
mol = None
if mol:
mol = Chem.AddHs(mol, 1)
smi2 = Chem.MolToSmiles(mol)
contribs = Crippen._GetAtomContribs(mol)
contribs = [x[0] for x in contribs]
#
# we're comparing to the old results using the oelib code.
# Since we have some disagreements with them as to what is
# aromatic and what isn't, we may have different numbers of
# Hs. For the sake of comparison, just pop those off our
# new results.
#
while len(contribs) > len(refContribs):
del contribs[-1]
order = numpy.argsort(contribs)
for i in range(len(refContribs)):
refL = refContribs[refOrder[i]]
l = contribs[order[i]]
if not feq(refL, l):
print '%s (%s): %d %6.5f != %6.5f' % (
smi, smi2, order[i], refL, l)
Crippen._GetAtomContribs(mol, force=1)
print '-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*'
nFails += 1
break
self.failUnless(nFails < nFailsAllowed)
else:
print 'Problems with SMILES:', smi
def run_filter(self, mol):
"""
This runs a Ghose filter for drug-likeliness. Ghose filter filters
molecules by Molecular weight (MW), the number of atoms, and the logP
value.
We protonate the mol in this filter because hydrogens affect
atom count. Our Ghose implementation counts hydrogens in against
the total number of atoms.
To pass the filter a molecule must be:
MW between 160 and 480 dalton
Number of Atoms: between 20 and 70
logP between -0,4 and +5,6
Inputs:
:param rdkit.Chem.rdchem.Mol object mol: An rdkit mol object to be
tested if it passes the filters
Returns:
:returns: bool bool: True if the mol passes the filter; False if it
fails the filter
"""
# Make a copy of the mol so we can AddHs without affecting other filters
# number of atoms is altered by the presence/absence of hydrogens.
# Our Ghose filter counts hydrogenss towards atom count
copy_mol = copy.deepcopy(mol)
copy_mol = Chem.AddHs(copy_mol)
exact_mwt = Descriptors.ExactMolWt(copy_mol)
if ((exact_mwt < 160) or (exact_mwt > 480)):
return False
num_atoms = copy_mol.GetNumAtoms()
if ((num_atoms < 20) or (num_atoms > 70)):
return False
# molar Refractivity
MolMR = Crippen.MolMR(copy_mol)
if ((MolMR < 40) or (MolMR > 130)):
return False
# molar LogP
mol_log_p = Crippen.MolLogP(copy_mol)
if ((mol_log_p < -0.4) or (mol_log_p > 5.6)):
return False
# passed all filters
return True
def logP(smile, train_smiles):
low_logp = -2.10799552492
high_logp = 2.71567964162
logp = Crippen.MolLogP(Chem.MolFromSmiles(smile))
val = remap(logp, low_logp, high_logp)
val = np.clip(logp, 0.0, 1.0)
return val
def logP(smile, train_smiles=None):
low_logp = -2.12178879609
high_logp = 6.0429063424
logp = Crippen.MolLogP(Chem.MolFromSmiles(smile))
val = remap(logp, low_logp, high_logp)
val = np.clip(val, 0.0, 1.0)
return val
def CalculateMolLogP2(mol: Chem.Mol) -> float:
"""Cacluate MolLogP^2.
From Wildman and G. M. Crippen JCICS _39_ 868-873 (1999).
"""
res = Crippen._pyMolLogP(mol)
return round(res * res, 3)
def _testLogPLong2(self):
""" test calculation of Lipinski params
"""
fName = 'PP_descrs_regress.2.csv'
col = 33
self.__testDesc(fName, col, lambda x: Crippen.MolLogP(x, includeHs=1))
def generate(smiles):
moldata = []
for elem in smiles:
mol = Chem.MolFromSmiles(elem)
moldata.append(mol)
baseData = np.arange(1, 1)
i = 0
for mol in moldata:
desc_MolLogP = Crippen.MolLogP(mol)
desc_MolWt = Descriptors.MolWt(mol)
desc_NumRotatableBonds = Lipinski.NumRotatableBonds(mol)
desc_AromaticProportion = getAromaticProportion(mol)
row = np.array([desc_MolLogP,
desc_MolWt,
desc_NumRotatableBonds,
desc_AromaticProportion])
if i == 0:
baseData = row
else:
baseData = np.vstack([baseData, row])
i = i + 1
columnNames = ["MolLogP", "MolWt", "NumRotatableBonds", "AromaticProportion"]
descriptors = pd.DataFrame(data=baseData, columns=columnNames)
return descriptors
def properties_mw_logp(filepaths):
properties = []
for i, fname in enumerate(filepaths):
with open(filepaths[i], 'r') as f:
reader = csv.reader(f)
it = iter(reader)
if not ("generated" in fname):
for row in it:
try:
properties.append([float(row[2]), float(row[3]), i])
except:
print("")
else:
for row in it:
try:
mol = Chem.MolFromSmiles(row[0])
x, y = desc.MolWt(mol), Crippen.MolLogP(mol)
properties.append([x, y, i])
except:
print("Non-Canonical SMILES: " + row[0])
df = pd.DataFrame(properties[2000:2355], columns=['MW', 'logP', 'Label'])
return df
def testRepeat(self):
self._readData()
nMols = len(self.smis)
for i in range(nMols):
smi = self.smis[i]
mol = Chem.MolFromSmiles(smi)
clog = self.clogs[i]
tmp = Crippen.MolLogP(mol)
tmp = Crippen.MolLogP(mol)
self.failUnless(feq(clog,tmp),'bad logp fooutF,r %s: %4.4f != %4.4f'%(smi,clog,tmp))
mr = self.mrs[i]
tmp = Crippen.MolMR(mol)
tmp = Crippen.MolMR(mol)
self.failUnless(feq(mr,tmp),'bad MR for %s: %4.4f != %4.4f'%(smi,mr,tmp))
def get_properties(mols):
properties = []
for mol in tqdm(mols):
molwt = Descriptors.MolWt(mol)
logp = Crippen.MolLogP(mol)
properties.append((molwt, logp))
return properties
def get_filter_values(mol):
"""
calculate the values, for a given molecule, that are used to filter
return as a dictionary
"""
assert isinstance(mol, Chem.Mol)
values = {}
values["MW"] = desc.CalcExactMolWt(mol)
values["logP"] = crip.MolLogP(mol)
values["HBA"] = lip.NumHAcceptors(mol)
values["HBD"] = lip.NumHDonors(mol)
values["tPSA"] = desc.CalcTPSA(mol)
values["rot_bonds"] = lip.NumRotatableBonds(mol)
values["rigid_bonds"] = mol.GetNumBonds() - values["rot_bonds"] # assume mutual exclusion
values["num_rings"] = lip.RingCount(mol)
values["num_hetero_atoms"] = lip.NumHeteroatoms(mol)
values["charge"] = rdmolops.GetFormalCharge(mol) # trusting this charge calculation method
values["num_carbons"], values["num_charges"], values["max_ring_size"] = get_atom_props(mol)
try:
values["hc_ratio"] = float(values["num_hetero_atoms"]) / float(values["num_carbons"])
except ZeroDivisionError:
values["hc_ratio"] = 100000000 # if there are zero carbons
values["fc"] = len(list(Brics.FindBRICSBonds(mol))) # how many BRICS bonds, related to complexity
values["is_good"] = True # default to true, but not yet observed
atoms = [atom.GetSymbol() for atom in mol.GetAtoms()] # get all the atoms, and make the list unique (only types)
atoms = set(atoms)
atoms = list(atoms)
values["atoms"] = atoms
values["num_chiral_centers"] = len(Chem.FindMolChiralCenters(mol, includeUnassigned=True))
values["rejections"] = [] # empty list to store the reasons for rejection
return values
def LogP(smile):
smile = str(smile)
try:
m = Chem.MolFromSmiles(smile)
return Crippen.MolLogP(m)
except:
return 'NaN'
def ProcessMol(mol,typeConversions,globalProps,nDone,nameProp='_Name',nameCol='compound_id',
redraw=False,keepHs=False,
skipProps=False,addComputedProps=False,
skipSmiles=False,
uniqNames=None,namesSeen=None):
if not mol:
raise ValueError('no molecule')
if keepHs:
Chem.SanitizeMol(mol)
try:
nm = mol.GetProp(nameProp)
except KeyError:
nm = None
if not nm:
nm = 'Mol_%d'%nDone
if uniqNames and nm in namesSeen:
logger.error('duplicate compound id (%s) encountered. second instance skipped.'%nm)
return None
namesSeen.add(nm)
row = [nm]
if not skipProps:
if addComputedProps:
nHD=Lipinski.NumHDonors(mol)
mol.SetProp('DonorCount',str(nHD))
nHA=Lipinski.NumHAcceptors(mol)
mol.SetProp('AcceptorCount',str(nHA))
nRot=Lipinski.NumRotatableBonds(mol)
mol.SetProp('RotatableBondCount',str(nRot))
MW=Descriptors.MolWt(mol)
mol.SetProp('AMW',str(MW))
logp=Crippen.MolLogP(mol)
mol.SetProp('MolLogP',str(logp))
pns = list(mol.GetPropNames())
pD={}
for pi,pn in enumerate(pns):
if pn.lower()==nameCol.lower(): continue
pv = mol.GetProp(pn).strip()
if pv.find('>')<0 and pv.find('<')<0:
colTyp = globalProps.get(pn,2)
while colTyp>0:
try:
tpi = typeConversions[colTyp][1](pv)
except:
colTyp-=1
else:
break
globalProps[pn]=colTyp
pD[pn]=typeConversions[colTyp][1](pv)
else:
pD[pn]=pv
else:
pD={}
if redraw:
AllChem.Compute2DCoords(m)
if not skipSmiles:
row.append(Chem.MolToSmiles(mol,True))
row.append(DbModule.binaryHolder(mol.ToBinary()))
row.append(pD)
return row
def calc_lipinski(self, mol):
"""
Returns: a tuple consisting of:
- a boolean indicating whether the molecule passed Lipinski test
- a dictionary giving the values of the Lipinski check.
NOTE: Lipinski's rules are:
- Hydrogen bond donors <= 5
- Hydrogen bond acceptors <= 10
- Molecular weight < 500 daltons
- logP < 5
"""
num_hdonors = Lipi.NumHDonors(mol)
num_hacceptors = Lipi.NumHAcceptors(mol)
mol_weight = Descriptors.MolWt(mol)
mol_logp = round(Crippen.MolLogP(mol), 4)
return ((num_hdonors <= 5 and num_hacceptors <= 10 and mol_weight < 500
and mol_logp < 5), {
'hydrogen_bond_donors': num_hdonors,
'hydrogen_bond_acceptors': num_hacceptors,
'molecular_weight': mol_weight,
'logp': mol_logp
})
def water_octanol_partition_coefficient_scores(mols, norm=False):
scores = [MolecularMetrics._avoid_sanitization_error(lambda: Crippen.MolLogP(mol)) if mol is not None else None
for mol in mols]
scores = np.array(list(map(lambda x: -3 if x is None else x, scores)))
scores = np.clip(MolecularMetrics.remap(scores, -2.12178879609, 6.0429063424), 0.0, 1.0) if norm else scores
return scores
def properties(mol):
"""
Calculates the properties that are required to calculate the QED descriptor.
"""
if mol is None:
raise ValueError('You need to provide a mol argument.')
mol = Chem.RemoveHs(mol)
qedProperties = QEDproperties(
MW=rdmd._CalcMolWt(mol),
ALOGP=Crippen.MolLogP(mol),
HBA=sum(
len(mol.GetSubstructMatches(pattern)) for pattern in Acceptors
if mol.HasSubstructMatch(pattern)),
HBD=rdmd.CalcNumHBD(mol),
PSA=MolSurf.TPSA(mol),
ROTB=rdmd.CalcNumRotatableBonds(mol,
rdmd.NumRotatableBondsOptions.Strict),
AROM=Chem.GetSSSR(Chem.DeleteSubstructs(Chem.Mol(mol),
AliphaticRings)),
ALERTS=sum(1 for alert in StructuralAlerts
if mol.HasSubstructMatch(alert)),
)
# The replacement
# AROM=Lipinski.NumAromaticRings(mol),
# is not identical. The expression above tends to count more rings
# N1C2=CC=CC=C2SC3=C1C=CC4=C3C=CC=C4
# OC1=C(O)C=C2C(=C1)OC3=CC(=O)C(=CC3=C2C4=CC=CC=C4)O
# CC(C)C1=CC2=C(C)C=CC2=C(C)C=C1 uses 2, should be 0 ?
return qedProperties
def _doDetailFile(self,inF,nFailsAllowed=1):
done = 0
verbose=0
nFails=0
while not done:
if verbose: print('---------------')
try:
smi,refContribs = cPickle.load(inF)
except EOFError:
done = 1
else:
refContribs = [x[0] for x in refContribs]
refOrder= numpy.argsort(refContribs)
try:
mol = Chem.MolFromSmiles(smi)
except:
import traceback
traceback.print_exc()
mol = None
if mol:
mol=Chem.AddHs(mol,1)
smi2 = Chem.MolToSmiles(mol)
contribs = Crippen._GetAtomContribs(mol)
contribs = [x[0] for x in contribs]
#
# we're comparing to the old results using the oelib code.
# Since we have some disagreements with them as to what is
# aromatic and what isn't, we may have different numbers of
# Hs. For the sake of comparison, just pop those off our
# new results.
#
while len(contribs)>len(refContribs):
del contribs[-1]
order = numpy.argsort(contribs)
for i in range(len(refContribs)):
refL = refContribs[refOrder[i]]
l = contribs[order[i]]
if not feq(refL,l):
print('%s (%s): %d %6.5f != %6.5f'%(smi,smi2,order[i],refL,l))
Crippen._GetAtomContribs(mol,force=1)
print('-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*')
nFails +=1
break;
else:
print('Problems with SMILES:',smi)
self.assertTrue(nFails<nFailsAllowed)
def logP(mol, train_smiles=None):
val = Crippen.MolLogP(mol)
if NORMALIZE:
low_logp = -2.12178879609
high_logp = 6.0429063424
val = remap(val, low_logp, high_logp)
val = np.clip(val, 0.0, 1.0)
return val
def _rdkit_eval(entry: dict) -> dict:
"""Computes the chemical properties from RDKit,
adds them to the input dictionary"""
mol = Chem.MolFromSmiles(entry['smiles'])
entry['logP'] = Crippen.MolLogP(mol)
entry['QED'] = QED.qed(mol)
entry['SA_score'] = calculateScore(mol)
return entry
def PhyChem(smiles):
""" Calculating the 19D physicochemical descriptors for each molecules,
the value has been normalized with Gaussian distribution.
Arguments:
smiles (list): list of SMILES strings.
Returns:
props (ndarray): m X 19 matrix as normalized PhysChem descriptors.
m is the No. of samples
"""
props = []
for smile in smiles:
mol = Chem.MolFromSmiles(smile)
try:
MW = desc.MolWt(mol)
LOGP = Crippen.MolLogP(mol)
HBA = Lipinski.NumHAcceptors(mol)
HBD = Lipinski.NumHDonors(mol)
rotable = Lipinski.NumRotatableBonds(mol)
amide = AllChem.CalcNumAmideBonds(mol)
bridge = AllChem.CalcNumBridgeheadAtoms(mol)
heteroA = Lipinski.NumHeteroatoms(mol)
heavy = Lipinski.HeavyAtomCount(mol)
spiro = AllChem.CalcNumSpiroAtoms(mol)
FCSP3 = AllChem.CalcFractionCSP3(mol)
ring = Lipinski.RingCount(mol)
Aliphatic = AllChem.CalcNumAliphaticRings(mol)
aromatic = AllChem.CalcNumAromaticRings(mol)
saturated = AllChem.CalcNumSaturatedRings(mol)
heteroR = AllChem.CalcNumHeterocycles(mol)
TPSA = MolSurf.TPSA(mol)
valence = desc.NumValenceElectrons(mol)
mr = Crippen.MolMR(mol)
# charge = AllChem.ComputeGasteigerCharges(mol)
prop = [
MW, LOGP, HBA, HBD, rotable, amide, bridge, heteroA, heavy,
spiro, FCSP3, ring, Aliphatic, aromatic, saturated, heteroR,
TPSA, valence, mr
]
except Exception:
print(smile)
prop = [0] * 19
props.append(prop)
props = np.array(props)
props = Scaler().fit_transform(props)
return props
def testLipinskiLong(self):
""" Lipinski parameter """
if not doLong:
raise unittest.SkipTest('long test')
fName = 'PP_descrs_regress.csv'
self.__testDesc(fName, 30, Lipinski.NumHDonors)
self.__testDesc(fName, 31, Lipinski.NumHeteroatoms)
self.__testDesc(fName, 32, Lipinski.NumRotatableBonds)
self.__testDesc(fName, 33, lambda x: Crippen.MolLogP(x, includeHs=1))
fName = 'Block_regress.Lip.csv'
self.__testDesc(fName, 1, Lipinski.NumHAcceptors)
self.__testDesc(fName, 2, Lipinski.NumHDonors)
self.__testDesc(fName, 3, Lipinski.NumHeteroatoms)
self.__testDesc(fName, 4, Lipinski.NumRotatableBonds)
fName = 'PP_descrs_regress.2.csv'
self.__testDesc(fName, 33, lambda x: Crippen.MolLogP(x, includeHs=1))
def mole_proper(mol):
num_hdonors = Lipinski.NumHDonors(mol)
num_hacceptors = Lipinski.NumHAcceptors(mol)
num_rotatable = Lipinski.NumRotatableBonds(mol)
mol_weight = Descriptors.MolWt(mol)
mol_logp = Crippen.MolLogP(mol)
mol_TPSA = Descriptors.TPSA(mol)
proper = (num_hdonors, num_hacceptors, num_rotatable, mol_weight, mol_logp,
mol_TPSA)
return proper
def evaluate_chem_mol(mol):
try:
Chem.GetSSSR(mol)
clogp = Crippen.MolLogP(mol)
mw = MolDescriptors.CalcExactMolWt(mol)
tpsa = Descriptors.TPSA(mol)
ret_val = [True, 320 < mw < 420, 2 < clogp < 3, 40 < tpsa < 60]
except:
ret_val = [False] * 4
return ret_val
def log_partition_coefficient(smiles):
'''
Returns the octanol-water partition coefficient given a molecule SMILES
string
'''
try:
mol = Chem.MolFromSmiles(smiles)
except Exception as e:
raise SmilesError('%s returns a None molecule' % smiles)
return Crippen.MolLogP(mol)
def pyPEOE_VSA_(mol, bins=None, force=1):
""" *Internal Use Only*
"""
if not force:
try:
res = mol._peoeVSA
except AttributeError:
pass
else:
if res.all():
return res
if bins is None:
bins = chgBins
Crippen._Init()
#print('\ts:',repr(mol.GetMol()))
#print('\t\t:',len(mol.GetAtoms()))
rdPartialCharges.ComputeGasteigerCharges(mol)
#propContribs = [float(x.GetProp('_GasteigerCharge')) for x in mol.GetAtoms()]
propContribs = []
for at in mol.GetAtoms():
p = at.GetProp('_GasteigerCharge')
try:
v = float(p)
except ValueError:
v = 0.0
propContribs.append(v)
#print '\tp',propContribs
volContribs = _LabuteHelper(mol)
#print '\tv',volContribs
ans = numpy.zeros(len(bins) + 1, 'd')
for i in range(len(propContribs)):
prop = propContribs[i]
vol = volContribs[i + 1]
if prop is not None:
bin = bisect.bisect_right(bins, prop)
ans[bin] += vol
mol._peoeVSA = ans
return ans
def _writeDetailFile(self, inF, outF):
while 1:
try:
smi, refContribs = pickle.load(inF)
except EOFError:
break
else:
mol = Chem.MolFromSmiles(smi)
if mol:
mol = Chem.AddHs(mol, 1)
smi2 = Chem.MolToSmiles(mol)
contribs = Crippen._GetAtomContribs(mol)
pickle.dump((smi, contribs), outF)
else:
print('Problems with SMILES:', smi)
def CalculateMolMR(mol):
"""
#################################################################
Cacluation of molecular refraction value based on Crippen method
---->MR
Usage:
result=CalculateMolMR(mol)
Input: mol is a molecule object.
Output: result is a numeric value.
#################################################################
"""
return round(Crippen._pyMolMR(mol),3)
def runIt(inFileName, outFileName, smiCol=0, maxMols=-1, delim=','):
inF = gzip.open(inFileName, 'r')
outF = open(outFileName, 'wb+')
mols = []
nDone = 0
for line in inF.readlines():
if line[0] != '#':
splitL = line.strip().split(delim)
smi = splitL[smiCol].strip()
print(smi)
mol = Chem.MolFromSmiles(smi)
if mol:
contribs = Crippen._GetAtomContribs(mol)
cPickle.dump((smi, contribs), outF)
nDone += 1
if maxMols > 0 and nDone >= maxMols:
break
outF.close()
def CalculateMolLogP2(mol):
"""
#################################################################
Cacluation of LogP^2 value based on Crippen method
---->LogP2
Usage:
result=CalculateMolLogP2(mol)
Input: mol is a molecule object.
Output: result is a numeric value.
#################################################################
"""
res=Crippen._pyMolLogP(mol)
return round(res**2,3)
def _writeDetailFile(self,inF,outF):
while 1:
try:
smi,refContribs = cPickle.load(inF)
except EOFError:
break
else:
try:
mol = Chem.MolFromSmiles(smi)
except:
import traceback
traceback.print_exc()
mol = None
if mol:
mol=Chem.AddHs(mol,1)
smi2 = Chem.MolToSmiles(mol)
contribs = Crippen._GetAtomContribs(mol)
cPickle.dump((smi,contribs),outF)
else:
print 'Problems with SMILES:',smi
from __future__ import print_function
from rdkit import RDConfig
import gzip
import os.path
from rdkit.six.moves import cPickle
from rdkit import Chem
from rdkit.Chem import Crippen
Crippen._Init()
def runIt(inFileName, outFileName, smiCol=0, maxMols=-1, delim=','):
inF = gzip.open(inFileName, 'r')
outF = open(outFileName, 'wb+')
mols = []
nDone = 0
for line in inF.readlines():
if line[0] != '#':
splitL = line.strip().split(delim)
smi = splitL[smiCol].strip()
print(smi)
mol = Chem.MolFromSmiles(smi)
if mol:
contribs = Crippen._GetAtomContribs(mol)
cPickle.dump((smi, contribs), outF)
nDone += 1
if maxMols > 0 and nDone >= maxMols:
break
outF.close()
if __name__ == '__main__':
