diff --git a/.gitignore b/.gitignore index fed07500..763b11f8 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,216 @@ +# FEGrow ignore_git -.idea -fegrow.egg-info/ + +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[codz] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py.cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# UV +# Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +#uv.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock +#poetry.toml + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +# pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python. +# https://pdm-project.org/en/latest/usage/project/#working-with-version-control +#pdm.lock +#pdm.toml +.pdm-python +.pdm-build/ + +# pixi +# Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control. +#pixi.lock +# Pixi creates a virtual environment in the .pixi directory, just like venv module creates one +# in the .venv directory. It is recommended not to include this directory in version control. +.pixi + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.envrc +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +.idea/ + +# Abstra +# Abstra is an AI-powered process automation framework. +# Ignore directories containing user credentials, local state, and settings. +# Learn more at https://abstra.io/docs +.abstra/ + +# Visual Studio Code +# Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore +# that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore +# and can be added to the global gitignore or merged into this file. However, if you prefer, +# you could uncomment the following to ignore the entire vscode folder +# .vscode/ + +# Ruff stuff: +.ruff_cache/ + +# PyPI configuration file +.pypirc + +# Cursor +# Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to +# exclude from AI features like autocomplete and code analysis. Recommended for sensitive data +# refer to https://docs.cursor.com/context/ignore-files +.cursorignore +.cursorindexingignore + +# Marimo +marimo/_static/ +marimo/_lsp/ +__marimo__/ + +# Streamlit +.streamlit/secrets.toml + +# VSCode +.vscode diff --git a/CHANGELOG b/CHANGELOG index 6bf9f331..4d1a5757 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,6 +1,9 @@ Authors: Mateusz K. Bieniek, Ben Cree, Rachael Pirie, Joshua T. Horton, Natalie J. Tatum, Daniel J. Cole +**version 3.0.0** + - Compatibility with MACE MLPs for optimising the ligand. + **version 2.0.1 ** - The scaffold's R atom breaks the constrained embedding. The R atom is now omitted. (#74) diff --git a/docs/notebooks/notebook1-basic-tutorial-full/1_basic_tutorial_full.md b/docs/notebooks/notebook1-basic-tutorial-full/1_basic_tutorial_full.md index 9616c058..7dfe6cee 100644 --- a/docs/notebooks/notebook1-basic-tutorial-full/1_basic_tutorial_full.md +++ b/docs/notebooks/notebook1-basic-tutorial-full/1_basic_tutorial_full.md @@ -554,7 +554,7 @@ The remaining conformers are optimised using hybrid machine learning / molecular energies = rmol.optimise_in_receptor( receptor_file="rec_final.pdb", ligand_force_field="openff", - use_ani=True, + ligand_intramolecular_force_field="ani2x", sigma_scale_factor=0.8, relative_permittivity=4, water_model = None, diff --git a/docs/notebooks/notebook2.1-tutorial-single-molecule/2_tutorial_single_mol.md b/docs/notebooks/notebook2.1-tutorial-single-molecule/2_tutorial_single_mol.md index b345cb62..0220e11d 100644 --- a/docs/notebooks/notebook2.1-tutorial-single-molecule/2_tutorial_single_mol.md +++ b/docs/notebooks/notebook2.1-tutorial-single-molecule/2_tutorial_single_mol.md @@ -4448,7 +4448,7 @@ The remaining conformers are optimised using hybrid machine learning / molecular energies = rmol.optimise_in_receptor( receptor_file="rec_final.pdb", ligand_force_field="openff", - use_ani=True, + ligand_intramolecular_force_field="ani2x", sigma_scale_factor=0.8, relative_permittivity=4, water_model = None, diff --git a/docs/notebooks/notebook4-introduce-chemspace/4_tutorial_introduce_chemspace.md b/docs/notebooks/notebook4-introduce-chemspace/4_tutorial_introduce_chemspace.md index ce98f477..bb44210d 100644 --- a/docs/notebooks/notebook4-introduce-chemspace/4_tutorial_introduce_chemspace.md +++ b/docs/notebooks/notebook4-introduce-chemspace/4_tutorial_introduce_chemspace.md @@ -4447,7 +4447,7 @@ The remaining conformers are optimised using hybrid machine learning / molecular energies = cs.optimise_in_receptor( receptor_file="rec_final.pdb", ligand_force_field="openff", - use_ani=True, + ligand_intramolecular_mlp="ani2x", sigma_scale_factor=0.8, relative_permittivity=4, water_model = None, diff --git a/docs/tutorials/0_basic/0_basic_tutorial_full.md b/docs/tutorials/0_basic/0_basic_tutorial_full.md index e86f26f1..2e5ab28c 100644 --- a/docs/tutorials/0_basic/0_basic_tutorial_full.md +++ b/docs/tutorials/0_basic/0_basic_tutorial_full.md @@ -328,8 +328,8 @@ fegrow.fix_receptor("rec.pdb", "rec_final.pdb") rec_final = prody.parsePDB("rec_final.pdb") ``` - File ‘7L10.pdb’ already there; not retrieving. - + File ‘7L10.pdb’ already there; not retrieving. + @> 2609 atoms and 1 coordinate set(s) were parsed in 0.05s. @@ -544,7 +544,7 @@ The remaining conformers are optimised using hybrid machine learning / molecular energies = rmol.optimise_in_receptor( receptor_file="rec_final.pdb", ligand_force_field="openff", - use_ani=True, + ligand_intramolecular_mlp="ani2x", sigma_scale_factor=0.8, relative_permittivity=4, water_model=None, diff --git a/docs/tutorials/1_chemspace/1_tutorial_introduce_chemspace.md b/docs/tutorials/1_chemspace/1_tutorial_introduce_chemspace.md index 38a4ef3e..42af4d84 100644 --- a/docs/tutorials/1_chemspace/1_tutorial_introduce_chemspace.md +++ b/docs/tutorials/1_chemspace/1_tutorial_introduce_chemspace.md @@ -49,7 +49,7 @@ The provided core structure is adapted from a recent study by [Jorgensen and co- !obabel -ipdb sarscov2/lig.pdb -osdf -O sarscov2/coreh.sdf -p 7 ``` - 1 molecule converted + 1 molecule converted @@ -4238,8 +4238,8 @@ fegrow.fix_receptor("rec.pdb", "rec_final.pdb") rec_final = prody.parsePDB("rec_final.pdb") ``` - File ‘7L10.pdb’ already there; not retrieving. - + File ‘7L10.pdb’ already there; not retrieving. + @> 2609 atoms and 1 coordinate set(s) were parsed in 0.05s. @@ -4411,7 +4411,7 @@ The remaining conformers are optimised using hybrid machine learning / molecular energies = cs.optimise_in_receptor( receptor_file="rec_final.pdb", ligand_force_field="openff", - use_ani=True, + ligand_intramolecular_mlp="ani2x", sigma_scale_factor=0.8, relative_permittivity=4, water_model=None, diff --git a/environment.yml b/environment.yml index fdc04e3c..ad0c0cdf 100644 --- a/environment.yml +++ b/environment.yml @@ -30,3 +30,5 @@ dependencies: - modal # modAL on pip - cachey - pyparsing<3.1.0 # temporary fix for prody + - nnpops + - pooch diff --git a/fegrow/__init__.py b/fegrow/__init__.py index cad9fcb4..bf293bdf 100644 --- a/fegrow/__init__.py +++ b/fegrow/__init__.py @@ -3,6 +3,7 @@ # activate nanomolar units in Pandas import pint_pandas # noqa: F401 +from . import mlp # noqa: F401 from .conformers import WrongCoreForMolecule, generate_conformers from .package import ( ChemSpace, diff --git a/fegrow/cli/utils.py b/fegrow/cli/utils.py index 8b382945..3c474299 100644 --- a/fegrow/cli/utils.py +++ b/fegrow/cli/utils.py @@ -8,6 +8,7 @@ from fegrow import RMol from fegrow.receptor import ForceField +from fegrow.mlp import MLForceFieldName class Settings(BaseModel): @@ -25,9 +26,14 @@ class Settings(BaseModel): "openff", description="The force field model to use for the small molecule during the restrained optimisation.", ) - use_ani: bool = Field( - True, - description="If we should attempt to use ANI2x to model the internal energies of the ligand in an ML/MM optimisation.", + use_ani: Optional[bool] = Field( + None, + description="**DEPRECATED**: Use 'ligand_intramolecular_mlp' instead. This field is kept for backwards compatibility only.", + ) + ligand_intramolecular_mlp: Optional[MLForceFieldName] = Field( + None, + description="The machine learning force field that should be used for the ligand intramolecular interactions. " + "If set to None, the molecular mechanics ligand_force_field is used for all ligand interactions. ", ) sigma_scale_factor: float = Field( 0.8, @@ -54,6 +60,21 @@ class Settings(BaseModel): description="The relative energy cutoff in kcal/mol used to select the top conformers for scoring.", ) + def model_post_init(self, __context) -> None: + """Validate and handle deprecated use_ani parameter.""" + if self.use_ani is not None: + raise ValueError( + "The 'use_ani' parameter has been deprecated and removed. " + "Please use 'ligand_intramolecular_mlp' instead.\n\n" + "Migration guide:\n" + " - Old: use_ani=true\n" + " - New: ligand_intramolecular_mlp='ani2x'\n\n" + " - Old: use_ani=false\n" + " - New: ligand_intramolecular_mlp=None\n\n" + "Available MLPs: 'ani2x', 'mace-off23-small', 'mace-off23-medium', " + "'mace-off23-large', 'egret-1'" + ) + @dask.delayed def score_ligand( @@ -86,7 +107,7 @@ def score_ligand( rmol.optimise_in_receptor( receptor_file=receptor, ligand_force_field=settings.ligand_force_field, - use_ani=settings.use_ani, + ligand_intramolecular_mlp=settings.ligand_intramolecular_mlp, sigma_scale_factor=settings.sigma_scale_factor, relative_permittivity=settings.relative_permittivity, water_model=settings.water_model, diff --git a/fegrow/mlp.py b/fegrow/mlp.py new file mode 100644 index 00000000..0a448dd3 --- /dev/null +++ b/fegrow/mlp.py @@ -0,0 +1,174 @@ +"""Functionality for working with ML force fields.""" + +from abc import ABC, abstractmethod +import pooch +import logging +from typing import Literal + +from openff.toolkit import Molecule +from openmmml import MLPotential as OMMMLPotential + +logger = logging.getLogger(__name__) + +__all__ = [ + "MLForceFieldName", + "ANI2X", + "MACEOFF23Small", + "MACEOFF23Medium", + "MACEOFF23Large", + "EGRET1", +] + +_EGRET1_MODEL_URL = ( + "https://github.com/rowansci/egret-public/raw/227d6641e6851" + "eb1037d48712462e4ce61c1518f/compiled_models/EGRET_1.model" +) + +MLForceFieldName = Literal[ + "ani2x", + "mace-off23-small", + "mace-off23-medium", + "mace-off23-large", + "egret-1", +] + + +def check_mace_installed() -> None: + """Check that mace-torch is installed.""" + try: + import mace # noqa: F401 + + except ImportError: + msg = ( + "Using a MACE force field requires the `mace_torch` package. " + "Please install it with `pip install mace-torch`." + ) + raise ImportError(msg) + + +class MLForceField(ABC): + """Abstract base class for machine learning force fields.""" + + name: str + allowed_elements: frozenset[str] + allow_charged: bool = False + + @classmethod + @abstractmethod + def get_potential(cls) -> OMMMLPotential: + """Get the OpenMM MLPotential for this force field.""" + + @classmethod + def _check_available(cls) -> None: + """Check if the force field is available and raise an error if not.""" + + @classmethod + def is_compatible_with_molecule(cls, molecule: Molecule) -> bool: + """ + Check if the force field is compatible with the given molecule. + + Args: + molecule (OFFMolecule): The molecule to check compatibility with. + + Returns: + bool: True if compatible, False otherwise. + """ + mol_elements = set(atom.symbol for atom in molecule.atoms) + if not mol_elements.issubset(cls.allowed_elements): + return False + # Work out the total formal charge + rdkit_mol = molecule.to_rdkit() + total_charge = sum(atom.GetFormalCharge() for atom in rdkit_mol.GetAtoms()) + if not cls.allow_charged and total_charge != 0: + return False + return True + + +class ANI2X(MLForceField): + name = "ani2x" + allowed_elements = frozenset(["H", "C", "N", "O", "S", "F", "Cl"]) + allow_charged = False + + @classmethod + def get_potential(cls) -> OMMMLPotential: + """Get the ANI2x potential.""" + return OMMMLPotential(cls.name) + + +class _MACE_BASE(MLForceField): + """Base class for MACE force fields.""" + + allowed_elements = frozenset(["C", "H", "N", "O", "S", "F", "Cl", "Br"]) + allow_charged = False + + @classmethod + def get_potential(cls) -> OMMMLPotential: + """Get the MACE potential.""" + + cls._check_available() + + logger.warning( + "MACE models are distributed under the ASL which" + "does not permit commercial use." + ) + + return OMMMLPotential(cls.name) + + @staticmethod + def _check_available() -> None: + """Check if the MACE force field is available.""" + check_mace_installed() + + +class MACEOFF23Small(_MACE_BASE): + """MACE-OFF 23 Small force field.""" + + name = "mace-off23-small" + + +class MACEOFF23Medium(_MACE_BASE): + """MACE-OFF 23 Medium force field.""" + + name = "mace-off23-medium" + + +class MACEOFF23Large(_MACE_BASE): + """MACE-OFF 23 Large force field.""" + + name = "mace-off23-large" + + +class EGRET1(MLForceField): + """EGRET-1 force field.""" + + name = "egret-1" + allowed_elements = frozenset(["C", "H", "N", "O", "S", "F", "Cl", "Br"]) + allow_charged = False + + @classmethod + def get_potential(cls) -> OMMMLPotential: + """Get the EGRET-1 potential.""" + + cls._check_available() + + model_path = pooch.retrieve( + url=_EGRET1_MODEL_URL, + known_hash="e674f134fd463c11f78fab182419bed8e0b5e1485ca4cad006fd327f9b8bf1ca", + path=pooch.os_cache("fegrow"), + ) + + return OMMMLPotential("mace", modelPath=model_path) + + @staticmethod + def _check_available() -> None: + """Check if the EGRET-1 MLP is available.""" + check_mace_installed() + + +AVAILABLE_ML_FORCE_FIELD_CLASSES: dict[MLForceFieldName, type[MLForceField]] = { + "ani2x": ANI2X, + "mace-off23-small": MACEOFF23Small, + "mace-off23-medium": MACEOFF23Medium, + "mace-off23-large": MACEOFF23Large, + "egret-1": EGRET1, +} diff --git a/fegrow/package.py b/fegrow/package.py index 2465fe82..6321854b 100644 --- a/fegrow/package.py +++ b/fegrow/package.py @@ -150,9 +150,8 @@ def generate_conformers( def optimise_in_receptor(self, *args, **kwargs): """ Enumerate the conformers inside of the receptor by employing - ANI2x, a hybrid machine learning / molecular mechanics (ML/MM) approach. - ANI2x is neural nework potential for the ligand energetics - but works only for the following atoms: H, C, N, O, F, S, Cl. + a hybrid machine learning / molecular mechanics (ML/MM) approach + with MLPs such as MACE-OFF-23 and ANI2x. Open Force Field Parsley force field is used for intermolecular interactions with the receptor. @@ -613,8 +612,8 @@ def __init__( ) warnings.warn( "ANI uses TORCHAni which is not threadsafe, leading to random SEGFAULTS. " - "Use a Dask cluster with processes as a work around " - "(see the documentation for an example of this workaround) ." + "mace-torch has the same issue. Use a Dask cluster with processes as a " + "work around (see the documentation for an example of this workaround)." ) kwargs = { @@ -735,6 +734,15 @@ def optimise_in_receptor(self, *args, **kwargs): """ Return lists of energies. """ + # Check we're not using an MLP with processes= False + if ( + kwargs.get("ligand_intramolecular_mlp", None) is not None + and self._dask_cluster.processes is False + ): + raise ValueError( + "When using ML-based ligand intramolecular potentials, " + "Dask has to be configured with `processes=True`." + ) # daskify parameters args = [dask.delayed(arg) for arg in args] @@ -1021,6 +1029,7 @@ def evaluate( minimum_conf_rms=0.5, penalty=pd.NA, al_ignore_penalty=True, + ligand_intramolecular_mlp="ani2x", **kwargs, ): """ @@ -1081,6 +1090,26 @@ def evaluate( if len(h_attachements) > 0: h_attachement_index = h_attachements[0] + if kwargs.get("ani", None) is not None: + raise ValueError( + "The 'ani' parameter has been deprecated and removed. " + "Please use 'ligand_intramolecular_mlp' instead.\n\n" + "Migration guide:\n" + " - Old: ani=True\n" + " - New: ligand_intramolecular_mlp='ani2x'\n\n" + " - Old: ani=False\n" + " - New: ligand_intramolecular_mlp=None\n\n" + ) + + if ( + ligand_intramolecular_mlp is not None + and self._dask_cluster.processes is False + ): + raise ValueError( + "When using ML-based ligand intramolecular potentials, " + "Dask has to be configured with `processes=True`." + ) + # create dask jobs delayed_evaluate = dask.delayed(_evaluate_atomic) jobs = {} @@ -1768,7 +1797,8 @@ def _evaluate_atomic( scoring_function=None, num_conf=50, minimum_conf_rms=0.5, - ani=True, + ligand_intramolecular_mlp=None, + ani=None, platform="CPU", gnina_gpu=False, skip_optimisation=False, @@ -1784,7 +1814,6 @@ def _evaluate_atomic( :param gnina_path: :return: """ - if full_evaluation is not None: return full_evaluation( scaffold, @@ -1794,6 +1823,7 @@ def _evaluate_atomic( scoring_function=None, num_conf=50, minimum_conf_rms=0.5, + ligand_intramolecular_mlp=ligand_intramolecular_mlp, ani=ani, platform="CPU", skip_optimisation=False, @@ -1819,7 +1849,7 @@ def _evaluate_atomic( rmol.optimise_in_receptor( receptor_file=pdb_filename, ligand_force_field="openff", - use_ani=ani, + ligand_intramolecular_mlp=ligand_intramolecular_mlp, sigma_scale_factor=0.8, relative_permittivity=4, water_model=None, diff --git a/fegrow/receptor.py b/fegrow/receptor.py index 0fab1338..0ce624fd 100644 --- a/fegrow/receptor.py +++ b/fegrow/receptor.py @@ -6,12 +6,13 @@ import numpy import parmed from openmmforcefields.generators import SystemGenerator -from openmmml import MLPotential from pdbfixer import PDBFixer from rdkit import Chem from rdkit.Geometry.rdGeometry import Point3D from tqdm import tqdm -from typing_extensions import Literal +from typing_extensions import Literal, get_args + +from fegrow.mlp import AVAILABLE_ML_FORCE_FIELD_CLASSES, MLForceFieldName import warnings @@ -79,7 +80,7 @@ def fix_receptor( :param input_file: The name of the pdb file which contains the receptor. :param output_file: The name of the pdb file the fixed receptor should be wrote to. - :param pH:The ph the pronation state should be fixed for. + :param pH: The pH the protonation state should be fixed for. :param prefer_chimera_protonation: If True, use Chimera to protonate the receptor instead of PDBFixer. """ fixer = PDBFixer(filename=input_file) @@ -105,18 +106,6 @@ def fix_receptor( chimera_protonate(temp_pdb.name, output_file) -def _can_use_ani2x(molecule: OFFMolecule) -> bool: - """ - Check if ani2x can be used for this molecule by inspecting the elements. - """ - mol_elements = set([atom.symbol for atom in molecule.atoms]) - ani2x_elements = {"H", "C", "N", "O", "S", "F", "Cl"} - if mol_elements - ani2x_elements: - # if there is any difference in the sets or a net charge ani2x can not be used. - return False - return True - - def _scale_system( system: openmm.System, sigma_scale_factor: float, relative_permittivity: float ): @@ -148,12 +137,13 @@ def optimise_in_receptor( ligand: Chem.Mol, receptor_file: Union[str, app.PDBFile], ligand_force_field: ForceField, - use_ani: bool = True, + ligand_intramolecular_mlp: Optional[MLForceFieldName] = None, sigma_scale_factor: float = 0.8, relative_permittivity: float = 4, water_model: str = "tip3p.xml", platform_name: str = "CPU", ligand_indices_to_freeze: Optional[list[int]] = None, + use_ani: Optional[bool] = None, ) -> Tuple[Chem.Mol, List[float]]: """ For each of the input molecule conformers optimise the system using the chosen force field with the receptor held fixed. @@ -165,8 +155,10 @@ def optimise_in_receptor( The pdb file of the fixed and pronated receptor. ligand_force_field: The base ligand force field that should be used. - use_ani: - If we should try and use ani2x for the internal energy of the ligand. + ligand_intramolecular_mlp: + The machine learning force field that should be used for the ligand intramolecular interactions. + If set to None, the molecular mechanics ligand_force_field is used for all ligand interactions. + Representations of available MLPs can be imported from the `fegrow.mlp` module. sigma_scale_factor: The factor by which all sigma values should be scaled relative_permittivity: @@ -179,11 +171,25 @@ def optimise_in_receptor( See the OpenMM documentation of Platform. ligand_indices_to_freeze: The ligand indices to be frozen (relative to the ligand) + use_ani: + **DEPRECATED**: This parameter has been removed. Use `ligand_intramolecular_mlp="ani2x"` instead. Returns: A copy of the input molecule with the optimised positions. """ + # Check for deprecated use_ani parameter + if use_ani is not None: + raise TypeError( + "The 'use_ani' parameter has been deprecated and removed. " + "Please use 'ligand_intramolecular_mlp' instead.\n\n" + "Migration guide:\n" + " - Old: optimise_in_receptor(..., use_ani=True)\n" + " - New: optimise_in_receptor(..., ligand_intramolecular_mlp='ani2x')\n\n" + " - Old: optimise_in_receptor(..., use_ani=False)\n" + " - New: optimise_in_receptor(..., ligand_intramolecular_mlp=None)\n\n" + ) + ligand_force_fields = { "openff": "openff_unconstrained-2.0.0.offxml", "gaff": "gaff-2.11", @@ -236,21 +242,43 @@ def optimise_in_receptor( for idx in ligand_indices_to_freeze: system.setParticleMass(ligand_idx[idx], 0) - # if we want to use ani2x check we can and adapt the system - if use_ani and _can_use_ani2x(openff_mol): - print("using ani2x") - potential = MLPotential("ani2x", platform_name=platform_name) + # Check if we want to add an intramolecular MLP + if ligand_intramolecular_mlp is not None: + logger.info( + f"Using ligand intramolecular MLP: {ligand_intramolecular_mlp} " + "for ligand intramolecular interactions and " + f"{ligand_force_field} for intermolecular interactions." + ) + + if ligand_intramolecular_mlp not in get_args(MLForceFieldName): + raise ValueError( + f"ligand_intramolecular_mlp must be one of {MLForceFieldName}" + ) - # save the torch model animodel.pt to a temporary file to ensure this is thread safe - # note this file will be closed when garbage collected - tmpfile = tempfile.NamedTemporaryFile() + # get the MLP class + ligand_intramolecular_mlp_class = AVAILABLE_ML_FORCE_FIELD_CLASSES[ + ligand_intramolecular_mlp + ] + + if not ligand_intramolecular_mlp_class.is_compatible_with_molecule(openff_mol): + raise ValueError( + f"The ligand {ligand} is not compatible with the MLP {ligand_intramolecular_mlp}" + ) + # create the potential + potential = ligand_intramolecular_mlp_class.get_potential() + # add the potential to the system complex_system = potential.createMixedSystem( - complex_structure.topology, system, ligand_idx, filename=tmpfile.name + complex_structure.topology, system, ligand_idx + ) + + else: # Use the MM FF for all ligand interactions + logger.info( + f"Using {ligand_force_field} force field for ligand intra and " + "inter-molecular interactions." ) - else: - print("Using force field") complex_system = system + # scale the charges and sigma values _scale_system( system=complex_system, diff --git a/fegrow/testing/asapsmiles/asapsmiles.py b/fegrow/testing/asapsmiles/asapsmiles.py index dfbf1acc..4049dbcc 100644 --- a/fegrow/testing/asapsmiles/asapsmiles.py +++ b/fegrow/testing/asapsmiles/asapsmiles.py @@ -36,7 +36,7 @@ energies = rlist[mol_id].optimise_in_receptor( receptor_file=protein_filename, ligand_force_field="openff", - use_ani=True, + ligand_intramolecular_mlp="ani2x", sigma_scale_factor=0.8, relative_permittivity=4, water_model=None, diff --git a/fegrow/testing/test_chemspace.py b/fegrow/testing/test_chemspace.py index e47cfc15..5fed2438 100644 --- a/fegrow/testing/test_chemspace.py +++ b/fegrow/testing/test_chemspace.py @@ -19,7 +19,9 @@ def test_chem_space(RGroups, sars_scaffold_chunk_sdf, rec_7l10_final_path): # check if two molecules were built with chemspace - chemspace = ChemSpace() + chemspace = ChemSpace( + dask_local_cluster_kwargs={"processes": True} + ) # Required for use with MLPs R_group_ethanol = RGroups[RGroups.Name == "*CCO"].Mol.item() R_group_cyclopropane = RGroups[RGroups.Name == "*C1CC1"].Mol.item() @@ -37,7 +39,11 @@ def test_chem_space(RGroups, sars_scaffold_chunk_sdf, rec_7l10_final_path): rec_final = prody.parsePDB(rec_7l10_final_path) chemspace.remove_clashing_confs(rec_final) - chemspace.optimise_in_receptor(rec_7l10_final_path, "openff", use_ani=False) + chemspace.optimise_in_receptor( + rec_7l10_final_path, + "openff", + ligand_intramolecular_mlp="ani2x", + ) cnnaff = chemspace.gnina(rec_7l10_final_path) # ensure unique IDs for each molecule @@ -62,7 +68,9 @@ def test_pipeline_experimental(RGroups, sars_scaffold_chunk_sdf, rec_7l10_final_ def test_pipeline_rgroups(RGroups, sars_scaffold_chunk_sdf, rec_7l10_final_path): # check if two molecules were built with chemspace - chemspace = ChemSpace() + chemspace = ChemSpace( + dask_local_cluster_kwargs={"processes": True} + ) # Required for use with MLPs R_group_ethanol = RGroups[RGroups.Name == "*CCO"].Mol.item() R_group_cyclopropane = RGroups[RGroups.Name == "*C1CC1"].Mol.item() @@ -203,7 +211,9 @@ def test_io_write_load(RGroups, sars_scaffold_chunk_sdf, rec_7l10_final_path): def test_pipeline_smiles(RGroups, sars_scaffold_chunk_sdf, rec_7l10_final_path): # check if two molecules were built with chemspace - chemspace = ChemSpace() + chemspace = ChemSpace( + dask_local_cluster_kwargs={"processes": True} + ) # Required for use with MLPs chemspace.add_scaffold(sars_scaffold_chunk_sdf, 8) # this could be a list of smiles, (but molecules would be automatically converted to smiles anyway) @@ -223,7 +233,9 @@ def test_pipeline_smiles(RGroups, sars_scaffold_chunk_sdf, rec_7l10_final_path): def test_pipeline_smiles_noh(RGroups, sars_scaffold_chunk_sdf, rec_7l10_final_path): # check if two molecules were built with chemspace - chemspace = ChemSpace() + chemspace = ChemSpace( + dask_local_cluster_kwargs={"processes": True} + ) # Required for use with MLPs bare_scaffold_noh = Chem.RemoveHs(sars_scaffold_chunk_sdf) chemspace.add_scaffold(bare_scaffold_noh) @@ -255,7 +267,9 @@ def test_evaluate_scoring_function_works( """ # check if two molecules were built with chemspace - chemspace = ChemSpace() + chemspace = ChemSpace( + dask_local_cluster_kwargs={"processes": True} + ) # Required for use with MLPs chemspace.add_scaffold(sars_scaffold_chunk_sdf, 8) chemspace.add_smiles(["[H]OC([H])([H])C([H])([H])c1c([H])nc([H])c([H])c1[H]"]) @@ -284,7 +298,9 @@ def test_evaluate_scoring_function_saves_data( """ # check if two molecules were built with chemspace - chemspace = ChemSpace() + chemspace = ChemSpace( + dask_local_cluster_kwargs={"processes": True} + ) # Required for use with MLPs chemspace.add_scaffold(sars_scaffold_chunk_sdf, 8) chemspace.add_smiles(["[H]OC([H])([H])C([H])([H])c1c([H])nc([H])c([H])c1[H]"]) @@ -312,7 +328,9 @@ def test_evaluate_full_hijack(RGroups, sars_scaffold_chunk_sdf, rec_7l10_final_p """ # check if two molecules were built with chemspace - chemspace = ChemSpace() + chemspace = ChemSpace( + dask_local_cluster_kwargs={"processes": True} + ) # Required for use with MLPs chemspace.add_scaffold(sars_scaffold_chunk_sdf, 8) chemspace.add_smiles(["[H]OC([H])([H])C([H])([H])c1c([H])nc([H])c([H])c1[H]"]) @@ -370,7 +388,9 @@ def test_al_local(sars_scaffold_chunk_sdf, rec_7l10_final_path): """ # check if two molecules were built with chemspace - chemspace = ChemSpace() + chemspace = ChemSpace( + dask_local_cluster_kwargs={"processes": True} + ) # Required for use with MLPs scaffold = Chem.SDMolSupplier(str(root / "data/5R83_core.sdf"), removeHs=False)[0] chemspace.add_scaffold(scaffold, 6) @@ -429,7 +449,9 @@ def test_al_full(RGroups, sars_scaffold_chunk_sdf, rec_7l10_final_path): """ # check if two molecules were built with chemspace - chemspace = ChemSpace() + chemspace = ChemSpace( + dask_local_cluster_kwargs={"processes": True} + ) # Required for use with MLPs scaffold = Chem.SDMolSupplier(str(root / "data/5R83_core.sdf"), removeHs=False)[0] chemspace.add_scaffold(scaffold, 6) @@ -463,7 +485,9 @@ def oracle_look_up(scaffold, h, smiles, *args, **kwargs): def test_al_manual_gp(RGroups, sars_scaffold_chunk_sdf, rec_7l10_final_path): """ """ # check if two molecules were built with chemspace - chemspace = ChemSpace() + chemspace = ChemSpace( + dask_local_cluster_kwargs={"processes": True} + ) # Required for use with MLPs scaffold = Chem.SDMolSupplier(str(root / "data/5R83_core.sdf"), removeHs=False)[0] chemspace.add_scaffold(scaffold, 6) @@ -529,7 +553,9 @@ def test_adding_enamines(RGroups, sars_scaffold_chunk_sdf, rec_7l10_final_path): """ # check if two molecules were built with chemspace - chemspace = ChemSpace() + chemspace = ChemSpace( + dask_local_cluster_kwargs={"processes": True} + ) # Required for use with MLPs chemspace.add_scaffold(sars_scaffold_chunk_sdf, 8) chemspace.add_smiles(["[H]OC([H])([H])C([H])([H])c1c([H])nc([H])c([H])c1[H]"], h=8) @@ -545,3 +571,55 @@ def scorer(rmol, pdb_filename, data): # at least one extra one must have made it assert len(chemspace) > 1 + + +def test_ani_parameter_deprecation_error( + RGroups, sars_scaffold_chunk_sdf, rec_7l10_final_path +): + """Test that using the deprecated 'ani' parameter in evaluate raises an error.""" + chemspace = ChemSpace(dask_local_cluster_kwargs={"processes": True}) + + R_group_ethanol = RGroups[RGroups.Name == "*CCO"].Mol.item() + chemspace.add_scaffold(sars_scaffold_chunk_sdf, 8) + chemspace.add_rgroups([R_group_ethanol]) + chemspace.add_protein(rec_7l10_final_path) + + # Test that ani=True raises an error + with pytest.raises(ValueError) as exc_info: + chemspace.evaluate([0], ani=True, skip_optimisation=True) + + error_msg = str(exc_info.value) + assert "deprecated" in error_msg.lower() + assert "ligand_intramolecular_mlp" in error_msg + assert "ani2x" in error_msg + + # Test that ani=False also raises an error + with pytest.raises(ValueError) as exc_info: + chemspace.evaluate([0], ani=False, skip_optimisation=True) + + error_msg = str(exc_info.value) + assert "deprecated" in error_msg.lower() + assert "ligand_intramolecular_mlp" in error_msg + + +def test_ligand_intramolecular_mlp_requires_processes( + RGroups, sars_scaffold_chunk_sdf, rec_7l10_final_path +): + """Test that using MLPs without processes=True raises an error.""" + # Create ChemSpace with processes=False (default) + chemspace = ChemSpace(dask_local_cluster_kwargs={"processes": False}) + + R_group_ethanol = RGroups[RGroups.Name == "*CCO"].Mol.item() + chemspace.add_scaffold(sars_scaffold_chunk_sdf, 8) + chemspace.add_rgroups([R_group_ethanol]) + chemspace.add_protein(rec_7l10_final_path) + + # Test that using MLP with processes=False raises an error + with pytest.raises(ValueError) as exc_info: + chemspace.evaluate( + [0], ligand_intramolecular_mlp="ani2x", skip_optimisation=True + ) + + error_msg = str(exc_info.value) + assert "processes=True" in error_msg + assert "ML-based" in error_msg or "ligand intramolecular" in error_msg diff --git a/fegrow/testing/test_general.py b/fegrow/testing/test_general.py index 10ea2b66..bfae6896 100644 --- a/fegrow/testing/test_general.py +++ b/fegrow/testing/test_general.py @@ -1,6 +1,9 @@ from rdkit import Chem +import pytest +from pydantic import ValidationError import fegrow +from fegrow.cli.utils import Settings def test_adding_ethanol_1mol(RGroups, sars_core_scaffold): @@ -254,3 +257,39 @@ def test_add_a_linker_check_star(RLinkers, sars_scaffold_sdf): for atom in template_with_linker.GetAtoms(): if atom.GetAtomicNum() == 0: assert len(atom.GetBonds()) == 1 + + +def test_cli_settings_use_ani_deprecation_error(): + """Test that CLI Settings with use_ani parameter raises a helpful error.""" + + # Test with use_ani=True + with pytest.raises(ValidationError) as exc_info: + Settings( + gnina_path="/usr/bin/gnina", + use_ani=True, + ) + + error_msg = str(exc_info.value) + assert "deprecated" in error_msg.lower() + assert "ligand_intramolecular_mlp" in error_msg + assert "Migration guide" in error_msg + + # Test with use_ani=False + with pytest.raises(ValidationError) as exc_info: + Settings( + gnina_path="/usr/bin/gnina", + use_ani=False, + ) + + error_msg = str(exc_info.value) + assert "deprecated" in error_msg.lower() + assert "ligand_intramolecular_mlp" in error_msg + + +def test_cli_settings_without_use_ani_works(): + """Test that CLI Settings without use_ani parameter works correctly.""" + settings = Settings( + gnina_path="/usr/bin/gnina", + ligand_intramolecular_mlp="ani2x", + ) + assert settings.ligand_intramolecular_mlp == "ani2x" diff --git a/fegrow/testing/test_mlp.py b/fegrow/testing/test_mlp.py new file mode 100644 index 00000000..df2b1559 --- /dev/null +++ b/fegrow/testing/test_mlp.py @@ -0,0 +1,296 @@ +"""Tests for the mlp module.""" + +from unittest.mock import MagicMock, patch + +import pytest +from openff.toolkit import Molecule +from openmmml import MLPotential + +from fegrow.mlp import ( + ANI2X, + EGRET1, + MACEOFF23Large, + MACEOFF23Medium, + MACEOFF23Small, + AVAILABLE_ML_FORCE_FIELD_CLASSES, + check_mace_installed, +) + + +class TestCheckMaceInstalled: + """Tests for check_mace_installed function.""" + + @patch.dict("sys.modules", {"mace": MagicMock()}) + def test_check_mace_installed_success(self): + """Test that no error is raised when mace is installed.""" + # Should not raise any exception + check_mace_installed() + + def test_check_mace_not_installed(self): + """Test that ImportError is raised when mace is not installed.""" + with patch.dict("sys.modules", {"mace": None}): + with pytest.raises(ImportError, match="mace_torch"): + # Force re-import to trigger the import error + import importlib + import fegrow.mlp as mlp_module + + importlib.reload(mlp_module) + mlp_module.check_mace_installed() + + +class TestANI2X: + """Tests for the ANI2X force field.""" + + def test_name(self): + """Test that the name is correct.""" + assert ANI2X.name == "ani2x" + + def test_allowed_elements(self): + """Test that allowed elements are correct.""" + expected = frozenset(["H", "C", "N", "O", "S", "F", "Cl"]) + assert ANI2X.allowed_elements == expected + + def test_allow_charged(self): + """Test that charged molecules are not allowed.""" + assert ANI2X.allow_charged is False + + def test_get_potential(self): + """Test that get_potential returns an MLPotential.""" + potential = ANI2X.get_potential() + assert isinstance(potential, MLPotential) + + def test_compatible_with_methane(self): + """Test compatibility with a simple molecule (methane).""" + methane = Molecule.from_smiles("C") + assert ANI2X.is_compatible_with_molecule(methane) is True + + def test_compatible_with_ethanol(self): + """Test compatibility with ethanol.""" + ethanol = Molecule.from_smiles("CCO") + assert ANI2X.is_compatible_with_molecule(ethanol) is True + + def test_compatible_with_sulfur(self): + """Test compatibility with sulfur-containing molecule.""" + dimethyl_sulfide = Molecule.from_smiles("CSC") + assert ANI2X.is_compatible_with_molecule(dimethyl_sulfide) is True + + def test_compatible_with_fluorine(self): + """Test compatibility with fluorine-containing molecule.""" + fluoromethane = Molecule.from_smiles("CF") + assert ANI2X.is_compatible_with_molecule(fluoromethane) is True + + def test_compatible_with_chlorine(self): + """Test compatibility with chlorine-containing molecule.""" + chloromethane = Molecule.from_smiles("CCl") + assert ANI2X.is_compatible_with_molecule(chloromethane) is True + + def test_incompatible_with_bromine(self): + """Test incompatibility with bromine (not in allowed elements).""" + bromomethane = Molecule.from_smiles("CBr") + assert ANI2X.is_compatible_with_molecule(bromomethane) is False + + def test_incompatible_with_iodine(self): + """Test incompatibility with iodine (not in allowed elements).""" + iodomethane = Molecule.from_smiles("CI") + assert ANI2X.is_compatible_with_molecule(iodomethane) is False + + def test_incompatible_with_charged_molecule(self): + """Test incompatibility with charged molecules.""" + # Methylammonium (positively charged) + charged_mol = Molecule.from_smiles("[NH3+]C") + assert ANI2X.is_compatible_with_molecule(charged_mol) is False + + def test_incompatible_with_negatively_charged_molecule(self): + """Test incompatibility with negatively charged molecules.""" + # Acetate (negatively charged) + charged_mol = Molecule.from_smiles("CC([O-])=O") + assert ANI2X.is_compatible_with_molecule(charged_mol) is False + + +class TestMACEForceFields: + """Tests for MACE force field classes.""" + + @pytest.mark.parametrize( + "mace_class,expected_name", + [ + (MACEOFF23Small, "mace-off23-small"), + (MACEOFF23Medium, "mace-off23-medium"), + (MACEOFF23Large, "mace-off23-large"), + ], + ) + def test_names(self, mace_class, expected_name): + """Test that MACE force field names are correct.""" + assert mace_class.name == expected_name + + @pytest.mark.parametrize( + "mace_class", + [MACEOFF23Small, MACEOFF23Medium, MACEOFF23Large], + ) + def test_allowed_elements(self, mace_class): + """Test that MACE allowed elements are correct.""" + expected = frozenset(["C", "H", "N", "O", "S", "F", "Cl", "Br"]) + assert mace_class.allowed_elements == expected + + @pytest.mark.parametrize( + "mace_class", + [MACEOFF23Small, MACEOFF23Medium, MACEOFF23Large], + ) + def test_allow_charged(self, mace_class): + """Test that MACE force fields don't allow charged molecules.""" + assert mace_class.allow_charged is False + + @pytest.mark.parametrize( + "mace_class", + [MACEOFF23Small, MACEOFF23Medium, MACEOFF23Large], + ) + @patch("fegrow.mlp.check_mace_installed") + @patch("fegrow.mlp.logger") + def test_get_potential(self, mock_logger, mock_check, mace_class): + """Test that get_potential returns an MLPotential for MACE models.""" + potential = mace_class.get_potential() + assert isinstance(potential, MLPotential) + mock_check.assert_called_once() + # Check that the ASL license warning is logged + mock_logger.warning.assert_called_once() + assert "ASL" in mock_logger.warning.call_args[0][0] + + @pytest.mark.parametrize( + "mace_class", + [MACEOFF23Small, MACEOFF23Medium, MACEOFF23Large], + ) + def test_compatible_with_bromine(self, mace_class): + """Test MACE compatibility with bromine (allowed in MACE).""" + bromomethane = Molecule.from_smiles("CBr") + assert mace_class.is_compatible_with_molecule(bromomethane) is True + + @pytest.mark.parametrize( + "mace_class", + [MACEOFF23Small, MACEOFF23Medium, MACEOFF23Large], + ) + def test_incompatible_with_iodine(self, mace_class): + """Test MACE incompatibility with iodine (not in allowed elements).""" + iodomethane = Molecule.from_smiles("CI") + assert mace_class.is_compatible_with_molecule(iodomethane) is False + + @pytest.mark.parametrize( + "mace_class", + [MACEOFF23Small, MACEOFF23Medium, MACEOFF23Large], + ) + def test_incompatible_with_charged_molecule(self, mace_class): + """Test MACE incompatibility with charged molecules.""" + charged_mol = Molecule.from_smiles("[NH3+]C") + assert mace_class.is_compatible_with_molecule(charged_mol) is False + + +class TestEGRET1: + """Tests for the EGRET-1 force field.""" + + def test_name(self): + """Test that the name is correct.""" + assert EGRET1.name == "egret-1" + + def test_allowed_elements(self): + """Test that allowed elements are correct.""" + expected = frozenset(["C", "H", "N", "O", "S", "F", "Cl", "Br"]) + assert EGRET1.allowed_elements == expected + + def test_allow_charged(self): + """Test that charged molecules are not allowed.""" + assert EGRET1.allow_charged is False + + @patch("fegrow.mlp.check_mace_installed") + @patch("fegrow.mlp.pooch.retrieve") + def test_get_potential( + self, + mock_pooch_retrieve, + mock_check, + ): + """Test that get_potential retrieves model using pooch and returns + an MLPotential. + """ + # Mock pooch.retrieve to return a fake model path + mock_model_path = "/tmp/cached_egret.model" + mock_pooch_retrieve.return_value = mock_model_path + + potential = EGRET1.get_potential() + + assert isinstance(potential, MLPotential) + mock_check.assert_called_once() + # Check that pooch.retrieve was called with correct arguments + mock_pooch_retrieve.assert_called_once() + call_kwargs = mock_pooch_retrieve.call_args[1] + assert "url" in call_kwargs + assert "known_hash" in call_kwargs + assert "path" in call_kwargs + + def test_compatible_with_bromine(self): + """Test EGRET-1 compatibility with bromine.""" + bromomethane = Molecule.from_smiles("CBr") + assert EGRET1.is_compatible_with_molecule(bromomethane) is True + + def test_incompatible_with_iodine(self): + """Test EGRET-1 incompatibility with iodine.""" + iodomethane = Molecule.from_smiles("CI") + assert EGRET1.is_compatible_with_molecule(iodomethane) is False + + def test_incompatible_with_charged_molecule(self): + """Test EGRET-1 incompatibility with charged molecules.""" + charged_mol = Molecule.from_smiles("[NH3+]C") + assert EGRET1.is_compatible_with_molecule(charged_mol) is False + + +class TestMLFFNameToClass: + """Tests for the AVAILABLE_ML_FORCE_FIELD_CLASSES mapping.""" + + def test_mapping_contains_all_models(self): + """Test that the mapping contains all available models.""" + expected_keys = { + "ani2x", + "mace-off23-small", + "mace-off23-medium", + "mace-off23-large", + "egret-1", + } + assert set(AVAILABLE_ML_FORCE_FIELD_CLASSES.keys()) == expected_keys + + def test_mapping_values(self): + """Test that the mapping values are correct classes.""" + assert AVAILABLE_ML_FORCE_FIELD_CLASSES["ani2x"] == ANI2X + assert AVAILABLE_ML_FORCE_FIELD_CLASSES["mace-off23-small"] == MACEOFF23Small + assert AVAILABLE_ML_FORCE_FIELD_CLASSES["mace-off23-medium"] == MACEOFF23Medium + assert AVAILABLE_ML_FORCE_FIELD_CLASSES["mace-off23-large"] == MACEOFF23Large + assert AVAILABLE_ML_FORCE_FIELD_CLASSES["egret-1"] == EGRET1 + + +class TestCompatibilityEdgeCases: + """Tests for edge cases in molecule compatibility checking.""" + + def test_complex_molecule_compatible(self): + """Test compatibility with a more complex molecule.""" + # Aspirin + aspirin = Molecule.from_smiles("CC(=O)Oc1ccccc1C(=O)O") + assert ANI2X.is_compatible_with_molecule(aspirin) is True + assert MACEOFF23Medium.is_compatible_with_molecule(aspirin) is True + assert EGRET1.is_compatible_with_molecule(aspirin) is True + + def test_molecule_with_all_allowed_elements_ani2x(self): + """Test molecule containing all ANI2X allowed elements.""" + # Create a molecule with H, C, N, O, S, F, Cl + # Hypothetical molecule for testing + mol = Molecule.from_smiles("FC(Cl)C(=O)N(C)CS", allow_undefined_stereo=True) + assert ANI2X.is_compatible_with_molecule(mol) is True + + def test_molecule_with_all_allowed_elements_mace(self): + """Test molecule containing all MACE allowed elements.""" + # Create a molecule with C, H, N, O, S, F, Cl, Br + mol = Molecule.from_smiles("FC(Cl)C(=O)N(C)CSBr", allow_undefined_stereo=True) + assert MACEOFF23Medium.is_compatible_with_molecule(mol) is True + assert EGRET1.is_compatible_with_molecule(mol) is True + + def test_empty_molecule_elements(self): + """Test that single atoms are compatible if in allowed set.""" + # Single carbon atom + carbon = Molecule.from_smiles("C") + assert ANI2X.is_compatible_with_molecule(carbon) is True + assert MACEOFF23Medium.is_compatible_with_molecule(carbon) is True + assert EGRET1.is_compatible_with_molecule(carbon) is True diff --git a/fegrow/testing/test_receptor.py b/fegrow/testing/test_receptor.py index 6d968718..27ace6cc 100644 --- a/fegrow/testing/test_receptor.py +++ b/fegrow/testing/test_receptor.py @@ -1,8 +1,9 @@ import numpy as np import prody +import pytest from rdkit import Chem -from fegrow import build_molecule +from fegrow import build_molecule, optimise_in_receptor def test_mcs_atom_freezing(sars_scaffold_chunk_sdf, rec_7l10_final_path): @@ -21,7 +22,7 @@ def test_mcs_atom_freezing(sars_scaffold_chunk_sdf, rec_7l10_final_path): rmol.optimise_in_receptor( receptor_file=rec_7l10_final_path, ligand_force_field="openff", - use_ani=False, + ligand_intramolecular_mlp=None, water_model=None, platform_name="CPU", ligand_indices_to_freeze=scaffold_atoms, @@ -37,7 +38,7 @@ def test_mcs_atom_freezing(sars_scaffold_chunk_sdf, rec_7l10_final_path): rmol.optimise_in_receptor( receptor_file=rec_7l10_final_path, ligand_force_field="openff", - use_ani=False, + ligand_intramolecular_mlp=None, water_model=None, platform_name="CPU", ) @@ -47,3 +48,38 @@ def test_mcs_atom_freezing(sars_scaffold_chunk_sdf, rec_7l10_final_path): np.testing.assert_almost_equal( min_pos_unfrozen[scaffold_atoms], unmin_pos[scaffold_atoms] ) + + +def test_use_ani_parameter_raises_deprecation_error(): + """Test that using the deprecated use_ani parameter raises a helpful error.""" + # Create a simple molecule + mol = Chem.MolFromSmiles("CCO") + mol = Chem.AddHs(mol) + + # Test use_ani=True raises deprecation error + with pytest.raises(TypeError) as exc_info: + optimise_in_receptor( + ligand=mol, + receptor_file="dummy.pdb", + ligand_force_field="openff", + use_ani=True, + ) + + error_msg = str(exc_info.value) + assert "deprecated" in error_msg.lower() + assert "ligand_intramolecular_mlp" in error_msg + assert "ani2x" in error_msg + assert "Migration guide" in error_msg + + # Test use_ani=False also raises deprecation error + with pytest.raises(TypeError) as exc_info: + optimise_in_receptor( + ligand=mol, + receptor_file="dummy.pdb", + ligand_force_field="openff", + use_ani=False, + ) + + error_msg = str(exc_info.value) + assert "deprecated" in error_msg.lower() + assert "ligand_intramolecular_mlp" in error_msg diff --git a/fegrow/version.txt b/fegrow/version.txt index 10bf840e..56fea8a0 100644 --- a/fegrow/version.txt +++ b/fegrow/version.txt @@ -1 +1 @@ -2.0.1 \ No newline at end of file +3.0.0 \ No newline at end of file diff --git a/notebooks/.tutorial.py b/notebooks/.tutorial.py index 4a71afdb..7beb73a3 100644 --- a/notebooks/.tutorial.py +++ b/notebooks/.tutorial.py @@ -221,7 +221,7 @@ energies = rmol.optimise_in_receptor( receptor_file="rec_final.pdb", ligand_force_field="openff", - use_ani=True, + ligand_intramolecular_mlp="ani2x", sigma_scale_factor=0.8, relative_permittivity=4, water_model=None, diff --git a/notebooks/1_basic_tutorial_full.ipynb b/notebooks/1_basic_tutorial_full.ipynb index 3230d310..ef12d332 100644 --- a/notebooks/1_basic_tutorial_full.ipynb +++ b/notebooks/1_basic_tutorial_full.ipynb @@ -343,7 +343,7 @@ "energies = rmol.optimise_in_receptor(\n", " receptor_file=\"rec_final.pdb\",\n", " ligand_force_field=\"openff\",\n", - " use_ani=True,\n", + " ligand_intramolecular_mlp=\"ani2x\",\n", " sigma_scale_factor=0.8,\n", " relative_permittivity=4,\n", " water_model=None,\n", diff --git a/notebooks/2_tutorial_single_mol.ipynb b/notebooks/2_tutorial_single_mol.ipynb index 7fcf088f..2fbc5891 100644 --- a/notebooks/2_tutorial_single_mol.ipynb +++ b/notebooks/2_tutorial_single_mol.ipynb @@ -504,7 +504,7 @@ "energies = rmol.optimise_in_receptor(\n", " receptor_file=\"rec_final.pdb\",\n", " ligand_force_field=\"openff\",\n", - " use_ani=True,\n", + " ligand_intramolecular_mlp=\"ani2x\",\n", " sigma_scale_factor=0.8,\n", " relative_permittivity=4,\n", " water_model=None,\n", diff --git a/notebooks/4_tutorial_introduce_chemspace.ipynb b/notebooks/4_tutorial_introduce_chemspace.ipynb index e70b46af..85648cc1 100644 --- a/notebooks/4_tutorial_introduce_chemspace.ipynb +++ b/notebooks/4_tutorial_introduce_chemspace.ipynb @@ -491,7 +491,7 @@ "energies = cs.optimise_in_receptor(\n", " receptor_file=\"rec_final.pdb\",\n", " ligand_force_field=\"openff\",\n", - " use_ani=True,\n", + " ligand_intramolecular_mlp=\"ani2x\",\n", " sigma_scale_factor=0.8,\n", " relative_permittivity=4,\n", " water_model=None,\n", diff --git a/notebooks/linker_example/peplites-fl33.ipynb b/notebooks/linker_example/peplites-fl33.ipynb index c717283b..4bd447ad 100644 --- a/notebooks/linker_example/peplites-fl33.ipynb +++ b/notebooks/linker_example/peplites-fl33.ipynb @@ -162,7 +162,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "" ] @@ -815,7 +815,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "" ] @@ -1510,7 +1510,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/html": [ "
\n", "