Package rdkit :: Package Chem :: Module rdmolops
[hide private]
[frames] | no frames]

Module rdmolops

Module containing RDKit functionality for manipulating molecules.

Classes [hide private]
  AdjustQueryParameters
Parameters controlling which components of the query atoms are adjusted.
  AdjustQueryWhichFlags
  AromaticityModel
  SanitizeFlags
Functions [hide private]
 
AddHs(...)
AddHs( (Mol)mol [, (bool)explicitOnly=False [, (bool)addCoords=False [, (AtomPairsParameters)onlyOnAtoms=None]]]) -> Mol : Adds hydrogens to the graph of a molecule.
 
AddRecursiveQuery(...)
AddRecursiveQuery( (Mol)mol, (Mol)query, (int)atomIdx [, (bool)preserveExistingQuery=True]) -> None : Adds a recursive query to an atom
 
AdjustQueryProperties(...)
AdjustQueryProperties( (Mol)mol [, (AtomPairsParameters)params=None]) -> Mol : Returns a new molecule where the query properties of atoms have been modified.
 
AssignAtomChiralTagsFromStructure(...)
AssignAtomChiralTagsFromStructure( (Mol)mol [, (int)confId=-1 [, (bool)replaceExistingTags=True]]) -> None : Sets the chiral tags on a molecule's atoms based on a 3D conformation.
 
AssignRadicals(...)
AssignRadicals( (Mol)mol) -> None : Assigns radical counts to atoms
 
AssignStereochemistry(...)
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).
 
Cleanup(...)
Cleanup( (Mol)mol) -> None : cleans up certain common bad functionalities in the molecule
 
CombineMols(...)
CombineMols( (Mol)mol1, (Mol)mol2 [, (Point3D)offset=<rdkit.Geometry.rdGeometry.Point3D object at 0x7f7942a10c00>]) -> Mol : Combine the atoms from two molecules to produce a third
 
DeleteSubstructs(...)
DeleteSubstructs( (Mol)mol, (Mol)query [, (bool)onlyFrags=False [, (bool)useChirality=False]]) -> Mol : Removes atoms matching a substructure query from a molecule
 
DetectBondStereoChemistry(...)
DetectBondStereoChemistry( (Mol)mol, (Conformer)conformer) -> None : Assign stereochemistry to bonds based on coordinates.
 
FastFindRings(...)
FastFindRings( (Mol)arg1) -> None : Does a non-SSSR ring finding for a molecule.
 
FindAllPathsOfLengthN(...)
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
 
FindAllSubgraphsOfLengthMToN(...)
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
 
FindAllSubgraphsOfLengthN(...)
FindAllSubgraphsOfLengthN( (Mol)mol, (int)length [, (bool)useHs=False [, (int)rootedAtAtom=-1]]) -> _listSt6vectorIiSaIiEE : Finds all subgraphs of a particular length in a molecule
 
FindAtomEnvironmentOfRadiusN(...)
FindAtomEnvironmentOfRadiusN( (Mol)mol, (int)radius, (int)rootedAtAtom [, (bool)useHs=False]) -> _vecti : Finds the bonds within a certain radius of an atom in a molecule
 
FindUniqueSubgraphsOfLengthN(...)
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
 
FragmentOnBRICSBonds(...)
FragmentOnBRICSBonds( (Mol)mol) -> Mol : Return a new molecule with all BRICS bonds broken
 
FragmentOnBonds(...)
FragmentOnBonds( (Mol)mol, (AtomPairsParameters)bondIndices [, (bool)addDummies=True [, (AtomPairsParameters)dummyLabels=None [, (AtomPairsParameters)bondTypes=None [, (list)cutsPerAtom=[]]]]]) -> Mol : Return a new molecule with all specified bonds broken
 
FragmentOnSomeBonds(...)
FragmentOnSomeBonds( (Mol)mol, (AtomPairsParameters)bondIndices [, (int)numToBreak=1 [, (bool)addDummies=True [, (AtomPairsParameters)dummyLabels=None [, (AtomPairsParameters)bondTypes=None [, (bool)returnCutsPerAtom=False]]]]]) -> tuple : fragment on some bonds
 
Get3DDistanceMatrix(...)
Get3DDistanceMatrix( (Mol)mol [, (int)confId=-1 [, (bool)useAtomWts=False [, (bool)force=False [, (str)prefix='']]]]) -> object : Returns the molecule's 3D distance matrix.
 
GetAdjacencyMatrix(...)
GetAdjacencyMatrix( (Mol)mol [, (bool)useBO=False [, (int)emptyVal=0 [, (bool)force=False [, (str)prefix='']]]]) -> object : Returns the molecule's adjacency matrix.
 
GetDistanceMatrix(...)
GetDistanceMatrix( (Mol)mol [, (bool)useBO=False [, (bool)useAtomWts=False [, (bool)force=False [, (str)prefix='']]]]) -> object : Returns the molecule's topological distance matrix.
 
GetFormalCharge(...)
GetFormalCharge( (Mol)arg1) -> int : Returns the formal charge for the molecule.
 
GetMolFrags(...)
GetMolFrags( (Mol)mol [, (bool)asMols=False [, (bool)sanitizeFrags=True]]) -> tuple : Finds the disconnected fragments from a molecule.
 
GetSSSR(...)
GetSSSR( (Mol)arg1) -> int : Get the smallest set of simple rings for a molecule.
 
GetShortestPath(...)
GetShortestPath( (Mol)arg1, (int)arg2, (int)arg3) -> tuple : Find the shortest path between two atoms using the Bellman-Ford algorithm.
 
GetSymmSSSR(...)
GetSymmSSSR( (Mol)arg1) -> _vectSt6vectorIiSaIiEE : Get a symmetrized SSSR for a molecule.
 
Kekulize(...)
Kekulize( (Mol)mol [, (bool)clearAromaticFlags=False]) -> None : Kekulizes the molecule
 
LayeredFingerprint(...)
LayeredFingerprint( (Mol)mol [, (int)layerFlags=4294967295 [, (int)minPath=1 [, (int)maxPath=7 [, (int)fpSize=2048 [, (list)atomCounts=[] [, (ExplicitBitVect)setOnlyBits=None [, (bool)branchedPaths=True [, (AtomPairsParameters)fromAtoms=0]]]]]]]]) -> ExplicitBitVect : Returns a layered fingerprint for a molecule
 
MergeQueryHs(...)
MergeQueryHs( (Mol)mol [, (bool)mergeUnmappedOnly=False]) -> Mol : merges hydrogens into their neighboring atoms as queries
 
MolAddRecursiveQueries(...)
MolAddRecursiveQueries( (Mol)mol, (dict)queries, (str)propName) -> None : Adds named recursive queries to atoms
 
MolToSVG(...)
MolToSVG( (Mol)arg1, (int)mol [, (int)width=300 [, (AtomPairsParameters)height=300 [, (bool)highlightAtoms=None [, (int)kekulize=True [, (int)lineWidthMult=1 [, (bool)fontSize=12 [, (int)includeAtomCircles=True]]]]]]]) -> str : Returns svg for a molecule
 
MurckoDecompose(...)
MurckoDecompose( (Mol)mol) -> Mol : Do a Murcko decomposition and return the scaffold
 
ParseMolQueryDefFile(...)
ParseMolQueryDefFile( (AtomPairsParameters)fileobj [, (bool)standardize=True [, (str)delimiter='\t' [, (str)comment='//' [, (int)nameColumn=0 [, (int)smartsColumn=1]]]]]) -> dict : reads query definitions from a simply formatted file
 
PathToSubmol(...)
PathToSubmol( (Mol)mol, (AtomPairsParameters)path [, (bool)useQuery=False [, (AtomPairsParameters)atomMap=None]]) -> Mol :
 
PatternFingerprint(...)
PatternFingerprint( (Mol)mol [, (int)fpSize=2048 [, (list)atomCounts=[] [, (ExplicitBitVect)setOnlyBits=None]]]) -> ExplicitBitVect : A fingerprint using SMARTS patterns
 
RDKFingerprint(...)
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 [, (AtomPairsParameters)atomInvariants=0 [, (AtomPairsParameters)fromAtoms=0 [, (AtomPairsParameters)atomBits=None [, (AtomPairsParameters)bitInfo=None]]]]]]]]]]]]]) -> ExplicitBitVect : Returns an RDKit topological fingerprint for a molecule
 
RemoveHs(...)
RemoveHs( (Mol)mol [, (bool)implicitOnly=False [, (bool)updateExplicitCount=False [, (bool)sanitize=True]]]) -> Mol : Removes any hydrogens from the graph of a molecule.
 
RemoveStereochemistry(...)
RemoveStereochemistry( (Mol)mol) -> None : Removes all stereochemistry info from the molecule.
 
RenumberAtoms(...)
RenumberAtoms( (Mol)mol, (AtomPairsParameters)newOrder) -> Mol : Returns a copy of a molecule with renumbered atoms
 
ReplaceCore(...)
ReplaceCore( (Mol)mol, (Mol)core, (AtomPairsParameters)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.
 
ReplaceSidechains(...)
ReplaceSidechains( (Mol)mol, (Mol)coreQuery [, (bool)useChirality=False]) -> Mol : Replaces sidechains in a molecule with dummy atoms for their attachment points.
 
ReplaceSubstructs(...)
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
 
SanitizeMol(...)
SanitizeMol( (Mol)mol [, (int)sanitizeOps=rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_ALL [, (bool)catchErrors=False]]) -> SanitizeFlags : Kekulize, check valencies, set aromaticity, conjugation and hybridization
 
SetAromaticity(...)
SetAromaticity( (Mol)mol [, (AromaticityModel)model=rdkit.Chem.rdmolops.AromaticityModel.AROMATICITY_DEFAULT]) -> None : does aromaticity perception
 
SetConjugation(...)
SetConjugation( (Mol)mol) -> None : finds conjugated bonds
 
SetHybridization(...)
SetHybridization( (Mol)mol) -> None : Assigns hybridization states to atoms
 
SplitMolByPDBChainId(...)
SplitMolByPDBChainId( (Mol)mol [, (AtomPairsParameters)whiteList=None [, (bool)negateList=False]]) -> dict : Splits a molecule into pieces based on PDB chain information.
 
SplitMolByPDBResidues(...)
SplitMolByPDBResidues( (Mol)mol [, (AtomPairsParameters)whiteList=None [, (bool)negateList=False]]) -> dict : Splits a molecule into pieces based on PDB residue information.
 
UnfoldedRDKFingerprintCountBased(...)
UnfoldedRDKFingerprintCountBased( (Mol)mol [, (int)minPath=1 [, (int)maxPath=7 [, (bool)useHs=True [, (bool)branchedPaths=True [, (bool)useBondOrder=True [, (AtomPairsParameters)atomInvariants=0 [, (AtomPairsParameters)fromAtoms=0 [, (AtomPairsParameters)atomBits=None [, (AtomPairsParameters)bitInfo=None]]]]]]]]]) -> ULongSparseIntVect : Returns an unfolded count-based version of the RDKit fingerprint for a molecule
 
WedgeMolBonds(...)
WedgeMolBonds( (Mol)arg1, (Conformer)arg2) -> None : Set the wedging on single bonds in a molecule.
Variables [hide private]
  ADJUST_IGNOREALL = rdkit.Chem.rdmolops.AdjustQueryWhichFlags.A...
  ADJUST_IGNORECHAINS = rdkit.Chem.rdmolops.AdjustQueryWhichFlag...
  ADJUST_IGNOREDUMMIES = rdkit.Chem.rdmolops.AdjustQueryWhichFla...
  ADJUST_IGNORENONDUMMIES = rdkit.Chem.rdmolops.AdjustQueryWhich...
  ADJUST_IGNORENONE = rdkit.Chem.rdmolops.AdjustQueryWhichFlags....
  ADJUST_IGNORERINGS = rdkit.Chem.rdmolops.AdjustQueryWhichFlags...
  AROMATICITY_CUSTOM = rdkit.Chem.rdmolops.AromaticityModel.AROM...
  AROMATICITY_DEFAULT = rdkit.Chem.rdmolops.AromaticityModel.ARO...
  AROMATICITY_RDKIT = rdkit.Chem.rdmolops.AromaticityModel.AROMA...
  AROMATICITY_SIMPLE = rdkit.Chem.rdmolops.AromaticityModel.AROM...
  LayeredFingerprint_substructLayers = 7
  SANITIZE_ADJUSTHS = rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE...
  SANITIZE_ALL = rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_ALL
  SANITIZE_CLEANUP = rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_...
  SANITIZE_CLEANUPCHIRALITY = rdkit.Chem.rdmolops.SanitizeFlags....
  SANITIZE_FINDRADICALS = rdkit.Chem.rdmolops.SanitizeFlags.SANI...
  SANITIZE_KEKULIZE = rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE...
  SANITIZE_NONE = rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_NONE
  SANITIZE_PROPERTIES = rdkit.Chem.rdmolops.SanitizeFlags.SANITI...
  SANITIZE_SETAROMATICITY = rdkit.Chem.rdmolops.SanitizeFlags.SA...
  SANITIZE_SETCONJUGATION = rdkit.Chem.rdmolops.SanitizeFlags.SA...
  SANITIZE_SETHYBRIDIZATION = rdkit.Chem.rdmolops.SanitizeFlags....
  SANITIZE_SYMMRINGS = rdkit.Chem.rdmolops.SanitizeFlags.SANITIZ...
  _LayeredFingerprint_version = '0.7.0'
  _RDKFingerprint_version = '2.0.0'
  __package__ = None
hash(x)
Function Details [hide private]

AddHs(...)

 

AddHs( (Mol)mol [, (bool)explicitOnly=False [, (bool)addCoords=False [, (AtomPairsParameters)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]]])

AddRecursiveQuery(...)

 

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

AdjustQueryProperties(...)

 

AdjustQueryProperties( (Mol)mol [, (AtomPairsParameters)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])

AssignAtomChiralTagsFromStructure(...)

 

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

AssignRadicals(...)

 

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

AssignStereochemistry(...)

 

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

Cleanup(...)

 

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

CombineMols(...)

 

CombineMols( (Mol)mol1, (Mol)mol2 [, (Point3D)offset=<rdkit.Geometry.rdGeometry.Point3D object at 0x7f7942a10c00>]) -> 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 0x7f7942a10c00>])

DeleteSubstructs(...)

 

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

DetectBondStereoChemistry(...)

 

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

FastFindRings(...)

 

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)

FindAllPathsOfLengthN(...)

 

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::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]]])

FindAllSubgraphsOfLengthMToN(...)

 

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

FindAllSubgraphsOfLengthN(...)

 

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::list<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > FindAllSubgraphsOfLengthN(RDKit::ROMol,unsigned int [,bool=False [,int=-1]])

FindAtomEnvironmentOfRadiusN(...)

 

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

FindUniqueSubgraphsOfLengthN(...)

 

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::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]]])

FragmentOnBRICSBonds(...)

 

FragmentOnBRICSBonds( (Mol)mol) -> Mol :
    Return a new molecule with all BRICS bonds broken

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

FragmentOnBonds(...)

 

FragmentOnBonds( (Mol)mol, (AtomPairsParameters)bondIndices [, (bool)addDummies=True [, (AtomPairsParameters)dummyLabels=None [, (AtomPairsParameters)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=[]]]]])

FragmentOnSomeBonds(...)

 

FragmentOnSomeBonds( (Mol)mol, (AtomPairsParameters)bondIndices [, (int)numToBreak=1 [, (bool)addDummies=True [, (AtomPairsParameters)dummyLabels=None [, (AtomPairsParameters)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]]]]])

Get3DDistanceMatrix(...)

 

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*='']]]])

GetAdjacencyMatrix(...)

 

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*='']]]])

GetDistanceMatrix(...)

 

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*='']]]])

GetFormalCharge(...)

 

GetFormalCharge( (Mol)arg1) -> int :
    Returns the formal charge for the molecule.
    
      ARGUMENTS:
    
        - mol: the molecule to use
    
    

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

GetMolFrags(...)

 

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

GetSSSR(...)

 

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

GetShortestPath(...)

 

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)

GetSymmSSSR(...)

 

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

Kekulize(...)

 

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

LayeredFingerprint(...)

 

LayeredFingerprint( (Mol)mol [, (int)layerFlags=4294967295 [, (int)minPath=1 [, (int)maxPath=7 [, (int)fpSize=2048 [, (list)atomCounts=[] [, (ExplicitBitVect)setOnlyBits=None [, (bool)branchedPaths=True [, (AtomPairsParameters)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]]]]]]]])

MergeQueryHs(...)

 

MergeQueryHs( (Mol)mol [, (bool)mergeUnmappedOnly=False]) -> Mol :
    merges hydrogens into their neighboring atoms as queries

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

MolAddRecursiveQueries(...)

 

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::string)

MolToSVG(...)

 

MolToSVG( (Mol)arg1, (int)mol [, (int)width=300 [, (AtomPairsParameters)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::string 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]]]]]]])

MurckoDecompose(...)

 

MurckoDecompose( (Mol)mol) -> Mol :
    Do a Murcko decomposition and return the scaffold

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

ParseMolQueryDefFile(...)

 

ParseMolQueryDefFile( (AtomPairsParameters)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::string='\t' [,std::string='//' [,unsigned int=0 [,unsigned int=1]]]]])

PathToSubmol(...)

 

PathToSubmol( (Mol)mol, (AtomPairsParameters)path [, (bool)useQuery=False [, (AtomPairsParameters)atomMap=None]]) -> Mol :

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

PatternFingerprint(...)

 

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

RDKFingerprint(...)

 

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 [, (AtomPairsParameters)atomInvariants=0 [, (AtomPairsParameters)fromAtoms=0 [, (AtomPairsParameters)atomBits=None [, (AtomPairsParameters)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]]]]]]]]]]]]])

RemoveHs(...)

 

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

RemoveStereochemistry(...)

 

RemoveStereochemistry( (Mol)mol) -> None :
    Removes all stereochemistry info from the molecule.
    
    

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

RenumberAtoms(...)

 

RenumberAtoms( (Mol)mol, (AtomPairsParameters)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})

ReplaceCore(...)

 

ReplaceCore( (Mol)mol, (Mol)core, (AtomPairsParameters)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]]]])

ReplaceSidechains(...)

 

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

ReplaceSubstructs(...)

 

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

SanitizeMol(...)

 

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 int=rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_ALL [,bool=False]])

SetAromaticity(...)

 

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

SetConjugation(...)

 

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

SetHybridization(...)

 

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

SplitMolByPDBChainId(...)

 

SplitMolByPDBChainId( (Mol)mol [, (AtomPairsParameters)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]])

SplitMolByPDBResidues(...)

 

SplitMolByPDBResidues( (Mol)mol [, (AtomPairsParameters)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]])

UnfoldedRDKFingerprintCountBased(...)

 

UnfoldedRDKFingerprintCountBased( (Mol)mol [, (int)minPath=1 [, (int)maxPath=7 [, (bool)useHs=True [, (bool)branchedPaths=True [, (bool)useBondOrder=True [, (AtomPairsParameters)atomInvariants=0 [, (AtomPairsParameters)fromAtoms=0 [, (AtomPairsParameters)atomBits=None [, (AtomPairsParameters)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]]]]]]]]])

WedgeMolBonds(...)

 

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


Variables Details [hide private]

ADJUST_IGNOREALL

Value:
rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNOREALL

ADJUST_IGNORECHAINS

Value:
rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNORECHAINS

ADJUST_IGNOREDUMMIES

Value:
rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNOREDUMMIES

ADJUST_IGNORENONDUMMIES

Value:
rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNORENONDUMMIES

ADJUST_IGNORENONE

Value:
rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNORENONE

ADJUST_IGNORERINGS

Value:
rdkit.Chem.rdmolops.AdjustQueryWhichFlags.ADJUST_IGNORERINGS

AROMATICITY_CUSTOM

Value:
rdkit.Chem.rdmolops.AromaticityModel.AROMATICITY_CUSTOM

AROMATICITY_DEFAULT

Value:
rdkit.Chem.rdmolops.AromaticityModel.AROMATICITY_DEFAULT

AROMATICITY_RDKIT

Value:
rdkit.Chem.rdmolops.AromaticityModel.AROMATICITY_RDKIT

AROMATICITY_SIMPLE

Value:
rdkit.Chem.rdmolops.AromaticityModel.AROMATICITY_SIMPLE

SANITIZE_ADJUSTHS

Value:
rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_ADJUSTHS

SANITIZE_CLEANUP

Value:
rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_CLEANUP

SANITIZE_CLEANUPCHIRALITY

Value:
rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_CLEANUPCHIRALITY

SANITIZE_FINDRADICALS

Value:
rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_FINDRADICALS

SANITIZE_KEKULIZE

Value:
rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_KEKULIZE

SANITIZE_PROPERTIES

Value:
rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_PROPERTIES

SANITIZE_SETAROMATICITY

Value:
rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_SETAROMATICITY

SANITIZE_SETCONJUGATION

Value:
rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_SETCONJUGATION

SANITIZE_SETHYBRIDIZATION

Value:
rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_SETHYBRIDIZATION

SANITIZE_SYMMRINGS

Value:
rdkit.Chem.rdmolops.SanitizeFlags.SANITIZE_SYMMRINGS