rdkit.Chem.rdMolDescriptors module — The RDKit 2025.09.6 documentation

# rdkit.Chem.rdMolDescriptors module

Module containing functions to compute molecular descriptors

class rdkit.Chem.rdMolDescriptors.AtomPairsParameters((object)arg1) → None :

  Bases: `instance`

  C++ signature :

    void __init__(_object*)

  atomTypes = <rdkit.rdBase._vectj object>
  codeSize = 9
  numAtomPairFingerprintBits = 23
  numBranchBits = 3
  numChiralBits = 2
  numPathBits = 5
  numPiBits = 2
  numTypeBits = 4
  version = '1.1.0'

rdkit.Chem.rdMolDescriptors.BCUT2D((rdkit.Chem.rdchem.Mol)mol) → list :
  Implements BCUT descriptors From J. Chem. Inf. Comput. Sci., Vol. 39, No. 1, 1999Diagonal elements are (currently) atomic mass, gasteiger charge,crippen logP and crippen MRReturns the 2D BCUT2D descriptors vector as described in
    returns [mass eigen value high, mass eigen value low,

      gasteiger charge eigenvalue high, gasteiger charge low, crippen lowgp eigenvalue high, crippen lowgp low, crippen mr eigenvalue high, crippen mr low]

    C++ signature :

      boost::python::list BCUT2D(RDKit::ROMol)

  BCUT2D( (rdkit.Chem.rdchem.Mol)mol, (list)atom_props) -> tuple :
    Returns a 2D BCUT (eigen value hi, eigenvalue low) given the molecule and the specified atom props

      atom_props must be a list or tuple of floats equal in size to the number of atoms in mol

    C++ signature :

      std::pair<double, double> BCUT2D(RDKit::ROMol,boost::python::list)

  BCUT2D( (rdkit.Chem.rdchem.Mol)mol, (tuple)atom_props) -> tuple :
    Returns a 2D BCUT (eigen value hi, eigenvalue low) given the molecule and the specified atom props

      atom_props must be a list or tuple of floats equal in size to the number of atoms in mol

    C++ signature :

      std::pair<double, double> BCUT2D(RDKit::ROMol,boost::python::tuple)

  BCUT2D( (rdkit.Chem.rdchem.Mol)mol, (str)atom_propname) -> tuple :

    Returns a 2D BCUT (eigen value high, eigen value low) given the molecule and the specified atom prop name atom_propname must exist on each atom and be convertible to a float

    C++ signature :

      std::pair<double, double> BCUT2D(RDKit::ROMol,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

rdkit.Chem.rdMolDescriptors.CalcAUTOCORR2D((rdkit.Chem.rdchem.Mol)mol[, (str)CustomAtomProperty='']) → list :

  Returns 2D Autocorrelation descriptors vector

  C++ signature :

    boost::python::list CalcAUTOCORR2D(RDKit::ROMol [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >=’’])

rdkit.Chem.rdMolDescriptors.CalcAUTOCORR3D((rdkit.Chem.rdchem.Mol)mol[, (int)confId=-1[, (str)CustomAtomProperty='']]) → list :

  Returns 3D Autocorrelation descriptors vector

  C++ signature :

    boost::python::list CalcAUTOCORR3D(RDKit::ROMol [,int=-1 [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >=’’]])

rdkit.Chem.rdMolDescriptors.CalcAsphericity((rdkit.Chem.rdchem.Mol)mol[, (int)confId=-1[, (bool)useAtomicMasses=True[, (bool)force=True]]]) → float :
  C++ signature :

    double CalcAsphericity(RDKit::ROMol [,int=-1 [,bool=True [,bool=True]]])

rdkit.Chem.rdMolDescriptors.CalcChi0n((rdkit.Chem.rdchem.Mol)mol[, (bool)force=False]) → float :
  C++ signature :

    double CalcChi0n(RDKit::ROMol [,bool=False])

rdkit.Chem.rdMolDescriptors.CalcChi0v((rdkit.Chem.rdchem.Mol)mol[, (bool)force=False]) → float :
  C++ signature :

    double CalcChi0v(RDKit::ROMol [,bool=False])

rdkit.Chem.rdMolDescriptors.CalcChi1n((rdkit.Chem.rdchem.Mol)mol[, (bool)force=False]) → float :
  C++ signature :

    double CalcChi1n(RDKit::ROMol [,bool=False])

rdkit.Chem.rdMolDescriptors.CalcChi1v((rdkit.Chem.rdchem.Mol)mol[, (bool)force=False]) → float :
  C++ signature :

    double CalcChi1v(RDKit::ROMol [,bool=False])

rdkit.Chem.rdMolDescriptors.CalcChi2n((rdkit.Chem.rdchem.Mol)mol[, (bool)force=False]) → float :
  C++ signature :

    double CalcChi2n(RDKit::ROMol [,bool=False])

rdkit.Chem.rdMolDescriptors.CalcChi2v((rdkit.Chem.rdchem.Mol)mol[, (bool)force=False]) → float :
  C++ signature :

    double CalcChi2v(RDKit::ROMol [,bool=False])

rdkit.Chem.rdMolDescriptors.CalcChi3n((rdkit.Chem.rdchem.Mol)mol[, (bool)force=False]) → float :
  C++ signature :

    double CalcChi3n(RDKit::ROMol [,bool=False])

rdkit.Chem.rdMolDescriptors.CalcChi3v((rdkit.Chem.rdchem.Mol)mol[, (bool)force=False]) → float :
  C++ signature :

    double CalcChi3v(RDKit::ROMol [,bool=False])

rdkit.Chem.rdMolDescriptors.CalcChi4n((rdkit.Chem.rdchem.Mol)mol[, (bool)force=False]) → float :
  C++ signature :

    double CalcChi4n(RDKit::ROMol [,bool=False])

rdkit.Chem.rdMolDescriptors.CalcChi4v((rdkit.Chem.rdchem.Mol)mol[, (bool)force=False]) → float :
  C++ signature :

    double CalcChi4v(RDKit::ROMol [,bool=False])

rdkit.Chem.rdMolDescriptors.CalcChiNn((rdkit.Chem.rdchem.Mol)mol, (int)n[, (bool)force=False]) → float :
  C++ signature :

    double CalcChiNn(RDKit::ROMol,unsigned int [,bool=False])

rdkit.Chem.rdMolDescriptors.CalcChiNv((rdkit.Chem.rdchem.Mol)mol, (int)n[, (bool)force=False]) → float :
  C++ signature :

    double CalcChiNv(RDKit::ROMol,unsigned int [,bool=False])

rdkit.Chem.rdMolDescriptors.CalcCoulombMat((rdkit.Chem.rdchem.Mol)mol[, (int)confId=-1]) → tuple :

  Returns severals Coulomb randomized matrices

  C++ signature :

    boost::python::tuple CalcCoulombMat(RDKit::ROMol [,int=-1])

rdkit.Chem.rdMolDescriptors.CalcCrippenDescriptors((rdkit.Chem.rdchem.Mol)mol[, (bool)includeHs=True[, (bool)force=False]]) → tuple :

  returns a 2-tuple with the Wildman-Crippen logp,mr values

  C++ signature :

    boost::python::tuple CalcCrippenDescriptors(RDKit::ROMol [,bool=True [,bool=False]])

rdkit.Chem.rdMolDescriptors.CalcEEMcharges((rdkit.Chem.rdchem.Mol)mol[, (int)confId=-1]) → list :

  Returns EEM atomic partial charges

  C++ signature :

    boost::python::list CalcEEMcharges(RDKit::ROMol {lvalue} [,int=-1])

rdkit.Chem.rdMolDescriptors.CalcEccentricity((rdkit.Chem.rdchem.Mol)mol[, (int)confId=-1[, (bool)useAtomicMasses=True[, (bool)force=True]]]) → float :
  C++ signature :

    double CalcEccentricity(RDKit::ROMol [,int=-1 [,bool=True [,bool=True]]])

rdkit.Chem.rdMolDescriptors.CalcExactMolWt((rdkit.Chem.rdchem.Mol)mol[, (bool)onlyHeavy=False]) → float :

  returns the molecule’s exact molecular weight

  C++ signature :

    double CalcExactMolWt(RDKit::ROMol [,bool=False])

rdkit.Chem.rdMolDescriptors.CalcFractionCSP3((rdkit.Chem.rdchem.Mol)mol) → float :

  returns the fraction of C atoms that are SP3 hybridized

  C++ signature :

    double CalcFractionCSP3(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcGETAWAY((rdkit.Chem.rdchem.Mol)mol[, (int)confId=-1[, (float)precision=2[, (str)CustomAtomProperty='']]]) → list :

  Returns the GETAWAY descriptors vector

  C++ signature :

    boost::python::list CalcGETAWAY(RDKit::ROMol [,int=-1 [,double=2 [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >=’’]]])

rdkit.Chem.rdMolDescriptors.CalcHallKierAlpha((rdkit.Chem.rdchem.Mol)mol[, (AtomPairsParameters)atomContribs=None]) → float :
  C++ signature :

    double CalcHallKierAlpha(RDKit::ROMol [,boost::python::api::object=None])

rdkit.Chem.rdMolDescriptors.CalcInertialShapeFactor((rdkit.Chem.rdchem.Mol)mol[, (int)confId=-1[, (bool)useAtomicMasses=True[, (bool)force=True]]]) → float :
  C++ signature :

    double CalcInertialShapeFactor(RDKit::ROMol [,int=-1 [,bool=True [,bool=True]]])

rdkit.Chem.rdMolDescriptors.CalcKappa1((rdkit.Chem.rdchem.Mol)mol) → float :
  C++ signature :

    double CalcKappa1(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcKappa2((rdkit.Chem.rdchem.Mol)mol) → float :
  C++ signature :

    double CalcKappa2(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcKappa3((rdkit.Chem.rdchem.Mol)mol) → float :
  C++ signature :

    double CalcKappa3(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcLabuteASA((rdkit.Chem.rdchem.Mol)mol[, (bool)includeHs=True[, (bool)force=False]]) → float :

  returns the Labute ASA value for a molecule

  C++ signature :

    double CalcLabuteASA(RDKit::ROMol [,bool=True [,bool=False]])

rdkit.Chem.rdMolDescriptors.CalcMORSE((rdkit.Chem.rdchem.Mol)mol[, (int)confId=-1[, (str)CustomAtomProperty='']]) → list :

  Returns Molecule Representation of Structures based on Electron diffraction descriptors

  C++ signature :

    boost::python::list CalcMORSE(RDKit::ROMol [,int=-1 [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >=’’]])

rdkit.Chem.rdMolDescriptors.CalcMolFormula((rdkit.Chem.rdchem.Mol)mol[, (bool)separateIsotopes=False[, (bool)abbreviateHIsotopes=True]]) → str :

  returns the molecule’s formula

  C++ signature :

    std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > CalcMolFormula(RDKit::ROMol [,bool=False [,bool=True]])

rdkit.Chem.rdMolDescriptors.CalcNPR1((rdkit.Chem.rdchem.Mol)mol[, (int)confId=-1[, (bool)useAtomicMasses=True[, (bool)force=True]]]) → float :
  C++ signature :

    double CalcNPR1(RDKit::ROMol [,int=-1 [,bool=True [,bool=True]]])

rdkit.Chem.rdMolDescriptors.CalcNPR2((rdkit.Chem.rdchem.Mol)mol[, (int)confId=-1[, (bool)useAtomicMasses=True[, (bool)force=True]]]) → float :
  C++ signature :

    double CalcNPR2(RDKit::ROMol [,int=-1 [,bool=True [,bool=True]]])

rdkit.Chem.rdMolDescriptors.CalcNumAliphaticCarbocycles((rdkit.Chem.rdchem.Mol)mol) → int :

  returns the number of aliphatic (containing at least one non-aromatic bond) carbocycles for a molecule

  C++ signature :

    unsigned int CalcNumAliphaticCarbocycles(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumAliphaticHeterocycles((rdkit.Chem.rdchem.Mol)mol) → int :

  returns the number of aliphatic (containing at least one non-aromatic bond) heterocycles for a molecule

  C++ signature :

    unsigned int CalcNumAliphaticHeterocycles(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumAliphaticRings((rdkit.Chem.rdchem.Mol)mol) → int :

  returns the number of aliphatic (containing at least one non-aromatic bond) rings for a molecule

  C++ signature :

    unsigned int CalcNumAliphaticRings(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumAmideBonds((rdkit.Chem.rdchem.Mol)mol) → int :

  returns the number of amide bonds in a molecule

  C++ signature :

    unsigned int CalcNumAmideBonds(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumAromaticCarbocycles((rdkit.Chem.rdchem.Mol)mol) → int :

  returns the number of aromatic carbocycles for a molecule

  C++ signature :

    unsigned int CalcNumAromaticCarbocycles(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumAromaticHeterocycles((rdkit.Chem.rdchem.Mol)mol) → int :

  returns the number of aromatic heterocycles for a molecule

  C++ signature :

    unsigned int CalcNumAromaticHeterocycles(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumAromaticRings((rdkit.Chem.rdchem.Mol)mol) → int :

  returns the number of aromatic rings for a molecule

  C++ signature :

    unsigned int CalcNumAromaticRings(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumAtomStereoCenters((rdkit.Chem.rdchem.Mol)mol) → int :

  Returns the total number of atomic stereocenters (specified and unspecified)

  C++ signature :

    unsigned int CalcNumAtomStereoCenters(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumAtoms((rdkit.Chem.rdchem.Mol)mol) → int :

  returns the total number of atoms for a molecule

  C++ signature :

    unsigned int CalcNumAtoms(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumBridgeheadAtoms((rdkit.Chem.rdchem.Mol)mol[, (AtomPairsParameters)atoms=None]) → int :

  Returns the number of bridgehead atoms (atoms shared between rings that share at least two bonds)

  C++ signature :

    unsigned int CalcNumBridgeheadAtoms(RDKit::ROMol [,boost::python::api::object=None])

rdkit.Chem.rdMolDescriptors.CalcNumHBA((rdkit.Chem.rdchem.Mol)mol) → int :

  returns the number of H-bond acceptors for a molecule

  C++ signature :

    unsigned int CalcNumHBA(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumHBD((rdkit.Chem.rdchem.Mol)mol) → int :

  returns the number of H-bond donors for a molecule

  C++ signature :

    unsigned int CalcNumHBD(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumHeavyAtoms((rdkit.Chem.rdchem.Mol)mol) → int :

  returns the number of heavy atoms for a molecule

  C++ signature :

    unsigned int CalcNumHeavyAtoms(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumHeteroatoms((rdkit.Chem.rdchem.Mol)mol) → int :

  returns the number of heteroatoms for a molecule

  C++ signature :

    unsigned int CalcNumHeteroatoms(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumHeterocycles((rdkit.Chem.rdchem.Mol)mol) → int :

  returns the number of heterocycles for a molecule

  C++ signature :

    unsigned int CalcNumHeterocycles(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumLipinskiHBA((rdkit.Chem.rdchem.Mol)mol) → int :

  returns the number of Lipinski H-bond acceptors for a molecule

  C++ signature :

    unsigned int CalcNumLipinskiHBA(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumLipinskiHBD((rdkit.Chem.rdchem.Mol)mol) → int :

  returns the number of Lipinski H-bond donors for a molecule

  C++ signature :

    unsigned int CalcNumLipinskiHBD(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumRings((rdkit.Chem.rdchem.Mol)mol) → int :

  returns the number of rings for a molecule

  C++ signature :

    unsigned int CalcNumRings(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumRotatableBonds((rdkit.Chem.rdchem.Mol)mol, (bool)strict) → int :
  returns the number of rotatable bonds for a molecule.

    > strict = NumRotatableBondsOptions.NonStrict - Simple rotatable bond definition. strict = NumRotatableBondsOptions.Strict - (default) does not count things like

    > > amide or ester bonds

    > strict = NumRotatableBondsOptions.StrictLinkages - handles linkages between ring

    >   systems. - Single bonds between aliphatic ring Cs are always rotatable. This

    >   > means that the central bond in CC1CCCC(C)C1-C1C(C)CCCC1C is now considered rotatable; it was not before

    >   - Heteroatoms in the linked rings no longer affect whether or not the linking bond is rotatable

    >   - the linking bond in systems like Cc1cccc(C)c1-c1c(C)cccc1 is now

    >       considered non-rotatable

    C++ signature :

      unsigned int CalcNumRotatableBonds(RDKit::ROMol,bool)

  CalcNumRotatableBonds( (rdkit.Chem.rdchem.Mol)mol [, (NumRotatableBondsOptions)strict=rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.Default]) -> int :
    returns the number of rotatable bonds for a molecule.

      strict = NumRotatableBondsOptions.NonStrict - Simple rotatable bond definition. strict = NumRotatableBondsOptions.Strict - (default) does not count things like

      > amide or ester bonds

      strict = NumRotatableBondsOptions.StrictLinkages - handles linkages between ring

        systems. - Single bonds between aliphatic ring Cs are always rotatable. This

        > means that the central bond in CC1CCCC(C)C1-C1C(C)CCCC1C is now considered rotatable; it was not before

        - Heteroatoms in the linked rings no longer affect whether or not the linking bond is rotatable

        - the linking bond in systems like Cc1cccc(C)c1-c1c(C)cccc1 is now

            considered non-rotatable

    C++ signature :

      unsigned int CalcNumRotatableBonds(RDKit::ROMol [,RDKit::Descriptors::NumRotatableBondsOptions=rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.Default])

rdkit.Chem.rdMolDescriptors.CalcNumSaturatedCarbocycles((rdkit.Chem.rdchem.Mol)mol) → int :

  returns the number of saturated carbocycles for a molecule

  C++ signature :

    unsigned int CalcNumSaturatedCarbocycles(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumSaturatedHeterocycles((rdkit.Chem.rdchem.Mol)mol) → int :

  returns the number of saturated heterocycles for a molecule

  C++ signature :

    unsigned int CalcNumSaturatedHeterocycles(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumSaturatedRings((rdkit.Chem.rdchem.Mol)mol) → int :

  returns the number of saturated rings for a molecule

  C++ signature :

    unsigned int CalcNumSaturatedRings(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcNumSpiroAtoms((rdkit.Chem.rdchem.Mol)mol[, (AtomPairsParameters)atoms=None]) → int :

  Returns the number of spiro atoms (atoms shared between rings that share exactly one atom)

  C++ signature :

    unsigned int CalcNumSpiroAtoms(RDKit::ROMol [,boost::python::api::object=None])

rdkit.Chem.rdMolDescriptors.CalcNumUnspecifiedAtomStereoCenters((rdkit.Chem.rdchem.Mol)mol) → int :

  Returns the number of unspecified atomic stereocenters

  C++ signature :

    unsigned int CalcNumUnspecifiedAtomStereoCenters(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcOxidationNumbers((rdkit.Chem.rdchem.Mol)mol) → None :

  Adds the oxidation number/state to the atoms of a molecule as property OxidationNumber on each atom. Use Pauling electronegativities. This is experimental code, still under development.

  C++ signature :

    void CalcOxidationNumbers(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcPBF((rdkit.Chem.rdchem.Mol)mol[, (int)confId=-1]) → float :

  Returns the PBF (plane of best fit) descriptor (https://doi.org/10.1021/ci300293f)

  C++ signature :

    double CalcPBF(RDKit::ROMol [,int=-1])

rdkit.Chem.rdMolDescriptors.CalcPMI1((rdkit.Chem.rdchem.Mol)mol[, (int)confId=-1[, (bool)useAtomicMasses=True[, (bool)force=True]]]) → float :
  C++ signature :

    double CalcPMI1(RDKit::ROMol [,int=-1 [,bool=True [,bool=True]]])

rdkit.Chem.rdMolDescriptors.CalcPMI2((rdkit.Chem.rdchem.Mol)mol[, (int)confId=-1[, (bool)useAtomicMasses=True[, (bool)force=True]]]) → float :
  C++ signature :

    double CalcPMI2(RDKit::ROMol [,int=-1 [,bool=True [,bool=True]]])

rdkit.Chem.rdMolDescriptors.CalcPMI3((rdkit.Chem.rdchem.Mol)mol[, (int)confId=-1[, (bool)useAtomicMasses=True[, (bool)force=True]]]) → float :
  C++ signature :

    double CalcPMI3(RDKit::ROMol [,int=-1 [,bool=True [,bool=True]]])

rdkit.Chem.rdMolDescriptors.CalcPhi((rdkit.Chem.rdchem.Mol)mol) → float :
  C++ signature :

    double CalcPhi(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.CalcRDF((rdkit.Chem.rdchem.Mol)mol[, (int)confId=-1[, (str)CustomAtomProperty='']]) → list :

  Returns radial distribution fonction descriptors (RDF)

  C++ signature :

    boost::python::list CalcRDF(RDKit::ROMol [,int=-1 [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >=’’]])

rdkit.Chem.rdMolDescriptors.CalcRadiusOfGyration((rdkit.Chem.rdchem.Mol)mol[, (int)confId=-1[, (bool)useAtomicMasses=True[, (bool)force=True]]]) → float :
  C++ signature :

    double CalcRadiusOfGyration(RDKit::ROMol [,int=-1 [,bool=True [,bool=True]]])

rdkit.Chem.rdMolDescriptors.CalcSpherocityIndex((rdkit.Chem.rdchem.Mol)mol[, (int)confId=-1[, (bool)force=True]]) → float :
  C++ signature :

    double CalcSpherocityIndex(RDKit::ROMol [,int=-1 [,bool=True]])

rdkit.Chem.rdMolDescriptors.CalcTPSA((rdkit.Chem.rdchem.Mol)mol[, (bool)force=False[, (bool)includeSandP=False]]) → float :

  returns the TPSA value for a molecule

  C++ signature :

    double CalcTPSA(RDKit::ROMol [,bool=False [,bool=False]])

rdkit.Chem.rdMolDescriptors.CalcWHIM((rdkit.Chem.rdchem.Mol)mol[, (int)confId=-1[, (float)thresh=0.001[, (str)CustomAtomProperty='']]]) → list :

  Returns the WHIM descriptors vector

  C++ signature :

    boost::python::list CalcWHIM(RDKit::ROMol [,int=-1 [,double=0.001 [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >=’’]]])

rdkit.Chem.rdMolDescriptors.CustomProp_VSA_((rdkit.Chem.rdchem.Mol)mol, (str)customPropName, (AtomPairsParameters)bins[, (bool)force=False]) → list :
  C++ signature :

    boost::python::list CustomProp_VSA_(RDKit::ROMol,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,boost::python::api::object [,bool=False])

class rdkit.Chem.rdMolDescriptors.DoubleCubicLatticeVolume((object)arg1, (rdkit.Chem.rdchem.Mol)mol[, (bool)isProtein=False[, (bool)includeLigand=True[, (float)probeRadius=1.4[, (int)confId=-1]]]]) → None :

  Bases: `instance`

  Class for the Double Cubic Lattice Volume method

  > C++ signature :

  >   void __init__(_object*,RDKit::ROMol [,bool=False [,bool=True [,double=1.4 [,int=-1]]]])

  __init__( (AtomPairsParameters)arg1, (rdkit.Chem.rdchem.Mol)mol, (list)radii [, (bool)isProtein=False [, (bool)includeLigand=True [, (float)probeRadius=1.4 [, (int)confId=-1]]]]) -> object :
    ARGUMENTS:

      “ - mol: molecule or protein under consideration “ - radii: radii for atoms of input mol (get using GetPeriodicTable or provide custom list) “ - isProtein: flag to indicate if the input is a protein (default=False, free ligand). “ - includeLigand: flag to include or exclude a bound ligand when input is a protein (default=True) “ - probeRadius: radius of the solvent probe (default=1.2) “ - confId: conformer ID to consider (default=-1) “

    C++ signature :

      void* __init__(boost::python::api::object,RDKit::ROMol,boost::python::list [,bool=False [,bool=True [,double=1.4 [,int=-1]]]])

  GetAtomSurfaceArea((DoubleCubicLatticeVolume)arg1, (int)atom_idx) → float :

    Get the surface area of atom with atom_idx

    C++ signature :

      double GetAtomSurfaceArea(RDKit::Descriptors::DoubleCubicLatticeVolume {lvalue},unsigned int)

  GetAtomVolume((DoubleCubicLatticeVolume)arg1, (int)atomIdx, (float)solventRadius) → float :

    Get the volume atom of atom_idx with volume for specified Probe Radius

    C++ signature :

      double GetAtomVolume(RDKit::Descriptors::DoubleCubicLatticeVolume {lvalue},unsigned int,double)

  GetCompactness((DoubleCubicLatticeVolume)arg1) → float :

    Get the Compactness of the Protein

    C++ signature :

      double GetCompactness(RDKit::Descriptors::DoubleCubicLatticeVolume {lvalue})

  GetPackingDensity((DoubleCubicLatticeVolume)arg1) → float :

    Get the PackingDensity of the Protein

    C++ signature :

      double GetPackingDensity(RDKit::Descriptors::DoubleCubicLatticeVolume {lvalue})

  GetPartialSurfaceArea((DoubleCubicLatticeVolume)arg1, (AtomPairsParameters)atomIndices) → float :

    Get the Partial Surface Area of the Molecule or Protein for specified subset of atoms

    C++ signature :

      double GetPartialSurfaceArea(RDKit::Descriptors::DoubleCubicLatticeVolume {lvalue},boost::python::api::object)

  GetPartialVolume((DoubleCubicLatticeVolume)arg1, (AtomPairsParameters)atomIdx) → float :

    Get the Partial Volume of the Molecule or Protein for specified subset of atoms

    C++ signature :

      double GetPartialVolume(RDKit::Descriptors::DoubleCubicLatticeVolume {lvalue},boost::python::api::object)

  GetPolarSurfaceArea((DoubleCubicLatticeVolume)arg1[, (bool)includeSandP=False[, (bool)includeHs=False]]) → float :

    Get the Polar Surface Area of the Molecule or Protein

    C++ signature :

      double GetPolarSurfaceArea(RDKit::Descriptors::DoubleCubicLatticeVolume {lvalue} [,bool=False [,bool=False]])

  GetPolarVolume((DoubleCubicLatticeVolume)arg1[, (bool)includeSandP=False[, (bool)includeHs=False]]) → float :

    Get the Polar Volume of the Molecule or Protein

    C++ signature :

      double GetPolarVolume(RDKit::Descriptors::DoubleCubicLatticeVolume {lvalue} [,bool=False [,bool=False]])

  GetSurfaceArea((DoubleCubicLatticeVolume)self) → float :

    Get the Surface Area of the Molecule or Protein

    C++ signature :

      double GetSurfaceArea(RDKit::Descriptors::DoubleCubicLatticeVolume {lvalue})

  GetSurfacePoints((DoubleCubicLatticeVolume)arg1) → dict :

    Get the set of points representing the surface

    C++ signature :

      boost::python::dict GetSurfacePoints(RDKit::Descriptors::DoubleCubicLatticeVolume {lvalue})

  GetVDWVolume((DoubleCubicLatticeVolume)arg1) → float :

    Get the van der Waals Volume of the Molecule or Protein

    C++ signature :

      double GetVDWVolume(RDKit::Descriptors::DoubleCubicLatticeVolume {lvalue})

  GetVolume((DoubleCubicLatticeVolume)arg1) → float :

    Get the Total Volume of the Molecule or Protein

    C++ signature :

      double GetVolume(RDKit::Descriptors::DoubleCubicLatticeVolume {lvalue})

rdkit.Chem.rdMolDescriptors.GetAtomFeatures((rdkit.Chem.rdchem.Mol)mol, (int)atomid[, (bool)addchiral=False]) → list :

  Returns the Atom Features vector

  C++ signature :

    boost::python::list GetAtomFeatures(RDKit::ROMol,int [,bool=False])

rdkit.Chem.rdMolDescriptors.GetAtomPairAtomCode((rdkit.Chem.rdchem.Atom)atom[, (int)branchSubtract=0[, (bool)includeChirality=False]]) → int :

  Returns the atom code (hash) for an atom

  C++ signature :

    unsigned int GetAtomPairAtomCode(RDKit::Atom const* [,unsigned int=0 [,bool=False]])

rdkit.Chem.rdMolDescriptors.GetAtomPairCode((int)atom1Code, (int)atom2Code, (int)distance[, (bool)includeChirality=False]) → int :

  Returns the atom-pair code (hash) for a pair of atoms separated by a certain number of bonds

  C++ signature :

    unsigned int GetAtomPairCode(unsigned int,unsigned int,unsigned int [,bool=False])

rdkit.Chem.rdMolDescriptors.GetAtomPairFingerprint((rdkit.Chem.rdchem.Mol)mol[, (int)minLength=1[, (int)maxLength=30[, (AtomPairsParameters)fromAtoms=0[, (AtomPairsParameters)ignoreAtoms=0[, (AtomPairsParameters)atomInvariants=0[, (bool)includeChirality=False[, (bool)use2D=True[, (int)confId=-1]]]]]]]]) → rdkit.DataStructs.cDataStructs.IntSparseIntVect :

  Returns the atom-pair fingerprint for a molecule as an IntSparseIntVect

  C++ signature :

    RDKit::SparseIntVect<int>* GetAtomPairFingerprint(RDKit::ROMol [,unsigned int=1 [,unsigned int=30 [,boost::python::api::object=0 [,boost::python::api::object=0 [,boost::python::api::object=0 [,bool=False [,bool=True [,int=-1]]]]]]]])

rdkit.Chem.rdMolDescriptors.GetConnectivityInvariants((rdkit.Chem.rdchem.Mol)mol[, (bool)includeRingMembership=True]) → list :

  Returns connectivity invariants (ECFP-like) for a molecule.

  C++ signature :

    boost::python::list GetConnectivityInvariants(RDKit::ROMol [,bool=True])

rdkit.Chem.rdMolDescriptors.GetFeatureInvariants((rdkit.Chem.rdchem.Mol)mol) → list :

  Returns feature invariants (FCFP-like) for a molecule.

  C++ signature :

    boost::python::list GetFeatureInvariants(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.GetHashedAtomPairFingerprint((rdkit.Chem.rdchem.Mol)mol[, (int)nBits=2048[, (int)minLength=1[, (int)maxLength=30[, (AtomPairsParameters)fromAtoms=0[, (AtomPairsParameters)ignoreAtoms=0[, (AtomPairsParameters)atomInvariants=0[, (bool)includeChirality=False[, (bool)use2D=True[, (int)confId=-1]]]]]]]]]) → rdkit.DataStructs.cDataStructs.IntSparseIntVect :

  Returns the hashed atom-pair fingerprint for a molecule as an IntSparseIntVect

  C++ signature :

    RDKit::SparseIntVect<int>* GetHashedAtomPairFingerprint(RDKit::ROMol [,unsigned int=2048 [,unsigned int=1 [,unsigned int=30 [,boost::python::api::object=0 [,boost::python::api::object=0 [,boost::python::api::object=0 [,bool=False [,bool=True [,int=-1]]]]]]]]])

rdkit.Chem.rdMolDescriptors.GetHashedAtomPairFingerprintAsBitVect((rdkit.Chem.rdchem.Mol)mol[, (int)nBits=2048[, (int)minLength=1[, (int)maxLength=30[, (AtomPairsParameters)fromAtoms=0[, (AtomPairsParameters)ignoreAtoms=0[, (AtomPairsParameters)atomInvariants=0[, (int)nBitsPerEntry=4[, (bool)includeChirality=False[, (bool)use2D=True[, (int)confId=-1]]]]]]]]]]) → rdkit.DataStructs.cDataStructs.ExplicitBitVect :

  Returns the atom-pair fingerprint for a molecule as an ExplicitBitVect

  C++ signature :

    ExplicitBitVect* GetHashedAtomPairFingerprintAsBitVect(RDKit::ROMol [,unsigned int=2048 [,unsigned int=1 [,unsigned int=30 [,boost::python::api::object=0 [,boost::python::api::object=0 [,boost::python::api::object=0 [,unsigned int=4 [,bool=False [,bool=True [,int=-1]]]]]]]]]])

rdkit.Chem.rdMolDescriptors.GetHashedMorganFingerprint((rdkit.Chem.rdchem.Mol)mol, (int)radius[, (int)nBits=2048[, (AtomPairsParameters)invariants=[][, (AtomPairsParameters)fromAtoms=[][, (bool)useChirality=False[, (bool)useBondTypes=True[, (bool)useFeatures=False[, (AtomPairsParameters)bitInfo=None[, (bool)includeRedundantEnvironments=False]]]]]]]]) → rdkit.DataStructs.cDataStructs.UIntSparseIntVect :

  Returns a hashed Morgan fingerprint for a molecule

  C++ signature :

    RDKit::SparseIntVect<unsigned int>* GetHashedMorganFingerprint(RDKit::ROMol,unsigned int [,unsigned int=2048 [,boost::python::api::object=[] [,boost::python::api::object=[] [,bool=False [,bool=True [,bool=False [,boost::python::api::object=None [,bool=False]]]]]]]])

rdkit.Chem.rdMolDescriptors.GetHashedTopologicalTorsionFingerprint((rdkit.Chem.rdchem.Mol)mol[, (int)nBits=2048[, (int)targetSize=4[, (AtomPairsParameters)fromAtoms=0[, (AtomPairsParameters)ignoreAtoms=0[, (AtomPairsParameters)atomInvariants=0[, (bool)includeChirality=False]]]]]]) → rdkit.DataStructs.cDataStructs.LongSparseIntVect :

  Returns the hashed topological-torsion fingerprint for a molecule as a LongIntSparseIntVect

  C++ signature :

    RDKit::SparseIntVect<long>* GetHashedTopologicalTorsionFingerprint(RDKit::ROMol [,unsigned int=2048 [,unsigned int=4 [,boost::python::api::object=0 [,boost::python::api::object=0 [,boost::python::api::object=0 [,bool=False]]]]]])

rdkit.Chem.rdMolDescriptors.GetHashedTopologicalTorsionFingerprintAsBitVect((rdkit.Chem.rdchem.Mol)mol[, (int)nBits=2048[, (int)targetSize=4[, (AtomPairsParameters)fromAtoms=0[, (AtomPairsParameters)ignoreAtoms=0[, (AtomPairsParameters)atomInvariants=0[, (int)nBitsPerEntry=4[, (bool)includeChirality=False]]]]]]]) → rdkit.DataStructs.cDataStructs.ExplicitBitVect :

  Returns the topological-torsion fingerprint for a molecule as an ExplicitBitVect

  C++ signature :

    ExplicitBitVect* GetHashedTopologicalTorsionFingerprintAsBitVect(RDKit::ROMol [,unsigned int=2048 [,unsigned int=4 [,boost::python::api::object=0 [,boost::python::api::object=0 [,boost::python::api::object=0 [,unsigned int=4 [,bool=False]]]]]]])

rdkit.Chem.rdMolDescriptors.GetMACCSKeysFingerprint((rdkit.Chem.rdchem.Mol)mol) → rdkit.DataStructs.cDataStructs.ExplicitBitVect :

  Returns the MACCS keys for a molecule as an ExplicitBitVect

  C++ signature :

    ExplicitBitVect* GetMACCSKeysFingerprint(RDKit::ROMol)

rdkit.Chem.rdMolDescriptors.GetMorganFingerprint((rdkit.Chem.rdchem.Mol)mol, (int)radius[, (AtomPairsParameters)invariants=[][, (AtomPairsParameters)fromAtoms=[][, (bool)useChirality=False[, (bool)useBondTypes=True[, (bool)useFeatures=False[, (bool)useCounts=True[, (AtomPairsParameters)bitInfo=None[, (bool)includeRedundantEnvironments=False]]]]]]]]) → rdkit.DataStructs.cDataStructs.UIntSparseIntVect :

  Returns a Morgan fingerprint for a molecule

  C++ signature :

    RDKit::SparseIntVect<unsigned int>* GetMorganFingerprint(RDKit::ROMol,unsigned int [,boost::python::api::object=[] [,boost::python::api::object=[] [,bool=False [,bool=True [,bool=False [,bool=True [,boost::python::api::object=None [,bool=False]]]]]]]])

rdkit.Chem.rdMolDescriptors.GetMorganFingerprintAsBitVect((rdkit.Chem.rdchem.Mol)mol, (int)radius[, (int)nBits=2048[, (AtomPairsParameters)invariants=[][, (AtomPairsParameters)fromAtoms=[][, (bool)useChirality=False[, (bool)useBondTypes=True[, (bool)useFeatures=False[, (AtomPairsParameters)bitInfo=None[, (bool)includeRedundantEnvironments=False]]]]]]]]) → rdkit.DataStructs.cDataStructs.ExplicitBitVect :

  Returns a Morgan fingerprint for a molecule as a bit vector

  C++ signature :

    ExplicitBitVect* GetMorganFingerprintAsBitVect(RDKit::ROMol,unsigned int [,unsigned int=2048 [,boost::python::api::object=[] [,boost::python::api::object=[] [,bool=False [,bool=True [,bool=False [,boost::python::api::object=None [,bool=False]]]]]]]])

rdkit.Chem.rdMolDescriptors.GetTopologicalTorsionFingerprint((rdkit.Chem.rdchem.Mol)mol[, (int)targetSize=4[, (AtomPairsParameters)fromAtoms=0[, (AtomPairsParameters)ignoreAtoms=0[, (AtomPairsParameters)atomInvariants=0[, (bool)includeChirality=False]]]]]) → rdkit.DataStructs.cDataStructs.LongSparseIntVect :

  Returns the topological-torsion fingerprint for a molecule as a LongIntSparseIntVect

  C++ signature :

    RDKit::SparseIntVect<long>* GetTopologicalTorsionFingerprint(RDKit::ROMol [,unsigned int=4 [,boost::python::api::object=0 [,boost::python::api::object=0 [,boost::python::api::object=0 [,bool=False]]]]])

rdkit.Chem.rdMolDescriptors.GetUSR((rdkit.Chem.rdchem.Mol)mol[, (int)confId=-1]) → list :

  Returns a USR descriptor for one conformer of a molecule

  C++ signature :

    boost::python::list GetUSR(RDKit::ROMol [,int=-1])

rdkit.Chem.rdMolDescriptors.GetUSRCAT((rdkit.Chem.rdchem.Mol)mol[, (AtomPairsParameters)atomSelections=None[, (int)confId=-1]]) → list :

  Returns a USRCAT descriptor for one conformer of a molecule

  C++ signature :

    boost::python::list GetUSRCAT(RDKit::ROMol [,boost::python::api::object=None [,int=-1]])

rdkit.Chem.rdMolDescriptors.GetUSRDistributions((AtomPairsParameters)coords[, (AtomPairsParameters)points=None]) → list :

  Returns the four USR distance distributions for a set of coordinates

  C++ signature :

    boost::python::list GetUSRDistributions(boost::python::api::object [,boost::python::api::object=None])

rdkit.Chem.rdMolDescriptors.GetUSRDistributionsFromPoints((AtomPairsParameters)coords, (AtomPairsParameters)points) → list :

  Returns the USR distance distributions for a set of coordinates and points

  C++ signature :

    boost::python::list GetUSRDistributionsFromPoints(boost::python::api::object,boost::python::api::object)

rdkit.Chem.rdMolDescriptors.GetUSRFromDistributions((AtomPairsParameters)distances) → list :

  Returns the USR descriptor from a set of distance distributions

  C++ signature :

    boost::python::list GetUSRFromDistributions(boost::python::api::object)

rdkit.Chem.rdMolDescriptors.GetUSRScore((AtomPairsParameters)descriptor1, (AtomPairsParameters)descriptor2[, (AtomPairsParameters)weights=[]]) → float :

  Returns the USR score for two USR or USRCAT descriptors

  C++ signature :

    double GetUSRScore(boost::python::api::object,boost::python::api::object [,boost::python::api::object=[]])

rdkit.Chem.rdMolDescriptors.MQNs_((rdkit.Chem.rdchem.Mol)mol[, (bool)force=False]) → list :
  C++ signature :

    boost::python::list MQNs_(RDKit::ROMol [,bool=False])

rdkit.Chem.rdMolDescriptors.MakePropertyRangeQuery((str)name, (float)min, (float)max) → PropertyRangeQuery :

  Generates a Range property for the specified property, between min and max query = MakePropertyRangeQuery(‘exactmw’, 0, 500) query.Match( mol )

  C++ signature :

    Queries::RangeQuery<double, RDKit::ROMol const&, true>* MakePropertyRangeQuery(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,double,double)

class rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions

  Bases: `enum`

  Options for generating rotatable bonds NonStrict - standard loose definitions Strict - stricter definition excluding amides, esters, etc StrictLinkages - adds rotors between rotatable bonds Default - Current RDKit default

  Default = rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.Default
  NonStrict = rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.NonStrict
  Strict = rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.Strict
  StrictLinkages = rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.StrictLinkages
  names = {'Default': rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.Default, 'NonStrict': rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.NonStrict, 'Strict': rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.Strict, 'StrictLinkages': rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.StrictLinkages}
  values = {-1: rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.Default, 0: rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.NonStrict, 1: rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.Strict, 2: rdkit.Chem.rdMolDescriptors.NumRotatableBondsOptions.StrictLinkages}

rdkit.Chem.rdMolDescriptors.PEOE_VSA_((rdkit.Chem.rdchem.Mol)mol[, (AtomPairsParameters)bins=[][, (bool)force=False]]) → list :
  C++ signature :

    boost::python::list PEOE_VSA_(RDKit::ROMol [,boost::python::api::object=[] [,bool=False]])

class rdkit.Chem.rdMolDescriptors.Properties((object)self) → None :

  Bases: `instance`

  Property computation and registry system. To compute all registered properties: mol = Chem.MolFromSmiles(‘c1ccccc1’) properties = rdMolDescriptors.Properties() for name, value in zip(properties.GetPropertyNames(), properties.ComputeProperties(mol)):

  > print(name, value)

  To compute a subset properties = rdMolDescriptors.Properties([‘exactmw’, ‘lipinskiHBA’]) for name, value in zip(properties.GetPropertyNames(), properties.ComputeProperties(mol)):

  > print(name, value)

  > > C++ signature :

  > >   void __init__(_object*)

  __init__( (object)self, (rdkit.rdBase._vectNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE)propNames) -> None :

  > C++ signature :

  >   void __init__(_object*,std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >)

  AnnotateProperties((Properties)self, (rdkit.Chem.rdchem.Mol)mol) → None :

    Annotate the molecule with the computed properties. These properties will be available as SDData or from mol.GetProp(prop)

    C++ signature :

      void AnnotateProperties(RDKit::Descriptors::Properties {lvalue},RDKit::ROMol {lvalue})

  ComputeProperties((Properties)self, (rdkit.Chem.rdchem.Mol)mol[, (bool)annotateMol=False]) → rdkit.rdBase._vectd :

    Return a list of computed properties, if annotateMol==True, annotate the molecule with the computed properties.

    C++ signature :

      std::vector<double, std::allocator<double> > ComputeProperties(RDKit::Descriptors::Properties {lvalue},RDKit::ROMol [,bool=False])

  static GetAvailableProperties() → rdkit.rdBase._vectNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE :

    Return all available property names that can be computed

    C++ signature :

      std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > GetAvailableProperties()

  static GetProperty((str)propName) → PropertyFunctor :

    Return the named property if it exists

    C++ signature :

      boost::shared_ptr<RDKit::Descriptors::PropertyFunctor> GetProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

  GetPropertyNames((Properties)self) → rdkit.rdBase._vectNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE :

    Return the property names computed by this instance

    C++ signature :

      std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > GetPropertyNames(RDKit::Descriptors::Properties {lvalue})

  static RegisterProperty((AtomPairsParameters)propertyFunctor) → int :

    Register a new property object (not thread safe)

    C++ signature :

      int RegisterProperty(boost::python::api::object)

class rdkit.Chem.rdMolDescriptors.PropertyFunctor

  Bases: `instance`

  Property computation class stored in the property registry. See rdkit.Chem.rdMolDescriptor.Properties.GetProperty and rdkit.Chem.Descriptor.Properties.PropertyFunctor for creating new ones

  Raises an exception This class cannot be instantiated from Python

  GetName((PropertyFunctor)self) → str :

    Return the name of the property to calculate

    C++ signature :

      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > GetName(RDKit::Descriptors::PropertyFunctor {lvalue})

  GetVersion((PropertyFunctor)self) → str :

    Return the version of the calculated property

    C++ signature :

      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > GetVersion(RDKit::Descriptors::PropertyFunctor {lvalue})

class rdkit.Chem.rdMolDescriptors.PropertyRangeQuery

  Bases: `instance`

  Property Range Query for a molecule. Match(mol) -> true if in range

  Raises an exception This class cannot be instantiated from Python

  Match((PropertyRangeQuery)self, (rdkit.Chem.rdchem.Mol)what) → bool :
    C++ signature :

      bool Match(Queries::RangeQuery<double, RDKit::ROMol const&, true> {lvalue},RDKit::ROMol)

class rdkit.Chem.rdMolDescriptors.PythonPropertyFunctor((object)self, (object)callback, (str)name, (str)version) → None :

  Bases: `PropertyFunctor`

  C++ signature :

    void __init__(_object*,_object*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

rdkit.Chem.rdMolDescriptors.SMR_VSA_((rdkit.Chem.rdchem.Mol)mol[, (AtomPairsParameters)bins=[][, (bool)force=False]]) → list :
  C++ signature :

    boost::python::list SMR_VSA_(RDKit::ROMol [,boost::python::api::object=[] [,bool=False]])

rdkit.Chem.rdMolDescriptors.SlogP_VSA_((rdkit.Chem.rdchem.Mol)mol[, (AtomPairsParameters)bins=[][, (bool)force=False]]) → list :
  C++ signature :

    boost::python::list SlogP_VSA_(RDKit::ROMol [,boost::python::api::object=[] [,bool=False]])