chython 2.4__cp312-cp312-win_amd64.whl

chython/algorithms/aromatics/test/test_kekule.py

@@ -0,0 +1,160 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2025 Ramil Nugmanov <nougmanoff@protonmail.com>
+#  Copyright 2025 Tagir Akhmetshin <tagirshin@gmail.com>
+#  This file is part of chython.
+#
+#  chython is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation; either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program; if not, see <https://www.gnu.org/licenses/>.
+#
+from chython import smiles
+from chython.exceptions import InvalidAromaticRing
+from pytest import raises
+
+
+def test_kekule_basic():
+    # Test basic aromatic ring conversion
+    mol = smiles('c1ccccc1')  # benzene
+    assert mol.kekule()  # should return True for aromatic rings
+    assert mol == smiles('C1=CC=CC=C1')
+
+
+def test_kekule_pyridine():
+    # Test pyridine and its derivatives
+    mol = smiles('n1ccccc1')  # pyridine
+    assert mol.kekule()
+    assert mol == smiles('N1=CC=CC=C1')
+    assert mol.atom(1).implicit_hydrogens == 0
+
+    # Test protonated pyridine
+    mol = smiles('[nH+]1ccccc1')
+    assert mol.kekule()
+    assert mol == smiles('[NH+]1=CC=CC=C1')
+
+
+def test_kekule_pyrrole():
+    # Test pyrrole and its derivatives
+    mol = smiles('[nH]1cccc1')  # pyrrole
+    assert mol.kekule()
+    assert mol == smiles('N1C=CC=C1')
+    assert mol.atom(1).implicit_hydrogens == 1
+
+    mol = smiles('n1cccc1')
+    assert mol.kekule()
+    assert mol == smiles('N1C=CC=C1')
+    assert mol.atom(1).implicit_hydrogens == 1
+
+    # Test N-methylpyrrole
+    mol = smiles('Cn1cccc1')
+    assert mol.kekule()
+    assert mol == smiles('CN1C=CC=C1')
+    assert mol.atom(2).implicit_hydrogens == 0
+
+
+def test_kekule_furan_thiophene():
+    # Test oxygen and sulfur containing aromatics
+    mol = smiles('o1cccc1')
+    assert mol.kekule()
+    assert mol == smiles('O1C=CC=C1')
+    assert mol.atom(1).implicit_hydrogens == 0
+
+    mol = smiles('s1cccc1')
+    assert mol.kekule()
+    assert mol == smiles('S1C=CC=C1')
+    assert mol.atom(1).implicit_hydrogens == 0
+
+
+def test_kekule_complex_systems():
+    # Test fused ring systems
+    mol = smiles('c1ccc2ccccc2c1')
+    assert mol.kekule()
+    assert mol == smiles('C1=CC2=CC=CC=C2C=C1') or mol == smiles('C1=CC2=C(C=C1)C=CC=C2')
+
+    # Test indole
+    mol = smiles('c1ccc2[nH]ccc2c1')
+    assert mol.kekule()
+    assert mol == smiles('N1C=CC2=C1C=CC=C2') or mol == smiles('N1C=CC2=CC=CC=C12')
+
+
+def test_kekule_enumeration():
+    mol = smiles('Cc1ccccc1C')
+    forms = list(mol.enumerate_kekule())
+    assert len(forms) == 2  # benzene has 2 Kekule forms
+    assert smiles('CC1=C(C)C=CC=C1') in forms
+    assert smiles('CC1=CC=CC=C1C') in forms
+
+
+def test_kekule_invalid_structures():
+    # Test invalid aromatic structures
+    with raises(InvalidAromaticRing):
+        mol = smiles('c1cccc1')  # 5-membered carbon ring (invalid aromatic)
+        mol.kekule()
+
+    with raises(InvalidAromaticRing):
+        mol = smiles('c1ccc2c1c3ccccc3cc2')  # acenaphthalene (invalid aromatic form)
+        mol.kekule()
+
+    with raises(InvalidAromaticRing):
+        mol = smiles('c1cccc1C(=O)c1cccc1')  # cyclopentadiene with carbonyl (invalid aromatic)
+        mol.kekule()
+
+
+def test_kekule_charged_species():
+    # Test charged aromatic species
+    mol = smiles('[n+]1ccccc1')
+    assert mol.kekule()
+    assert mol == smiles('C=1[NH+]=CC=CC=1')
+
+    mol = smiles('[cH-]1cccc1')
+    assert mol.kekule()
+    assert mol == smiles('C=1C=C[CH-]C=1')
+
+
+def test_kekule_multiple_rings():
+    # Test molecules with multiple aromatic rings
+    mol = smiles('c1ccccc1c2ccccc2')
+    assert mol.kekule()
+    assert mol == smiles('C1=CC=C(C=C1)C1=CC=CC=C1')
+
+
+def test_kekule_heteroatoms():
+    # Test various heteroatoms in aromatic rings
+    mol = smiles('c1cncn1')  # two nitrogens
+    assert mol.kekule()
+    assert mol == smiles('N1C=CN=C1')
+
+    mol = smiles('o1cncc1')  # oxygen and nitrogen
+    assert mol.kekule()
+    assert mol == smiles('C1=COC=N1')
+
+
+def test_kekule_buffer_size():
+    # Test buffer size parameter for complex heterocycles
+    mol = smiles('c1ccc2[nH]ccc2c1')  # indole
+    assert mol.kekule(buffer_size=1)  # small buffer
+
+    mol = smiles('c1ccc2[nH]ccc2c1')  # fresh indole instance
+    assert mol.kekule(buffer_size=10)  # large buffer
+
+
+def test_kekule_radical_species():
+    mol = smiles('[c]1ccccc1')
+    assert mol.kekule()
+    assert mol == smiles('C=1C=CC=[C]C=1 |^1:4|')
+
+
+def test_kekule_quinones():
+    # Test quinone-like structures
+    mol = smiles('O=c1ccc(=O)cc1')
+    assert mol.kekule()
+    assert mol == smiles('C1=CC(C=CC1=O)=O')

chython/algorithms/aromatics/test/test_thiele.py

@@ -0,0 +1,263 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2025 Ramil Nugmanov <nougmanoff@protonmail.com>
+#  Copyright 2025 Tagir Akhmetshin <tagirshin@gmail.com>
+#  This file is part of chython.
+#
+#  chython is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation; either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program; if not, see <https://www.gnu.org/licenses/>.
+#
+from chython import smiles
+
+
+def test_basic_thiele():
+    # Test basic aromatic systems
+    mol = smiles('C1=CC=CC=C1')  # benzene in Kekule form
+    assert mol.thiele()
+
+    # Check that all bonds in the ring are aromatic (order 4)
+    for n, m, bond in mol.bonds():
+        assert bond.order == 4
+
+
+def test_pyrrole_thiele():
+    # Test pyrrole-like systems
+    mol = smiles('N1C=CC=C1')  # pyrrole in Kekule form
+    assert mol.thiele()
+
+    # Check that all bonds in the ring are aromatic
+    for n, m, bond in mol.bonds():
+        assert bond.order == 4
+
+
+def test_furan_thiele():
+    # Test furan-like systems
+    mol = smiles('O1C=CC=C1')  # furan in Kekule form
+    assert mol.thiele()
+
+    # Check that all bonds in the ring are aromatic
+    for n, m, bond in mol.bonds():
+        assert bond.order == 4
+
+
+def test_thiophene_thiele():
+    # Test thiophene-like systems
+    mol = smiles('S1C=CC=C1')  # thiophene in Kekule form
+    assert mol.thiele()
+
+    # Check that all bonds in the ring are aromatic
+    for n, m, bond in mol.bonds():
+        assert bond.order == 4
+
+
+def test_condensed_rings():
+    # Test condensed ring systems
+    mol = smiles('C1=CC=C2C=CC=CC2=C1')  # naphthalene in Kekule form
+    assert mol.thiele()
+
+    # Check that all bonds in both rings are aromatic
+    for n, m, bond in mol.bonds():
+        assert bond.order == 4
+
+
+def test_tautomer_fix():
+    # Test tautomer fixing in condensed rings
+    mol = smiles('N1C=CC2=NC=CC2=C1')  # before fix
+    assert mol.thiele(fix_tautomers=True)
+
+    for n, m, bond in mol.bonds():
+        assert bond.order == 4
+
+    assert mol.atom(1).implicit_hydrogens == 0
+    assert mol.atom(5).implicit_hydrogens == 1
+
+    mol = smiles('N1C=CC2=NC=CC2=C1')  # before fix
+    assert mol.thiele(fix_tautomers=False)
+
+    for n, m, bond in mol.bonds():
+        assert bond.order == 4
+
+    assert mol.atom(1).implicit_hydrogens == 1
+    assert mol.atom(5).implicit_hydrogens == 0
+
+
+def test_quinone_exclusion():
+    # Test that quinone-like structures are not aromatized
+    mol = smiles('O=C1C=CC(=O)C=C1')  # para-benzoquinone
+    assert not mol.thiele()  # should return False
+    assert mol == smiles('O=C1C=CC(=O)C=C1')
+
+
+def test_invalid_rings():
+    # Test that invalid rings are not aromatized
+    mol = smiles('C1=CC=C1')  # cyclobutadiene - too small
+    assert not mol.thiele()  # should return False
+
+    mol = smiles('C1=CC=CC=CC=CC=C1')  # 10-membered ring - too large
+    assert not mol.thiele()  # should return False
+
+
+def test_charged_systems():
+    # Test charged aromatic systems
+    mol = smiles('[NH+]1C=CC=CC=1')  # pyridinium in Kekule form
+    assert mol.thiele()
+
+    # Check that charge is preserved and ring is aromatic
+    assert mol.atom(1).charge == 1
+    assert mol.atom(1).implicit_hydrogens == 1
+
+    for n, m, bond in mol.bonds():
+        assert bond.order == 4  # all bonds should be aromatic
+
+
+def test_freak_rules():
+    # Test special cases handled by freak rules
+    mol = smiles('N1C=CN2C=CC=C12')  # special N-fused system in Kekule form
+    assert mol.thiele()
+
+    # Check that all bonds are aromatic
+    for n, m, bond in mol.bonds():
+        assert bond.order == 4
+
+
+def test_tetracyclic_systems():
+    # Test 4-membered ring in condensed systems
+    mol = smiles('C1=CC2=C(C=CC=C2)C1')  # benzocyclobutene
+    assert mol.thiele()
+    assert mol == smiles('C1C=Cc2ccccc12')
+
+
+def test_phosphorus_rings():
+    # Test phosphorus-containing aromatic rings
+    mol = smiles('P1C=CC=CC=1')  # phosphabenzene in Kekule form
+    assert mol.thiele()
+
+    # Check that all bonds in the ring are aromatic
+    for n, m, bond in mol.bonds():
+        assert bond.order == 4
+
+
+def test_boron_rings():
+    # Test boron-containing aromatic rings
+    mol = smiles('B1C=CC=C1')  # borole in Kekule form
+    assert mol.thiele()
+
+    # Check that all bonds in the ring are aromatic
+    for n, m, bond in mol.bonds():
+        assert bond.order == 4
+
+
+def test_seven_membered_rings():
+    # Test 7-membered rings with different heteroatoms
+    # Only boron-containing 7-membered rings should be aromatic
+    mol = smiles('B1C=CC=CC=C1')  # 7-membered ring with boron
+    assert mol.thiele()
+
+    mol = smiles('N1C=CC=CC=C1')  # 7-membered ring with nitrogen
+    assert not mol.thiele()
+
+
+def test_ferrocene_like():
+    # Test negatively charged carbon systems (ferrocene-like)
+    mol = smiles('[CH-]1C=CC=C1')  # cyclopentadienyl anion
+    assert mol.thiele()
+
+    for n, m, bond in mol.bonds():
+        assert bond.order == 4
+
+    assert int(mol) == -1
+    assert mol.atom(1).charge == -1
+
+
+def test_multiple_components():
+    # Test systems with multiple aromatic components
+    mol = smiles('C1=CC=CC=C1.C1=CC=CC=C1')  # two benzene molecules in Kekule form
+    assert mol.thiele()
+
+    # Check that all bonds in both components are aromatic
+    for n, m, bond in mol.bonds():
+        assert bond.order == 4
+    assert mol.connected_components_count == 2
+
+
+def test_complex_fused_systems():
+    # Test complex fused ring systems with multiple heteroatoms
+
+    # Benzothiazole (simplified)
+    mol = smiles('C1=CC=C2SC=NC2=C1')  # benzothiazole in Kekule form
+    assert mol.thiele()
+    for n, m, bond in mol.bonds():
+        assert bond.order == 4
+
+    # Thienopyridine (simplified)
+    mol = smiles('C1=CC=NC2=CSC=C12')  # thienopyridine in Kekule form
+    assert mol.thiele()
+    for n, m, bond in mol.bonds():
+        assert bond.order == 4
+
+
+def test_complex_charged_systems():
+    # Test charged aromatic systems
+
+    # Basic charged systems that should work
+    # Pyridinium
+    mol = smiles('[NH+]1C=CC=CC=1')  # pyridinium in Kekule form
+    assert mol.thiele()
+    for n, m, bond in mol.bonds():
+        assert bond.order == 4
+    assert mol.atom(1).charge == 1
+    assert mol.atom(1).implicit_hydrogens == 1
+
+    # Complex charged systems that are not yet supported
+    # N-methylpyridinium (currently not aromatized properly)
+    mol = smiles('C[N+]1=CC=CC=C1')  # N-methylpyridinium in Kekule form
+    assert mol.thiele()
+    assert mol.atom(2).charge == 1
+
+
+def test_complex_heterocycles():
+    # Test heterocyclic systems
+
+    # Basic heterocycles that should work
+    # Benzimidazole
+    mol = smiles('C1=CC=C2NC=NC2=C1')  # in Kekule form
+    assert mol.thiele()
+    for n, m, bond in mol.bonds():
+        assert bond.order == 4
+
+    # Quinoxaline
+    mol = smiles('C1=CC=C2N=CC=NC2=C1')  # in Kekule form
+    assert mol.thiele()
+    for n, m, bond in mol.bonds():
+        assert bond.order == 4
+
+    # Benzimidazole fused to thiophene (works)
+    mol = smiles('C1=CC2=C(C=C1)N=CN2C3=CC=CS3')  # in Kekule form
+    assert mol.thiele()
+
+    for n, m, bond in mol.bonds():
+        # Check if both atoms of the bond are in the same ring
+        assert bond.order == 4 or (bond.order == 1 and n in (9, 10) and m in (9, 10))
+
+
+def test_complex_bridged_systems():
+    # Complex bridged system with multiple heteroatoms (works)
+    mol = smiles('C1=CC2=C(C=C1)N=C3C(=C2)C=CC4=C3N=CS4')  # in Kekule form
+    assert mol.thiele()
+    for n, m, bond in mol.bonds():
+        assert bond.order == 4
+
+    # Bridged system with N and S (works)
+    mol = smiles('C1=CC2=C(C=C1)SC3=C(N=CC=C3)C=C2')  # in Kekule form
+    assert mol.thiele()
+    assert mol == smiles('S1c2ccccc2C=Cc2[n]cccc12')

chython/algorithms/aromatics/thiele.py

@@ -0,0 +1,226 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2021-2024 Ramil Nugmanov <nougmanoff@protonmail.com>
+#  This file is part of chython.
+#
+#  chython is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation; either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program; if not, see <https://www.gnu.org/licenses/>.
+#
+from collections import defaultdict
+from typing import TYPE_CHECKING
+from ._rules import freak_rules
+from ..rings import _sssr, _connected_components
+
+
+if TYPE_CHECKING:
+    from chython import MoleculeContainer
+
+
+# atomic number constants
+B = 5
+C = 6
+N = 7
+O = 8
+P = 15
+S = 16
+Se = 34
+
+
+class Thiele:
+    __slots__ = ()
+
+    def thiele(self: 'MoleculeContainer', *, fix_tautomers=True) -> bool:
+        """
+        Convert structure to aromatic form (Huckel rule ignored). Return True if found any kekule ring.
+        Also marks atoms as aromatic.
+
+        :param fix_tautomers: try to fix condensed rings with pyrroles.
+            N1C=CC2=NC=CC2=C1>>N1C=CC2=CN=CC=C12
+        """
+        atoms = self._atoms
+        bonds = self._bonds
+        nsc = self.not_special_connectivity
+
+        rings = defaultdict(set)  # aromatic? skeleton. include quinones
+        tetracycles = []
+        pyrroles = set()
+        acceptors = set()
+        donors = []
+        freaks = []
+        for ring in self.sssr:
+            lr = len(ring)
+            if not 3 < lr < 8:  # skip 3-membered and big rings
+                continue
+            # only B C N O P S with 2-3 neighbors. detects this: C1=CC=CP12=CC=CC=C2
+            if any(atoms[n] not in (C, N, O, S, B, P) or len(nsc[n]) > 3 for n in ring):
+                continue
+            sp2 = sum(atoms[n].hybridization == 2 for n in ring)
+            if sp2 == lr:  # benzene like
+                if lr == 4:  # two bonds condensed aromatic rings
+                    tetracycles.append(ring)
+                else:
+                    if fix_tautomers and lr % 2:  # find potential pyrroles
+                        acceptors.update(n for n in ring if (a := atoms[n]) == N and not a.charge)
+                    n, *_, m = ring
+                    rings[n].add(m)
+                    rings[m].add(n)
+                    for n, m in zip(ring, ring[1:]):
+                        rings[n].add(m)
+                        rings[m].add(n)
+            elif 4 < lr == sp2 + 1:  # pyrroles, furanes, etc
+                try:
+                    n = next(n for n in ring if atoms[n].hybridization == 1)
+                except StopIteration:  # exotic, just skip
+                    continue
+                if (a := atoms[n]).charge == -1:
+                    if a != C or lr != 5:  # skip any but ferrocene
+                        continue
+                elif a.charge:  # skip any charged
+                    continue
+                elif lr == 7:  # skip electron-rich 7-membered rings
+                    if a != 5:  # not B?
+                        continue
+                # below lr == 5 or 6 only
+                elif a in (O, S, Se):
+                    if len(bonds[n]) != 2:  # like CS1(C)C=CC=C1
+                        continue
+                elif a == N:
+                    if (b := len(bonds[n])) > 3:  # extra check for invalid N(IV)
+                        continue
+                    elif fix_tautomers and lr == 6 and b == 2:
+                        donors.append(n)
+                elif a in (B, P):
+                    if len(bonds[n]) > 3:
+                        continue
+                else:  # only B, [C-], N, O, P, S, Se
+                    continue
+
+                pyrroles.add(n)
+                n, *_, m = ring
+                rings[n].add(m)
+                rings[m].add(n)
+                for n, m in zip(ring, ring[1:]):
+                    rings[n].add(m)
+                    rings[m].add(n)
+            # like N1C=Cn2cccc12, S1C=Cn2cccc12
+            elif lr == 5 and sp2 == 3:
+                freaks.append(ring)
+        if not rings:
+            return False
+
+        # check out-of-ring double bonds
+        double_bonded = {n for n in rings if any(m not in rings[n] and b == 2 for m, b in bonds[n].items())}
+
+        # fix_tautomers
+        if fix_tautomers and acceptors and donors:
+            for start in donors:
+                stack = [(start, n, 0, 2) for n in rings[start] if n not in double_bonded]
+                path = []
+                seen = {start}
+                while stack:
+                    last, current, depth, order = stack.pop()
+                    if len(path) > depth:
+                        seen.difference_update(x for _, x, _ in path[depth:])
+                        path = path[:depth]
+                    path.append((last, current, order))
+                    if current in acceptors:  # we found
+                        if order == 1:
+                            acceptors.discard(current)
+                            pyrroles.discard(start)
+                            pyrroles.add(current)
+                            atoms[current]._implicit_hydrogens = 1
+                            atoms[start]._implicit_hydrogens = 0
+                            break
+                        else:
+                            continue
+
+                    depth += 1
+                    seen.add(current)
+                    new_order = 1 if order == 2 else 2
+                    stack.extend((current, n, depth, new_order) for n in rings[current] if
+                                 n not in seen and n not in double_bonded and bonds[current][n] == order)
+                else:  # path not found
+                    continue
+                for n, m, o in path:
+                    bonds[n][m]._order = o
+                if not acceptors:
+                    break
+            self.flush_cache(keep_sssr=True, keep_components=True)
+            self.calc_labels()
+
+        if double_bonded:  # delete quinones
+            for n in double_bonded:
+                for m in rings.pop(n):
+                    rings[m].discard(n)
+
+            for n in [n for n, ms in rings.items() if not ms]:  # imide leads to isolated atoms
+                del rings[n]
+            if not rings:
+                return False
+            while True:
+                try:
+                    n = next(n for n, ms in rings.items() if len(ms) == 1)
+                except StopIteration:
+                    break
+                m = rings.pop(n).pop()
+                if n in pyrroles:
+                    rings[m].discard(n)
+                else:
+                    pm = rings.pop(m)
+                    pm.discard(n)
+                    for x in pm:
+                        rings[x].discard(m)
+            if not rings:
+                return False
+
+        n_sssr = sum(len(x) for x in rings.values()) // 2 - len(rings) + len(_connected_components(rings))
+        if not n_sssr:
+            return False
+        rings = _sssr(rings, n_sssr)  # search rings again
+
+        seen = set()
+        for ring in rings:
+            seen.update(ring)
+
+        # reset bonds to single
+        for ring in tetracycles:
+            if seen.issuperset(ring):
+                n, *_, m = ring
+                bonds[n][m]._order = 1
+                for n, m in zip(ring, ring[1:]):
+                    bonds[n][m]._order = 1
+
+        for ring in rings:
+            n, *_, m = ring
+            bonds[n][m]._order = 4
+            for n, m in zip(ring, ring[1:]):
+                bonds[n][m]._order = 4
+
+        self.flush_cache(keep_sssr=True, keep_components=True)
+        self.calc_labels()
+        for ring in freaks:  # aromatize rule based
+            for q in freak_rules:
+                if next(q.get_mapping(self, searching_scope=ring, automorphism_filter=False), None):
+                    n, *_, m = ring
+                    bonds[n][m]._order = 4
+                    for n, m in zip(ring, ring[1:]):
+                        bonds[n][m]._order = 4
+                    break
+        if freaks:
+            self.flush_cache(keep_sssr=True, keep_components=True)  # flush again
+            self.calc_labels()
+        self.fix_stereo()  # check if any stereo centers vanished.
+        return True
+
+
+__all__ = ['Thiele']

chython/algorithms/calculate2d/__init__.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2019-2025 Ramil Nugmanov <nougmanoff@protonmail.com>
+#  This file is part of chython.
+#
+#  chython is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation; either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program; if not, see <https://www.gnu.org/licenses/>.
+#
+from .molecule import *
+from .reaction import *
+
+
+__all__ = ['Calculate2DMolecule', 'Calculate2DReaction']