Medchem

Aperçu

Medchem est une bibliothèque Python pour le filtrage moléculaire et la priorisation dans les workflows de découverte de médicaments. Appliquez des centaines de filtres moléculaires bien établis et novateurs, d'alertes structurales et de règles de chimie médicinale pour trier et prioriser efficacement les bibliothèques de composés à grande échelle. Les règles et filtres sont spécifiques au contexte—utilisez-les comme des lignes directrices combinées avec une expertise de domaine.

Quand utiliser cette compétence

Cette compétence doit être utilisée quand :

• Appliquer des règles de ressemblance aux médicaments (Lipinski, Veber, etc.) à des bibliothèques de composés
• Filtrer des molécules par alertes structurales ou motifs PAINS
• Prioriser les composés pour l'optimisation des composés principaux
• Évaluer la qualité des composés et les propriétés de chimie médicinale
• Détecter les groupes fonctionnels réactifs ou problématiques
• Calculer les métriques de complexité moléculaire

Installation

uv pip install medchem

Capacités principales

1. Règles de chimie médicinale

Appliquez des règles établies de ressemblance aux médicaments aux molécules en utilisant le module medchem.rules.

Règles disponibles :

• Rule of Five (Lipinski)
• Rule of Oprea
• Rule of CNS
• Rule of leadlike (soft et strict)
• Rule of three
• Rule of Reos
• Rule of drug
• Rule of Veber
• Golden triangle
• Filtres PAINS

Application d'une règle unique :

import medchem as mc

# Apply Rule of Five to a SMILES string
smiles = "CC(=O)OC1=CC=CC=C1C(=O)O"  # Aspirin
passes = mc.rules.basic_rules.rule_of_five(smiles)
# Returns: True

# Check specific rules
passes_oprea = mc.rules.basic_rules.rule_of_oprea(smiles)
passes_cns = mc.rules.basic_rules.rule_of_cns(smiles)

Multiples règles avec RuleFilters :

import datamol as dm
import medchem as mc

# Load molecules
mols = [dm.to_mol(smiles) for smiles in smiles_list]

# Create filter with multiple rules
rfilter = mc.rules.RuleFilters(
    rule_list=[
        "rule_of_five",
        "rule_of_oprea",
        "rule_of_cns",
        "rule_of_leadlike_soft"
    ]
)

# Apply filters with parallelization
results = rfilter(
    mols=mols,
    n_jobs=-1,  # Use all CPU cores
    progress=True
)

Format des résultats : Les résultats sont retournés sous forme de dictionnaires avec le statut réussi/échoué et les informations détaillées pour chaque règle.

2. Filtres d'alertes structurales

Détectez les motifs structuraux potentiellement problématiques en utilisant le module medchem.structural.

Filtres disponibles :

1. Common Alerts - Alertes structurales générales dérivées de la curation ChEMBL et de la littérature
2. Filtres NIBR - Ensemble de filtres des Novartis Institutes for BioMedical Research
3. Lilly Demerits - Système basé sur les démérites d'Eli Lilly (275 règles, molécules rejetées à >100 démérites)

Alertes communes :

import medchem as mc

# Create filter
alert_filter = mc.structural.CommonAlertsFilters()

# Check single molecule
mol = dm.to_mol("c1ccccc1")
has_alerts, details = alert_filter.check_mol(mol)

# Batch filtering with parallelization
results = alert_filter(
    mols=mol_list,
    n_jobs=-1,
    progress=True
)

Filtres NIBR :

import medchem as mc

# Apply NIBR filters
nibr_filter = mc.structural.NIBRFilters()
results = nibr_filter(mols=mol_list, n_jobs=-1)

Lilly Demerits :

import medchem as mc

# Calculate Lilly demerits
lilly = mc.structural.LillyDemeritsFilters()
results = lilly(mols=mol_list, n_jobs=-1)

# Each result includes demerit score and whether it passes (≤100 demerits)

3. API fonctionnelle pour les opérations de haut niveau

Le module medchem.functional fournit des fonctions pratiques pour les workflows courants.

Filtrage rapide :

import medchem as mc

# Apply NIBR filters to a list
filter_ok = mc.functional.nibr_filter(
    mols=mol_list,
    n_jobs=-1
)

# Apply common alerts
alert_results = mc.functional.common_alerts_filter(
    mols=mol_list,
    n_jobs=-1
)

4. Détection de groupes chimiques

Identifiez les groupes chimiques et les groupes fonctionnels spécifiques en utilisant medchem.groups.

Groupes disponibles :

• Hinge binders
• Phosphate binders
• Michael acceptors
• Groupes réactifs
• Motifs SMARTS personnalisés

Utilisation :

import medchem as mc

# Create group detector
group = mc.groups.ChemicalGroup(groups=["hinge_binders"])

# Check for matches
has_matches = group.has_match(mol_list)

# Get detailed match information
matches = group.get_matches(mol)

5. Catalogues nommés

Accédez à des collections curées de structures chimiques via medchem.catalogs.

Catalogues disponibles :

• Groupes fonctionnels
• Groupes de protection
• Réactifs courants
• Fragments standards

Utilisation :

import medchem as mc

# Access named catalogs
catalogs = mc.catalogs.NamedCatalogs

# Use catalog for matching
catalog = catalogs.get("functional_groups")
matches = catalog.get_matches(mol)

6. Complexité moléculaire

Calculez les métriques de complexité qui approchent l'accessibilité synthétique en utilisant medchem.complexity.

Métriques courantes :

• Complexité Bertz
• Complexité Whitlock
• Complexité Barone

Utilisation :

import medchem as mc

# Calculate complexity
complexity_score = mc.complexity.calculate_complexity(mol)

# Filter by complexity threshold
complex_filter = mc.complexity.ComplexityFilter(max_complexity=500)
results = complex_filter(mols=mol_list)

7. Filtrage des contraintes

Appliquez des contraintes personnalisées basées sur les propriétés en utilisant medchem.constraints.

Exemples de contraintes :

• Plages de poids moléculaire
• Limites de LogP
• Limites de TPSA
• Nombres de liaisons rotatives

Utilisation :

import medchem as mc

# Define constraints
constraints = mc.constraints.Constraints(
    mw_range=(200, 500),
    logp_range=(-2, 5),
    tpsa_max=140,
    rotatable_bonds_max=10
)

# Apply constraints
results = constraints(mols=mol_list, n_jobs=-1)

8. Langage de requête Medchem

Utilisez un langage de requête spécialisé pour les critères de filtrage complexes.

Exemples de requêtes :

# Molecules passing Ro5 AND not having common alerts
"rule_of_five AND NOT common_alerts"

# CNS-like molecules with low complexity
"rule_of_cns AND complexity < 400"

# Leadlike molecules without Lilly demerits
"rule_of_leadlike AND lilly_demerits == 0"

Utilisation :

import medchem as mc

# Parse and apply query
query = mc.query.parse("rule_of_five AND NOT common_alerts")
results = query.apply(mols=mol_list, n_jobs=-1)

Modèles de workflow

Modèle 1 : Triage initial d'une bibliothèque de composés

Filtrez une large collection de composés pour identifier les candidats ressemblant à des médicaments.

import datamol as dm
import medchem as mc
import pandas as pd

# Load compound library
df = pd.read_csv("compounds.csv")
mols = [dm.to_mol(smi) for smi in df["smiles"]]

# Apply primary filters
rule_filter = mc.rules.RuleFilters(rule_list=["rule_of_five", "rule_of_veber"])
rule_results = rule_filter(mols=mols, n_jobs=-1, progress=True)

# Apply structural alerts
alert_filter = mc.structural.CommonAlertsFilters()
alert_results = alert_filter(mols=mols, n_jobs=-1, progress=True)

# Combine results
df["passes_rules"] = rule_results["pass"]
df["has_alerts"] = alert_results["has_alerts"]
df["drug_like"] = df["passes_rules"] & ~df["has_alerts"]

# Save filtered compounds
filtered_df = df[df["drug_like"]]
filtered_df.to_csv("filtered_compounds.csv", index=False)

Modèle 2 : Filtrage pour l'optimisation du composé principal

Appliquez des critères plus stricts lors de l'optimisation du composé principal.

import medchem as mc

# Create comprehensive filter
filters = {
    "rules": mc.rules.RuleFilters(rule_list=["rule_of_leadlike_strict"]),
    "alerts": mc.structural.NIBRFilters(),
    "lilly": mc.structural.LillyDemeritsFilters(),
    "complexity": mc.complexity.ComplexityFilter(max_complexity=400)
}

# Apply all filters
results = {}
for name, filt in filters.items():
    results[name] = filt(mols=candidate_mols, n_jobs=-1)

# Identify compounds passing all filters
passes_all = all(r["pass"] for r in results.values())

Modèle 3 : Identifier des groupes chimiques spécifiques

Trouvez les molécules contenant des groupes fonctionnels ou des scaffolds spécifiques.

import medchem as mc

# Create group detector for multiple groups
group_detector = mc.groups.ChemicalGroup(
    groups=["hinge_binders", "phosphate_binders"]
)

# Screen library
matches = group_detector.get_all_matches(mol_list)

# Filter molecules with desired groups
mol_with_groups = [mol for mol, match in zip(mol_list, matches) if match]

Bonnes pratiques

1. Le contexte compte : N'appliquez pas aveuglément des filtres. Comprenez la cible biologique et l'espace chimique.

2. Combinez plusieurs filtres : Utilisez ensemble les règles, les alertes structurales et les connaissances de domaine pour de meilleures décisions.

3. Utilisez la parallélisation : Pour les grands ensembles de données (>1 000 molécules), utilisez toujours n_jobs=-1 pour le traitement parallèle.

4. Raffinement itératif : Commencez par des filtres larges (Ro5), puis appliquez des critères plus spécifiques (CNS, leadlike) selon les besoins.

5. Documentez les décisions de filtrage : Suivez quelles molécules ont été filtrées et pourquoi pour la reproductibilité.

6. Validez les résultats : Souvenez-vous que les médicaments commercialisés échouent souvent aux filtres standard—utilisez-les comme des lignes directrices, pas des règles absolues.

7. Considérez les prodrogues : Les molécules conçues comme prodrogues peuvent intentionnellement violer les règles standard de chimie médicinale.

Ressources

references/api_guide.md

Référence API complète couvrant tous les modules medchem avec les signatures de fonctions détaillées, les paramètres et les types de retour.

references/rules_catalog.md

Catalogue complet des règles, filtres et alertes disponibles avec descriptions, seuils et références littéraires.

scripts/filter_molecules.py

Script prêt pour la production pour les workflows de filtrage par lots. Supporte plusieurs formats d'entrée (CSV, SDF, SMILES), les combinaisons de filtres configurables et les rapports détaillés.

Utilisation :

python scripts/filter_molecules.py input.csv --rules rule_of_five,rule_of_cns --alerts nibr --output filtered.csv

Documentation

Documentation officielle : https://medchem-docs.datamol.io/ Dépôt GitHub : https://github.com/datamol-io/medchem