How to use MolStandardizer

MolStandardizerHowToGist.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>How to use <code>MolStandardizer</code></h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging\n",
    "import rdkit\n",
    "from rdkit import Chem, RDLogger\n",
    "from rdkit.Chem.MolStandardize import rdMolStandardize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2021.09.1pre'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rdkit.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BaseLogger:\n",
    "    \"\"\"\n",
    "    Simple logging base class.\n",
    "\n",
    "    Inherit from this class and call self.get_logger() to\n",
    "    get a logger bearing the class name.\n",
    "    \"\"\"\n",
    "\n",
    "    DEFAULT_LOG_LEVEL = logging.WARNING\n",
    "\n",
    "    def __init__(self):\n",
    "        self._log_level = self.DEFAULT_LOG_LEVEL\n",
    "\n",
    "    def set_log_level(self, log_level):\n",
    "        if not getattr(logging, log_level):\n",
    "            raise TypeError(f\"log_level {log_level} does not exist in logging\")\n",
    "        self._log_level = log_level\n",
    "\n",
    "    def get_logger(self):\n",
    "        \"\"\"Return a logger bearing the class name.\"\"\"\n",
    "        logger = logging.getLogger(self.__class__.__name__)\n",
    "        if not logger.hasHandlers():\n",
    "            handler = logging.StreamHandler()\n",
    "            formatter = logging.Formatter(\"[%(asctime)s:%(name)s:%(levelname)s] %(message)s\")\n",
    "            handler.setFormatter(formatter)\n",
    "            logger.addHandler(handler)\n",
    "        logger.setLevel(self._log_level)\n",
    "        return logger"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class StandardizeMols(BaseLogger):\n",
    "    \"\"\"\n",
    "    Simple wrapper class around MolStandardizer.\n",
    "    \"\"\"\n",
    "\n",
    "    DEFAULT_CANON_TAUT = False\n",
    "    DEFAULT_METAL_DISCONNECT = False\n",
    "    MAX_TAUTOMERS = 100\n",
    "    MAX_TRANSFORMS = 100\n",
    "    MAX_RESTARTS = 200\n",
    "    PREFER_ORGANIC = True\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        metal_disconnect=None,\n",
    "        canon_taut=None,\n",
    "    ):\n",
    "        \"\"\"\n",
    "        Constructor.\n",
    "\n",
    "        All parameters are optional.\n",
    "        :param metal_disconnect:    if True, metallorganic complexes are\n",
    "                                    disconnected\n",
    "        :param canon_taut:          if True, molecules are converted to their\n",
    "                                    canonical tautomer\n",
    "        \"\"\"\n",
    "        super().__init__()\n",
    "        if metal_disconnect is None:\n",
    "            metal_disconnect = self.DEFAULT_METAL_DISCONNECT\n",
    "        if canon_taut is None:\n",
    "            canon_taut = self.DEFAULT_CANON_TAUT\n",
    "        self._canon_taut = canon_taut\n",
    "        self._metal_disconnect = metal_disconnect\n",
    "        self._taut_enumerator = None\n",
    "        self._rdlogger = None\n",
    "        self._uncharger = None\n",
    "        self._lfrag_chooser = None\n",
    "        self._metal_disconnector = None\n",
    "        self._normalizer = None\n",
    "        self._reionizer = None\n",
    "        self._params = None\n",
    "\n",
    "    @property\n",
    "    def params(self):\n",
    "        \"\"\"Return the MolStandardize CleanupParameters.\"\"\"\n",
    "        if self._params is None:\n",
    "            self._params = rdMolStandardize.CleanupParameters()\n",
    "            self._params.maxTautomers = self.MAX_TAUTOMERS\n",
    "            self._params.maxTransforms = self.MAX_TRANSFORMS\n",
    "            self._params.maxRestarts = self.MAX_RESTARTS\n",
    "            self._params.preferOrganic = self.PREFER_ORGANIC\n",
    "            self._params.tautomerRemoveSp3Stereo = False\n",
    "        return self._params\n",
    "\n",
    "    @property\n",
    "    def canon_taut(self):\n",
    "        \"\"\"Return whether tautomer canonicalization will be done.\"\"\"\n",
    "        return self._canon_taut\n",
    "\n",
    "    @property\n",
    "    def metal_disconnect(self):\n",
    "        \"\"\"Return whether metallorganic complexes will be disconnected.\"\"\"\n",
    "        return self._metal_disconnect\n",
    "\n",
    "    @property\n",
    "    def taut_enumerator(self):\n",
    "        \"\"\"Return the TautomerEnumerator object.\"\"\"\n",
    "        if self._taut_enumerator is None:\n",
    "            self._taut_enumerator = rdMolStandardize.TautomerEnumerator(self.params)\n",
    "        return self._taut_enumerator\n",
    "\n",
    "    @property\n",
    "    def uncharger(self):\n",
    "        \"\"\"Return the Uncharger object.\"\"\"\n",
    "        if self._uncharger is None:\n",
    "            self._uncharger = rdMolStandardize.Uncharger()\n",
    "        return self._uncharger\n",
    "\n",
    "    @property\n",
    "    def lfrag_chooser(self):\n",
    "        \"\"\"Return the LargestFragmentChooser object.\"\"\"\n",
    "        if self._lfrag_chooser is None:\n",
    "            self._lfrag_chooser = rdMolStandardize.LargestFragmentChooser(\n",
    "                self.params.preferOrganic\n",
    "            )\n",
    "        return self._lfrag_chooser\n",
    "\n",
    "    @property\n",
    "    def metal_disconnector(self):\n",
    "        \"\"\"Return the MetalDisconnector object.\"\"\"\n",
    "        if self._metal_disconnector is None:\n",
    "            self._metal_disconnector = rdMolStandardize.MetalDisconnector()\n",
    "        return self._metal_disconnector\n",
    "\n",
    "    @property\n",
    "    def normalizer(self):\n",
    "        \"\"\"Return the Normalizer object.\"\"\"\n",
    "        if self._normalizer is None:\n",
    "            self._normalizer = rdMolStandardize.Normalizer(\n",
    "                self.params.normalizationsFile, self.params.maxRestarts\n",
    "            )\n",
    "        return self._normalizer\n",
    "\n",
    "    @property\n",
    "    def reionizer(self):\n",
    "        \"\"\"Return the Reionizer object.\"\"\"\n",
    "        if self._reionizer is None:\n",
    "            self._reionizer = rdMolStandardize.Reionizer(self.params.acidbaseFile)\n",
    "        return self._reionizer\n",
    "\n",
    "    def charge_parent(self, mol_in):\n",
    "        \"\"\"Sequentially apply a series of MolStandardize operations:\n",
    "\n",
    "        * MetalDisconnector\n",
    "        * Normalizer\n",
    "        * Reionizer\n",
    "        * LargestFragmentChooser\n",
    "        * Uncharger\n",
    "\n",
    "        The net result is that a desalted, normalized, neutral\n",
    "        molecule with implicit Hs is returned.\n",
    "        \"\"\"\n",
    "        params = Chem.RemoveHsParameters()\n",
    "        params.removeAndTrackIsotopes = True\n",
    "        mol_in = Chem.RemoveHs(mol_in, params, sanitize=False)\n",
    "        if self._metal_disconnect:\n",
    "            mol_in = self.metal_disconnector.Disconnect(mol_in)\n",
    "        normalized = self.normalizer.normalize(mol_in)\n",
    "        Chem.SanitizeMol(normalized)\n",
    "        normalized = self.reionizer.reionize(normalized)\n",
    "        Chem.AssignStereochemistry(normalized)\n",
    "        normalized = self.lfrag_chooser.choose(normalized)\n",
    "        normalized = self.uncharger.uncharge(normalized)\n",
    "        # need this to reassess aromaticity on things like\n",
    "        # cyclopentadienyl, tropylium, azolium, etc.\n",
    "        Chem.SanitizeMol(normalized)\n",
    "        return Chem.RemoveHs(Chem.AddHs(normalized))\n",
    "\n",
    "    def standardize_mol(self, mol_in):\n",
    "        \"\"\"\n",
    "        Standardize a single molecule.\n",
    "\n",
    "        :param mol_in:  a Chem.Mol\n",
    "        :return:        * (standardized Chem.Mol, n_taut) tuple\n",
    "                          if success. n_taut will be negative if\n",
    "                          tautomer enumeration was aborted due\n",
    "                          to reaching a limit\n",
    "                        * (None, error_msg) if failure\n",
    "\n",
    "        This calls self.charge_parent() and, if self._canon_taut\n",
    "        is True, runs tautomer canonicalization.\n",
    "        \"\"\"\n",
    "        logger = self.get_logger()\n",
    "        if self._rdlogger is None:\n",
    "            self._rdlogger = RDLogger.logger()\n",
    "            self._rdlogger.setLevel(RDLogger.CRITICAL)\n",
    "        n_tautomers = 0\n",
    "        if isinstance(mol_in, Chem.Mol):\n",
    "            name = None\n",
    "            try:\n",
    "                name = mol_in.GetProp(\"_Name\")\n",
    "            except KeyError:\n",
    "                pass\n",
    "            if not name:\n",
    "                name = \"NONAME\"\n",
    "        else:\n",
    "            error = (\n",
    "                f\"Expected SMILES or Chem.Mol as input, got {str(type(mol_in))}\"\n",
    "            )\n",
    "            logger.critical(error)\n",
    "            return None, error\n",
    "        try:\n",
    "            mol_out = self.charge_parent(mol_in)\n",
    "        except Exception as e:\n",
    "            error = f\"charge_parent FAILED: {str(e).strip()}\"\n",
    "            logger.critical(error)\n",
    "            return None, error\n",
    "        if self._canon_taut:\n",
    "            try:\n",
    "                res = self.taut_enumerator.Enumerate(mol_out, False)\n",
    "            except TypeError:\n",
    "                # we are still on the pre-2020 RDKit API\n",
    "                res = self.taut_enumerator.Enumerate(mol_out)\n",
    "            except Exception as e:\n",
    "                # something else went wrong\n",
    "                error = f\"canon_taut FAILED: {str(e).strip()}\"\n",
    "                logger.critical(error)\n",
    "                return None, error\n",
    "            n_tautomers = len(res)\n",
    "            if hasattr(res, \"status\"):\n",
    "                completed = res.status == rdMolStandardize.TautomerEnumeratorStatus.Completed\n",
    "            else:\n",
    "                # we are still on the pre-2020 RDKit API\n",
    "                completed = len(res) < 1000\n",
    "            if not completed:\n",
    "                n_tautomers = -n_tautomers\n",
    "            try:\n",
    "                mol_out = self.taut_enumerator.PickCanonical(res)\n",
    "            except AttributeError:\n",
    "                # we are still on the pre-2020 RDKit API\n",
    "                mol_out = max([(self.taut_enumerator.ScoreTautomer(m), m) for m in res])[1]\n",
    "            except Exception as e:\n",
    "                # something else went wrong\n",
    "                error = f\"canon_taut FAILED: {str(e).strip()}\"\n",
    "                logger.critical(error)\n",
    "                return None, error\n",
    "        mol_out.SetProp(\"_Name\", name)\n",
    "        return mol_out, n_tautomers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I instantiate two `StandardizeMols` objects, one that carries out tautomer canonicalizaiton..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "sm = StandardizeMols(canon_taut=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "...and one that does not:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "sm_no_canon = StandardizeMols(canon_taut=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This example molecule is the salt of an an enol:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "mol = Chem.MolFromSmiles(\"[NH3+]CC=CO.[Cl-]\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<rdkit.Chem.rdchem.Mol at 0x7f0ae2b9b4e0>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mol"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When I standardize this molecule using the `sm` instance, I get the desalted and neutralized keto tautomer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "standardized_mol, n_taut = sm.standardize_mol(mol)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<rdkit.Chem.rdchem.Mol at 0x7f0ae2b5f4e0>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "standardized_mol"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'NCCC=O'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Chem.MolToSmiles(standardized_mol)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you are interested, this will tell you that this molecule actually had 2 tautomers (the keto and the enol one):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_taut"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When I standardize this molecule using the `sm_no_canon` instance, I get the desalted and neutralized form of the input tautomer, as tautomer canonicalization is not done:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "standardized_mol, n_taut = sm_no_canon.standardize_mol(mol)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<rdkit.Chem.rdchem.Mol at 0x7f0ae2bb5030>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "standardized_mol"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As tautomer canonicalization was not done, `n_taut` is 0:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_taut"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'NCC=CO'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Chem.MolToSmiles(standardized_mol)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cyclosporin A hits the 100 maximum tautomers limit (which is configurable) and hence `n_taut` is negative, to let you know that tautomer enumeration was not exhaustive:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "cyclosporin_A = Chem.MolFromSmiles(\"CC[C@H]1C(=O)N(CC(=O)N([C@H](C(=O)N[C@H](C(=O)N([C@H](C(=O)N[C@H](C(=O)N[C@@H](C(=O)N([C@H](C(=O)N([C@H](C(=O)N([C@H](C(=O)N([C@H](C(=O)N1)[C@@H]([C@H](C)C/C=C/C)O)C)C(C)C)C)CC(C)C)C)CC(C)C)C)C)C)CC(C)C)C)C(C)C)CC(C)C)C)C\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<rdkit.Chem.rdchem.Mol at 0x7f0ae2bb5440>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cyclosporin_A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "standardized_cyclosporin_A, n_taut = sm.standardize_mol(cyclosporin_A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<rdkit.Chem.rdchem.Mol at 0x7f0ae2bb5b70>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "standardized_cyclosporin_A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-100"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_taut"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}