Migrated from GitHub

data/ClickReaction/BaseReaction.py

@@ -0,0 +1,122 @@
+from typing import ClassVar, Dict, List, Iterable
+import re
+
+try:
+    from rdkit import Chem
+    from rdkit.Chem import AllChem
+    from rdkit.Chem.rdchem import Mol
+    from rdkit.Chem.rdChemReactions import ChemicalReaction
+    from rdkit.Chem import AllChem
+except ModuleNotFoundError:
+    print("This module requires rdkit to run.")
+    exit(-1)
+
+from . import Exceptions
+
+
+Reactant = Mol
+Reactants = Dict[str, Reactant]
+
+
+class BaseReaction:
+    """
+    Abstract reaction class to provide common implementations for all reactions.
+    """
+
+    """ Dictionary of reactants """
+    _reactants: Reactants
+    """ Smarts used by the implementing class"""
+    _smarts: ClassVar[str]
+    """ rdkit ChemicalReaction instance created from the smarts. """
+    _rdReaction: ClassVar[ChemicalReaction]
+
+    reactant_names = ClassVar[List[str]]
+
+    def __runReaction__(self, reactants: Reactants) -> List[List[Mol]]:
+        """
+        Returns all products of all product sets.
+
+        :return: A list of all product sets.
+        """
+        raise NotImplementedError("You must implement __runReaction__")
+
+    @classmethod
+    def set_reaction_smarts(cls, smarts: str) -> None:
+        """
+        Sets the reaction smarts and creates the rdkit reaction from it.
+
+        :param smarts: A smarts string. All whitespace will be removed.
+        """
+        cls._smarts = re.sub(r'\s+', '', smarts)
+        cls._rdReaction = AllChem.ReactionFromSmarts(cls._smarts)
+
+    def set_reactants(self, reactants: Reactants):
+        """
+        Sets the reactants.
+
+        :param reactants: A dictionary where each key-value pair associates a reactant name with the corresponding mol.
+        :return:
+
+        Example:
+            AmideCoupling.set_reactants({"amine": amine_molecule, "acid": acid_molecule})
+        """
+        self._reactants = reactants
+
+    def get_reactants(self) -> Reactants:
+        """
+        Returns the reactants as a dictionary, where each key-value pair associates a reactant name with the
+        corresponding mol. See set_reactants.
+
+        :return:
+        """
+        return self._reactants
+
+    def get_products(self, symmetrical_as_one: bool = False) -> List[Mol]:
+        """
+        Returns a list of all possible products.
+
+        :param symmetrical_as_one: Set to true if symmetrical products should get reduced to one.
+        :return:
+        """
+        productSets = self.__runReaction__(self.get_reactants())
+
+        if productSets is None:
+            raise Exception("No product set was returned.")
+        elif len(productSets) == 0:
+            raise Exceptions.NoProductError("Reaction {} gave no product.".format(type(self)))
+
+        # Retrieve first product of all product sets
+        products = []
+        productSmiles = []
+        for p in productSets:
+            # Sanitize product from reaction fragments.
+            AllChem.SanitizeMol(p[0])
+
+            if symmetrical_as_one:
+                smiles = AllChem.MolToSmiles(p[0])
+
+                if smiles in productSmiles:
+                    continue
+                else:
+                    productSmiles.append(smiles)
+
+            products.append(p[0])
+
+        return products
+
+    def get_product(self, symmetrical_as_one: bool = False) -> Mol:
+        """
+        Returns one product and raises an exception if multiple products are possible.
+
+        :param symmetrical_as_one: Set to true to remove all but one instance of identical products.
+        :return:
+        """
+
+        # Get all possible products
+        products = self.get_products(symmetrical_as_one=symmetrical_as_one)
+
+        # More than one product is unexpected, raise an error to make the user aware.
+        if len(products) > 1:
+            raise Exceptions.AmbiguousProductError("Reaction {} gave more than one product sets: {}".format(type(self), [Chem.MolToSmiles(x) for x in products]))
+
+        return products[0]

data/ClickReaction/Exceptions.py

@@ -0,0 +1,20 @@
+
+class ClickException(Exception):
+    """
+    Base exception for the ClickReaction package.he
+    """
+    pass
+
+
+class NoProductError(ClickException):
+    """
+    Error raised if a reaction does not give any product.
+    """
+    pass
+
+
+class AmbiguousProductError(ClickException):
+    """
+    Gets raised if a reaction leads unexpectedly to one or more products.
+    """
+    pass

data/ClickReaction/Reactions/AlkalineEsterHydrolysis.py

@@ -0,0 +1,40 @@
+from ClickReaction.BaseReaction import BaseReaction, Reactant, Reactants
+
+
+class AlkalineEsterHydrolysis(BaseReaction):
+    """
+    Hydrolysis of typical esters that can be removed under alkaline conditions.
+
+    Hydrolyses:
+        - methyl esters
+        - ethyl esters
+
+    Does not hydrolyse:
+        - benzyl esters
+        - tBut esters
+
+    amine-boc -> amine
+    """
+
+    reactant_names = ["ester"]
+
+    def __init__(self, ester: Reactant):
+        self.set_reactants({
+            "ester": ester,
+        })
+
+    def __runReaction__(self, reactants: Reactants):
+        return self._rdReaction.RunReactants((reactants["ester"], ))
+
+
+smarts = """
+    [CX3:1](=[OX1:2])
+    -[OX2:3]
+    -[$([CH3]),$([CH2]-[CH3])]
+
+    >>
+
+    [C:1](=[O:2])-[O:3]
+"""
+
+AlkalineEsterHydrolysis.set_reaction_smarts(smarts)

data/ClickReaction/Reactions/AmideCoupling.py

@@ -0,0 +1,52 @@
+from ClickReaction.BaseReaction import BaseReaction, Reactant, Reactants
+
+
+class AmideCoupling(BaseReaction):
+    """
+    Amide coupling reaction to form amides.
+
+    Does not work with anilines.
+
+    amine + carboxylic acid -> Amide
+    """
+
+    reactant_names = ["amine", "acid"]
+
+    def __init__(self, amine: Reactant, acid: Reactant):
+        self.set_reactants({
+            "amine": amine,
+            "acid": acid,
+        })
+
+    def __runReaction__(self, reactants: Reactants):
+        return self._rdReaction.RunReactants((reactants["amine"], reactants["acid"]))
+
+
+smarts = """
+    [
+        $([NX3H3]),
+        $([NX4H4]),
+        $([NX3H2]-[CX4]),
+        $([NX4H3]-[CX4]),
+        $([NX3H1](-[CX4])(-[CX4])),
+        $([NX4H2](-[CX4])(-[CX4]))
+    :1]
+
+    .
+    
+    [C:2]
+        (=[OX1:3])
+        -[
+            $([OX2]-N1C(=O)CCC1(=O)),
+            $([OX2]-c1c(-F)c(-F)c(-F)c(-F)c1(-F)),
+            $([OX2]-c1ccc(-N(~O)(~O))cc1),
+            $([OX2H1]),
+            $([O-X1])
+        ]
+    
+    >>
+    
+    [*+0:1]-[*:2](=[*:3])
+"""
+
+AmideCoupling.set_reaction_smarts(smarts)

data/ClickReaction/Reactions/AmideCouplingWithAnilines.py

@@ -0,0 +1,56 @@
+from ClickReaction.BaseReaction import BaseReaction, Reactant, Reactants
+
+
+class AmideCouplingWithAnilines(BaseReaction):
+    """
+    Amide coupling reaction to form amides, does also include anilines.
+
+    amine + carboxylic acid -> Amide
+    """
+
+    reactant_names = ["amine", "acid"]
+
+    def __init__(self, amine: Reactant, acid: Reactant):
+        self.set_reactants({
+            "amine": amine,
+            "acid": acid,
+        })
+
+    def __runReaction__(self, reactants: Reactants):
+        return self._rdReaction.RunReactants((reactants["amine"], reactants["acid"]))
+
+
+smarts = """
+    [
+        $([NX3H3]),
+        $([NX4H4]),
+        $([NX3H2]-[CX4]),
+        $([NX4H3]-[CX4]),
+        $([NX3H1](-[CX4])(-[CX4])),
+        $([NX4H2](-[CX4])(-[CX4])),
+        $([NX3H2]-[cX3]),
+        $([NX4H3]-[cX3]),
+        $([NX3H1](-[cX3])(-[CX4])),
+        $([NX4H2](-[cX3])(-[CX4])),
+        $([NX3H1](-[cX3])(-[cx3])),
+        $([NX4H2](-[cX3])(-[cx3]))
+    :1]
+
+    .
+    
+    [C:2]
+        (=[OX1:3])
+        -[
+            $([OX2]-N1C(=O)CCC1(=O)),
+            $([OX2]-c1c(-F)c(-F)c(-F)c(-F)c1(-F)),
+            $([OX2]-c1ccc(-N(~O)(~O))cc1),
+            $([OX2H1]),
+            $([O-X1])
+        ]
+    
+    >>
+    
+    [*+0:1]-[*:2](=[*:3])
+"""
+
+AmideCouplingWithAnilines.set_reaction_smarts(smarts)

data/ClickReaction/Reactions/BocRemoval.py

@@ -0,0 +1,33 @@
+from ClickReaction.BaseReaction import BaseReaction, Reactant, Reactants
+
+
+class BocRemoval(BaseReaction):
+    """
+    Removal of Boc from amines
+
+    amine-boc -> amine
+    """
+
+    reactant_names = ["bocamine"]
+
+    def __init__(self, bocamine: Reactant):
+        self.set_reactants({
+            "bocamine": bocamine,
+        })
+
+    def __runReaction__(self, reactants: Reactants):
+        return self._rdReaction.RunReactants((reactants["bocamine"], ))
+
+
+smarts = """
+    [#7:1]
+    -C(=O)
+    -O
+    -[$(C(-[CH3])(-[CH3])(-[CH3]))]
+
+    >>
+
+    [*:1]
+"""
+
+BocRemoval.set_reaction_smarts(smarts)

data/ClickReaction/Reactions/CuAAC.py

@@ -0,0 +1,35 @@
+from ClickReaction.BaseReaction import BaseReaction, Reactant, Reactants
+
+
+class CuAAC(BaseReaction):
+    """
+    Copper-catalyzed alkyne azide cycloaddition to give the 1,4 regioisomer.
+
+    alkyne + azide -> 1,4-triazole
+    """
+
+    reactant_names = ["alkyne", "azide"]
+
+    def __init__(self, alkyne: Reactant, azide: Reactant):
+        self.set_reactants({
+            "alkyne": alkyne,
+            "azide": azide,
+        })
+
+    def __runReaction__(self, reactants: Reactants):
+        return self._rdReaction.RunReactants((reactants["alkyne"], reactants["azide"]))
+
+
+smarts = """
+    [C:1]#[$([CH1]),$(C-[I]):2]
+
+    .
+
+    [$([#6]-N=[N+]=[-N]),$([#6]-[N-]-[N+]#N):3]-N~N~N
+
+    >>
+
+    [*:3]n1[c:2][c:1]nn1
+"""
+
+CuAAC.set_reaction_smarts(smarts)

data/ClickReaction/Reactions/FmocRemoval.py

@@ -0,0 +1,34 @@
+from ClickReaction.BaseReaction import BaseReaction, Reactant, Reactants
+
+
+class FmocRemoval(BaseReaction):
+    """
+    Removal of Fmoc from amines
+
+    amine-fmoc -> amine
+    """
+
+    reactant_names = ["fmocamine"]
+
+    def __init__(self, fmocamine: Reactant):
+        self.set_reactants({
+            "fmocamine": fmocamine,
+        })
+
+    def __runReaction__(self, reactants: Reactants):
+        return self._rdReaction.RunReactants((reactants["fmocamine"], ))
+
+
+smarts = """
+    [#7:1]
+    -C(=O)
+    -O
+    -C
+    -[$([C]1[cR2][cR2][cR2][cR2]1)]
+
+    >>
+
+    [*:1]
+"""
+
+FmocRemoval.set_reaction_smarts(smarts)

data/ClickReaction/Reactions/SulfonAmideFormation.py

@@ -0,0 +1,42 @@
+from ClickReaction.BaseReaction import BaseReaction, Reactant, Reactants
+
+
+class SulfonAmideFormation(BaseReaction):
+    """
+    Formation of sulfon amides from sulfonyl halogenides and amines
+
+    amine + sulfonylhalogenide -> sulfonamide
+    """
+
+    reactant_names = ["amine", "sulfonylhalogenide"]
+
+    def __init__(self, amine: Reactant, sulfonylhalogenide: Reactant):
+        self.set_reactants({
+            "amine": amine,
+            "sulfonylhalogenide": sulfonylhalogenide,
+        })
+
+    def __runReaction__(self, reactants: Reactants):
+        return self._rdReaction.RunReactants((reactants["amine"], reactants["sulfonylhalogenide"]))
+
+
+smarts = """
+    [
+        $([NX3H3]),
+        $([NX4H4]),
+        $([NX3H2]-[#6]),
+        $([NX4H3]-[#6]),
+        $([#7X3H1]([#6])([#6])),
+        $([#7X4H2]([#6])([#6]))
+    :1]
+
+    .
+
+    [#6:2]-[$([SX4](~[OX1H0])(~[OX1H0]))]-[F,Cl,Br,I;X1]
+
+    >>
+
+    [#7+0:1]-[S+2](-[O-])(-[O-])-[*:2]
+"""
+
+SulfonAmideFormation.set_reaction_smarts(smarts)

data/ClickReaction/Reactions/SuzukiMiyaura.py

@@ -0,0 +1,36 @@
+from ClickReaction.BaseReaction import BaseReaction, Reactant, Reactants
+
+
+class SuzukiMiyaura(BaseReaction):
+    """
+    Formation of C-C bonds from a boronic acid or ester and an aromatic halogenide (except fluorine).
+
+    boronic acid + arylhalogenide -> C-C bond formation
+    boronic ester + arylhalogenide -> C-C bond formation
+    trifluoroborates + arylhalogenide -> C-C bond formation
+    """
+
+    reactant_names = ["boronate", "halogenide"]
+
+    def __init__(self, boronate: Reactant, halogenide: Reactant):
+        self.set_reactants({
+            "boronate": boronate,
+            "halogenide": halogenide,
+        })
+
+    def __runReaction__(self, reactants: Reactants):
+        return self._rdReaction.RunReactants((reactants["boronate"], reactants["halogenide"]))
+
+
+smarts = """
+    [#6:1]-[$([B](-O)(-O)),$([B](-F)(-F)(-F))]
+    .
+
+    [c:2]-[I,Br,Cl]
+
+    >>
+
+    [*:1]-[*:2]
+"""
+
+SuzukiMiyaura.set_reaction_smarts(smarts)

data/ClickReaction/Reactions/__init__.py

@@ -0,0 +1,24 @@
+from ClickReaction.Reactions.AmideCoupling import AmideCoupling
+from ClickReaction.Reactions.AmideCouplingWithAnilines import AmideCouplingWithAnilines
+from ClickReaction.Reactions.CuAAC import CuAAC
+from ClickReaction.Reactions.SulfonAmideFormation import SulfonAmideFormation
+
+# Cross couplings
+from ClickReaction.Reactions.SuzukiMiyaura import SuzukiMiyaura
+
+# Protecting group removals
+from ClickReaction.Reactions.FmocRemoval import FmocRemoval
+from ClickReaction.Reactions.BocRemoval import BocRemoval
+from ClickReaction.Reactions.AlkalineEsterHydrolysis import AlkalineEsterHydrolysis
+
+# All reactions as a dictionary.
+all_reactions = {
+    "AmideCoupling": AmideCoupling,
+    "AmideCouplingWithAnilines": AmideCouplingWithAnilines,
+    "CuAAC": CuAAC,
+    "SulfonAmideFormation": SulfonAmideFormation,
+    "SuzukiMiyaura": SuzukiMiyaura,
+    "FmocRemoval": FmocRemoval,
+    "BocRemoval": BocRemoval,
+    "AlkalineEsterHydrolysis": AlkalineEsterHydrolysis,
+}

data/ClickReaction/__init__.py

@@ -0,0 +1 @@
+from .Reactions import *

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Basilius Sauter <basilius.sauter@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,64 @@
+# Click
+
+Click is a collection of pre-made and tested reaction patterns to use with RDKit molecules.
+The reactions can be used to sequentially modify a molecule, or to create combinatorial 
+libraries. Click is only doing the reaction as you've specified and does *not* check 
+if the reaction would work.
+
+## Requirements
+
+* RDKit (version >= 2019.03)
+* Python (version >= 3.6)
+
+## Installation
+To install Click, run
+
+`pip install ClickReaction`
+
+## Usage
+
+Many examples can be found in the [tests folder](https://github.com/Gillingham-Lab/Click/tree/master/tests).
+
+### Boc removal
+
+```python
+from rdkit import Chem
+from ClickReaction import BocRemoval
+
+boc_protected_amine = Chem.MolFromSmiles("CNC(OC(C)(C)C)=O")
+
+reaction = BocRemoval(bocamine=boc_protected_amine)
+product = reaction.get_product()
+
+assert "CN" == Chem.MolToSmiles(product)
+```
+
+### Click Reaction
+
+```python
+from rdkit import Chem
+from ClickReaction import CuAAC
+
+alkyne = Chem.MolFromSmiles("c1ccccc1C#C")
+azide = Chem.MolFromSmiles("C-[N-]-[N+]#N")
+
+reaction = CuAAC(alkyne=alkyne, azide=azide)
+product = reaction.get_product()
+
+assert "Cn1cc(-c2ccccc2)nn1" == Chem.MolToSmiles(product)
+```
+
+## Supported reactions
+
+### Simple transformations
+
+* Boc removal
+* Fmoc removal
+* Alkaline ester hydrolysis
+
+### Bimolecular reactions
+
+* Amide coupling (with or without anilines)
+* CuAAC
+* Sulfon amide formation from amines and sulfonyl chlorides
+* Suzuki-Miyaura cross coupling

data/requirements.txt

@@ -0,0 +1 @@
+rdkit

data/setup.py

@@ -0,0 +1,27 @@
+import setuptools
+
+with open("README.md", "r") as fh:
+    long_description = fh.read()
+
+setuptools.setup(
+    name="ClickReaction",
+    version="0.3.1",
+    author="Basilius Sauter",
+    author_email="basilius.sauter@gmail.com",
+    description="A collection of chemical reaction formulations for use with rdkit. Requires rdkit.",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/Gillingham-Lab/Click",
+    packages=setuptools.find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Intended Audience :: Science/Research",
+        "Topic :: Scientific/Engineering :: Chemistry",
+        "Topic :: Scientific/Engineering :: Bio-Informatics",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+        "Topic :: Utilities",
+    ],
+    python_requires='>=3.6',
+)

data/testrun.sh

@@ -0,0 +1,2 @@
+#/usr/bin/bash
+python -m unittest discover -s tests

data/tests/TestHelper.py

@@ -0,0 +1,108 @@
+import unittest
+from rdkit.Chem import MolFromSmiles as fromSmiles
+from rdkit.Chem import MolToSmiles as toSmiles
+from typing import Sequence, Tuple, Union, Type
+
+import ClickReaction
+import ClickReaction.Exceptions
+import ClickReaction.BaseReaction
+
+Reactants = Sequence[str]
+ReactantNames = Sequence[str]
+NoProductTestCase = Reactants
+OneProductTestCase = Tuple[Reactants, str]
+MultipleProductTestCase = Tuple[Reactants, Sequence[str]]
+AnyProductTestCase = Union[NoProductTestCase, OneProductTestCase, MultipleProductTestCase]
+
+
+class ReactionTestCase(unittest.TestCase):
+    def set_reaction(self, reaction: Type):
+        self.reaction = reaction
+
+    def prepare_testcases(self,
+                          case: AnyProductTestCase,
+                          reactant_names: ReactantNames,
+                          with_product: bool = True,
+                          ):
+        product_expected = None
+
+        if with_product is True:
+            # Product is always the last one - we use here to canonicalize given smiles.
+
+            if isinstance(case[1], str):
+                product_expected = toSmiles(fromSmiles(case[1]))
+            else:
+                product_expected = [toSmiles(fromSmiles(x)) for x in case[1]]
+
+            reactants = case[0]
+        else:
+            reactants = case
+
+        # Convert reactants to objects from smiles
+        reactants = [fromSmiles(x) for x in reactants]
+
+        # create a dictonary
+        reactants = {reactant_names[x]: reactants[x] for x in range(len(reactants))}
+
+        return product_expected, reactants
+
+    def _test_one_product(self,
+                          tests: Sequence[OneProductTestCase],
+                          reactant_names: ReactantNames,
+                          symmetrical_as_one: bool = False,
+                          ):
+        """ Tests for giving exactly one expected product. """
+        for case in tests:
+            with self.subTest(case=case):
+                product_expected, reactants = self.prepare_testcases(case, reactant_names)
+
+                # Run the reaction
+                product = self.reaction(**reactants).get_product(symmetrical_as_one=symmetrical_as_one)
+
+                # Test if there was any product
+                self.assertIsNotNone(product)
+
+                # Test if the product is what we expected
+                product_smiles = toSmiles(product)
+                self.assertEqual(product_expected, product_smiles)
+
+    def _test_no_product(self,
+                         tests: Sequence[NoProductTestCase],
+                         reactant_names: ReactantNames,
+                         symmetrical_as_one: bool = False,
+                         ):
+        """ Tests for failing to give a product. """
+        for case in tests:
+            with self.subTest(case=case):
+                _, reactants = self.prepare_testcases(case, reactant_names, with_product=False)
+
+                with self.assertRaises(ClickReaction.Exceptions.NoProductError):
+                    test_product = self.reaction(**reactants).get_product(symmetrical_as_one=symmetrical_as_one)
+
+    def _test_all_possible_products(self,
+                                    tests: Sequence[MultipleProductTestCase],
+                                    reactant_names: ReactantNames,
+                                    symmetrical_as_one: bool = False,
+                                    ):
+        """ Tests if all possible expected products are covered from one reaction. """
+        for case in tests:
+            with self.subTest(case=case):
+                products_expected, reactants = self.prepare_testcases(case, reactant_names)
+
+                # getProduct only expects 1 product - this must give an Exception
+                with self.assertRaises(ClickReaction.Exceptions.AmbiguousProductError):
+                    product = self.reaction(**reactants).get_product()
+
+                # getProducts should be used instead.
+                products = self.reaction(**reactants).get_products(symmetrical_as_one=symmetrical_as_one)
+
+                products_found = 0
+                for p in products:
+                    # Convert product to smiles
+                    p_smiles = toSmiles(p)
+
+                    self.assertIn(p_smiles, products_expected)
+                    products_found += 1
+
+                self.assertEqual(products_found, len(products), "Not all products wer expected")
+                self.assertEqual(len(products), len(products_expected), "Mismatch between expected products and actual products.")

data/tests/test_AlkalineEsterHydrolysisTest.py

@@ -0,0 +1,34 @@
+from ClickReaction.Reactions import AlkalineEsterHydrolysis
+from tests import TestHelper
+
+
+class AlkalineEsterHydrolysisTest(TestHelper.ReactionTestCase):
+    reactant_names = ["ester"]
+
+    def setUp(self):
+        self.set_reaction(AlkalineEsterHydrolysis)
+
+    def test_one_product(self):
+        reactants = [
+            # Esters from formiates
+            (("C(=O)OC", ), "C(=O)O"),
+            (("C(=O)OCC", ), "C(=O)O"),
+
+            # acetates
+            (("CC(=O)OC", ), "CC(=O)O"),
+            (("CC(=O)OCC", ), "CC(=O)O"),
+        ]
+
+        self._test_one_product(reactants, self.reactant_names)
+
+    # Those tests should not give any product.
+    def test_no_product(self):
+        reactants = [
+            # tBu should not be removed
+            ("C(=O)OC(C)(C)C", ),
+
+            # Bn should not be removed
+            ("C(=O)OCc1ccccc1", ),
+        ]
+
+        self._test_no_product(reactants, self.reactant_names)

data/tests/test_AmideCoupling.py

@@ -0,0 +1,104 @@
+import ClickReaction
+from tests import TestHelper
+
+
+class AmideCouplingTest(TestHelper.ReactionTestCase):
+    reactant_names = ["amine", "acid"]
+
+    def setUp(self):
+        self.set_reaction(ClickReaction.AmideCoupling)
+
+    def test_one_product(self):
+        reactants = [
+            # Ammonia and ammonium with acetic acid
+            (("N", "OC(C)=O"), "O=C(C)N"),
+            (("[NH4+]", "OC(C)=O"), "O=C(C)N"),
+            (("N(-[H])(-[H])(-[H])", "OC(C)=O"), "O=C(C)N"),
+
+            # Primary amines with simple acids
+            (("CN", "OC=O"), "CNC=O"),
+            (("CCN", "OC(C)=O"), "O=C(C)NCC"),
+            (("CN", "OC(C1=CC=CC=C1)=O"), "O=C(C1=CC=CC=C1)NC"),
+            (("NC1=CC=CC(CN)=C1", "OC(C)=O"), "NC1=CC=CC(CNC(C)=O)=C1"),
+
+            # Secondary amines with simple acids
+            (("CNC", "OC(C)=O"), "O=C(C)N(C)C"),
+
+            # Primary ammonium with simple acids
+            (("CC[NH3+]", "OC(C)=O"), "O=C(C)NCC"),
+
+            # Secondary ammonium with simple acids
+            (("C[NH2+]C", "OC(C)=O"), "O=C(C)N(C)C"),
+
+            # Simple amine with carboxylate
+            (("CCN", "[O-]C(C)=O"), "O=C(C)NCC"),
+
+            # Secondary ammonium with carboxylate
+            (("C[NH2+]C", "[O-]C(C(C1=CC=CC=C1)(F)Cl)=O"), "O=C(C(C1=CC=CC=C1)(F)Cl)N(C)C"),
+
+            #
+            # Amine with active esters
+            #
+
+            # N-Hydroxysuccinimide
+            (("CCN", "CCC(ON1C(CCC1=O)=O)=O"), "CCC(NCC)=O"),
+            # N-Sulfo-Hydroxysuccinimide
+            (("CCN", "CCC(ON1C(CC(S(=O)(O)=O)C1=O)=O)=O"), "CCC(NCC)=O"),
+            # p-Nitrophenol
+            (("CCN", "CCC(OC1=CC=C([N+]([O-])=O)C=C1)=O"), "CCC(NCC)=O"),
+            # Pentafluorophenyl
+            (("CCN", "CCC(OC1=C(F)C(F)=C(F)C(F)=C1F)=O"), "CCC(NCC)=O"),
+
+        ]
+
+        self._test_one_product(reactants, self.reactant_names)
+
+    # Those tests should not give any product.
+    def test_no_product(self):
+        reactants = [
+            # No primary amide
+            ("NC(C)=O", "OC(C)=O"),
+            # No secondary amide
+            ("CC(NC)=O", "OC(C)=O"),
+            # No N-methyl urea
+            ("NC(NC)=O", "OC(C)=O"),
+            # No carbamates
+            ("O=C(OC)NC", "OC(C)=O"),
+            # No imides
+            ("CC(NC(C)=O)=O", "OC(C)=O"),
+            # No aniline
+            ("NC1=CC=CC=C1", "OC(C1=CC=CC=C1)=O"),
+            # No tertiary amines
+            ("CN(C)C", "OC(C)=O"),
+            # No guanosine
+            ("NC(=N)N", "OC(C)=O")
+        ]
+
+        self._test_no_product(reactants, self.reactant_names)
+
+    # This reactions should give multiple possible products
+    def test_if_get_products_returns_all_possible_products(self):
+        reactants = [
+            (("NCCNC", "OC(C)=O"), ("CNCCNC(C)=O", "NCCN(C(C)=O)C")),
+            (("CNCCNC", "OC(C)=O"), ("CNCCN(C)C(C)=O", "CNCCN(C)C(C)=O")),
+            (("N", "OC(CN(CC(O)=O)CCN(CC(O)=O)CC(O)=O)=O"), ["OC(CN(CC(O)=O)CCN(CC(N)=O)CC(O)=O)=O"]*4),
+        ]
+
+        self._test_all_possible_products(reactants, self.reactant_names)
+
+    def test_if_get_products_returns_only_1_products_if_symmetrical_as_one_is_true(self):
+        reactants = [
+            (("NCCNC", "OC(C)=O"), ["CNCCNC(C)=O", "NCCN(C(C)=O)C"]),
+            (("CNCCNC", "OC(C)=O"), ["CNCCN(C)C(C)=O"]),
+            (("N", "OC(CN(CC(O)=O)CCN(CC(O)=O)CC(O)=O)=O"), ["OC(CN(CC(O)=O)CCN(CC(N)=O)CC(O)=O)=O"]),
+        ]
+
+        self._test_all_possible_products(reactants, self.reactant_names, symmetrical_as_one=True)
+
+    def test_if_get_product_returns_the_symmetric_product_if_symmetrical_as_one_is_true(self):
+        reactants = [
+            (("CNCCNC", "OC(C)=O"), "CNCCN(C)C(C)=O"),
+            (("N", "OC(CN(CC(O)=O)CCN(CC(O)=O)CC(O)=O)=O"), "OC(CN(CC(O)=O)CCN(CC(N)=O)CC(O)=O)=O"),
+        ]
+
+        self._test_one_product(reactants, self.reactant_names, symmetrical_as_one=True)

data/tests/test_AmideCouplingWithAnilines.py

@@ -0,0 +1,107 @@
+import ClickReaction
+from tests import TestHelper
+
+
+class AmideCouplingWithAnilinesTest(TestHelper.ReactionTestCase):
+    reactant_names = ["amine", "acid"]
+
+    def setUp(self):
+        self.set_reaction(ClickReaction.AmideCouplingWithAnilines)
+
+    def test_one_product(self):
+        reactants = [
+            # Ammonia and ammonium with acetic acid
+            (("N", "OC(C)=O"), "O=C(C)N"),
+            (("[NH4+]", "OC(C)=O"), "O=C(C)N"),
+            (("N(-[H])(-[H])(-[H])", "OC(C)=O"), "O=C(C)N"),
+
+            # Primary amines with simple acids
+            (("CN", "OC=O"), "CNC=O"),
+            (("CCN", "OC(C)=O"), "O=C(C)NCC"),
+            (("CN", "OC(C1=CC=CC=C1)=O"), "O=C(C1=CC=CC=C1)NC"),
+
+            # Secondary amines with simple acids
+            (("CNC", "OC(C)=O"), "O=C(C)N(C)C"),
+
+            # Primary ammonium with simple acids
+            (("CC[NH3+]", "OC(C)=O"), "O=C(C)NCC"),
+
+            # Secondary ammonium with simple acids
+            (("C[NH2+]C", "OC(C)=O"), "O=C(C)N(C)C"),
+
+            # Simple amine with carboxylate
+            (("CCN", "[O-]C(C)=O"), "O=C(C)NCC"),
+
+            # Secondary ammonium with carboxylate
+            (("C[NH2+]C", "[O-]C(C(C1=CC=CC=C1)(F)Cl)=O"), "O=C(C(C1=CC=CC=C1)(F)Cl)N(C)C"),
+
+            #
+            # Amine with active esters
+            #
+
+            # N-Hydroxysuccinimide
+            (("CCN", "CCC(ON1C(CCC1=O)=O)=O"), "CCC(NCC)=O"),
+            # N-Sulfo-Hydroxysuccinimide
+            (("CCN", "CCC(ON1C(CC(S(=O)(O)=O)C1=O)=O)=O"), "CCC(NCC)=O"),
+            # p-Nitrophenol
+            (("CCN", "CCC(OC1=CC=C([N+]([O-])=O)C=C1)=O"), "CCC(NCC)=O"),
+            # Pentafluorophenyl
+            (("CCN", "CCC(OC1=C(F)C(F)=C(F)C(F)=C1F)=O"), "CCC(NCC)=O"),
+
+            #
+            # Anilines
+            #
+
+            # No aniline
+            (("NC1=CC=CC=C1", "OC(C1=CC=CC=C1)=O"), "O=C(Nc1ccccc1)c1ccccc1"),
+        ]
+
+        self._test_one_product(reactants, self.reactant_names)
+
+    # Those tests should not give any product.
+    def test_no_product(self):
+        reactants = [
+            # No primary amide
+            ("NC(C)=O", "OC(C)=O"),
+            # No secondary amide
+            ("CC(NC)=O", "OC(C)=O"),
+            # No N-methyl urea
+            ("NC(NC)=O", "OC(C)=O"),
+            # No carbamates
+            ("O=C(OC)NC", "OC(C)=O"),
+            # No imides
+            ("CC(NC(C)=O)=O", "OC(C)=O"),
+            # No tertiary amines
+            ("CN(C)C", "OC(C)=O"),
+            # No guanosine
+            ("NC(=N)N", "OC(C)=O")
+        ]
+
+        self._test_no_product(reactants, self.reactant_names)
+
+    # This reactions should give multiple possible products
+    def test_if_get_products_returns_all_possible_products(self):
+        reactants = [
+            (("NCCNC", "OC(C)=O"), ("CNCCNC(C)=O", "NCCN(C(C)=O)C")),
+            (("CNCCNC", "OC(C)=O"), ("CNCCN(C)C(C)=O", "CNCCN(C)C(C)=O")),
+            (("N", "OC(CN(CC(O)=O)CCN(CC(O)=O)CC(O)=O)=O"), ["OC(CN(CC(O)=O)CCN(CC(N)=O)CC(O)=O)=O"]*4),
+        ]
+
+        self._test_all_possible_products(reactants, self.reactant_names)
+
+    def test_if_get_products_returns_only_1_products_if_symmetrical_as_one_is_true(self):
+        reactants = [
+            (("NCCNC", "OC(C)=O"), ["CNCCNC(C)=O", "NCCN(C(C)=O)C"]),
+            (("CNCCNC", "OC(C)=O"), ["CNCCN(C)C(C)=O"]),
+            (("N", "OC(CN(CC(O)=O)CCN(CC(O)=O)CC(O)=O)=O"), ["OC(CN(CC(O)=O)CCN(CC(N)=O)CC(O)=O)=O"]),
+        ]
+
+        self._test_all_possible_products(reactants, self.reactant_names, symmetrical_as_one=True)
+
+    def test_if_get_product_returns_the_symmetric_product_if_symmetrical_as_one_is_true(self):
+        reactants = [
+            (("CNCCNC", "OC(C)=O"), "CNCCN(C)C(C)=O"),
+            (("N", "OC(CN(CC(O)=O)CCN(CC(O)=O)CC(O)=O)=O"), "OC(CN(CC(O)=O)CCN(CC(N)=O)CC(O)=O)=O"),
+        ]
+
+        self._test_one_product(reactants, self.reactant_names, symmetrical_as_one=True)

data/tests/test_BocRemoval.py

@@ -0,0 +1,46 @@
+from ClickReaction.Reactions import BocRemoval
+from tests import TestHelper
+
+
+class BocRemovalTest(TestHelper.ReactionTestCase):
+    reactant_names = ["bocamine"]
+
+    def setUp(self):
+        self.set_reaction(BocRemoval)
+
+    def test_one_product(self):
+        reactants = [
+            # Boc from primary aliphatic amine
+            (("CNC(OC(C)(C)C)=O", ), "CN"),
+            # Boc from primary aniline
+            (("CC(OC(NC1=CC=CC=C1)=O)(C)C", ), "NC1=CC=CC=C1"),
+            # Boc from secondary aliphatic amines
+            (("CN(C)C(OC(C)(C)C)=O", ), "CNC"),
+            # Boc from secondary anilines
+            (("CC(OC(N(C1=CC=CC=C1)C2=CC=CC=C2)=O)(C)C", ), "C1(NC2=CC=CC=C2)=CC=CC=C1"),
+            # Boc from mixed anilines / aliphatic amines
+            (("CN(C(OC(C)(C)C)=O)C1=CC=CC=C1", ), "CNC1=CC=CC=C1"),
+        ]
+
+        self._test_one_product(reactants, self.reactant_names)
+
+    # Those tests should not give any product.
+    def test_no_product(self):
+        reactants = [
+            # Fmoc
+            ("CNC(OCC1C(C=CC=C2)=C2C3=C1C=CC=C3)=O", ),
+
+            # Benzyl
+            ("CNCC1=CC=CC=C1", ),
+
+            # Dimethylamine
+            ("CNC",),
+
+            # O-Methylcarbamates
+            ("CN(C(OC)=O)C", ),
+
+            # Ureas
+            ("CN(C(NC)=O)C", ),
+        ]
+
+        self._test_no_product(reactants, self.reactant_names)

data/tests/test_CuAAC.py

@@ -0,0 +1,55 @@
+import ClickReaction
+from tests import TestHelper
+
+
+class CuAACTest(TestHelper.ReactionTestCase):
+    reactant_names = ["alkyne", "azide"]
+
+    def setUp(self):
+        self.set_reaction(ClickReaction.CuAAC)
+
+    def test_one_product(self):
+        reactants = [
+            # S
+            (("CC#C", "C-N=[N+]=[N-]"), "Cn1cc(C)nn1"),
+            (("CC#C", "C-[N-]-[N+]#N"), "Cn1cc(C)nn1"),
+            (("CC#CI", "C-[N-]-[N+]#N"), "Cn1c(I)c(C)nn1"),
+            (("c1ccccc1C#C", "C-[N-]-[N+]#N"), "Cn1cc(-c2ccccc2)nn1"),
+        ]
+
+        self._test_one_product(reactants, self.reactant_names)
+
+    def test_no_product(self):
+        reactants = [
+            # Non-terminal alkynes
+            ("CC#CC", "C-N=[N+]=[N-]"),
+            ("CC#Cc1ccccc1", "C-N=[N+]=[N-]"),
+            ("c1ccccc1C#Cc1ccccc1", "C-N=[N+]=[N-]"),
+            ("C1CCCC#CCC1", "C-N=[N+]=[N-]"),
+        ]
+
+        self._test_no_product(reactants, self.reactant_names)
+
+    def test_if_get_products_returns_all_possible_products(self):
+        reactants = [
+            (("C#CC#C", "C-N=[N+]=[N-]"), ("C#Cc1cn(C)nn1", "C#Cc1cn(C)nn1")),
+            (("C#CCC#CI", "C-N=[N+]=[N-]"), ("IC#CCc1cn(C)nn1", "C#CCC(N=NN1C)=C1I")),
+        ]
+
+        self._test_all_possible_products(reactants, self.reactant_names)
+
+    def test_if_get_products_returns_only_1_products_if_symmetrical_as_one_is_true(self):
+        reactants = [
+            (("C#C", "C-N=[N+]=[N-]"), ["Cn1ccnn1"]),
+            (("C#C", "C-[N-]-[N+]#N"), ["Cn1ccnn1"]),
+        ]
+
+        self._test_all_possible_products(reactants, self.reactant_names, symmetrical_as_one=True)
+
+    def test_if_get_product_returns_the_symmetric_product_if_symmetrical_as_one_is_true(self):
+        reactants = [
+            (("C#C", "C-N=[N+]=[N-]"), "Cn1ccnn1"),
+            (("C#C", "C-[N-]-[N+]#N"), "Cn1ccnn1"),
+        ]
+
+        self._test_one_product(reactants, self.reactant_names, symmetrical_as_one=True)

data/tests/test_FmocRemoval.py

@@ -0,0 +1,46 @@
+from ClickReaction.Reactions import FmocRemoval
+from tests import TestHelper
+
+
+class FmocRemovalTest(TestHelper.ReactionTestCase):
+    reactant_names = ["fmocamine"]
+
+    def setUp(self):
+        self.set_reaction(FmocRemoval)
+
+    def test_one_product(self):
+        reactants = [
+            # Fmoc from primary aliphatic amine
+            (("CNC(OCC1C(C=CC=C2)=C2C3=C1C=CC=C3)=O", ), "CN"),
+            # Fmoc from primary aniline
+            (("O=C(NC1=CC=CC=C1)OCC2C(C=CC=C3)=C3C4=C2C=CC=C4", ), "NC1=CC=CC=C1"),
+            # Fmoc from secondary aliphatic amines
+            (("CN(C)C(OCC1C(C=CC=C2)=C2C3=C1C=CC=C3)=O", ), "CNC"),
+            # Fmoc from secondary anilines
+            (("O=C(N(C1=CC=CC=C1)C2=CC=CC=C2)OCC3C(C=CC=C4)=C4C5=C3C=CC=C5", ), "C1(NC2=CC=CC=C2)=CC=CC=C1"),
+            # Fmoc from mixed anilines / aliphatic amines
+            (("CN(C(OCC1C(C=CC=C2)=C2C3=C1C=CC=C3)=O)C4=CC=CC=C4", ), "CNC1=CC=CC=C1"),
+        ]
+
+        self._test_one_product(reactants, self.reactant_names)
+
+    # Those tests should not give any product.
+    def test_no_product(self):
+        reactants = [
+            # Boc
+            ("CNC(OC(C)(C)C)=O", ),
+
+            # Benzyl
+            ("CNCC1=CC=CC=C1", ),
+
+            # Dimethylamine
+            ("CNC",),
+
+            # O-Methylcarbamates
+            ("CN(C(OC)=O)C", ),
+
+            # Ureas
+            ("CN(C(NC)=O)C", ),
+        ]
+
+        self._test_no_product(reactants, self.reactant_names)

data/tests/test_SulfonAmideFormation.py

@@ -0,0 +1,63 @@
+from ClickReaction.Reactions import SulfonAmideFormation
+from tests import TestHelper
+
+
+class SulfonAmideFormationTest(TestHelper.ReactionTestCase):
+    reactant_names = ["amine", "sulfonylhalogenide"]
+
+    def setUp(self):
+        self.set_reaction(SulfonAmideFormation)
+
+    def test_one_product(self):
+        reactants = [
+            # Ammonia and sulfonyl halogenides
+            (("N", "F[S+2]([O-])([O-])CC"), "N[S+2]([O-])([O-])CC"),
+            (("N", "Cl[S+2]([O-])([O-])CC"), "N[S+2]([O-])([O-])CC"),
+            (("N", "Br[S+2]([O-])([O-])CC"), "N[S+2]([O-])([O-])CC"),
+            (("N", "I[S+2]([O-])([O-])CC"), "N[S+2]([O-])([O-])CC"),
+
+            # Primary amines and sulfonyl chlorides
+            (("CN", "Cl[S+2]([O-])([O-])CC"), "CN[S+2]([O-])([O-])CC"),
+            (("C[NH3+]", "Cl[S+2]([O-])([O-])CC"), "CN[S+2]([O-])([O-])CC"),
+
+            # Secondary amine and sulfonyl chloride
+            (("CNC", "Cl[S+2]([O-])([O-])CC"), "CN(-C)[S+2]([O-])([O-])CC"),
+            (("C[NH2+]C", "Cl[S+2]([O-])([O-])CC"), "CN(-C)[S+2]([O-])([O-])CC"),
+
+            # Primary aniline and sulfonyl chlorides
+            (("c1ccccc1N", "Cl[S+2]([O-])([O-])CC"), "c1ccccc1N[S+2]([O-])([O-])CC"),
+            (("c1ccccc1[NH3+]", "Cl[S+2]([O-])([O-])CC"), "c1ccccc1N[S+2]([O-])([O-])CC"),
+
+            # Secondary aniline and sulfonyl chloride
+            (("c1ccccc1NC", "Cl[S+2]([O-])([O-])CC"), "c1ccccc1N(C)[S+2]([O-])([O-])CC"),
+
+            # Pyrrole or indole
+            (("C1=CC=CN1", "Cl[S+2]([O-])([O-])CC"), "c1cccn1[S+2]([O-])([O-])CC"),
+            (("C1=CC=CN1", "Cl[S+2]([O-])([O-])CC"), "c1cccn1[S+2]([O-])([O-])CC"),
+            (("C12=CC=CC=C1NC=C2", "Cl[S+2]([O-])([O-])CC"), "c12ccccc1n([S+2]([O-])([O-])CC)cc2"),
+            (("c1ccc2[nH]ccc2c1", "Cl[S+2]([O-])([O-])CC"), "c12ccccc1n([S+2]([O-])([O-])CC)cc2"),
+
+            # Special test: This is a standard sulfon amide directly from ChemDraw. The tests should be able to digest this.
+            (("CN", "ClS(CC)(=O)=O"), "CN[S+2]([O-])([O-])CC"),
+        ]
+
+        self._test_one_product(reactants, self.reactant_names)
+
+    # Those tests should not give any product.
+    def test_no_product(self):
+        reactants = [
+            # Ammonium and sulfonic acid
+            ("N", "O[S+2]([O-])([O-])CC"),
+
+            # Ammonium and sulfonate
+            ("N", "[O-][S+2]([O-])([O-])CC"),
+
+            # No tertiary amine
+            ("N(C)(C)(C)", "F[S+2]([O-])([O-])CC"),
+
+            # No tertiary pyrrole or indole
+            ("c1cccn(C)1", "F[S+2]([O-])([O-])CC"),
+            ("c1ccc2n(C)ccc2c1", "F[S+2]([O-])([O-])CC")
+        ]
+
+        self._test_no_product(reactants, self.reactant_names)

data/tests/test_SuzukiMiyaura.py

@@ -0,0 +1,41 @@
+from ClickReaction.Reactions import SuzukiMiyaura
+from tests import TestHelper
+
+
+class SuzukiMiyauraTest(TestHelper.ReactionTestCase):
+    reactant_names = ["boronate", "halogenide"]
+
+    def setUp(self):
+        self.set_reaction(SuzukiMiyaura)
+
+    def test_one_product(self):
+        reactants = [
+            # Test phenylhalogenides and phenylboronic acid
+            (("c1ccccc1B(O)O", "c1ccccc1Cl"), "c1ccccc1c1ccccc1"),
+            (("c1ccccc1B(O)O", "c1ccccc1Br"), "c1ccccc1c1ccccc1"),
+            (("c1ccccc1B(O)O", "c1ccccc1I"), "c1ccccc1c1ccccc1"),
+
+            # Check different esters for the boronic acid
+            # BPin
+            (("CC1(C)C(C)(C)OB(C2=CC=CC=C2)O1", "c1ccccc1Cl"), "c1ccccc1c1ccccc1"),
+            # Mida (open form)
+            (("CN1CC(=O)OB(OC(=O)C1)c2ccccc2", "c1ccccc1Cl"), "c1ccccc1c1ccccc1"),
+            # Mida (closed form)
+            (("C[N+]12CC(O[B-](c3ccccc3)1OC(C2)=O)=O", "c1ccccc1Cl"), "c1ccccc1c1ccccc1"),
+
+            # Check trifluoroboronates
+            (("F[B-](F)(F)C1=CC=CC=C1.[K+]", "c1ccccc1Cl"), "c1ccccc1c1ccccc1"),
+        ]
+
+        self._test_one_product(reactants, self.reactant_names)
+
+    # Those tests should not give any product.
+    def test_no_product(self):
+        reactants = [
+            # Arylfluorides should not work.
+            ("c1ccccc1B(O)O", "c1ccccc1F"),
+            # This should also not work.
+            ("c1ccccc1P(O)O", "c1ccccc1Cl"),
+        ]
+
+        self._test_no_product(reactants, self.reactant_names)