rdkit.Chem.rdchem.Mol

Package rdkit :: Package Chem :: Module rdchem :: Class Mol |
[hide private]
[frames] | no frames]

# Class Mol

     object --+
              |
    ??.instance --+
                  |
                 Mol

Known Subclasses:
  - PropertyMol.PropertyMol
  - , RWMol

    The Molecule class.

    In addition to the expected Atoms and Bonds, molecules contain:
      - a collection of Atom and Bond bookmarks indexed with integers
          that can be used to flag and retrieve particular Atoms or Bonds
          using the {get|set}{Atom|Bond}Bookmark() methods.

      - a set of string-valued properties. These can have arbitrary string
          labels and can be set and retrieved using the {set|get}Prop() methods
          Molecular properties can be tagged as being *computed*, in which case
            they will be automatically cleared under certain circumstances (when the
            molecule itself is modified, for example).
          Molecules also have the concept of *private* properties, which are tagged
            by beginning the property name with an underscore (_).

Instance Methods | [hide private]
AddConformer(...) AddConformer( (Mol)self, (Conformer)conf [, (bool)assignId=False]) -> int : Add a conformer to the molecule and return the conformer ID |
ClearComputedProps(...) ClearComputedProps( (Mol)arg1) -> None : Removes all computed properties from the molecule. |
ClearProp(...) ClearProp( (Mol)arg1, (str)arg2) -> None : Removes a property from the molecule. |
Compute2DCoords(...) Compute2DCoords( (Mol)mol [, (bool)canonOrient=True [, (bool)clearConfs=True [, (dict)coordMap={} [, (int)nFlipsPerSample=0 [, (int)nSample=0 [, (int)sampleSeed=0 [, (bool)permuteDeg4Nodes=False [, (float)bondLength=-1.0]]]]]]]]) -> int : Compute 2D coordinates for a molecule. |
ComputeGasteigerCharges(...) ComputeGasteigerCharges( (Mol)mol [, (int)nIter=12 [, (bool)throwOnParamFailure=False]]) -> None : Compute Gasteiger partial charges for molecule |
Debug(...) Debug( (Mol)mol [, (bool)useStdout=True]) -> None : Prints debugging information about the molecule. |
GetAromaticAtoms(...) GetAromaticAtoms( (Mol)arg1) -> _ROQAtomSeq : Returns a read-only sequence containing all of the molecule's aromatic Atoms. |
GetAtomWithIdx(...) GetAtomWithIdx( (Mol)arg1, (int)arg2) -> Atom : Returns a particular Atom. |
GetAtoms(...) GetAtoms( (Mol)arg1) -> _ROAtomSeq : Returns a read-only sequence containing all of the molecule's Atoms. |
GetAtomsMatchingQuery(...) GetAtomsMatchingQuery( (Mol)arg1, (QueryAtom)arg2) -> _ROQAtomSeq : Returns a read-only sequence containing all of the atoms in a molecule that match the query atom. |
GetBondBetweenAtoms(...) GetBondBetweenAtoms( (Mol)arg1, (int)arg2, (int)arg3) -> Bond : Returns the bond between two atoms, if there is one. |
GetBondWithIdx(...) GetBondWithIdx( (Mol)arg1, (int)arg2) -> Bond : Returns a particular Bond. |
GetBonds(...) GetBonds( (Mol)arg1) -> _ROBondSeq : Returns a read-only sequence containing all of the molecule's Bonds. |
GetBoolProp(...) GetBoolProp( (Mol)arg1, (str)arg2) -> bool : Returns the double value of the property if possible. |
GetConformer(...) GetConformer( (Mol)self [, (int)id=-1]) -> Conformer : Get the conformer with a specified ID |
GetConformers(...) GetConformers( (Mol)arg1) -> object : Get all the conformers as a tuple |
GetDoubleProp(...) GetDoubleProp( (Mol)arg1, (str)arg2) -> float : Returns the double value of the property if possible. |
GetIntProp(...) GetIntProp( (Mol)arg1, (str)arg2) -> int : Returns the integer value of the property if possible. |
GetNumAtoms(...) GetNumAtoms( (Mol)arg1 [, (int)onlyHeavy=-1 [, (bool)onlyExplicit=True]]) -> int : Returns the number of atoms in the molecule. |
GetNumBonds(...) GetNumBonds( (Mol)arg1 [, (bool)onlyHeavy=True]) -> int : Returns the number of Bonds in the molecule. |
GetNumConformers(...) GetNumConformers( (Mol)arg1) -> int : Return the number of conformations on the molecule |
GetNumHeavyAtoms(...) GetNumHeavyAtoms( (Mol)arg1) -> int : Returns the number of heavy atoms (atomic number >1) in the molecule. |
GetProp(...) GetProp( (Mol)arg1, (str)arg2) -> str : Returns the value of the property. |
GetPropNames(...) GetPropNames( (Mol)self [, (bool)includePrivate=False [, (bool)includeComputed=False]]) -> _vectSs : Returns a tuple with all property names for this molecule. |
GetPropsAsDict(...) GetPropsAsDict( (Mol)self [, (bool)includePrivate=False [, (bool)includeComputed=False]]) -> dict : Returns a dictionary populated with the molecules properties. |
GetRingInfo(...) GetRingInfo( (Mol)arg1) -> RingInfo : Returns the number of molecule's RingInfo object. |
GetSubstructMatch(...) GetSubstructMatch( (Mol)self, (Mol)query [, (bool)useChirality=False [, (bool)useQueryQueryMatches=False]]) -> object : Returns the indices of the molecule's atoms that match a substructure query. |
GetSubstructMatches(...) GetSubstructMatches( (Mol)self, (Mol)query [, (bool)uniquify=True [, (bool)useChirality=False [, (bool)useQueryQueryMatches=False [, (int)maxMatches=1000]]]]) -> object : Returns tuples of the indices of the molecule's atoms that match a substructure query. |
GetUnsignedProp(...) GetUnsignedProp( (Mol)arg1, (str)arg2) -> int : Returns the unsigned int value of the property if possible. |
HasProp(...) HasProp( (Mol)arg1, (str)arg2) -> int : Queries a molecule to see if a particular property has been assigned. |
HasSubstructMatch(...) HasSubstructMatch( (Mol)self, (Mol)query [, (bool)recursionPossible=True [, (bool)useChirality=False [, (bool)useQueryQueryMatches=False]]]) -> bool : Queries whether or not the molecule contains a particular substructure. |
NeedsUpdatePropertyCache(...) NeedsUpdatePropertyCache( (Mol)self) -> bool : Returns true or false depending on whether implicit and explicit valence of the molecule have already been calculated. |
RemoveAllConformers(...) RemoveAllConformers( (Mol)arg1) -> None : Remove all the conformations on the molecule |
RemoveConformer(...) RemoveConformer( (Mol)arg1, (int)arg2) -> None : Remove the conformer with the specified ID |
SetBoolProp(...) SetBoolProp( (Mol)self, (str)key, (bool)val [, (bool)computed=False]) -> None : Sets a boolean valued molecular property |
SetDoubleProp(...) SetDoubleProp( (Mol)self, (str)key, (float)val [, (bool)computed=False]) -> None : Sets a double valued molecular property |
SetIntProp(...) SetIntProp( (Mol)self, (str)key, (int)val [, (bool)computed=False]) -> None : Sets an integer valued molecular property |
SetProp(...) SetProp( (Mol)self, (str)key, (str)val [, (bool)computed=False]) -> None : Sets a molecular property |
SetUnsignedProp(...) SetUnsignedProp( (Mol)self, (str)key, (int)val [, (bool)computed=False]) -> None : Sets an unsigned integer valued molecular property |
ToBinary(...) ToBinary( (Mol)arg1) -> object : Returns a binary string representation of the molecule. |
UpdatePropertyCache(...) UpdatePropertyCache( (Mol)self [, (bool)strict=True]) -> None : Regenerates computed properties like implicit valence and ring information. |
__copy__(...) __copy__( (AtomPairsParameters)arg1) -> object : |
__deepcopy__(...) __deepcopy__( (AtomPairsParameters)arg1, (dict)arg2) -> object : |
__ge__(x, y) Allows for substructure check using the >= operator (X has substructure Y -> X >= Y) by... | source code
__getinitargs__(...) __getinitargs__( (Mol)arg1) -> tuple : |
__init__(...) __init__( (object)arg1) -> None : Constructor, takes no arguments |
__reduce__(...) helper for pickle |
__str__(x, renderer=None) returns the molecules as base64 encoded PNG image... | source code
Inherited from `unreachable.instance`: `__new__` Inherited from `object`: `__delattr__`, `__format__`, `__getattribute__`, `__hash__`, `__reduce_ex__`, `__repr__`, `__setattr__`, `__sizeof__`, `__subclasshook__`

Class Variables | [hide private]
| __instance_size__ = `32`
| __safe_for_unpickling__ = `True`

Properties | [hide private]
Inherited from `object`: `__class__`

Method Details | [hide private]

### AddConformer(...) |
    AddConformer( (Mol)self, (Conformer)conf [, (bool)assignId=False]) -> int :
        Add a conformer to the molecule and return the conformer ID

        C++ signature :
            unsigned int AddConformer(RDKit::ROMol {lvalue},RDKit::Conformer* [,bool=False])

### ClearComputedProps(...) |
    ClearComputedProps( (Mol)arg1) -> None :
        Removes all computed properties from the molecule.

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

### ClearProp(...) |
    ClearProp( (Mol)arg1, (str)arg2) -> None :
        Removes a property from the molecule.

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

        C++ signature :
            void ClearProp(RDKit::ROMol,char const*)

### Compute2DCoords(...) |
    Compute2DCoords( (Mol)mol [, (bool)canonOrient=True [, (bool)clearConfs=True [, (dict)coordMap={} [, (int)nFlipsPerSample=0 [, (int)nSample=0 [, (int)sampleSeed=0 [, (bool)permuteDeg4Nodes=False [, (float)bondLength=-1.0]]]]]]]]) -> int :
        Compute 2D coordinates for a molecule.
          The resulting coordinates are stored on each atom of the molecule

          ARGUMENTS:

             mol - the molecule of interest
             canonOrient - orient the molecule in a canonical way
             clearConfs - if true, all existing conformations on the molecule
                     will be cleared
             coordMap - a dictionary mapping atom Ids -> Point2D objects
                        with starting coordinates for atoms that should
                        have their positions locked.
             nFlipsPerSample - number of rotatable bonds that are
                        flipped at random at a time.
             nSample - Number of random samplings of rotatable bonds.
             sampleSeed - seed for the random sampling process.
             permuteDeg4Nodes - allow permutation of bonds at a degree 4
                         node during the sampling process
             bondLength - change the default bond length for depiction

          RETURNS:

             ID of the conformation added to the molecule

        C++ signature :
            unsigned int Compute2DCoords(RDKit::ROMol {lvalue} [,bool=True [,bool=True [,boost::python::dict {lvalue}={} [,unsigned int=0 [,unsigned int=0 [,int=0 [,bool=False [,double=-1.0]]]]]]]])

### ComputeGasteigerCharges(...) |
    ComputeGasteigerCharges( (Mol)mol [, (int)nIter=12 [, (bool)throwOnParamFailure=False]]) -> None :
        Compute Gasteiger partial charges for molecule

         The charges are computed using an iterative procedure presented in

         Ref : J.Gasteiger, M. Marseli, Iterative Equalization of Oribital Electronegatiity
         A Rapid Access to Atomic Charges, Tetrahedron Vol 36 p3219 1980

         The computed charges are stored on each atom are stored a computed property ( under the name
         _GasteigerCharge). In addition, each atom also stored the total charge for the implicit hydrogens
         on the atom (under the property name _GasteigerHCharge)

         ARGUMENTS:

            - mol : the molecule of interrest
            - nIter : number of iteration (defaults to 12)
            - throwOnParamFailure : toggles whether or not an exception should be raised if parameters
              for an atom cannot be found.  If this is false (the default), all parameters for unknown
              atoms will be set to zero.  This has the effect of removing that atom from the iteration.

        C++ signature :
            void ComputeGasteigerCharges(RDKit::ROMol const* [,int=12 [,bool=False]])

### Debug(...) |
    Debug( (Mol)mol [, (bool)useStdout=True]) -> None :
        Prints debugging information about the molecule.

        C++ signature :
            void Debug(RDKit::ROMol [,bool=True])

### GetAromaticAtoms(...) |
    GetAromaticAtoms( (Mol)arg1) -> _ROQAtomSeq :
        Returns a read-only sequence containing all of the molecule's aromatic Atoms.

        C++ signature :
            RDKit::ReadOnlySeq<RDKit::QueryAtomIterator_<RDKit::Atom, RDKit::ROMol>, RDKit::Atom*, RDKit::AtomCountFunctor>* GetAromaticAtoms(RDKit::ROMol*)

### GetAtomWithIdx(...) |
    GetAtomWithIdx( (Mol)arg1, (int)arg2) -> Atom :
        Returns a particular Atom.

          ARGUMENTS:
            - idx: which Atom to return

          NOTE: atom indices start at 0

        C++ signature :
            RDKit::Atom* GetAtomWithIdx(RDKit::ROMol {lvalue},unsigned int)

### GetAtoms(...) |
    GetAtoms( (Mol)arg1) -> _ROAtomSeq :
        Returns a read-only sequence containing all of the molecule's Atoms.

        C++ signature :
            RDKit::ReadOnlySeq<RDKit::AtomIterator_<RDKit::Atom, RDKit::ROMol>, RDKit::Atom*, RDKit::AtomCountFunctor>* GetAtoms(RDKit::ROMol*)

### GetAtomsMatchingQuery(...) |
    GetAtomsMatchingQuery( (Mol)arg1, (QueryAtom)arg2) -> _ROQAtomSeq :
        Returns a read-only sequence containing all of the atoms in a molecule that match the query atom.

        C++ signature :
            RDKit::ReadOnlySeq<RDKit::QueryAtomIterator_<RDKit::Atom, RDKit::ROMol>, RDKit::Atom*, RDKit::AtomCountFunctor>* GetAtomsMatchingQuery(RDKit::ROMol*,RDKit::QueryAtom*)

### GetBondBetweenAtoms(...) |
    GetBondBetweenAtoms( (Mol)arg1, (int)arg2, (int)arg3) -> Bond :
        Returns the bond between two atoms, if there is one.

          ARGUMENTS:
            - idx1,idx2: the Atom indices

          Returns:
            The Bond between the two atoms, if such a bond exists.
            If there is no Bond between the atoms, None is returned instead.

          NOTE: bond indices start at 0

        C++ signature :
            RDKit::Bond* GetBondBetweenAtoms(RDKit::ROMol {lvalue},unsigned int,unsigned int)

### GetBondWithIdx(...) |
    GetBondWithIdx( (Mol)arg1, (int)arg2) -> Bond :
        Returns a particular Bond.

          ARGUMENTS:
            - idx: which Bond to return

          NOTE: bond indices start at 0

        C++ signature :
            RDKit::Bond* GetBondWithIdx(RDKit::ROMol {lvalue},unsigned int)

### GetBonds(...) |
    GetBonds( (Mol)arg1) -> _ROBondSeq :
        Returns a read-only sequence containing all of the molecule's Bonds.

        C++ signature :
            RDKit::ReadOnlySeq<RDKit::BondIterator_, RDKit::Bond*, RDKit::BondCountFunctor>* GetBonds(RDKit::ROMol*)

### GetBoolProp(...) |
    GetBoolProp( (Mol)arg1, (str)arg2) -> bool :
        Returns the double value of the property if possible.

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

          RETURNS: a bool

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

        C++ signature :
            bool GetBoolProp(RDKit::ROMol*,char const*)

### GetConformer(...) |
    GetConformer( (Mol)self [, (int)id=-1]) -> Conformer :
        Get the conformer with a specified ID

        C++ signature :
            RDKit::Conformer* GetConformer(RDKit::ROMol {lvalue} [,int=-1])

### GetConformers(...) |
    GetConformers( (Mol)arg1) -> object :
        Get all the conformers as a tuple

        C++ signature :
            _object* GetConformers(RDKit::ROMol {lvalue})

### GetDoubleProp(...) |
    GetDoubleProp( (Mol)arg1, (str)arg2) -> float :
        Returns the double value of the property if possible.

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

          RETURNS: a double

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

        C++ signature :
            double GetDoubleProp(RDKit::ROMol*,char const*)

### GetIntProp(...) |
    GetIntProp( (Mol)arg1, (str)arg2) -> int :
        Returns the integer value of the property if possible.

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

          RETURNS: an integer

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

        C++ signature :
            int GetIntProp(RDKit::ROMol*,char const*)

### GetNumAtoms(...) |
    GetNumAtoms( (Mol)arg1 [, (int)onlyHeavy=-1 [, (bool)onlyExplicit=True]]) -> int :
        Returns the number of atoms in the molecule.

          ARGUMENTS:
            - onlyExplicit: (optional) include only explicit atoms (atoms in the molecular graph)
                            defaults to 1.
          NOTE: the onlyHeavy argument is deprecated

        C++ signature :
            int GetNumAtoms(RDKit::ROMol [,int=-1 [,bool=True]])

### GetNumBonds(...) |
    GetNumBonds( (Mol)arg1 [, (bool)onlyHeavy=True]) -> int :
        Returns the number of Bonds in the molecule.

          ARGUMENTS:
            - onlyHeavy: (optional) include only bonds to heavy atoms (not Hs)
                          defaults to 1.

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

### GetNumConformers(...) |
    GetNumConformers( (Mol)arg1) -> int :
        Return the number of conformations on the molecule

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

### GetNumHeavyAtoms(...) |
    GetNumHeavyAtoms( (Mol)arg1) -> int :
        Returns the number of heavy atoms (atomic number >1) in the molecule.

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

### GetProp(...) |
    GetProp( (Mol)arg1, (str)arg2) -> str :
        Returns the value of the property.

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

          RETURNS: a string

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

        C++ signature :
            std::string GetProp(RDKit::ROMol*,char const*)

### GetPropNames(...) |
    GetPropNames( (Mol)self [, (bool)includePrivate=False [, (bool)includeComputed=False]]) -> _vectSs :
        Returns a tuple with all property names for this molecule.

          ARGUMENTS:
            - includePrivate: (optional) toggles inclusion of private properties in the result set.
                              Defaults to 0.
            - includeComputed: (optional) toggles inclusion of computed properties in the result set.
                              Defaults to 0.

          RETURNS: a tuple of strings

        C++ signature :
            std::vector<std::string, std::allocator<std::string> > GetPropNames(RDKit::ROMol {lvalue} [,bool=False [,bool=False]])

### GetPropsAsDict(...) |
    GetPropsAsDict( (Mol)self [, (bool)includePrivate=False [, (bool)includeComputed=False]]) -> dict :
        Returns a dictionary populated with the molecules properties.
         n.b. Some properties are not able to be converted to python types.

          ARGUMENTS:
            - includePrivate: (optional) toggles inclusion of private properties in the result set.
                              Defaults to False.
            - includeComputed: (optional) toggles inclusion of computed properties in the result set.
                              Defaults to False.

          RETURNS: a dictionary

        C++ signature :
            boost::python::dict GetPropsAsDict(RDKit::ROMol [,bool=False [,bool=False]])

### GetRingInfo(...) |
    GetRingInfo( (Mol)arg1) -> RingInfo :
        Returns the number of molecule's RingInfo object.

        C++ signature :
            RDKit::RingInfo* GetRingInfo(RDKit::ROMol {lvalue})

### GetSubstructMatch(...) |
    GetSubstructMatch( (Mol)self, (Mol)query [, (bool)useChirality=False [, (bool)useQueryQueryMatches=False]]) -> object :
        Returns the indices of the molecule's atoms that match a substructure query.

          ARGUMENTS:
            - query: a Molecule

            - useChirality: enables the use of stereochemistry in the matching

            - useQueryQueryMatches: use query-query matching logic

          RETURNS: a tuple of integers

          NOTES:
             - only a single match is returned
             - the ordering of the indices corresponds to the atom ordering
                 in the query. For example, the first index is for the atom in
                 this molecule that matches the first atom in the query.

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

    GetSubstructMatch( (Mol)self, (MolBundle)query [, (bool)useChirality=False [, (bool)useQueryQueryMatches=False]]) -> object :

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

### GetSubstructMatches(...) |
    GetSubstructMatches( (Mol)self, (Mol)query [, (bool)uniquify=True [, (bool)useChirality=False [, (bool)useQueryQueryMatches=False [, (int)maxMatches=1000]]]]) -> object :
        Returns tuples of the indices of the molecule's atoms that match a substructure query.

          ARGUMENTS:
            - query: a Molecule.
            - uniquify: (optional) determines whether or not the matches are uniquified.
                        Defaults to 1.

            - useChirality: enables the use of stereochemistry in the matching

            - useQueryQueryMatches: use query-query matching logic

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

          RETURNS: a tuple of tuples of integers

          NOTE:
             - the ordering of the indices corresponds to the atom ordering
                 in the query. For example, the first index is for the atom in
                 this molecule that matches the first atom in the query.

        C++ signature :
            _object* GetSubstructMatches(RDKit::ROMol,RDKit::ROMol [,bool=True [,bool=False [,bool=False [,unsigned int=1000]]]])

    GetSubstructMatches( (Mol)self, (MolBundle)query [, (bool)uniquify=True [, (bool)useChirality=False [, (bool)useQueryQueryMatches=False [, (int)maxMatches=1000]]]]) -> object :

        C++ signature :
            _object* GetSubstructMatches(RDKit::ROMol,RDKit::MolBundle [,bool=True [,bool=False [,bool=False [,unsigned int=1000]]]])

### GetUnsignedProp(...) |
    GetUnsignedProp( (Mol)arg1, (str)arg2) -> int :
        Returns the unsigned int value of the property if possible.

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

          RETURNS: an unsigned integer

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

        C++ signature :
            unsigned int GetUnsignedProp(RDKit::ROMol*,char const*)

### HasProp(...) |
    HasProp( (Mol)arg1, (str)arg2) -> int :
        Queries a molecule to see if a particular property has been assigned.

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

        C++ signature :
            int HasProp(RDKit::ROMol,char const*)

### HasSubstructMatch(...) |
    HasSubstructMatch( (Mol)self, (Mol)query [, (bool)recursionPossible=True [, (bool)useChirality=False [, (bool)useQueryQueryMatches=False]]]) -> bool :
        Queries whether or not the molecule contains a particular substructure.

          ARGUMENTS:
            - query: a Molecule

            - recursionPossible: (optional)

            - useChirality: enables the use of stereochemistry in the matching

            - useQueryQueryMatches: use query-query matching logic

          RETURNS: True or False

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

    HasSubstructMatch( (Mol)self, (MolBundle)query [, (bool)recursionPossible=True [, (bool)useChirality=False [, (bool)useQueryQueryMatches=False]]]) -> bool :

        C++ signature :
            bool HasSubstructMatch(RDKit::ROMol,RDKit::MolBundle [,bool=True [,bool=False [,bool=False]]])

### NeedsUpdatePropertyCache(...) |
    NeedsUpdatePropertyCache( (Mol)self) -> bool :
        Returns true or false depending on whether implicit and explicit valence of the molecule have already been calculated.

        C++ signature :
            bool NeedsUpdatePropertyCache(RDKit::ROMol {lvalue})

### RemoveAllConformers(...) |
    RemoveAllConformers( (Mol)arg1) -> None :
        Remove all the conformations on the molecule

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

### RemoveConformer(...) |
    RemoveConformer( (Mol)arg1, (int)arg2) -> None :
        Remove the conformer with the specified ID

        C++ signature :
            void RemoveConformer(RDKit::ROMol {lvalue},unsigned int)

### SetBoolProp(...) |
    SetBoolProp( (Mol)self, (str)key, (bool)val [, (bool)computed=False]) -> None :
        Sets a boolean valued molecular property

          ARGUMENTS:
            - key: the name of the property to be set (a string).
            - value: the property value as a bool.
            - computed: (optional) marks the property as being computed.
                        Defaults to False.

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

### SetDoubleProp(...) |
    SetDoubleProp( (Mol)self, (str)key, (float)val [, (bool)computed=False]) -> None :
        Sets a double valued molecular property

          ARGUMENTS:
            - key: the name of the property to be set (a string).
            - value: the property value as a double.
            - computed: (optional) marks the property as being computed.
                        Defaults to 0.

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

### SetIntProp(...) |
    SetIntProp( (Mol)self, (str)key, (int)val [, (bool)computed=False]) -> None :
        Sets an integer valued molecular property

          ARGUMENTS:
            - key: the name of the property to be set (an unsigned number).
            - value: the property value as an integer.
            - computed: (optional) marks the property as being computed.
                        Defaults to False.

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

### SetProp(...) |
    SetProp( (Mol)self, (str)key, (str)val [, (bool)computed=False]) -> None :
        Sets a molecular property

          ARGUMENTS:
            - key: the name of the property to be set (a string).
            - value: the property value (a string).
            - computed: (optional) marks the property as being computed.
                        Defaults to False.

        C++ signature :
            void SetProp(RDKit::ROMol,char const*,std::string [,bool=False])

### SetUnsignedProp(...) |
    SetUnsignedProp( (Mol)self, (str)key, (int)val [, (bool)computed=False]) -> None :
        Sets an unsigned integer valued molecular property

          ARGUMENTS:
            - key: the name of the property to be set (a string).
            - value: the property value as an unsigned integer.
            - computed: (optional) marks the property as being computed.
                        Defaults to False.

        C++ signature :
            void SetUnsignedProp(RDKit::ROMol,char const*,unsigned int [,bool=False])

### ToBinary(...) |
    ToBinary( (Mol)arg1) -> object :
        Returns a binary string representation of the molecule.

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

    ToBinary( (Mol)mol, (int)propertyFlags) -> object :
        Returns a binary string representation of the molecule pickling the specified properties.

        C++ signature :
            boost::python::api::object ToBinary(RDKit::ROMol,unsigned int)

### UpdatePropertyCache(...) |
    UpdatePropertyCache( (Mol)self [, (bool)strict=True]) -> None :
        Regenerates computed properties like implicit valence and ring information.

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

### __copy__(...) |
    __copy__( (AtomPairsParameters)arg1) -> object :

        C++ signature :
            boost::python::api::object __copy__(boost::python::api::object)

### __deepcopy__(...) |
    __deepcopy__( (AtomPairsParameters)arg1, (dict)arg2) -> object :

        C++ signature :
            boost::python::api::object __deepcopy__(boost::python::api::object,boost::python::dict)

### __ge__(x, y) (Greater-than-or-equals operator) | source code
    Allows for substructure check using the >= operator (X has substructure Y -> X >= Y) by
    monkey-patching the __ge__ function
    This has the effect that the pandas/numpy rowfilter can be used for substructure filtering
    (filtered = dframe[dframe['RDKitColumn'] >= SubstructureMolecule])

### __getinitargs__(...) |
    __getinitargs__( (Mol)arg1) -> tuple :

        C++ signature :
            boost::python::tuple __getinitargs__(RDKit::ROMol)

### __init__(...) (Constructor) |
    __init__( (object)arg1) -> None :
        Constructor, takes no arguments

        C++ signature :
            void __init__(_object*)

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

        C++ signature :
            void __init__(_object*,std::string)

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

        C++ signature :
            void __init__(_object*,RDKit::ROMol)

    __init__( (object)arg1, (Mol)arg2, (bool)arg3) -> None :

        C++ signature :
            void __init__(_object*,RDKit::ROMol,bool)

    __init__( (object)arg1, (Mol)arg2, (bool)arg3, (int)arg4) -> None :

        C++ signature :
            void __init__(_object*,RDKit::ROMol,bool,int)
Overrides: object.__init__

### __reduce__(...) |
    helper for pickle
Overrides: object.__reduce__ (inherited documentation)

### __str__(x, renderer=None) (Informal representation operator) | source code
    returns the molecules as base64 encoded PNG image
Overrides: object.__str__