def generate_molecule_from_smiles(smiles, name=None):
"""
Parameters
----------
smiles : str
The canonical isomeric SMILES string.
name : str, optional, default=None
If specified, the molecule title will be set to this; if not, the IUPAC name will be assigned.
"""
# Generate a molecule from canonical isomeric SMILES.
molecule = oechem.OEMol()
if not oechem.OEParseSmiles(molecule, smiles):
raise ValueError("The supplied SMILES '%s' could not be parsed." %
smiles)
# Assign aromaticity.
oechem.OEAssignAromaticFlags(molecule, oechem.OEAroModelOpenEye)
# Add hydrogens.
oechem.OEAddExplicitHydrogens(molecule)
# Set title.
if name is None:
# Set title to IUPAC name.
name = oeiupac.OECreateIUPACName(molecule)
molecule.SetTitle(name)
# Check for any missing atom names, if found reassign all of them.
if any([atom.GetName() == '' for atom in molecule.GetAtoms()]):
oechem.OETriposAtomNames(molecule)
return molecule
def create_molecule_from_smiles(smiles):
"""
Create an ``OEMol`` molecule from a smiles pattern.
.. todo:: Replace with the toolkit function when finished.
Parameters
----------
smiles : str
Smiles pattern
Returns
-------
molecule : OEMol
OEMol with 3D coordinates, but no charges
"""
from openeye import oechem, oeomega
# Check cache
if smiles in _cached_molecules:
return copy.deepcopy(_cached_molecules[smiles])
# Create molecule from smiles.
molecule = oechem.OEMol()
parse_smiles_options = oechem.OEParseSmilesOptions(quiet=True)
if not oechem.OEParseSmiles(molecule, smiles, parse_smiles_options):
logging.warning('Could not parse SMILES: ' + smiles)
return False
# Normalize molecule
oechem.OEAssignAromaticFlags(molecule, oechem.OEAroModelOpenEye)
oechem.OEAddExplicitHydrogens(molecule)
# oechem.OETriposAtomNames(molecule)
# Create configuration
omega = oeomega.OEOmega()
omega.SetMaxConfs(1)
omega.SetIncludeInput(False)
omega.SetCanonOrder(False)
omega.SetSampleHydrogens(True)
omega.SetStrictStereo(True)
omega.SetStrictAtomTypes(False)
status = omega(molecule)
if not status:
logging.warning('Could not generate a conformer for ' + smiles)
return False
_cached_molecules[smiles] = molecule
return molecule
def getoutput(self, smi):
mol = oe.OEGraphMol()
msgstream.clear()
ok = oe.OEParseSmiles(mol, smi)
if not ok:
msg = msgstream.str().decode("utf-8")
if "Kekul" in msg:
return None, "Kekulization_failure"
else:
return None, "Parse_error"
return [atom.GetImplicitHCount() for atom in mol.GetAtoms()], None
def test_MDL_aromaticity(verbose=False):
"""Test support for alternate aromaticity models."""
ffxml = StringIO(ffxml_MDL_contents)
ff = ForceField(ffxml)
from openeye import oechem
mol = oechem.OEMol()
oechem.OEParseSmiles(mol, 'c12c(cccc1)occ2')
oechem.OEAddExplicitHydrogens(mol)
labels = ff.labelMolecules([mol], verbose=True)
# The bond 6-7 should get the b16 parameter iff the MDL model is working, otherwise it will pick up just the generic
details = labels[0]['HarmonicBondGenerator']
found = False
for (atom_indices, pid, smirks) in details:
if pid == 'b16' and atom_indices == [6, 7]:
found = True
if not found: raise Exception("Didn't find right param.")
def test_drug_bank_oe(input, output):
"""
Parameters
----------
input
output
Returns
-------
"""
mol = oechem.OEMol()
oechem.OEParseSmiles(mol, input)
assert cmiles.utils.mol_to_smiles(mol,
mapped=True,
isomeric=True,
explicit_hydrogen=True) == output
def test_parameter_completeness_check(self):
"""Test that proper exceptions are raised if a force field fails to assign parameters to valence terms in a molecule."""
from openeye import oechem
mol = oechem.OEMol()
oechem.OEParseSmiles(mol, 'CCC')
oechem.OEAddExplicitHydrogens(mol)
oechem.OETriposAtomNames(mol)
ff = ForceField(get_data_filename('forcefield/Frosst_AlkEthOH.ffxml'))
topology = generateTopologyFromOEMol(mol)
# Test nonbonded error checking by wiping out required LJ parameter
params = ff.getParameter(paramID='n0001')
params['smirks'] = '[#136:1]'
ff.setParameter(paramID='n0001', params=params)
ff.setParameter(paramID='n0002', params=params)
with self.assertRaises(Exception):
system = ff.createSystem(topology, [mol])
ff = ForceField(get_data_filename('forcefield/Frosst_AlkEthOH.ffxml'))
# Test bond error checking by wiping out a required bond parameter
params = ff.getParameter(paramID='b0001')
params['smirks'] = '[#136:1]~[*:2]'
ff.setParameter(paramID='b0001', params=params)
with self.assertRaises(Exception):
system = ff.createSystem(topology, [mol])
ff = ForceField(get_data_filename('forcefield/Frosst_AlkEthOH.ffxml'))
# Test angle error checking by wiping out a required angle parameter
params = ff.getParameter(paramID='a0001')
params['smirks'] = '[#136:1]~[*:2]~[*:3]'
ff.setParameter(paramID='a0001', params=params)
with self.assertRaises(Exception):
system = ff.createSystem(topology, [mol])
ff = ForceField(get_data_filename('forcefield/Frosst_AlkEthOH.ffxml'))
# Test torsion error checking by wiping out a required torsion parameter
params = ff.getParameter(paramID='t0001')
params['smirks'] = '[#136:1]~[*:2]~[*:3]~[*:4]'
ff.setParameter(paramID='t0001', params=params)
ff.setParameter(paramID='t0004', params=params)
with self.assertRaises(Exception):
system = ff.createSystem(topology, [mol])
ff = ForceField(get_data_filename('forcefield/Frosst_AlkEthOH.ffxml'))
def standardizeSmiles(self, smiles, type="ISOMERIC"): # pylint: disable=redefined-builtin
""" Return a standardized SMILES (type) or None
"""
smilesOut = None
try:
mol = oechem.OEGraphMol()
if (oechem.OEParseSmiles(mol, smiles) == 1):
oechem.OEAssignAromaticFlags(mol)
if type == "CANNONICAL":
smilesOut = oechem.OECreateCanSmiString(mol)
elif type == "ISOMERIC":
smilesOut = oechem.OECreateIsoSmiString(mol)
else:
logger.error("Unable to parse input SMILES '%s'", smiles)
except Exception as e:
logger.exception("Error '%s' occured. Arguments %s.", str(e), e.args)
return smilesOut
def test_molecule_labeling(verbose=False):
"""Test using labelMolecules to see which parameters applied to an oemol."""
from openeye import oechem
mol = oechem.OEMol()
oechem.OEParseSmiles(mol, 'CCC')
oechem.OEAddExplicitHydrogens(mol)
ff = ForceField(get_data_filename('forcefield/Frosst_AlkEthOH.ffxml'))
labels = ff.labelMolecules([mol], verbose=verbose)
# Check that force terms aren't empty
print(labels[0].keys())
if not 'HarmonicBondGenerator' in labels[0].keys():
raise Exception("No force term assigned for harmonic bonds.")
if not 'HarmonicAngleGenerator' in labels[0].keys():
raise Exception("No force term assigned for harmonic angles.")
if not 'PeriodicTorsionGenerator' in labels[0].keys():
raise Exception("No force term assigned for periodic torsions.")
if not 'NonbondedGenerator' in labels[0].keys():
raise Exception("No nonbonded force term assigned.")
def smiles_to_oemol(smiles):
"""Create a OEMolBuilder from a smiles string.
Parameters
----------
smiles : str
SMILES representation of desired molecule.
Returns
-------
molecule : OEMol
A normalized molecule with desired smiles string.
"""
molecule = oechem.OEMol()
if not oechem.OEParseSmiles(molecule, smiles):
raise ValueError("The supplied SMILES '%s' could not be parsed." % smiles)
molecule = normalize_molecule(molecule)
return molecule
def smilesToMol(self, smiles, limitPerceptions=False, messageTag=None):
"""Parse the input SMILES string and return a molecule object (OeGraphMol).
Args:
smiles (str): SMILES string
limitPerceptions (bool): flag to limit the perceptions/transformations of input SMILES
Returns:
object: OeGraphMol() object or None for failure
"""
try:
label = messageTag if messageTag else ""
mol = oechem.OEGraphMol()
smiles.strip()
if limitPerceptions:
# convert the SMILES string into a molecule
if oechem.OEParseSmiles(mol, smiles, False, False):
return mol
else:
logger.debug(
"%s parsing failed for input SMILES string %s", label,
smiles)
logger.error("%s parsing failed for input SMILES string",
label)
else:
if oechem.OESmilesToMol(mol, smiles):
return mol
else:
logger.debug(
"%s converting failed for input SMILES string %s",
label, smiles)
logger.error(
"%s converting failed for input SMILES string", label)
except Exception as e:
logger.exception("Failing with %s", str(e))
return None
def create_molecule_from_smiles(smiles, number_of_conformers=1):
"""
Create an ``OEMol`` molecule from a smiles pattern.
.. todo:: Replace with the toolkit function when finished.
Parameters
----------
smiles : str
The smiles pattern to create the molecule from.
number_of_conformers: int
The number of conformers to generate for the molecule using Omega.
Returns
-------
molecule : OEMol
OEMol with no charges, and a number of conformers as specified
by `number_of_conformers`
"""
from openeye import oechem, oeomega
# Check cache
if (number_of_conformers, smiles) in _cached_molecules:
return copy.deepcopy(_cached_molecules[(number_of_conformers, smiles)])
# Create molecule from smiles.
molecule = oechem.OEMol()
parse_smiles_options = oechem.OEParseSmilesOptions(quiet=True)
if not oechem.OEParseSmiles(molecule, smiles, parse_smiles_options):
logging.warning('Could not parse SMILES: ' + smiles)
return None
# Normalize molecule
oechem.OEAssignAromaticFlags(molecule, oechem.OEAroModelOpenEye)
oechem.OEAddExplicitHydrogens(molecule)
# Create configuration
if number_of_conformers > 0:
omega = oeomega.OEOmega()
omega.SetMaxConfs(number_of_conformers)
omega.SetIncludeInput(False)
omega.SetCanonOrder(False)
omega.SetSampleHydrogens(True)
omega.SetStrictStereo(True)
omega.SetStrictAtomTypes(False)
status = omega(molecule)
if not status:
logging.warning('Could not generate a conformer for ' + smiles)
return None
_cached_molecules[(number_of_conformers, smiles)] = molecule
return molecule
#!/usr/bin/env python
# (C) 2017 OpenEye Scientific Software Inc. All rights reserved.
#
# TERMS FOR USE OF SAMPLE CODE The software below ("Sample Code") is
# provided to current licensees or subscribers of OpenEye products or
# SaaS offerings (each a "Customer").
# Customer is hereby permitted to use, copy, and modify the Sample Code,
# subject to these terms. OpenEye claims no rights to Customer's
# modifications. Modification of Sample Code is at Customer's sole and
# exclusive risk. Sample Code may require Customer to have a then
# current license or subscription to the applicable OpenEye offering.
# THE SAMPLE CODE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED. OPENEYE DISCLAIMS ALL WARRANTIES, INCLUDING, BUT
# NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
# PARTICULAR PURPOSE AND NONINFRINGEMENT. In no event shall OpenEye be
# liable for any damages or liability in connection with the Sample Code
# or its use.
# @ <SNIPPET>
from __future__ import print_function
from openeye import oechem
mol = oechem.OEGraphMol()
oechem.OEParseSmiles(mol, "c1ccccc1")
print("Number of benzene atoms:", mol.NumAtoms())
oechem.OEParseSmiles(mol, "c1ccccc1O")
print("Number of phenol atoms:", mol.NumAtoms())
# @ </SNIPPET>
def smiles_to_pdf(smiles, file_path, rows=10, columns=6):
"""Creates a PDF file containing images of a list of molecules
described by their SMILES patterns.
Parameters
----------
smiles: list of str or tuple of str
The SMILES patterns of the molecules. The list can either contain
a list of single SMILES strings, or a tuple of SMILES strings. If
tuples of SMILES are provided, these smiles will be grouped together
in the output. All tuples in the list must have the same length.
file_path: str
The file path to save the pdf to.
rows: int
The maximum number of rows of molecules to include per page.
columns: int
The maximum number of molecules to include per row.
"""
assert len(smiles) > 0
# Validate the input type.
assert all(isinstance(x, str)
for x in smiles) or all(isinstance(x, tuple) for x in smiles)
# Make sure the smiles tuples are the same length.
molecules_per_group = 1
if isinstance(smiles[0], tuple):
assert (len(x) == len(smiles[0]) for x in smiles)
molecules_per_group = len(smiles[0])
# Convert the list of tuple to list of strings.
if isinstance(smiles[0], tuple):
smiles = [".".join(sorted(x)) for x in smiles]
# Create OEMol objects for each unique smiles pattern provided.
oe_molecules = {}
unique_smiles = set(smiles)
for smiles_pattern in unique_smiles:
molecule = oechem.OEMol()
oechem.OEParseSmiles(molecule, smiles_pattern)
oe_molecules[smiles_pattern] = molecule
# Take into account that each group may have more than one molecule
columns = int(math.floor(columns / molecules_per_group))
report_options = oedepict.OEReportOptions(rows, columns)
report_options.SetHeaderHeight(25)
report_options.SetFooterHeight(25)
report_options.SetCellGap(4)
report_options.SetPageMargins(10)
report = oedepict.OEReport(report_options)
cell_width, cell_height = report.GetCellWidth(), report.GetCellHeight()
display_options = oedepict.OE2DMolDisplayOptions(
cell_width, cell_height, oedepict.OEScale_Default * 0.5)
display_options.SetAromaticStyle(oedepict.OEAromaticStyle_Circle)
pen = oedepict.OEPen(oechem.OEBlack, oechem.OEBlack, oedepict.OEFill_On,
1.0)
display_options.SetDefaultBondPen(pen)
interface = oechem.OEInterface()
oedepict.OESetup2DMolDisplayOptions(display_options, interface)
for i, smiles_pattern in enumerate(smiles):
cell = report.NewCell()
oe_molecule = oechem.OEMol(oe_molecules[smiles_pattern])
oedepict.OEPrepareDepiction(oe_molecule, False, True)
display = oedepict.OE2DMolDisplay(oe_molecule, display_options)
oedepict.OERenderMolecule(cell, display)
oedepict.OEWriteReport(file_path, report)
def cluster_similar_molecules(
smiles, fingerprint_type=oegraphsim.OEFPType_Tree, eps=0.5, min_samples=2
):
"""The method attempts to cluster a sets of molecules based on their
similarity using a Tanimoto distance metric and the `sklearn` DBSCAN
clustering code.
Notes
-----
This is based on the code by David Mobley:
https://github.com/openforcefield/release-1-benchmarking/blob/master/QM_molecule_selection/divide_sets.ipynb
Parameters
----------
smiles: list of str
The SMILES representations of the molecules to cluster.
fingerprint_type
The type of molecular fingerprint to use.
eps: float
The `eps` parameter to pass as an argument to DBSCAN while clustering.
min_samples: int
The `min_samples` parameter to pass as an argument to DBSCAN while
clustering.
Returns
-------
dict of str and list of str
The clustered SMILES patterns.
"""
assert isinstance(smiles, list)
# Build fingerprints
fingerprints = {}
for smiles_pattern in smiles:
oe_molecule = oechem.OEMol()
oechem.OEParseSmiles(oe_molecule, smiles_pattern)
fingerprint = oegraphsim.OEFingerPrint()
oegraphsim.OEMakeFP(fingerprint, oe_molecule, fingerprint_type)
fingerprints[smiles_pattern] = fingerprint
# Build a similarity matrix
distance_matrix = np.zeros((len(smiles), len(smiles)))
for i, smiles_i in enumerate(smiles):
for j, smiles_j in enumerate(smiles):
if i == j:
continue
distance_matrix[i, j] = 1.0 - oegraphsim.OETanimoto(
fingerprints[smiles_i], fingerprints[smiles_j]
)
# Cluster the data
clustering = DBSCAN(eps=eps, min_samples=min_samples, metric="precomputed")
clustered_smiles = clustering.fit(distance_matrix)
labels = clustered_smiles.labels_
smiles_by_cluster = {}
for label in set(labels):
smiles_by_cluster[label] = [
smiles[i] for i, x in enumerate(labels) if x == label
]
return smiles_by_cluster
def smiles2mol(self, smiles):
mol = oechem.OEGraphMol()
oechem.OEParseSmiles(mol, smiles)
return mol
def getoutput(self, smi):
mol = oe.OEGraphMol()
ok = oe.OEParseSmiles(mol, smi)
assert ok
return oe.OECreateSmiString(mol, flags)
#
# TERMS FOR USE OF SAMPLE CODE The software below ("Sample Code") is
# provided to current licensees or subscribers of OpenEye products or
# SaaS offerings (each a "Customer").
# Customer is hereby permitted to use, copy, and modify the Sample Code,
# subject to these terms. OpenEye claims no rights to Customer's
# modifications. Modification of Sample Code is at Customer's sole and
# exclusive risk. Sample Code may require Customer to have a then
# current license or subscription to the applicable OpenEye offering.
# THE SAMPLE CODE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED. OPENEYE DISCLAIMS ALL WARRANTIES, INCLUDING, BUT
# NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
# PARTICULAR PURPOSE AND NONINFRINGEMENT. In no event shall OpenEye be
# liable for any damages or liability in connection with the Sample Code
# or its use.
# @ <SNIPPET>
from __future__ import print_function
from openeye import oechem
mol = oechem.OEGraphMol()
if not oechem.OEParseSmiles(mol, "C1=CC=CC=C1"):
print("SMILES string was invalid!")
print("Number of aromatic atoms =",
oechem.OECount(mol, oechem.OEIsAromaticAtom()))
oechem.OEAssignAromaticFlags(mol)
print("Number of aromatic atoms =",
oechem.OECount(mol, oechem.OEIsAromaticAtom()))
# @ </SNIPPET>
# SaaS offerings (each a "Customer").
# Customer is hereby permitted to use, copy, and modify the Sample Code,
# subject to these terms. OpenEye claims no rights to Customer's
# modifications. Modification of Sample Code is at Customer's sole and
# exclusive risk. Sample Code may require Customer to have a then
# current license or subscription to the applicable OpenEye offering.
# THE SAMPLE CODE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED. OPENEYE DISCLAIMS ALL WARRANTIES, INCLUDING, BUT
# NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
# PARTICULAR PURPOSE AND NONINFRINGEMENT. In no event shall OpenEye be
# liable for any damages or liability in connection with the Sample Code
# or its use.
# @ <SNIPPET>
from openeye import oechem
qmol = oechem.OEQMol()
oechem.OEParseSmarts(qmol, "c1cc[o,n,s]c1")
qscreen = oechem.OESubSearchScreen()
oechem.OEMakeSubSearchQueryScreen(qscreen, qmol, oechem.OESubSearchScreenType_SMARTS)
tmol = oechem.OEGraphMol()
oechem.OEParseSmiles(tmol, "c1ccoc1")
tscreen = oechem.OESubSearchScreen()
oechem.OEMakeSubSearchTargetScreen(tscreen, tmol, oechem.OESubSearchScreenType_MDL)
if oechem.OESameSubSearchScreenTypes(qscreen, tscreen):
print("same screen types")
else:
print("different screen types")
# @ </SNIPPET>
# TERMS FOR USE OF SAMPLE CODE The software below ("Sample Code") is
# provided to current licensees or subscribers of OpenEye products or
# SaaS offerings (each a "Customer").
# Customer is hereby permitted to use, copy, and modify the Sample Code,
# subject to these terms. OpenEye claims no rights to Customer's
# modifications. Modification of Sample Code is at Customer's sole and
# exclusive risk. Sample Code may require Customer to have a then
# current license or subscription to the applicable OpenEye offering.
# THE SAMPLE CODE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED. OPENEYE DISCLAIMS ALL WARRANTIES, INCLUDING, BUT
# NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
# PARTICULAR PURPOSE AND NONINFRINGEMENT. In no event shall OpenEye be
# liable for any damages or liability in connection with the Sample Code
# or its use.
# @ <SNIPPET>
from __future__ import print_function
from openeye import oechem
import sys
mol = oechem.OEGraphMol()
for smi in sys.stdin:
mol.Clear()
smi = smi.strip()
if oechem.OEParseSmiles(mol, smi):
oechem.OEAssignAromaticFlags(mol)
print(oechem.OECreateCanSmiString(mol))
else:
oechem.OEThrow.Warning("%s is an invalid SMILES!" % smi)
# @ </SNIPPET>
# exclusive risk. Sample Code may require Customer to have a then
# current license or subscription to the applicable OpenEye offering.
# THE SAMPLE CODE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED. OPENEYE DISCLAIMS ALL WARRANTIES, INCLUDING, BUT
# NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
# PARTICULAR PURPOSE AND NONINFRINGEMENT. In no event shall OpenEye be
# liable for any damages or liability in connection with the Sample Code
# or its use.
# @ <SNIPPET>
from __future__ import print_function
from openeye import oechem
# @ <SNIPPET-AROM-PERCEIVE>
mol = oechem.OEGraphMol()
oechem.OEParseSmiles(mol, "C1[NH]C=CC=1CO")
oechem.OEAssignAromaticFlags(mol)
# @ </SNIPPET-AROM-PERCEIVE>
# @ <SNIPPET-AROM-LOOP1>
for atom in mol.GetAtoms(oechem.OEIsAromaticAtom()):
print(atom.GetIdx(), oechem.OEGetAtomicSymbol(atom.GetAtomicNum()))
# @ </SNIPPET-AROM-LOOP1>
# @ <SNIPPET-AROM-LOOP2>
for atom in mol.GetAtoms():
if atom.IsAromatic():
print(atom.GetIdx(), oechem.OEGetAtomicSymbol(atom.GetAtomicNum()))
# @ </SNIPPET-AROM-LOOP2>
# @ </SNIPPET>
#!/usr/bin/env python
# (C) 2017 OpenEye Scientific Software Inc. All rights reserved.
#
# TERMS FOR USE OF SAMPLE CODE The software below ("Sample Code") is
# provided to current licensees or subscribers of OpenEye products or
# SaaS offerings (each a "Customer").
# Customer is hereby permitted to use, copy, and modify the Sample Code,
# subject to these terms. OpenEye claims no rights to Customer's
# modifications. Modification of Sample Code is at Customer's sole and
# exclusive risk. Sample Code may require Customer to have a then
# current license or subscription to the applicable OpenEye offering.
# THE SAMPLE CODE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED. OPENEYE DISCLAIMS ALL WARRANTIES, INCLUDING, BUT
# NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
# PARTICULAR PURPOSE AND NONINFRINGEMENT. In no event shall OpenEye be
# liable for any damages or liability in connection with the Sample Code
# or its use.
# @ <SNIPPET>
from __future__ import print_function
from openeye import oechem
mol = oechem.OEGraphMol()
oechem.OEParseSmiles(mol, "n1ccncc1")
print("Canonical smiles :", oechem.OECreateCanSmiString(mol))
oechem.OEClearAromaticFlags(mol)
oechem.OEKekulize(mol)
print("Kekule smiles :", oechem.OECreateCanSmiString(mol))
# @ </SNIPPET>
def getoutput(self, smi):
mol = oe.OEGraphMol()
ok = oe.OEParseSmiles(mol, smi)
assert ok
oe.OEAssignAromaticFlags(mol)
return oe.OECreateSmiString(mol, 0)
# exclusive risk. Sample Code may require Customer to have a then
# current license or subscription to the applicable OpenEye offering.
# THE SAMPLE CODE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED. OPENEYE DISCLAIMS ALL WARRANTIES, INCLUDING, BUT
# NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
# PARTICULAR PURPOSE AND NONINFRINGEMENT. In no event shall OpenEye be
# liable for any damages or liability in connection with the Sample Code
# or its use.
# @ <SNIPPET>
from __future__ import print_function
from openeye import oechem
# @ <SNIPPET-DATA-ITER>
mol = oechem.OEGraphMol()
oechem.OEParseSmiles(mol, "C1CCCC(C(=O)O)C1")
activitytag = oechem.OEGetTag("activity")
mol.AddData(activitytag, "antiarthritic")
mol.AddData(activitytag, "antiinflammatory")
mol.SetData("weight", oechem.OECalculateMolecularWeight(mol))
for gdata in mol.GetDataIter():
print(oechem.OEGetTag(gdata.GetTag()), gdata.GetData())
# @ </SNIPPET-DATA-ITER>
# @ <SNIPPET-DATA-ITER-WITH-TAG>
for gdata in mol.GetDataIter(oechem.OEGetTag("activity")):
print(oechem.OEGetTag(gdata.GetTag()), gdata.GetData())
# @ </SNIPPET-DATA-ITER-WITH-TAG>
# @ </SNIPPET>
