creating_SMARTS.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Final version of SMARTS\n",
    "\n",
    "Firstly, I need to import all of the necessary libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from rdkit import rdBase\n",
    "from rdkit import Chem\n",
    "from rdkit.Chem import AllChem\n",
    "from rdkit.Chem import Draw\n",
    "from rdkit.Chem import rdFMCS\n",
    "from rdkit.Chem import rdRascalMCES\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Secondly, I need to import the data from our csv file\n",
    "\n",
    "I will preprocess it followingly: \n",
    "- i will only take enzymes that are promiscuous or moderately-promiscuous\n",
    "- every missing value will be -1 (i dont thik there are any but it is there as a precaution)\n",
    "- if there are more products noted, i will only take the longest (assuming that the reaction happening alters the main core of the substrate which stays the longest)\n",
    "- i will group the dataframe by enzyme name and save all substrates and products each into one array separated by ';'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"Cytochrome_P450_database.csv\", delimiter = \";\")\n",
    "df2 = df.copy()\n",
    "df2_altered = df2[df2['Product SMILES'].notna()]\n",
    "df2_altered_2 = df2_altered[(df2_altered['promiscuity'] != 'specific')]\n",
    "working_df = df2_altered_2[df2_altered_2['promiscuity'] != 'no-reaction']\n",
    "working_df = working_df[working_df['Product SMILES'] != -1]\n",
    "\n",
    "def select_longest_product(products):\n",
    "    product_list = products.split(';')\n",
    "    longest_product = max(product_list, key=len)\n",
    "    return longest_product\n",
    "\n",
    "# Apply the function to each row to get longest products\n",
    "working_df['Product SMILES'] = working_df['Product SMILES'].apply(select_longest_product)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "promiscuous_df = pd.DataFrame(columns=['protein', 'Substrate SMILES', 'Product SMILES'])\n",
    "\n",
    "for protein, group_df in working_df.groupby('protein'):\n",
    "    substrate = ';'.join(group_df['Substrate SMILES'])\n",
    "    product = ';'.join(group_df['Product SMILES'].astype(str))\n",
    "    promiscuous_df.loc[len(promiscuous_df.index)] = [protein, substrate, product]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, the dataframe that i will be searching in, is ready.\n",
    "\n",
    "First step of the process is to find substrates and products in the df according to the name of the enzyme, which can be done by the following function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def subs_prods_smiles(protein_name, df_t):\n",
    "    # iterating over each row in the dataframe, trying to find matching protein name\n",
    "    # once it finds the corresponding row, it saves substrates and products and returns them\n",
    "    for _, row in df_t.iterrows():\n",
    "        prot = row['protein']\n",
    "        smiles = row['Substrate SMILES']\n",
    "        prods = row['Product SMILES']\n",
    "        if prot == protein_name:\n",
    "            sub_smiles = smiles.split(';') \n",
    "            prod_smiles = prods.split(';')\n",
    "    return sub_smiles,prod_smiles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next step is to create groups from the substrates and products, this will be done based on the **chemical reaction** happening, using the following functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#This is a function which gets us the index of the changing atom\n",
    "def get_changing_index(molecule, pattern):\n",
    "    \"\"\"\n",
    "    Gets the index of the changing atom.\n",
    "    The reason why it needs to be complicated is that the indexing of substrate and product is not the same -\n",
    "    the changing atom has different indexes in each structure.\n",
    "    \"\"\"\n",
    "    hit_atoms = list(molecule.GetSubstructMatch(pattern))\n",
    "    all_atoms_prod = list(molecule.GetSubstructMatch(molecule))\n",
    "    resulting_index = set(all_atoms_prod)-set(hit_atoms)\n",
    "    return resulting_index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_pattern(structure1,structure2):\n",
    "    \"\"\"\n",
    "    Sets pattern and molecule, then uses get_changing_index().\n",
    "    If pattern is bigger than the molecule (happens when pattern is a product and molecule is a substrate),uses MCS.\n",
    "    \"\"\"\n",
    "    pattern = Chem.MolFromSmiles(structure1)\n",
    "    molecule = Chem.MolFromSmiles(structure2)\n",
    "    hit_atoms = list(molecule.GetSubstructMatch(pattern))\n",
    "    # First, we need to check if there are any hit atoms = if the molecule has a pattern\n",
    "    if len(hit_atoms) == 0:\n",
    "        MCS_pattern = rdFMCS.FindMCS([molecule,pattern])\n",
    "        pattern = Chem.MolFromSmarts(MCS_pattern.smartsString)\n",
    "        hit_atoms = list(molecule.GetSubstructMatch(pattern))\n",
    "    if len(hit_atoms) == 0:\n",
    "        raise Exception(\"Hit atoms still zero after using MCS!\")\n",
    "    return get_changing_index(molecule, pattern)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def chemical_reaction(subs,prod):\n",
    "    \"\"\" \n",
    "    Takes a substrate and a product as an input, uses set_pattern() to find the index of a changing atom and the valence.\n",
    "    Returns changing atom and valence for substrate and product\n",
    "    \"\"\"\n",
    "    index_1 = set_pattern(subs,prod)\n",
    "    index_2 = set_pattern(prod,subs)\n",
    "    # Here it checks if the index in substrate is valid, if yes it records the valence and symbol\n",
    "    if index_2:\n",
    "        index_subs = list(index_2)[0]\n",
    "        changing_atom_subs = Chem.MolFromSmiles(subs).GetAtomWithIdx(index_subs).GetSymbol()\n",
    "        changing_valence_subs = Chem.MolFromSmiles(subs).GetAtomWithIdx(index_subs).GetExplicitValence()\n",
    "        substrate_list = [changing_atom_subs, changing_valence_subs]\n",
    "    # If it isnt valid (is an empty set), the atom does not exist (either was added or removed by the reaction)\n",
    "    else:\n",
    "        substrate_list = []\n",
    "    # Here it does the same thing for the index in product\n",
    "    if index_1:\n",
    "        index_prod = list(index_1)[0]\n",
    "        changing_atom_prod = Chem.MolFromSmiles(prod).GetAtomWithIdx(index_prod).GetSymbol()\n",
    "        changing_valence_prod = Chem.MolFromSmiles(prod).GetAtomWithIdx(index_prod).GetExplicitValence()\n",
    "        product_list = [changing_atom_prod, changing_valence_prod]\n",
    "    else:\n",
    "        product_list = []\n",
    "    return substrate_list, product_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_groups(input_subs,input_prods):\n",
    "    \"\"\" Takes a list of substrate and product structures as an input. \n",
    "    For each substrate/product pair uses chemical_reaction() to identify the chemical reaction.\n",
    "    Output is a dictionary, key is the reaction and value is a list of indexes. \n",
    "    eg. {('O',1): [0,1,2], ('O',2): [3,4,5]}\n",
    "    \"\"\"\n",
    "    # Firstly, it creates an empty dictionary to later store recorded reactions\n",
    "    individual_reactions = {}\n",
    "    # It loops through all substrate/product pairs, identifies the changing atom and valence and saves it into the dictionary\n",
    "    for i in range(len(input_subs)):\n",
    "        substrate_change,product_change = chemical_reaction(input_subs[i],input_prods[i])\n",
    "        individual_reactions[i] = substrate_change + product_change\n",
    "\n",
    "    # Next, it creates a final dictionary\n",
    "    reaction_groups = {}\n",
    "    # It loops through the individual_reactions dicitonary, uses the reaction as a key and assigns corresponding indexes as values\n",
    "    for index,individual_reaction in individual_reactions.items():\n",
    "        individual_reaction_tuple = tuple(individual_reaction)\n",
    "        if individual_reaction_tuple in reaction_groups:\n",
    "            reaction_groups[individual_reaction_tuple].append(index)\n",
    "        else:\n",
    "            reaction_groups[individual_reaction_tuple] = [index]\n",
    "    return reaction_groups"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Third step is to possibly split the created groups. The reason behind this being that the groups are initially created based on chemical reactions, they do not take into consideration what kinds of molecules they are - if we did not split them, the generated MCS would be more general (we want specific)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_max_value(combinations_list):\n",
    "    \"\"\" \n",
    "    Input is a list of combinations: [[index1, index2, X3, similarity], [index1, index22, X3, similarity]]\n",
    "    Finds max similarity value (located at last index of each list)\n",
    "    Output is the maximum value and the corresponding combination (list)\n",
    "    \"\"\"\n",
    "    max_combination = max(combinations_list, key=lambda x: x[-1])\n",
    "    max_value = max_combination[-1]\n",
    "    return max_value, max_combination"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_group(input_combination, input_dictionary):\n",
    "    \"\"\"\n",
    "    First input is a list of 4 values, representing a combination of structures: [index1, index2, X3, similarity],\n",
    "    second input is a dictionary consisting of groups created in this step: {'group1': [0,1,2], 'group2': [3]}\n",
    "    Ouput is a dictionary\n",
    "    \"\"\"\n",
    "    i_1, i_2, _, _ = input_combination \n",
    "    inserted = False\n",
    "    # It loops through all the values and checks if the indexes are already present \n",
    "    for group in input_dictionary.values():\n",
    "        if i_1 in group or i_2 in group:\n",
    "            # If one of the indexes is in a group and the second one isnt, it adds the missing one\n",
    "            if i_1 not in group:\n",
    "                group.append(i_1)\n",
    "            if i_2 not in group:\n",
    "                group.append(i_2)\n",
    "            inserted = True\n",
    "    # If they arent present, it creates a new group\n",
    "    if not inserted:\n",
    "        input_dictionary[f\"group{len(input_dictionary)+1}\"] = [i_1,i_2] \n",
    "    return input_dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def merge_groups(input_dictionary):\n",
    "    \"\"\" Used to aviod duplicate groups. \n",
    "    Through the process, two groups such as [0,1,2] and [2,1,0] can be created, they represent the same structures so having two of them is unnecessary and wrong.\n",
    "    Input is a dictionary in the following form: {'group1': [0,1,2], 'group2': [2,1,0], 'group3': [3]}\n",
    "    Ouput is a new dictionary that does not have duplicate values: {'group1': [0,1,2], 'group2': [3]}\n",
    "    \"\"\"    \n",
    "    # Firstly, create array of tuples out of all values in the input dictionary\n",
    "    list_of_values = [tuple(sorted(value)) for key, value in input_dictionary.items()]\n",
    "    unique_values = list(set(list_of_values))\n",
    "    output_dictionary = { ('group' + str(i+1)): list(values) for i, values in enumerate(unique_values) }\n",
    "    return output_dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import combinations\n",
    "def MCS_groups(input, substrate_structures, input_threshold):\n",
    "    \"\"\" \n",
    "    First input is a list of indexes to be evaluated, second input is a list of all structures for a specfic enzyme.\n",
    "    Third input is the threshold that will be used for similarity comparison.\n",
    "    Creates all possible combinations of given indexes and finds MCES for each combination.\n",
    "    Saved in the form of list of lists: [[0, 1, 23, 0.987], [0, 2, 18, 0.765], [1, 2, 12, 0.543]]\n",
    "    Then, finds max similarity value and compares to a threshold, if >= threshold, creates new groups; if < checks the presence od indexes and potentially adds them.\n",
    "    Saves in  form of a dictionary: {'group1': [0,1,2], 'group2': [2,1,0], 'group3': [3]}\n",
    "    Uses merge_groups() to avoid duplicates and outputs a dictionary: {'group1': [0,1,2], 'group2': [3]}\n",
    "    \"\"\"\n",
    "    # Preparing empty list to store information, creating all possible combinations of structures \n",
    "    MCS_combinations = []\n",
    "    all_combinations = list(combinations(input,2))\n",
    "    # It loops through all combinations and uses Rascal MCES to find MCS\n",
    "    for combination in all_combinations:\n",
    "        mcs2 = rdRascalMCES.FindMCES(Chem.MolFromSmiles(substrate_structures[combination[0]]), Chem.MolFromSmiles(substrate_structures[combination[1]]))\n",
    "        # Here we check if the result is valid = if there is a MCS, if it isnt we record zeroes\n",
    "        last_two = [len(mcs2[0].atomMatches()), mcs2[0].similarity] if mcs2 != [] else [0, 0]\n",
    "        MCS_combinations.append([combination[0], combination[1]] + last_two)\n",
    "\n",
    "    # In the second part of the fucntion it splits the groups, it compares the similarity to a threshold\n",
    "    threshold = input_threshold\n",
    "    new_groups = {}\n",
    "    # It loops through all the MCS combinations, finds the max value, compares it to threshold\n",
    "    while (len(MCS_combinations) > 0):\n",
    "        max_value, its_combination = find_max_value(MCS_combinations) \n",
    "        # If the similarity is above the threshold, it creates a new group\n",
    "        if max_value >= threshold:\n",
    "            new_groups = create_group(its_combination, new_groups)\n",
    "        else:\n",
    "            # If the similarity is below the threshold, it has to separate the structures\n",
    "            i_1, i_2, _, _ = its_combination\n",
    "            found1 = False\n",
    "            found2 = False\n",
    "            # Here it loop through the new_group dictionary and looks if the indexes of the strctures are already recorded\n",
    "            for indices in new_groups.values():\n",
    "                found1 |= i_1 in indices\n",
    "                found2 |= i_2 in indices\n",
    "            # If they are, they have already been split, if one of them isnt there, it creates a new group for this index\n",
    "            if not found1:\n",
    "                new_groups[f\"group{len(new_groups)+1}\"] = [i_1]\n",
    "            if not found2:\n",
    "                new_groups[f\"group{len(new_groups)+2}\"] = [i_2]\n",
    "        MCS_combinations.remove(its_combination)\n",
    "    newly_split_groups = merge_groups(new_groups)\n",
    "    return newly_split_groups"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def split_groups(input,substrate_structures, threshold): \n",
    "    \"\"\"\n",
    "    First input is a dictionary of chemical reactions created in a previous step: {('O', 1): [0, 1, 2, 3], ('O', 2): [4, 5, 6]}\n",
    "    Second input is a list of all substrate structures: ['HCOOH','C**',....]\n",
    "    Third input is the threshold that will be used for similarity comparisons\n",
    "    For each value from the input dictionary checks the length, if > 1 tries to split the groups. \n",
    "    Output is a dictionary of split groups: {('O', 1, 'group1'): [0, 1, 2],('O', 1, 'group2'):  [3], ('O', 2, 'group1'): [4, 5, 6]}\n",
    "    \"\"\"\n",
    "    split_dictionary = {}\n",
    "    # Iterate over all reaction/structure indexes pairs\n",
    "    for key,value in input.items(): # key, value = ('O', 1), [0, 1, 2, 3]\n",
    "        # It checks if there are more indexes than one, if yes it uses MCS_groups2 function to try to split the groups\n",
    "        if len(value) != 1:\n",
    "            output = MCS_groups(value, substrate_structures, threshold) # output: {'group1': [0, 1, 2], 'group2': [3]}\n",
    "            for output_key, output_value in output.items():\n",
    "                new_key = (*key,output_key)\n",
    "                split_dictionary[new_key] = (output_value)\n",
    "        else:\n",
    "            split_dictionary[key] = value\n",
    "    return split_dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After the groups are finalized, all thats left is finding the MCS for substrates and products and joining it into reactions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def finding_MCS(input,grouped_dict):\n",
    "    \"\"\"\n",
    "    Fourth step of the whole process, finds MCS for each group.\n",
    "    First input is a list of structures: ['HCOOH','C**',....],\n",
    "    Second input is the dictionary created in the previous step: {('O', 1, 'group1'): [0, 1, 2],('O', 1, 'group2'):  [3], ('O', 2, 'group1'): [4, 5, 6]},\n",
    "    If there is just one index, uses its corresponding SMARTS structure, if there are more, finds MCES using Rascal.\n",
    "    Output is a dictionary: {('O', 1, 'group1'): 'MCSs1',('O', 1, 'group2'):  'MCSs2', ('O', 2, 'group1'): 'MCSs3'}.\n",
    "    \"\"\"\n",
    "    d_out = {}\n",
    "    # It iterates over each reaction-indexes pair\n",
    "    for change, indexes in grouped_dict.items():\n",
    "        seznam = [input[x] for x in indexes]\n",
    "        seznam_smiles = [Chem.MolFromSmiles(x) for x in seznam]\n",
    "        # Checks the number of indexes, if it is only one, it uses SMARTS structure\n",
    "        if len(indexes) == 1:\n",
    "            structure = Chem.MolToSmarts(seznam_smiles[0])\n",
    "            structure = structure.replace('[#6]', 'C').replace('[#8]', 'O')\n",
    "            d_out[change] = structure\n",
    "        # If there are multiple, it picks the first two and creates MCS using Rascal MCES\n",
    "        else:\n",
    "            res_smiles = rdRascalMCES.FindMCES(seznam_smiles[0],seznam_smiles[1])\n",
    "            result = res_smiles[0].smartsString.replace('[#6]', 'C').replace('[#8]', 'O').replace('[#8-]', 'O-')\n",
    "            d_out[change] = result\n",
    "    return d_out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following function joins the substrate a product MCS and creates a list of reactions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# And this is the final function. The inputs are dictionaries for substrates and products that contain MCS as values and reactions as keys\n",
    "def reactions(subs_structures, prod_structures):\n",
    "    \"\"\"\n",
    "    Last step, creates reactions.\n",
    "    First input is a dictionary of substrate groups and corresponding MCS structures: {('O', 1, 'group1'): 'MCSs1',('O', 1, 'group2'):  'MCSs2', ('O', 2, 'group1'): 'MCSs3'}\n",
    "    Second input is a dictionary of product groups and corresponding MCS structures: {('O', 1, 'group1'): 'MCSp1',('O', 1, 'group2'):  'MCSp2', ('O', 2, 'group1'): 'MCSp3'}\n",
    "    Output is a list of reactions: [['MCSs1>>MCSp1'], ['MCSs2>>MCSp2'], ['MCSs3>>MCSp3']]\n",
    "    \"\"\"\n",
    "    reactions = []\n",
    "    for i in zip(subs_structures.values(), prod_structures.values()):\n",
    "        reaction = i[0] + '>>' + i[1]\n",
    "        reactions.append([reaction])\n",
    "    return reactions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is where the generative part ends, the ouput of the last step is a list of reactions\n",
    "\n",
    "I shall connect it all into one function called **find_reactions()**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_reactions(name_of_enzyme, df_t, threshold):\n",
    "    s,p = subs_prods_smiles(name_of_enzyme,df_t)\n",
    "    groupes_dict = create_groups(s, p)\n",
    "    output = split_groups(groupes_dict,s, threshold)\n",
    "    structures_subs = finding_MCS(s, output)\n",
    "    structures_prods = finding_MCS(p, output)\n",
    "    list_of_reactions = reactions(structures_subs,structures_prods)\n",
    "    return list_of_reactions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[13:16:32] WARNING: not removing hydrogen atom with dummy atom neighbors\n",
      "[13:16:32] WARNING: not removing hydrogen atom with dummy atom neighbors\n",
      "[13:16:32] WARNING: not removing hydrogen atom with dummy atom neighbors\n",
      "[13:16:32] WARNING: not removing hydrogen atom with dummy atom neighbors\n",
      "[13:16:32] WARNING: not removing hydrogen atom with dummy atom neighbors\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[['CCC.CCC(-OO)-C=CC=CCC.CCCCC(-O)=O>>CCC.CCC(=O)-C=CC=CCC.CCCCC(-O)=O'],\n",
       " ['C-C/C=C\\\\C/C=C\\\\C/C=C\\\\C/C=C\\\\C/C=C\\\\C/C=C\\\\C-C-C(-[#8-])=O>>C(-C(-[#8-])=O)-C/C=C\\\\C/C=C\\\\C/C=C\\\\C/C=C\\\\C/C=C\\\\C-[#6@@H]1-[#6@H](-C-C)-O-1'],\n",
       " ['C-C/C=C\\\\C/C=C\\\\C/C=C\\\\C/C=C\\\\C/C=C\\\\C-C-C-C(-[#8-])=O>>C-C-[#6@@H]1-O-[#6@@H]-1-C/C=C\\\\C/C=C\\\\C/C=C\\\\C/C=C\\\\C-C-C-C(-[#8-])=O'],\n",
       " ['CCCCCC=CCC=CCC=CCC=CCCCC(-O)=O>>C(-CCC)-CC1C(-CC=CCC=CCC=CCCCC(-O)=O)-O1'],\n",
       " ['C12CCC3(-C)-C(-O)-CCC3C1CCc1:c:c(-O):c:c:c-2:1>>C1(-CCC2(-C)-C(-O)-CCC2C1CC)-c1:c:c:c(-O):c(-O):c:1'],\n",
       " ['[#6H](=O)/C=C(-C)/C=C/C=C(-C)/C=C/C1=C(-C)-C-C-C-C-1(-C)-C>>C-C(/C=C/C1=C(-C)-C-C-C-C-1(-C)-C)=C\\\\C=C\\\\C(-C)=C\\\\C(-[#8-])=O'],\n",
       " ['C1-[#6@@]2(-[#6@H]3-C-C-[#6@]4(-[#6@H](-[#6@@H]-3-C-C=C-2-C-[#6@H](-C-1)-O)-C-C-[#6@@H]-4-[#6@H](-C)-C-C-C-C(-C)-C)-C)-C>>C1-[#6@@H](-[#6@@]2(-[#6@@H](-C-1)-[#6@@H]1-C-C=C3-C-[#6@@H](-O)-C-C-[#6@]-3(-C)-[#6@H]-1-C-C-2)-C)-[#6@H](-C)-C-C-C-C(-C)(-C)-O'],\n",
       " ['CCCCCC=CCC=CCC=CCC=CCCCC(-O)=O>>O=C(-CCCC=CCC=CCC=CCC=CCCCCC)-O'],\n",
       " ['C-C(=C\\\\C-O)/C=C/C=C(-C)/C=C/C1=C(-C)-C-C-C-C-1(-C)-C>>[#6H](=O)/C=C(-C)/C=C/C=C(-C)/C=C/C1=C(-C)-C-C-C-C-1(-C)-C'],\n",
       " ['[#0]-[H]>>O-[#0]']]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "find_reactions('O77809',promiscuous_df, 0.75)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to show how it works, I called the function once with all the prints, I changed the code now to only print the output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['C12CCC3C(-CCC4(-C)-C(-CCC3-4)-C(-C)-C(-O)-C(-O)-C(-C)-C(-C)-C)-C1(-C)-CCCC2>>C1(-CCC2C3CC(=O)-C4CCCCC4(-C)-C3CCC1-2-C)-C(-C)-C(-O)-C(-O)-C(-C)-C(-C)-C'], ['C12CCC3C(-CCC4(-C)-C(-CCC3-4)-C(-C)-C(-O)-C(-O)-C(-C)-C(-C)-C)-C1(-C)-CCCC2>>C1(-C(-C(-C(-C(-C(-C)-C)-C)-O)-O)-C)-C2(-CCC3C(-CC(-C4CCCCC3-4-C)-O)-C2CC1)-C'], ['C1(-C(-C(-C(-C(-C(-C)-C)-C)-O)-O)-C)-C2(-CCC3C(-CC(-C4CCCCC3-4-C)-O)-C2CC1)-C>>C1(-CCC2C3CC(=O)-C4CCCCC4(-C)-C3CCC1-2-C)-C(-C)-C(-O)-C(-O)-C(-C)-C(-C)-C']]\n"
     ]
    }
   ],
   "source": [
    "reactions_i1gqe7 = find_reactions('I1GQE7',promiscuous_df, 0.75)\n",
    "print(reactions_i1gqe7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['C-[#0]-C(-[#8-])=O>>O-C-[#0]-C(-[#8-])=O'], ['CCCCCC=CCC=CCCCCCCCC(-O)=O>>C(=CCC=CCCC)-CCCCCCCC(=O)-O.C(-C)-O'], ['C(-[#0]-C(-[#8-])=O)-C>>C(=O)(-[#8-])-[#0]-C(-C)-O']]\n"
     ]
    }
   ],
   "source": [
    "reactions_b8qhp1 = find_reactions('B8QHP1',promiscuous_df, 0.75)\n",
    "print(reactions_b8qhp1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[13:16:43] WARNING: not removing hydrogen atom with dummy atom neighbors\n",
      "[13:16:43] WARNING: not removing hydrogen atom with dummy atom neighbors\n",
      "[13:16:43] WARNING: not removing hydrogen atom with dummy atom neighbors\n",
      "[13:16:43] WARNING: not removing hydrogen atom with dummy atom neighbors\n",
      "[13:16:43] WARNING: not removing hydrogen atom with dummy atom neighbors\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['CCC.CCC(-OO)-C=CC=CCC.CCCCC(-O)=O>>CCC.CCC(=O)-C=CC=CCC.CCCCC(-O)=O'], ['C-C/C=C\\\\C/C=C\\\\C/C=C\\\\C/C=C\\\\C/C=C\\\\C/C=C\\\\C-C-C(-[#8-])=O>>C(-C(-[#8-])=O)-C/C=C\\\\C/C=C\\\\C/C=C\\\\C/C=C\\\\C/C=C\\\\C-[#6@@H]1-[#6@H](-C-C)-O-1'], ['C-C/C=C\\\\C/C=C\\\\C/C=C\\\\C/C=C\\\\C/C=C\\\\C-C-C-C(-[#8-])=O>>C-C-[#6@@H]1-O-[#6@@H]-1-C/C=C\\\\C/C=C\\\\C/C=C\\\\C/C=C\\\\C-C-C-C(-[#8-])=O'], ['CCCCCC=CCC=CCC=CCC=CCCCC(-O)=O>>C(-CCC)-CC1C(-CC=CCC=CCC=CCCCC(-O)=O)-O1'], ['C12CCC3(-C)-C(-O)-CCC3C1CCc1:c:c(-O):c:c:c-2:1>>C1(-CCC2(-C)-C(-O)-CCC2C1CC)-c1:c:c:c(-O):c(-O):c:1'], ['[#6H](=O)/C=C(-C)/C=C/C=C(-C)/C=C/C1=C(-C)-C-C-C-C-1(-C)-C>>C-C(/C=C/C1=C(-C)-C-C-C-C-1(-C)-C)=C\\\\C=C\\\\C(-C)=C\\\\C(-[#8-])=O'], ['C1-[#6@@]2(-[#6@H]3-C-C-[#6@]4(-[#6@H](-[#6@@H]-3-C-C=C-2-C-[#6@H](-C-1)-O)-C-C-[#6@@H]-4-[#6@H](-C)-C-C-C-C(-C)-C)-C)-C>>C1-[#6@@H](-[#6@@]2(-[#6@@H](-C-1)-[#6@@H]1-C-C=C3-C-[#6@@H](-O)-C-C-[#6@]-3(-C)-[#6@H]-1-C-C-2)-C)-[#6@H](-C)-C-C-C-C(-C)(-C)-O'], ['CCCCCC=CCC=CCC=CCC=CCCCC(-O)=O>>O=C(-CCCC=CCC=CCC=CCC=CCCCCC)-O'], ['C-C(=C\\\\C-O)/C=C/C=C(-C)/C=C/C1=C(-C)-C-C-C-C-1(-C)-C>>[#6H](=O)/C=C(-C)/C=C/C=C(-C)/C=C/C1=C(-C)-C-C-C-C-1(-C)-C'], ['[#0]-[H]>>O-[#0]']]\n"
     ]
    }
   ],
   "source": [
    "reactions_o77809 = find_reactions('O77809',promiscuous_df, 0.75)\n",
    "print(reactions_o77809)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['C(-CCCCCCCC)-CCC(-O)=O>>CCCCCCCCCCCC(-O)=O'], ['C12CC(-O)-CCC1(-C)-C1CCC3(-C)-C(-CCC3C1C(-O)-C2)-C(-C)-CCCC(-C)-C>>C12(-C(-C3C(-CC1)-C1(-C(-CC(-CC1)-O)-CC3O)-C)-CCC2C(-CCCC(-C)(-C)-O)-C)-C']]\n"
     ]
    }
   ],
   "source": [
    "reactions_o46658 = find_reactions('O46658',promiscuous_df, 0.75)\n",
    "print(reactions_o46658)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['C1C2(-C3CCC4(-C(-C=3-CCC2C(-C(-C1)-O)(-C)-C)(-CCC4C(-C)-CCC)-CO)-C)-C.C(-C)-C>>C1C2(-C3CCC4(-C(-C=3-CCC2C(-C(-C1)-O)(-C)-C)(-CCC4C(-C)-CCC)-C=O)-C)-C.C(-C)-C'], ['C12-C(-[#6@]3(-C(-C(-C-C-3)-[#0])(-C)-C-C-1)-C-O)-C-C-C1-C-2(-C-C-C-C-1)-C>>C-C12-C-C-C3-C(-C-C-C4-C-C-C-C-C-3-4-C)-[#6@@]-1(-C-C-C-2-[#0])-C=O'], ['C1-[#6@@]2(-C3-C-C-[#6@]4(-[#6@](-C=3-C-C-[#6@H]-2-C(-[#6@H](-C-1)-O)(-C)-C)(-C-C-[#6@@H]-4-[#6@H](-C)-C-C-C(-C(-C)-C)=C)-C=O)-C)-C>>C1-[#6@@]2(-C3-C-C-[#6@]4(-C(-C=3-C-C-[#6@H]-2-C(-[#6@H](-C-1)-O)(-C)-C)=C-C-[#6@@H]-4-[#6@H](-C)-C-C-C(-C(-C)-C)=C)-C)-C'], ['C-C12-C-C-C3-C(-C-C-C4-C-C-C-C-C-3-4-C)-[#6@@]-1(-C-C-C-2-[#0])-C=O>>C12-C(-C3-C(-C(-C-C=3)-[#0])(-C)-C-C-1)-C-C-C1-C-2(-C-C-C-C-1)-C'], ['O-[#6@@H]1-C(-[#6@H]2-[#6@@](-C3=C(-[#6@]4(-[#6@@](-[#6@H](-C-C-4)-[#6@@H](-C-C-C=C(-C)-C)-C)(-C-C-3)-C)-C=O)-C-C-2)(-C-C-1)-C)(-C)-C>>C1-[#6@@H](-[#6@@]2(-C(=C-1)-C1=C(-C-C-2)-[#6@@]2(-C)-C-C-[#6@H](-O)-C(-C)(-C)-[#6@@H]-2-C-C-1)-C)-[#6@H](-C)-C-C-C=C(-C)-C'], ['C12-C(-[#6@]3(-C(-C(-C-C-3)-[#0])(-C)-C-C-1)-C)-C-C-C1-C-2(-C-C-C-C-1)-C>>C12-C(-C3-C(-C(-C-C=3)-[#0])(-C)-C-C-1)-C-C-C1-C-2(-C-C-C-C-1)-C'], ['C1C2(-C3CCC4(-C(-C=3-CCC2C(-C(-C1)-O)(-C)-C)(-CCC4C(-C)-CCC)-C)-C)-C.C(-C)-C>>C1C2(-C3CCC4(-C(-C=3-CCC2C(-C(-C1)-O)(-C)-C)=CCC4C(-C)-CCC)-C)-C.C(-C)-C'], ['C1C2(-C3CCC4(-C(-C=3-CCC2C(-C(-C1)-O)(-C)-C)(-CCC4C(-C)-CCC)-C)-C)-C.C(-C)-C>>C1C2(-C3CCC4(-C(-C=3-CCC2C(-C(-C1)-O)(-C)-C)(-CCC4C(-C)-CCC)-CO)-C)-C.C(-C)-C'], ['C12-C(-[#6@]3(-C(-C(-C-C-3)-[#0])(-C)-C-C-1)-C)-C-C-C1-C-2(-C-C-C-C-1)-C>>C12-C(-[#6@]3(-C(-C(-C-C-3)-[#0])(-C)-C-C-1)-C-O)-C-C-C1-C-2(-C-C-C-C-1)-C']]\n"
     ]
    }
   ],
   "source": [
    "reactions_e9qy26 = find_reactions('E9QY26',promiscuous_df, 0.75)\n",
    "print(reactions_e9qy26)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['CCCCCCC=CCCCCCCCC(-O)=O>>C(-CCC)-CCCCC(-O)=O.CCCCCCCO'], ['C-[#0]-C(-[#8-])=O>>O-C-[#0]-C(-[#8-])=O']]\n"
     ]
    }
   ],
   "source": [
    "reactions_b8qhp3 = find_reactions('B8QHP3',promiscuous_df, 0.75)\n",
    "print(reactions_b8qhp3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['C1C2(-C3CCC4(-C(-C=3-CCC2C(-C(-C1)-O)(-C)-C)(-CCC4C(-C)-CCC)-CO)-C)-C.C(-C)-C>>C1C2(-C3CCC4(-C(-C=3-CCC2C(-C(-C1)-O)(-C)-C)(-CCC4C(-C)-CCC)-C=O)-C)-C.C(-C)-C'], ['C12-C(-[#6@]3(-C(-C(-C-C-3)-[#0])(-C)-C-C-1)-C-O)-C-C-C1-C-2(-C-C-C-C-1)-C>>C-C12-C-C-C3-C(-C-C-C4-C-C-C-C-C-3-4-C)-[#6@@]-1(-C-C-C-2-[#0])-C=O'], ['C1-[#6@@]2(-C3-C-C-[#6@]4(-[#6@](-C=3-C-C-[#6@H]-2-C(-[#6@H](-C-1)-O)(-C)-C)(-C-C-[#6@@H]-4-[#6@H](-C)-C-C-C(-C(-C)-C)=C)-C=O)-C)-C>>C1-[#6@@]2(-C3-C-C-[#6@]4(-C(-C=3-C-C-[#6@H]-2-C(-[#6@H](-C-1)-O)(-C)-C)=C-C-[#6@@H]-4-[#6@H](-C)-C-C-C(-C(-C)-C)=C)-C)-C'], ['C-C12-C-C-C3-C(-C-C-C4-C-C-C-C-C-3-4-C)-[#6@@]-1(-C-C-C-2-[#0])-C=O>>C12-C(-C3-C(-C(-C-C=3)-[#0])(-C)-C-C-1)-C-C-C1-C-2(-C-C-C-C-1)-C'], ['O-[#6@@H]1-C(-[#6@H]2-[#6@@](-C3=C(-[#6@]4(-[#6@@](-[#6@H](-C-C-4)-[#6@@H](-C-C-C=C(-C)-C)-C)(-C-C-3)-C)-C=O)-C-C-2)(-C-C-1)-C)(-C)-C>>C1-[#6@@H](-[#6@@]2(-C(=C-1)-C1=C(-C-C-2)-[#6@@]2(-C)-C-C-[#6@H](-O)-C(-C)(-C)-[#6@@H]-2-C-C-1)-C)-[#6@H](-C)-C-C-C=C(-C)-C'], ['C12-C(-[#6@]3(-C(-C(-C-C-3)-[#0])(-C)-C-C-1)-C)-C-C-C1-C-2(-C-C-C-C-1)-C>>C12-C(-C3-C(-C(-C-C=3)-[#0])(-C)-C-C-1)-C-C-C1-C-2(-C-C-C-C-1)-C'], ['C1C2(-C3CCC4(-C(-C=3-CCC2C(-C(-C1)-O)(-C)-C)(-CCC4C(-C)-CCC)-C)-C)-C.C(-C)-C>>C1C2(-C3CCC4(-C(-C=3-CCC2C(-C(-C1)-O)(-C)-C)=CCC4C(-C)-CCC)-C)-C.C(-C)-C'], ['C1C2(-C3CCC4(-C(-C=3-CCC2C(-C(-C1)-O)(-C)-C)(-CCC4C(-C)-CCC)-C)-C)-C.C(-C)-C>>C1C2(-C3CCC4(-C(-C=3-CCC2C(-C(-C1)-O)(-C)-C)(-CCC4C(-C)-CCC)-CO)-C)-C.C(-C)-C'], ['C12-C(-[#6@]3(-C(-C(-C-C-3)-[#0])(-C)-C-C-1)-C)-C-C-C1-C-2(-C-C-C-C-1)-C>>C12-C(-[#6@]3(-C(-C(-C-C-3)-[#0])(-C)-C-C-1)-C-O)-C-C-C1-C-2(-C-C-C-C-1)-C']]\n"
     ]
    }
   ],
   "source": [
    "reactions_i1rjr2 = find_reactions('I1RJR2',promiscuous_df, 0.75)\n",
    "print(reactions_i1rjr2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['C1CCC2C(-CCCC1-2-C)=CC=C1CC(-O)-CC(-O)-C1=C.C(-C)-CC=O>>C1(-CCC2C(-CCCC1-2-C)=CC=C1CC(-O)-CC(-O)-C1=C)-C(-C)-CCO'], ['C1(-CCC2C(-CCCC1-2-C)=CC=C1CC(-O)-CCC1=C)-C(-C)-C.CO>>C1CCC2C(-CCCC1-2-C)=CC=C1CC(-O)-CCC1=C.C(-C)-CC=O']]\n"
     ]
    }
   ],
   "source": [
    "reactions_q09128 = find_reactions('Q09128',promiscuous_df, 0.75)\n",
    "print(reactions_q09128)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This can be done for any and every enzyme in the dataset."
   ]
  }
 ],
 "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.11.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}