def _load_verify_openeye(self, oechemlicensepath=None): """Loads required OpenEye libraries and checks licenses Parameters ---------- oechemlicensepath : str, optional, default=None OpenEye license path to use, or None if environment variables are to be used. Raises ------ RuntimeError If OE_LICENSE is not found as an environment variable If A valid license is missing Notes ----- Needs to be run before any of the other functions to assure OpenEye libraries are accessible. """ # Don't do anything if we've already imported OpenEye toolkit. if self.oechem: return try: # Import the OpenEye toolkit components. from openeye import oechem # For chemical objects from openeye import oeiupac # For IUPAC conversion from openeye import oeomega # For conformer generation from openeye import oequacpac # For pKa estimations except Exception as e: raise Exception("Could not import `openeye` library. Make sure OpenEye Python Toolkit is installed and on PYTHONPATH.") import os if oechemlicensepath is not None: os.environ['OE_LICENSE'] = oechemlicensepath try: os.environ['OE_LICENSE'] # See if license path is set. except KeyError: raise RuntimeError("Environment variable OE_LICENSE needs to be set.") if not oechem.OEChemIsLicensed(): # Check for OEchem TK license. raise RuntimeError("No valid license available for OEChem TK.") if not oeiupac.OEIUPACIsLicensed(): # Check for Lexichem TK license. raise RuntimeError("No valid license available for Lexichem TK.") if not oeomega.OEOmegaIsLicensed(): # Check for Omega TK license. raise RuntimeError("No valid license for Omega TK.") if not oequacpac.OEQuacPacIsLicensed(): # Check for Quacpac TK license. raise RuntimeError("No valid license for Quacpac TK.") #Attach libraries to the instance to only load and check them once at initialization. self.oechem = oechem self.oeiupac = oeiupac self.oeomega = oeomega self.oequacpac = oequacpac return
def __init__( self, host_codes: List[str] = None, guest_codes: List[str] = None, default_ionic_strength: Optional[unit.Quantity] = 150 * unit.millimolar, negative_buffer_ion: str = "[Cl-]", positive_buffer_ion: str = "[Na+]", attach_apr_meta_data: bool = True, ): """ Parameters ---------- host_codes The three letter codes of the host molecules to load from ``taproom`` If no list is provided, all hosts will be loaded. guest_codes The three letter codes of the guest molecules to load from ``taproom``. If no list is provided, all guests will be loaded. default_ionic_strength The default ionic strength to use for measurements. The value specified in ``taproom`` will be ignored and this value used instead. If no value is provided, no buffer will be included. negative_buffer_ion The SMILES pattern of the negative buffer ion to use. The value specified in ``taproom`` will be ignored and this value used instead. positive_buffer_ion The SMILES pattern of the positive buffer ion to use. The value specified in ``taproom`` will be ignored and this value used instead. attach_apr_meta_data Whether to add the metadata required for an APR based calculation using the ``paprika`` based workflow. """ super().__init__() try: from openeye import oechem except ImportError: raise MissingOptionalDependency("openeye.oechem", False) unlicensed_library = "openeye.oechem" if not oechem.OEChemIsLicensed( ) else None if unlicensed_library is not None: raise MissingOptionalDependency(unlicensed_library, True) # TODO: Don't overwrite the taproom ionic strength and buffer ions. self._initialize( host_codes, guest_codes, default_ionic_strength, negative_buffer_ion, positive_buffer_ion, attach_apr_meta_data, )
def test_adjacency(smiles, expected_adj): if not oechem.OEChemIsLicensed(): logging.warning( "License for OpenEye OEChem TK is not found. Not testing featurizers." ) return True mol = oechem.OEMol() oechem.OESmilesToMol(mol, smiles) oechem.OESuppressHydrogens(mol) adj = Adjacency(mol=mol) assert adj.adj_mat.tolist() == expected_adj
def is_openeye_installed(): try: from openeye import oechem from openeye import oequacpac from openeye import oeiupac from openeye import oeomega if not (oechem.OEChemIsLicensed() and oequacpac.OEQuacPacIsLicensed() and oeiupac.OEIUPACIsLicensed() and oeomega.OEOmegaIsLicensed()): raise ImportError except ImportError: return False return True
def get_unique_protomer(molecule): """ Generate unique protomer for all tuatomers and charge states of the moelcule. **Requires openeye license** Parameters ---------- molecule: oechem.OEMol Will convert `rdkit.Chem.Mol` to `oechem.OEMol` if openeye is installed and license is valid Returns ------- str unique protomer """ molecule = deepcopy(molecule) # This only works for OpenEye # Todo There might be a way to use different layers of InChI for this purpose. # Not all tautomers are recognized as the same by InChI so it won't capture all tautomers. # But if we use only the formula and connectivity level we might be able to capture a larger subset. # if has_openeye: from openeye import oequacpac, oechem else: raise RuntimeError("Must have OpenEye for unique protomer feature") if not oechem.OEChemIsLicensed(): raise ImportError("Must have OEChem license!") if not oequacpac.OEQuacPacIsLicensed(): raise ImportError("Must have OEQuacPac license!") if has_rdkit: if isinstance(molecule, rd.Chem.rdchem.Mol): # convert to openeye molecule # Maybe we shouldn't do this. smiles = rd.Chem.MolToSmiles(molecule) molecule = oechem.OEMol() oechem.OESmilesToMol(molecule, smiles) molecule_copy = deepcopy(molecule) oequacpac.OEGetUniqueProtomer(molecule_copy, molecule) return oechem.OEMolToSmiles(molecule_copy)
def _check_oe_available(cls): """Check if the `oechem` and `oegraphsim` modules are available for import. Raises ------- MissingOptionalDependency """ try: from openeye import oechem, oegraphsim except ImportError as e: raise MissingOptionalDependency(e.path, False) unlicensed_library = ("openeye.oechem" if not oechem.OEChemIsLicensed() else "openeye.oegraphsim" if not oegraphsim.OEGraphSimIsLicensed() else None) if unlicensed_library is not None: raise MissingOptionalDependency(unlicensed_library, True)
def has_openeye(): """Checks whether the `openeye` toolkits are available for use Returns ------- bool True if the `openeye` toolkit can be imported and has a valid license. """ try: from openeye import oechem available = True if not oechem.OEChemIsLicensed(): available = False except ImportError: available = False return available
# # 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. from openeye import oechem # @ <SNIPPET-OECHEMISLICENSED-VERIFY> if not oechem.OEChemIsLicensed("python"): oechem.OEThrow.Warning("OEChem is not licensed for the python feature") # @ </SNIPPET-OECHEMISLICENSED-VERIFY> # @ <SNIPPET-OECHEMISLICENSED-EXPIRE> expdate = oechem.OEUIntArray(3) if oechem.OEChemIsLicensed("python", expdate): oechem.OEThrow.Info("License expires: day: %d month: %d year: %d" % (expdate[0], expdate[1], expdate[2])) # @ </SNIPPET-OECHEMISLICENSED-EXPIRE>
Contributors: Nathan M. Lim, Kalistyn Burley, David L. Mobley """ import parmed from simtk import unit import mdtraj import numpy as np import sys, traceback import math import copy import random import os try: import openeye.oechem as oechem if not oechem.OEChemIsLicensed(): print('ImportError: Need License for OEChem! SideChainMove class will be unavailable.') try: import oeommtools.utils as oeommtools except ImportError: print('ImportError: Could not import oeommtools. SideChainMove class will be unavailable.') except ImportError: print('ImportError: Could not import openeye-toolkits. SideChainMove class will be unavailable.') class Move(object): """Move provides methods for calculating properties on the object 'move' (i.e ligand) being perturbed in the NCMC simulation. This is the base Move class. Ex. from blues.ncmc import Model
import sys import os import argparse import glob import logging import tarfile import shutil import tempfile import pickle import csv try: OPENEYE_MOD_LOADED = False from openeye import oechem try: if oechem.OEChemIsLicensed(): OPENEYE_MOD_LOADED = True else: sys.stderr.write('WARNING: No valid license found for openeye ' + 'Please verify OE_LICENSE environment variable' 'is set to valid license file\n') except AttributeError as ae: sys.stderr.write('WARNING Unable to check if openey is licensed' + str(ae)) except ImportError as e: sys.stderr.write('WARNING: Unable to import oechem: ' + str(e) + ' validation will NOT work\n') import d3r from d3r.celpp import util from d3r.celpp.task import D3RParameters
def get_charges(molecule, max_confs=800, strict_stereo=True, normalize=True, keep_confs=None, legacy=True): """Generate charges for an OpenEye OEMol molecule. Parameters ---------- molecule : OEMol Molecule for which to generate conformers. Omega will be used to generate max_confs conformations. max_confs : int, optional, default=800 Max number of conformers to generate strictStereo : bool, optional, default=True If False, permits smiles strings with unspecified stereochemistry. See https://docs.eyesopen.com/omega/usage.html normalize : bool, optional, default=True If True, normalize the molecule by checking aromaticity, adding explicit hydrogens, and renaming by IUPAC name. keep_confs : int, optional, default=None If None, apply the charges to the provided conformation and return this conformation, unless no conformation is present. Otherwise, return some or all of the generated conformations. If -1, all generated conformations are returned. Otherwise, keep_confs = N will return an OEMol with up to N generated conformations. Multiple conformations are still used to *determine* the charges. legacy : bool, default=True If False, uses the new OpenEye charging engine. See https://docs.eyesopen.com/toolkits/python/quacpactk/OEProtonFunctions/OEAssignCharges.html# Returns ------- charged_copy : OEMol A molecule with OpenEye's recommended AM1BCC charge selection scheme. Notes ----- Roughly follows http://docs.eyesopen.com/toolkits/cookbook/python/modeling/am1-bcc.html """ # If there is no geometry, return at least one conformation. if molecule.GetConfs() == 0: keep_confs = 1 if not oechem.OEChemIsLicensed(): raise (ImportError("Need License for OEChem!")) if not oequacpac.OEQuacPacIsLicensed(): raise (ImportError("Need License for oequacpac!")) if normalize: molecule = normalize_molecule(molecule) else: molecule = oechem.OEMol(molecule) charged_copy = generate_conformers( molecule, max_confs=max_confs, strict_stereo=strict_stereo) # Generate up to max_confs conformers if not legacy: # 2017.2.1 OEToolkits new charging function status = oequacpac.OEAssignCharges(charged_copy, oequacpac.OEAM1BCCCharges()) if not status: raise (RuntimeError("OEAssignCharges failed.")) else: # AM1BCCSym recommended by Chris Bayly to KAB+JDC, Oct. 20 2014. status = oequacpac.OEAssignPartialCharges( charged_copy, oequacpac.OECharges_AM1BCCSym) if not status: raise (RuntimeError( "OEAssignPartialCharges returned error code %d" % status)) #Determine conformations to return if keep_confs == None: #If returning original conformation original = molecule.GetCoords() #Delete conformers over 1 for k, conf in enumerate(charged_copy.GetConfs()): if k > 0: charged_copy.DeleteConf(conf) #Copy coordinates to single conformer charged_copy.SetCoords(original) elif keep_confs > 0: logger().debug( "keep_confs was set to %s. Molecule positions will be reset." % keep_confs) #Otherwise if a number is provided, return this many confs if available for k, conf in enumerate(charged_copy.GetConfs()): if k > keep_confs - 1: charged_copy.DeleteConf(conf) elif keep_confs == -1: #If we want all conformations, continue pass else: #Not a valid option to keep_confs raise (ValueError('Not a valid option to keep_confs in get_charges.')) return charged_copy