Molecule_Breakdown_Model_Ring_Fragments.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4f012aac",
   "metadata": {},
   "source": [
    "# **_Ring Fragment Database Building_**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6eb8758a",
   "metadata": {},
   "source": [
    "## Environment Setting Up and Packages Importing:\n",
    "        !conda activate fragment-env \n",
    "        Please create this environment from the .yml file: fragment.yml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4de9af4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import time\n",
    "\n",
    "import pandas as pd\n",
    "from tqdm import tqdm \n",
    "import pickle\n",
    "import numpy as np\n",
    "from collections import Counter\n",
    "\n",
    "#RDKit:\n",
    "from rdkit.Chem import AllChem\n",
    "from rdkit.Chem import rdchem\n",
    "from rdkit import Chem\n",
    "from rdkit.Chem.rdmolops import *\n",
    "from rdkit.Chem import PandasTools\n",
    "from rdkit.Chem.Draw import MolsToGridImage"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fad5e378",
   "metadata": {},
   "source": [
    "### 1. Input the Data (usually for multiple-input-file cases):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e177556",
   "metadata": {},
   "outputs": [],
   "source": [
    "# To check the time running the code:\n",
    "start_time = time.time()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99bab568",
   "metadata": {},
   "source": [
    "#### (1) If you are using command line, for example .csv files:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc0b82aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "#scr_path = sys.argv[1]\n",
    "#filename = (scr_path.split('/')[-1]).split('.')[0]\n",
    "\n",
    "#df_input = pd.read_csv(scr_path,  sep = ' ', header = None, names = ['SMILES'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06f96544",
   "metadata": {},
   "source": [
    "#### (2) If you are using Jupyter Notebook, for example .csv files:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2f32d8c",
   "metadata": {},
   "source": [
    "        Some formats that you may encounter:\n",
    "\n",
    "        (1) Read .sdf file:\n",
    "        f = 'filename.sdf'\n",
    "        df_input = PandasTools.LoadSDF(f, embedProps=True, molColName=None, smilesName='smiles')\n",
    "\n",
    "        (2) Read .csv or csv.gz file:\n",
    "        df_input = pd.read_csv('filename.csv')\n",
    "        df_input = pd.read_csv('filename.csv.gz')\n",
    "\n",
    "        (3) Read .pickle file:\n",
    "        df_input = pd.read_pickle('filename.pickle')\n",
    "\n",
    "        (4) Read .smi files:\n",
    "        df = pd.read_csv(\"filename.smi\", sep=' ', header=None, names=['SMILES'])\n",
    "\n",
    "        (5) Read .xml files:\n",
    "        import xml.etree.ElementTree as ET\n",
    "        xml_data = open('data/drugbank_full_database.xml', 'r').read()\n",
    "        root = ET.XML(xml_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed390d38",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_input = pd.read_csv('example.smi',  sep=' ', header=None, names=['SMILES'])\n",
    "df_input "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e632115",
   "metadata": {},
   "source": [
    "#### For Single SMILES cases:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "002e5e55",
   "metadata": {},
   "outputs": [],
   "source": [
    "# For example: \n",
    "# df_input = pd.DataFrame({'SMILES':['CCCC1=CC(=CC=C1B(O)O)C(O)=O']})"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8dc2860d",
   "metadata": {},
   "source": [
    "#### (3) Clean the Raw Database:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b5b08e34",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove the duplicates in the original dataset:\n",
    "df_input.drop_duplicates(subset = \"SMILES\", keep = 'last', inplace = True)\n",
    "df_input = df_input.reset_index(drop = True)\n",
    "df_input.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4933ef7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# To check the size of the database:\n",
    "len(df_input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0ed8ccf",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('This databse contains', len(df_input), 'compounds')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c96c5b2",
   "metadata": {},
   "source": [
    "### 2. Create a Data Output Dataframe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "574522a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_output = pd.DataFrame({'Input_Smiles':df_input['SMILES']}) \n",
    "df_output['Fragment_Distribution'] = 'fragment_distribution'\n",
    "df_output"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8508728",
   "metadata": {},
   "source": [
    "### 3. Break Molecules from All SMILES:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00b7af01",
   "metadata": {},
   "source": [
    "\n",
    "#### (1) Remove All Bonds Between Any Two Acyclic Atoms:\n",
    "        Only keep the substituents on rings\n",
    "#### (2) Break the Ring Systems that Share One Atom:\n",
    "        Have to add the shared atom back to the sub-fragments\n",
    "       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7400e999",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Neutralizing Molecules:\n",
    "def neutralize_atoms(mol):\n",
    "    pattern = Chem.MolFromSmarts(\"[+1!h0!$([*]~[-1,-2,-3,-4]),-1!$([*]~[+1,+2,+3,+4])]\")\n",
    "    at_matches = mol.GetSubstructMatches(pattern)\n",
    "    at_matches_list = [y[0] for y in at_matches]\n",
    "    if len(at_matches_list) > 0:\n",
    "        for at_idx in at_matches_list:\n",
    "            atom = mol.GetAtomWithIdx(at_idx)\n",
    "            chg = atom.GetFormalCharge()\n",
    "            hcount = atom.GetTotalNumHs()\n",
    "            atom.SetFormalCharge(0)\n",
    "            atom.SetNumExplicitHs(hcount - chg)\n",
    "            atom.UpdatePropertyCache()\n",
    "    return mol"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2a8a0bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "count = 0\n",
    "my_list_invaild = []\n",
    "\n",
    "\n",
    "for q in tqdm(range(0, len(df_output)), desc = 'Loop 1'):\n",
    "\n",
    "    try:  \n",
    "        # 1.remove all the non-bond ions:\n",
    "        qsmiles = df_output['Input_Smiles'][q]\n",
    "        qsmiles = qsmiles.replace('.[Li+]', '')\n",
    "        qsmiles = qsmiles.replace('.[Na+]', '')\n",
    "        qsmiles = qsmiles.replace('.[K+]', '')\n",
    "        qsmiles = qsmiles.replace('.[F-]', '')\n",
    "        qsmiles = qsmiles.replace('.[Cl-]', '')\n",
    "        qsmiles = qsmiles.replace('.[Br-]', '')\n",
    "        qsmiles = qsmiles.replace('.[I-]', '')\n",
    "\n",
    "        qmol = Chem.MolFromSmiles(qsmiles)\n",
    "        neutralize_atoms(qmol)\n",
    "        qmolw = Chem.RWMol(qmol)\n",
    " \n",
    "        # 2.make sure there is no more dissociation \n",
    "        if '.' not in qsmiles:\n",
    "\n",
    "            if qmol and qmolw: \n",
    "\n",
    "            # 3.Remove all the bonds between two acyclic atoms:\n",
    "                for bond in qmol.GetBonds():\n",
    "                    if bond.IsInRing() == False:\n",
    "                        qmol_begin=bond.GetBeginAtomIdx()\n",
    "                        qmol_end=bond.GetEndAtomIdx()\n",
    "                        bondatom=(qmol_begin, qmol_end)\n",
    "                        bond_a=qmol.GetAtomWithIdx(qmol_begin).GetSymbol()\n",
    "                        bond_b=qmol.GetAtomWithIdx(qmol_end).GetSymbol()\n",
    "                        if  qmol.GetAtomWithIdx(qmol_begin).IsInRing() == qmol.GetAtomWithIdx(qmol_end).IsInRing() == False:\n",
    "                            qmolw.RemoveBond(qmol_begin, qmol_end)\n",
    "\n",
    "                new_mol=qmolw.GetMol()\n",
    "                new_smiles = Chem.MolToSmiles(new_mol)\n",
    "                frag_smiles_list = []\n",
    "                frag_smiles_list = frag_smiles_list + list(new_smiles.split('.'))\n",
    "\n",
    "            # 4.Break ring systems that sharing one atom:\n",
    "            result_list = []\n",
    "            working_list = frag_smiles_list\n",
    "            working_list_breakable_frags = []\n",
    "            remove_atom_list = []\n",
    "            initial_len_working_list = len(working_list)\n",
    "            new_len_working_list = 0\n",
    "\n",
    "            while new_len_working_list != initial_len_working_list:\n",
    "\n",
    "                for f in range(1000):\n",
    "\n",
    "                    try:\n",
    "                        frag_smiles = working_list[f]\n",
    "                        initial_len_working_list = len(working_list)\n",
    "                            \n",
    "                        if frag_smiles not in working_list_breakable_frags:\n",
    "                            fragmol = Chem.MolFromSmiles(frag_smiles)\n",
    "                            fragmolw = Chem.RWMol(fragmol)\n",
    "\n",
    "                            for atom in fragmol.GetAtoms():\n",
    "                                i = atom.GetIdx()\n",
    "                                neighbor_list_atom = []\n",
    "                                neighbor_list_idx = []\n",
    "                                degree = atom.GetDegree()\n",
    "                                \n",
    "                                if fragmol.GetAtomWithIdx(i).IsInRing() == False and degree > 1:\n",
    "                                    neighbor_list_RDKMol = fragmol.GetAtomWithIdx(i).GetNeighbors()\n",
    "\n",
    "                                    for n in neighbor_list_RDKMol:\n",
    "                                        neighbor_atom = n.GetSymbol()\n",
    "                                        neighbor_idx = n.GetIdx()\n",
    "                                        neighbor_list_atom.append(neighbor_atom)\n",
    "                                        neighbor_list_idx.append(neighbor_idx)\n",
    "\n",
    "                                    if all(fragmol.GetAtomWithIdx(neighbor_idx).IsInRing() == True for neighbor_idx in neighbor_list_idx) == True:\n",
    "\n",
    "                                        working_list_breakable_frags.append(frag_smiles)\n",
    "\n",
    "                                        for neighbor_idx in neighbor_list_idx:\n",
    "                                            bond = fragmol.GetBondBetweenAtoms(neighbor_idx, i)\n",
    "                                            bondtype = bond.GetBondType()\n",
    "                                            bridge_atom_symbol = fragmol.GetAtomWithIdx(i).GetSymbol()\n",
    "                                            fragmolw.RemoveBond(neighbor_idx, i)\n",
    "                                            new_atom_idx = fragmolw.AddAtom(atom)\n",
    "                                            fragmolw.AddBond(new_atom_idx, neighbor_idx, bondtype)\n",
    "\n",
    "\n",
    "                                        fragmolw.RemoveAtom(i)\n",
    "\n",
    "                                        new_fragmol = fragmolw.GetMol()\n",
    "                                        new_fragsmiles = Chem.MolToSmiles(new_fragmol)\n",
    "\n",
    "                                        working_list_split_frags = []\n",
    "                                        working_list_split_frags = list(new_fragsmiles.split('.'))\n",
    "     \n",
    "                                        working_list = working_list + working_list_split_frags\n",
    "                                        new_len_working_list = len(working_list)\n",
    "                                        break\n",
    "\n",
    "                                    else:\n",
    "                                        continue\n",
    "                                else:\n",
    "                                    continue  \n",
    "                            else:\n",
    "                                new_len_working_list = len(working_list)\n",
    "                        else:\n",
    "                            break\n",
    "                            \n",
    "                    except IndexError:\n",
    "                        pass\n",
    "        \n",
    "                c1 = Counter(working_list)\n",
    "                c2 = Counter(working_list_breakable_frags)\n",
    "                c3 = Counter(remove_atom_list)\n",
    "                diff = c1 - c2 - c3\n",
    "\n",
    "                result_list = list(diff.elements())\n",
    "                mylist = result_list\n",
    "\n",
    "\n",
    "                mylist=list(map(lambda item: item.replace('[C@@H]','C'), mylist))\n",
    "                mylist=list(map(lambda item: item.replace('[C@H]','C'), mylist))\n",
    "                mylist=list(map(lambda item: item.replace('[C@@]','C'), mylist))\n",
    "                mylist=list(map(lambda item: item.replace('[C@]','C'), mylist))\n",
    "                mylist=list(map(lambda item: item.replace('[P@@H]','P'), mylist))\n",
    "                mylist=list(map(lambda item: item.replace('[P@@]','P'), mylist))\n",
    "                mylist=list(map(lambda item: item.replace('[P@]','P'), mylist))\n",
    "                mylist=list(map(lambda item: item.replace('[S@@H]','S'), mylist))\n",
    "                mylist=list(map(lambda item: item.replace('[S@@]','S'), mylist))\n",
    "                mylist=list(map(lambda item: item.replace('[S@]','S'), mylist))\n",
    "                mylist=list(map(lambda item: item.replace('[N@]','N'), mylist))\n",
    "        \n",
    "                mylist=list(map(lambda item: item.replace('[nH3]','N'), mylist))\n",
    "\n",
    "                mylist=list(map(lambda item: item.replace('C-C','CC'), mylist))\n",
    "                \n",
    "                #repeat-count:\n",
    "                my_dict = {i:mylist.count(i) for i in mylist}\n",
    "\n",
    "                # 5.Count each fragment only once (single-count)\n",
    "                my_dict = {x: 1 for x in my_dict}\n",
    "\n",
    "                key_list=list(my_dict.keys())\n",
    "                count_list=list(my_dict.values())\n",
    "                df_output['Fragment_Distribution'][q]= my_dict\n",
    "\n",
    "        else:\n",
    "            count += 1\n",
    "            my_list_invaild.append(q)\n",
    "            continue\n",
    "        \n",
    "    except:\n",
    "        count += 1\n",
    "        my_list_invaild.append(q)\n",
    "        continue\n",
    "\n",
    "print(count, 'invalids')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4503e13a",
   "metadata": {},
   "source": [
    "### 4. Wrangling the Data Obtained :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "280041ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1.Remove the invalid data: \n",
    "new_df = df_output.drop(my_list_invaild)\n",
    "\n",
    "# Reset the index:\n",
    "new_df = new_df.reset_index(drop = True)\n",
    "\n",
    "print('After remove invalid data:', len(new_df))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b717d89d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.Save the pickle file:\n",
    "with open ('example-each-cpd-breakdown-ring-without-ROMol.pickle','wb') as f:\n",
    "    pickle.dump(new_df,f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a731b7c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.Sort the data according to the fragment frequency:\n",
    "fragment_distribution = {\n",
    "    k:[d.get(k) for d in new_df.Fragment_Distribution if k in d]\n",
    "    for k in set().union(*new_df.Fragment_Distribution)\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae9a3b4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_result=pd.DataFrame({'Fragment':fragment_distribution}) \n",
    "k=list(df_result['Fragment'].keys())\n",
    "arr=df_result.Fragment.values\n",
    "l1=list()\n",
    "for ls in arr:\n",
    "    while None in ls:\n",
    "        ls.remove(None)\n",
    "        next\n",
    "    else:\n",
    "        l1.append(ls)\n",
    "\n",
    "l2=list()\n",
    "for i in l1:\n",
    "    s=sum(i)\n",
    "    l2.append(s)\n",
    "\n",
    "df_result['Fragment_SMILES']=k\n",
    "df_result['Frequency']=l2\n",
    "\n",
    "df_result = df_result.sort_values(by=['Frequency'], ascending=False)\n",
    "df_result = df_result.reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ed9f73e",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_result = df_result.drop(columns='Fragment')\n",
    "df_result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b336855",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 4.Divide into Ring and Non-Ring Two groups:\n",
    "if_ring_check=[]  \n",
    "for i in df_result['Fragment_SMILES']:\n",
    "    try:\n",
    "        mol = AllChem.MolFromSmiles(i)\n",
    "        atoms = mol.GetAtoms()\n",
    "        n_ringatoms = 0\n",
    "        for atom in atoms:\n",
    "            if atom.IsInRing():\n",
    "                n_ringatoms += 1\n",
    "\n",
    "            if n_ringatoms == 0:\n",
    "                ringcheck = False\n",
    "            else:\n",
    "                ringcheck = True\n",
    "        if_ring_check.append(ringcheck)\n",
    "    except:\n",
    "        ringcheck = False\n",
    "        if_ring_check.append(ringcheck)\n",
    "\n",
    "df_result['Ring']=if_ring_check\n",
    "df_result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f6a3adff",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.Obtain the results only for the ring-fragment group:\n",
    "df_ring = df_result[df_result.Ring]\n",
    "\n",
    "# Reset the index:\n",
    "df_ring = df_ring.reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "333eecfe",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('The number of ring fragments obtained is', len(df_ring))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1eff14ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.Save the pickle file:\n",
    "with open ('example-ring-fragments-sorted-without-ROMol.pickle','wb') as f:\n",
    "    pickle.dump(df_ring,f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e37ba02f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7.Finish all the code running and print the key outputs:\n",
    "end_time = time.time()\n",
    "duration = round((end_time - start_time)/60)\n",
    "print('This programme took', duration, 'minutes')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "232e5ea3",
   "metadata": {},
   "source": [
    "### 5. Display the Ring Fragments (ony for single-input-file cases, for multiple-input-file cases please use the 'merge' code):\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "46581081",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1.Add ROMol to each ring fragment:\n",
    "PandasTools.AddMoleculeColumnToFrame(df_ring, smilesCol = \"Fragment_SMILES\")\n",
    "df_ring\n",
    "\n",
    "# If the ROMols already have been added before, to display them again:\n",
    "# PandasTools.RenderImagesInAllDataFrames(images=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "812b65bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2. Display the results (all or top 10000 frequent ring fragments) in a .html file\n",
    "df_ring_top = df_ring.head(10000)\n",
    "\n",
    "fmolport = open('example-top10000-ring-fragments-with-ROMol.html','w')\n",
    "h = df_ring.to_html()\n",
    "fmolport.write(h)\n",
    "fmolport.close()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.13 ('env-fragmentation')",
   "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.9.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "078c8f19e0ba7590f95e671d05f61230bb22f953ed32440aa8021a171b742402"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}