rdkit.Chem.MolStandardize.rdMolStandardize module¶

Module containing tools for normalizing molecules defined by SMARTS patterns

class rdkit.Chem.MolStandardize.rdMolStandardize.AllowedAtomsValidation((AtomPairsParameters)arg1, (AtomPairsParameters)arg2)¶

Bases: ValidationMethod

C++ signature :: void* __init__(boost::python::api::object,boost::python::api::object)

rdkit.Chem.MolStandardize.rdMolStandardize.CHARGE_CORRECTIONS() → object :¶

C++ signature :: std::vector<RDKit::MolStandardize::ChargeCorrection, std::allocator<RDKit::MolStandardize::ChargeCorrection> > CHARGE_CORRECTIONS()

rdkit.Chem.MolStandardize.rdMolStandardize.CanonicalTautomer((Mol)mol[, (AtomPairsParameters)params=None]) → Mol :¶

Returns the canonical tautomer for the molecule

C++ signature :: RDKit::ROMol* CanonicalTautomer(RDKit::ROMol const* [,boost::python::api::object=None])

class rdkit.Chem.MolStandardize.rdMolStandardize.ChargeCorrection((object)self, (str)name, (str)smarts, (int)charge)¶

Bases: instance

C++ signature :: void __init__(_object*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,int)

property Charge¶

property Name¶

property Smarts¶

rdkit.Chem.MolStandardize.rdMolStandardize.ChargeParent((Mol)mol[, (AtomPairsParameters)params=None[, (bool)skipStandardize=False]]) → Mol :¶

Returns the uncharged version of the largest fragment

C++ signature :: RDKit::ROMol* ChargeParent(RDKit::ROMol const* [,boost::python::api::object=None [,bool=False]])

rdkit.Chem.MolStandardize.rdMolStandardize.ChargeParentInPlace((Mol)mol[, (AtomPairsParameters)params=None[, (bool)skipStandardize=False]]) → None :¶

Generates the charge parent in place

C++ signature :
void ChargeParentInPlace(RDKit::ROMol* [,boost::python::api::object=None [,bool=False]])

ChargeParentInPlace( (AtomPairsParameters)mols, (int)numThreads [, (AtomPairsParameters)params=None [, (bool)skipStandardize=False]]) -> None :

Generates the chargeparent in place for multiple molecules

C++ signature :: void ChargeParentInPlace(boost::python::api::object,int [,boost::python::api::object=None [,bool=False]])

rdkit.Chem.MolStandardize.rdMolStandardize.Cleanup((Mol)mol[, (AtomPairsParameters)params=None]) → Mol :¶

Standardizes a molecule

C++ signature :: RDKit::ROMol* Cleanup(RDKit::ROMol const* [,boost::python::api::object=None])

rdkit.Chem.MolStandardize.rdMolStandardize.CleanupInPlace((Mol)mol[, (AtomPairsParameters)params=None]) → None :¶

Standardizes a molecule in place

C++ signature :
void CleanupInPlace(RDKit::ROMol* [,boost::python::api::object=None])

CleanupInPlace( (AtomPairsParameters)mols, (int)numThreads [, (AtomPairsParameters)params=None]) -> None :

Standardizes multiple molecules in place

C++ signature :: void CleanupInPlace(boost::python::api::object,int [,boost::python::api::object=None])

class rdkit.Chem.MolStandardize.rdMolStandardize.CleanupParameters((object)arg1)¶

Bases: instance

Parameters controlling molecular standardization

C++ signature :: void __init__(_object*)

property acidbaseFile¶: file containing the acid and base definitions

property doCanonical¶: apply atom-order dependent normalizations (like uncharging) in a canonical order

property fragmentFile¶: file containing the acid and base definitions

property largestFragmentChooserCountHeavyAtomsOnly¶: whether LargestFragmentChooser should only count heavy atoms (defaults to False)

property largestFragmentChooserUseAtomCount¶: Whether LargestFragmentChooser should use atom count as main criterion before MW (defaults to True)

property maxRestarts¶: maximum number of restarts

property maxTautomers¶: maximum number of tautomers to generate (defaults to 1000)

property maxTransforms¶: maximum number of transforms to apply during tautomer enumeration (defaults to 1000)

property normalizationsFile¶: file containing the normalization transformations

property preferOrganic¶: prefer organic fragments to inorganic ones when deciding what to keep

property tautomerReassignStereo¶: call AssignStereochemistry on all generated tautomers (defaults to True)

property tautomerRemoveBondStereo¶: remove stereochemistry from double bonds involved in tautomerism (defaults to True)

property tautomerRemoveIsotopicHs¶: remove isotopic Hs from centers involved in tautomerism (defaults to True)

property tautomerRemoveSp3Stereo¶: remove stereochemistry from sp3 centers involved in tautomerism (defaults to True)

property tautomerTransformsFile¶: file containing the tautomer transformations

class rdkit.Chem.MolStandardize.rdMolStandardize.DisallowedAtomsValidation((AtomPairsParameters)arg1, (AtomPairsParameters)arg2)¶

Bases: ValidationMethod

C++ signature :: void* __init__(boost::python::api::object,boost::python::api::object)

rdkit.Chem.MolStandardize.rdMolStandardize.DisconnectOrganometallics((Mol)mol[, (AtomPairsParameters)params=None]) → Mol :¶

Returns the molecule disconnected using the organometallics rules.

C++ signature :: RDKit::ROMol* DisconnectOrganometallics(RDKit::ROMol {lvalue} [,boost::python::api::object=None])

rdkit.Chem.MolStandardize.rdMolStandardize.DisconnectOrganometallicsInPlace((Mol)mol[, (AtomPairsParameters)params=None]) → None :¶

Disconnects the molecule using the organometallics rules, modifies the input molecule

C++ signature :: void DisconnectOrganometallicsInPlace(RDKit::ROMol* [,boost::python::api::object=None])

rdkit.Chem.MolStandardize.rdMolStandardize.FragmentParent((Mol)mol[, (AtomPairsParameters)params=None[, (bool)skipStandardize=False]]) → Mol :¶

Returns the largest fragment after doing a cleanup

C++ signature :: RDKit::ROMol* FragmentParent(RDKit::ROMol const* [,boost::python::api::object=None [,bool=False]])

rdkit.Chem.MolStandardize.rdMolStandardize.FragmentParentInPlace((Mol)mol[, (AtomPairsParameters)params=None[, (bool)skipStandardize=False]]) → None :¶

Generates the largest fragment in place

C++ signature :
void FragmentParentInPlace(RDKit::ROMol* [,boost::python::api::object=None [,bool=False]])

FragmentParentInPlace( (AtomPairsParameters)mols, (int)numThreads [, (AtomPairsParameters)params=None [, (bool)skipStandardize=False]]) -> None :

Generates the largest fragment in place for multiple molecules

C++ signature :: void FragmentParentInPlace(boost::python::api::object,int [,boost::python::api::object=None [,bool=False]])

class rdkit.Chem.MolStandardize.rdMolStandardize.FragmentRemover((object)self)¶

Bases: instance

C++ signature :
void __init__(_object*)

__init__( (object)self [, (str)fragmentFilename=’’ [, (bool)leave_last=True [, (bool)skip_if_all_match=False]]]) -> None :

C++ signature :
void __init__(_object* [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >=’’ [,bool=True [,bool=False]]])

remove((FragmentRemover)self, (Mol)mol) → Mol :¶

C++ signature :: RDKit::ROMol* remove(RDKit::MolStandardize::FragmentRemover {lvalue},RDKit::ROMol)

removeInPlace((FragmentRemover)self, (Mol)mol) → None :¶

modifies the molecule in place

C++ signature :: void removeInPlace(RDKit::MolStandardize::FragmentRemover {lvalue},RDKit::ROMol {lvalue})

rdkit.Chem.MolStandardize.rdMolStandardize.FragmentRemoverFromData((str)fragmentData[, (bool)leave_last=True[, (bool)skip_if_all_match=False]]) → FragmentRemover :¶

creates a FragmentRemover from a string containing parameter data

C++ signature :: RDKit::MolStandardize::FragmentRemover* FragmentRemoverFromData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > [,bool=True [,bool=False]])

class rdkit.Chem.MolStandardize.rdMolStandardize.FragmentValidation((object)arg1)¶

Bases: ValidationMethod

C++ signature :: void __init__(_object*)

rdkit.Chem.MolStandardize.rdMolStandardize.GetV1TautomerEnumerator() → TautomerEnumerator :¶

return a TautomerEnumerator using v1 of the enumeration rules

C++ signature :: RDKit::MolStandardize::TautomerEnumerator* GetV1TautomerEnumerator()

rdkit.Chem.MolStandardize.rdMolStandardize.IsotopeParent((Mol)mol[, (AtomPairsParameters)params=None[, (bool)skipStandardize=False]]) → Mol :¶

removes all isotopes specifications from the given molecule

C++ signature :: RDKit::ROMol* IsotopeParent(RDKit::ROMol const* [,boost::python::api::object=None [,bool=False]])

rdkit.Chem.MolStandardize.rdMolStandardize.IsotopeParentInPlace((Mol)mol[, (AtomPairsParameters)params=None[, (bool)skipStandardize=False]]) → None :¶

Generates the isotope parent in place

C++ signature :
void IsotopeParentInPlace(RDKit::ROMol* [,boost::python::api::object=None [,bool=False]])

IsotopeParentInPlace( (AtomPairsParameters)mols, (int)numThreads [, (AtomPairsParameters)params=None [, (bool)skipStandardize=False]]) -> None :

Generates the isotope parent in place for multiple molecules

C++ signature :: void IsotopeParentInPlace(boost::python::api::object,int [,boost::python::api::object=None [,bool=False]])

class rdkit.Chem.MolStandardize.rdMolStandardize.IsotopeValidation((object)arg1)¶

Bases: ValidationMethod

C++ signature :: void __init__(_object*)

class rdkit.Chem.MolStandardize.rdMolStandardize.LargestFragmentChooser((object)self[, (bool)preferOrganic=False])¶

Bases: instance

C++ signature :
void __init__(_object* [,bool=False])

__init__( (object)self, (CleanupParameters)params) -> None :

C++ signature :
void __init__(_object*,RDKit::MolStandardize::CleanupParameters)

choose((LargestFragmentChooser)self, (Mol)mol) → Mol :¶

C++ signature :: RDKit::ROMol* choose(RDKit::MolStandardize::LargestFragmentChooser {lvalue},RDKit::ROMol)

chooseInPlace((LargestFragmentChooser)self, (Mol)mol) → None :¶

C++ signature :: void chooseInPlace(RDKit::MolStandardize::LargestFragmentChooser {lvalue},RDKit::ROMol {lvalue})

class rdkit.Chem.MolStandardize.rdMolStandardize.MetalDisconnector((object)self[, (AtomPairsParameters)options=None])¶

Bases: instance

a class to disconnect metals that are defined as covalently bonded to non-metals

C++ signature :: void __init__(_object* [,boost::python::api::object=None])

Disconnect((MetalDisconnector)self, (Mol)mol) → Mol :¶

performs the disconnection

C++ signature :: RDKit::ROMol* Disconnect((anonymous namespace)::MetalDisconnectorWrap {lvalue},RDKit::ROMol)

DisconnectInPlace((MetalDisconnector)self, (Mol)mol) → None :¶

performs the disconnection, modifies the input molecule

C++ signature :: void DisconnectInPlace((anonymous namespace)::MetalDisconnectorWrap {lvalue},RDKit::ROMol {lvalue})

property MetalNof¶: SMARTS defining the metals to disconnect if attached to Nitrogen, Oxygen or Fluorine

property MetalNon¶: SMARTS defining the metals to disconnect other inorganic elements

SetMetalNof((MetalDisconnector)self, (Mol)mol) → None :¶

Set the query molecule defining the metals to disconnect if attached to Nitrogen, Oxygen or Fluorine.

C++ signature :: void SetMetalNof((anonymous namespace)::MetalDisconnectorWrap {lvalue},RDKit::ROMol)

SetMetalNon((MetalDisconnector)self, (Mol)mol) → None :¶

Set the query molecule defining the metals to disconnect from other inorganic elements.

C++ signature :: void SetMetalNon((anonymous namespace)::MetalDisconnectorWrap {lvalue},RDKit::ROMol)

class rdkit.Chem.MolStandardize.rdMolStandardize.MetalDisconnectorOptions((object)self)¶

Bases: instance

Metal Disconnector Options

C++ signature :: void __init__(_object*)

property adjustCharges¶: Whether to adjust charges on ligand atoms. Default true.

property removeHapticDummies¶: Whether to remove the dummy atoms representing haptic bonds. Such dummies are bonded to the metal with a bond that has the MolFileBondEndPts prop set. Default false.

property splitAromaticC¶: Whether to split metal-aromatic C bonds. Default false.

property splitGrignards¶: Whether to split Grignard-type complexes. Default false.

class rdkit.Chem.MolStandardize.rdMolStandardize.MolVSValidation((object)arg1)¶

Bases: ValidationMethod

C++ signature :
void __init__(_object*)

__init__( (AtomPairsParameters)arg1, (AtomPairsParameters)arg2) -> object :

C++ signature :
void* __init__(boost::python::api::object,boost::python::api::object)

class rdkit.Chem.MolStandardize.rdMolStandardize.NeutralValidation((object)arg1)¶

Bases: ValidationMethod

C++ signature :: void __init__(_object*)

class rdkit.Chem.MolStandardize.rdMolStandardize.NoAtomValidation((object)arg1)¶

Bases: ValidationMethod

C++ signature :: void __init__(_object*)

rdkit.Chem.MolStandardize.rdMolStandardize.Normalize((Mol)mol[, (AtomPairsParameters)params=None]) → Mol :¶

Applies a series of standard transformations to correct functional groups and recombine charges

C++ signature :: RDKit::ROMol* Normalize(RDKit::ROMol const* [,boost::python::api::object=None])

rdkit.Chem.MolStandardize.rdMolStandardize.NormalizeInPlace((Mol)mol[, (AtomPairsParameters)params=None]) → None :¶

Applies a series of standard transformations to correct functional groups and recombine charges, modifies the input molecule

C++ signature :
void NormalizeInPlace(RDKit::ROMol* [,boost::python::api::object=None])

NormalizeInPlace( (AtomPairsParameters)mols, (int)numThreads [, (AtomPairsParameters)params=None]) -> None :

Normalizes multiple molecules in place

C++ signature :: void NormalizeInPlace(boost::python::api::object,int [,boost::python::api::object=None])

class rdkit.Chem.MolStandardize.rdMolStandardize.Normalizer((object)self)¶

Bases: instance

C++ signature :
void __init__(_object*)

__init__( (object)self, (str)normalizeFilename, (int)maxRestarts) -> None :

C++ signature :
void __init__(_object*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,unsigned int)

normalize((Normalizer)self, (Mol)mol) → Mol :¶

C++ signature :: RDKit::ROMol* normalize(RDKit::MolStandardize::Normalizer {lvalue},RDKit::ROMol)

normalizeInPlace((Normalizer)self, (Mol)mol) → None :¶

modifies the input molecule

C++ signature :: void normalizeInPlace(RDKit::MolStandardize::Normalizer {lvalue},RDKit::ROMol {lvalue})

rdkit.Chem.MolStandardize.rdMolStandardize.NormalizerFromData((str)paramData, (CleanupParameters)params) → Normalizer :¶

creates a Normalizer from a string containing normalization SMARTS

C++ signature :: RDKit::MolStandardize::Normalizer* NormalizerFromData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,RDKit::MolStandardize::CleanupParameters)

rdkit.Chem.MolStandardize.rdMolStandardize.NormalizerFromParams((CleanupParameters)params) → Normalizer :¶

creates a Normalizer from CleanupParameters

C++ signature :: RDKit::MolStandardize::Normalizer* NormalizerFromParams(RDKit::MolStandardize::CleanupParameters)

class rdkit.Chem.MolStandardize.rdMolStandardize.RDKitValidation((object)arg1)¶

Bases: ValidationMethod

C++ signature :: void __init__(_object*)

rdkit.Chem.MolStandardize.rdMolStandardize.Reionize((Mol)mol[, (AtomPairsParameters)params=None]) → Mol :¶

Ensures the strongest acid groups are charged first

C++ signature :: RDKit::ROMol* Reionize(RDKit::ROMol const* [,boost::python::api::object=None])

rdkit.Chem.MolStandardize.rdMolStandardize.ReionizeInPlace((Mol)mol[, (AtomPairsParameters)params=None]) → None :¶

Ensures the strongest acid groups are charged first, modifies the input molecule

C++ signature :
void ReionizeInPlace(RDKit::ROMol* [,boost::python::api::object=None])

ReionizeInPlace( (AtomPairsParameters)mols, (int)numThreads [, (AtomPairsParameters)params=None]) -> None :

Reionizes multiple molecules in place

C++ signature :: void ReionizeInPlace(boost::python::api::object,int [,boost::python::api::object=None])

class rdkit.Chem.MolStandardize.rdMolStandardize.Reionizer((object)self)¶

Bases: instance

C++ signature :
void __init__(_object*)

__init__( (object)self, (str)acidbaseFile) -> None :

C++ signature :
void __init__(_object*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

__init__( (object)self, (str)acidbaseFile, (object)ccs) -> None :

C++ signature :
void __init__(_object*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,std::vector<RDKit::MolStandardize::ChargeCorrection, std::allocator<RDKit::MolStandardize::ChargeCorrection> >)

reionize((Reionizer)self, (Mol)mol) → Mol :¶

C++ signature :: RDKit::ROMol* reionize(RDKit::MolStandardize::Reionizer {lvalue},RDKit::ROMol)

reionizeInPlace((Reionizer)self, (Mol)mol) → None :¶

modifies the input molecule

C++ signature :: void reionizeInPlace(RDKit::MolStandardize::Reionizer {lvalue},RDKit::ROMol {lvalue})

rdkit.Chem.MolStandardize.rdMolStandardize.ReionizerFromData((str)paramData[, (AtomPairsParameters)chargeCorrections=[]]) → Reionizer :¶

creates a reionizer from a string containing parameter data and a list of charge corrections

C++ signature :: RDKit::MolStandardize::Reionizer* ReionizerFromData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > [,boost::python::api::object=[]])

rdkit.Chem.MolStandardize.rdMolStandardize.RemoveFragments((Mol)mol[, (AtomPairsParameters)params=None]) → Mol :¶

Removes fragments from the molecule

C++ signature :: RDKit::ROMol* RemoveFragments(RDKit::ROMol const* [,boost::python::api::object=None])

rdkit.Chem.MolStandardize.rdMolStandardize.RemoveFragmentsInPlace((Mol)mol[, (AtomPairsParameters)params=None]) → None :¶

Removes fragments from the molecule, modifies the input molecule

C++ signature :
void RemoveFragmentsInPlace(RDKit::ROMol* [,boost::python::api::object=None])

RemoveFragmentsInPlace( (AtomPairsParameters)mols, (int)numThreads [, (AtomPairsParameters)params=None]) -> None :

Removes fragments from multiple molecules in place

C++ signature :: void RemoveFragmentsInPlace(boost::python::api::object,int [,boost::python::api::object=None])

class rdkit.Chem.MolStandardize.rdMolStandardize.SmilesTautomerMap¶

Bases: instance

maps SMILES strings to the respective Tautomer objects

Raises an exception This class cannot be instantiated from Python

items((SmilesTautomerMap)self) → tuple :¶

C++ signature :: boost::python::tuple items(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, RDKit::MolStandardize::Tautomer, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, RDKit::MolStandardize::Tautomer> > >)

keys((SmilesTautomerMap)self) → tuple :¶

C++ signature :: boost::python::tuple keys(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, RDKit::MolStandardize::Tautomer, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, RDKit::MolStandardize::Tautomer> > >)

values((SmilesTautomerMap)self) → tuple :¶

C++ signature :: boost::python::tuple values(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, RDKit::MolStandardize::Tautomer, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, RDKit::MolStandardize::Tautomer> > >)

rdkit.Chem.MolStandardize.rdMolStandardize.StandardizeSmiles((str)smiles) → str :¶

Convenience function for standardizing a SMILES

C++ signature :: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > StandardizeSmiles(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

rdkit.Chem.MolStandardize.rdMolStandardize.StereoParent((Mol)mol[, (AtomPairsParameters)params=None[, (bool)skipStandardize=False]]) → Mol :¶

Generates the largest fragment in place for multiple molecules

C++ signature :: RDKit::ROMol* StereoParent(RDKit::ROMol const* [,boost::python::api::object=None [,bool=False]])

rdkit.Chem.MolStandardize.rdMolStandardize.StereoParentInPlace((Mol)mol[, (AtomPairsParameters)params=None[, (bool)skipStandardize=False]]) → None :¶

Generates the stereo parent in place

C++ signature :
void StereoParentInPlace(RDKit::ROMol* [,boost::python::api::object=None [,bool=False]])

StereoParentInPlace( (AtomPairsParameters)mols, (int)numThreads [, (AtomPairsParameters)params=None [, (bool)skipStandardize=False]]) -> None :

Generates the stereo parent in place for multiple molecules

C++ signature :: void StereoParentInPlace(boost::python::api::object,int [,boost::python::api::object=None [,bool=False]])

rdkit.Chem.MolStandardize.rdMolStandardize.SuperParent((Mol)mol[, (AtomPairsParameters)params=None[, (bool)skipStandardize=False]]) → Mol :¶

Returns the super parent. The super parent is the fragment, charge, isotope, stereo, and tautomer parent of the molecule.

C++ signature :: RDKit::ROMol* SuperParent(RDKit::ROMol const* [,boost::python::api::object=None [,bool=False]])

rdkit.Chem.MolStandardize.rdMolStandardize.SuperParentInPlace((Mol)mol[, (AtomPairsParameters)params=None[, (bool)skipStandardize=False]]) → None :¶

Generates the super parent in place

C++ signature :
void SuperParentInPlace(RDKit::ROMol* [,boost::python::api::object=None [,bool=False]])

SuperParentInPlace( (AtomPairsParameters)mols, (int)numThreads [, (AtomPairsParameters)params=None [, (bool)skipStandardize=False]]) -> None :

Generates the super parent in place for multiple molecules

C++ signature :: void SuperParentInPlace(boost::python::api::object,int [,boost::python::api::object=None [,bool=False]])

class rdkit.Chem.MolStandardize.rdMolStandardize.Tautomer¶

Bases: instance

used to hold the aromatic and kekulized versions of each tautomer

Raises an exception This class cannot be instantiated from Python

property kekulized¶: kekulized version of the tautomer

property tautomer¶: aromatic version of the tautomer

class rdkit.Chem.MolStandardize.rdMolStandardize.TautomerEnumerator((AtomPairsParameters)arg1)¶

Bases: instance

C++ signature :
void* __init__(boost::python::api::object)

__init__( (AtomPairsParameters)arg1, (CleanupParameters)arg2) -> object :

C++ signature :
void* __init__(boost::python::api::object,RDKit::MolStandardize::CleanupParameters)

__init__( (AtomPairsParameters)arg1, (TautomerEnumerator)arg2) -> object :

C++ signature :
void* __init__(boost::python::api::object,RDKit::MolStandardize::TautomerEnumerator)

Canonicalize((TautomerEnumerator)self, (Mol)mol) → Mol :¶

Returns the canonical tautomer for a molecule.

The default scoring scheme is inspired by the publication: M. Sitzmann et al., “Tautomerism in Large Databases.”, JCAMD 24:521 (2010) https://doi.org/10.1007/s10822-010-9346-4

Note that the canonical tautomer is very likely not the most stable tautomer for any given conditions. The default scoring rules are designed to produce “reasonable” tautomers, but the primary concern is that the results are canonical: you always get the same canonical tautomer for a molecule regardless of what the input tautomer or atom ordering were.

C++ signature :
RDKit::ROMol* Canonicalize(RDKit::MolStandardize::TautomerEnumerator,RDKit::ROMol)

Canonicalize( (TautomerEnumerator)self, (Mol)mol, (AtomPairsParameters)scoreFunc) -> Mol :

picks the canonical tautomer from an iterable of molecules using a custom scoring function

C++ signature :: RDKit::ROMol* Canonicalize(RDKit::MolStandardize::TautomerEnumerator,RDKit::ROMol,boost::python::api::object)

Enumerate((TautomerEnumerator)self, (Mol)mol) → TautomerEnumeratorResult :¶

Generates the tautomers for a molecule.

The enumeration rules are inspired by the publication: M. Sitzmann et al., “Tautomerism in Large Databases.”, JCAMD 24:521 (2010) https://doi.org/10.1007/s10822-010-9346-4

Note: the definitions used here are that the atoms modified during tautomerization are the atoms at the beginning and end of each tautomer transform (the H “donor” and H “acceptor” in the transform) and the bonds modified during transformation are any bonds whose order is changed during the tautomer transform (these are the bonds between the “donor” and the “acceptor”).

C++ signature :: (anonymous namespace)::PyTautomerEnumeratorResult* Enumerate(RDKit::MolStandardize::TautomerEnumerator,RDKit::ROMol)

GetCallback((TautomerEnumerator)self) → object :¶

Get the TautomerEnumeratorCallback subclass instance, or None if none was set.

C++ signature :: boost::python::api::object GetCallback(RDKit::MolStandardize::TautomerEnumerator)

GetMaxTautomers((TautomerEnumerator)self) → int :¶

returns the maximum number of tautomers to be generated.

C++ signature :: unsigned int GetMaxTautomers(RDKit::MolStandardize::TautomerEnumerator {lvalue})

GetMaxTransforms((TautomerEnumerator)self) → int :¶

returns the maximum number of transformations to be applied.

C++ signature :: unsigned int GetMaxTransforms(RDKit::MolStandardize::TautomerEnumerator {lvalue})

GetReassignStereo((TautomerEnumerator)self) → bool :¶

returns whether AssignStereochemistry will be called on each tautomer generated by the Enumerate() method.

C++ signature :: bool GetReassignStereo(RDKit::MolStandardize::TautomerEnumerator {lvalue})

GetRemoveBondStereo((TautomerEnumerator)self) → bool :¶

returns whether stereochemistry information will be removed from double bonds involved in tautomerism.

C++ signature :: bool GetRemoveBondStereo(RDKit::MolStandardize::TautomerEnumerator {lvalue})

GetRemoveSp3Stereo((TautomerEnumerator)self) → bool :¶

returns whether stereochemistry information will be removed from sp3 atoms involved in tautomerism.

C++ signature :: bool GetRemoveSp3Stereo(RDKit::MolStandardize::TautomerEnumerator {lvalue})

PickCanonical((TautomerEnumerator)self, (AtomPairsParameters)iterable) → Mol :¶

picks the canonical tautomer from an iterable of molecules

C++ signature :
RDKit::ROMol* PickCanonical(RDKit::MolStandardize::TautomerEnumerator,boost::python::api::object)

PickCanonical( (TautomerEnumerator)self, (AtomPairsParameters)iterable, (AtomPairsParameters)scoreFunc) -> Mol :

returns the canonical tautomer for a molecule using a custom scoring function

C++ signature :: RDKit::ROMol* PickCanonical(RDKit::MolStandardize::TautomerEnumerator,boost::python::api::object,boost::python::api::object)

static ScoreTautomer((Mol)mol) → int :¶

returns the score for a tautomer using the default scoring scheme.

C++ signature :: int ScoreTautomer(RDKit::ROMol)

SetCallback((TautomerEnumerator)self, (object)callback) → None :¶

Pass an instance of a class derived from TautomerEnumeratorCallback, which must implement the __call__() method.

C++ signature :: void SetCallback(RDKit::MolStandardize::TautomerEnumerator {lvalue},_object*)

SetMaxTautomers((TautomerEnumerator)self, (int)maxTautomers) → None :¶

set the maximum number of tautomers to be generated.

C++ signature :: void SetMaxTautomers(RDKit::MolStandardize::TautomerEnumerator {lvalue},unsigned int)

SetMaxTransforms((TautomerEnumerator)self, (int)maxTransforms) → None :¶

set the maximum number of transformations to be applied. This limit is usually hit earlier than the maxTautomers limit and leads to a more linear scaling of CPU time with increasing number of tautomeric centers (see Sitzmann et al.).

C++ signature :: void SetMaxTransforms(RDKit::MolStandardize::TautomerEnumerator {lvalue},unsigned int)

SetReassignStereo((TautomerEnumerator)self, (bool)reassignStereo) → None :¶

set to True if you wish AssignStereochemistry to be called on each tautomer generated by the Enumerate() method. This defaults to True.

C++ signature :: void SetReassignStereo(RDKit::MolStandardize::TautomerEnumerator {lvalue},bool)

SetRemoveBondStereo((TautomerEnumerator)self, (bool)removeBondStereo) → None :¶

set to True if you wish stereochemistry information to be removed from double bonds involved in tautomerism. This means that enols will lose their E/Z stereochemistry after going through tautomer enumeration because of the keto-enolic tautomerism. This defaults to True in the RDKit and also in the workflow described by Sitzmann et al.

C++ signature :: void SetRemoveBondStereo(RDKit::MolStandardize::TautomerEnumerator {lvalue},bool)

SetRemoveSp3Stereo((TautomerEnumerator)self, (bool)removeSp3Stereo) → None :¶

set to True if you wish stereochemistry information to be removed from sp3 atoms involved in tautomerism. This means that S-aminoacids will lose their stereochemistry after going through tautomer enumeration because of the amido-imidol tautomerism. This defaults to True in RDKit, and to False in the workflow described by Sitzmann et al.

C++ signature :: void SetRemoveSp3Stereo(RDKit::MolStandardize::TautomerEnumerator {lvalue},bool)

tautomerScoreVersion = '1.0.0'¶

class rdkit.Chem.MolStandardize.rdMolStandardize.TautomerEnumeratorCallback((object)self)¶

Bases: instance

Create a derived class from this abstract base class and implement the __call__() method. The __call__() method is called in the innermost loop of the algorithm, and provides a mechanism to monitor or stop its progress.

To have your callback called, pass an instance of your derived class to TautomerEnumerator.SetCallback()

C++ signature :: void __init__(_object*)

class rdkit.Chem.MolStandardize.rdMolStandardize.TautomerEnumeratorResult¶

Bases: instance

used to return tautomer enumeration results

Raises an exception This class cannot be instantiated from Python

property modifiedAtoms¶: tuple of atom indices modified by the transforms

property modifiedBonds¶: tuple of bond indices modified by the transforms

property smiles¶: SMILES of tautomers generated by the enumerator

property smilesTautomerMap¶: dictionary mapping SMILES strings to the respective Tautomer objects

property status¶: whether the enumeration completed or not; see TautomerEnumeratorStatus for possible values

property tautomers¶: tautomers generated by the enumerator

class rdkit.Chem.MolStandardize.rdMolStandardize.TautomerEnumeratorStatus¶

Bases: enum

Canceled = rdkit.Chem.MolStandardize.rdMolStandardize.TautomerEnumeratorStatus.Canceled¶

Completed = rdkit.Chem.MolStandardize.rdMolStandardize.TautomerEnumeratorStatus.Completed¶

MaxTautomersReached = rdkit.Chem.MolStandardize.rdMolStandardize.TautomerEnumeratorStatus.MaxTautomersReached¶

MaxTransformsReached = rdkit.Chem.MolStandardize.rdMolStandardize.TautomerEnumeratorStatus.MaxTransformsReached¶

names = {'Canceled': rdkit.Chem.MolStandardize.rdMolStandardize.TautomerEnumeratorStatus.Canceled, 'Completed': rdkit.Chem.MolStandardize.rdMolStandardize.TautomerEnumeratorStatus.Completed, 'MaxTautomersReached': rdkit.Chem.MolStandardize.rdMolStandardize.TautomerEnumeratorStatus.MaxTautomersReached, 'MaxTransformsReached': rdkit.Chem.MolStandardize.rdMolStandardize.TautomerEnumeratorStatus.MaxTransformsReached}¶

values = {0: rdkit.Chem.MolStandardize.rdMolStandardize.TautomerEnumeratorStatus.Completed, 1: rdkit.Chem.MolStandardize.rdMolStandardize.TautomerEnumeratorStatus.MaxTautomersReached, 2: rdkit.Chem.MolStandardize.rdMolStandardize.TautomerEnumeratorStatus.MaxTransformsReached, 3: rdkit.Chem.MolStandardize.rdMolStandardize.TautomerEnumeratorStatus.Canceled}¶

rdkit.Chem.MolStandardize.rdMolStandardize.TautomerParent((Mol)mol[, (AtomPairsParameters)params=None[, (bool)skipStandardize=False]]) → Mol :¶

Returns the tautomer parent of a given molecule. The fragment parent is the standardized canonical tautomer of the molecule

C++ signature :: RDKit::ROMol* TautomerParent(RDKit::ROMol const* [,boost::python::api::object=None [,bool=False]])

rdkit.Chem.MolStandardize.rdMolStandardize.TautomerParentInPlace((Mol)mol[, (AtomPairsParameters)params=None[, (bool)skipStandardize=False]]) → None :¶

Generates the tautomer parent in place

C++ signature :
void TautomerParentInPlace(RDKit::ROMol* [,boost::python::api::object=None [,bool=False]])

TautomerParentInPlace( (AtomPairsParameters)mols, (int)numThreads [, (AtomPairsParameters)params=None [, (bool)skipStandardize=False]]) -> None :

Generates the tautomer parent in place for multiple molecules

C++ signature :: void TautomerParentInPlace(boost::python::api::object,int [,boost::python::api::object=None [,bool=False]])

class rdkit.Chem.MolStandardize.rdMolStandardize.Uncharger((object)self[, (bool)canonicalOrder=True[, (bool)force=False]])¶

Bases: instance

C++ signature :: void __init__(_object* [,bool=True [,bool=False]])

uncharge((Uncharger)self, (Mol)mol) → Mol :¶

C++ signature :: RDKit::ROMol* uncharge(RDKit::MolStandardize::Uncharger {lvalue},RDKit::ROMol)

unchargeInPlace((Uncharger)self, (Mol)mol) → None :¶

modifies the input molecule

C++ signature :: void unchargeInPlace(RDKit::MolStandardize::Uncharger {lvalue},RDKit::ROMol {lvalue})

rdkit.Chem.MolStandardize.rdMolStandardize.UpdateParamsFromJSON((CleanupParameters)params, (str)json) → None :¶

updates the cleanup parameters from the provided JSON string

C++ signature :: void UpdateParamsFromJSON(RDKit::MolStandardize::CleanupParameters {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

rdkit.Chem.MolStandardize.rdMolStandardize.ValidateSmiles((str)mol) → list :¶

C++ signature :: boost::python::list ValidateSmiles(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

class rdkit.Chem.MolStandardize.rdMolStandardize.ValidationMethod((object)arg1)¶

Bases: instance

C++ signature :: void __init__(_object*)

validate((ValidationMethod)self, (Mol)mol[, (bool)reportAllFailures=False]) → list :¶

C++ signature :: boost::python::list validate(RDKit::MolStandardize::ValidationMethod,RDKit::ROMol [,bool=False])

class rdkit.Chem.MolStandardize.rdMolStandardize.map_indexing_suite_SmilesTautomerMap_entry((object)arg1)¶

Bases: instance

C++ signature :: void __init__(_object*)

data((map_indexing_suite_SmilesTautomerMap_entry)arg1) → Tautomer :¶

C++ signature :: RDKit::MolStandardize::Tautomer data(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, RDKit::MolStandardize::Tautomer> {lvalue})

key((map_indexing_suite_SmilesTautomerMap_entry)arg1) → str :¶

C++ signature :: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > key(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, RDKit::MolStandardize::Tautomer> {lvalue})

rdkit.Chem.MolStandardize.rdMolStandardize module¶

Table of Contents

Previous topic

Next topic

This Page