chemFilters

A collection of chemical filters, with some support for data visualization and analysis. At the moment, the supported filters are:

• RDKit filters based on RDKit implementation of Pat Walter's version of the ChEMBL filters*;
• Purchasability filters based on Andrew White's molbloom;
• Peptide filters based on Olivier Béquignon's PepSift;
• Silly molecules filters based Olivier's fork of Pat Water's silly walks;

*note: RDKit's implementation these chemical filters is only available from rdkit version 2023.03.1 onwards. Check here for the release notes.

Overview:

The different filtering classes are implemented with a similar API, where get_flagging/scoring_df run all the filters available for that filtering class and return a dataframe that used to investigate the filters. In case of the RdkitFilters implementation, a few visualization methods are available to render the molecules, substructure matches, and molecular grids.

See available filters and visualization methods below:

• chemFilters
  • Overview:
  • Installation
  • Filtering Compounds
    • RdkitFilters
    • Purchasability filters
    • Silly molecules filters
    • Peptide filters
    • Core filters
    • CLI
  • Visualization
    • Rendering a grid of molecules;
    • Rendering substructure matches:
    • Rendering substructure matches with colors:

Installation

python -m pip install git+https://github.com/David-Araripe/chemFilters.git

Filtering Compounds

RdkitFilters

from chemFilters import RdkitFilters
from rdkit import Chem

mols = [
    Chem.MolFromSmiles("CCC1=[O+][Cu-3]2([O+]=C(CC)C1)[O+]=C(CC)CC(CC)=[O+]2"),
    Chem.MolFromSmiles("CC1=C2C(=COC(C)C2C)C(O)=C(C(=O)O)C1=O"),
    Chem.MolFromSmiles("CCOP(=O)(Nc1cccc(Cl)c1)OCC"),
    Chem.MolFromSmiles("Nc1ccc(C=Cc2ccc(N)cc2S(=O)(=O)O)c(S(=O)(=O)O)c1"),
]

rdkit_filter = RdkitFilters(filter_type='ALL', from_smi=False)
filtered_df = rdkit_filter.get_flagging_df(mols)

Purchasability filters

from chemFilters import MolbloomFilters
bloom_filter = MolbloomFilters(from_smi=False, standardize=False)
bloom_filter.get_flagging_df(mols)

Silly molecules filters

from chemFilters import SillyMolFilters
silly_filter = SillyMolFilters(from_smi=False)
silly_filter.get_scoring_df(mols)

Peptide filters

from chemFilters import PeptideFilters
pep_filter = PeptideFilters(from_smi=False)
pep_filter.get_flagging_df(mols)

Core filters

The package also has an implementation that allows applying all available filters at once. This implementation is also used in the CLI version of the package. For further configuration options, check the CLI help.

from chemFilters.core import CoreFilters

smiles = [
    "CCC1=[O+][Cu-3]2([O+]=C(CC)C1)[O+]=C(CC)CC(CC)=[O+]2",
    "CC1=C2C(=COC(C)C2C)C(O)=C(C(=O)O)C1=O",
    "CCOP(=O)(Nc1cccc(Cl)c1)OCC",
    "Nc1ccc(C=Cc2ccc(N)cc2S(=O)(=O)O)c(S(=O)(=O)O)c1",
]

core_filter = CoreFilters()
filtered_df = core_filter(smiles)

CLI

After installing the package, the CLI can be used to filter datasets. The CLI has the following options:

usage: chemFilters [-h] -i INPUT [-c COL_NAME] -o OUTPUT [--rdkit-filter] [--no-rdkit-filter]
                   [--rdkit-subset RDKIT_SUBSET] [--rdkit-valtype RDKIT_VALTYPE] [--pep-filter] [--no-pep-filter]
                   [--silly-filter] [--no-silly-filter] [--bloom-filter] [--no-bloom-filter] [--std-mols]
                   [--no-std-mols] [--std-method STD_METHOD] [--n-jobs N_JOBS] [--chunk-size CHUNK_SIZE]

Where --<name>-filter and --no-<name>-filter enables and disables the implemented filters. Same goes for the parameter --std-mols, that enables the molecular standardization according to --std-method.

Visualization

Rendering a grid of molecules;

from rdkit import Chem
from chemFilters.img_render import MolPlotter, MolGridPlotter

mols = [
    Chem.MolFromSmiles("CCC1=[O+][Cu-3]2([O+]=C(CC)C1)[O+]=C(CC)CC(CC)=[O+]2"),
    Chem.MolFromSmiles("CC1=C2C(=COC(C)C2C)C(O)=C(C(=O)O)C1=O"),
    Chem.MolFromSmiles("CCOP(=O)(Nc1cccc(Cl)c1)OCC"),
    Chem.MolFromSmiles("Nc1ccc(C=Cc2ccc(N)cc2S(=O)(=O)O)c(S(=O)(=O)O)c1"),
]
labels = [f"Molecule {i}" for i in range(1, len(mols) + 1)]

# Initialize grid plotter instance
grid_plotter = MolGridPlotter(from_smi=False, font_name="Telex-Regular")

img = grid_plotter.mol_grid_png(mols[:4], n_cols=2, labels=labels)
display(img)

Rendering substructure matches:

chemFilter = RdkitFilters(filter_type="ALL")
filter_names, description, substructs = chemFilter.filter_mols(mols)

grid_plotter = MolGridPlotter(
    from_smi=False, font_name="Telex-Regular", size=(250, 250)
)

img = grid_plotter.mol_structmatch_grid_png(mols, substructs=substructs, n_cols=2)
display(img)

Rendering substructure matches with colors:

from chemFilters import RdkitFilters
import matplotlib.pyplot as plt

chemFilter = RdkitFilters(filter_type="NIH")
filter_names, description, substructs = chemFilter.filter_mols(mols)

plotter = MolPlotter(
    from_smi=False, font_size=20, size=(350, 350), font_name="Telex-Regular"
)
img = plotter.render_with_colored_matches(
    mols[0],
    descriptions=description[0],
    substructs=substructs[0],
    label=labels[0],
    alpha=0.3,
)

plt.imshow(img)
ax = plt.gca()  # get current axis
ax.set_axis_off()
plotter.colored_matches_legend(description[0], substructs[0], ax=ax)
fig = plt.gcf()  # get current figure
fig.savefig(  # save matplotlib figure
    "figures/colored_matches.png", bbox_inches="tight", dpi=150, facecolor="white"
)