Chem

Package Chem |
[hide private]
[frames] | no frames]

# Package Chem

source code

    A module for molecules and stuff

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

Submodules | [hide private]
Chem.AllChem: Import all RDKit chemistry modules... Chem.AtomPairs Chem.AtomPairs.Pairs: Contains an implementation of Atom-pair fingerprints, as described in: R.E. Chem.AtomPairs.Torsions: Contains an implementation of Topological-torsion fingerprints, as described in: R. Chem.AtomPairs.Utils Chem.AvailDescriptors: constructs the list of available descriptors Chem.BuildFragmentCatalog: command line utility for working with FragmentCatalogs (CASE-type analysis) **Usage** BuildFragmentCatalog [optional args] <filename> filename, the name of a delimited text file containing InData, is required for some modes of operation (see below) **Command Line Arguments** - -n *maxNumMols*: specify the maximum number of molecules to be processed - -b: build the catalog and OnBitLists *requires InData* - -s: score compounds *requires InData and a Catalog, can use OnBitLists* - -g: calculate info gains *requires Scores* - -d: show details about high-ranking fragments *requires a Catalog and Gains* - --catalog=*filename*: filename with the pickled catalog. Chem.ChemUtils Chem.ChemUtils.AlignDepict Chem.ChemUtils.BulkTester Chem.ChemUtils.SDFToCSV Chem.ChemUtils.TemplateExpand Chem.ChemicalFeatures Chem.ChemicalForceFields Chem.Crippen: Atom-based calculation of LogP and MR using Crippen's approach Reference: S. Chem.Descriptors Chem.Draw Chem.Draw.DrawUtils Chem.Draw.MolDrawing Chem.Draw.aggCanvas Chem.Draw.mplCanvas Chem.Draw.spingCanvas Chem.EState: A module for Kier and Hall's EState Descriptors Unless otherwise noted, all definitions here can be found in: L.B. Chem.EState.AtomTypes: contains SMARTS definitions and calculators for EState atom types... Chem.EState.EState: Basic EState definitions Chem.EState.EState_VSA: Hybrid EState-VSA descriptors (like the MOE VSA descriptors) Chem.EState.Fingerprinter: EState fingerprinting Chem.FastSDMolSupplier Chem.FeatFinderCLI Chem.FeatMaps Chem.FeatMaps.FeatMapParser Chem.FeatMaps.FeatMapPoint Chem.FeatMaps.FeatMapUtils Chem.FeatMaps.FeatMaps Chem.Features Chem.Features.FeatDirUtilsRD Chem.Features.ShowFeats Chem.Fingerprints Chem.Fingerprints.ClusterMols: utility functionality for clustering molecules using fingerprints... Chem.Fingerprints.DbFpSupplier: Supplies a class for working with fingerprints from databases... Chem.Fingerprints.FingerprintMols: utility functionality for fingerprinting sets of molecules... Chem.Fingerprints.MolSimilarity: utility functionality for molecular similarity... Chem.Fingerprints.SimilarityScreener: class definitions for similarity screening... Chem.FragmentCatalog Chem.FragmentMatcher: exposes a class for matching fragments of molecules. Chem.Fragments: functions to match a bunch of fragment descriptors from a file No user-servicable parts inside. Chem.GraphDescriptors: Calculation of topological/topochemical descriptors. Chem.Graphs: Python functions for manipulating molecular graphs In theory much of the functionality in here should be migrating into the C/C++ codebase. Chem.Lipinski: Calculation of Lipinski parameters for molecules Chem.MACCSkeys: SMARTS definitions for the publically available MACCS keys and a MACCS fingerprinter I compared the MACCS fingerprints generated here with those from two other packages (not MDL, unfortunately). Chem.MolCatalog Chem.MolDb Chem.MolDb.Loader Chem.MolSurf: Exposes functionality for MOE-like approximate molecular surface area descriptors. Chem.PeriodicTable': periodic table data, **obsolete**... Chem.Pharm2D: module with functionality for 2D pharmacophores Chem.Pharm2D.Generate: generation of 2D pharmacophores **Notes** - The terminology for this gets a bit rocky, so here's a glossary of what terms used here mean: 1) *N-point pharmacophore* a combination of N features along with distances betwen them. Chem.Pharm2D.Gobbi_Pharm2D: Definitions for 2D Pharmacophores from: Gobbi and Poppinger, Biotech. Chem.Pharm2D.LazyGenerator: lazy generator of 2D pharmacophore signature data Chem.Pharm2D.Matcher: functionality for finding pharmacophore matches in molecules See Docs/Chem/Pharm2D.triangles.jpg for an illustration of the way pharmacophores are broken into triangles and labelled. Chem.Pharm2D.SigFactory: contains factory class for producing signatures Chem.Pharm2D.Signature: data structures for holding 2D pharmacophore signatures See Docs/Chem/Pharm2D.triangles.jpg for an illustration of the way pharmacophores are broken into triangles and labelled. Chem.Pharm2D.Utils: utility functionality for the 2D pharmacophores code See Docs/Chem/Pharm2D.triangles.jpg for an illustration of the way pharmacophores are broken into triangles and labelled. Chem.Pharm3D Chem.Pharm3D.EmbedLib Chem.Pharm3D.ExcludedVolume Chem.Pharm3D.Pharmacophore Chem.PyMol: uses pymol to interact with molecules Chem.Randomize Chem.Recap: Implementation of the RECAP algorithm from Lewell et al. Chem.SATIS: Functionality for SATIS typing atoms Chem.ShowMols Chem.Subshape Chem.Subshape.BuilderUtils Chem.Subshape.SubshapeAligner Chem.Subshape.SubshapeBuilder Chem.Subshape.SubshapeObjects Chem.Suppliers Chem.Suppliers.DbMolSupplier: Supplies a class for working with molecules from databases... Chem.Suppliers.MolSupplier: Supplies an abstract class for working with sequences of molecules Chem.TemplateAlign Chem.rdChemReactions: Module containing classes and functions for working with chemical reactions. Chem.rdChemicalFeatures: Module containing free chemical feature functionality These are feature that are not associated with molecules. Chem.rdDepictor: Module containing the functionality to compute 2D coordinates for a molecule Chem.rdDistGeom: Module containing functions to compute atomic coordinates in 3D using distance geometry Chem.rdForceFieldHelpers: Module containing functions to handle molecular force fields (currently UFF) Chem.rdMolAlign: Module containing functions to align a molecule to a second molecule Chem.rdMolCatalog Chem.rdMolChemicalFeatures: Module containing from chemical feature and functions to generate the Chem.rdMolDescriptors: Module containing functions to compute molecular descriptors Chem.rdMolTransforms: Module containing functions to perform 3D operations like rotate and translate conformations Chem.rdPartialCharges: Module containing functions to set partial charges - currently Gasteiger Charges Chem.rdShapeHelpers: Module containing functions to encode ans compre the shapes of molecules Chem.rdchem: Module containing the core chemistry functionality of the RDKit Chem.rdfragcatalog Chem.rdmolfiles: Module containing RDKit functionality for working with molecular file formats. Chem.rdmolops: Module containing RDKit functionality for manipulating and querying molecules.

Functions | [hide private]
_HasSubstructMatchStr(...) _HasSubstructMatchStr( (str)pkl, (Mol)query [, (bool)recursionPossible=True [, (bool)useChirality=False]]) -> bool : This function is included to speed substructure queries from databases, it's probably not of general interest. | source code
GetSmartsMatchCDXML(mol, patt, maps, which=0, showAllAtoms=0) | source code
DisplaySmartsMatch(mol, patt, maps, which=0, showAllAtoms=0) | source code
QuickSmartsMatch(smi, sma, unique=1, display=0) | source code
CanonSmiles(smi, useChiral=1) | source code
SmilesRoundtrip(smi, useChiral=1) | source code
SupplierFromFilename(fileN, delim=`'````'`, **kwargs) | source code
FindMolChiralCenters(mol) >>> mol = Chem.MolFromSmiles('[C@H](Cl)(F)Br')... | source code
AddHs(...) AddHs( (Mol)mol [, (bool)explicitOnly=False [, (bool)addCoords=False]]) -> Mol : Adds hydrogens to the graph of a molecule. | source code
AssignAtomChiralCodes(...) AssignAtomChiralCodes( (Mol)mol [, (bool)cleanIt=False [, (bool)force=False]]) -> None : Does the CIP chirality assignment (R/S) for the molecule's atoms. | source code
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. | source code
AssignBondStereoCodes(...) AssignBondStereoCodes( (Mol)mol [, (bool)cleanIt=False [, (bool)force=False]]) -> None : Does the CIP stereochemistry assignment (Z/E) for the molecule's bonds . | source code
DaylightFingerprint(...) 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. | source code
DeleteSubstructs(...) 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. | source code
FindAllPathsOfLengthN(...) 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. | source code
FindAllSubgraphsOfLengthN(...) 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. | source code
FindUniqueSubgraphsOfLengthN(...) 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. | source code
GetAdjacencyMatrix(...) GetAdjacencyMatrix( (Mol)mol [, (bool)useBO=False [, (int)emptyVal=0 [, (bool)force=False [, (str)prefix='']]]]) -> object : Returns the molecule's adjacency matrix. | source code
GetDistanceMatrix(...) GetDistanceMatrix( (Mol)mol [, (bool)useBO=False [, (bool)useAtomWts=False [, (bool)force=False [, (str)prefix='']]]]) -> object : Returns the molecule's distance matrix. | source code
GetFormalCharge(...) GetFormalCharge( (Mol)arg1) -> int : Returns the formal charge for the molecule. | source code
GetMolFrags(...) GetMolFrags( (Mol)mol [, (bool)asMols=False]) -> tuple : Finds the disconnected fragments from a molecule. | source code
GetPeriodicTable() Returns the application's PeriodicTable instance. | source code
GetSSSR(...) GetSSSR( (Mol)arg1) -> int : Get the smallest set of simple rings for a molecule. | source code
GetSymmSSSR(...) GetSymmSSSR( (Mol)arg1) -> _vectSt6vectorIiSaIiEE : Get a symmetrized SSSR for a molecule. | source code
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. | source code
MolFromMolBlock(...) MolFromMolBlock( (str)molBlock [, (bool)sanitize=True [, (bool)removeHs=True]]) -> Mol : Construct a molecule from a Mol block. | source code
MolFromMolFile(...) MolFromMolFile( (str)molFileName [, (bool)sanitize=True [, (bool)removeHs=True]]) -> Mol : Construct a molecule from a Mol file. | source code
MolFromSmarts(...) MolFromSmarts( (str)SMARTS [, (bool)mergeHs=False]) -> Mol : Construct a molecule from a SMARTS string. | source code
MolFromSmiles(...) MolFromSmiles( (str)SMILES [, (bool)sanitize=True]) -> Mol : Construct a molecule from a SMILES string. | source code
MolFromTPLBlock(...) MolFromTPLBlock( (str)tplBlock [, (bool)sanitize=True [, (bool)skipFirstConf=False]]) -> Mol : Construct a molecule from a TPL block. | source code
MolFromTPLFile(...) MolFromTPLFile( (str)fileName [, (bool)sanitize=True [, (bool)skipFirstConf=False]]) -> Mol : Construct a molecule from a TPL file. | source code
MolToMolBlock(...) MolToMolBlock( (Mol)mol [, (bool)includeStereo=False [, (int)confId=-1]]) -> str :... | source code
MolToSmarts(...) 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. | source code
MolToSmiles(...) 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. | source code
MolToTPLBlock(...) MolToTPLBlock( (Mol)mol [, (str)partialChargeProp='_GasteigerCharge' [, (bool)writeFirstConfTwice=False]]) -> str : Returns the Tpl block for a molecule. | source code
MolToTPLFile(...) MolToTPLFile( (Mol)mol, (str)fileName [, (str)partialChargeProp='_GasteigerCharge' [, (bool)writeFirstConfTwice=False]]) -> None : Writes a molecule to a TPL file. | source code
RDKFingerprint(...) 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. | source code
RemoveHs(...) RemoveHs( (Mol)mol [, (bool)implicitOnly=False]) -> Mol : Removes any hydrogens from the graph of a molecule. | source code
ReplaceCore(...) ReplaceCore( (Mol)mol, (Mol)coreQuery [, (bool)replaceDummies=True]) -> Mol : Removes the core of a molecule and labels the sidechains with dummy atoms. | source code
ReplaceSidechains(...) ReplaceSidechains( (Mol)mol, (Mol)coreQuery) -> Mol : Replaces sidechains in a molecule with dummy atoms for their attachment points. | source code
ReplaceSubstructs(...) 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. | source code
SanitizeMol(...) SanitizeMol( (Mol)arg1) -> None : Kekulize, check valencies, set aromaticity, conjugation and hybridization - The molecule is modified in place. | source code
SmilesMolSupplierFromText(...) SmilesMolSupplierFromText( (str)text [, (str)delimiter=' ' [, (int)smilesColumn=0 [, (int)nameColumn=1 [, (bool)titleLine=True [, (bool)sanitize=True]]]]]) -> SmilesMolSupplier :... | source code
WedgeMolBonds(...) WedgeMolBonds( (Mol)arg1, (Conformer)arg2) -> None : Set the wedging on single bonds in a molecule. | source code
tossit() C++ signature :... | source code

Function Details | [hide private]

### _HasSubstructMatchStr(...) | source code
    _HasSubstructMatchStr( (str)pkl, (Mol)query [, (bool)recursionPossible=True [, (bool)useChirality=False]]) -> bool :
        This function is included to speed substructure queries from databases,
        it's probably not of
        general interest.

          ARGUMENTS:
            - pkl: a Molecule pickle

            - query: a Molecule

            - recursionPossible: (optional)

            - useChirality: (optional)

          RETURNS: 1 or 0

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

### FindMolChiralCenters(mol) | source code
    >>> 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(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    GetFormalCharge( (Mol)arg1) -> int :
        Returns the formal charge for the molecule.

          ARGUMENTS:

            - mol: the molecule to use

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

### GetMolFrags(...) | source code
    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])

### GetPeriodicTable() | source code
        Returns the application's PeriodicTable instance.

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

### GetSSSR(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    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(...) | source code
    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*)

### tossit() | source code
        C++ signature :
            void tossit()
  Returns:
      None :