rdkit.Chem package — The RDKit 2016.09.1 documentation

# rdkit.Chem package

## Subpackages

- rdkit.Chem.AtomPairs package
  - Submodules
    - rdkit.Chem.AtomPairs.Pairs module
    - rdkit.Chem.AtomPairs.Sheridan module
    - rdkit.Chem.AtomPairs.Torsions module
    - rdkit.Chem.AtomPairs.UnitTestDescriptors module
    - rdkit.Chem.AtomPairs.Utils module
    - rdkit.Chem.AtomPairs.test_list module
  - Module contents
- rdkit.Chem.ChemUtils package
  - Submodules
    - rdkit.Chem.ChemUtils.AlignDepict module
    - rdkit.Chem.ChemUtils.BulkTester module
    - rdkit.Chem.ChemUtils.SDFToCSV module
    - rdkit.Chem.ChemUtils.TemplateExpand module
    - rdkit.Chem.ChemUtils.UnitTestAlignDepict module
    - rdkit.Chem.ChemUtils.UnitTestSDFToCSV module
    - rdkit.Chem.ChemUtils.test_list module
  - Module contents
- rdkit.Chem.Draw package
  - Submodules
    - rdkit.Chem.Draw.IPythonConsole module
    - rdkit.Chem.Draw.MolDrawing module
    - rdkit.Chem.Draw.SimilarityMaps module
    - rdkit.Chem.Draw.UnitTestDraw module
    - rdkit.Chem.Draw.UnitTestIPython module
    - rdkit.Chem.Draw.UnitTestSimilarityMaps module
    - rdkit.Chem.Draw.aggCanvas module
    - rdkit.Chem.Draw.cairoCanvas module
    - rdkit.Chem.Draw.canvasbase module
    - rdkit.Chem.Draw.mplCanvas module
    - rdkit.Chem.Draw.qtCanvas module
    - rdkit.Chem.Draw.spingCanvas module
    - rdkit.Chem.Draw.test_list module
  - Module contents
- rdkit.Chem.EState package
  - Submodules
    - rdkit.Chem.EState.AtomTypes module
    - rdkit.Chem.EState.EState module
    - rdkit.Chem.EState.EState_VSA module
    - rdkit.Chem.EState.Fingerprinter module
    - rdkit.Chem.EState.UnitTestEState module
    - rdkit.Chem.EState.UnitTestFingerprints module
    - rdkit.Chem.EState.UnitTestTypes module
    - rdkit.Chem.EState.UnitTestVSA module
    - rdkit.Chem.EState.test_list module
  - Module contents
- rdkit.Chem.FeatMaps package
  - Submodules
    - rdkit.Chem.FeatMaps.FeatMapParser module
    - rdkit.Chem.FeatMaps.FeatMapPoint module
    - rdkit.Chem.FeatMaps.FeatMapUtils module
    - rdkit.Chem.FeatMaps.FeatMaps module
    - rdkit.Chem.FeatMaps.UnitTestFeatMap module
    - rdkit.Chem.FeatMaps.UnitTestFeatMapParser module
    - rdkit.Chem.FeatMaps.UnitTestFeatMapPoint module
    - rdkit.Chem.FeatMaps.UnitTestFeatMapUtils module
    - rdkit.Chem.FeatMaps.test_list module
  - Module contents
- rdkit.Chem.Features package
  - Submodules
    - rdkit.Chem.Features.FeatDirUtilsRD module
    - rdkit.Chem.Features.ShowFeats module
  - Module contents
- rdkit.Chem.Fingerprints package
  - Submodules
    - rdkit.Chem.Fingerprints.ClusterMols module
    - rdkit.Chem.Fingerprints.DbFpSupplier module
    - rdkit.Chem.Fingerprints.FingerprintMols module
    - rdkit.Chem.Fingerprints.MolSimilarity module
    - rdkit.Chem.Fingerprints.SimilarityScreener module
    - rdkit.Chem.Fingerprints.UnitTestDbFpSupplier module
    - rdkit.Chem.Fingerprints.UnitTestFingerprints module
    - rdkit.Chem.Fingerprints.UnitTestSimScreener module
    - rdkit.Chem.Fingerprints.test_list module
  - Module contents
- rdkit.Chem.Fraggle package
  - Submodules
    - rdkit.Chem.Fraggle.FraggleSim module
      - Fragmentation algorithm
    - rdkit.Chem.Fraggle.UnitTestFraggle module
    - rdkit.Chem.Fraggle.test_list module
  - Module contents
- rdkit.Chem.MolDb package
  - Submodules
    - rdkit.Chem.MolDb.FingerprintUtils module
    - rdkit.Chem.MolDb.Loader module
    - rdkit.Chem.MolDb.Loader_orig module
    - rdkit.Chem.MolDb.Loader_sa module
  - Module contents
- rdkit.Chem.MolKey package
  - Submodules
    - rdkit.Chem.MolKey.InchiInfo module
    - rdkit.Chem.MolKey.MolKey module
    - rdkit.Chem.MolKey.UnitTestMolKey module
    - rdkit.Chem.MolKey.test_list module
  - Module contents
- rdkit.Chem.Pharm2D package
  - Submodules
    - rdkit.Chem.Pharm2D.Generate module
    - rdkit.Chem.Pharm2D.Gobbi_Pharm2D module
    - rdkit.Chem.Pharm2D.LazyGenerator module
    - rdkit.Chem.Pharm2D.Matcher module
    - rdkit.Chem.Pharm2D.SigFactory module
    - rdkit.Chem.Pharm2D.UnitTestGenerate module
    - rdkit.Chem.Pharm2D.UnitTestGobbi module
    - rdkit.Chem.Pharm2D.UnitTestLazyGenerator module
    - rdkit.Chem.Pharm2D.UnitTestMatcher module
    - rdkit.Chem.Pharm2D.UnitTestSignature module
    - rdkit.Chem.Pharm2D.UnitTestUtils module
    - rdkit.Chem.Pharm2D.Utils module
    - rdkit.Chem.Pharm2D.test_list module
  - Module contents
- rdkit.Chem.Pharm3D package
  - Submodules
    - rdkit.Chem.Pharm3D.EmbedLib module
    - rdkit.Chem.Pharm3D.ExcludedVolume module
    - rdkit.Chem.Pharm3D.Pharmacophore module
    - rdkit.Chem.Pharm3D.UnitTestEmbed module
    - rdkit.Chem.Pharm3D.UnitTestExcludedVolume module
    - rdkit.Chem.Pharm3D.UnitTestPharmacophore module
    - rdkit.Chem.Pharm3D.test_list module
  - Module contents
- rdkit.Chem.Scaffolds package
  - Submodules
    - rdkit.Chem.Scaffolds.MurckoScaffold module
    - rdkit.Chem.Scaffolds.UnitTestMurckoScaffold module
    - rdkit.Chem.Scaffolds.test_list module
  - Module contents
- rdkit.Chem.SimpleEnum package
  - Submodules
    - rdkit.Chem.SimpleEnum.Enumerator module
    - rdkit.Chem.SimpleEnum.UnitTestEnumerator module
    - rdkit.Chem.SimpleEnum.test_list module
  - Module contents
- rdkit.Chem.Subshape package
  - Submodules
    - rdkit.Chem.Subshape.BuilderUtils module
    - rdkit.Chem.Subshape.SubshapeAligner module
    - rdkit.Chem.Subshape.SubshapeBuilder module
    - rdkit.Chem.Subshape.SubshapeObjects module
    - rdkit.Chem.Subshape.UnitTestSubshape module
    - rdkit.Chem.Subshape.testCombined module
    - rdkit.Chem.Subshape.test_list module
  - Module contents
- rdkit.Chem.Suppliers package
  - Submodules
    - rdkit.Chem.Suppliers.DbMolSupplier module
    - rdkit.Chem.Suppliers.MolSupplier module
    - rdkit.Chem.Suppliers.UnitTestDbMolSupplier module
    - rdkit.Chem.Suppliers.UnitTestSDMolSupplier module
    - rdkit.Chem.Suppliers.UnitTestSmilesMolSupplier module
    - rdkit.Chem.Suppliers.test_list module
  - Module contents
- rdkit.Chem.fmcs package
  - Submodules
    - rdkit.Chem.fmcs.fmcs module
  - Module contents

## Submodules

- rdkit.Chem.AllChem module
- rdkit.Chem.BRICS module
- rdkit.Chem.BuildFragmentCatalog module
- rdkit.Chem.ChemicalFeatures module
- rdkit.Chem.ChemicalForceFields module
- rdkit.Chem.Crippen module
- rdkit.Chem.DSViewer module
- rdkit.Chem.Descriptors module
- rdkit.Chem.Descriptors3D module
- rdkit.Chem.FastSDMolSupplier module
- rdkit.Chem.FeatFinderCLI module
- rdkit.Chem.FilterCatalog module
- rdkit.Chem.FragmentCatalog module
- rdkit.Chem.FragmentMatcher module
- rdkit.Chem.Fragments module
- rdkit.Chem.FunctionalGroups module
- rdkit.Chem.GraphDescriptors module
- rdkit.Chem.Graphs module
- rdkit.Chem.Lipinski module
- rdkit.Chem.MACCSkeys module
- rdkit.Chem.MCS module
- rdkit.Chem.MolCatalog module
- rdkit.Chem.MolSurf module
- rdkit.Chem.PandasTools module
- rdkit.Chem.PeriodicTable module
- rdkit.Chem.PropertyMol module
- rdkit.Chem.PyMol module
- rdkit.Chem.Randomize module
- rdkit.Chem.Recap module
- rdkit.Chem.ReducedGraphs module
- rdkit.Chem.SATIS module
- rdkit.Chem.SaltRemover module
- rdkit.Chem.ShowMols module
- rdkit.Chem.TemplateAlign module
- rdkit.Chem.TorsionFingerprints module
- rdkit.Chem.inchi module

## Module contents

A module for molecules and stuff

see Chem/index.html in the doc tree for documentation

`rdkit.Chem.` `CanonSmiles`(smi, useChiral=1)

`rdkit.Chem.` `FindMolChiralCenters`(mol, force=True, includeUnassigned=False)

      >>> from rdkit import Chem
      >>> mol = Chem.MolFromSmiles('[C@H](Cl)(F)Br')
      >>> FindMolChiralCenters(mol)
      [(0, 'R')]
      >>> mol = Chem.MolFromSmiles('[C@@H](Cl)(F)Br')
      >>> FindMolChiralCenters(mol)
      [(0, 'S')]

      >>> FindMolChiralCenters(Chem.MolFromSmiles('CCC'))
      []

  By default unassigned stereo centers are not reported: >>> mol = Chem.MolFromSmiles(‘C[C@H](F)C(F)(Cl)Br’) >>> FindMolChiralCenters(mol,force=True) [(1, ‘S’)]

  but this can be changed: >>> FindMolChiralCenters(mol,force=True,includeUnassigned=True) [(1, ‘S’), (3, ‘?’)]

  The handling of unassigned stereocenters for dependent stereochemistry is not correct: >>> Chem.FindMolChiralCenters(Chem.MolFromSmiles(‘C1CC(C)C(C)C(C)C1’),includeUnassigned=True) [(2, ‘?’), (6, ‘?’)] >>> Chem.FindMolChiralCenters(Chem.MolFromSmiles(‘C1C[C@H](C)C(C)[C@H](C)C1’),includeUnassigned=True) [(2, ‘S’), (4, ‘?’), (6, ‘R’)]

`rdkit.Chem.` `QuickSmartsMatch`(smi, sma, unique=True, display=False)

`rdkit.Chem.` `SupplierFromFilename`(fileN, delim='', **kwargs)

Module containing the core chemistry functionality of the RDKit

class `rdkit.Chem.rdchem.` `Atom`

  Bases: `Boost.Python.instance`

  The class to store Atoms. Note that, though it is possible to create one, having an Atom on its own (i.e not associated with a molecule) is not particularly useful.

  `ClearProp`((Atom)arg1, (str)arg2) → None :

    Removes a particular property from an Atom (does nothing if not already set).

    > ARGUMENTS:
    >   - key: the name of the property to be removed.

    C++ signature :
      void ClearProp(RDKit::Atom const*,char const*)
  `DescribeQuery`((Atom)arg1) → str :

    returns a text description of the query. Primarily intended for debugging purposes.

    C++ signature :
      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > DescribeQuery(RDKit::Atom const*)
  `GetAtomMapNum`((Atom)arg1) → int :

    Gets the atoms map number, returns 0 if not set

    C++ signature :
      int GetAtomMapNum(RDKit::Atom {lvalue})
  `GetAtomicNum`((Atom)arg1) → int :

    Returns the atomic number.

    C++ signature :
      int GetAtomicNum(RDKit::Atom {lvalue})
  `GetBonds`((Atom)arg1) → tuple :

    Returns a read-only sequence of the atom’s bonds

    C++ signature :
      boost::python::tuple GetBonds(RDKit::Atom*)
  `GetBoolProp`((Atom)arg1, (str)arg2) → bool :

    Returns the value of the property.

    > ARGUMENTS:
    >   - key: the name of the property to return (a bool).

    > RETURNS: a bool

    > NOTE:
    >   - If the property has not been set, a KeyError exception will be raised.

    C++ signature :
      bool GetBoolProp(RDKit::Atom*,char const*)
  `GetChiralTag`((Atom)arg1) → ChiralType :
    C++ signature :
      RDKit::Atom::ChiralType GetChiralTag(RDKit::Atom {lvalue})
  `GetDegree`((Atom)arg1) → int :

    Returns the degree of the atom in the molecule.

    > The degree of an atom is defined to be its number of directly-bonded neighbors. The degree is independent of bond orders, but is dependent

    > > on whether or not Hs are explicit in the graph.

    C++ signature :
      unsigned int GetDegree(RDKit::Atom {lvalue})
  `GetDoubleProp`((Atom)arg1, (str)arg2) → float :

    Returns the value of the property.

    > ARGUMENTS:
    >   - key: the name of the property to return (a double).

    > RETURNS: a double

    > NOTE:
    >   - If the property has not been set, a KeyError exception will be raised.

    C++ signature :
      double GetDoubleProp(RDKit::Atom*,char const*)
  `GetExplicitValence`((Atom)arg1) → int :

    Returns the explicit valence of the atom.

    C++ signature :
      int GetExplicitValence(RDKit::Atom {lvalue})
  `GetFormalCharge`((Atom)arg1) → int :
    C++ signature :
      int GetFormalCharge(RDKit::Atom {lvalue})
  `GetHybridization`((Atom)arg1) → HybridizationType :

    Returns the atom’s hybridization.

    C++ signature :
      RDKit::Atom::HybridizationType GetHybridization(RDKit::Atom {lvalue})
  `GetIdx`((Atom)arg1) → int :

    Returns the atom’s index (ordering in the molecule)

    C++ signature :
      unsigned int GetIdx(RDKit::Atom {lvalue})
  `GetImplicitValence`((Atom)arg1) → int :

    Returns the number of implicit Hs on the atom.

    C++ signature :
      int GetImplicitValence(RDKit::Atom {lvalue})
  `GetIntProp`((Atom)arg1, (str)arg2) → int :

    Returns the value of the property.

    > ARGUMENTS:
    >   - key: the name of the property to return (an int).

    > RETURNS: an int

    > NOTE:
    >   - If the property has not been set, a KeyError exception will be raised.

    C++ signature :
      int GetIntProp(RDKit::Atom*,char const*)
  `GetIsAromatic`((Atom)arg1) → bool :
    C++ signature :
      bool GetIsAromatic(RDKit::Atom {lvalue})
  `GetIsotope`((Atom)arg1) → int :
    C++ signature :
      unsigned int GetIsotope(RDKit::Atom {lvalue})
  `GetMass`((Atom)arg1) → float :
    C++ signature :
      double GetMass(RDKit::Atom {lvalue})
  `GetMonomerInfo`((Atom)arg1) → AtomMonomerInfo :

    Returns the atom’s MonomerInfo object, if there is one.

    C++ signature :
      RDKit::AtomMonomerInfo* GetMonomerInfo(RDKit::Atom*)
  `GetNeighbors`((Atom)arg1) → tuple :

    Returns a read-only sequence of the atom’s neighbors

    C++ signature :
      boost::python::tuple GetNeighbors(RDKit::Atom*)
  `GetNoImplicit`((Atom)arg1) → bool :

    Returns whether or not the atom is allowed to have implicit Hs.

    C++ signature :
      bool GetNoImplicit(RDKit::Atom {lvalue})
  `GetNumExplicitHs`((Atom)arg1) → int :
    C++ signature :
      unsigned int GetNumExplicitHs(RDKit::Atom {lvalue})
  `GetNumImplicitHs`((Atom)arg1) → int :

    Returns the total number of implicit Hs on the atom.

    C++ signature :
      unsigned int GetNumImplicitHs(RDKit::Atom {lvalue})
  `GetNumRadicalElectrons`((Atom)arg1) → int :
    C++ signature :
      unsigned int GetNumRadicalElectrons(RDKit::Atom {lvalue})
  `GetOwningMol`((Atom)arg1) → Mol :

    Returns the Mol that owns this atom.

    C++ signature :
      RDKit::ROMol {lvalue} GetOwningMol(RDKit::Atom {lvalue})
  `GetPDBResidueInfo`((Atom)arg1) → AtomPDBResidueInfo :

    Returns the atom’s MonomerInfo object, if there is one.

    C++ signature :
      RDKit::AtomPDBResidueInfo* GetPDBResidueInfo(RDKit::Atom*)
  `GetProp`((Atom)arg1, (str)arg2) → str :

    Returns the value of the property.

    > ARGUMENTS:
    >   - key: the name of the property to return (a string).

    > RETURNS: a string

    > NOTE:
    >   - If the property has not been set, a KeyError exception will be raised.

    C++ signature :
      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > GetProp(RDKit::Atom*,char const*)
  `GetPropNames`((Atom)self[, (bool)includePrivate=False[, (bool)includeComputed=False]]) → _vectNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE :

    Returns a list of the properties set on the Atom.

    C++ signature :
      std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > GetPropNames(RDKit::Atom {lvalue} [,bool=False [,bool=False]])
  `GetPropsAsDict`((Atom)self[, (bool)includePrivate=True[, (bool)includeComputed=True]]) → dict :
    Returns a dictionary of the properties set on the Atom.
      n.b. some properties cannot be converted to python types.
    C++ signature :
      boost::python::dict GetPropsAsDict(RDKit::Atom [,bool=True [,bool=True]])
  `GetSmarts`((Atom)arg1) → str :

    returns the SMARTS (or SMILES) string for an Atom

    C++ signature :
      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > GetSmarts(RDKit::Atom const*)
  `GetSymbol`((Atom)arg1) → str :

    Returns the atomic symbol (a string)

    C++ signature :
      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > GetSymbol(RDKit::Atom {lvalue})
  `GetTotalDegree`((Atom)arg1) → int :

    Returns the degree of the atom in the molecule including Hs.

    > The degree of an atom is defined to be its number of directly-bonded neighbors. The degree is independent of bond orders.

    C++ signature :
      unsigned int GetTotalDegree(RDKit::Atom {lvalue})
  `GetTotalNumHs`((Atom)self[, (bool)includeNeighbors=False]) → int :

    Returns the total number of Hs (explicit and implicit) on the atom.

    > ARGUMENTS:

    > > - includeNeighbors: (optional) toggles inclusion of neighboring H atoms in the sum. Defaults to 0.

    C++ signature :
      unsigned int GetTotalNumHs(RDKit::Atom {lvalue} [,bool=False])
  `GetTotalValence`((Atom)arg1) → int :

    Returns the total valence (explicit + implicit) of the atom.

    C++ signature :
      unsigned int GetTotalValence(RDKit::Atom {lvalue})
  `GetUnsignedProp`((Atom)arg1, (str)arg2) → int :

    Returns the value of the property.

    > ARGUMENTS:
    >   - key: the name of the property to return (an unsigned integer).

    > RETURNS: an integer (Python has no unsigned type)

    > NOTE:
    >   - If the property has not been set, a KeyError exception will be raised.

    C++ signature :
      unsigned int GetUnsignedProp(RDKit::Atom*,char const*)
  `HasProp`((Atom)arg1, (str)arg2) → int :

    Queries a Atom to see if a particular property has been assigned.

    > ARGUMENTS:
    >   - key: the name of the property to check for (a string).

    C++ signature :
      int HasProp(RDKit::Atom const*,char const*)
  `HasQuery`((Atom)arg1) → bool :

    Returns whether or not the atom has an associated query

    C++ signature :
      bool HasQuery(RDKit::Atom {lvalue})
  `InvertChirality`((Atom)arg1) → None :
    C++ signature :
      void InvertChirality(RDKit::Atom {lvalue})
  `IsInRing`((Atom)arg1) → bool :

    Returns whether or not the atom is in a ring

    C++ signature :
      bool IsInRing(RDKit::Atom const*)
  `IsInRingSize`((Atom)arg1, (int)arg2) → bool :

    Returns whether or not the atom is in a ring of a particular size.

    > ARGUMENTS:
    >   - size: the ring size to look for

    C++ signature :
      bool IsInRingSize(RDKit::Atom const*,int)
  `Match`((Atom)arg1, (Atom)arg2) → bool :

    Returns whether or not this atom matches another Atom.

    > Each Atom (or query Atom) has a query function which is used for this type of matching.

    > ARGUMENTS:
    >   - other: the other Atom to which to compare

    C++ signature :
      bool Match(RDKit::Atom {lvalue},RDKit::Atom const*)
  `NeedsUpdatePropertyCache`((Atom)self) → bool :

    Returns true or false depending on whether implicit and explicit valence of the molecule have already been calculated.

    C++ signature :
      bool NeedsUpdatePropertyCache(RDKit::Atom {lvalue})
  `SetAtomMapNum`((Atom)self, (int)mapno[, (bool)strict=False]) → None :

    Sets the atoms map number, a value of 0 clears the atom map

    C++ signature :
      void SetAtomMapNum(RDKit::Atom {lvalue},int [,bool=False])
  `SetAtomicNum`((Atom)arg1, (int)arg2) → None :

    Sets the atomic number, takes an integer value as an argument

    C++ signature :
      void SetAtomicNum(RDKit::Atom {lvalue},int)
  `SetBoolProp`((Atom)self, (str)key, (bool)val) → None :

    Sets an atomic property

    > ARGUMENTS:
    >   - key: the name of the property to be set (a bool).
    >   - value: the property value (a bool).

    C++ signature :
      void SetBoolProp(RDKit::Atom const*,char const*,bool)
  `SetChiralTag`((Atom)arg1, (ChiralType)arg2) → None :
    C++ signature :
      void SetChiralTag(RDKit::Atom {lvalue},RDKit::Atom::ChiralType)
  `SetDoubleProp`((Atom)self, (str)key, (float)val) → None :

    Sets an atomic property

    > ARGUMENTS:
    >   - key: the name of the property to be set (a double).
    >   - value: the property value (a double).

    C++ signature :
      void SetDoubleProp(RDKit::Atom const*,char const*,double)
  `SetFormalCharge`((Atom)arg1, (int)arg2) → None :
    C++ signature :
      void SetFormalCharge(RDKit::Atom {lvalue},int)
  `SetHybridization`((Atom)arg1, (HybridizationType)arg2) → None :
    Sets the hybridization of the atom.
      The argument should be a HybridizationType
    C++ signature :
      void SetHybridization(RDKit::Atom {lvalue},RDKit::Atom::HybridizationType)
  `SetIntProp`((Atom)self, (str)key, (int)val) → None :

    Sets an atomic property

    > ARGUMENTS:
    >   - key: the name of the property to be set (a int).
    >   - value: the property value (a int).

    C++ signature :
      void SetIntProp(RDKit::Atom const*,char const*,int)
  `SetIsAromatic`((Atom)arg1, (bool)arg2) → None :
    C++ signature :
      void SetIsAromatic(RDKit::Atom {lvalue},bool)
  `SetIsotope`((Atom)arg1, (int)arg2) → None :
    C++ signature :
      void SetIsotope(RDKit::Atom {lvalue},unsigned int)
  `SetMonomerInfo`((Atom)arg1, (AtomMonomerInfo)arg2) → None :

    Sets the atom’s MonomerInfo object.

    C++ signature :
      void SetMonomerInfo(RDKit::Atom*,RDKit::AtomMonomerInfo const*)
  `SetNoImplicit`((Atom)arg1, (bool)arg2) → None :
    Sets a marker on the atom that disallows implicit Hs.
      This holds even if the atom would otherwise have implicit Hs added.
    C++ signature :
      void SetNoImplicit(RDKit::Atom {lvalue},bool)
  `SetNumExplicitHs`((Atom)arg1, (int)arg2) → None :
    C++ signature :
      void SetNumExplicitHs(RDKit::Atom {lvalue},unsigned int)
  `SetNumRadicalElectrons`((Atom)arg1, (int)arg2) → None :
    C++ signature :
      void SetNumRadicalElectrons(RDKit::Atom {lvalue},unsigned int)
  `SetProp`((Atom)self, (str)key, (str)val) → None :

    Sets an atomic property

    > ARGUMENTS:
    >   - key: the name of the property to be set (a string).
    >   - value: the property value (a string).

    C++ signature :
      void SetProp(RDKit::Atom const*,char const*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)
  `SetUnsignedProp`((Atom)self, (str)key, (int)val) → None :

    Sets an atomic property

    > ARGUMENTS:
    >   - key: the name of the property to be set (an unsigned integer).
    >   - value: the property value (a int >= 0).

    C++ signature :
      void SetUnsignedProp(RDKit::Atom const*,char const*,unsigned int)
  `UpdatePropertyCache`((Atom)self[, (bool)strict=True]) → None :

    Regenerates computed properties like implicit valence and ring information.

    C++ signature :
      void UpdatePropertyCache(RDKit::Atom {lvalue} [,bool=True])

class `rdkit.Chem.rdchem.` `AtomMonomerInfo`

  Bases: `Boost.Python.instance`

  The class to store monomer information attached to Atoms

  `GetMonomerType`((AtomMonomerInfo)arg1) → AtomMonomerType :
    C++ signature :
      RDKit::AtomMonomerInfo::AtomMonomerType GetMonomerType(RDKit::AtomMonomerInfo {lvalue})
  `GetName`((AtomMonomerInfo)arg1) → str :
    C++ signature :
      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > GetName(RDKit::AtomMonomerInfo {lvalue})
  `SetMonomerType`((AtomMonomerInfo)arg1, (AtomMonomerType)arg2) → None :
    C++ signature :
      void SetMonomerType(RDKit::AtomMonomerInfo {lvalue},RDKit::AtomMonomerInfo::AtomMonomerType)
  `SetName`((AtomMonomerInfo)arg1, (str)arg2) → None :
    C++ signature :
      void SetName(RDKit::AtomMonomerInfo {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

class `rdkit.Chem.rdchem.` `AtomMonomerType`

  Bases: `Boost.Python.enum`

  `OTHER` = rdkit.Chem.rdchem.AtomMonomerType.OTHER
  `PDBRESIDUE` = rdkit.Chem.rdchem.AtomMonomerType.PDBRESIDUE
  `UNKNOWN` = rdkit.Chem.rdchem.AtomMonomerType.UNKNOWN
  `names` = {'PDBRESIDUE': rdkit.Chem.rdchem.AtomMonomerType.PDBRESIDUE, 'OTHER': rdkit.Chem.rdchem.AtomMonomerType.OTHER, 'UNKNOWN': rdkit.Chem.rdchem.AtomMonomerType.UNKNOWN}
  `values` = {0: rdkit.Chem.rdchem.AtomMonomerType.UNKNOWN, 1: rdkit.Chem.rdchem.AtomMonomerType.PDBRESIDUE, 2: rdkit.Chem.rdchem.AtomMonomerType.OTHER}

class `rdkit.Chem.rdchem.` `AtomPDBResidueInfo`

  Bases: `rdkit.Chem.rdchem.AtomMonomerInfo`

  The class to store PDB residue information attached to Atoms

  `GetAltLoc`((AtomPDBResidueInfo)arg1) → str :
    C++ signature :
      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > GetAltLoc(RDKit::AtomPDBResidueInfo {lvalue})
  `GetChainId`((AtomPDBResidueInfo)arg1) → str :
    C++ signature :
      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > GetChainId(RDKit::AtomPDBResidueInfo {lvalue})
  `GetInsertionCode`((AtomPDBResidueInfo)arg1) → str :
    C++ signature :
      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > GetInsertionCode(RDKit::AtomPDBResidueInfo {lvalue})
  `GetIsHeteroAtom`((AtomPDBResidueInfo)arg1) → bool :
    C++ signature :
      bool GetIsHeteroAtom(RDKit::AtomPDBResidueInfo {lvalue})
  `GetOccupancy`((AtomPDBResidueInfo)arg1) → float :
    C++ signature :
      double GetOccupancy(RDKit::AtomPDBResidueInfo {lvalue})
  `GetResidueName`((AtomPDBResidueInfo)arg1) → str :
    C++ signature :
      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > GetResidueName(RDKit::AtomPDBResidueInfo {lvalue})
  `GetResidueNumber`((AtomPDBResidueInfo)arg1) → int :
    C++ signature :
      int GetResidueNumber(RDKit::AtomPDBResidueInfo {lvalue})
  `GetSecondaryStructure`((AtomPDBResidueInfo)arg1) → int :
    C++ signature :
      unsigned int GetSecondaryStructure(RDKit::AtomPDBResidueInfo {lvalue})
  `GetSegmentNumber`((AtomPDBResidueInfo)arg1) → int :
    C++ signature :
      unsigned int GetSegmentNumber(RDKit::AtomPDBResidueInfo {lvalue})
  `GetSerialNumber`((AtomPDBResidueInfo)arg1) → int :
    C++ signature :
      int GetSerialNumber(RDKit::AtomPDBResidueInfo {lvalue})
  `GetTempFactor`((AtomPDBResidueInfo)arg1) → float :
    C++ signature :
      double GetTempFactor(RDKit::AtomPDBResidueInfo {lvalue})
  `SetAltLoc`((AtomPDBResidueInfo)arg1, (str)arg2) → None :
    C++ signature :
      void SetAltLoc(RDKit::AtomPDBResidueInfo {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)
  `SetChainId`((AtomPDBResidueInfo)arg1, (str)arg2) → None :
    C++ signature :
      void SetChainId(RDKit::AtomPDBResidueInfo {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)
  `SetInsertionCode`((AtomPDBResidueInfo)arg1, (str)arg2) → None :
    C++ signature :
      void SetInsertionCode(RDKit::AtomPDBResidueInfo {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)
  `SetIsHeteroAtom`((AtomPDBResidueInfo)arg1, (bool)arg2) → None :
    C++ signature :
      void SetIsHeteroAtom(RDKit::AtomPDBResidueInfo {lvalue},bool)
  `SetOccupancy`((AtomPDBResidueInfo)arg1, (float)arg2) → None :
    C++ signature :
      void SetOccupancy(RDKit::AtomPDBResidueInfo {lvalue},double)
  `SetResidueName`((AtomPDBResidueInfo)arg1, (str)arg2) → None :
    C++ signature :
      void SetResidueName(RDKit::AtomPDBResidueInfo {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)
  `SetResidueNumber`((AtomPDBResidueInfo)arg1, (int)arg2) → None :
    C++ signature :
      void SetResidueNumber(RDKit::AtomPDBResidueInfo {lvalue},int)
  `SetSecondaryStructure`((AtomPDBResidueInfo)arg1, (int)arg2) → None :
    C++ signature :
      void SetSecondaryStructure(RDKit::AtomPDBResidueInfo {lvalue},unsigned int)
  `SetSegmentNumber`((AtomPDBResidueInfo)arg1, (int)arg2) → None :
    C++ signature :
      void SetSegmentNumber(RDKit::AtomPDBResidueInfo {lvalue},unsigned int)
  `SetSerialNumber`((AtomPDBResidueInfo)arg1, (int)arg2) → None :
    C++ signature :
      void SetSerialNumber(RDKit::AtomPDBResidueInfo {lvalue},int)
  `SetTempFactor`((AtomPDBResidueInfo)arg1, (float)arg2) → None :
    C++ signature :
      void SetTempFactor(RDKit::AtomPDBResidueInfo {lvalue},double)

class `rdkit.Chem.rdchem.` `Bond`

  Bases: `Boost.Python.instance`

  The class to store Bonds. Note: unlike Atoms, is it currently impossible to construct Bonds from Python.

  `ClearProp`((Bond)arg1, (str)arg2) → None :

    Removes a particular property from an Bond (does nothing if not already set).

    > ARGUMENTS:
    >   - key: the name of the property to be removed.

    C++ signature :
      void ClearProp(RDKit::Bond const*,char const*)
  `DescribeQuery`((Bond)arg1) → str :

    returns a text description of the query. Primarily intended for debugging purposes.

    C++ signature :
      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > DescribeQuery(RDKit::Bond const*)
  `GetBeginAtom`((Bond)arg1) → Atom :

    Returns the bond’s first atom.

    C++ signature :
      RDKit::Atom* GetBeginAtom(RDKit::Bond {lvalue})
  `GetBeginAtomIdx`((Bond)arg1) → int :

    Returns the index of the bond’s first atom.

    C++ signature :
      unsigned int GetBeginAtomIdx(RDKit::Bond {lvalue})
  `GetBondDir`((Bond)arg1) → BondDir :

    Returns the type of the bond as a BondDir

    C++ signature :
      RDKit::Bond::BondDir GetBondDir(RDKit::Bond {lvalue})
  `GetBondType`((Bond)arg1) → BondType :

    Returns the type of the bond as a BondType

    C++ signature :
      RDKit::Bond::BondType GetBondType(RDKit::Bond {lvalue})
  `GetBondTypeAsDouble`((Bond)arg1) → float :

    Returns the type of the bond as a double (i.e. 1.0 for SINGLE, 1.5 for AROMATIC, 2.0 for DOUBLE)

    C++ signature :
      double GetBondTypeAsDouble(RDKit::Bond {lvalue})
  `GetBoolProp`((Bond)arg1, (str)arg2) → bool :

    Returns the value of the property.

    > ARGUMENTS:
    >   - key: the name of the property to return (a boolean).

    > RETURNS: a boolean

    > NOTE:
    >   - If the property has not been set, a KeyError exception will be raised.

    C++ signature :
      bool GetBoolProp(RDKit::Bond*,char const*)
  `GetDoubleProp`((Bond)arg1, (str)arg2) → float :

    Returns the value of the property.

    > ARGUMENTS:
    >   - key: the name of the property to return (a double).

    > RETURNS: a double

    > NOTE:
    >   - If the property has not been set, a KeyError exception will be raised.

    C++ signature :
      double GetDoubleProp(RDKit::Bond*,char const*)
  `GetEndAtom`((Bond)arg1) → Atom :

    Returns the bond’s second atom.

    C++ signature :
      RDKit::Atom* GetEndAtom(RDKit::Bond {lvalue})
  `GetEndAtomIdx`((Bond)arg1) → int :

    Returns the index of the bond’s first atom.

    C++ signature :
      unsigned int GetEndAtomIdx(RDKit::Bond {lvalue})
  `GetIdx`((Bond)arg1) → int :

    Returns the bond’s index (ordering in the molecule)

    C++ signature :
      unsigned int GetIdx(RDKit::Bond {lvalue})
  `GetIntProp`((Bond)arg1, (str)arg2) → int :

    Returns the value of the property.

    > ARGUMENTS:
    >   - key: the name of the property to return (an int).

    > RETURNS: an int

    > NOTE:
    >   - If the property has not been set, a KeyError exception will be raised.

    C++ signature :
      int GetIntProp(RDKit::Bond*,char const*)
  `GetIsAromatic`((Bond)arg1) → bool :
    C++ signature :
      bool GetIsAromatic(RDKit::Bond {lvalue})
  `GetIsConjugated`((Bond)arg1) → bool :

    Returns whether or not the bond is considered to be conjugated.

    C++ signature :
      bool GetIsConjugated(RDKit::Bond {lvalue})
  `GetOtherAtom`((Bond)arg1, (Atom)arg2) → Atom :

    Given one of the bond’s atoms, returns the other one.

    C++ signature :
      RDKit::Atom* GetOtherAtom(RDKit::Bond {lvalue},RDKit::Atom const*)
  `GetOtherAtomIdx`((Bond)arg1, (int)arg2) → int :

    Given the index of one of the bond’s atoms, returns the index of the other.

    C++ signature :
      unsigned int GetOtherAtomIdx(RDKit::Bond {lvalue},unsigned int)
  `GetOwningMol`((Bond)arg1) → Mol :

    Returns the Mol that owns this bond.

    C++ signature :
      RDKit::ROMol {lvalue} GetOwningMol(RDKit::Bond {lvalue})
  `GetProp`((Bond)arg1, (str)arg2) → str :

    Returns the value of the property.

    > ARGUMENTS:
    >   - key: the name of the property to return (a string).

    > RETURNS: a string

    > NOTE:
    >   - If the property has not been set, a KeyError exception will be raised.

    C++ signature :
      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > GetProp(RDKit::Bond*,char const*)
  `GetPropNames`((Bond)self[, (bool)includePrivate=False[, (bool)includeComputed=False]]) → _vectNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE :

    Returns a list of the properties set on the Bond.

    C++ signature :
      std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > GetPropNames(RDKit::Bond {lvalue} [,bool=False [,bool=False]])
  `GetPropsAsDict`((Bond)self[, (bool)includePrivate=True[, (bool)includeComputed=True]]) → dict :
    Returns a dictionary of the properties set on the Bond.
      n.b. some properties cannot be converted to python types.
    C++ signature :
      boost::python::dict GetPropsAsDict(RDKit::Bond [,bool=True [,bool=True]])
  `GetSmarts`((Bond)bond[, (bool)allBondsExplicit=False]) → str :

    returns the SMARTS (or SMILES) string for a Bond

    C++ signature :
      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > GetSmarts(RDKit::Bond const* [,bool=False])
  `GetStereo`((Bond)arg1) → BondStereo :

    Returns the stereo configuration of the bond as a BondStereo

    C++ signature :
      RDKit::Bond::BondStereo GetStereo(RDKit::Bond {lvalue})
  `GetStereoAtoms`((Bond)arg1) → _vecti :

    Returns the indices of the atoms setting this bond’s stereochemistry.

    C++ signature :
      std::vector<int, std::allocator<int> > GetStereoAtoms(RDKit::Bond const*)
  `GetUnsignedProp`((Bond)arg1, (str)arg2) → int :

    Returns the value of the property.

    > ARGUMENTS:
    >   - key: the name of the property to return (an unsigned integer).

    > RETURNS: an int (Python has no unsigned type)

    > NOTE:
    >   - If the property has not been set, a KeyError exception will be raised.

    C++ signature :
      unsigned int GetUnsignedProp(RDKit::Bond*,char const*)
  `GetValenceContrib`((Bond)arg1, (Atom)arg2) → float :

    Returns the contribution of the bond to the valence of an Atom.

    > ARGUMENTS:

    > > - atom: the Atom to consider.

    C++ signature :
      double GetValenceContrib(RDKit::Bond {lvalue},RDKit::Atom const*)
  `HasProp`((Bond)arg1, (str)arg2) → int :

    Queries a Bond to see if a particular property has been assigned.

    > ARGUMENTS:
    >   - key: the name of the property to check for (a string).

    C++ signature :
      int HasProp(RDKit::Bond const*,char const*)
  `HasQuery`((Bond)arg1) → bool :

    Returns whether or not the bond has an associated query

    C++ signature :
      bool HasQuery(RDKit::Bond {lvalue})
  `IsInRing`((Bond)arg1) → bool :

    Returns whether or not the bond is in a ring of any size.

    C++ signature :
      bool IsInRing(RDKit::Bond const*)
  `IsInRingSize`((Bond)arg1, (int)arg2) → bool :

    Returns whether or not the bond is in a ring of a particular size.

    > ARGUMENTS:
    >   - size: the ring size to look for

    C++ signature :
      bool IsInRingSize(RDKit::Bond const*,int)
  `Match`((Bond)arg1, (Bond)arg2) → bool :

    Returns whether or not this bond matches another Bond.

    > Each Bond (or query Bond) has a query function which is used for this type of matching.

    > ARGUMENTS:
    >   - other: the other Bond to which to compare

    C++ signature :
      bool Match(RDKit::Bond {lvalue},RDKit::Bond const*)
  `SetBondDir`((Bond)arg1, (BondDir)arg2) → None :

    Set the type of the bond as a BondDir

    C++ signature :
      void SetBondDir(RDKit::Bond {lvalue},RDKit::Bond::BondDir)
  `SetBondType`((Bond)arg1, (BondType)arg2) → None :

    Set the type of the bond as a BondType

    C++ signature :
      void SetBondType(RDKit::Bond {lvalue},RDKit::Bond::BondType)
  `SetBoolProp`((Bond)self, (str)key, (bool)val) → None :

    Sets a bond property

    > ARGUMENTS:
    >   - key: the name of the property to be set (a string).
    >   - value: the property value (a boolean).

    C++ signature :
      void SetBoolProp(RDKit::Bond const*,char const*,bool)
  `SetDoubleProp`((Bond)self, (str)key, (float)val) → None :

    Sets a bond property

    > ARGUMENTS:
    >   - key: the name of the property to be set (a string).
    >   - value: the property value (a double).

    C++ signature :
      void SetDoubleProp(RDKit::Bond const*,char const*,double)
  `SetIntProp`((Bond)self, (str)key, (int)val) → None :

    Sets a bond property

    > ARGUMENTS:
    >   - key: the name of the property to be set (a string).
    >   - value: the property value (an int).

    C++ signature :
      void SetIntProp(RDKit::Bond const*,char const*,int)
  `SetIsAromatic`((Bond)arg1, (bool)arg2) → None :
    C++ signature :
      void SetIsAromatic(RDKit::Bond {lvalue},bool)
  `SetIsConjugated`((Bond)arg1, (bool)arg2) → None :
    C++ signature :
      void SetIsConjugated(RDKit::Bond {lvalue},bool)
  `SetProp`((Bond)self, (str)key, (str)val) → None :

    Sets a bond property

    > ARGUMENTS:
    >   - key: the name of the property to be set (a string).
    >   - value: the property value (a string).

    C++ signature :
      void SetProp(RDKit::Bond const*,char const*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)
  `SetStereo`((Bond)arg1, (BondStereo)arg2) → None :

    Set the stereo configuration of the bond as a BondStereo

    C++ signature :
      void SetStereo(RDKit::Bond {lvalue},RDKit::Bond::BondStereo)
  `SetStereoAtoms`((Bond)arg1, (int)arg2, (int)arg3) → None :

    Set the indices of the atoms setting this bond’s stereochemistry.

    C++ signature :
      void SetStereoAtoms(RDKit::Bond {lvalue},unsigned int,unsigned int)
  `SetUnsignedProp`((Bond)self, (str)key, (int)val) → None :

    Sets a bond property

    > ARGUMENTS:
    >   - key: the name of the property to be set (a string).
    >   - value: the property value (an int >= 0).

    C++ signature :
      void SetUnsignedProp(RDKit::Bond const*,char const*,unsigned int)

class `rdkit.Chem.rdchem.` `BondDir`

  Bases: `Boost.Python.enum`

  `BEGINDASH` = rdkit.Chem.rdchem.BondDir.BEGINDASH
  `BEGINWEDGE` = rdkit.Chem.rdchem.BondDir.BEGINWEDGE
  `EITHERDOUBLE` = rdkit.Chem.rdchem.BondDir.EITHERDOUBLE
  `ENDDOWNRIGHT` = rdkit.Chem.rdchem.BondDir.ENDDOWNRIGHT
  `ENDUPRIGHT` = rdkit.Chem.rdchem.BondDir.ENDUPRIGHT
  `NONE` = rdkit.Chem.rdchem.BondDir.NONE
  `UNKNOWN` = rdkit.Chem.rdchem.BondDir.UNKNOWN
  `names` = {'UNKNOWN': rdkit.Chem.rdchem.BondDir.UNKNOWN, 'BEGINDASH': rdkit.Chem.rdchem.BondDir.BEGINDASH, 'ENDDOWNRIGHT': rdkit.Chem.rdchem.BondDir.ENDDOWNRIGHT, 'EITHERDOUBLE': rdkit.Chem.rdchem.BondDir.EITHERDOUBLE, 'BEGINWEDGE': rdkit.Chem.rdchem.BondDir.BEGINWEDGE, 'ENDUPRIGHT': rdkit.Chem.rdchem.BondDir.ENDUPRIGHT, 'NONE': rdkit.Chem.rdchem.BondDir.NONE}
  `values` = {0: rdkit.Chem.rdchem.BondDir.NONE, 1: rdkit.Chem.rdchem.BondDir.BEGINWEDGE, 2: rdkit.Chem.rdchem.BondDir.BEGINDASH, 3: rdkit.Chem.rdchem.BondDir.ENDDOWNRIGHT, 4: rdkit.Chem.rdchem.BondDir.ENDUPRIGHT, 5: rdkit.Chem.rdchem.BondDir.EITHERDOUBLE, 6: rdkit.Chem.rdchem.BondDir.UNKNOWN}

class `rdkit.Chem.rdchem.` `BondStereo`

  Bases: `Boost.Python.enum`

  `STEREOANY` = rdkit.Chem.rdchem.BondStereo.STEREOANY
  `STEREOCIS` = rdkit.Chem.rdchem.BondStereo.STEREOCIS
  `STEREOE` = rdkit.Chem.rdchem.BondStereo.STEREOE
  `STEREONONE` = rdkit.Chem.rdchem.BondStereo.STEREONONE
  `STEREOTRANS` = rdkit.Chem.rdchem.BondStereo.STEREOTRANS
  `STEREOZ` = rdkit.Chem.rdchem.BondStereo.STEREOZ
  `names` = {'STEREOANY': rdkit.Chem.rdchem.BondStereo.STEREOANY, 'STEREOE': rdkit.Chem.rdchem.BondStereo.STEREOE, 'STEREOZ': rdkit.Chem.rdchem.BondStereo.STEREOZ, 'STEREONONE': rdkit.Chem.rdchem.BondStereo.STEREONONE, 'STEREOCIS': rdkit.Chem.rdchem.BondStereo.STEREOCIS, 'STEREOTRANS': rdkit.Chem.rdchem.BondStereo.STEREOTRANS}
  `values` = {0: rdkit.Chem.rdchem.BondStereo.STEREONONE, 1: rdkit.Chem.rdchem.BondStereo.STEREOANY, 2: rdkit.Chem.rdchem.BondStereo.STEREOZ, 3: rdkit.Chem.rdchem.BondStereo.STEREOE, 4: rdkit.Chem.rdchem.BondStereo.STEREOCIS, 5: rdkit.Chem.rdchem.BondStereo.STEREOTRANS}

class `rdkit.Chem.rdchem.` `BondType`

  Bases: `Boost.Python.enum`

  `AROMATIC` = rdkit.Chem.rdchem.BondType.AROMATIC
  `DATIVE` = rdkit.Chem.rdchem.BondType.DATIVE
  `DATIVEL` = rdkit.Chem.rdchem.BondType.DATIVEL
  `DATIVEONE` = rdkit.Chem.rdchem.BondType.DATIVEONE
  `DATIVER` = rdkit.Chem.rdchem.BondType.DATIVER
  `DOUBLE` = rdkit.Chem.rdchem.BondType.DOUBLE
  `FIVEANDAHALF` = rdkit.Chem.rdchem.BondType.FIVEANDAHALF
  `FOURANDAHALF` = rdkit.Chem.rdchem.BondType.FOURANDAHALF
  `HEXTUPLE` = rdkit.Chem.rdchem.BondType.HEXTUPLE
  `HYDROGEN` = rdkit.Chem.rdchem.BondType.HYDROGEN
  `IONIC` = rdkit.Chem.rdchem.BondType.IONIC
  `ONEANDAHALF` = rdkit.Chem.rdchem.BondType.ONEANDAHALF
  `OTHER` = rdkit.Chem.rdchem.BondType.OTHER
  `QUADRUPLE` = rdkit.Chem.rdchem.BondType.QUADRUPLE
  `QUINTUPLE` = rdkit.Chem.rdchem.BondType.QUINTUPLE
  `SINGLE` = rdkit.Chem.rdchem.BondType.SINGLE
  `THREEANDAHALF` = rdkit.Chem.rdchem.BondType.THREEANDAHALF
  `THREECENTER` = rdkit.Chem.rdchem.BondType.THREECENTER
  `TRIPLE` = rdkit.Chem.rdchem.BondType.TRIPLE
  `TWOANDAHALF` = rdkit.Chem.rdchem.BondType.TWOANDAHALF
  `UNSPECIFIED` = rdkit.Chem.rdchem.BondType.UNSPECIFIED
  `ZERO` = rdkit.Chem.rdchem.BondType.ZERO
  `names` = {'FOURANDAHALF': rdkit.Chem.rdchem.BondType.FOURANDAHALF, 'IONIC': rdkit.Chem.rdchem.BondType.IONIC, 'OTHER': rdkit.Chem.rdchem.BondType.OTHER, 'DATIVEONE': rdkit.Chem.rdchem.BondType.DATIVEONE, 'THREEANDAHALF': rdkit.Chem.rdchem.BondType.THREEANDAHALF, 'HYDROGEN': rdkit.Chem.rdchem.BondType.HYDROGEN, 'DATIVER': rdkit.Chem.rdchem.BondType.DATIVER, 'DATIVEL': rdkit.Chem.rdchem.BondType.DATIVEL, 'DATIVE': rdkit.Chem.rdchem.BondType.DATIVE, 'TWOANDAHALF': rdkit.Chem.rdchem.BondType.TWOANDAHALF, 'ZERO': rdkit.Chem.rdchem.BondType.ZERO, 'ONEANDAHALF': rdkit.Chem.rdchem.BondType.ONEANDAHALF, 'SINGLE': rdkit.Chem.rdchem.BondType.SINGLE, 'DOUBLE': rdkit.Chem.rdchem.BondType.DOUBLE, 'THREECENTER': rdkit.Chem.rdchem.BondType.THREECENTER, 'HEXTUPLE': rdkit.Chem.rdchem.BondType.HEXTUPLE, 'UNSPECIFIED': rdkit.Chem.rdchem.BondType.UNSPECIFIED, 'FIVEANDAHALF': rdkit.Chem.rdchem.BondType.FIVEANDAHALF, 'TRIPLE': rdkit.Chem.rdchem.BondType.TRIPLE, 'QUADRUPLE': rdkit.Chem.rdchem.BondType.QUADRUPLE, 'AROMATIC': rdkit.Chem.rdchem.BondType.AROMATIC, 'QUINTUPLE': rdkit.Chem.rdchem.BondType.QUINTUPLE}
  `values` = {0: rdkit.Chem.rdchem.BondType.UNSPECIFIED, 1: rdkit.Chem.rdchem.BondType.SINGLE, 2: rdkit.Chem.rdchem.BondType.DOUBLE, 3: rdkit.Chem.rdchem.BondType.TRIPLE, 4: rdkit.Chem.rdchem.BondType.QUADRUPLE, 5: rdkit.Chem.rdchem.BondType.QUINTUPLE, 6: rdkit.Chem.rdchem.BondType.HEXTUPLE, 7: rdkit.Chem.rdchem.BondType.ONEANDAHALF, 8: rdkit.Chem.rdchem.BondType.TWOANDAHALF, 9: rdkit.Chem.rdchem.BondType.THREEANDAHALF, 10: rdkit.Chem.rdchem.BondType.FOURANDAHALF, 11: rdkit.Chem.rdchem.BondType.FIVEANDAHALF, 12: rdkit.Chem.rdchem.BondType.AROMATIC, 13: rdkit.Chem.rdchem.BondType.IONIC, 14: rdkit.Chem.rdchem.BondType.HYDROGEN, 15: rdkit.Chem.rdchem.BondType.THREECENTER, 16: rdkit.Chem.rdchem.BondType.DATIVEONE, 17: rdkit.Chem.rdchem.BondType.DATIVE, 18: rdkit.Chem.rdchem.BondType.DATIVEL, 19: rdkit.Chem.rdchem.BondType.DATIVER, 20: rdkit.Chem.rdchem.BondType.OTHER, 21: rdkit.Chem.rdchem.BondType.ZERO}

class `rdkit.Chem.rdchem.` `ChiralType`

  Bases: `Boost.Python.enum`

  `CHI_OTHER` = rdkit.Chem.rdchem.ChiralType.CHI_OTHER
  `CHI_TETRAHEDRAL_CCW` = rdkit.Chem.rdchem.ChiralType.CHI_TETRAHEDRAL_CCW
  `CHI_TETRAHEDRAL_CW` = rdkit.Chem.rdchem.ChiralType.CHI_TETRAHEDRAL_CW
  `CHI_UNSPECIFIED` = rdkit.Chem.rdchem.ChiralType.CHI_UNSPECIFIED
  `names` = {'CHI_TETRAHEDRAL_CW': rdkit.Chem.rdchem.ChiralType.CHI_TETRAHEDRAL_CW, 'CHI_OTHER': rdkit.Chem.rdchem.ChiralType.CHI_OTHER, 'CHI_TETRAHEDRAL_CCW': rdkit.Chem.rdchem.ChiralType.CHI_TETRAHEDRAL_CCW, 'CHI_UNSPECIFIED': rdkit.Chem.rdchem.ChiralType.CHI_UNSPECIFIED}
  `values` = {0: rdkit.Chem.rdchem.ChiralType.CHI_UNSPECIFIED, 1: rdkit.Chem.rdchem.ChiralType.CHI_TETRAHEDRAL_CW, 2: rdkit.Chem.rdchem.ChiralType.CHI_TETRAHEDRAL_CCW, 3: rdkit.Chem.rdchem.ChiralType.CHI_OTHER}

class `rdkit.Chem.rdchem.` `CompositeQueryType`

  Bases: `Boost.Python.enum`

  `COMPOSITE_AND` = rdkit.Chem.rdchem.CompositeQueryType.COMPOSITE_AND
  `COMPOSITE_OR` = rdkit.Chem.rdchem.CompositeQueryType.COMPOSITE_OR
  `COMPOSITE_XOR` = rdkit.Chem.rdchem.CompositeQueryType.COMPOSITE_XOR
  `names` = {'COMPOSITE_OR': rdkit.Chem.rdchem.CompositeQueryType.COMPOSITE_OR, 'COMPOSITE_XOR': rdkit.Chem.rdchem.CompositeQueryType.COMPOSITE_XOR, 'COMPOSITE_AND': rdkit.Chem.rdchem.CompositeQueryType.COMPOSITE_AND}
  `values` = {0: rdkit.Chem.rdchem.CompositeQueryType.COMPOSITE_AND, 1: rdkit.Chem.rdchem.CompositeQueryType.COMPOSITE_OR, 2: rdkit.Chem.rdchem.CompositeQueryType.COMPOSITE_XOR}

class `rdkit.Chem.rdchem.` `Conformer`

  Bases: `Boost.Python.instance`

  The class to store 2D or 3D conformation of a molecule

  `GetAtomPosition`((Conformer)arg1, (int)arg2) → Point3D :

    Get the posistion of an atom

    C++ signature :
      RDGeom::Point3D GetAtomPosition(RDKit::Conformer const*,unsigned int)
  `GetId`((Conformer)arg1) → int :

    Get the ID of the conformer

    C++ signature :
      unsigned int GetId(RDKit::Conformer {lvalue})
  `GetNumAtoms`((Conformer)arg1) → int :

    Get the number of atoms in the conformer

    C++ signature :
      unsigned int GetNumAtoms(RDKit::Conformer {lvalue})
  `GetOwningMol`((Conformer)arg1) → Mol :

    Get the owning molecule

    C++ signature :
      RDKit::ROMol {lvalue} GetOwningMol(RDKit::Conformer {lvalue})
  `GetPositions`((Conformer)arg1) → object :

    Get positions of all the atoms

    C++ signature :
      _object* GetPositions(RDKit::Conformer const*)
  `Is3D`((Conformer)arg1) → bool :

    returns the 3D flag of the conformer

    C++ signature :
      bool Is3D(RDKit::Conformer {lvalue})
  `Set3D`((Conformer)arg1, (bool)arg2) → None :

    Set the 3D flag of the conformer

    C++ signature :
      void Set3D(RDKit::Conformer {lvalue},bool)
  `SetAtomPosition`((Conformer)arg1, (int)arg2, (object)arg3) → None :

    Set the position of the specified atom

    > C++ signature :
    >   void SetAtomPosition(RDKit::Conformer*,unsigned int,boost::python::api::object)

    SetAtomPosition( (Conformer)arg1, (int)arg2, (Point3D)arg3) -> None :

      Set the position of the specified atom

      C++ signature :
        void SetAtomPosition(RDKit::Conformer {lvalue},unsigned int,RDGeom::Point3D)
  `SetId`((Conformer)arg1, (int)arg2) → None :

    Set the ID of the conformer

    C++ signature :
      void SetId(RDKit::Conformer {lvalue},unsigned int)

class `rdkit.Chem.rdchem.` `EditableMol`

  Bases: `Boost.Python.instance`

  an editable molecule class

  `AddAtom`((EditableMol)mol, (Atom)atom) → int :

    add an atom, returns the index of the newly added atom

    C++ signature :
      int AddAtom(RDKit::(anonymous namespace)::EditableMol {lvalue},RDKit::Atom*)
  `AddBond`((EditableMol)mol, (int)beginAtomIdx, (int)endAtomIdx[, (BondType)order=rdkit.Chem.rdchem.BondType.UNSPECIFIED]) → int :

    add a bond, returns the index of the newly added bond

    C++ signature :
      int AddBond(RDKit::(anonymous namespace)::EditableMol {lvalue},unsigned int,unsigned int [,RDKit::Bond::BondType=rdkit.Chem.rdchem.BondType.UNSPECIFIED])
  `GetMol`((EditableMol)arg1) → Mol :

    Returns a Mol (a normal molecule)

    C++ signature :
      RDKit::ROMol* GetMol(RDKit::(anonymous namespace)::EditableMol {lvalue})
  `RemoveAtom`((EditableMol)arg1, (int)arg2) → None :

    Remove the specified atom from the molecule

    C++ signature :
      void RemoveAtom(RDKit::(anonymous namespace)::EditableMol {lvalue},unsigned int)
  `RemoveBond`((EditableMol)arg1, (int)arg2, (int)arg3) → None :

    Remove the specified bond from the molecule

    C++ signature :
      void RemoveBond(RDKit::(anonymous namespace)::EditableMol {lvalue},unsigned int,unsigned int)
  `ReplaceAtom`((EditableMol)mol, (int)index, (Atom)newAtom) → None :

    replaces the specified atom with the provided one

    C++ signature :
      void ReplaceAtom(RDKit::(anonymous namespace)::EditableMol {lvalue},unsigned int,RDKit::Atom*)

`rdkit.Chem.rdchem.` `GetAtomAlias`((Atom)atom) → str :

  Returns the atom’s MDL alias text

  C++ signature :
    std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > GetAtomAlias(RDKit::Atom const*)

`rdkit.Chem.rdchem.` `GetAtomRLabel`((Atom)atom) → int :

  Returns the atom’s MDL AtomRLabel (this is an integer from 0 to 99)

  C++ signature :
    int GetAtomRLabel(RDKit::Atom const*)

`rdkit.Chem.rdchem.` `GetAtomValue`((Atom)atom) → str :

  Returns the atom’s MDL alias text

  C++ signature :
    std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > GetAtomValue(RDKit::Atom const*)

`rdkit.Chem.rdchem.` `GetDefaultPickleProperties`() → int :

  Get the current global mol pickler options.

  C++ signature :
    unsigned int GetDefaultPickleProperties()

`rdkit.Chem.rdchem.` `GetPeriodicTable`() → PeriodicTable :

  Returns the application’s PeriodicTable instance.

  C++ signature :
    RDKit::PeriodicTable* GetPeriodicTable()

`rdkit.Chem.rdchem.` `GetSupplementalSmilesLabel`((Atom)atom) → str :

  Gets the supplemental smiles label on an atom, returns an empty string if not present.

  C++ signature :
    std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > GetSupplementalSmilesLabel(RDKit::Atom const*)

class `rdkit.Chem.rdchem.` `HybridizationType`

  Bases: `Boost.Python.enum`

  `OTHER` = rdkit.Chem.rdchem.HybridizationType.OTHER
  `S` = rdkit.Chem.rdchem.HybridizationType.S
  `SP` = rdkit.Chem.rdchem.HybridizationType.SP
  `SP2` = rdkit.Chem.rdchem.HybridizationType.SP2
  `SP3` = rdkit.Chem.rdchem.HybridizationType.SP3
  `SP3D` = rdkit.Chem.rdchem.HybridizationType.SP3D
  `SP3D2` = rdkit.Chem.rdchem.HybridizationType.SP3D2
  `UNSPECIFIED` = rdkit.Chem.rdchem.HybridizationType.UNSPECIFIED
  `names` = {'SP': rdkit.Chem.rdchem.HybridizationType.SP, 'S': rdkit.Chem.rdchem.HybridizationType.S, 'SP3D2': rdkit.Chem.rdchem.HybridizationType.SP3D2, 'SP3': rdkit.Chem.rdchem.HybridizationType.SP3, 'UNSPECIFIED': rdkit.Chem.rdchem.HybridizationType.UNSPECIFIED, 'SP2': rdkit.Chem.rdchem.HybridizationType.SP2, 'OTHER': rdkit.Chem.rdchem.HybridizationType.OTHER, 'SP3D': rdkit.Chem.rdchem.HybridizationType.SP3D}
  `values` = {0: rdkit.Chem.rdchem.HybridizationType.UNSPECIFIED, 1: rdkit.Chem.rdchem.HybridizationType.S, 2: rdkit.Chem.rdchem.HybridizationType.SP, 3: rdkit.Chem.rdchem.HybridizationType.SP2, 4: rdkit.Chem.rdchem.HybridizationType.SP3, 5: rdkit.Chem.rdchem.HybridizationType.SP3D, 6: rdkit.Chem.rdchem.HybridizationType.SP3D2, 7: rdkit.Chem.rdchem.HybridizationType.OTHER}

`rdkit.Chem.rdchem.` `LogErrorMsg`((str)arg1) → None :

  Log a warning message to the RDKit error logs

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

`rdkit.Chem.rdchem.` `LogWarningMsg`((str)arg1) → None :

  Log a warning message to the RDKit warning logs

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

class `rdkit.Chem.rdchem.` `Mol`

  Bases: `Boost.Python.instance`

  The Molecule class.

  In addition to the expected Atoms and Bonds, molecules contain:
    - a collection of Atom and Bond bookmarks indexed with integers

        that can be used to flag and retrieve particular Atoms or Bonds using the {get|set}{Atom|Bond}Bookmark() methods.

    - a set of string-valued properties. These can have arbitrary string

        labels and can be set and retrieved using the {set|get}Prop() methods Molecular properties can be tagged as being computed, in which case

        > they will be automatically cleared under certain circumstances (when the molecule itself is modified, for example).

        Molecules also have the concept of private properties, which are tagged

          by beginning the property name with an underscore (_).

  `AddConformer`((Mol)self, (Conformer)conf[, (bool)assignId=False]) → int :

    Add a conformer to the molecule and return the conformer ID

    C++ signature :
      unsigned int AddConformer(RDKit::ROMol {lvalue},RDKit::Conformer* [,bool=False])
  `ClearComputedProps`((Mol)arg1) → None :

    Removes all computed properties from the molecule.

    C++ signature :
      void ClearComputedProps(RDKit::ROMol)
  `ClearProp`((Mol)arg1, (str)arg2) → None :

    Removes a property from the molecule.

    > ARGUMENTS:
    >   - key: the name of the property to clear (a string).

    C++ signature :
      void ClearProp(RDKit::ROMol,char const*)
  `Debug`((Mol)mol[, (bool)useStdout=True]) → None :

    Prints debugging information about the molecule.

    C++ signature :
      void Debug(RDKit::ROMol [,bool=True])
  `GetAromaticAtoms`((Mol)arg1) → _ROQAtomSeq :

    Returns a read-only sequence containing all of the molecule’s aromatic Atoms.

    C++ signature :
      RDKit::ReadOnlySeq<RDKit::QueryAtomIterator_<RDKit::Atom, RDKit::ROMol>, RDKit::Atom*>* GetAromaticAtoms(RDKit::ROMol*)
  `GetAtomWithIdx`((Mol)arg1, (int)arg2) → Atom :

    Returns a particular Atom.

    > ARGUMENTS:
    >   - idx: which Atom to return

    > NOTE: atom indices start at 0

    C++ signature :
      RDKit::Atom* GetAtomWithIdx(RDKit::ROMol {lvalue},unsigned int)
  `GetAtoms`((Mol)arg1) → _ROAtomSeq :

    Returns a read-only sequence containing all of the molecule’s Atoms.

    C++ signature :
      RDKit::ReadOnlySeq<RDKit::AtomIterator_<RDKit::Atom, RDKit::ROMol>, RDKit::Atom*>* GetAtoms(RDKit::ROMol*)
  `GetAtomsMatchingQuery`((Mol)arg1, (QueryAtom)arg2) → _ROQAtomSeq :

    Returns a read-only sequence containing all of the atoms in a molecule that match the query atom.

    C++ signature :
      RDKit::ReadOnlySeq<RDKit::QueryAtomIterator_<RDKit::Atom, RDKit::ROMol>, RDKit::Atom*>* GetAtomsMatchingQuery(RDKit::ROMol*,RDKit::QueryAtom*)
  `GetBondBetweenAtoms`((Mol)arg1, (int)arg2, (int)arg3) → Bond :

    Returns the bond between two atoms, if there is one.

    > ARGUMENTS:
    >   - idx1,idx2: the Atom indices
    > Returns:
    >   The Bond between the two atoms, if such a bond exists. If there is no Bond between the atoms, None is returned instead.

    > NOTE: bond indices start at 0

    C++ signature :
      RDKit::Bond* GetBondBetweenAtoms(RDKit::ROMol {lvalue},unsigned int,unsigned int)
  `GetBondWithIdx`((Mol)arg1, (int)arg2) → Bond :

    Returns a particular Bond.

    > ARGUMENTS:
    >   - idx: which Bond to return

    > NOTE: bond indices start at 0

    C++ signature :
      RDKit::Bond* GetBondWithIdx(RDKit::ROMol {lvalue},unsigned int)
  `GetBonds`((Mol)arg1) → _ROBondSeq :

    Returns a read-only sequence containing all of the molecule’s Bonds.

    C++ signature :
      RDKit::ReadOnlySeq<RDKit::BondIterator_, RDKit::Bond*>* GetBonds(RDKit::ROMol*)
  `GetBoolProp`((Mol)arg1, (str)arg2) → bool :

    Returns the double value of the property if possible.

    > ARGUMENTS:
    >   - key: the name of the property to return (a string).

    > RETURNS: a bool

    > NOTE:
    >   - If the property has not been set, a KeyError exception will be raised.

    C++ signature :
      bool GetBoolProp(RDKit::ROMol*,char const*)
  `GetConformer`((Mol)self[, (int)id=-1]) → Conformer :

    Get the conformer with a specified ID

    C++ signature :
      RDKit::Conformer* GetConformer(RDKit::ROMol {lvalue} [,int=-1])
  `GetConformers`((Mol)arg1) → object :

    Get all the conformers as a tuple

    C++ signature :
      _object* GetConformers(RDKit::ROMol {lvalue})
  `GetDoubleProp`((Mol)arg1, (str)arg2) → float :

    Returns the double value of the property if possible.

    > ARGUMENTS:
    >   - key: the name of the property to return (a string).

    > RETURNS: a double

    > NOTE:
    >   - If the property has not been set, a KeyError exception will be raised.

    C++ signature :
      double GetDoubleProp(RDKit::ROMol*,char const*)
  `GetIntProp`((Mol)arg1, (str)arg2) → int :

    Returns the integer value of the property if possible.

    > ARGUMENTS:
    >   - key: the name of the property to return (a string).

    > RETURNS: an integer

    > NOTE:
    >   - If the property has not been set, a KeyError exception will be raised.

    C++ signature :
      int GetIntProp(RDKit::ROMol*,char const*)
  `GetNumAtoms`((Mol)arg1[, (int)onlyHeavy=-1[, (bool)onlyExplicit=True]]) → int :

    Returns the number of atoms in the molecule.

    > ARGUMENTS:
    >   - onlyExplicit: (optional) include only explicit atoms (atoms in the molecular graph)

    >       defaults to 1.

    > NOTE: the onlyHeavy argument is deprecated

    C++ signature :
      int GetNumAtoms(RDKit::ROMol [,int=-1 [,bool=True]])
  `GetNumBonds`((Mol)arg1[, (bool)onlyHeavy=True]) → int :

    Returns the number of Bonds in the molecule.

    > ARGUMENTS:
    >   - onlyHeavy: (optional) include only bonds to heavy atoms (not Hs)

    >       defaults to 1.

    C++ signature :
      unsigned int GetNumBonds(RDKit::ROMol {lvalue} [,bool=True])
  `GetNumConformers`((Mol)arg1) → int :

    Return the number of conformations on the molecule

    C++ signature :
      unsigned int GetNumConformers(RDKit::ROMol {lvalue})
  `GetNumHeavyAtoms`((Mol)arg1) → int :

    Returns the number of heavy atoms (atomic number >1) in the molecule.

    C++ signature :
      unsigned int GetNumHeavyAtoms(RDKit::ROMol {lvalue})
  `GetProp`((Mol)arg1, (str)arg2) → str :

    Returns the value of the property.

    > ARGUMENTS:
    >   - key: the name of the property to return (a string).

    > RETURNS: a string

    > NOTE:
    >   - If the property has not been set, a KeyError exception will be raised.

    C++ signature :
      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > GetProp(RDKit::ROMol*,char const*)
  `GetPropNames`((Mol)self[, (bool)includePrivate=False[, (bool)includeComputed=False]]) → _vectNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE :

    Returns a tuple with all property names for this molecule.

    > ARGUMENTS:
    >   - includePrivate: (optional) toggles inclusion of private properties in the result set.

    >       Defaults to 0.

    >   - includeComputed: (optional) toggles inclusion of computed properties in the result set.

    >       Defaults to 0.

    > RETURNS: a tuple of strings

    C++ signature :
      std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > GetPropNames(RDKit::ROMol {lvalue} [,bool=False [,bool=False]])
  `GetPropsAsDict`((Mol)self[, (bool)includePrivate=False[, (bool)includeComputed=False]]) → dict :
    Returns a dictionary populated with the molecules properties.

      n.b. Some properties are not able to be converted to python types.

      > ARGUMENTS:
      >   - includePrivate: (optional) toggles inclusion of private properties in the result set.

      >       Defaults to False.

      >   - includeComputed: (optional) toggles inclusion of computed properties in the result set.

      >       Defaults to False.

      > RETURNS: a dictionary

    C++ signature :
      boost::python::dict GetPropsAsDict(RDKit::ROMol [,bool=False [,bool=False]])
  `GetRingInfo`((Mol)arg1) → RingInfo :

    Returns the number of molecule’s RingInfo object.

    C++ signature :
      RDKit::RingInfo* GetRingInfo(RDKit::ROMol {lvalue})
  `GetSubstructMatch`((Mol)self, (Mol)query[, (bool)useChirality=False[, (bool)useQueryQueryMatches=False]]) → object :

    Returns the indices of the molecule’s atoms that match a substructure query.

    > ARGUMENTS:
    >   - query: a Molecule
    >   - useChirality: enables the use of stereochemistry in the matching
    >   - useQueryQueryMatches: use query-query matching logic

    > RETURNS: a tuple of integers

    > NOTES:

    >   - only a single match is returned

    >   - the ordering of the indices corresponds to the atom ordering

    >       in the query. For example, the first index is for the atom in this molecule that matches the first atom in the query.

    C++ signature :
      _object* GetSubstructMatch(RDKit::ROMol,RDKit::ROMol [,bool=False [,bool=False]])
  `GetSubstructMatches`((Mol)self, (Mol)query[, (bool)uniquify=True[, (bool)useChirality=False[, (bool)useQueryQueryMatches=False[, (int)maxMatches=1000]]]]) → object :

    Returns tuples of the indices of the molecule’s atoms that match a substructure query.

    > ARGUMENTS:

    >   - query: a Molecule.

    >   - uniquify: (optional) determines whether or not the matches are uniquified.

    >       Defaults to 1.

    >   - useChirality: enables the use of stereochemistry in the matching

    >   - useQueryQueryMatches: use query-query matching logic

    >   - maxMatches: The maximum number of matches that will be returned.

    >       In high-symmetry cases with medium-sized molecules, it is very easy to end up with a combinatorial explosion in the number of possible matches. This argument prevents that from having unintended consequences

    > RETURNS: a tuple of tuples of integers

    > NOTE:
    >   - the ordering of the indices corresponds to the atom ordering

    >       in the query. For example, the first index is for the atom in this molecule that matches the first atom in the query.

    C++ signature :
      _object* GetSubstructMatches(RDKit::ROMol,RDKit::ROMol [,bool=True [,bool=False [,bool=False [,unsigned int=1000]]]])
  `GetUnsignedProp`((Mol)arg1, (str)arg2) → int :

    Returns the unsigned int value of the property if possible.

    > ARGUMENTS:
    >   - key: the name of the property to return (a string).

    > RETURNS: an unsigned integer

    > NOTE:
    >   - If the property has not been set, a KeyError exception will be raised.

    C++ signature :
      unsigned int GetUnsignedProp(RDKit::ROMol*,char const*)
  `HasProp`((Mol)arg1, (str)arg2) → int :

    Queries a molecule to see if a particular property has been assigned.

    > ARGUMENTS:
    >   - key: the name of the property to check for (a string).

    C++ signature :
      int HasProp(RDKit::ROMol,char const*)
  `HasSubstructMatch`((Mol)self, (Mol)query[, (bool)recursionPossible=True[, (bool)useChirality=False[, (bool)useQueryQueryMatches=False]]]) → bool :

    Queries whether or not the molecule contains a particular substructure.

    > ARGUMENTS:
    >   - query: a Molecule
    >   - recursionPossible: (optional)
    >   - useChirality: enables the use of stereochemistry in the matching
    >   - useQueryQueryMatches: use query-query matching logic

    > RETURNS: True or False

    C++ signature :
      bool HasSubstructMatch(RDKit::ROMol,RDKit::ROMol [,bool=True [,bool=False [,bool=False]]])
  `NeedsUpdatePropertyCache`((Mol)self) → bool :

    Returns true or false depending on whether implicit and explicit valence of the molecule have already been calculated.

    C++ signature :
      bool NeedsUpdatePropertyCache(RDKit::ROMol {lvalue})
  `RemoveAllConformers`((Mol)arg1) → None :

    Remove all the conformations on the molecule

    C++ signature :
      void RemoveAllConformers(RDKit::ROMol {lvalue})
  `RemoveConformer`((Mol)arg1, (int)arg2) → None :

    Remove the conformer with the specified ID

    C++ signature :
      void RemoveConformer(RDKit::ROMol {lvalue},unsigned int)
  `SetBoolProp`((Mol)self, (str)key, (bool)val[, (bool)computed=False]) → None :

    Sets a boolean valued molecular property

    > ARGUMENTS:

    >   - key: the name of the property to be set (a string).

    >   - value: the property value as a bool.

    >   - computed: (optional) marks the property as being computed.

    >       Defaults to False.

    C++ signature :
      void SetBoolProp(RDKit::ROMol,char const*,bool [,bool=False])
  `SetDoubleProp`((Mol)self, (str)key, (float)val[, (bool)computed=False]) → None :

    Sets a double valued molecular property

    > ARGUMENTS:

    >   - key: the name of the property to be set (a string).

    >   - value: the property value as a double.

    >   - computed: (optional) marks the property as being computed.

    >       Defaults to 0.

    C++ signature :
      void SetDoubleProp(RDKit::ROMol,char const*,double [,bool=False])
  `SetIntProp`((Mol)self, (str)key, (int)val[, (bool)computed=False]) → None :

    Sets an integer valued molecular property

    > ARGUMENTS:

    >   - key: the name of the property to be set (an unsigned number).

    >   - value: the property value as an integer.

    >   - computed: (optional) marks the property as being computed.

    >       Defaults to False.

    C++ signature :
      void SetIntProp(RDKit::ROMol,char const*,int [,bool=False])
  `SetProp`((Mol)self, (str)key, (str)val[, (bool)computed=False]) → None :

    Sets a molecular property

    > ARGUMENTS:

    >   - key: the name of the property to be set (a string).

    >   - value: the property value (a string).

    >   - computed: (optional) marks the property as being computed.

    >       Defaults to False.

    C++ signature :
      void SetProp(RDKit::ROMol,char const*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > [,bool=False])
  `SetUnsignedProp`((Mol)self, (str)key, (int)val[, (bool)computed=False]) → None :

    Sets an unsigned integer valued molecular property

    > ARGUMENTS:

    >   - key: the name of the property to be set (a string).

    >   - value: the property value as an unsigned integer.

    >   - computed: (optional) marks the property as being computed.

    >       Defaults to False.

    C++ signature :
      void SetUnsignedProp(RDKit::ROMol,char const*,unsigned int [,bool=False])
  `ToBinary`((Mol)arg1) → object :

    Returns a binary string representation of the molecule.

    > C++ signature :
    >   boost::python::api::object ToBinary(RDKit::ROMol)

    ToBinary( (Mol)mol, (int)propertyFlags) -> object :

      Returns a binary string representation of the molecule pickling the specified properties.

      C++ signature :
        boost::python::api::object ToBinary(RDKit::ROMol,unsigned int)
  `UpdatePropertyCache`((Mol)self[, (bool)strict=True]) → None :

    Regenerates computed properties like implicit valence and ring information.

    C++ signature :
      void UpdatePropertyCache(RDKit::ROMol {lvalue} [,bool=True])

class `rdkit.Chem.rdchem.` `PeriodicTable`

  Bases: `Boost.Python.instance`

  A class which stores information from the Periodic Table.

  It is not possible to create a PeriodicTable object directly from Python, use GetPeriodicTable() to get the global table.

  The PeriodicTable object can be queried for a variety of properties:

  > - GetAtomicWeight
  > - GetAtomicNumber
  > - GetElementSymbol
  > - GetRvdw (van der Waals radius)
  > - GetRCovalent (covalent radius)
  > - GetDefaultValence
  > - GetValenceList
  > - GetNOuterElecs (number of valence electrons)
  > - GetMostCommonIsotope
  > - GetMostCommonIsotopeMass
  > - GetRb0
  > - GetAbundanceForIsotope
  > - GetMassForIsotope

  When it makes sense, these can be queried using either an atomic number (integer) or an atomic symbol (string)

  `GetAbundanceForIsotope`((PeriodicTable)arg1, (int)arg2, (int)arg3) → float :

    > C++ signature :
    >   double GetAbundanceForIsotope(RDKit::PeriodicTable {lvalue},unsigned int,unsigned int)

    GetAbundanceForIsotope( (PeriodicTable)arg1, (str)arg2, (int)arg3) -> float :

    > C++ signature :
    >   double GetAbundanceForIsotope(RDKit::PeriodicTable {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,unsigned int)

  `GetAtomicNumber`((PeriodicTable)arg1, (str)arg2) → int :
    C++ signature :
      int GetAtomicNumber(RDKit::PeriodicTable {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)
  `GetAtomicWeight`((PeriodicTable)arg1, (int)arg2) → float :

    > C++ signature :
    >   double GetAtomicWeight(RDKit::PeriodicTable {lvalue},unsigned int)

    GetAtomicWeight( (PeriodicTable)arg1, (str)arg2) -> float :

    > C++ signature :
    >   double GetAtomicWeight(RDKit::PeriodicTable {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

  `GetDefaultValence`((PeriodicTable)arg1, (int)arg2) → int :

    > C++ signature :
    >   int GetDefaultValence(RDKit::PeriodicTable {lvalue},unsigned int)

    GetDefaultValence( (PeriodicTable)arg1, (str)arg2) -> int :

    > C++ signature :
    >   int GetDefaultValence(RDKit::PeriodicTable {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

  `GetElementSymbol`((PeriodicTable)arg1, (int)arg2) → str :
    C++ signature :
      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > GetElementSymbol(RDKit::PeriodicTable {lvalue},unsigned int)
  `GetMassForIsotope`((PeriodicTable)arg1, (int)arg2, (int)arg3) → float :

    > C++ signature :
    >   double GetMassForIsotope(RDKit::PeriodicTable {lvalue},unsigned int,unsigned int)

    GetMassForIsotope( (PeriodicTable)arg1, (str)arg2, (int)arg3) -> float :

    > C++ signature :
    >   double GetMassForIsotope(RDKit::PeriodicTable {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,unsigned int)

  `GetMostCommonIsotope`((PeriodicTable)arg1, (int)arg2) → int :

    > C++ signature :
    >   int GetMostCommonIsotope(RDKit::PeriodicTable {lvalue},unsigned int)

    GetMostCommonIsotope( (PeriodicTable)arg1, (str)arg2) -> int :

    > C++ signature :
    >   int GetMostCommonIsotope(RDKit::PeriodicTable {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

  `GetMostCommonIsotopeMass`((PeriodicTable)arg1, (int)arg2) → float :

    > C++ signature :
    >   double GetMostCommonIsotopeMass(RDKit::PeriodicTable {lvalue},unsigned int)

    GetMostCommonIsotopeMass( (PeriodicTable)arg1, (str)arg2) -> float :

    > C++ signature :
    >   double GetMostCommonIsotopeMass(RDKit::PeriodicTable {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

  `GetNOuterElecs`((PeriodicTable)arg1, (int)arg2) → int :

    > C++ signature :
    >   int GetNOuterElecs(RDKit::PeriodicTable {lvalue},unsigned int)

    GetNOuterElecs( (PeriodicTable)arg1, (str)arg2) -> int :

    > C++ signature :
    >   int GetNOuterElecs(RDKit::PeriodicTable {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

  `GetRb0`((PeriodicTable)arg1, (int)arg2) → float :

    > C++ signature :
    >   double GetRb0(RDKit::PeriodicTable {lvalue},unsigned int)

    GetRb0( (PeriodicTable)arg1, (str)arg2) -> float :

    > C++ signature :
    >   double GetRb0(RDKit::PeriodicTable {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

  `GetRcovalent`((PeriodicTable)arg1, (int)arg2) → float :

    > C++ signature :
    >   double GetRcovalent(RDKit::PeriodicTable {lvalue},unsigned int)

    GetRcovalent( (PeriodicTable)arg1, (str)arg2) -> float :

    > C++ signature :
    >   double GetRcovalent(RDKit::PeriodicTable {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

  `GetRvdw`((PeriodicTable)arg1, (int)arg2) → float :

    > C++ signature :
    >   double GetRvdw(RDKit::PeriodicTable {lvalue},unsigned int)

    GetRvdw( (PeriodicTable)arg1, (str)arg2) -> float :

    > C++ signature :
    >   double GetRvdw(RDKit::PeriodicTable {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

  `GetValenceList`((PeriodicTable)arg1, (int)arg2) → _vecti :

    > C++ signature :
    >   std::vector<int, std::allocator<int> > GetValenceList(RDKit::PeriodicTable {lvalue},unsigned int)

    GetValenceList( (PeriodicTable)arg1, (str)arg2) -> _vecti :

    > C++ signature :
    >   std::vector<int, std::allocator<int> > GetValenceList(RDKit::PeriodicTable {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

class `rdkit.Chem.rdchem.` `PropertyPickleOptions`

  Bases: `Boost.Python.enum`

  `AllProps` = rdkit.Chem.rdchem.PropertyPickleOptions.AllProps
  `AtomProps` = rdkit.Chem.rdchem.PropertyPickleOptions.AtomProps
  `BondProps` = rdkit.Chem.rdchem.PropertyPickleOptions.BondProps
  `ComputedProps` = rdkit.Chem.rdchem.PropertyPickleOptions.ComputedProps
  `MolProps` = rdkit.Chem.rdchem.PropertyPickleOptions.MolProps
  `NoProps` = rdkit.Chem.rdchem.PropertyPickleOptions.NoProps
  `PrivateProps` = rdkit.Chem.rdchem.PropertyPickleOptions.PrivateProps
  `QueryAtomData` = rdkit.Chem.rdchem.PropertyPickleOptions.QueryAtomData
  `names` = {'MolProps': rdkit.Chem.rdchem.PropertyPickleOptions.MolProps, 'QueryAtomData': rdkit.Chem.rdchem.PropertyPickleOptions.QueryAtomData, 'PrivateProps': rdkit.Chem.rdchem.PropertyPickleOptions.PrivateProps, 'BondProps': rdkit.Chem.rdchem.PropertyPickleOptions.BondProps, 'ComputedProps': rdkit.Chem.rdchem.PropertyPickleOptions.ComputedProps, 'AllProps': rdkit.Chem.rdchem.PropertyPickleOptions.AllProps, 'NoProps': rdkit.Chem.rdchem.PropertyPickleOptions.NoProps, 'AtomProps': rdkit.Chem.rdchem.PropertyPickleOptions.AtomProps}
  `values` = {0: rdkit.Chem.rdchem.PropertyPickleOptions.NoProps, 1: rdkit.Chem.rdchem.PropertyPickleOptions.MolProps, 65536: rdkit.Chem.rdchem.PropertyPickleOptions.PrivateProps, 2147483647: rdkit.Chem.rdchem.PropertyPickleOptions.AllProps, 1048576: rdkit.Chem.rdchem.PropertyPickleOptions.ComputedProps, 256: rdkit.Chem.rdchem.PropertyPickleOptions.QueryAtomData, 16: rdkit.Chem.rdchem.PropertyPickleOptions.AtomProps}

class `rdkit.Chem.rdchem.` `QueryAtom`

  Bases: `rdkit.Chem.rdchem.Atom`

  The class to store QueryAtoms. These cannot currently be constructed directly from Python

  `ExpandQuery`((QueryAtom)self, (QueryAtom)other[, (CompositeQueryType)how=rdkit.Chem.rdchem.CompositeQueryType.COMPOSITE_AND[, (bool)maintainOrder=True]]) → None :

    combines the query from other with ours

    C++ signature :
      void ExpandQuery(RDKit::QueryAtom*,RDKit::QueryAtom const* [,Queries::CompositeQueryType=rdkit.Chem.rdchem.CompositeQueryType.COMPOSITE_AND [,bool=True]])

class `rdkit.Chem.rdchem.` `QueryBond`

  Bases: `rdkit.Chem.rdchem.Bond`

  The class to store QueryBonds. These cannot currently be constructed directly from Python

class `rdkit.Chem.rdchem.` `RWMol`

  Bases: `rdkit.Chem.rdchem.Mol`

  The RW molecule class (read/write)

  This class is a more-performant version of the EditableMolecule class in that it is a ‘live’ molecule and shares the interface from the Mol class. All changes are performed without the need to create a copy of the molecule using GetMol() (this is still available, however).

  n.b. Eventually this class may become a direct replacement for EditableMol

  `AddAtom`((RWMol)mol, (Atom)atom) → int :

    add an atom, returns the index of the newly added atom

    C++ signature :
      int AddAtom(RDKit::ReadWriteMol {lvalue},RDKit::Atom*)
  `AddBond`((RWMol)mol, (int)beginAtomIdx, (int)endAtomIdx[, (BondType)order=rdkit.Chem.rdchem.BondType.UNSPECIFIED]) → int :

    add a bond, returns the new number of bonds

    C++ signature :
      int AddBond(RDKit::ReadWriteMol {lvalue},unsigned int,unsigned int [,RDKit::Bond::BondType=rdkit.Chem.rdchem.BondType.UNSPECIFIED])
  `GetMol`((RWMol)arg1) → Mol :

    Returns a Mol (a normal molecule)

    C++ signature :
      RDKit::ROMol* GetMol(RDKit::ReadWriteMol {lvalue})
  `RemoveAtom`((RWMol)arg1, (int)arg2) → None :

    Remove the specified atom from the molecule

    C++ signature :
      void RemoveAtom(RDKit::ReadWriteMol {lvalue},unsigned int)
  `RemoveBond`((RWMol)arg1, (int)arg2, (int)arg3) → None :

    Remove the specified bond from the molecule

    C++ signature :
      void RemoveBond(RDKit::ReadWriteMol {lvalue},unsigned int,unsigned int)
  `ReplaceAtom`((RWMol)mol, (int)index, (Atom)newAtom) → None :

    replaces the specified atom with the provided one

    C++ signature :
      void ReplaceAtom(RDKit::ReadWriteMol {lvalue},unsigned int,RDKit::Atom*)
  `ReplaceBond`((RWMol)mol, (int)index, (Bond)newBond) → None :

    replaces the specified bond with the provided one

    C++ signature :
      void ReplaceBond(RDKit::ReadWriteMol {lvalue},unsigned int,RDKit::Bond*)

class `rdkit.Chem.rdchem.` `ResonanceFlags`

  Bases: `Boost.Python.enum`

  `ALLOW_CHARGE_SEPARATION` = rdkit.Chem.rdchem.ResonanceFlags.ALLOW_CHARGE_SEPARATION
  `ALLOW_INCOMPLETE_OCTETS` = rdkit.Chem.rdchem.ResonanceFlags.ALLOW_INCOMPLETE_OCTETS
  `KEKULE_ALL` = rdkit.Chem.rdchem.ResonanceFlags.KEKULE_ALL
  `UNCONSTRAINED_ANIONS` = rdkit.Chem.rdchem.ResonanceFlags.UNCONSTRAINED_ANIONS
  `UNCONSTRAINED_CATIONS` = rdkit.Chem.rdchem.ResonanceFlags.UNCONSTRAINED_CATIONS
  `names` = {'ALLOW_CHARGE_SEPARATION': rdkit.Chem.rdchem.ResonanceFlags.ALLOW_CHARGE_SEPARATION, 'KEKULE_ALL': rdkit.Chem.rdchem.ResonanceFlags.KEKULE_ALL, 'UNCONSTRAINED_CATIONS': rdkit.Chem.rdchem.ResonanceFlags.UNCONSTRAINED_CATIONS, 'ALLOW_INCOMPLETE_OCTETS': rdkit.Chem.rdchem.ResonanceFlags.ALLOW_INCOMPLETE_OCTETS, 'UNCONSTRAINED_ANIONS': rdkit.Chem.rdchem.ResonanceFlags.UNCONSTRAINED_ANIONS}
  `values` = {8: rdkit.Chem.rdchem.ResonanceFlags.UNCONSTRAINED_CATIONS, 1: rdkit.Chem.rdchem.ResonanceFlags.ALLOW_INCOMPLETE_OCTETS, 2: rdkit.Chem.rdchem.ResonanceFlags.ALLOW_CHARGE_SEPARATION, 4: rdkit.Chem.rdchem.ResonanceFlags.KEKULE_ALL, 16: rdkit.Chem.rdchem.ResonanceFlags.UNCONSTRAINED_ANIONS}

class `rdkit.Chem.rdchem.` `ResonanceMolSupplier`

  Bases: `Boost.Python.instance`

  A class which supplies resonance structures (as mols) from a mol.

  Usage examples:

  > 1. Lazy evaluation: the resonance structures are not constructed until we ask for them: >>> suppl = ResonanceMolSupplier(mol) >>> for resMol in suppl: ... resMol.GetNumAtoms()
  > 2. Lazy evaluation 2: >>> suppl = ResonanceMolSupplier(mol) >>> resMol1 = suppl.next() >>> resMol2 = suppl.next() >>> suppl.reset() >>> resMol3 = suppl.next() # resMol3 and resMol1 are the same: >>> MolToSmiles(resMol3)==MolToSmiles(resMol1)
  > 3. Random Access: >>> suppl = ResonanceMolSupplier(mol) >>> resMol1 = suppl[0] >>> resMol2 = suppl[1] NOTE: this will generate an IndexError if the supplier doesn’t have that many molecules.
  > 4. Random Access 2: looping over all resonance structures >>> suppl = ResonanceMolSupplier(mol) >>> nResMols = len(suppl) >>> for i in range(nResMols): ... suppl[i].GetNumAtoms()

  `Enumerate`((ResonanceMolSupplier)arg1) → None :

    Ask ResonanceMolSupplier to enumerate resonance structures(automatically done as soon as any attempt to access them is made)

    C++ signature :
      void Enumerate(RDKit::ResonanceMolSupplier {lvalue})
  `GetAtomConjGrpIdx`((ResonanceMolSupplier)arg1, (int)arg2) → int :

    Given an atom index, it returns the index of the conjugated groupthe atom belongs to, or -1 if it is not conjugated

    C++ signature :
      unsigned int GetAtomConjGrpIdx(RDKit::ResonanceMolSupplier {lvalue},unsigned int)
  `GetBondConjGrpIdx`((ResonanceMolSupplier)arg1, (int)arg2) → int :

    Given a bond index, it returns the index of the conjugated groupthe bond belongs to, or -1 if it is not conjugated

    C++ signature :
      unsigned int GetBondConjGrpIdx(RDKit::ResonanceMolSupplier {lvalue},unsigned int)
  `GetIsEnumerated`((ResonanceMolSupplier)arg1) → bool :

    Returns true if resonance structure enumeration has already happened

    C++ signature :
      bool GetIsEnumerated(RDKit::ResonanceMolSupplier {lvalue})
  `GetNumConjGrps`((ResonanceMolSupplier)arg1) → int :

    Returns the number of individual conjugated groups in the molecule

    C++ signature :
      unsigned int GetNumConjGrps(RDKit::ResonanceMolSupplier {lvalue})
  `GetSubstructMatch`((ResonanceMolSupplier)self, (Mol)query[, (bool)useChirality=False[, (bool)useQueryQueryMatches=False]]) → object :

    Returns the indices of the molecule’s atoms that match a substructure query, taking into account all resonance structures in ResonanceMolSupplier.

    > ARGUMENTS:
    >   - query: a Molecule
    >   - useChirality: enables the use of stereochemistry in the matching
    >   - useQueryQueryMatches: use query-query matching logic

    > RETURNS: a tuple of integers

    > NOTES:

    >   - only a single match is returned

    >   - the ordering of the indices corresponds to the atom ordering

    >       in the query. For example, the first index is for the atom in this molecule that matches the first atom in the query.

    C++ signature :
      _object* GetSubstructMatch(RDKit::ResonanceMolSupplier {lvalue},RDKit::ROMol [,bool=False [,bool=False]])
  `GetSubstructMatches`((ResonanceMolSupplier)self, (Mol)query[, (bool)uniquify=False[, (bool)useChirality=False[, (bool)useQueryQueryMatches=False[, (int)maxMatches=1000[, (int)numThreads=1]]]]]) → object :

    Returns tuples of the indices of the molecule’s atoms that match a substructure query, taking into account all resonance structures in ResonanceMolSupplier.

    > ARGUMENTS:

    >   - query: a Molecule.

    >   - uniquify: (optional) determines whether or not the matches are uniquified.

    >       Defaults to 1.

    >   - useChirality: enables the use of stereochemistry in the matching

    >   - useQueryQueryMatches: use query-query matching logic

    >   - maxMatches: The maximum number of matches that will be returned.

    >       In high-symmetry cases with medium-sized molecules, it is very easy to end up with a combinatorial explosion in the number of possible matches. This argument prevents that from having unintended consequences

    >   - numThreads: The number of threads to be used (defaults to 1; 0 selects the

    >       number of concurrent threads supported by the hardware; negative values are added to the number of concurrent threads supported by the hardware).

    > RETURNS: a tuple of tuples of integers

    > NOTE:
    >   - the ordering of the indices corresponds to the atom ordering

    >       in the query. For example, the first index is for the atom in this molecule that matches the first atom in the query.

    C++ signature :
      _object* GetSubstructMatches(RDKit::ResonanceMolSupplier {lvalue},RDKit::ROMol [,bool=False [,bool=False [,bool=False [,unsigned int=1000 [,int=1]]]]])
  `SetNumThreads`((ResonanceMolSupplier)arg1, (int)arg2) → None :

    Sets the number of threads to be used to enumerate resonance structures (defaults to 1; 0 selects the number of concurrent threads supported by the hardware; negative values are added to the number of concurrent threads supported by the hardware)

    C++ signature :
      void SetNumThreads(RDKit::ResonanceMolSupplier {lvalue},unsigned int)
  `atEnd`((ResonanceMolSupplier)arg1) → bool :

    Returns whether or not we have hit the end of the resonance structure supplier.

    C++ signature :
      bool atEnd(RDKit::ResonanceMolSupplier {lvalue})
  `reset`((ResonanceMolSupplier)arg1) → None :

    Resets our position in the resonance structure supplier to the beginning.

    C++ signature :
      void reset(RDKit::ResonanceMolSupplier {lvalue})

class `rdkit.Chem.rdchem.` `RingInfo`

  Bases: `Boost.Python.instance`

  contains information about a molecule’s rings

  `AtomRings`((RingInfo)arg1) → object :
    C++ signature :
      boost::python::api::object AtomRings(RDKit::RingInfo const*)
  `BondRings`((RingInfo)arg1) → object :
    C++ signature :
      boost::python::api::object BondRings(RDKit::RingInfo const*)
  `IsAtomInRingOfSize`((RingInfo)arg1, (int)arg2, (int)arg3) → bool :
    C++ signature :
      bool IsAtomInRingOfSize(RDKit::RingInfo {lvalue},unsigned int,unsigned int)
  `IsBondInRingOfSize`((RingInfo)arg1, (int)arg2, (int)arg3) → bool :

    > C++ signature :
    >   bool IsBondInRingOfSize(RDKit::RingInfo {lvalue},unsigned int,unsigned int)

    IsBondInRingOfSize( (RingInfo)arg1, (int)arg2, (int)arg3) -> bool :

    > C++ signature :
    >   bool IsBondInRingOfSize(RDKit::RingInfo {lvalue},unsigned int,unsigned int)

  `NumAtomRings`((RingInfo)arg1, (int)arg2) → int :
    C++ signature :
      unsigned int NumAtomRings(RDKit::RingInfo {lvalue},unsigned int)
  `NumBondRings`((RingInfo)arg1, (int)arg2) → int :
    C++ signature :
      unsigned int NumBondRings(RDKit::RingInfo {lvalue},unsigned int)
  `NumRings`((RingInfo)arg1) → int :
    C++ signature :
      unsigned int NumRings(RDKit::RingInfo {lvalue})

`rdkit.Chem.rdchem.` `SetAtomAlias`((Atom)atom, (str)rlabel) → None :

  Sets the atom’s MDL alias text. Setting to an empty string clears the alias.

  C++ signature :
    void SetAtomAlias(RDKit::Atom*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

`rdkit.Chem.rdchem.` `SetAtomRLabel`((Atom)atom, (int)rlabel) → None :

  Sets the atom’s MDL RLabel (this is an integer from 0 to 99). Setting to 0 clears the rlabel.

  C++ signature :
    void SetAtomRLabel(RDKit::Atom*,int)

`rdkit.Chem.rdchem.` `SetAtomValue`((Atom)atom, (str)rlabel) → None :

  Sets the atom’s MDL alias text. Setting to an empty string clears the alias.

  C++ signature :
    void SetAtomValue(RDKit::Atom*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

`rdkit.Chem.rdchem.` `SetDefaultPickleProperties`((int)arg1) → None :

  Set the current global mol pickler options.

  C++ signature :
    void SetDefaultPickleProperties(unsigned int)

`rdkit.Chem.rdchem.` `SetSupplementalSmilesLabel`((Atom)atom, (str)label) → None :

  Sets a supplemental label on an atom that is written to the smiles string. >>> m = Chem.MolFromSmiles(“C”) >>> Chem.SetSupplementalSmilesLabel(m.GetAtomWithIdx(0), ‘<xxx>’) >>> Chem.MolToSmiles(m) ‘C<xxx>’

  C++ signature :
    void SetSupplementalSmilesLabel(RDKit::Atom*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

`rdkit.Chem.rdchem.` `WrapLogs`() → None :

  Wrap the internal RDKit streams so they go to python’s SysStdErr

  C++ signature :
    void WrapLogs()

`rdkit.Chem.rdchem.` `tossit`() → None :
  C++ signature :
    void tossit()

Module containing RDKit functionality for manipulating molecules.

`rdkit.Chem.rdmolops.` `AddHs`((Mol)mol[, (bool)explicitOnly=False[, (bool)addCoords=False[, (object)onlyOnAtoms=None]]]) → Mol :

  Adds hydrogens to the graph of a molecule.

  > ARGUMENTS:

  > > - mol: the molecule to be modified
  > > - explicitOnly: (optional) if this toggle is set, only explicit Hs will be added to the molecule. Default value is 0 (add implicit and explicit Hs).
  > > - addCoords: (optional) if this toggle is set, The Hs will have 3D coordinates set. Default value is 0 (no 3D coords).
  > > - onlyOnHs: (optional) if this sequence is provided, only these atoms will be considered to have Hs added to them

  > RETURNS: a new molecule with added Hs

  > NOTES:

  > > - The original molecule is not modified.
  > > - Much of the code assumes that Hs are not included in the molecular topology, so be very careful with the molecule that comes back from this function.

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

`rdkit.Chem.rdmolops.` `AddRecursiveQuery`((Mol)mol, (Mol)query, (int)atomIdx[, (bool)preserveExistingQuery=True]) → None :

  Adds a recursive query to an atom

  > ARGUMENTS:

  > > - mol: the molecule to be modified
  > > - query: the molecule to be used as the recursive query (this will be copied)
  > > - atomIdx: the atom to modify
  > > - preserveExistingQuery: (optional) if this is set, existing query information on the atom will be preserved

  > RETURNS: None

  C++ signature :
    void AddRecursiveQuery(RDKit::ROMol {lvalue},RDKit::ROMol,unsigned int [,bool=True])

class `rdkit.Chem.rdmolops.` `AdjustQueryParameters`

  Bases: `Boost.Python.instance`

  Parameters controlling which components of the query atoms are adjusted.

  Attributes:
    - adjustDegree:

        modified atoms have an explicit-degree query added based on their degree in the query

    - adjustDegreeFlags:

        controls which atoms have a degree query added

    - adjustRingCount:

        modified atoms have a ring-count query added based on their ring count in the query

    - adjustRingCountFlags:

        controls which atoms have a ring-cout query added

    - makeDummiesQueries:

        dummy atoms that do not have a specified isotope are converted to any-atom queries

    - aromatizeIfPossible:

        attempts aromaticity perception on the molecule

    - makeBondsGeneric:

        convert bonds to generic (any) bonds

    - makeBondsGenericFlags:

        controls which bonds are made generic

    - makeAtomsGeneric:

        convert atoms to generic (any) atoms

    - makeAtomsGenericFlags:

        controls which atoms are made generic

  A note on the flags controlling which atoms/bonds are modified:

    These generally limit the set of atoms/bonds to be modified. For example if ADJUST_RINGSONLY is set, then only atoms in rings will be modified.

    > ADJUST_IGNORENONE causes all atoms to be modified ADJUST_SETALL sets all of the ADJUST flags

    Some of the options obviously make no sense for bonds

  `adjustDegree`
  `adjustDegreeFlags`
  `adjustRingCount`
  `adjustRingCountFlags`
  `aromatizeIfPossible`
  `makeAtomsGeneric`
  `makeAtomsGenericFlags`
  `makeBondsGeneric`
  `makeBondsGenericFlags`
  `makeDummiesQueries`

`rdkit.Chem.rdmolops.` `AdjustQueryProperties`((Mol)mol[, (object)params=None]) → Mol :

  Returns a new molecule where the query properties of atoms have been modified.

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

class `rdkit.Chem.rdmolops.` `AdjustQueryWhichFlags`

  Bases: `Boost.Python.enum`

  `ADJUST_IGNOREALL` = rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNOREALL
  `ADJUST_IGNORECHAINS` = rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNORECHAINS
  `ADJUST_IGNOREDUMMIES` = rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNOREDUMMIES
  `ADJUST_IGNORENONDUMMIES` = rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNORENONDUMMIES
  `ADJUST_IGNORENONE` = rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNORENONE
  `ADJUST_IGNORERINGS` = rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNORERINGS
  `names` = {'ADJUST_IGNOREDUMMIES': rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNOREDUMMIES, 'ADJUST_IGNOREALL': rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNOREALL, 'ADJUST_IGNORENONE': rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNORENONE, 'ADJUST_IGNORECHAINS': rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNORECHAINS, 'ADJUST_IGNORERINGS': rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNORERINGS, 'ADJUST_IGNORENONDUMMIES': rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNORENONDUMMIES}
  `values` = {0: rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNORENONE, 1: rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNORECHAINS, 2: rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNOREDUMMIES, 4: rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNORERINGS, 8: rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNORENONDUMMIES, 268435455: rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNOREALL}

class `rdkit.Chem.rdmolops.` `AromaticityModel`

  Bases: `Boost.Python.enum`

  `AROMATICITY_CUSTOM` = rdkit.Chem.rdmolops.AromaticityModel.AROMATICITY_CUSTOM
  `AROMATICITY_DEFAULT` = rdkit.Chem.rdmolops.AromaticityModel.AROMATICITY_DEFAULT
  `AROMATICITY_RDKIT` = rdkit.Chem.rdmolops.AromaticityModel.AROMATICITY_RDKIT
  `AROMATICITY_SIMPLE` = rdkit.Chem.rdmolops.AromaticityModel.AROMATICITY_SIMPLE
  `names` = {'AROMATICITY_DEFAULT': rdkit.Chem.rdmolops.AromaticityModel.AROMATICITY_DEFAULT, 'AROMATICITY_RDKIT': rdkit.Chem.rdmolops.AromaticityModel.AROMATICITY_RDKIT, 'AROMATICITY_SIMPLE': rdkit.Chem.rdmolops.AromaticityModel.AROMATICITY_SIMPLE, 'AROMATICITY_CUSTOM': rdkit.Chem.rdmolops.AromaticityModel.AROMATICITY_CUSTOM}
  `values` = {0: rdkit.Chem.rdmolops.AromaticityModel.AROMATICITY_DEFAULT, 1: rdkit.Chem.rdmolops.AromaticityModel.AROMATICITY_RDKIT, 2: rdkit.Chem.rdmolops.AromaticityModel.AROMATICITY_SIMPLE, 268435455: rdkit.Chem.rdmolops.AromaticityModel.AROMATICITY_CUSTOM}

`rdkit.Chem.rdmolops.` `AssignAtomChiralTagsFromStructure`((Mol)mol[, (int)confId=-1[, (bool)replaceExistingTags=True]]) → None :
  Sets the chiral tags on a molecule’s atoms based on

    a 3D conformation.

    ARGUMENTS:

    > - mol: the molecule to use

    > - confId: the conformer id to use, -1 for the default

    > - replaceExistingTags: if True, existing stereochemistry information will be cleared

    >     before running the calculation.

  C++ signature :
    void AssignAtomChiralTagsFromStructure(RDKit::ROMol {lvalue} [,int=-1 [,bool=True]])

`rdkit.Chem.rdmolops.` `AssignRadicals`((Mol)mol) → None :

  Assigns radical counts to atoms

  > ARGUMENTS:

  > > - mol: the molecule to use

  > NOTES:

  > > - The molecule is modified in place.

  C++ signature :
    void AssignRadicals(RDKit::ROMol {lvalue})

`rdkit.Chem.rdmolops.` `AssignStereochemistry`((Mol)mol[, (bool)cleanIt=False[, (bool)force=False[, (bool)flagPossibleStereoCenters=False]]]) → None :
  Does the CIP stereochemistry assignment

    for the molecule’s atoms (R/S) and double bond (Z/E). Chiral atoms will have a property ‘_CIPCode’ indicating their chiral code.

    ARGUMENTS:

    > - mol: the molecule to use
    > - cleanIt: (optional) if provided, atoms with a chiral specifier that aren’t actually chiral (e.g. atoms with duplicate substituents or only 2 substituents, etc.) will have their chiral code set to CHI_UNSPECIFIED
    > - force: (optional) causes the calculation to be repeated, even if it has already been done
    > - flagPossibleStereoCenters (optional) set the _ChiralityPossible property on atoms that are possible stereocenters

  C++ signature :
    void AssignStereochemistry(RDKit::ROMol {lvalue} [,bool=False [,bool=False [,bool=False]]])

`rdkit.Chem.rdmolops.` `Cleanup`((Mol)mol) → None :

  cleans up certain common bad functionalities in the molecule

  > ARGUMENTS:

  > > - mol: the molecule to use

  > NOTES:

  > > - The molecule is modified in place.

  C++ signature :
    void Cleanup(RDKit::ROMol {lvalue})

`rdkit.Chem.rdmolops.` `CombineMols`((Mol)mol1, (Mol)mol2[, (Point3D)offset=<rdkit.Geometry.rdGeometry.Point3D object at 0x7f8db3089c60>]) → Mol :

  Combine the atoms from two molecules to produce a third

  C++ signature :
    RDKit::ROMol* CombineMols(RDKit::ROMol,RDKit::ROMol [,RDGeom::Point3D=<rdkit.Geometry.rdGeometry.Point3D object at 0x7f8db3089c60>])

`rdkit.Chem.rdmolops.` `DeleteSubstructs`((Mol)mol, (Mol)query[, (bool)onlyFrags=False[, (bool)useChirality=False]]) → Mol :

  Removes atoms matching a substructure query from a molecule

  > ARGUMENTS:

  > > - mol: the molecule to be modified
  > > - query: the molecule to be used as a substructure query
  > > - onlyFrags: (optional) if this toggle is set, atoms will only be removed if the entire fragment in which they are found is matched by the query. See below for examples. Default value is 0 (remove the atoms whether or not the entire fragment matches)
  > > - useChirality: (optional) match the substructure query using chirality

  > RETURNS: a new molecule with the substructure removed

  > NOTES:

  > > - The original molecule is not modified.

  > EXAMPLES:

  > > The following examples substitute SMILES/SMARTS strings for molecules, you’d have to actually use molecules:

  > > > - DeleteSubstructs(‘CCOC’,’OC’) -> ‘CC’
  > > > - DeleteSubstructs(‘CCOC’,’OC’,1) -> ‘CCOC’
  > > > - DeleteSubstructs(‘CCOCCl.Cl’,’Cl’,1) -> ‘CCOCCl’
  > > > - DeleteSubstructs(‘CCOCCl.Cl’,’Cl’) -> ‘CCOC’

  C++ signature :
    RDKit::ROMol* DeleteSubstructs(RDKit::ROMol,RDKit::ROMol [,bool=False [,bool=False]])

`rdkit.Chem.rdmolops.` `DetectBondStereoChemistry`((Mol)mol, (Conformer)conformer) → None :

  Assign stereochemistry to bonds based on coordinates.

  > ARGUMENTS:

  > > - mol: the molecule to be modified
  > > - conformer: Conformer providing the coordinates

  C++ signature :
    void DetectBondStereoChemistry(RDKit::ROMol {lvalue},RDKit::Conformer const*)

`rdkit.Chem.rdmolops.` `FastFindRings`((Mol)arg1) → None :

  Does a non-SSSR ring finding for a molecule.

  > ARGUMENTS:

  > > - mol: the molecule to use.

  > RETURNS: Nothing

  C++ signature :
    void FastFindRings(RDKit::ROMol)

`rdkit.Chem.rdmolops.` `FindAllPathsOfLengthN`((Mol)mol, (int)length[, (bool)useBonds=True[, (bool)useHs=False[, (int)rootedAtAtom=-1]]]) → _listSt6vectorIiSaIiEE :

  Finds all paths of a particular length in a molecule

  > ARGUMENTS:

  > > - mol: the molecule to use
  > > - length: an integer with the target length for the paths.
  > > - useBonds: (optional) toggles the use of bond indices in the paths. Otherwise atom indices are used. Note this behavior is different from that for subgraphs. Defaults to 1.
  > > - rootedAtAtom: (optional) if nonzero, only paths from the specified atom will be returned.

  > RETURNS: a tuple of tuples with IDs for the bonds.

  > NOTES:

  > > - Difference between _subgraphs_ and _paths_

  > >       Subgraphs are potentially branched, whereas paths (in our
  > >       terminology at least) cannot be.  So, the following graph:

  > >            C--0--C--1--C--3--C
  > >                  |
  > >                  2
  > >                  |
  > >                  C

  > >       has 3 _subgraphs_ of length 3: (0,1,2),(0,1,3),(2,1,3)
  > >       but only 2 _paths_ of length 3: (0,1,3),(2,1,3)

  C++ signature :
    std::__cxx11::list<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > FindAllPathsOfLengthN(RDKit::ROMol,unsigned int [,bool=True [,bool=False [,int=-1]]])

`rdkit.Chem.rdmolops.` `FindAllSubgraphsOfLengthMToN`((Mol)mol, (int)min, (int)max[, (bool)useHs=False[, (int)rootedAtAtom=-1]]) → object :
  Finds all subgraphs of a particular length in a molecule
    See documentation for FindAllSubgraphsOfLengthN for definitions
  C++ signature :
    boost::python::api::object FindAllSubgraphsOfLengthMToN(RDKit::ROMol,unsigned int,unsigned int [,bool=False [,int=-1]])

`rdkit.Chem.rdmolops.` `FindAllSubgraphsOfLengthN`((Mol)mol, (int)length[, (bool)useHs=False[, (int)rootedAtAtom=-1]]) → _listSt6vectorIiSaIiEE :

  Finds all subgraphs of a particular length in a molecule

  > ARGUMENTS:

  > > - mol: the molecule to use
  > > - length: an integer with the target number of bonds for the subgraphs.
  > > - useHs: (optional) toggles whether or not bonds to Hs that are part of the graph should be included in the results. Defaults to 0.
  > > - rootedAtAtom: (optional) if nonzero, only subgraphs from the specified atom will be returned.

  > RETURNS: a tuple of 2-tuples with bond IDs

  > NOTES:

  > > - Difference between _subgraphs_ and _paths_

  > >       Subgraphs are potentially branched, whereas paths (in our
  > >       terminology at least) cannot be.  So, the following graph:

  > >            C--0--C--1--C--3--C
  > >                  |
  > >                  2
  > >                  |
  > >                  C

  > has 3 _subgraphs_ of length 3: (0,1,2),(0,1,3),(2,1,3) but only 2 _paths_ of length 3: (0,1,3),(2,1,3)

  C++ signature :
    std::__cxx11::list<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > FindAllSubgraphsOfLengthN(RDKit::ROMol,unsigned int [,bool=False [,int=-1]])

`rdkit.Chem.rdmolops.` `FindAtomEnvironmentOfRadiusN`((Mol)mol, (int)radius, (int)rootedAtAtom[, (bool)useHs=False]) → _vecti :

  Finds the bonds within a certain radius of an atom in a molecule

  > ARGUMENTS:

  > > - mol: the molecule to use
  > > - radius: an integer with the target radius for the environment.
  > > - rootedAtAtom: the atom to consider
  > > - useHs: (optional) toggles whether or not bonds to Hs that are part of the graph should be included in the results. Defaults to 0.

  > RETURNS: a vector of bond IDs

  C++ signature :
    std::vector<int, std::allocator<int> > FindAtomEnvironmentOfRadiusN(RDKit::ROMol,unsigned int,unsigned int [,bool=False])

`rdkit.Chem.rdmolops.` `FindPotentialStereoBonds`((Mol)mol[, (bool)cleanIt=False]) → None :
  Find bonds than can be cis/trans in a molecule and mark them as ‘any’.

    > This function finds any double bonds that can potentially be part of a cis/trans system. No attempt is made here to mark them cis or trans

    ARGUMENTS:

    > - mol: the molecule to use

    > - cleanIt: (optional) if this option is set to true, any previous marking of _CIPCode

    >     on the bond is cleared - otherwise it is left untouched

  C++ signature :
    void FindPotentialStereoBonds(RDKit::ROMol {lvalue} [,bool=False])

`rdkit.Chem.rdmolops.` `FindUniqueSubgraphsOfLengthN`((Mol)mol, (int)length[, (bool)useHs=False[, (bool)useBO=True[, (int)rootedAtAtom=-1]]]) → _listSt6vectorIiSaIiEE :

  Finds unique subgraphs of a particular length in a molecule

  > ARGUMENTS:

  > > - mol: the molecule to use
  > > - length: an integer with the target number of bonds for the subgraphs.
  > > - useHs: (optional) toggles whether or not bonds to Hs that are part of the graph should be included in the results. Defaults to 0.
  > > - useBO: (optional) Toggles use of bond orders in distinguishing one subgraph from another. Defaults to 1.
  > > - rootedAtAtom: (optional) if nonzero, only subgraphs from the specified atom will be returned.

  > RETURNS: a tuple of tuples with bond IDs

  C++ signature :
    std::__cxx11::list<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > FindUniqueSubgraphsOfLengthN(RDKit::ROMol,unsigned int [,bool=False [,bool=True [,int=-1]]])

`rdkit.Chem.rdmolops.` `FragmentOnBRICSBonds`((Mol)mol) → Mol :

  Return a new molecule with all BRICS bonds broken

  C++ signature :
    RDKit::ROMol* FragmentOnBRICSBonds(RDKit::ROMol)

`rdkit.Chem.rdmolops.` `FragmentOnBonds`((Mol)mol, (object)bondIndices[, (bool)addDummies=True[, (object)dummyLabels=None[, (object)bondTypes=None[, (list)cutsPerAtom=[]]]]]) → Mol :

  Return a new molecule with all specified bonds broken

  > ARGUMENTS:

  > > - mol - the molecule to be modified

  > > - bondIndices - indices of the bonds to be broken

  > > - addDummies - toggles addition of dummy atoms to indicate where

  > >     bonds were broken

  > > - dummyLabels - used to provide the labels to be used for the dummies.

  > >     the first element in each pair is the label for the dummy that replaces the bond’s beginAtom, the second is for the dummy that replaces the bond’s endAtom. If not provided, the dummies are labeled with atom indices.

  > > - bondTypes - used to provide the bond type to use between the

  > >     fragments and the dummy atoms. If not provided, defaults to single.

  > > - cutsPerAtom - used to return the number of cuts made at each atom.

  > RETURNS:
  >   a new Mol with the modifications

  C++ signature :
    RDKit::ROMol* FragmentOnBonds(RDKit::ROMol,boost::python::api::object [,bool=True [,boost::python::api::object=None [,boost::python::api::object=None [,boost::python::list=[]]]]])

`rdkit.Chem.rdmolops.` `FragmentOnSomeBonds`((Mol)mol, (object)bondIndices[, (int)numToBreak=1[, (bool)addDummies=True[, (object)dummyLabels=None[, (object)bondTypes=None[, (bool)returnCutsPerAtom=False]]]]]) → tuple :

  fragment on some bonds

  C++ signature :
    boost::python::tuple FragmentOnSomeBonds(RDKit::ROMol,boost::python::api::object [,unsigned int=1 [,bool=True [,boost::python::api::object=None [,boost::python::api::object=None [,bool=False]]]]])

`rdkit.Chem.rdmolops.` `Get3DDistanceMatrix`((Mol)mol[, (int)confId=-1[, (bool)useAtomWts=False[, (bool)force=False[, (str)prefix='']]]]) → object :

  Returns the molecule’s 3D distance matrix.

  > ARGUMENTS:

  > > - mol: the molecule to use
  > > - confId: (optional) chooses the conformer Id to use Default value is -1.
  > > - useAtomWts: (optional) toggles using atom weights for the diagonal elements of the matrix (to return a “Balaban” distance matrix). Default value is 0.
  > > - force: (optional) forces the calculation to proceed, even if there is a cached value. Default value is 0.
  > > - prefix: (optional, internal use) sets the prefix used in the property cache Default value is .

  > RETURNS: a Numeric array of floats with the distance matrix

  C++ signature :
    _object* Get3DDistanceMatrix(RDKit::ROMol {lvalue} [,int=-1 [,bool=False [,bool=False [,char const*=’‘]]]])

`rdkit.Chem.rdmolops.` `GetAdjacencyMatrix`((Mol)mol[, (bool)useBO=False[, (int)emptyVal=0[, (bool)force=False[, (str)prefix='']]]]) → object :

  Returns the molecule’s adjacency matrix.

  > ARGUMENTS:

  > > - mol: the molecule to use
  > > - useBO: (optional) toggles use of bond orders in calculating the matrix. Default value is 0.
  > > - emptyVal: (optional) sets the elements of the matrix between non-adjacent atoms Default value is 0.
  > > - force: (optional) forces the calculation to proceed, even if there is a cached value. Default value is 0.
  > > - prefix: (optional, internal use) sets the prefix used in the property cache Default value is .

  > RETURNS: a Numeric array of floats containing the adjacency matrix

  C++ signature :
    _object* GetAdjacencyMatrix(RDKit::ROMol {lvalue} [,bool=False [,int=0 [,bool=False [,char const*=’‘]]]])

`rdkit.Chem.rdmolops.` `GetDistanceMatrix`((Mol)mol[, (bool)useBO=False[, (bool)useAtomWts=False[, (bool)force=False[, (str)prefix='']]]]) → object :

  Returns the molecule’s topological distance matrix.

  > ARGUMENTS:

  > > - mol: the molecule to use
  > > - useBO: (optional) toggles use of bond orders in calculating the distance matrix. Default value is 0.
  > > - useAtomWts: (optional) toggles using atom weights for the diagonal elements of the matrix (to return a “Balaban” distance matrix). Default value is 0.
  > > - force: (optional) forces the calculation to proceed, even if there is a cached value. Default value is 0.
  > > - prefix: (optional, internal use) sets the prefix used in the property cache Default value is .

  > RETURNS: a Numeric array of floats with the distance matrix

  C++ signature :
    _object* GetDistanceMatrix(RDKit::ROMol {lvalue} [,bool=False [,bool=False [,bool=False [,char const*=’‘]]]])

`rdkit.Chem.rdmolops.` `GetFormalCharge`((Mol)arg1) → int :

  Returns the formal charge for the molecule.

  > ARGUMENTS:

  > > - mol: the molecule to use

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

`rdkit.Chem.rdmolops.` `GetMolFrags`((Mol)mol[, (bool)asMols=False[, (bool)sanitizeFrags=True]]) → tuple :

  Finds the disconnected fragments from a molecule.

  > For example, for the molecule ‘CC(=O)[O-].[NH3+]C’ GetMolFrags() returns ((0, 1, 2, 3), (4, 5))

  > ARGUMENTS:

  > > - mol: the molecule to use
  > > - asMols: (optional) if this is provided and true, the fragments will be returned as molecules instead of atom ids.
  > > - sanitizeFrags: (optional) if this is provided and true, the fragments molecules will be sanitized before returning them.

  > RETURNS: a tuple of tuples with IDs for the atoms in each fragment
  >   or a tuple of molecules.

  C++ signature :
    boost::python::tuple GetMolFrags(RDKit::ROMol [,bool=False [,bool=True]])

`rdkit.Chem.rdmolops.` `GetSSSR`((Mol)arg1) → int :

  Get the smallest set of simple rings for a molecule.

  > ARGUMENTS:

  > > - mol: the molecule to use.

  > RETURNS: a sequence of sequences containing the rings found as atom ids
  >   The length of this will be equal to NumBonds-NumAtoms+1 for single-fragment molecules.

  C++ signature :
    int GetSSSR(RDKit::ROMol {lvalue})

`rdkit.Chem.rdmolops.` `GetShortestPath`((Mol)arg1, (int)arg2, (int)arg3) → tuple :

  Find the shortest path between two atoms using the Bellman-Ford algorithm.

  > ARGUMENTS:

  > > - mol: the molecule to use
  > > - idx1: index of the first atom
  > > - idx2: index of the second atom

  C++ signature :
    boost::python::tuple GetShortestPath(RDKit::ROMol,int,int)

`rdkit.Chem.rdmolops.` `GetSymmSSSR`((Mol)arg1) → _vectSt6vectorIiSaIiEE :

  Get a symmetrized SSSR for a molecule.

  > The symmetrized SSSR is at least as large as the SSSR for a molecule. In certain highly-symmetric cases (e.g. cubane), the symmetrized SSSR can be a bit larger (i.e. the number of symmetrized rings is >= NumBonds-NumAtoms+1).

  > ARGUMENTS:

  > > - mol: the molecule to use.

  > RETURNS: a sequence of sequences containing the rings found as atom ids

  C++ signature :
    std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > GetSymmSSSR(RDKit::ROMol {lvalue})

`rdkit.Chem.rdmolops.` `Kekulize`((Mol)mol[, (bool)clearAromaticFlags=False]) → None :

  Kekulizes the molecule

  > ARGUMENTS:

  > > - mol: the molecule to use
  > > - clearAromaticFlags: (optional) if this toggle is set, all atoms and bonds in the molecule will be marked non-aromatic following the kekulization. Default value is 0.

  > NOTES:

  > > - The molecule is modified in place.

  C++ signature :
    void Kekulize(RDKit::ROMol {lvalue} [,bool=False])

`rdkit.Chem.rdmolops.` `LayeredFingerprint`((Mol)mol[, (int)layerFlags=4294967295[, (int)minPath=1[, (int)maxPath=7[, (int)fpSize=2048[, (list)atomCounts=[][, (ExplicitBitVect)setOnlyBits=None[, (bool)branchedPaths=True[, (object)fromAtoms=0]]]]]]]]) → ExplicitBitVect :

  Returns a layered fingerprint for a molecule

  > NOTE: This function is experimental. The API or results may change from
  >   release to release.

  > Explanation of the algorithm below.

  > ARGUMENTS:

  > > - mol: the molecule to use

  > > - layerFlags: (optional) which layers to include in the fingerprint See below for definitions. Defaults to all.

  > > - minPath: (optional) minimum number of bonds to include in the subgraphs Defaults to 1.

  > > - maxPath: (optional) maximum number of bonds to include in the subgraphs Defaults to 7.

  > > - fpSize: (optional) number of bits in the fingerprint Defaults to 2048.

  > > - atomCounts: (optional)

  > >     if provided, this should be a list at least as long as the number of atoms in the molecule. It will be used to provide the count of the number of paths that set bits each atom is involved in. NOTE: the list is not zeroed out here.

  > > - setOnlyBits: (optional)

  > >     if provided, only bits that are set in this bit vector will be set in the result. This is essentially the same as doing:

  > >     > res &= setOnlyBits

  > >     but also has an impact on the atomCounts (if being used)

  > > - branchedPaths: (optional) if set both branched and unbranched paths will be used in the fingerprint. Defaults to True.

  > > - fromAtoms: (optional) a sequence of atom indices. If provided, only paths/subgraphs starting from these atoms will be used. Defaults to empty.

  > RETURNS: a DataStructs.ExplicitBitVect with _fpSize_ bits

  > Layer definitions:
  >   - 0x01: pure topology
  >   - 0x02: bond order
  >   - 0x04: atom types
  >   - 0x08: presence of rings
  >   - 0x10: ring sizes
  >   - 0x20: aromaticity

  C++ signature :
    ExplicitBitVect* LayeredFingerprint(RDKit::ROMol [,unsigned int=4294967295 [,unsigned int=1 [,unsigned int=7 [,unsigned int=2048 [,boost::python::list=[] [,ExplicitBitVect*=None [,bool=True [,boost::python::api::object=0]]]]]]]])

`rdkit.Chem.rdmolops.` `MergeQueryHs`((Mol)mol[, (bool)mergeUnmappedOnly=False]) → Mol :

  merges hydrogens into their neighboring atoms as queries

  C++ signature :
    RDKit::ROMol* MergeQueryHs(RDKit::ROMol [,bool=False])

`rdkit.Chem.rdmolops.` `MolAddRecursiveQueries`((Mol)mol, (dict)queries, (str)propName) → None :

  Adds named recursive queries to atoms

  C++ signature :
    void MolAddRecursiveQueries(RDKit::ROMol {lvalue},boost::python::dict,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

`rdkit.Chem.rdmolops.` `MolToSVG`((Mol)arg1, (int)mol[, (int)width=300[, (object)height=300[, (bool)highlightAtoms=None[, (int)kekulize=True[, (int)lineWidthMult=1[, (bool)fontSize=12[, (int)includeAtomCircles=True]]]]]]]) → str :

  Returns svg for a molecule

  C++ signature :
    std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > MolToSVG(RDKit::ROMol,unsigned int [,unsigned int=300 [,boost::python::api::object=300 [,bool=None [,unsigned int=True [,unsigned int=1 [,bool=12 [,int=True]]]]]]])

`rdkit.Chem.rdmolops.` `MurckoDecompose`((Mol)mol) → Mol :

  Do a Murcko decomposition and return the scaffold

  C++ signature :
    RDKit::ROMol* MurckoDecompose(RDKit::ROMol)

`rdkit.Chem.rdmolops.` `ParseMolQueryDefFile`((object)fileobj[, (bool)standardize=True[, (str)delimiter='t'[, (str)comment='//'[, (int)nameColumn=0[, (int)smartsColumn=1]]]]]) → dict :

  reads query definitions from a simply formatted file

  C++ signature :
    boost::python::dict ParseMolQueryDefFile(boost::python::api::object {lvalue} [,bool=True [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >=’t’ [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >=’//’ [,unsigned int=0 [,unsigned int=1]]]]])

`rdkit.Chem.rdmolops.` `PathToSubmol`((Mol)mol, (object)path[, (bool)useQuery=False[, (object)atomMap=None]]) → Mol :
  C++ signature :
    RDKit::ROMol* PathToSubmol(RDKit::ROMol,boost::python::api::object {lvalue} [,bool=False [,boost::python::api::object=None]])

`rdkit.Chem.rdmolops.` `PatternFingerprint`((Mol)mol[, (int)fpSize=2048[, (list)atomCounts=[][, (ExplicitBitVect)setOnlyBits=None]]]) → ExplicitBitVect :

  A fingerprint using SMARTS patterns

  > NOTE: This function is experimental. The API or results may change from
  >   release to release.

  C++ signature :
    ExplicitBitVect* PatternFingerprint(RDKit::ROMol [,unsigned int=2048 [,boost::python::list=[] [,ExplicitBitVect*=None]]])

`rdkit.Chem.rdmolops.` `RDKFingerprint`((Mol)mol[, (int)minPath=1[, (int)maxPath=7[, (int)fpSize=2048[, (int)nBitsPerHash=2[, (bool)useHs=True[, (float)tgtDensity=0.0[, (int)minSize=128[, (bool)branchedPaths=True[, (bool)useBondOrder=True[, (object)atomInvariants=0[, (object)fromAtoms=0[, (object)atomBits=None[, (object)bitInfo=None]]]]]]]]]]]]]) → ExplicitBitVect :

  Returns an RDKit topological fingerprint for a molecule

  > Explanation of the algorithm below.

  > ARGUMENTS:

  > > > - mol: the molecule to use
  > > > - minPath: (optional) minimum number of bonds to include in the subgraphs Defaults to 1.
  > > > - maxPath: (optional) maximum number of bonds to include in the subgraphs Defaults to 7.
  > > > - fpSize: (optional) number of bits in the fingerprint Defaults to 2048.
  > > > - nBitsPerHash: (optional) number of bits to set per path Defaults to 2.
  > > > - useHs: (optional) include paths involving Hs in the fingerprint if the molecule has explicit Hs. Defaults to True.
  > > > - tgtDensity: (optional) fold the fingerprint until this minimum density has been reached Defaults to 0.
  > > > - minSize: (optional) the minimum size the fingerprint will be folded to when trying to reach tgtDensity Defaults to 128.
  > > > - branchedPaths: (optional) if set both branched and unbranched paths will be used in the fingerprint. Defaults to True.
  > > > - useBondOrder: (optional) if set both bond orders will be used in the path hashes Defaults to True.
  > > > - atomInvariants: (optional) a sequence of atom invariants to use in the path hashes Defaults to empty.
  > > > - fromAtoms: (optional) a sequence of atom indices. If provided, only paths/subgraphs starting from these atoms will be used. Defaults to empty.
  > > > - atomBits: (optional) an empty list. If provided, the result will contain a list containing the bits each atom sets. Defaults to empty.

  > > - bitInfo: (optional) an empty dict. If provided, the result will contain a dict with bits as keys and corresponding bond paths as values. Defaults to empty.

  > RETURNS: a DataStructs.ExplicitBitVect with _fpSize_ bits

  > ALGORITHM:

  > > This algorithm functions by find all subgraphs between minPath and maxPath in length. For each subgraph:

  > > > 1. A hash is calculated.
  > > > 2. The hash is used to seed a random-number generator
  > > > 3. _nBitsPerHash_ random numbers are generated and used to set the corresponding bits in the fingerprint

  C++ signature :
    ExplicitBitVect* RDKFingerprint(RDKit::ROMol [,unsigned int=1 [,unsigned int=7 [,unsigned int=2048 [,unsigned int=2 [,bool=True [,double=0.0 [,unsigned int=128 [,bool=True [,bool=True [,boost::python::api::object=0 [,boost::python::api::object=0 [,boost::python::api::object=None [,boost::python::api::object=None]]]]]]]]]]]]])

`rdkit.Chem.rdmolops.` `RemoveHs`((Mol)mol[, (bool)implicitOnly=False[, (bool)updateExplicitCount=False[, (bool)sanitize=True]]]) → Mol :

  Removes any hydrogens from the graph of a molecule.

  > ARGUMENTS:

  > > - mol: the molecule to be modified
  > > - implicitOnly: (optional) if this toggle is set, only implicit Hs will be removed from the graph. Default value is 0 (remove implicit and explicit Hs).
  > > - updateExplicitCount: (optional) if this toggle is set, the explicit H count on atoms with Hs will be updated. Default value is 0 (do not update explicit H count).
  > > - sanitize: (optional) if this toggle is set, the molecule will be sanitized after the Hs are removed. Default value is 1 (do sanitize).

  > RETURNS: a new molecule with the Hs removed

  > NOTES:

  > > - The original molecule is not modified.

  C++ signature :
    RDKit::ROMol* RemoveHs(RDKit::ROMol [,bool=False [,bool=False [,bool=True]]])

`rdkit.Chem.rdmolops.` `RemoveStereochemistry`((Mol)mol) → None :

  Removes all stereochemistry info from the molecule.

  C++ signature :
    void RemoveStereochemistry(RDKit::ROMol {lvalue})

`rdkit.Chem.rdmolops.` `RenumberAtoms`((Mol)mol, (object)newOrder) → Mol :

  Returns a copy of a molecule with renumbered atoms

  > ARGUMENTS:

  > > - mol: the molecule to be modified

  > > - newOrder: the new ordering the atoms (should be numAtoms long)

  > >     for example: if newOrder is [3,2,0,1], then atom 3 in the original molecule will be atom 0 in the new one

  C++ signature :
    RDKit::ROMol* RenumberAtoms(RDKit::ROMol,boost::python::api::object {lvalue})

`rdkit.Chem.rdmolops.` `ReplaceCore`((Mol)mol, (Mol)core, (object)matches[, (bool)replaceDummies=True[, (bool)labelByIndex=False[, (bool)requireDummyMatch=False]]]) → Mol :
  Removes the core of a molecule and labels the sidechains with dummy atoms based on

    The matches indices given in the matching vector matches. Calling:

    > ReplaceCore(mol,core,mol.GetSubstructMatch(core))

    > ARGUMENTS:

    > > - mol: the molecule to be modified

    > > - coreQuery: the molecule to be used as a substructure query for recognizing the core

    > > - matches: a matching vector of the type returned by mol.GetSubstructMatch(...)

    > > - replaceDummies: toggles replacement of atoms that match dummies in the query

    > > - labelByIndex: toggles labeling the attachment point dummy atoms with

    > >     the index of the core atom they’re attached to.

    > > - requireDummyMatch: if the molecule has side chains that attach at points not

    > >     flagged with a dummy, it will be rejected (None is returned)

    > RETURNS: a new molecule with the core removed

    > NOTES:

    > > - The original molecule is not modified.

    EXAMPLES:

          >>> from rdkit.Chem import MolToSmiles, MolFromSmiles, ReplaceCore
          >>> mol = MolFromSmiles('C1ONNCC1')
          >>> core = MolFromSmiles('NN')

      Note: Using isomericSmiles is necessary to see the labels. >>> MolToSmiles(ReplaceCore(mol, core, mol.GetSubstructMatch(core)), isomericSmiles=True) ‘[1*]OCCC[2*]’

      Since NN is symmetric, we should actually get two matches here if we don’t uniquify the matches. >>> [MolToSmiles(ReplaceCore(mol, core, match), isomericSmiles=True) ... for match in mol.GetSubstructMatches(core, uniquify=False)] [‘[1*]OCCC[2*]’, ‘[1*]CCCO[2*]’]

    C++ signature :
      RDKit::ROMol* ReplaceCore(RDKit::ROMol,RDKit::ROMol,boost::python::api::object [,bool=True [,bool=False [,bool=False]]])
  ReplaceCore( (Mol)mol, (Mol)coreQuery [, (bool)replaceDummies=True [, (bool)labelByIndex=False [, (bool)requireDummyMatch=False [, (bool)useChirality=False]]]]) -> Mol :

    Removes the core of a molecule and labels the sidechains with dummy atoms.

    > ARGUMENTS:

    > > - mol: the molecule to be modified

    > > - coreQuery: the molecule to be used as a substructure query for recognizing the core

    > > - replaceDummies: toggles replacement of atoms that match dummies in the query

    > > - labelByIndex: toggles labeling the attachment point dummy atoms with

    > >     the index of the core atom they’re attached to.

    > > - requireDummyMatch: if the molecule has side chains that attach at points not

    > >     flagged with a dummy, it will be rejected (None is returned)

    > > - useChirality: use chirality matching in the coreQuery

    > RETURNS: a new molecule with the core removed

    > NOTES:

    > > - The original molecule is not modified.

    > EXAMPLES:

    > >     >>> from rdkit.Chem import MolToSmiles, MolFromSmiles, MolFromSmarts, ReplaceCore

    > > Basic usage: remove a core as specified by SMILES (or another molecule). To get the atom labels which are stored as an isotope of the matched atom, the output must be written as isomeric smiles. A small confusion is that atom isotopes of 0 aren’t shown in smiles strings.

    > > Here we remove a ring and leave the decoration (r-group) behind.

    > >     >>> MolToSmiles(ReplaceCore(MolFromSmiles('CCCC1CCC1'),MolFromSmiles('C1CCC1')),
    > >     ...             isomericSmiles=True)
    > >     '[1*]CCC'

    > > The isotope label by default is matched by the first connection found. In order to indicate which atom the decoration is attached in the core query, use labelByIndex=True. Here the attachment is from the third atom in the smiles string, which is indexed by 3 in the core, like all good computer scientists expect, atoms indices start at 0. >>> MolToSmiles(ReplaceCore(MolFromSmiles(‘CCN1CCC1’),MolFromSmiles(‘C1CCN1’), ... labelByIndex=True), ... isomericSmiles=True) ‘[3*]CC’

    > > Non-core matches just return None >>> ReplaceCore(MolFromSmiles(‘CCC1CC1’),MolFromSmiles(‘C1CCC1’))

    > > The bond between atoms are considered part of the core and are removed as well >>> MolToSmiles(ReplaceCore(MolFromSmiles(‘C1CC2C1CCC2’),MolFromSmiles(‘C1CCC1’)), ... isomericSmiles=True) ‘[1*]CCC[2*]’ >>> MolToSmiles(ReplaceCore(MolFromSmiles(‘C1CNCC1’),MolFromSmiles(‘N’)), ... isomericSmiles=True) ‘[1*]CCCC[2*]’

    > > When using dummy atoms, cores should be read in as SMARTS. When read as SMILES dummy atoms only match other dummy atoms. The replaceDummies flag indicates whether matches to the dummy atoms should be considered as part of the core or as part of the decoration (r-group) >>> MolToSmiles(ReplaceCore(MolFromSmiles(‘C1CNCC1’),MolFromSmarts(‘[*]N[*]’), ... replaceDummies=True), ... isomericSmiles=True) ‘[1*]CC[2*]’ >>> MolToSmiles(ReplaceCore(MolFromSmiles(‘C1CNCC1’),MolFromSmarts(‘[*]N[*]’), ... replaceDummies=False), ... isomericSmiles=True) ‘[1*]CCCC[2*]’

    > >     >>> MolToSmiles(ReplaceCore(MolFromSmiles('C1CCC1CN'),MolFromSmarts('C1CCC1[*]'),
    > >     ...                         replaceDummies=False),
    > >     ...             isomericSmiles=True)
    > >     '[1*]CN'

    C++ signature :
      RDKit::ROMol* ReplaceCore(RDKit::ROMol,RDKit::ROMol [,bool=True [,bool=False [,bool=False [,bool=False]]]])

`rdkit.Chem.rdmolops.` `ReplaceSidechains`((Mol)mol, (Mol)coreQuery[, (bool)useChirality=False]) → Mol :

  Replaces sidechains in a molecule with dummy atoms for their attachment points.

  > ARGUMENTS:

  > > - mol: the molecule to be modified
  > > - coreQuery: the molecule to be used as a substructure query for recognizing the core
  > > - useChirality: (optional) match the substructure query using chirality

  > RETURNS: a new molecule with the sidechains removed

  > NOTES:

  > > - The original molecule is not modified.

  > EXAMPLES:

  > > The following examples substitute SMILES/SMARTS strings for molecules, you’d have to actually use molecules:

  > > > - ReplaceSidechains(‘CCC1CCC1’,’C1CCC1’) -> ‘[Xa]C1CCC1’
  > > > - ReplaceSidechains(‘CCC1CC1’,’C1CCC1’) -> ‘’
  > > > - ReplaceSidechains(‘C1CC2C1CCC2’,’C1CCC1’) -> ‘[Xa]C1CCC1[Xb]’

  C++ signature :
    RDKit::ROMol* ReplaceSidechains(RDKit::ROMol,RDKit::ROMol [,bool=False])

`rdkit.Chem.rdmolops.` `ReplaceSubstructs`((Mol)mol, (Mol)query, (Mol)replacement[, (bool)replaceAll=False[, (int)replacementConnectionPoint=0[, (bool)useChirality=False]]]) → object :

  Replaces atoms matching a substructure query in a molecule

  > ARGUMENTS:

  > > - mol: the molecule to be modified
  > > - query: the molecule to be used as a substructure query
  > > - replacement: the molecule to be used as the replacement
  > > - replaceAll: (optional) if this toggle is set, all substructures matching the query will be replaced in a single result, otherwise each result will contain a separate replacement. Default value is False (return multiple replacements)
  > > - replacementConnectionPoint: (optional) index of the atom in the replacement that the bond should be made to.
  > > - useChirality: (optional) match the substructure query using chirality

  > RETURNS: a tuple of new molecules with the substructures replaced removed

  > NOTES:

  > > - The original molecule is not modified.

  > EXAMPLES:

  > > The following examples substitute SMILES/SMARTS strings for molecules, you’d have to actually use molecules:

  > > > - ReplaceSubstructs(‘CCOC’,’OC’,’NC’) -> (‘CCNC’,)
  > > > - ReplaceSubstructs(‘COCCOC’,’OC’,’NC’) -> (‘COCCNC’,’CNCCOC’)
  > > > - ReplaceSubstructs(‘COCCOC’,’OC’,’NC’,True) -> (‘CNCCNC’,)
  > > > - ReplaceSubstructs(‘COCCOC’,’OC’,’CN’,True,1) -> (‘CNCCNC’,)

  C++ signature :
    _object* ReplaceSubstructs(RDKit::ROMol,RDKit::ROMol,RDKit::ROMol [,bool=False [,unsigned int=0 [,bool=False]]])

class `rdkit.Chem.rdmolops.` `SanitizeFlags`

  Bases: `Boost.Python.enum`

  `SANITIZE_ADJUSTHS` = rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_ADJUSTHS
  `SANITIZE_ALL` = rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_ALL
  `SANITIZE_CLEANUP` = rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_CLEANUP
  `SANITIZE_CLEANUPCHIRALITY` = rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_CLEANUPCHIRALITY
  `SANITIZE_FINDRADICALS` = rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_FINDRADICALS
  `SANITIZE_KEKULIZE` = rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_KEKULIZE
  `SANITIZE_NONE` = rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_NONE
  `SANITIZE_PROPERTIES` = rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_PROPERTIES
  `SANITIZE_SETAROMATICITY` = rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_SETAROMATICITY
  `SANITIZE_SETCONJUGATION` = rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_SETCONJUGATION
  `SANITIZE_SETHYBRIDIZATION` = rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_SETHYBRIDIZATION
  `SANITIZE_SYMMRINGS` = rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_SYMMRINGS
  `names` = {'SANITIZE_SETCONJUGATION': rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_SETCONJUGATION, 'SANITIZE_CLEANUP': rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_CLEANUP, 'SANITIZE_SETHYBRIDIZATION': rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_SETHYBRIDIZATION, 'SANITIZE_FINDRADICALS': rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_FINDRADICALS, 'SANITIZE_ALL': rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_ALL, 'SANITIZE_KEKULIZE': rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_KEKULIZE, 'SANITIZE_PROPERTIES': rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_PROPERTIES, 'SANITIZE_ADJUSTHS': rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_ADJUSTHS, 'SANITIZE_CLEANUPCHIRALITY': rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_CLEANUPCHIRALITY, 'SANITIZE_NONE': rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_NONE, 'SANITIZE_SETAROMATICITY': rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_SETAROMATICITY, 'SANITIZE_SYMMRINGS': rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_SYMMRINGS}
  `values` = {0: rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_NONE, 1: rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_CLEANUP, 2: rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_PROPERTIES, 4: rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_SYMMRINGS, 32: rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_SETAROMATICITY, 8: rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_KEKULIZE, 64: rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_SETCONJUGATION, 128: rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_SETHYBRIDIZATION, 256: rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_CLEANUPCHIRALITY, 16: rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_FINDRADICALS, 512: rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_ADJUSTHS, 268435455: rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_ALL}

`rdkit.Chem.rdmolops.` `SanitizeMol`((Mol)mol[, (int)sanitizeOps=rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_ALL[, (bool)catchErrors=False]]) → SanitizeFlags :

  Kekulize, check valencies, set aromaticity, conjugation and hybridization

  > > - The molecule is modified in place.
  > > - If sanitization fails, an exception will be thrown unless catchErrors is set

  > ARGUMENTS:

  > > - mol: the molecule to be modified

  > > - sanitizeOps: (optional) sanitization operations to be carried out

  > >     these should be constructed by or’ing together the operations in rdkit.Chem.SanitizeFlags

  > > - catchErrors: (optional) if provided, instead of raising an exception

  > >     when sanitization fails (the default behavior), the first operation that failed (as defined in rdkit.Chem.SanitizeFlags) is returned. Zero is returned on success.

  C++ signature :
    RDKit::MolOps::SanitizeFlags SanitizeMol(RDKit::ROMol {lvalue} [,unsigned long=rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_ALL [,bool=False]])

`rdkit.Chem.rdmolops.` `SetAromaticity`((Mol)mol[, (AromaticityModel)model=rdkit.Chem.rdmolops.AromaticityModel.AROMATICITY_DEFAULT]) → None :

  does aromaticity perception

  > ARGUMENTS:

  > > - mol: the molecule to use
  > > - model: the model to use

  > NOTES:

  > > - The molecule is modified in place.

  C++ signature :
    void SetAromaticity(RDKit::ROMol {lvalue} [,RDKit::MolOps::AromaticityModel=rdkit.Chem.rdmolops.AromaticityModel.AROMATICITY_DEFAULT])

`rdkit.Chem.rdmolops.` `SetConjugation`((Mol)mol) → None :

  finds conjugated bonds

  > ARGUMENTS:

  > > - mol: the molecule to use

  > NOTES:

  > > - The molecule is modified in place.

  C++ signature :
    void SetConjugation(RDKit::ROMol {lvalue})

`rdkit.Chem.rdmolops.` `SetHybridization`((Mol)mol) → None :

  Assigns hybridization states to atoms

  > ARGUMENTS:

  > > - mol: the molecule to use

  > NOTES:

  > > - The molecule is modified in place.

  C++ signature :
    void SetHybridization(RDKit::ROMol {lvalue})

`rdkit.Chem.rdmolops.` `SplitMolByPDBChainId`((Mol)mol[, (object)whiteList=None[, (bool)negateList=False]]) → dict :

  Splits a molecule into pieces based on PDB chain information.

  > ARGUMENTS:

  > > - mol: the molecule to use
  > > - whiteList: only residues in this list will be returned
  > > - negateList: if set, negates the white list inclusion logic

  > RETURNS: a dictionary keyed by chain id with molecules as the values

  C++ signature :
    boost::python::dict SplitMolByPDBChainId(RDKit::ROMol [,boost::python::api::object=None [,bool=False]])

`rdkit.Chem.rdmolops.` `SplitMolByPDBResidues`((Mol)mol[, (object)whiteList=None[, (bool)negateList=False]]) → dict :

  Splits a molecule into pieces based on PDB residue information.

  > ARGUMENTS:

  > > - mol: the molecule to use
  > > - whiteList: only residues in this list will be returned
  > > - negateList: if set, negates the white list inclusion logic

  > RETURNS: a dictionary keyed by residue name with molecules as the values

  C++ signature :
    boost::python::dict SplitMolByPDBResidues(RDKit::ROMol [,boost::python::api::object=None [,bool=False]])

`rdkit.Chem.rdmolops.` `UnfoldedRDKFingerprintCountBased`((Mol)mol[, (int)minPath=1[, (int)maxPath=7[, (bool)useHs=True[, (bool)branchedPaths=True[, (bool)useBondOrder=True[, (object)atomInvariants=0[, (object)fromAtoms=0[, (object)atomBits=None[, (object)bitInfo=None]]]]]]]]]) → ULongSparseIntVect :

  Returns an unfolded count-based version of the RDKit fingerprint for a molecule

  ARGUMENTS:

  > > - mol: the molecule to use
  > > - minPath: (optional) minimum number of bonds to include in the subgraphs Defaults to 1.
  > > - maxPath: (optional) maximum number of bonds to include in the subgraphs Defaults to 7.
  > > - useHs: (optional) include paths involving Hs in the fingerprint if the molecule has explicit Hs. Defaults to True.
  > > - branchedPaths: (optional) if set both branched and unbranched paths will be used in the fingerprint. Defaults to True.
  > > - useBondOrder: (optional) if set both bond orders will be used in the path hashes Defaults to True.
  > > - atomInvariants: (optional) a sequence of atom invariants to use in the path hashes Defaults to empty.
  > > - fromAtoms: (optional) a sequence of atom indices. If provided, only paths/subgraphs starting from these atoms will be used. Defaults to empty.
  > > - atomBits: (optional) an empty list. If provided, the result will contain a list containing the bits each atom sets. Defaults to empty.

  > - bitInfo: (optional) an empty dict. If provided, the result will contain a dict with bits as keys and corresponding bond paths as values. Defaults to empty.

  C++ signature :
    RDKit::SparseIntVect<unsigned long>* UnfoldedRDKFingerprintCountBased(RDKit::ROMol [,unsigned int=1 [,unsigned int=7 [,bool=True [,bool=True [,bool=True [,boost::python::api::object=0 [,boost::python::api::object=0 [,boost::python::api::object=None [,boost::python::api::object=None]]]]]]]]])

`rdkit.Chem.rdmolops.` `WedgeMolBonds`((Mol)arg1, (Conformer)arg2) → None :
  Set the wedging on single bonds in a molecule.

    > The wedging scheme used is that from Mol files.

    ARGUMENTS:

    > - molecule: the molecule to update

  C++ signature :
    void WedgeMolBonds(RDKit::ROMol {lvalue},RDKit::Conformer const*)