rdkit.Chem.MolStandardize.rdMolStandardize module — The RDKit 2025.09.6 documentation

# rdkit.Chem.MolStandardize.rdMolStandardize module

Module containing tools for normalizing molecules defined by SMARTS patterns

class rdkit.Chem.MolStandardize.rdMolStandardize.AllowedAtomsValidation((object)arg1, (object)arg2) → object :

  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((rdkit.Chem.rdchem.Mol)mol[, (object)params=None]) → rdkit.Chem.rdchem.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) → None :

  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

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.ChargeCorrection)arg1) -> int:

    C++ signature :

      int {lvalue} None(RDKit::MolStandardize::ChargeCorrection {lvalue})

  property Name

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.ChargeCorrection)arg1) -> str:

    C++ signature :

      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(RDKit::MolStandardize::ChargeCorrection {lvalue})

  property Smarts

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.ChargeCorrection)arg1) -> str:

    C++ signature :

      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(RDKit::MolStandardize::ChargeCorrection {lvalue})

rdkit.Chem.MolStandardize.rdMolStandardize.ChargeParent((rdkit.Chem.rdchem.Mol)mol[, (object)params=None[, (bool)skipStandardize=False]]) → rdkit.Chem.rdchem.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((rdkit.Chem.rdchem.Mol)mol[, (object)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( (object)mols, (int)numThreads [, (object)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((rdkit.Chem.rdchem.Mol)mol[, (object)params=None]) → rdkit.Chem.rdchem.Mol :

  Standardizes a molecule

  C++ signature :

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

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

  Standardizes a molecule in place

  > C++ signature :

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

  CleanupInPlace( (object)mols, (int)numThreads [, (object)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) → None :

  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((object)arg1, (object)arg2) → object :

  Bases: `ValidationMethod`

  C++ signature :

    void* __init__(boost::python::api::object,boost::python::api::object)

class rdkit.Chem.MolStandardize.rdMolStandardize.DisallowedRadicalValidation((object)arg1) → None :

  Bases: `ValidationMethod`

  C++ signature :

    void __init__(_object*)

rdkit.Chem.MolStandardize.rdMolStandardize.DisconnectOrganometallics((rdkit.Chem.rdchem.Mol)mol[, (object)params=None]) → rdkit.Chem.rdchem.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((rdkit.Chem.rdchem.Mol)mol[, (object)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])

class rdkit.Chem.MolStandardize.rdMolStandardize.FeaturesValidation((object)arg1) → None :

  Bases: `ValidationMethod`

  > C++ signature :

  >   void __init__(_object*)

  __init__( (object)arg1 [, (bool)allowEnhancedStereo=False [, (bool)allowAromaticBondType=False [, (bool)allowDativeBondType=False [, (bool)allowQueries=False [, (bool)allowDummmies=False [, (bool)allowAtomAliases=False]]]]]]) -> None :

  > C++ signature :

  >   void __init__(_object* [,bool=False [,bool=False [,bool=False [,bool=False [,bool=False [,bool=False]]]]]])

  property allowAromaticBondType

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.FeaturesValidation)arg1) -> bool:

    C++ signature :

      bool {lvalue} None(RDKit::MolStandardize::FeaturesValidation {lvalue})

  property allowAtomAliases

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.FeaturesValidation)arg1) -> bool:

    C++ signature :

      bool {lvalue} None(RDKit::MolStandardize::FeaturesValidation {lvalue})

  property allowDativeBondType

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.FeaturesValidation)arg1) -> bool:

    C++ signature :

      bool {lvalue} None(RDKit::MolStandardize::FeaturesValidation {lvalue})

  property allowDummies

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.FeaturesValidation)arg1) -> bool:

    C++ signature :

      bool {lvalue} None(RDKit::MolStandardize::FeaturesValidation {lvalue})

  property allowEnhancedStereo

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.FeaturesValidation)arg1) -> bool:

    C++ signature :

      bool {lvalue} None(RDKit::MolStandardize::FeaturesValidation {lvalue})

  property allowQueries

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.FeaturesValidation)arg1) -> bool:

    C++ signature :

      bool {lvalue} None(RDKit::MolStandardize::FeaturesValidation {lvalue})

rdkit.Chem.MolStandardize.rdMolStandardize.FragmentParent((rdkit.Chem.rdchem.Mol)mol[, (object)params=None[, (bool)skipStandardize=False]]) → rdkit.Chem.rdchem.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((rdkit.Chem.rdchem.Mol)mol[, (object)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( (object)mols, (int)numThreads [, (object)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) → None :

  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, (rdkit.Chem.rdchem.Mol)mol) → rdkit.Chem.rdchem.Mol :
    C++ signature :

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

  removeInPlace((FragmentRemover)self, (rdkit.Chem.rdchem.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) → None :

  Bases: `ValidationMethod`

  C++ signature :

    void __init__(_object*)

rdkit.Chem.MolStandardize.rdMolStandardize.GetDefaultTautomerScoreSubstructs() → SubstructTermVector :

  Return the default tautomer substructure scoring terms

  C++ signature :

    std::vector<RDKit::MolStandardize::TautomerScoringFunctions::SubstructTerm, std::allocator<RDKit::MolStandardize::TautomerScoringFunctions::SubstructTerm> > GetDefaultTautomerScoreSubstructs()

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

  return a TautomerEnumerator using v1 of the enumeration rules

  C++ signature :

    RDKit::MolStandardize::TautomerEnumerator* GetV1TautomerEnumerator()

class rdkit.Chem.MolStandardize.rdMolStandardize.Is2DValidation((object)arg1) → None :

  Bases: `ValidationMethod`

  > C++ signature :

  >   void __init__(_object*)

  __init__( (object)arg1 [, (float)threshold=0.001]) -> None :

  > C++ signature :

  >   void __init__(_object* [,double=0.001])

  property threshold

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.Is2DValidation)arg1) -> float:

    C++ signature :

      double {lvalue} None(RDKit::MolStandardize::Is2DValidation {lvalue})

rdkit.Chem.MolStandardize.rdMolStandardize.IsotopeParent((rdkit.Chem.rdchem.Mol)mol[, (object)params=None[, (bool)skipStandardize=False]]) → rdkit.Chem.rdchem.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((rdkit.Chem.rdchem.Mol)mol[, (object)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( (object)mols, (int)numThreads [, (object)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) → None :

  Bases: `ValidationMethod`

  > C++ signature :

  >   void __init__(_object*)

  __init__( (object)arg1 [, (bool)strict=False]) -> None :

  > C++ signature :

  >   void __init__(_object* [,bool=False])

  property strict

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.IsotopeValidation)arg1) -> bool:

    C++ signature :

      bool {lvalue} None(RDKit::MolStandardize::IsotopeValidation {lvalue})

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

  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, (rdkit.Chem.rdchem.Mol)mol) → rdkit.Chem.rdchem.Mol :
    C++ signature :

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

  chooseInPlace((LargestFragmentChooser)self, (rdkit.Chem.rdchem.Mol)mol) → None :
    C++ signature :

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

class rdkit.Chem.MolStandardize.rdMolStandardize.Layout2DValidation((object)arg1) → None :

  Bases: `ValidationMethod`

  > C++ signature :

  >   void __init__(_object*)

  __init__( (object)arg1 [, (float)clashLimit=0.15 [, (float)bondLengthLimit=25.0 [, (bool)allowLongBondsInRings=True [, (bool)allowAtomBondClashExemption=True [, (float)minMedianBondLength=False]]]]]) -> None :

  > C++ signature :

  >   void __init__(_object* [,double=0.15 [,double=25.0 [,bool=True [,bool=True [,double=False]]]]])

  property allowAtomBondClashExemption

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.Layout2DValidation)arg1) -> bool:

    C++ signature :

      bool {lvalue} None(RDKit::MolStandardize::Layout2DValidation {lvalue})

  property allowLongBondsInRings

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.Layout2DValidation)arg1) -> bool:

    C++ signature :

      bool {lvalue} None(RDKit::MolStandardize::Layout2DValidation {lvalue})

  property bondLengthLimit

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.Layout2DValidation)arg1) -> float:

    C++ signature :

      double {lvalue} None(RDKit::MolStandardize::Layout2DValidation {lvalue})

  property clashLimit

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.Layout2DValidation)arg1) -> float:

    C++ signature :

      double {lvalue} None(RDKit::MolStandardize::Layout2DValidation {lvalue})

  property minMedianBondLength

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.Layout2DValidation)arg1) -> float:

    C++ signature :

      double {lvalue} None(RDKit::MolStandardize::Layout2DValidation {lvalue})

class rdkit.Chem.MolStandardize.rdMolStandardize.MOL_SPTR_VECT((object)arg1) → None :

  Bases: `instance`

  C++ signature :

    void __init__(_object*)

  append((MOL_SPTR_VECT)arg1, (object)arg2) → None :
    C++ signature :

      void append(std::vector<boost::shared_ptr<RDKit::ROMol>, std::allocator<boost::shared_ptr<RDKit::ROMol> > > {lvalue},boost::python::api::object)

  extend((MOL_SPTR_VECT)arg1, (object)arg2) → None :
    C++ signature :

      void extend(std::vector<boost::shared_ptr<RDKit::ROMol>, std::allocator<boost::shared_ptr<RDKit::ROMol> > > {lvalue},boost::python::api::object)

class rdkit.Chem.MolStandardize.rdMolStandardize.MetalDisconnector((object)self[, (object)options=None]) → 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, (rdkit.Chem.rdchem.Mol)mol) → rdkit.Chem.rdchem.Mol :

    performs the disconnection

    C++ signature :

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

  DisconnectInPlace((MetalDisconnector)self, (rdkit.Chem.rdchem.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, (rdkit.Chem.rdchem.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, (rdkit.Chem.rdchem.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) → None :

  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) → None :

  Bases: `ValidationMethod`

  > C++ signature :

  >   void __init__(_object*)

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

  > C++ signature :

  >   void* __init__(boost::python::api::object,boost::python::api::object)

class rdkit.Chem.MolStandardize.rdMolStandardize.NeutralValidation((object)arg1) → None :

  Bases: `ValidationMethod`

  C++ signature :

    void __init__(_object*)

class rdkit.Chem.MolStandardize.rdMolStandardize.NoAtomValidation((object)arg1) → None :

  Bases: `ValidationMethod`

  C++ signature :

    void __init__(_object*)

rdkit.Chem.MolStandardize.rdMolStandardize.Normalize((rdkit.Chem.rdchem.Mol)mol[, (object)params=None]) → rdkit.Chem.rdchem.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((rdkit.Chem.rdchem.Mol)mol[, (object)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( (object)mols, (int)numThreads [, (object)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) → None :

  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, (rdkit.Chem.rdchem.Mol)mol) → rdkit.Chem.rdchem.Mol :
    C++ signature :

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

  normalizeInPlace((Normalizer)self, (rdkit.Chem.rdchem.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.Pipeline((object)arg1) → None :

  Bases: `instance`

  > C++ signature :

  >   void __init__(_object*)

  __init__( (object)arg1, (PipelineOptions)arg2) -> None :

  > C++ signature :

  >   void __init__(_object*,RDKit::MolStandardize::PipelineOptions)

  run((Pipeline)arg1, (str)arg2) → PipelineResult :
    C++ signature :

      RDKit::MolStandardize::PipelineResult run(RDKit::MolStandardize::Pipeline {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

class rdkit.Chem.MolStandardize.rdMolStandardize.PipelineLog

  Bases: `instance`

  Raises an exception This class cannot be instantiated from Python

  append((PipelineLog)arg1, (object)arg2) → None :
    C++ signature :

      void append(std::vector<RDKit::MolStandardize::PipelineLogEntry, std::allocator<RDKit::MolStandardize::PipelineLogEntry> > {lvalue},boost::python::api::object)

  extend((PipelineLog)arg1, (object)arg2) → None :
    C++ signature :

      void extend(std::vector<RDKit::MolStandardize::PipelineLogEntry, std::allocator<RDKit::MolStandardize::PipelineLogEntry> > {lvalue},boost::python::api::object)

class rdkit.Chem.MolStandardize.rdMolStandardize.PipelineLogEntry

  Bases: `instance`

  Raises an exception This class cannot be instantiated from Python

  property detail

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.PipelineLogEntry)arg1) -> str:

    C++ signature :

      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(RDKit::MolStandardize::PipelineLogEntry {lvalue})

  property status

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.PipelineLogEntry)arg1) -> rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus:

    C++ signature :

      RDKit::MolStandardize::PipelineStatus {lvalue} None(RDKit::MolStandardize::PipelineLogEntry {lvalue})

class rdkit.Chem.MolStandardize.rdMolStandardize.PipelineOptions((object)arg1) → None :

  Bases: `instance`

  C++ signature :

    void __init__(_object*)

  property allowAromaticBondType

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.PipelineOptions)arg1) -> bool:

    C++ signature :

      bool {lvalue} None(RDKit::MolStandardize::PipelineOptions {lvalue})

  property allowAtomBondClashExemption

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.PipelineOptions)arg1) -> bool:

    C++ signature :

      bool {lvalue} None(RDKit::MolStandardize::PipelineOptions {lvalue})

  property allowDativeBondType

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.PipelineOptions)arg1) -> bool:

    C++ signature :

      bool {lvalue} None(RDKit::MolStandardize::PipelineOptions {lvalue})

  property allowEmptyMolecules

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.PipelineOptions)arg1) -> bool:

    C++ signature :

      bool {lvalue} None(RDKit::MolStandardize::PipelineOptions {lvalue})

  property allowEnhancedStereo

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.PipelineOptions)arg1) -> bool:

    C++ signature :

      bool {lvalue} None(RDKit::MolStandardize::PipelineOptions {lvalue})

  property allowLongBondsInRings

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.PipelineOptions)arg1) -> bool:

    C++ signature :

      bool {lvalue} None(RDKit::MolStandardize::PipelineOptions {lvalue})

  property atomClashLimit

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.PipelineOptions)arg1) -> float:

    C++ signature :

      double {lvalue} None(RDKit::MolStandardize::PipelineOptions {lvalue})

  property bondLengthLimit

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.PipelineOptions)arg1) -> float:

    C++ signature :

      double {lvalue} None(RDKit::MolStandardize::PipelineOptions {lvalue})

  property is2DZeroThreshold

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.PipelineOptions)arg1) -> float:

    C++ signature :

      double {lvalue} None(RDKit::MolStandardize::PipelineOptions {lvalue})

  property metalNof

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.PipelineOptions)arg1) -> str:

    C++ signature :

      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(RDKit::MolStandardize::PipelineOptions {lvalue})

  property metalNon

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.PipelineOptions)arg1) -> str:

    C++ signature :

      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(RDKit::MolStandardize::PipelineOptions {lvalue})

  property minMedianBondLength

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.PipelineOptions)arg1) -> float:

    C++ signature :

      double {lvalue} None(RDKit::MolStandardize::PipelineOptions {lvalue})

  property normalizerData

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.PipelineOptions)arg1) -> str:

    C++ signature :

      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(RDKit::MolStandardize::PipelineOptions {lvalue})

  property normalizerMaxRestarts

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.PipelineOptions)arg1) -> int:

    C++ signature :

      unsigned int {lvalue} None(RDKit::MolStandardize::PipelineOptions {lvalue})

  property outputV2000

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.PipelineOptions)arg1) -> bool:

    C++ signature :

      bool {lvalue} None(RDKit::MolStandardize::PipelineOptions {lvalue})

  property reportAllFailures

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.PipelineOptions)arg1) -> bool:

    C++ signature :

      bool {lvalue} None(RDKit::MolStandardize::PipelineOptions {lvalue})

  property scaledMedianBondLength

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.PipelineOptions)arg1) -> float:

    C++ signature :

      double {lvalue} None(RDKit::MolStandardize::PipelineOptions {lvalue})

  property strictParsing

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.PipelineOptions)arg1) -> bool:

    C++ signature :

      bool {lvalue} None(RDKit::MolStandardize::PipelineOptions {lvalue})

class rdkit.Chem.MolStandardize.rdMolStandardize.PipelineResult

  Bases: `instance`

  Raises an exception This class cannot be instantiated from Python

  property inputMolData

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.PipelineResult)arg1) -> str:

    C++ signature :

      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(RDKit::MolStandardize::PipelineResult {lvalue})

  property log

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.PipelineResult)arg1) -> rdkit.Chem.MolStandardize.rdMolStandardize.PipelineLog:

    C++ signature :

      std::vector<RDKit::MolStandardize::PipelineLogEntry, std::allocator<RDKit::MolStandardize::PipelineLogEntry> > {lvalue} None(RDKit::MolStandardize::PipelineResult {lvalue})

  property outputMolData

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.PipelineResult)arg1) -> str:

    C++ signature :

      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(RDKit::MolStandardize::PipelineResult {lvalue})

  property parentMolData

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.PipelineResult)arg1) -> str:

    C++ signature :

      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(RDKit::MolStandardize::PipelineResult {lvalue})

  property stage

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.PipelineResult)arg1) -> int:

    C++ signature :

      unsigned int {lvalue} None(RDKit::MolStandardize::PipelineResult {lvalue})

  property status

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.PipelineResult)arg1) -> rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus:

    C++ signature :

      RDKit::MolStandardize::PipelineStatus {lvalue} None(RDKit::MolStandardize::PipelineResult {lvalue})

class rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStage

  Bases: `enum`

  COMPLETED = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStage.COMPLETED
  PARSING_INPUT = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStage.PARSING_INPUT
  PREPARE_FOR_STANDARDIZATION = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStage.PREPARE_FOR_STANDARDIZATION
  PREPARE_FOR_VALIDATION = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStage.PREPARE_FOR_VALIDATION
  SERIALIZING_OUTPUT = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStage.SERIALIZING_OUTPUT
  STANDARDIZATION = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStage.STANDARDIZATION
  VALIDATION = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStage.VALIDATION
  names = {'COMPLETED': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStage.COMPLETED, 'PARSING_INPUT': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStage.PARSING_INPUT, 'PREPARE_FOR_STANDARDIZATION': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStage.PREPARE_FOR_STANDARDIZATION, 'PREPARE_FOR_VALIDATION': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStage.PREPARE_FOR_VALIDATION, 'SERIALIZING_OUTPUT': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStage.SERIALIZING_OUTPUT, 'STANDARDIZATION': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStage.STANDARDIZATION, 'VALIDATION': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStage.VALIDATION}
  values = {1: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStage.PARSING_INPUT, 2: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStage.PREPARE_FOR_VALIDATION, 3: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStage.VALIDATION, 4: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStage.PREPARE_FOR_STANDARDIZATION, 5: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStage.STANDARDIZATION, 9: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStage.SERIALIZING_OUTPUT, 10: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStage.COMPLETED}

class rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus

  Bases: `enum`

  BASIC_VALIDATION_ERROR = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.BASIC_VALIDATION_ERROR
  CHARGE_STANDARDIZATION_ERROR = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.CHARGE_STANDARDIZATION_ERROR
  FEATURES_VALIDATION_ERROR = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.FEATURES_VALIDATION_ERROR
  FRAGMENTS_REMOVED = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.FRAGMENTS_REMOVED
  FRAGMENT_STANDARDIZATION_ERROR = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.FRAGMENT_STANDARDIZATION_ERROR
  INPUT_ERROR = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.INPUT_ERROR
  IS2D_VALIDATION_ERROR = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.IS2D_VALIDATION_ERROR
  LAYOUT2D_VALIDATION_ERROR = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.LAYOUT2D_VALIDATION_ERROR
  METALS_DISCONNECTED = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.METALS_DISCONNECTED
  METAL_STANDARDIZATION_ERROR = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.METAL_STANDARDIZATION_ERROR
  NORMALIZATION_APPLIED = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.NORMALIZATION_APPLIED
  NORMALIZER_STANDARDIZATION_ERROR = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.NORMALIZER_STANDARDIZATION_ERROR
  NO_EVENT = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.NO_EVENT
  OUTPUT_ERROR = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.OUTPUT_ERROR
  PIPELINE_ERROR = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.PIPELINE_ERROR
  PREPARE_FOR_STANDARDIZATION_ERROR = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.PREPARE_FOR_STANDARDIZATION_ERROR
  PREPARE_FOR_VALIDATION_ERROR = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.PREPARE_FOR_VALIDATION_ERROR
  PROTONATION_CHANGED = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.PROTONATION_CHANGED
  STANDARDIZATION_ERROR = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.STANDARDIZATION_ERROR
  STEREO_VALIDATION_ERROR = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.STEREO_VALIDATION_ERROR
  STRUCTURE_MODIFICATION = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.STRUCTURE_MODIFICATION
  VALIDATION_ERROR = rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.VALIDATION_ERROR
  names = {'BASIC_VALIDATION_ERROR': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.BASIC_VALIDATION_ERROR, 'CHARGE_STANDARDIZATION_ERROR': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.CHARGE_STANDARDIZATION_ERROR, 'FEATURES_VALIDATION_ERROR': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.FEATURES_VALIDATION_ERROR, 'FRAGMENTS_REMOVED': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.FRAGMENTS_REMOVED, 'FRAGMENT_STANDARDIZATION_ERROR': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.FRAGMENT_STANDARDIZATION_ERROR, 'INPUT_ERROR': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.INPUT_ERROR, 'IS2D_VALIDATION_ERROR': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.IS2D_VALIDATION_ERROR, 'LAYOUT2D_VALIDATION_ERROR': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.LAYOUT2D_VALIDATION_ERROR, 'METALS_DISCONNECTED': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.METALS_DISCONNECTED, 'METAL_STANDARDIZATION_ERROR': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.METAL_STANDARDIZATION_ERROR, 'NORMALIZATION_APPLIED': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.NORMALIZATION_APPLIED, 'NORMALIZER_STANDARDIZATION_ERROR': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.NORMALIZER_STANDARDIZATION_ERROR, 'NO_EVENT': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.NO_EVENT, 'OUTPUT_ERROR': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.OUTPUT_ERROR, 'PIPELINE_ERROR': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.PIPELINE_ERROR, 'PREPARE_FOR_STANDARDIZATION_ERROR': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.PREPARE_FOR_STANDARDIZATION_ERROR, 'PREPARE_FOR_VALIDATION_ERROR': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.PREPARE_FOR_VALIDATION_ERROR, 'PROTONATION_CHANGED': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.PROTONATION_CHANGED, 'STANDARDIZATION_ERROR': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.STANDARDIZATION_ERROR, 'STEREO_VALIDATION_ERROR': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.STEREO_VALIDATION_ERROR, 'STRUCTURE_MODIFICATION': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.STRUCTURE_MODIFICATION, 'VALIDATION_ERROR': rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.VALIDATION_ERROR}
  values = {0: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.NO_EVENT, 1: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.INPUT_ERROR, 2: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.PREPARE_FOR_VALIDATION_ERROR, 4: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.FEATURES_VALIDATION_ERROR, 8: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.BASIC_VALIDATION_ERROR, 16: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.IS2D_VALIDATION_ERROR, 32: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.LAYOUT2D_VALIDATION_ERROR, 64: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.STEREO_VALIDATION_ERROR, 124: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.VALIDATION_ERROR, 128: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.PREPARE_FOR_STANDARDIZATION_ERROR, 256: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.METAL_STANDARDIZATION_ERROR, 512: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.NORMALIZER_STANDARDIZATION_ERROR, 1024: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.FRAGMENT_STANDARDIZATION_ERROR, 2048: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.CHARGE_STANDARDIZATION_ERROR, 3840: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.STANDARDIZATION_ERROR, 4096: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.OUTPUT_ERROR, 8191: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.PIPELINE_ERROR, 8388608: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.METALS_DISCONNECTED, 16777216: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.NORMALIZATION_APPLIED, 33554432: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.FRAGMENTS_REMOVED, 67108864: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.PROTONATION_CHANGED, 125829120: rdkit.Chem.MolStandardize.rdMolStandardize.PipelineStatus.STRUCTURE_MODIFICATION}

class rdkit.Chem.MolStandardize.rdMolStandardize.RDKitValidation((object)arg1) → None :

  Bases: `ValidationMethod`

  > C++ signature :

  >   void __init__(_object*)

  __init__( (object)arg1 [, (bool)allowEmptyMolecules=False]) -> None :

  > C++ signature :

  >   void __init__(_object* [,bool=False])

  property allowEmptyMolecules

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.RDKitValidation)arg1) -> bool:

    C++ signature :

      bool {lvalue} None(RDKit::MolStandardize::RDKitValidation {lvalue})

rdkit.Chem.MolStandardize.rdMolStandardize.Reionize((rdkit.Chem.rdchem.Mol)mol[, (object)params=None]) → rdkit.Chem.rdchem.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((rdkit.Chem.rdchem.Mol)mol[, (object)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( (object)mols, (int)numThreads [, (object)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) → None :

  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, (rdkit.Chem.rdchem.Mol)mol) → rdkit.Chem.rdchem.Mol :
    C++ signature :

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

  reionizeInPlace((Reionizer)self, (rdkit.Chem.rdchem.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[, (object)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((rdkit.Chem.rdchem.Mol)mol[, (object)params=None]) → rdkit.Chem.rdchem.Mol :

  Removes fragments from the molecule

  C++ signature :

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

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

  Removes fragments from the molecule, modifies the input molecule

  > C++ signature :

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

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

    Removes fragments from multiple molecules in place

    C++ signature :

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

rdkit.Chem.MolStandardize.rdMolStandardize.ScoreHeteroHs((rdkit.Chem.rdchem.Mol)mol) → int :

  scores the number of heteroHs of the tautomer for canonicalization This gives a negative penalty to hydrogens attached to S,P, Se and Te

  C++ signature :

    int ScoreHeteroHs(RDKit::ROMol)

rdkit.Chem.MolStandardize.rdMolStandardize.ScoreRings((rdkit.Chem.rdchem.Mol)mol) → int :

  scores the ring system of the tautomer for canonicalization Aromatic rings score 100, all carbon aromatic rings score 250

  C++ signature :

    int ScoreRings(RDKit::ROMol)

rdkit.Chem.MolStandardize.rdMolStandardize.ScoreSubstructs((rdkit.Chem.rdchem.Mol)mol[, (SubstructTermVector)terms]) → int :

  scores the tautomer substructures

  C++ signature :

    int ScoreSubstructs(RDKit::ROMol [,std::vector<RDKit::MolStandardize::TautomerScoringFunctions::SubstructTerm, std::allocator<RDKit::MolStandardize::TautomerScoringFunctions::SubstructTerm> >])

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((rdkit.Chem.rdchem.Mol)mol[, (object)params=None[, (bool)skipStandardize=False]]) → rdkit.Chem.rdchem.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((rdkit.Chem.rdchem.Mol)mol[, (object)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( (object)mols, (int)numThreads [, (object)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]])

class rdkit.Chem.MolStandardize.rdMolStandardize.StereoValidation((object)arg1) → None :

  Bases: `ValidationMethod`

  C++ signature :

    void __init__(_object*)

class rdkit.Chem.MolStandardize.rdMolStandardize.SubstructTerm((object)self, (str)name, (str)smarts, (int)score) → None :

  Bases: `instance`

  Sets the score of this particular tautomer substructure, higher scores are more preferable Aromatic rings score 100, all carbon aromatic rings score 250

  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 name

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.SubstructTerm)arg1) -> str:

    C++ signature :

      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(RDKit::MolStandardize::TautomerScoringFunctions::SubstructTerm {lvalue})

  property score

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.SubstructTerm)arg1) -> int:

    C++ signature :

      int {lvalue} None(RDKit::MolStandardize::TautomerScoringFunctions::SubstructTerm {lvalue})

  property smarts

    None( (rdkit.Chem.MolStandardize.rdMolStandardize.SubstructTerm)arg1) -> str:

    C++ signature :

      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(RDKit::MolStandardize::TautomerScoringFunctions::SubstructTerm {lvalue})

class rdkit.Chem.MolStandardize.rdMolStandardize.SubstructTermVector((object)arg1) → None :

  Bases: `instance`

  C++ signature :

    void __init__(_object*)

  append((SubstructTermVector)arg1, (object)arg2) → None :
    C++ signature :

      void append(std::vector<RDKit::MolStandardize::TautomerScoringFunctions::SubstructTerm, std::allocator<RDKit::MolStandardize::TautomerScoringFunctions::SubstructTerm> > {lvalue},boost::python::api::object)

  extend((SubstructTermVector)arg1, (object)arg2) → None :
    C++ signature :

      void extend(std::vector<RDKit::MolStandardize::TautomerScoringFunctions::SubstructTerm, std::allocator<RDKit::MolStandardize::TautomerScoringFunctions::SubstructTerm> > {lvalue},boost::python::api::object)

rdkit.Chem.MolStandardize.rdMolStandardize.SuperParent((rdkit.Chem.rdchem.Mol)mol[, (object)params=None[, (bool)skipStandardize=False]]) → rdkit.Chem.rdchem.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((rdkit.Chem.rdchem.Mol)mol[, (object)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( (object)mols, (int)numThreads [, (object)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((object)arg1) → object :

  Bases: `instance`

  > C++ signature :

  >   void* __init__(boost::python::api::object)

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

  > C++ signature :

  >   void* __init__(boost::python::api::object,RDKit::MolStandardize::CleanupParameters)

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

  > C++ signature :

  >   void* __init__(boost::python::api::object,RDKit::MolStandardize::TautomerEnumerator)

  Canonicalize((TautomerEnumerator)self, (rdkit.Chem.rdchem.Mol)mol) → rdkit.Chem.rdchem.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, (rdkit.Chem.rdchem.Mol)mol, (object)scoreFunc) -> rdkit.Chem.rdchem.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, (rdkit.Chem.rdchem.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, (object)iterable) → rdkit.Chem.rdchem.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, (object)iterable, (object)scoreFunc) -> rdkit.Chem.rdchem.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((rdkit.Chem.rdchem.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) → None :

  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((rdkit.Chem.rdchem.Mol)mol[, (object)params=None[, (bool)skipStandardize=False]]) → rdkit.Chem.rdchem.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((rdkit.Chem.rdchem.Mol)mol[, (object)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( (object)mols, (int)numThreads [, (object)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[, (bool)protonationOnly=False]]]) → None :

  Bases: `instance`

  C++ signature :

    void __init__(_object* [,bool=True [,bool=False [,bool=False]]])

  uncharge((Uncharger)self, (rdkit.Chem.rdchem.Mol)mol) → rdkit.Chem.rdchem.Mol :
    C++ signature :

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

  unchargeInPlace((Uncharger)self, (rdkit.Chem.rdchem.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) → None :

  Bases: `instance`

  C++ signature :

    void __init__(_object*)

  validate((ValidationMethod)self, (rdkit.Chem.rdchem.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) → None :

  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})