{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Reactivities (Functional Groups v2)\n", "\n", "> ### In this tutorial we will cover:\n", "> - how we can use the `Reactivity` classes to automatically connect Molecules based on functional groups" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> ### NOTE: \n", "> The `Reactivity` classes are the **successors** of the previous `FunctionalGroup` classes. The functional groups are still part of the codebase, however, and can be used or extended at will." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "BuildAMol offers great flexibility when connecting molecules. It is designed create any kind of single-bond between any two atoms and is *not* restrained to work in the realm of the \"chemically plausible\". " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "However, BuildAMol does know about some functional groups. The (by now 'old') `FunctionalGroup` classes defined groups of atoms based on their geometric arrangement in space using a central atom. This allowed for rapid identification of suitable atom groups but limited the number of representable functional groups (e.g. larger groups without a meaningful 'central atom' could not be processed).\n", "\n", "Therefore the new `Reactivity` classes were written to work specifically in conjuction with the `Reaction` class. The basic idea behind a `Reactivity` is that it defines functions to search atoms that can serve as `linker` and `deleter` atoms when defining `Linkages`. The main difference between the old `FunctionalGroup` and `Reactivity` classes is that the latter can accept arbitrary functions to determine the suitable atoms. The pre-defined reactivities of some common functional groups mostly rely on the atom connectivity graphs of the molecules and do not consider the spatial arrangement of atoms in space anymore. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let us recycle the same example that was used in the old Functional Groups tutorial. \n", "\n", "Let's say we want to connect benzaldehyde to m-Toluidine like so:\n", "\n", "![](./files/reaction1.png)\n", "\n", "So we want to connect the aldehyde of benzaldehyde to the amine of m-Toluidine. " ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import buildamol as bam\n", "bam.visual.set_backend(\"py3dmol\")\n", "\n", "bam.load_small_molecules()\n", "\n", "# first make the component molecules\n", "benzaldehyde = bam.molecule(\"benzaldehyde\")\n", "toluidine = bam.molecule(\"m-toluidine\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now that we have our component molecules, we can connect them. Instead of looking at them and identifying the atoms manually we will now use the `Reactivity` classes for the `Amine` and `Aldehyde` to define a `Reaction` that will link our molecules together. Here's how:" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Making a Reaction\n", "\n", "We can use the classmethod `Reaction.from_reactivities` to setup our reaction in the desired way, specifying that the amine will serve as nucleophile and the aldehyde as electrophile. \n", "By default the electrophile is considered the `target` molecule and the nucleophile the `source`. If your setup is different add `target_is_electrophile=False` to the classmethod call. " ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# import the reactivities we want to use\n", "from buildamol.structural.reactivity import Amine, Aldehyde\n", "\n", "# setup the reaction\n", "reaction = bam.Reaction.from_reactivities(\n", " nucleophile=Amine(),\n", " electrophile=Aldehyde()\n", ")\n", "\n", "# now we can make the product\n", "product = reaction(target=benzaldehyde, source=toluidine)\n", "product.draw2d().draw(width=200, height=200)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# just for reference, this is how the old functional group way would look like:\n", "from buildamol.structural.groups import amine, aldehyde\n", "product_old = bam.react(benzaldehyde, toluidine, egroup=aldehyde, ngroup=amine)\n", "product_old.draw2d().draw(width=200, height=200)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As we can appreciate, setting up this basic reaction is straightforward - both with the reactivities and functional groups. Since both are roughly equal effort you might wonder why we created the reactivities in the first place. The reason is that the reactivities are much easier to define and they support larger leaving groups. If you checked out the tutorial of the functional groups and you read the part of defining a custom \"nitro\" group you may remember that the definition is not in itself a lot of effort but is definitely far from inuitive or beginner friendly. However, reactivities are much easier and flexible to work with. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Custom Reactivities \n", "\n", "Let's also recreate a custom reactivity for a nitro group just like we did in the functional groups tutorial. \n", "\n", "To define a custom functional group we need to define functions to obtain linker atoms from a `Molecule` instance. Optionally, we may define functions to also define deleter atoms based on a linker `Atom` and the corresponding `Molecule` instance. \n", "\n", "We can define reactivity for either `nucleophile` or `electrophile` behaviours (or both). \n", "\n", "The easiest way to define a custom reactivity is to subclass the `Reactivity` class. Here's how to do it:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# we are going to search for the right atoms using connectivity constraints\n", "# (the v2 constraints are better than the old ones)\n", "from buildamol.structural import constraints_v2 as constraints\n", "\n", "class Nitro(bam.structural.Reactivity):\n", " \"\"\"Custom Nitro reactivity\"\"\"\n", "\n", " # if we want the nitro group to act as an electrophile\n", " # we need to define an electrophile_linker method\n", " def electrophile_linker(self, mol):\n", " # we are looking for a nitrogen atom\n", " # with connectivity pattern N(=O)O\n", " filters = constraints.and_(\n", " constraints.has_double_bond_with(\"O\"),\n", " constraints.has_single_bond_with(\"O\"),\n", " )\n", " N = mol.get_atoms(\"N\", by=\"element\", filter=filters)\n", " return N\n", " \n", " # we want the nitro group to lose one oxygen as leaving group\n", " # therefore we also need to define an electrophile_deleter method\n", " def electrophile_deleter(self, atom, mol):\n", " filters = constraints.and_(\n", " constraints.has_element(\"O\"),\n", " constraints.has_single_bond_with(\"N\"),\n", " )\n", " O = mol.get_neighbors(atom, filter=filters).pop()\n", " return O" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And with that we have defined the reactivity of our Nitro group in case it should act as an electrophile (without being itself the full leaving group). We can now test it out by letting an amine perform an attack on a nitro-containing molecule. " ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "nitro_benzene = bam.read_smiles(\"C1=CC=C(C=C1)[N+](=O)[OH]\")\n", "\n", "# setup the reaction\n", "reaction_nitro = bam.Reaction.from_reactivities(\n", " nucleophile=Amine(),\n", " electrophile=Nitro()\n", ")\n", "\n", "# now we can make the product\n", "product_nitro = reaction_nitro(nitro_benzene, toluidine)\n", "product_nitro.draw2d().draw(width=200, height=200)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And that's it! Of course our custom Nitro reactivity is only defined for the case that we are using it as an electrophile. We could add methods `nucleophile_linker` and `nucleophile_deleter` to let the group do both:" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# we simply add a nucleophile_linker method to the Nitro class\n", "# that will obtain the O neighbor of the electrophilic N=O group\n", "class NitroWithNucleophile(Nitro):\n", " def nucleophile_linker(self, mol):\n", " electrophile_N = self.electrophile_linker(mol)\n", " nucleophile_O = []\n", "\n", " filters = constraints.and_(\n", " constraints.has_element(\"O\"),\n", " constraints.has_single_bond_with(\"N\"),\n", " )\n", " for N in electrophile_N:\n", " O = mol.get_neighbors(N, filter=filters).pop()\n", " nucleophile_O.append(O)\n", " return nucleophile_O\n", " \n", "\n", "# now we can use the new reactivity to also let the nitro group act as a nucleophile\n", "reaction = bam.Reaction.from_reactivities(\n", " nucleophile=NitroWithNucleophile(),\n", " electrophile=Aldehyde(),\n", " target_is_electrophile=False,\n", ")\n", "product = reaction(nitro_benzene, benzaldehyde)\n", "product.draw2d().draw(width=200, height=200)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Multiple Target Sites" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You may have noticed that the `nucleophile_linker` method of the `NitroWithNucleophile` class did not simply return an Atom but a list of Atoms. Does that mean that Reactivities would support performing multiple attachments at the same time? Yes, that's exactly what it means! With the little caveat that multiple attachment points are only supported for the _target_ molecule (i.e. a reaction can automatically attach copies of the source molecule onto multiple target linker atoms). \n", "\n", "To exemplify this with an easier molecule, let's look at the following:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAMgAAADICAYAAACtWK6eAAALDUlEQVR4nO3deYxdVR3A8e+jdKMbLUtbliIEkSUoRaQComxCQEWiiCkgEUVERRaFABIJUAIaQmSJEiQBQ1xAjEAkSDAElEXAjUUhKLQspSylDJ1SutD2+MfvDHNnOvPedObN3Ld8P8nknXfveW9+M++cd88995xzQZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkqVxTgPFlB9FKNio7AFW1RSG9dyH95UL6ZGDTnD4Q+NAwx9RWrCAjZxNgXE5PAXbM6dHAkYV8ZxfS3ymkjyikdymkx+HnOGz8xw7dWOBbQCU/P7Cwby4wI6f3Az6a09PpPiKMAnYtvGbC8ISpwbCCDN2ZwKFAys/vK+z7A7A4p/8D/C+nO4EFOZ2AZcMco1SK6cAbwAfr+J6bFdJ7FdJHF9LFZthpwLScPgrYo46xSENyI3BZyTFMI5ppADsAm/fafyBSCfYEFgGTyw5EajQV4AHgqyXHMVCj6dlNLA2r44B/0DydHLPw+ohGyHjgBWD/kuOQGtLFwC/LDmKQTgY+WXYQal3bEtc1ZpUdyCA1a9xqEr8Fflh2EHUwGZhYdhBqLfsBLxFjqprZZ4FLgKllB6LWsRHwN+CYsgOpg7FlB6DWczLwIN0DElvBBOD7wMZlB6LmNhl4hZ7joprd9sQQma3KDkTN7wrgurKDGGY2uzQoOxLdujNqZWxS44GziPks0ga7E/he2UEMo/Pw2ogG6RBiglO7ND9mAgeXHYSaw8bAv4HPlB3ICBhNNLEuxqH7GqAzgT+VHcQIOZyYaCUNyDTgdWC3sgMpwRbAPJy2qyquBX5SdhAjbDRwIjHObErJsaiB7UYcPTarlbHFbMX6E6p2xQGN6uUe4JSygyjZVOAc4jxsTMmxtL4EYxNMS3EYb2RHEz1X7Tw26RvARTTBETTBJrlcjey05wQTEyxN8ESNfE/nfOtdJ0iwWYLLEjyXIBV+nkxwTmq8IeNjiWseny47kJL1Hpu1Ew00/yXB9gmuS/BqoUytSfBwghNT9/JHXfnH5jL6dI33fSLnq92kTDAp/+IFNfItzPnG9dq+S4KX8r75CX6W4EcJbkzwet7+eGqs4RvnA78rO4gGMoEYgnIuDXKhNMHBCToL5eeqXK5uKWy/MxVWt08wLm9fWOO9F+R8kwYSyKArSILxCZ7J2y9NvZor+eh0S95/b2qM4eMziPFWO9bK2CYOJyZUbdlr+/QSYgEgwbYJOvLR4ut97J+R4JFcrq4pbG+4CnJK3nZXldeNTfBszndIzYCG301EgVDofa64PXA5JY4qSHB1Li+XV8mzVT6SvJdi7YCGrCD35W2H13jtGTnf9YVtv8/nKI8luD7BvASnJzghwd6p570y6mUfYAXrL9epOE88m+jRGlcj76DkFseYnJ6UCqvcp8KifAley+Wl6sDKXG5SgjPy8yFXkHr32HQt7//XGvkezI/FSUijgN1zekdgKfHBbE7EuSLBEqCDaBJ1AIvvhbWHwPPA28Tjf4kFpdfViKEC/JpoY3+F9rs4WM02wLeJ5sqrg3yPGcBrAAkOqMD9OX0CcGslvpgOAN4CHiVGMMyh+4T6Azn/tkTz7pVKrAlQzYPASdRxclu1CjIrwZtV9veY9J+PJJOAFZUorNUsyo/9HRWmFt7/HbpvIbA58eG9b5s40m1f2LSauJ3AksLPm0SF6sjvt5D4AKYTFeV4ojCsqRF3u1gI/KDwfAKwPKenEf+nTuLOVjsDj+R9ZwBX5vQpwIU5fQC5ghDnNj16m2roOhcaSEXtr1zN3JCyXFStgqwE/lJl/+H0PPR2/dG1vrkB1vZ6TTUT6e5+W0tc6V6et/VVwcYQwyXW5fyp8Pt2Bz5RiPNdotdjT+IawLUDiKfdbAn8k/jfdRCf+Xt53yh63vBnyjD8/nqUq9VUL8uH0c+lh2oV5I0KfKG/nbldt3XX8wosTxHIJgnGVaKC9aerzb+kSp6+rIlfzQriG2Xh2miK3Uocqhfn7U8RFem9Pt7jZrrv8be0sP0EYmrtQD6IdnIJ8T/ryM8XFfYtAe4tPL+okP5NIf2vQnoF3TcbGoiu3zutaq7QX7laUqMsLyA36Xqr9znIU8R5yEeIdmV/9syPTxa2rcmvX0w00d4/z8jP5wPPEhV3LYN3eo5vZ2KS0MtEO3cO0dS6aQjv3Wr2AD5Hz3siDtSzXYkK3FFI/7SQ5xG6m7WdxEiGLl0VYz7RLN4hwZRKzy+13voqV/U1xF6seXnb1TVee0/Od3y94t5Ac4kjXCLapqtz+s80xrWZRnE/0fQsVe7hTAm+WSXPmEJv1Oy8reG6ebv6olcn+FQ/r/ta6r7KXuZV2psiHBLxtybi26wVFoerh2OIptGGnFAPiwT7Jlib4I3Uz+3uElyRy9U9hW2NVUHy9rkprniuTHBliiECsxMckeCm/IcuS7BvzWCG16bEeLNEnKx35HS7zCSsZjzx+ff5JVeGBBfm8vZWggsS7J/L1ZcS3N1VERJsV3hN41WQvO/Q1D3kpPfPQ6lxZqwdSbRvE9HHnojmVjvMRa/mAuCWsoPoLbc+FvVRptYluC3lK+iF/EOuIOu1t1MMH94bWFmBx6u86WyiifRopY9eiRTv/WGie3AicaL99wo8Vy3YEvycaGevI3q+ZhK3bz6yzKBKtDXxuX+MuFFQQ0nR5JtDNLXGE504D1f6uE6Sy+AcYFWlZ09a73x7EF/0j1XsxVzPBOAxopK/SvyDVgEHlRlUiX5Fz+5aiYOJI1wCXsyP7Tj8fR+iqTmhVka1n6uIitFBXMxaDny81IhG1kbEtatjyw5EjWkMcWvnYrdvs96LcDBOBB7G60CqYl/iwuFKYrhCJ91XZ1vZJKKnx3upq6Z59Oz2vaHccEbEj2iPv1N1sDFwH1E5XiEGQQ5mLFKz2IHoKp1ZdiBqHrOJyT6vEwMjW3kY/O3ErEFpg5xHXBN5gags21XN3ZwOImZhNsTKJWouGwF/JE7Ul9M9U65VjCKGhR9VchxqYjsTJ+sLiF6eRlrLa6hOpedkJ2lQTiOGniwmentawVSi2bh7rYzSQNxOzDx8kda4PcA1FBZYk4ZqFtHMepnulTqa1S7EskiuBaa6OokoWPNp7sF8dwPfLTsItaabiW7fc0uOY7A+TyzM1ui3olCTmk5cN3ie5ru5zBhipZHDyg5ErW0ucS5yetmBbKBziM4GadjdRtxwp1nuRjWdOH/aqexA1B42Jc5Fzio3jAG7Afhx2UGovXyRqCQje4+8DTebWC60Fa7fjDhnjw3NQ0QFuYtYErOTmHA1nxgJvKFrD9dbhVgt8hc432NQrCBDM4GYM9LXt/MqYs2trp9lxHnAEmLOe9e2d4gZjK8RaxMvzK+th2OJZuBeuJzNoFhBhu58Ymh8vS4edtJ9H5NlvR47iObSMmLl+sXE0epNYsmi4vpk44FniJsDPVCn2NqOFaQ+7qC8hebWEBVlKTH7cQlRiRYQQ9ovLSmulmAFqY/JxFL+Q52au4o4Oixn/SPI28RRojPne5dosj1Pd6VQnVlB6udU4rYPXf/T3ucgS4nzjKX0fQ7yAjGBqet2DGoAVpD6qQDHEecJ84nK0FFqRJIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkqS39H4hwiZ63yWWbAAAAAElFTkSuQmCC", "text/plain": [ "" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cyclohexanol = bam.read_smiles(\"C1(O)CCC(O)CC1\")\n", "cyclohexanol.draw2d().draw(width=200, height=200)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The cyclohexan-diol has two hydroxyl groups. If we now let it react with the toluidine, **both** hydroxyl groups will form new bonds because the the `Hydroxyl` reactivity also returns lists of Atoms just like we did in our custom Nitro class. " ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from buildamol.structural.reactivity import Hydroxyl\n", "\n", "reaction = bam.Reaction.from_reactivities(\n", " nucleophile=Hydroxyl(),\n", " electrophile=Amine(),\n", " target_is_electrophile=False,\n", ")\n", "product = reaction(cyclohexanol, toluidine)\n", "product.draw2d().draw(width=200, height=200)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "or inversely as electrophile" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "reaction = bam.Reaction.from_reactivities(\n", " nucleophile=Amine(),\n", " electrophile=Hydroxyl(),\n", " target_is_electrophile=True,\n", ")\n", "product = reaction(cyclohexanol, toluidine)\n", "product.draw2d().draw(width=200, height=200)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Steric Constraints \n", "\n", "If we want to limit the reactivity or narrow down the atoms that should react we can either modify the _linker_ methods of the reactivities, or use the `set_steric_constraints` method to finetune the atoms that participate in reactions. We can either provide a custom function to check which atom matches are valid or we can tune the settings of the default \"steric hindrance\" implementation which checks for the number of atoms in close proximity to the linker atom. We can for example give a maximal number of allowed neighbors in a given region and limit the linker sites only to the N best ones. " ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# limit the reactivity to only one of the hydroxyl groups\n", "# (check out the other options in the docstring of set_steric_constraints)\n", "hydroxyl_one = Hydroxyl().set_steric_constraints(n_target_sites=1)\n", "\n", "reaction = bam.Reaction.from_reactivities(\n", " nucleophile=hydroxyl_one,\n", " electrophile=Amine(),\n", " target_is_electrophile=False,\n", ")\n", "product = reaction(cyclohexanol, toluidine)\n", "product.draw2d().draw(width=200, height=200)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Using Reactivities without a Reaction\n", "\n", "So far we have looked at using Reactivities together with a Reaction to get linkages automatically without any manual intervention. However, what if we have a specific target atom in mind on one molecule but we want to use a Reactivity on the source atom (or vice versa)? \n", "\n", "In those cases it might look like you just need to define a reactivity that will return the desired atom in the right linker method, right? True, that is one solution.\n", "\n", "Another option is defining a custom Reaction and using the Reactivity's `as_nucleophile` or `as_electrophile` methods to obtain the right linker and deleter functions while directly providing the target atoms to the appropriate arguments of the Reaction's init call. \n", " \n", " We can also just use the Reactivity's method `find_atoms` (similar to the old functional groups' `find_matches`) to obtain the right atoms and manually create a Linkage with the right specifics. \n", "\n", "So, in total there is three different options of how to mix manual and automated aspects when it comes to linkage generation with Reactivities and Reactions. \n", "\n", "Let's illustrate the three different approaches below:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# (option 1) make a pseudo-reactivity that will return the desired atoms\n", "\n", "pseudo_reactivity = bam.structural.Reactivity(\n", " nucleophile_linker=lambda mol: mol.get_atom(\"O1\", residue=1)\n", ")\n", "\n", "reaction = bam.Reaction.from_reactivities(\n", " nucleophile=pseudo_reactivity,\n", " electrophile=Amine(),\n", " target_is_electrophile=False,\n", ")\n", "\n", "product = reaction(cyclohexanol, toluidine)\n", "product.draw2d().draw(width=200, height=200)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# (option 2) directly provide arguments to the Reaction \n", "\n", "# get the amine's electrophile-mode search functions\n", "amine_linker, amine_deleter = Amine().as_electrophile(serves_target=False)\n", "\n", "# and create a reaction with specific target atom in the cyclohexanol\n", "reaction = bam.Reaction(\n", " atom1=cyclohexanol.get_atom(\"O1\", residue=1),\n", " atom2=amine_linker,\n", " delete_in_source=amine_deleter,\n", ")\n", "\n", "product = reaction(cyclohexanol, toluidine)\n", "product.draw2d().draw(width=200, height=200)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# (option 3) find atoms first and then create a linkage manually\n", "\n", "amine_linker, amine_deleters = Amine().find_electrophilic_atoms(toluidine, serves_target=False)\n", "\n", "link = bam.linkage(\n", " atom1=cyclohexanol.get_atom(\"O1\", residue=1),\n", " atom2=amine_linker,\n", " delete_in_source=[amine_deleters],\n", ")\n", "\n", "product = bam.connect(cyclohexanol, toluidine, link)\n", "product.draw2d().draw(width=200, height=200)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You will likely agree that the three approaches are nearly equal in the amount of code required to achieve the desired goal. Feel free to use whichever best suits your needs. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And with that we already reached the end of this tutorial. To summarize, we have seen the `Reactivity` classes that serve as atom search-engines to feed into the `Reaction` class that itself serves as a linkage generator-engine. There are a bunch of reactivities available within BuildAMol directly but defining custom ones is straightforward. Be sure to also check out the tutorial on Reactions directly to see how the two concepts of Reaction and Reactivity work hand in hand - depending on your use-case you may also directly define a reaction with a bunch of functions instead of going the route via a Reactivity object. \n", "\n", "Thanks a lot for sticking around to the end, and best of luck with your project using BuildAMol!" ] } ], "metadata": { "kernelspec": { "display_name": "glyco2", "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.0" }, "orig_nbformat": 4 }, "nbformat": 4, "nbformat_minor": 2 }