rdkit.Chem.rdfiltercatalog module — The RDKit 2025.09.6 documentation

# rdkit.Chem.rdfiltercatalog module

class rdkit.Chem.rdfiltercatalog.ExclusionList((object)self) → None :

  Bases: `FilterMatcherBase`

  C++ signature :

    void __init__(_object*)

  AddPattern((ExclusionList)self, (FilterMatcherBase)base) → None :

    Add a FilterMatcherBase that should not appear in a molecule

    C++ signature :

      void AddPattern(RDKit::ExclusionList {lvalue},RDKit::FilterMatcherBase)

  SetExclusionPatterns((ExclusionList)self, (rdkit.Chem.rdMolDescriptors.AtomPairsParameters)list) → None :

    Set a list of FilterMatcherBases that should not appear in a molecule

    C++ signature :

      void SetExclusionPatterns(RDKit::ExclusionList {lvalue},boost::python::api::object)

class rdkit.Chem.rdfiltercatalog.FilterCatalog((object)self) → None :

  Bases: `instance`

  > C++ signature :

  >   void __init__(_object*)

  __init__( (object)self, (str)binStr) -> None :

  > C++ signature :

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

  __init__( (object)self, (FilterCatalogParams)params) -> None :

  > C++ signature :

  >   void __init__(_object*,RDKit::FilterCatalogParams)

  __init__( (object)self, (FilterCatalogParams.FilterCatalogs)catalogs) -> None :

  > C++ signature :

  >   void __init__(_object*,RDKit::FilterCatalogParams::FilterCatalogs)

  AddEntry((FilterCatalog)entry[, (FilterCatalogEntry)updateFPLength=False]) → None :

    Add a FilterCatalogEntry to the catalog

    C++ signature :

      void AddEntry(RDKit::FilterCatalog {lvalue} [,RDKit::FilterCatalogEntry*=False])

  GetEntry((FilterCatalog)self, (int)idx) → FilterCatalogEntry :

    Return the FilterCatalogEntry at the specified index

    C++ signature :

      boost::shared_ptr<RDKit::FilterCatalogEntry const> GetEntry(RDKit::FilterCatalog {lvalue},unsigned int)

  GetEntryWithIdx((FilterCatalog)self, (int)idx) → FilterCatalogEntry :

    Return the FilterCatalogEntry at the specified index

    C++ signature :

      boost::shared_ptr<RDKit::FilterCatalogEntry const> GetEntryWithIdx(RDKit::FilterCatalog {lvalue},unsigned int)

  GetFilterMatches((FilterCatalog)self, (rdkit.Chem.rdchem.Mol)mol) → VectFilterMatch :

    Return every matching filter from all catalog entries that match mol

    C++ signature :

      std::vector<RDKit::FilterMatch, std::allocator<RDKit::FilterMatch> > GetFilterMatches(RDKit::FilterCatalog {lvalue},RDKit::ROMol)

  GetFirstMatch((FilterCatalog)self, (rdkit.Chem.rdchem.Mol)mol) → FilterCatalogEntry :

    Return the first catalog entry that matches mol

    C++ signature :

      boost::shared_ptr<RDKit::FilterCatalogEntry const> GetFirstMatch(RDKit::FilterCatalog {lvalue},RDKit::ROMol)

  GetMatches((FilterCatalog)self, (rdkit.Chem.rdchem.Mol)mol) → FilterCatalogEntryList :

    Return all catalog entries that match mol

    C++ signature :

      std::vector<boost::shared_ptr<RDKit::FilterCatalogEntry const>, std::allocator<boost::shared_ptr<RDKit::FilterCatalogEntry const> > > GetMatches(RDKit::FilterCatalog {lvalue},RDKit::ROMol)

  GetNumEntries((FilterCatalog)self) → int :

    Returns the number of entries in the catalog

    C++ signature :

      unsigned int GetNumEntries(RDKit::FilterCatalog {lvalue})

  HasMatch((FilterCatalog)self, (rdkit.Chem.rdchem.Mol)mol) → bool :

    Returns True if the catalog has an entry that matches mol

    C++ signature :

      bool HasMatch(RDKit::FilterCatalog {lvalue},RDKit::ROMol)

  RemoveEntry((FilterCatalog)self, (rdkit.Chem.rdMolDescriptors.AtomPairsParameters)obj) → bool :

    Remove the given entry from the catalog

    C++ signature :

      bool RemoveEntry(RDKit::FilterCatalog {lvalue},boost::python::api::object)

  Serialize((FilterCatalog)self) → object :
    C++ signature :

      boost::python::api::object Serialize(RDKit::FilterCatalog)

rdkit.Chem.rdfiltercatalog.FilterCatalogCanSerialize() → bool :

  Returns True if the FilterCatalog is serializable (requires boost serialization

  C++ signature :

    bool FilterCatalogCanSerialize()

class rdkit.Chem.rdfiltercatalog.FilterCatalogEntry

  Bases: `instance`

  A filter catalog entry is an entry in a filter catalog. Each filter is named and is used to flag a molecule usually for some undesirable property.

  For example, a PAINS (Pan Assay INterference) catalog entry be appear as follows:

      >>> from rdkit.Chem.FilterCatalog import *
      >>> params = FilterCatalogParams()
      >>> params.AddCatalog(FilterCatalogParams.FilterCatalogs.PAINS_A)
      True
      >>> catalog = FilterCatalog(params)
      >>> mol = Chem.MolFromSmiles('O=C(Cn1cnc2c1c(=O)n(C)c(=O)n2C)N/N=C/c1c(O)ccc2c1cccc2')
      >>> entry = catalog.GetFirstMatch(mol)
      >>> print (entry.GetProp('Scope'))
      PAINS filters (family A)
      >>> print (entry.GetDescription())
      hzone_phenol_A(479)

  __init__( (object)self) -> None :

  > C++ signature :

  >   void __init__(_object*)

  __init__( (object)self, (str)name, (FilterMatcherBase)matcher) -> None :

  > C++ signature :

  >   void __init__(_object*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,RDKit::FilterMatcherBase {lvalue})

  ClearProp((FilterCatalogEntry)self, (str)key) → None :
    C++ signature :

      void ClearProp(RDKit::FilterCatalogEntry {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

  GetDescription((FilterCatalogEntry)self) → str :

    Get the description of the catalog entry

    C++ signature :

      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > GetDescription(RDKit::FilterCatalogEntry {lvalue})

  GetFilterMatches((FilterCatalogEntry)self, (rdkit.Chem.rdchem.Mol)mol) → VectFilterMatch :

    Retrieve the list of filters that match the molecule

    C++ signature :

      std::vector<RDKit::FilterMatch, std::allocator<RDKit::FilterMatch> > GetFilterMatches(RDKit::FilterCatalogEntry {lvalue},RDKit::ROMol)

  GetProp((FilterCatalogEntry)self, (str)key) → str :
    C++ signature :

      std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > GetProp(RDKit::FilterCatalogEntry {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

  GetPropList((FilterCatalogEntry)self) → rdkit.rdBase._vectNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE :
    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> > > > GetPropList(RDKit::FilterCatalogEntry {lvalue})

  HasFilterMatch((FilterCatalogEntry)self, (rdkit.Chem.rdchem.Mol)mol) → bool :

    Returns True if the catalog entry contains filters that match the molecule

    C++ signature :

      bool HasFilterMatch(RDKit::FilterCatalogEntry {lvalue},RDKit::ROMol)

  IsValid((FilterCatalogEntry)self) → bool :
    C++ signature :

      bool IsValid(RDKit::FilterCatalogEntry {lvalue})

  Serialize((FilterCatalogEntry)self) → object :
    C++ signature :

      boost::python::api::object Serialize(RDKit::FilterCatalogEntry)

  SetDescription((FilterCatalogEntry)self, (str)description) → None :

    Set the description of the catalog entry

    C++ signature :

      void SetDescription(RDKit::FilterCatalogEntry {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

  SetProp((FilterCatalogEntry)self, (str)key, (str)val) → None :
    C++ signature :

      void SetProp(RDKit::FilterCatalogEntry {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

class rdkit.Chem.rdfiltercatalog.FilterCatalogEntryList((object)arg1) → None :

  Bases: `instance`

  C++ signature :

    void __init__(_object*)

  append((FilterCatalogEntryList)arg1, (rdkit.Chem.rdMolDescriptors.AtomPairsParameters)arg2) → None :
    C++ signature :

      void append(std::vector<boost::shared_ptr<RDKit::FilterCatalogEntry const>, std::allocator<boost::shared_ptr<RDKit::FilterCatalogEntry const> > > {lvalue},boost::python::api::object)

  extend((FilterCatalogEntryList)arg1, (rdkit.Chem.rdMolDescriptors.AtomPairsParameters)arg2) → None :
    C++ signature :

      void extend(std::vector<boost::shared_ptr<RDKit::FilterCatalogEntry const>, std::allocator<boost::shared_ptr<RDKit::FilterCatalogEntry const> > > {lvalue},boost::python::api::object)

class rdkit.Chem.rdfiltercatalog.FilterCatalogListOfEntryList((object)arg1) → None :

  Bases: `instance`

  C++ signature :

    void __init__(_object*)

  append((FilterCatalogListOfEntryList)arg1, (rdkit.Chem.rdMolDescriptors.AtomPairsParameters)arg2) → None :
    C++ signature :

      void append(std::vector<std::vector<boost::shared_ptr<RDKit::FilterCatalogEntry const>, std::allocator<boost::shared_ptr<RDKit::FilterCatalogEntry const> > >, std::allocator<std::vector<boost::shared_ptr<RDKit::FilterCatalogEntry const>, std::allocator<boost::shared_ptr<RDKit::FilterCatalogEntry const> > > > > {lvalue},boost::python::api::object)

  extend((FilterCatalogListOfEntryList)arg1, (rdkit.Chem.rdMolDescriptors.AtomPairsParameters)arg2) → None :
    C++ signature :

      void extend(std::vector<std::vector<boost::shared_ptr<RDKit::FilterCatalogEntry const>, std::allocator<boost::shared_ptr<RDKit::FilterCatalogEntry const> > >, std::allocator<std::vector<boost::shared_ptr<RDKit::FilterCatalogEntry const>, std::allocator<boost::shared_ptr<RDKit::FilterCatalogEntry const> > > > > {lvalue},boost::python::api::object)

class rdkit.Chem.rdfiltercatalog.FilterCatalogParams((object)self) → None :

  Bases: `instance`

  > C++ signature :

  >   void __init__(_object*)

  __init__( (object)self, (FilterCatalogParams.FilterCatalogs)catalogs) -> None :

    Construct from a FilterCatalogs identifier (i.e. FilterCatalogParams.PAINS)

    C++ signature :

      void __init__(_object*,RDKit::FilterCatalogParams::FilterCatalogs)

  AddCatalog((FilterCatalogParams)self, (FilterCatalogParams.FilterCatalogs)catalogs) → bool :
    C++ signature :

      bool AddCatalog(RDKit::FilterCatalogParams {lvalue},RDKit::FilterCatalogParams::FilterCatalogs)

  class FilterCatalogs

    Bases: `enum`

    ALL = rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.ALL
    BRENK = rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.BRENK
    CHEMBL = rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.CHEMBL
    CHEMBL_BMS = rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.CHEMBL_BMS
    CHEMBL_Dundee = rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.CHEMBL_Dundee
    CHEMBL_Glaxo = rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.CHEMBL_Glaxo
    CHEMBL_Inpharmatica = rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.CHEMBL_Inpharmatica
    CHEMBL_LINT = rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.CHEMBL_LINT
    CHEMBL_MLSMR = rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.CHEMBL_MLSMR
    CHEMBL_SureChEMBL = rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.CHEMBL_SureChEMBL
    NIH = rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.NIH
    PAINS = rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.PAINS
    PAINS_A = rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.PAINS_A
    PAINS_B = rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.PAINS_B
    PAINS_C = rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.PAINS_C
    ZINC = rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.ZINC
    names = {'ALL': rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.ALL, 'BRENK': rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.BRENK, 'CHEMBL': rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.CHEMBL, 'CHEMBL_BMS': rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.CHEMBL_BMS, 'CHEMBL_Dundee': rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.CHEMBL_Dundee, 'CHEMBL_Glaxo': rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.CHEMBL_Glaxo, 'CHEMBL_Inpharmatica': rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.CHEMBL_Inpharmatica, 'CHEMBL_LINT': rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.CHEMBL_LINT, 'CHEMBL_MLSMR': rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.CHEMBL_MLSMR, 'CHEMBL_SureChEMBL': rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.CHEMBL_SureChEMBL, 'NIH': rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.NIH, 'PAINS': rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.PAINS, 'PAINS_A': rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.PAINS_A, 'PAINS_B': rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.PAINS_B, 'PAINS_C': rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.PAINS_C, 'ZINC': rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.ZINC}
    values = {2: rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.PAINS_A, 4: rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.PAINS_B, 8: rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.PAINS_C, 14: rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.PAINS, 16: rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.BRENK, 32: rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.NIH, 64: rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.ZINC, 128: rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.CHEMBL_Glaxo, 256: rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.CHEMBL_Dundee, 512: rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.CHEMBL_BMS, 1024: rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.CHEMBL_SureChEMBL, 2048: rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.CHEMBL_MLSMR, 4096: rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.CHEMBL_Inpharmatica, 8192: rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.CHEMBL_LINT, 16256: rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.CHEMBL, 16382: rdkit.Chem.rdfiltercatalog.FilterCatalogParams.FilterCatalogs.ALL}

class rdkit.Chem.rdfiltercatalog.FilterHierarchyMatcher((object)self) → None :

  Bases: `FilterMatcherBase`

  Hierarchical Filter
    basic constructors:

      FilterHierarchyMatcher( matcher ) where can be any FilterMatcherBase (SmartsMatcher, etc)

    FilterHierarchyMatcher’s have children and can form matching

      trees. then GetFilterMatches is called, the most specific ( i.e. lowest node in a branch) is returned.

    n.b. A FilterHierarchicalMatcher of functional groups is returned

      by calling GetFunctionalGroupHierarchy()

      >>> from rdkit.Chem import MolFromSmiles
      >>> from rdkit.Chem.FilterCatalog import *
      >>> functionalGroups = GetFunctionalGroupHierarchy()
      >>> [match.filterMatch.GetName()
      ...     for match in functionalGroups.GetFilterMatches(
      ...         MolFromSmiles('c1ccccc1Cl'))]
      ['Halogen.Aromatic', 'Halogen.NotFluorine.Aromatic']

  > C++ signature :

  >   void __init__(_object*)

  __init__( (object)self, (FilterMatcherBase)matcher) -> None :

    Construct from a filtermatcher

    C++ signature :

      void __init__(_object*,RDKit::FilterMatcherBase)

  AddChild((FilterHierarchyMatcher)self, (FilterHierarchyMatcher)hierarchy) → FilterHierarchyMatcher :

    Add a child node to this hierarchy.

    C++ signature :

      boost::shared_ptr<RDKit::FilterHierarchyMatcher> AddChild(RDKit::FilterHierarchyMatcher {lvalue},RDKit::FilterHierarchyMatcher)

  SetPattern((FilterHierarchyMatcher)self, (FilterMatcherBase)matcher) → None :

    Set the filtermatcher pattern for this node. An empty node is considered a root node and passes along the matches to the children.

    C++ signature :

      void SetPattern(RDKit::FilterHierarchyMatcher {lvalue},RDKit::FilterMatcherBase)

class rdkit.Chem.rdfiltercatalog.FilterMatch((object)self, (FilterMatcherBase)filter, (rdkit.rdBase.MatchTypeVect)atomPairs) → None :

  Bases: `instance`

  Object that holds the result of running FilterMatcherBase::GetMatches

  > - filterMatch holds the FilterMatchBase that triggered the match

  > - atomParis holds the [ (query_atom_idx, target_atom_idx) ] pairs for the matches.

  Note that some matches may not have atom pairs (especially matches that use FilterMatchOps.Not

  C++ signature :

    void __init__(_object*,boost::shared_ptr<RDKit::FilterMatcherBase>,std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >)

  property atomPairs

    None( (rdkit.Chem.rdfiltercatalog.FilterMatch)arg1) -> rdkit.rdBase.MatchTypeVect:

    C++ signature :

      std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > {lvalue} None(RDKit::FilterMatch {lvalue})

  property filterMatch

    None( (rdkit.Chem.rdfiltercatalog.FilterMatch)arg1) -> object:

    C++ signature :

      boost::shared_ptr<RDKit::FilterMatcherBase> {lvalue} None(RDKit::FilterMatch {lvalue})

class rdkit.Chem.rdfiltercatalog.FilterMatcherBase

  Bases: `instance`

  Base class for matching molecules to filters.

  > A FilterMatcherBase supplies the following API - IsValid() returns True if the matcher is valid for use, False otherwise - HasMatch(mol) returns True if the molecule matches the filter - GetMatches(mol) -> [FilterMatch, FilterMatch] returns all the FilterMatch data

  > > that matches the molecule

  print( FilterMatcherBase ) will print user-friendly information about the filter Note that a FilterMatcherBase can be combined from may FilterMatcherBases This is why GetMatches can return multiple FilterMatcherBases. >>> from rdkit.Chem.FilterCatalog import * >>> carbon_matcher = SmartsMatcher(‘Carbon’, ‘[#6]’, 0, 1) >>> oxygen_matcher = SmartsMatcher(‘Oxygen’, ‘[#8]’, 0, 1) >>> co_matcher = FilterMatchOps.Or(carbon_matcher, oxygen_matcher) >>> mol = Chem.MolFromSmiles(‘C’) >>> matches = co_matcher.GetMatches(mol) >>> len(matches) 1 >>> print(matches[0].filterMatch) Carbon

  Raises an exception This class cannot be instantiated from Python

  GetMatches((FilterMatcherBase)self, (rdkit.Chem.rdchem.Mol)mol) → VectFilterMatch :

    Returns the list of matching subfilters mol matches any filter

    C++ signature :

      std::vector<RDKit::FilterMatch, std::allocator<RDKit::FilterMatch> > GetMatches(RDKit::FilterMatcherBase {lvalue},RDKit::ROMol)

  GetName((FilterMatcherBase)self) → str :
    C++ signature :

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

  HasMatch((FilterMatcherBase)self, (rdkit.Chem.rdchem.Mol)mol) → bool :

    Returns True if mol matches the filter

    C++ signature :

      bool HasMatch(RDKit::FilterMatcherBase {lvalue},RDKit::ROMol)

  IsValid((FilterMatcherBase)self) → bool :

    Return True if the filter matcher is valid, False otherwise

    C++ signature :

      bool IsValid(RDKit::FilterMatcherBase {lvalue})

rdkit.Chem.rdfiltercatalog.GetFlattenedFunctionalGroupHierarchy([(bool)normalized=False]) → dict :

  Returns the flattened functional group hierarchy as a dictionary of name:ROMOL_SPTR substructure items

  C++ signature :

    boost::python::dict GetFlattenedFunctionalGroupHierarchy([ bool=False])

rdkit.Chem.rdfiltercatalog.GetFunctionalGroupHierarchy() → FilterCatalog :

  Returns the functional group hierarchy filter catalog

  C++ signature :

    RDKit::FilterCatalog GetFunctionalGroupHierarchy()

class rdkit.Chem.rdfiltercatalog.IntPair((object)arg1) → None :

  Bases: `instance`

  > C++ signature :

  >   void __init__(_object*)

  __init__( (object)self, (int)query, (int)target) -> None :

  > C++ signature :

  >   void __init__(_object*,int,int)

  property query

    None( (rdkit.Chem.rdfiltercatalog.IntPair)arg1) -> int:

    C++ signature :

      int {lvalue} None(std::pair<int, int> {lvalue})

  property target

    None( (rdkit.Chem.rdfiltercatalog.IntPair)arg1) -> int:

    C++ signature :

      int {lvalue} None(std::pair<int, int> {lvalue})

class rdkit.Chem.rdfiltercatalog.MolList((object)arg1) → None :

  Bases: `instance`

  C++ signature :

    void __init__(_object*)

  append((MolList)arg1, (rdkit.Chem.rdMolDescriptors.AtomPairsParameters)arg2) → None :
    C++ signature :

      void append(std::vector<RDKit::ROMol*, std::allocator<RDKit::ROMol*> > {lvalue},boost::python::api::object)

  extend((MolList)arg1, (rdkit.Chem.rdMolDescriptors.AtomPairsParameters)arg2) → None :
    C++ signature :

      void extend(std::vector<RDKit::ROMol*, std::allocator<RDKit::ROMol*> > {lvalue},boost::python::api::object)

class rdkit.Chem.rdfiltercatalog.PythonFilterMatcher((object)self, (object)callback) → None :

  Bases: `FilterMatcherBase`

  C++ signature :

    void __init__(_object*,_object*)

rdkit.Chem.rdfiltercatalog.RunFilterCatalog((FilterCatalog)filterCatalog, (rdkit.rdBase._vectNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE)smiles[, (int)numThreads=1]) → FilterCatalogListOfEntryList :

  Run the filter catalog on the input list of smiles strings. Use numThreads=0 to use all available processors. Returns a vector of vectors. For each input smiles, a vector of FilterCatalogEntry objects are returned for each matched filter. If a molecule matches no filter, the vector will be empty. If a smiles string can’t be parsed, a ‘Bad smiles’ entry is returned.

  C++ signature :

    std::vector<std::vector<boost::shared_ptr<RDKit::FilterCatalogEntry const>, std::allocator<boost::shared_ptr<RDKit::FilterCatalogEntry const> > >, std::allocator<std::vector<boost::shared_ptr<RDKit::FilterCatalogEntry const>, std::allocator<boost::shared_ptr<RDKit::FilterCatalogEntry const> > > > > RunFilterCatalog(RDKit::FilterCatalog,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> > > > [,int=1])

class rdkit.Chem.rdfiltercatalog.SmartsMatcher((object)self, (str)name) → None :

  Bases: `FilterMatcherBase`

  Smarts Matcher Filter
    basic constructors:

      > SmartsMatcher( name, smarts_pattern, minCount=1, maxCount=UINT_MAX ) SmartsMatcher( name, molecule, minCount=1, maxCount=UINT_MAX )

      note: If the supplied smarts pattern is not valid, the IsValid() function will

        return False

      >>> from rdkit.Chem.FilterCatalog import *
      >>> minCount, maxCount = 1,2
      >>> carbon_matcher = SmartsMatcher('Carbon', '[#6]', minCount, maxCount)
      >>> print (carbon_matcher.HasMatch(Chem.MolFromSmiles('CC')))
      True
      >>> print (carbon_matcher.HasMatch(Chem.MolFromSmiles('CCC')))
      False
      >>> carbon_matcher.SetMinCount(2)
      >>> print (carbon_matcher.HasMatch(Chem.MolFromSmiles('C')))
      False
      >>> carbon_matcher.SetMaxCount(3)
      >>> print (carbon_matcher.HasMatch(Chem.MolFromSmiles('CCC')))
      True

  > C++ signature :

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

  __init__( (object)self, (rdkit.Chem.rdchem.Mol)rhs) -> None :

    Construct from a molecule

    C++ signature :

      void __init__(_object*,RDKit::ROMol)

  __init__( (object)self, (str)name, (rdkit.Chem.rdchem.Mol)mol [, (int)minCount=1 [, (int)maxCount=4294967295]]) -> None :

    Construct from a name, molecule, minimum and maximum count

    C++ signature :

      void __init__(_object*,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,RDKit::ROMol [,unsigned int=1 [,unsigned int=4294967295]])

  __init__( (object)self, (str)name, (str)smarts [, (int)minCount=1 [, (int)maxCount=4294967295]]) -> None :

    Construct from a name,smarts pattern, minimum and maximum count

    C++ signature :

      void __init__(_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> > [,unsigned int=1 [,unsigned int=4294967295]])

  GetMaxCount((SmartsMatcher)self) → int :

    Get the maximum times pattern can appear for the filter to match

    C++ signature :

      unsigned int GetMaxCount(RDKit::SmartsMatcher {lvalue})

  GetMinCount((SmartsMatcher)self) → int :

    Get the minimum times pattern must appear for the filter to match

    C++ signature :

      unsigned int GetMinCount(RDKit::SmartsMatcher {lvalue})

  GetPattern((SmartsMatcher)self) → rdkit.Chem.rdchem.Mol :
    C++ signature :

      boost::shared_ptr<RDKit::ROMol> GetPattern(RDKit::SmartsMatcher {lvalue})

  IsValid((SmartsMatcher)self) → bool :

    Returns True if the SmartsMatcher is valid

    C++ signature :

      bool IsValid(RDKit::SmartsMatcher {lvalue})

  SetMaxCount((SmartsMatcher)self, (int)count) → None :

    Set the maximum times pattern can appear for the filter to match

    C++ signature :

      void SetMaxCount(RDKit::SmartsMatcher {lvalue},unsigned int)

  SetMinCount((SmartsMatcher)self, (int)count) → None :

    Set the minimum times pattern must appear to match

    C++ signature :

      void SetMinCount(RDKit::SmartsMatcher {lvalue},unsigned int)

  SetPattern((SmartsMatcher)self, (rdkit.Chem.rdchem.Mol)pat) → None :

    Set the pattern molecule for the SmartsMatcher

    > C++ signature :

    >   void SetPattern(RDKit::SmartsMatcher {lvalue},RDKit::ROMol)

    SetPattern( (SmartsMatcher)self, (str)pat) -> None :

      Set the smarts pattern for the Smarts Matcher (warning: MinimumCount is not reset)

      C++ signature :

        void SetPattern(RDKit::SmartsMatcher {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

class rdkit.Chem.rdfiltercatalog.VectFilterMatch((object)arg1) → None :

  Bases: `instance`

  C++ signature :

    void __init__(_object*)

  append((VectFilterMatch)arg1, (rdkit.Chem.rdMolDescriptors.AtomPairsParameters)arg2) → None :
    C++ signature :

      void append(std::vector<RDKit::FilterMatch, std::allocator<RDKit::FilterMatch> > {lvalue},boost::python::api::object)

  extend((VectFilterMatch)arg1, (rdkit.Chem.rdMolDescriptors.AtomPairsParameters)arg2) → None :
    C++ signature :

      void extend(std::vector<RDKit::FilterMatch, std::allocator<RDKit::FilterMatch> > {lvalue},boost::python::api::object)