def test_embed_r_groups__ROR(bax_mol):
fragment = MolFromMolBlock('''
RDKit 3D
3 2 0 0 0 0 0 0 0 0999 V2000
0.0000 0.0000 0.0000 R 0 0 0 0 0 1 0 0 0 0 0 0
4.4640 1.0880 19.5620 O 0 0 0 0 0 0 0 0 0 0 0 0
0.0000 0.0000 0.0000 R 0 0 0 0 0 1 0 0 0 0 0 0
1 2 1 0
3 2 1 0
M END
''')
embed_r_groups(fragment, bax_mol)
expected = '''
RDKit 3D
3 2 0 0 0 0 0 0 0 0999 V2000
3.7070 1.4910 20.6340 R 0 0 0 0 0 1 0 0 0 0 0 0
4.4640 1.0880 19.5620 O 0 0 0 0 0 0 0 0 0 0 0 0
4.1550 0.2360 18.5580 R 0 0 0 0 0 1 0 0 0 0 0 0
1 2 1 0
3 2 1 0
M END
'''
assert MolToMolBlock(fragment) == expected
def adapt_molblockgz(mol):
"""Convert RDKit molecule to compressed molblock
Args:
mol (rdkit.Chem.Mol): molecule
Returns:
str: Compressed molblock
"""
molblock = MolToMolBlock(mol).encode()
return zlib.compress(molblock)
def __compound_to_dir__(compound):
compounds_dir = __mkd__(f'{compound["Compound Id"]}')
with open('smiles', 'w') as f:
f.write(compound["smiles"])
with open('molfile', 'w') as f:
mol = MolFromSmiles(compound["smiles"])
f.write(MolToMolBlock(mol))
os.chdir(compounds_dir)
comp = ET.SubElement(root, "Compound")
ET.SubElement(comp, "Id").text = compound["Compound Id"]
ET.SubElement(comp, "Cargos").text = "smiles molfile"
def _parseMolData(data):
suppl = SDMolSupplier()
suppl.SetData(str(data), sanitize=False)
data = [x for x in suppl if x]
for x in data:
if not x.HasProp("_drawingBondsWedged"):
SanitizeMol(x)
ctab = MolToMolBlock(x)
ctablines = [item.split("0.0000") for item in ctab.split("\n") if "0.0000" in item]
needs_redraw = 0
for line in ctablines:
if len(line) > 3:
needs_redraw +=1
if needs_redraw == len(ctablines):
#check for overlapping molecules in the CTAB
SanitizeMol(x)
Compute2DCoords(x)
print "testr"
return data
def test0InchiWritePubChem(self):
for fp, f in self.dataset.items():
inchi_db = self.dataset_inchi[fp]
same, diff, reasonable = 0, 0, 0
for m in f:
if m is None: # pragma: nocover
continue
ref_inchi = inchi_db[m.GetProp('PUBCHEM_COMPOUND_CID')]
x, y = MolToInchi(m), ref_inchi
if x != y:
# print("---------------")
# print(m.GetProp('PUBCHEM_COMPOUND_CID'))
# print(MolToSmiles(m))
# print(y)
# print(x)
if re.search(r'.[1-9]?ClO4', x) is not None:
reasonable += 1
continue
SanitizeMol(m)
if filter(lambda i: i >= 8,
[len(r) for r in m.GetRingInfo().AtomRings()]):
reasonable += 1
continue
# THERE ARE NO EXAMPLES FOR THE FOLLOWING (no coverage)
# if it is because RDKit does not think the bond is stereo
z = MolToInchi(MolFromMolBlock(MolToMolBlock(m)))
if y != z and inchiDiffPrefix(y, z) == 'b':
reasonable += 1
continue
# some warning
try:
MolToInchi(m, treatWarningAsError=True)
except InchiReadWriteError as inst:
_, error = inst.args
if 'Metal' in error:
reasonable += 1
continue
diff += 1
print('InChI mismatch for PubChem Compound ' +
m.GetProp('PUBCHEM_COMPOUND_CID'))
print(MolToSmiles(m, True))
print(inchiDiff(x, y))
print()
else:
same += 1
fmt = "\n{0}InChI write Summary: {1} identical, {2} suffix variance, {3} reasonable{4}"
print(fmt.format(COLOR_GREEN, same, diff, reasonable, COLOR_RESET))
self.assertEqual(same, 1162)
self.assertEqual(diff, 0)
self.assertEqual(reasonable, 19)
def calculate_coords(apps, schema_editor):
# We can't import the Person model directly as it may be a newer
# version than this migration expects. We use the historical version.
Batch = apps.get_model("cbh_chembl_model_extension", "CBHCompoundBatch")
for field in Batch.objects.all():
mol = MolFromMolBlock(field.ctab)
AllChem.Compute2DCoords(mol)
try:
field.ctab = MolToMolBlock(mol, includeStereo=True)
except:
print "test"
field.save()
def processline(t, step, line):
global lensum
if t.incr():
return 1
if step == 0:
lensum += len(line)
else:
m = MolFromSmiles(line)
if step == 100:
lensum += len(line)
elif step == 105:
lensum += len(sha256(line).hexdigest())
elif step in (110, 120):
with open(tmpname, 'wb+') as f:
print(line, file=f)
if step == 120:
os.fsync(f.fileno())
lensum += os.stat(tmpname).st_size
elif step == 210:
lensum += m.GetNumAtoms()
elif step == 220:
lensum += m.GetNumBonds()
elif step == 300:
lensum += len(MolToSmiles(m))
elif step == 400:
lensum += len(MolToMolBlock(m))
elif step == 420:
m2 = AddHs(m)
EmbedMolecule(m2, randomSeed=2020)
m2 = RemoveHs(m2)
m2.SetProp("_Name", "test")
lensum += len(MolToMolBlock(m2))
elif step == 600:
lensum += mol2file(m, 'svg')
elif step == 610:
lensum += mol2file(m, 'png')
else:
raise ValueError("Not implemented step " + str(step))
return 0
def generate_smiles(mol, logfile=devnull):
with stdout_redirected(to=logfile, stdout=sys.stderr):
with stdout_redirected(to=logfile, stdout=sys.stdout):
mol2 = Mol(mol)
mol2.SetProp("_Name", "")
molblock = MolToMolBlock(mol2, includeStereo=True)
del mol2
smi, smierr = generate_smiles_openbabel(molblock)
if isinstance(logfile, str):
with open(logfile, 'a') as to_file:
print(smierr, file=to_file)
else:
print(smierr, file=logfile)
return smi
def protonate_molecule(mol_in: Mol, ph=7.4) -> Mol:
molblock_in = MolToMolBlock(mol_in)
babel_mol = pybel.readstring('mol', molblock_in)
babel_mol.OBMol.AddHydrogens(False, True, ph)
molblock_out = babel_mol.write('mol')
mol = MolFromMolBlock(molblock_out, removeHs=False, sanitize=False)
try:
SanitizeMol(mol)
except ValueError:
# Try again, but without ph correction
babel_mol = pybel.readstring('mol', molblock_in)
babel_mol.OBMol.AddHydrogens(False, False)
molblock_out = babel_mol.write('mol')
mol = MolFromMolBlock(molblock_out, removeHs=False, sanitize=False)
SanitizeMol(mol)
return mol
def dump_conformers_sdf(mol, output, conf_ids=None,
energies=None,
renumber=True):
if conf_ids is None:
conformers = mol.GetConformers()
else:
conformers = (mol.GetConformer(conf_id) for conf_id in conf_ids)
# Record state of properties that may be overwritten
original_name = mol.GetProp(RD_NAME)
if energies is not None and mol.HasProp(CONF_ENERGY):
original_energy = mol.GetProp(CONF_ENERGY)
else:
original_energy = None
conformer_names = []
# Render conformers
for idx, conf in enumerate(conformers):
conf_id = conf.GetId()
if renumber:
conf_idx = idx
else:
conf_idx = conf_id
if energies is not None and conf_id in energies:
energy = energies[conf_id]
mol.SetProp(CONF_ENERGY, "{0:0.4f}".format(energy))
conf_name = "{0}_{1}".format(original_name, conf_idx)
mol.SetProp(RD_NAME, conf_name)
conformer_names.append(conf_name)
block = MolToMolBlock(mol, includeStereo=True, confId=conf_id)
print(block, file=output, end="")
print(SDF_MODEL_END, file=output)
# Reset changes to mol properties
mol.SetProp(RD_NAME, original_name)
if original_energy is not None:
mol.SetProp(CONF_ENERGY, original_energy)
else:
mol.ClearProp(CONF_ENERGY)
return conformer_names
def test1InchiReadPubChem(self):
for f in self.dataset.values():
same, diff, reasonable = 0, 0, 0
for m in f:
if m is None: # pragma: nocover
continue
x = MolToInchi(m)
y = None
RDLogger.DisableLog('rdApp.error')
mol = MolFromInchi(x)
RDLogger.EnableLog('rdApp.error')
if mol is not None:
y = MolToInchi(
MolFromSmiles(MolToSmiles(mol, isomericSmiles=True)))
if y is None:
# metal involved?
try:
MolToInchi(m, treatWarningAsError=True)
except InchiReadWriteError as inst:
_, error = inst.args
if 'Metal' in error or \
'Charges were rearranged' in error:
reasonable += 1
continue
# THERE ARE NO EXAMPLES FOR THE FOLLOWING (no coverage)
# RDKit does not like the SMILES? use MolBlock instead
inchiMol = MolFromInchi(x)
if inchiMol:
rdDepictor.Compute2DCoords(inchiMol)
z = MolToInchi(MolFromMolBlock(
MolToMolBlock(inchiMol)))
if x == z:
reasonable += 1
continue
# InChI messed up the radical?
unsanitizedInchiMol = MolFromInchi(x, sanitize=False)
if sum([
a.GetNumRadicalElectrons() * a.GetAtomicNum()
for a in m.GetAtoms()
if a.GetNumRadicalElectrons() != 0
]) != sum([
a.GetNumRadicalElectrons() * a.GetAtomicNum()
for a in unsanitizedInchiMol.GetAtoms()
if a.GetNumRadicalElectrons() != 0
]):
reasonable += 1
continue
diff += 1
cid = m.GetProp('PUBCHEM_COMPOUND_CID')
print(COLOR_GREEN + 'Empty mol for PubChem Compound ' +
cid + '\n' + COLOR_RESET)
continue
if x != y:
# if there was warning in the first place, then this is
# tolerable
try:
MolToInchi(m, treatWarningAsError=True)
MolFromInchi(x, treatWarningAsError=True)
except InchiReadWriteError as inst:
reasonable += 1
continue
# or if there are big rings
SanitizeMol(m)
if filter(lambda i: i >= 8,
[len(r) for r in m.GetRingInfo().AtomRings()]):
reasonable += 1
continue
# THERE ARE NO EXAMPLES FOR THE FOLLOWING (no coverage)
# or if RDKit loses bond stereo
s = MolToSmiles(m, True)
if MolToSmiles(MolFromSmiles(s), True) != s:
reasonable += 1
continue
# or if it is RDKit SMILES writer unhappy about the mol
inchiMol = MolFromInchi(x)
rdDepictor.Compute2DCoords(inchiMol)
z = MolToInchi(MolFromMolBlock(MolToMolBlock(inchiMol)))
if x == z:
reasonable += 1
continue
diff += 1
print(COLOR_GREEN +
'Molecule mismatch for PubChem Compound ' + cid +
COLOR_RESET)
print(inchiDiff(x, y))
print()
else:
same += 1
fmt = "\n{0}InChI read Summary: {1} identical, {2} variance, {3} reasonable variance{4}"
print(fmt.format(COLOR_GREEN, same, diff, reasonable, COLOR_RESET))
self.assertEqual(same, 621)
self.assertEqual(diff, 0)
self.assertEqual(reasonable, 560)
def save(self, force_insert=False, force_update=False, *args, **kwargs):
changed = False
new = not bool(CompoundStructures.objects.filter(pk=self.pk).count())
if settings.OPEN_SOURCE:
if self.molfile:
if not new: # The structure already exists and we only want to modify it
super(CompoundStructures, self).save(force_insert, force_update, *args, **kwargs) # this should trigger CMPD_STR_UPDATE_TRIG, which deletes compound images and properties and nulls standard inchi, key, smiles, and molformula
changed = True
# newInchi = inchiFromPipe(self.molfile, settings.INCHI_BINARIES_LOCATION['1.02'])
#if newInchi != self.standard_inchi:
# self.standard_inchi = newInchi
# changed = True
mol = MolFromInchi(self.standard_inchi.encode("ascii"))
if mol:
# self.canonical_smiles = MolToSmiles(mol)
if not self.standard_inchi:
raise NoStandardInchi("for CompundStructure, pk = " + str(self.pk))
newInchiKey = InchiToInchiKey(self.standard_inchi.encode("ascii"))
if self.standard_inchi_key != newInchiKey:
self.standard_inchi_key = newInchiKey
mol = MolFromInchi(self.standard_inchi.encode("ascii"))
# self.canonical_smiles = MolToSmiles(mol)
changed = True
self.molfile = MolToMolBlock(MolFromMolBlock(str(self.molfile))) # This is how we do kekulisation in RDKit...
self.clean_fields()
self.validate_unique()
super(CompoundStructures, self).save(force_insert, force_update, *args, **kwargs)
else:
if self.molfile:
if not new: # The structure already exists and we only want to modify it
super(CompoundStructures, self).save(force_insert, force_update, *args, **kwargs) # this should trigger CMPD_STR_UPDATE_TRIG, which deletes compound images and properties and nulls standard inchi, key, smiles, and molformula
changed = True
data = getStructure(self.molfile)
newInchi = data['InChI']
if newInchi != self.standard_inchi:
self.standard_inchi = newInchi
self.standard_inchi_key = data['InChIKey']
#self.molformula = data['Molecular_Formula']
self.canonical_smiles = data['Canonical_Smiles']
changed = True
if not self.standard_inchi:
raise NoStandardInchi("for CompundStructure, pk = " + str(self.pk))
if not self.standard_inchi_key:
self.standard_inchi_key = InchiToInchiKey(self.standard_inchi.encode("ascii"))
self.clean_fields()
self.validate_unique()
super(CompoundStructures, self).save(force_insert, force_update, *args, **kwargs)
if changed:
self.molecule.structure_key = self.standard_inchi_key
self.molecule.structure_type = "MOL"
self.molecule.molfile_update = datetime.now()
self.molecule.save()
structureChanged.send(sender=self.__class__, instance=self)
def process(
self,
input_file: str,
output_file: str = "",
output_file_sdf: str = "",
sdf_append: bool = False,
#images_prefix: str = "",
format_output: bool = True,
write_header: bool = True,
osra_output_format: str = "",
output_formats: list = None,
dry_run: bool = False,
csv_delimiter: str = ";",
use_gm: bool = True,
gm_dpi: int = 300,
gm_trim: bool = True,
n_jobs: int = -1,
input_type: str = "",
standardize_mols: bool = True,
annotate: bool = True,
chemspider_token: str = "",
custom_page: int = 0,
continue_on_failure: bool = False) -> OrderedDict:
r"""
Process the input file with OSRA.
Parameters
----------
input_file : str
Path to file to be processed by OSRA.
output_file : str
File to write output in.
output_file_sdf : str
| File to write SDF output in. "sdf" output format hasn't to be in `output_formats` to write SDF output.
| If "sdf_osra" output format is requested, suffix "-osra.sdf" will be added.
sdf_append : bool
If True, append new molecules to existing SDF file or create new one if doesn't exist.
NOT IMPLEMENTED | images_prefix : str
Prefix for images of extracted compounds which will be written.
format_output : bool
| If True, the value of "content" key of returned dict will be list of OrderedDicts.
| If True and `output_file` is set, the CSV file will be written.
| If False, the value of "content" key of returned dict will be None.
write_header : bool
If True and if `output_file` is set and `output_format` is True, write a CSV write_header.
osra_output_format : str
| Output format from OSRA. Temporarily overrides the option `output_format` set during instantiation (in __init__).
| Choices: "smi", "can", "sdf"
| If "sdf", additional information like coordinates cannot be retrieved (not implemented yet).
output_formats : list
| If True and `format_output` is also True, this specifies which molecule formats will be output.
| You can specify more than one format, but only one format from OSRA. This format must be also set with `output_format` in __init__
or with `osra_output_format` here.
| When output produces by OSRA is unreadable by RDKit, you can at least have that output from OSRA.
| Default value: ["smiles"]
+-----------------+--------------+--------------------------------------------------------------------------------------------+
| Value | Source | Note |
+=================+==============+============================================================================================+
| smiles | RDKit | canonical |
+-----------------+--------------+--------------------------------------------------------------------------------------------+
| smiles_osra | OSRA ("smi") | SMILES |
+-----------------+--------------+--------------------------------------------------------------------------------------------+
| smiles_can_osra | OSRA ("can") | canonical SMILES |
+-----------------+--------------+--------------------------------------------------------------------------------------------+
| inchi | RDKit | Not every molecule can be converted to InChI (it doesn`t support wildcard characters etc.) |
+-----------------+--------------+--------------------------------------------------------------------------------------------+
| inchikey | RDKit | The same applies as for "inchi". |
+-----------------+--------------+--------------------------------------------------------------------------------------------+
| sdf | RDKit | If present, an additional SDF file will be created. |
+-----------------+--------------+--------------------------------------------------------------------------------------------+
| sdf_osra | OSRA ("sdf") | If present, an additional SDF file will be created. |
+-----------------+--------------+--------------------------------------------------------------------------------------------+
dry_run : bool
If True, only return list of commands to be called by subprocess.
csv_delimiter : str
Delimiter for output CSV file.
use_gm : bool
| If True, use GraphicsMagick to convert PDF to temporary PNG images before processing.
| If False, OSRA will use it's own conversion of PDF to image.
| Using gm is more reliable since OSRA (v2.1.0) is showing wrong information
when converting directly from PDF (namely: coordinates, bond length and possibly more ones) and also there are sometimes
incorrectly recognised structures.
gm_dpi : int
How many DPI will temporary PNG images have.
gm_trim : bool
If True, gm will trim the temporary PNG images.
n_jobs : int
| If `use_gm` and input file is PDF, how many jobs to use for OSRA processing of temporary PNG images.
| If -1 all CPUs are used.
| If 1 is given, no parallel computing code is used at all, which is useful for debugging.
| For n_jobs below -1, (n_cpus + 1 + n_jobs) are used. Thus for n_jobs = -2, all CPUs but one are used.
input_type : str
| When empty, input (MIME) type will be determined from magic bytes.
| Or you can specify "pdf" or "image" and magic bytes check will be skipped.
standardize_mols : bool
If True and `format_output` is also True, use molvs (https://github.com/mcs07/MolVS) to standardize molecules.
annotate : bool
| If True, try to annotate entities in PubChem and ChemSpider. Compound IDs will be assigned by searching with
each identifier, separately for SMILES, InChI etc.
| If entity has InChI key yet, prefer it in searching.
| If "*" is present in SMILES, skip annotation.
chemspider_token : str
Your personal token for accessing the ChemSpider API. Make account there to obtain it.
custom_page : bool
When `use_gm` is False, this will set the page for all extracted compounds.
continue_on_failure : bool
| If True, continue running even if OSRA returns non-zero exit code.
| If False and error occurs, print it and return.
Returns
-------
dict
Keys:
- stdout: str ... standard output from OSRA
- stderr: str ... standard error output from OSRA
- exit_code: int ... exit code from OSRA
- content:
- list of OrderedDicts ... when `format_output` is True.
- None ... when `format_output` is False
| If `osra_output_format` is "sdf", additional information like 'bond_length' cannot be retrieved.
| If `use_gm` is True then stdout, stderr and exit_code will be lists containing items from each temporary image
extracted by OSRA.
Notes
-----
Only with `format_output` set to True you can use molecule standardization and more molecule formats. Otherwise
you will only get raw stdout from OSRA (which can also be written to file if `output_file` is set).
"""
options_internal = self.options_internal.copy()
osra_smiles_outputs = ["smi", "can"]
# OSRA output format check
if osra_output_format:
options_internal["output_format"] = osra_output_format
else:
osra_output_format = options_internal["output_format"]
osra_valid_output_formats = {
"can": "smiles_can_osra",
"smi": "smiles_osra",
"sdf": "sdf_osra"
}
if osra_output_format not in osra_valid_output_formats:
raise ValueError(
"Unknown OSRA output format. Possible values: {}".format(
osra_valid_output_formats.values()))
if osra_output_format == "sdf":
self.logger.warning(
"OSRA's output format is set to \"sdf\" so additional information like coordinates cannot be retrieved."
)
# output formats check
is_output_sdf = False
is_output_sdf_osra = False
if not output_formats:
output_formats = ["smiles"]
else:
output_formats = sorted(list(set(output_formats)))
possible_output_formats = ["smiles", "inchi", "inchikey", "sdf"]
output_formats = [
x for x in output_formats if x in possible_output_formats
or x == osra_valid_output_formats[osra_output_format]
]
if ("sdf" in output_formats
or "sdf_osra" in output_formats) and not output_file_sdf:
self.logger.warning(
"Cannot write SDF output: 'output_file_sdf' is not set.")
if output_file_sdf:
is_output_sdf = True
if "sdf_osra" in output_formats and osra_output_format == "sdf" and output_file_sdf:
is_output_sdf_osra = True
if ("smiles_osra" in output_formats or "smiles_can_osra"
in output_formats) and osra_output_format == "sdf":
try:
output_formats.remove("smiles_osra")
except ValueError:
pass
try:
output_formats.remove("smiles_can_osra")
except ValueError:
pass
self.logger.warning(
"SMILES or canonical SMILES output from OSRA is requested, but OSRA's output format is \"{}\"."
.format(osra_output_format))
# input file type check
possible_input_types = ["pdf", "image"]
if not input_type:
input_type = get_input_file_type(input_file)
if input_type not in possible_input_types:
use_gm = False
self.logger.warning(
"Input file MIME type ('{}') is not one of {}. You can specify 'input_type' directly (see docstring)."
.format(input_type, possible_input_types))
elif input_type not in possible_input_types:
raise ValueError("Possible 'input_type' values are {}".format(
possible_input_types))
#options = ChainMap({k: v for k, v in {"images_prefix": images_prefix}.items() if v},
# options_internal)
if annotate:
if not chemspider_token:
self.logger.warning(
"Cannot perform annotation in ChemSpider: 'chemspider_token' is empty."
)
[
output_formats.append(x)
for x in ["smiles", "inchi", "inchikey"]
if x not in output_formats
]
output_formats = sorted(output_formats)
commands, _, _ = self.build_commands(options_internal,
self._OPTIONS_REAL,
self.path_to_binary)
commands.extend(
["--bond", "--coordinates", "--page", "--guess", "--print"])
if dry_run:
return " ".join(commands)
osra_output_list = []
if input_type == "image" or not use_gm:
osra_output_list.append(
self._process(input_file,
commands,
page=custom_page if custom_page else 1))
elif input_type == "pdf":
with tempfile.TemporaryDirectory() as temp_dir:
stdout, stderr, exit_code = pdf_to_images(input_file,
temp_dir,
dpi=gm_dpi,
trim=gm_trim)
osra_output_list = Parallel(n_jobs=n_jobs)(
delayed(self._process)(
temp_image_file, commands, page=page)
for temp_image_file, page in get_temp_images(temp_dir))
# summarize OSRA results
to_return = {
"stdout": [],
"stderr": [],
"exit_code": [],
"content": None,
"pages": []
}
for result in osra_output_list:
if result["stdout"]:
to_return["stdout"].append(result["stdout"])
to_return["stderr"].append(result["stderr"])
to_return["exit_code"].append(result["exit_code"])
to_return["pages"].append(result["page"])
if not continue_on_failure:
errors = [(page + 1, error)
for page, (exit_code, error) in enumerate(
zip(to_return["exit_code"], to_return["stderr"]))
if exit_code > 0]
if errors:
self.logger.warning("OSRA errors:")
for page, error in errors:
eprint("\tError on page {}:".format(page))
eprint("\n\t\t".join("\n{}".format(error).splitlines()))
return to_return
if not format_output:
if output_file:
with open(output_file, mode="w", encoding="utf-8") as f:
f.write("\n".join(to_return["stdout"]))
return to_return
output_cols = OrderedDict([("bond_length", 1), ("resolution", 2),
("confidence", 3), ("page", 4),
("coordinates", 5)])
if osra_output_format in osra_smiles_outputs:
compound_template_dict = OrderedDict.fromkeys(
output_formats + list(output_cols.keys()))
else:
compound_template_dict = OrderedDict.fromkeys(["page"] +
output_formats)
if any(to_return["stdout"]):
if standardize_mols:
standardizer = Standardizer()
compounds = []
if is_output_sdf:
if sdf_append:
if not os.path.isfile(output_file_sdf):
open(output_file_sdf, mode="w",
encoding="utf-8").close()
writer = SDWriter(
open(output_file_sdf, mode="a", encoding="utf-8"))
else:
writer = SDWriter(output_file_sdf)
for output, page in zip(to_return["stdout"], to_return["pages"]):
if osra_output_format in osra_smiles_outputs:
lines = [x.strip() for x in output.split("\n") if x]
else:
lines = [x for x in output.split("$$$$") if x.strip()]
for line in lines:
"""
# so much problems with --learn
# we can't simply split output by " " when --learn is present, because its output is like "1,2,2,2 1"
if "learn" in filtered_cols:
learn_start = filtered_cols.index("learn") + 1 # "smiles" col isn't in output_cols
learn_end = filtered_cols.index("learn") + 1 + 3
line[learn_start:learn_end] = [" ".join(line[learn_start:learn_end])]
"""
if not line:
continue
if osra_output_format in osra_smiles_outputs:
line = [x.strip() for x in line.split()]
if custom_page:
line[output_cols["page"]] = custom_page
elif use_gm:
line[output_cols["page"]] = page
mol = MolFromSmiles(
line[0],
sanitize=False if standardize_mols else True)
elif osra_output_format == "sdf":
line = "\n" + line.strip()
mol = MolFromMolBlock(
line,
strictParsing=False,
sanitize=False if standardize_mols else True,
removeHs=False if standardize_mols else True)
if mol:
compound = compound_template_dict.copy()
if standardize_mols:
try:
mol = standardizer.standardize(mol)
except ValueError as e:
self.logger.warning(
"Cannot standardize '{}': {}".format(
MolToSmiles(mol), str(e)))
for f in output_formats:
if f == "smiles":
compound["smiles"] = MolToSmiles(
mol, isomericSmiles=True)
elif f == "smiles_osra" and osra_output_format == "smi":
compound["smiles_osra"] = line[0]
elif f == "smiles_can_osra" and osra_output_format == "can":
compound["smiles_can_osra"] = line[0]
elif f == "inchi":
inchi = MolToInchi(mol)
if inchi:
compound["inchi"] = inchi
else:
compound["inchi"] = ""
self.logger.warning(
"Cannot convert to InChI: {}".format(
MolToSmiles(mol)))
elif f == "inchikey":
inchi = MolToInchi(mol)
if inchi:
compound["inchikey"] = InchiToInchiKey(
inchi)
else:
compound["inchikey"] = ""
self.logger.warning(
"Cannot create InChI-key from InChI: {}"
.format(MolToSmiles(mol)))
elif f == "sdf":
compound["sdf"] = MolToMolBlock(
mol, includeStereo=True)
elif f == "sdf_osra":
compound["sdf_osra"] = line
if is_output_sdf:
writer.write(mol)
if osra_output_format in osra_smiles_outputs:
compound.update([(x[0], x[1]) for x in zip(
list(output_cols.keys()), line[1:])])
else:
compound[
"page"] = page if use_gm else custom_page if custom_page else 1
compounds.append(compound)
else:
self.logger.warning("Cannot convert to RDKit mol: " +
line[0])
if is_output_sdf_osra:
with open(output_file_sdf + "-osra.sdf",
mode="w",
encoding="utf-8") as f:
f.write("".join(to_return["stdout"]))
to_return["content"] = sorted(compounds, key=lambda x: x["page"])
if annotate:
chemspider = ChemSpider(
chemspider_token) if chemspider_token else None
for i, ent in enumerate(to_return["content"]):
self.logger.info("Annotating entity {}/{}...".format(
i + 1, len(to_return["content"])))
ent.update(
OrderedDict([("pch_cids_by_inchikey", ""),
("chs_cids_by_inchikey", ""),
("pch_cids_by_smiles", ""),
("chs_cids_by_smiles", ""),
("pch_cids_by_inchi", ""),
("chs_cids_by_inchi", ""),
("pch_iupac_name", ""),
("chs_common_name", ""),
("pch_synonyms", "")]))
results = []
# prefer InChI key
if "inchikey" in ent and ent["inchikey"]:
try:
results = get_compounds(ent["inchikey"],
"inchikey")
if results:
if len(results) == 1:
result = results[0]
synonyms = result.synonyms
if synonyms:
ent["pch_synonyms"] = "\"{}\"".format(
"\",\"".join(synonyms))
ent["pch_iupac_name"] = result.iupac_name
ent["pch_cids_by_inchikey"] = "\"{}\"".format(
",".join([str(c.cid) for c in results]))
except (BadRequestError, NotFoundError,
PubChemHTTPError, ResponseParseError,
ServerError, TimeoutError, PubChemPyError):
pass
results = chemspider.search(
ent["inchikey"]) if chemspider_token else []
if results:
if len(results) == 1:
result = results[0]
ent["chs_common_name"] = result.common_name
ent["chs_cids_by_inchikey"] = "\"{}\"".format(
",".join([str(c.csid) for c in results]))
else:
for search_field, col_pch, col_chs in [
("smiles", "pch_cids_by_smiles",
"chs_cids_by_smiles"),
("inchi", "pch_cids_by_inchi", "chs_cids_by_inchi")
]:
results_pch = []
results_chs = []
if search_field == "smiles" and "smiles" in ent and ent[
"smiles"] and "*" not in ent["smiles"]:
try:
results_pch = get_compounds(
ent["smiles"], "smiles")
except (BadRequestError, NotFoundError,
PubChemHTTPError, ResponseParseError,
ServerError, TimeoutError,
PubChemPyError):
pass
results_chs = chemspider.search(
ent["smiles"]) if chemspider_token else []
elif search_field == "inchi" and "inchi" in ent and ent[
"inchi"]:
try:
results_pch = get_compounds(
ent["inchi"], "inchi")
except (BadRequestError, NotFoundError,
PubChemHTTPError, ResponseParseError,
ServerError, TimeoutError,
PubChemPyError):
pass
results_chs = chemspider.search(
ent["inchi"]) if chemspider_token else []
if results_pch:
ent[col_pch] = "\"{}\"".format(",".join(
[str(c.cid) for c in results_pch]))
if results_chs:
ent[col_chs] = "\"{}\"".format(",".join(
[str(c.csid) for c in results_chs]))
sleep(0.5)
if output_file:
dict_to_csv(to_return["content"],
output_file=output_file,
csv_delimiter=csv_delimiter,
write_header=write_header)
if is_output_sdf:
writer.close()
elif not any(to_return["stdout"]) and output_file:
write_empty_file(output_file,
csv_delimiter=csv_delimiter,
header=list(compound_template_dict.keys()),
write_header=write_header)
return to_return
def molfile(self, m):
"""make molfile from molecule"""
return MolToMolBlock(m)
def process(self,
input: Union[str, list] = "",
input_file: str = "",
output_file: str = "",
output_file_sdf: str = "",
output_file_cml: str = "",
sdf_append: bool = False,
format_output: bool = True,
opsin_output_format: str = "",
output_formats: list = None,
write_header: bool = True,
dry_run: bool = False,
csv_delimiter: str = ";",
standardize_mols: bool = True,
normalize_plurals: bool = True,
continue_on_failure: bool = False) -> OrderedDict:
r"""
Process the input file with OPSIN.
Parameters
----------
input : str or list
| str: String with IUPAC names, one per line.
| list: List of IUPAC names.
input_file : str
Path to file to be processed by OPSIN. One IUPAC name per line.
output_file : str
File to write output in.
output_file_sdf : str
File to write SDF output in.
output_file_cml : str
| File to write CML (Chemical Markup Language) output in. `opsin_output_format` must be "cml".
| Not supported by RDKit so standardization and conversion to other formats cannot be done.
sdf_append : bool
If True, append new molecules to existing SDF file or create new one if doesn't exist.
format_output : bool
| If True, the value of "content" key of returned dict will be list of OrderedDicts with keys:
| "iupac", <output formats>, ..., "error"
| If True and `output_file` is set it will be created as CSV file with columns: "iupac", <output formats>, ..., "error"
| If False, the value of "content" key of returned dict will be None.
opsin_output_format : str
| Output format from OPSIN. Temporarily overrides the option `output_format` set during instantiation (in __init__).
| Choices: "cml", "smi", "extendedsmi", "inchi", "stdinchi", "stdinchikey"
output_formats : list
| If True and `format_output` is also True, this specifies which molecule formats will be output.
| You can specify more than one format, but only one format from OPSIN. This format must be also set with `output_format` in __init__
or with `osra_output_format` here.
| Default value: ["smiles"]
+-----------------------+-----------------------+--------------------------------------------------------------------------------------------+
| Value | Source | Note |
+=======================+=======================+============================================================================================+
| smiles | RDKit | canonical |
+-----------------------+-----------------------+--------------------------------------------------------------------------------------------+
| smiles_opsin | OPSIN ("smi") | SMILES |
+-----------------------+-----------------------+--------------------------------------------------------------------------------------------+
| smiles_extended_opsin | OPSIN ("extendedsmi") | Extended SMILES. Not supported by RDKit. |
+-----------------------+-----------------------+--------------------------------------------------------------------------------------------+
| inchi | RDKit | Not every molecule can be converted to InChI (it doesn`t support wildcard characters etc.) |
+-----------------------+-----------------------+--------------------------------------------------------------------------------------------+
| inchi_opsin | OPSIN ("inchi") | InChI |
+-----------------------+-----------------------+--------------------------------------------------------------------------------------------+
| stdinchi_opsin | OPSIN ("stdinchi") | standard InChI |
+-----------------------+-----------------------+--------------------------------------------------------------------------------------------+
| inchikey | RDKit | The same applies as for "inchi". Also molecule cannot be created from InChI-key. |
+-----------------------+-----------------------+--------------------------------------------------------------------------------------------+
| stdinchikey_opsin | OPSIN ("stdinchikey") | Standard InChI-key. Cannot be used by RDKit to create molecule. |
+-----------------------+-----------------------+--------------------------------------------------------------------------------------------+
| sdf | RDKit | If present, an additional SDF file will be created. |
+-----------------------+-----------------------+--------------------------------------------------------------------------------------------+
write_header : bool
If True and if `output_file` is set and `output_format` is True, write a CSV write_header.
dry_run : bool
If True, only return list of commands to be called by subprocess.
csv_delimiter : str
Delimiter for output CSV file.
standardize_mols : bool
If True and `format_output` is also True, use molvs (https://github.com/mcs07/MolVS) to standardize molecules.
normalize_plurals : bool
| If True, normalize plurals ("nitrates" -> "nitrate"). See OPSIN.PLURAL_PATTERNS for relating plurals. You can
set your own regex pattern with `plural_patterns` in __init__.
continue_on_failure : bool
| If True, continue running even if OPSIN returns non-zero exit code.
| If False and error occurs, print it and return.
Returns
-------
dict
Keys:
- stdout: str ... standard output from OPSIN
- stderr: str ... standard error output from OPSIN
- exit_code: int ... exit code from OPSIN
- content:
- list of OrderedDicts ... when format_output is True. Fields: "iupac", <output formats>, ..., "error"
- None ... when format_output is False
"""
options_internal = self.options_internal.copy()
opsin_nonreadable_formats = ["cml", "stdinchikey"]
if input and input_file:
input_file = ""
self.logger.warning(
"Both 'input' and 'input_file' are set, but 'input' will be prefered."
)
elif not input and not input_file:
raise ValueError("One of 'input' or 'input_file' must be set.")
# OSRA output format check
if opsin_output_format:
options_internal["output_format"] = opsin_output_format
else:
opsin_output_format = options_internal["output_format"]
opsin_valid_output_formats = {
"cml": "cml_opsin",
"smi": "smiles_opsin",
"extendedsmi": "smiles_extended_opsin",
"inchi": "inchi_opsin",
"stdinchi": "stdinchi_opsin",
"stdinchikey": "stdinchikey_opsin"
}
if opsin_output_format not in opsin_valid_output_formats:
raise ValueError(
"Unknown OPSIN output format. Possible values: {}".format(
list(opsin_valid_output_formats.keys())))
if standardize_mols and opsin_output_format in opsin_nonreadable_formats:
self.logger.warning(
"OPSIN output format is \"{}\", which cannot be used by RDKit."
.format(opsin_output_format))
# output formats check
if not output_formats:
output_formats = ["smiles"]
else:
if opsin_output_format == "stdinchikey":
output_formats = ["stdinchikey_opsin"]
elif opsin_output_format == "extendedsmi":
output_formats = ["smiles_extended_opsin"]
else:
output_formats = sorted(list(set(output_formats)))
possible_output_formats = [
"smiles", "inchi", "inchikey", "sdf"
]
output_formats = [
x for x in output_formats if x in possible_output_formats
or x == opsin_valid_output_formats[opsin_output_format]
]
if normalize_plurals:
if input_file:
with open(input_file, mode="r", encoding="utf-8") as f:
input = "\n".join([x.strip() for x in f.readlines()])
input_file = ""
input = self.normalize_iupac(input)
commands, _, _ = self.build_commands(options_internal,
self._OPTIONS_REAL,
self.path_to_binary)
if input_file:
commands.append(input)
stdout, stderr, exit_code = common_subprocess(commands)
elif input:
if isinstance(input, list):
input = "\n".join([x.strip() for x in input])
stdout, stderr, exit_code = common_subprocess(commands,
stdin=input)
else:
raise UserWarning("Input is empty.")
if dry_run:
return " ".join(commands)
to_return = {
"stdout": stdout,
"stderr": stderr,
"exit_code": exit_code,
"content": None
}
if not continue_on_failure and exit_code > 0:
self.logger.warning("OPSIN error:")
eprint("\n\t".join("\n{}".format(stderr).splitlines()))
return to_return
if output_file_cml and opsin_output_format == "cml":
with open(output_file_cml, mode="w", encoding="utf-8") as f:
f.write(stdout)
return to_return
elif output_file_cml and opsin_output_format != "cml":
self.logger.warning(
"Output file for CML is requested, but OPSIN output format is '{}'"
.format(opsin_output_format))
if not format_output:
if output_file:
with open(output_file, mode="w", encoding="utf-8") as f:
f.write(stdout)
return to_return
compounds = []
standardizer = Standardizer()
empty_cols = OrderedDict([(x, "") for x in output_formats])
if output_file_sdf:
if sdf_append:
if not os.path.isfile(output_file_sdf):
open(output_file_sdf, mode="w", encoding="utf-8").close()
writer = SDWriter(
open(output_file_sdf, mode="a", encoding="utf-8"))
else:
writer = SDWriter(output_file_sdf)
stdout = stdout.split("\n")
del stdout[-1]
stderr = [
x.strip() for x in stderr.split("\n")[1:] if x
] # remove first line of stderr because there is OPSIN message (y u du dis...)
if input_file:
with open(input_file, mode="r", encoding="utf-8") as f:
lines = iter(f.readlines())
else:
lines = iter(input.split("\n"))
mol_output_template = OrderedDict.fromkeys(["iupac"] + output_formats +
["error"])
e = 0
for i, line in enumerate(lines):
line = line.strip()
converted = stdout[i].strip()
mol_output = mol_output_template.copy()
if converted:
if opsin_output_format == "stdinchikey":
compounds.append(
OrderedDict([("iupac", line),
("stdinchikey_opsin", converted),
("error", "")]))
continue
elif opsin_output_format == "extendedsmi":
compounds.append(
OrderedDict([("iupac", line),
("smiles_extended_opsin", converted),
("error", "")]))
continue
if opsin_output_format == "smi":
mol = MolFromSmiles(
converted,
sanitize=False if standardize_mols else True)
elif opsin_output_format in ["inchi", "stdinchi"]:
mol = MolFromInchi(
converted,
sanitize=False if standardize_mols else True,
removeHs=False if standardize_mols else True)
if mol:
if standardize_mols:
try:
mol = standardizer.standardize(mol)
except ValueError as e:
self.logger.warning(
"Cannot standardize '{}': {}".format(
MolToSmiles(mol), str(e)))
for f in output_formats:
if f == "smiles":
mol_output["smiles"] = MolToSmiles(
mol, isomericSmiles=True)
elif f == "smiles_opsin" and opsin_output_format == "smi":
mol_output["smiles_opsin"] = converted
elif f == "inchi":
inchi = MolToInchi(mol)
if inchi:
mol_output["inchi"] = inchi
else:
mol_output["inchi"] = ""
self.logger.warning(
"Cannot convert to InChI: {}".format(
converted))
elif f == "inchi_opsin" and opsin_output_format == "inchi":
mol_output["inchi_opsin"] = converted
elif f == "stdinchi_opsin" and opsin_output_format == "stdinchi":
mol_output["stdinchi_opsin"] = converted
elif f == "inchikey":
inchi = MolToInchi(mol)
if inchi:
mol_output["inchikey"] = InchiToInchiKey(inchi)
else:
mol_output["inchikey"] = ""
self.logger.warning(
"Cannot create InChI-key from InChI: {}".
format(converted))
elif f == "stdinchikey_opsin" and opsin_output_format == "stdinchikey":
mol_output["stdinchikey_opsin"] = converted
elif f == "sdf":
mol_output["sdf"] = MolToMolBlock(
mol, includeStereo=True)
if output_file_sdf:
writer.write(mol)
mol_output.update(
OrderedDict([("iupac", line), ("error", "")]))
else:
mol_output.update([
("iupac", line),
("error",
"Cannot convert to RDKit mol: {}".format(converted))
])
mol_output.update(empty_cols)
self.logger.warning(compounds[-1].error)
else:
try:
error = stderr[e].strip()
except IndexError:
error = ""
mol_output.update([("iupac", line), ("error", error)])
mol_output.update(empty_cols)
e += 1
compounds.append(mol_output)
to_return["content"] = compounds
if output_file and compounds:
dict_to_csv(to_return["content"],
output_file=output_file,
csv_delimiter=csv_delimiter,
write_header=write_header)
elif output_file and not compounds:
write_empty_file(output_file,
csv_delimiter=csv_delimiter,
header=list(mol_output_template.keys()),
write_header=write_header)
return to_return
