Package 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'))
[]

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

AssignAtomChiralCodes( (Mol)mol [, (bool)cleanIt=False [, (bool)force=False]]) -> None :
    Does the CIP chirality assignment (R/S) 
      for the molecule's atoms.
      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
    
    

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

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

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

AssignBondStereoCodes( (Mol)mol [, (bool)cleanIt=False [, (bool)force=False]]) -> None :
    Does the CIP stereochemistry assignment (Z/E)
       for the molecule's bonds .
      Qualifying bonds will have a property '_CIPCode' indicating
      their stereochemistry.
    
      ARGUMENTS:
    
        - mol: the molecule to use
        - cleanIt: (optional) ignored
        - force: (optional) causes the calculation to be repeated, even if it has already
          been done
    
    

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

DaylightFingerprint( (Mol)mol [, (int)minPath=1 [, (int)maxPath=7 [, (int)fpSize=2048 [, (int)nBitsPerHash=4 [, (bool)useHs=True [, (float)tgtDensity=0.0 [, (int)minSize=128]]]]]]]) -> ExplicitBitVect :
    Returns a "Daylight"-type 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.
    
        - nBitsPerPath: (optional) number of bits to set per path
          Defaults to 4.
    
        - useHs: (optional) include information about number of Hs on each
          atom when calculating path hashes.
          Defaults to 1.
    
        - 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.
    
      RETURNS: a DataStructs.ExplicitBitVect with _fpSize_ bits
    
      ALGORITHM:
    
       This algorithm functions by find all paths between minPath and maxPath in
        length.  For each path:
    
         1) The Balaban J value is calculated.
    
         2) The 32 bit Balaban J value is used to seed a random-number generator
    
         3) _nBitsPerPath_ random numbers are generated and used to set the corresponding
            bits in the fingerprint
    
    
    

    C++ signature :
        ExplicitBitVect* DaylightFingerprint(RDKit::ROMol [,unsigned int=1 [,unsigned int=7 [,unsigned int=2048 [,unsigned int=4 [,bool=True [,double=0.0 [,unsigned int=128]]]]]]])

DeleteSubstructs( (Mol)mol, (Mol)query [, (bool)onlyFrags=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)
    
      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])

FindAllPathsOfLengthN( (Mol)mol, (int)length [, (bool)useBonds=True [, (bool)useHs=False]]) -> _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.
    
      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]])

FindAllSubgraphsOfLengthN( (Mol)mol, (int)length [, (bool)useHs=False]) -> _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.
    
        - verbose: (optional, internal use) toggles verbosity in the search algorithm.
          Defaults to 0.
    
      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])

FindUniqueSubgraphsOfLengthN( (Mol)mol, (int)length [, (bool)useHs=False [, (bool)useBO=True]]) -> _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.
    
      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]])

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( (Mol)mol [, (bool)useBO=False [, (bool)useAtomWts=False [, (bool)force=False [, (str)prefix='']]]]) -> object :
    Returns the molecule's 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( (Mol)arg1) -> int :
    Returns the formal charge for the molecule.
    
      ARGUMENTS:
    
        - mol: the molecule to use
    
    

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

GetMolFrags( (Mol)mol [, (bool)asMols=False]) -> 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.
    
      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])

    Returns the application's PeriodicTable instance.
    
    

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

Returns:

PeriodicTable :

GetSSSR( (Mol)arg1) -> int :
    Get the smallest set of simple rings for a molecule.
    
      ARGUMENTS:
    
        - mol: the molecule to use.
    
      RETURNS: the number of rings found
             This will be equal to NumBonds-NumAtoms+1 for single-fragment molecules.
    
    

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

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: the number of rings found
    
    

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

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

MolFromMolBlock( (str)molBlock [, (bool)sanitize=True [, (bool)removeHs=True]]) -> Mol :
    Construct a molecule from a Mol block.
    
      ARGUMENTS:
    
        - molBlock: string containing the Mol block
    
        - sanitize: (optional) toggles sanitization of the molecule.
          Defaults to 1.
    
        - removeHs: (optional) toggles removing hydrogens from the molecule.
          This only make sense when sanitization is done.
          Defaults to true.
    
      RETURNS:
    
        a Mol object, None on failure.
    
    

    C++ signature :
        RDKit::ROMol* MolFromMolBlock(std::string [,bool=True [,bool=True]])

MolFromMolFile( (str)molFileName [, (bool)sanitize=True [, (bool)removeHs=True]]) -> Mol :
    Construct a molecule from a Mol file.
    
      ARGUMENTS:
    
        - fileName: name of the file to read
    
        - sanitize: (optional) toggles sanitization of the molecule.
          Defaults to true.
    
        - removeHs: (optional) toggles removing hydrogens from the molecule.
          This only make sense when sanitization is done.
          Defaults to true.
    
      RETURNS:
    
        a Mol object, None on failure.
    
    

    C++ signature :
        RDKit::ROMol* MolFromMolFile(char const* [,bool=True [,bool=True]])

MolFromSmarts( (str)SMARTS [, (bool)mergeHs=False]) -> Mol :
    Construct a molecule from a SMARTS string.
    
      ARGUMENTS:
    
        - SMARTS: the smarts string
    
        - mergeHs: (optional) toggles the merging of explicit Hs in the query into the attached
          atoms.  So, for example, 'C[H]' becomes '[C;!H0]'.
          Defaults to 0.
    
      RETURNS:
    
        a Mol object, None on failure.
    
    

    C++ signature :
        RDKit::ROMol* MolFromSmarts(char const* [,bool=False])

MolFromSmiles( (str)SMILES [, (bool)sanitize=True]) -> Mol :
    Construct a molecule from a SMILES string.
    
      ARGUMENTS:
    
        - SMILES: the smiles string
    
        - sanitize: (optional) toggles sanitization of the molecule.
          Defaults to 1.
    
      RETURNS:
    
        a Mol object, None on failure.
    
    

    C++ signature :
        RDKit::ROMol* MolFromSmiles(std::string [,bool=True])

MolFromTPLBlock( (str)tplBlock [, (bool)sanitize=True [, (bool)skipFirstConf=False]]) -> Mol :
    Construct a molecule from a TPL block.
    
      ARGUMENTS:
    
        - fileName: name of the file to read
    
        - sanitize: (optional) toggles sanitization of the molecule.
          Defaults to True.
    
        - skipFirstConf: (optional) skips reading the first conformer.
          Defaults to False.
          This should be set to True when reading TPLs written by 
          the CombiCode.
    
      RETURNS:
    
        a Mol object, None on failure.
    
    

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

MolFromTPLFile( (str)fileName [, (bool)sanitize=True [, (bool)skipFirstConf=False]]) -> Mol :
    Construct a molecule from a TPL file.
    
      ARGUMENTS:
    
        - fileName: name of the file to read
    
        - sanitize: (optional) toggles sanitization of the molecule.
          Defaults to True.
    
        - skipFirstConf: (optional) skips reading the first conformer.
          Defaults to False.
          This should be set to True when reading TPLs written by 
          the CombiCode.
    
      RETURNS:
    
        a Mol object, None on failure.
    
    

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

MolToMolBlock( (Mol)mol [, (bool)includeStereo=False [, (int)confId=-1]]) -> str :
    Returns the a Mol block for a molecule
      ARGUMENTS:
    
        - mol: the molecule
        - includeStereo: (optional) toggles inclusion of stereochemical
                         information in the output
        - confId: (optional) selects which conformation to output (-1 = default)
    
      RETURNS:
    
        a string
    
    

    C++ signature :
        std::string MolToMolBlock(RDKit::ROMol [,bool=False [,int=-1]])

MolToSmarts( (Mol)mol [, (bool)isomericSmiles=False]) -> str :
    Returns a SMARTS string for a molecule
      ARGUMENTS:
    
        - mol: the molecule
        - isomericSmarts: (optional) include information about stereochemistry in
          the SMARTS.  Defaults to false.
    
      RETURNS:
    
        a string
    
    

    C++ signature :
        std::string MolToSmarts(RDKit::ROMol {lvalue} [,bool=False])

MolToSmiles( (Mol)mol [, (bool)isomericSmiles=False [, (bool)kekuleSmiles=False [, (int)rootedAtAtom=-1]]]) -> str :
    Returns the canonical SMILES string for a molecule
      ARGUMENTS:
    
        - mol: the molecule
        - isomericSmiles: (optional) include information about stereochemistry in
          the SMILES.  Defaults to false.
        - kekuleSmiles: (optional) use the Kekule form (no aromatic bonds) in
          the SMILES.  Defaults to false.
        - rootedAtAtom: (optional) if non-negative, this forces the SMILES 
          to start at a particular atom. Defaults to -1.
    
      RETURNS:
    
        a string
    
    

    C++ signature :
        std::string MolToSmiles(RDKit::ROMol {lvalue} [,bool=False [,bool=False [,int=-1]]])

MolToTPLBlock( (Mol)mol [, (str)partialChargeProp='_GasteigerCharge' [, (bool)writeFirstConfTwice=False]]) -> str :
    Returns the Tpl block for a molecule.
    
      ARGUMENTS:
    
        - mol: the molecule
        - partialChargeProp: name of the property to use for partial charges
          Defaults to '_GasteigerCharge'.
        - writeFirstConfTwice: Defaults to False.
          This should be set to True when writing TPLs to be read by 
          the CombiCode.
    
      RETURNS:
    
        a string
    
    

    C++ signature :
        std::string MolToTPLBlock(RDKit::ROMol [,std::string='_GasteigerCharge' [,bool=False]])

MolToTPLFile( (Mol)mol, (str)fileName [, (str)partialChargeProp='_GasteigerCharge' [, (bool)writeFirstConfTwice=False]]) -> None :
    Writes a molecule to a TPL file.
    
      ARGUMENTS:
    
        - mol: the molecule
        - fileName: name of the file to write
        - partialChargeProp: name of the property to use for partial charges
          Defaults to '_GasteigerCharge'.
        - writeFirstConfTwice: Defaults to False.
          This should be set to True when writing TPLs to be read by 
          the CombiCode.
    
    

    C++ signature :
        void MolToTPLFile(RDKit::ROMol,std::string [,std::string='_GasteigerCharge' [,bool=False]])

RDKFingerprint( (Mol)mol [, (int)minPath=1 [, (int)maxPath=7 [, (int)fpSize=2048 [, (int)nBitsPerHash=4 [, (bool)useHs=True [, (float)tgtDensity=0.0 [, (int)minSize=128]]]]]]]) -> 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.
    
        - nBitsPerPath: (optional) number of bits to set per path
          Defaults to 4.
    
        - useHs: (optional) include information about number of Hs on each
          atom when calculating path hashes.
          Defaults to 1.
    
        - 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.
    
      RETURNS: a DataStructs.ExplicitBitVect with _fpSize_ bits
    
      ALGORITHM:
    
       This algorithm functions by find all paths between minPath and maxPath in
        length.  For each path:
    
         1) A hash is calculated.
    
         2) The hash is used to seed a random-number generator
    
         3) _nBitsPerPath_ 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=4 [,bool=True [,double=0.0 [,unsigned int=128]]]]]]])

RemoveHs( (Mol)mol [, (bool)implicitOnly=False]) -> 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).
    
      RETURNS: a new molecule with the Hs removed
    
      NOTES:
    
        - The original molecule is *not* modified.
    
    

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

ReplaceCore( (Mol)mol, (Mol)coreQuery [, (bool)replaceDummies=True]) -> 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
    
      RETURNS: a new molecule with the core 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:
    
        - ReplaceCore('CCC1CCC1','C1CCC1') -> 'CC[Xa]'
    
        - ReplaceCore('CCC1CC1','C1CCC1') -> ''
    
        - ReplaceCore('C1CC2C1CCC2','C1CCC1') -> '[Xa]C1CCC1[Xb]'
    
        - ReplaceCore('C1CNCC1','N') -> '[Xa]CCCC[Xb]'
    
        - ReplaceCore('C1CCC1CN','C1CCC1[*]',False) -> '[Xa]CN'
    
    

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

ReplaceSidechains( (Mol)mol, (Mol)coreQuery) -> 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
    
      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)

ReplaceSubstructs( (Mol)mol, (Mol)query, (Mol)replacement [, (bool)replaceAll=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)
    
      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',)
    
    

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

SanitizeMol( (Mol)arg1) -> None :
    Kekulize, check valencies, set aromaticity, conjugation and hybridization
    
        - The molecule is modified in place.
    
        - If sanitization fails, an exception will be thrown
    
      ARGUMENTS:
    
        - mol: the molecule to be modified
    
      NOTES:
    
    

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

SmilesMolSupplierFromText( (str)text [, (str)delimiter=' ' [, (int)smilesColumn=0 [, (int)nameColumn=1 [, (bool)titleLine=True [, (bool)sanitize=True]]]]]) -> SmilesMolSupplier :

    C++ signature :
        RDKit::SmilesMolSupplier* SmilesMolSupplierFromText(std::string [,std::string=' ' [,int=0 [,int=1 [,bool=True [,bool=True]]]]])

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

    C++ signature :
        void tossit()

Returns:

None :