chython 2.19__cp313-cp313-win_amd64.whl

chython/reactor/base.py

@@ -0,0 +1,222 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2014-2026 Ramil Nugmanov <nougmanoff@protonmail.com>
+#  Copyright 2019 Adelia Fatykhova <adelik21979@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 typing import Union
+from ..containers import MoleculeContainer, QueryContainer
+from ..containers.bonds import Bond
+from ..periodictable import Element, AnyElement, QueryElement
+
+
+class BaseReactor:
+    def __init__(self, pattern, replacement, delete_atoms, canonicalize, fix_tautomers, ignore_pyrrole_hydrogen):
+        if isinstance(replacement, QueryContainer):
+            for n, a in replacement.atoms():
+                if not isinstance(a, (AnyElement, QueryElement)):
+                    raise TypeError('Unsupported query atom type')
+                elif len(a.implicit_hydrogens) > 1:
+                    raise ValueError('Query element in patch has more than one implicit hydrogen clause')
+            for *_, b in replacement.bonds():
+                if len(b.order) > 1:
+                    raise ValueError('Variable bond in replacement')
+
+        self._to_delete = {n for n, a in pattern.atoms() if not a.masked} - set(replacement) if delete_atoms else ()
+        self._replacement = replacement
+        self._canonicalize = canonicalize
+        self._fix_tautomers = fix_tautomers
+        self._ignore_pyrrole_hydrogen = ignore_pyrrole_hydrogen
+
+    def _get_deleted(self, structure, mapping):
+        if not self._to_delete:
+            return set()
+
+        bonds = structure._bonds
+        to_delete = {mapping[x] for x in self._to_delete}
+        # if deleted atoms have another path to remain fragment, the path is preserved
+        remain = set(mapping.values()).difference(to_delete)
+        delete, global_seen = set(), set()
+        for x in to_delete:
+            for n in bonds[x]:
+                if n in global_seen or n in remain:
+                    continue
+                seen = {n}
+                global_seen.add(n)
+                stack = [x for x in bonds[n] if x not in global_seen]
+                while stack:
+                    current = stack.pop()
+                    if current in remain:
+                        break
+                    if current in to_delete:
+                        continue
+                    seen.add(current)
+                    global_seen.add(current)
+                    stack.extend([x for x in bonds[current] if x not in global_seen])
+                else:
+                    delete.update(seen)
+
+        to_delete.update(delete)
+        return to_delete
+
+    def _patcher(self, structure: MoleculeContainer, mapping):
+        satoms = structure._atoms
+        sbonds = structure._bonds
+
+        to_delete = self._get_deleted(structure, mapping)
+        new = structure.__class__()
+        natoms = new._atoms
+        nbonds = new._bonds
+        max_atom = max(satoms)
+        stereo_atoms = []
+        stereo_bonds = []
+
+        # let's preserve connectivity order from replacement to keep stereo signs as is.
+        # stereo labels from original structure will be recalculated after full molecule construction.
+        for n, ra in self._replacement.atoms():
+            if isinstance(ra, AnyElement):
+                if m := mapping.get(n):
+                    # keep matched atom type and isotope
+                    sa = satoms[m]
+                    a = sa.copy()
+                    a.charge = ra.charge
+                    a.is_radical = ra.is_radical
+                    if ra.stereo is not None:  # override stereo
+                        a._stereo = ra.stereo
+                        a._extended_stereo = sa.extended_stereo  # stereo swap doesn't resolve uncertainty
+                    elif sa.stereo is not None:  # keep original stereo
+                        stereo_atoms.append(m)  # mark for stereo fix
+                        a._extended_stereo = sa._extended_stereo  # masked by property if retranslation fails
+                else:
+                    raise ValueError("AnyElement doesn't match to pattern")
+            else:  # QueryElement or Element
+                ra: Union[QueryElement, Element]  # typehint
+                e = Element.from_atomic_number(ra.atomic_number)
+                a = e(ra.isotope, charge=ra.charge, is_radical=ra.is_radical)
+                if not (m := mapping.get(n)):  # new atom
+                    m = max_atom + 1
+                    mapping[n] = max_atom = m
+                    a._stereo = ra.stereo  # keep stereo from patch for new atoms
+                    if isinstance(ra, Element):
+                        a._implicit_hydrogens = ra.implicit_hydrogens  # keep H count from patch
+                        a.xy = ra.xy  # keep coordinates from patch
+                        a._extended_stereo = ra._extended_stereo  # propagate template's extended stereo
+                    elif ra.implicit_hydrogens:  # keep H count from patch
+                        a._implicit_hydrogens = ra.implicit_hydrogens[0]
+                else:  # existing atoms
+                    sa = satoms[m]
+                    a.xy = sa.xy  # preserve existing coordinates
+                    if ra.stereo is not None:
+                        a._stereo = ra.stereo
+                        # template's extended stereo takes priority (e.g. reaction giving racemic product)
+                        if isinstance(ra, Element) and ra.extended_stereo is not None:
+                            a._extended_stereo = ra.extended_stereo
+                        else:  # stereo swap doesn't resolve uncertainty
+                            a._extended_stereo = sa.extended_stereo
+                    elif sa.stereo is not None:  # keep original stereo
+                        stereo_atoms.append(m)
+                        a._extended_stereo = sa._extended_stereo
+            natoms[m] = a
+            nbonds[m] = {}
+
+        # preserve connectivity order
+        for n, bs in self._replacement._bonds.items():
+            n = mapping[n]
+            for m, rb in bs.items():
+                m = mapping[m]
+                if n in nbonds[m]:  # back-link
+                    nbonds[n][m] = nbonds[m][n]
+                else:
+                    nbonds[n][m] = b = Bond(int(rb))
+                    if rb.stereo is not None:  # override stereo
+                        b._stereo = rb.stereo
+                    # check bond exists in source and has stereo label and the same order
+                    elif (sbn := sbonds.get(n)) is None or (sb := sbn.get(m)) is None or sb.stereo is None or sb != b:
+                        continue
+                    else:  # original structure has stereo bond
+                        stereo_bonds.append((n, m))
+
+        patched_atoms = set(new)
+        for n, sa in satoms.items():  # add unmatched or masked atoms
+            if n not in patched_atoms and n not in to_delete:
+                natoms[n] = a = sa.copy(hydrogens=True)
+                a._extended_stereo = sa._extended_stereo  # preserve for atoms outside RC
+                nbonds[n] = {}
+                if sa.stereo is not None:
+                    # in case of allenes label can disappear/change, thus, requires recalculation
+                    # for tetrahedrons label can be stored as is
+                    if n in structure.stereogenic_tetrahedrons:
+                        a._stereo = sa.stereo
+                    else:
+                        stereo_atoms.append(n)
+
+        for n, bs in sbonds.items():  # preserve connectivity order for keeping stereo labels as is
+            if n in to_delete:  # atoms for removing
+                continue
+            for m, b in bs.items():
+                # ignore deleted atoms and patch atoms
+                if m in to_delete or n in patched_atoms and m in patched_atoms:
+                    continue
+                elif n in nbonds[m]:  # back-link
+                    nbonds[n][m] = nbonds[m][n]
+                else:
+                    nbonds[n][m] = b.copy()
+                    if b.stereo is not None:
+                        # stereo label should be recalculated
+                        stereo_bonds.append((n, m))
+
+        for n, a in new.atoms():
+            if a.implicit_hydrogens is None:
+                new.calc_implicit(n)
+        new.calc_labels()
+
+        # translate stereo sign from old order to new order
+        for n in stereo_atoms:
+            if n in new.stereogenic_tetrahedrons:
+                if sbonds[n].keys() == nbonds[n].keys():
+                    # flush stereo from reaction center. should be explicitly set in replacement.
+                    s = new._translate_tetrahedron_sign(n, structure.stereogenic_tetrahedrons[n], satoms[n].stereo)
+                    natoms[n]._stereo = s
+            elif n in new.stereogenic_allenes:
+                if set(new.stereogenic_allenes[n]) == set(structure.stereogenic_allenes[n]):
+                    # flush stereo for changed allene substituents
+                    s = new._translate_allene_sign(n, *structure.stereogenic_allenes[n][:2], satoms[n].stereo)
+                    natoms[n]._stereo = s
+            # else: ignore label
+
+        for n, m in stereo_bonds:
+            # check if bond is center of cumulene
+            if (n12 := new._stereo_cis_trans_terminals.get(n, True)) != new._stereo_cis_trans_terminals.get(m, False):
+                continue
+            s12 = structure._stereo_cis_trans_terminals[n]
+            # check if cumulene terminals are the same
+            if set(n12) != set(s12):
+                continue
+            if set(new.stereogenic_cis_trans[n12]) == set(env := structure.stereogenic_cis_trans[s12]):
+                # connected to cumulenes atoms should be the same
+                s = new._translate_cis_trans_sign(*n12, *env[:2], sbonds[n][m].stereo)
+                nbonds[n][m]._stereo = s
+            # else: ignore label
+
+        if self._canonicalize:
+            new.canonicalize(fix_tautomers=self._fix_tautomers,
+                            ignore_pyrrole_hydrogen=self._ignore_pyrrole_hydrogen)
+        else:
+            new.fix_stereo()
+        return new
+
+
+__all__ = ['BaseReactor']

chython/reactor/reactor.py

@@ -0,0 +1,177 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2019-2026 Ramil Nugmanov <nougmanoff@protonmail.com>
+#  Copyright 2019 Adelia Fatykhova <adelik21979@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 collections import deque
+from functools import reduce
+from itertools import count, permutations, combinations
+from logging import getLogger, INFO
+from operator import or_
+from typing import List, Iterator, Tuple, Union
+from .base import BaseReactor
+from .._functions import lazy_product
+from ..containers import QueryContainer, MoleculeContainer, ReactionContainer
+
+
+logger = getLogger('chython.reactor')
+logger.setLevel(INFO)
+
+
+class Reactor(BaseReactor):
+    """
+    Reactor for molecules transformations.
+    Generates reaction from input molecules using transformation template.
+
+    Reactor calling transforms reactants to products and
+    returns generator of reaction transformations with all
+    possible reactions.
+    """
+    def __init__(self, patterns: Tuple[QueryContainer, ...],
+                 products: Tuple[Union[MoleculeContainer, QueryContainer], ...], *,
+                 delete_atoms: bool = True, one_shot: bool = True, polymerise_limit: int = 10,
+                 automorphism_filter: bool = True, canonicalize: bool = True,
+                 fix_tautomers: bool = True, ignore_pyrrole_hydrogen: bool = False):
+        """
+        :param patterns: Search patterns for each reactant.
+        :param products: Resulted structures.
+        :param delete_atoms: If True atoms exists in reactants but not exists in products will be removed.
+        :param one_shot: Do only single reaction center then True, else do all possible combinations of reactions.
+        :param polymerise_limit: Limit of self reactions. Make sense than one_shot = False.
+        :param automorphism_filter: Skip matches to same atoms.
+        :param canonicalize: Run full canonicalization on products (kekule, standardize, thiele, etc.).
+        :param fix_tautomers: Canonicalize tautomer forms. Passed to canonicalize().
+        :param ignore_pyrrole_hydrogen: Fix invalid rings like Cn1cc[nH]c1. Passed to canonicalize().
+        """
+        if not patterns or not products:
+            raise ValueError('empty template')
+
+        if not all(isinstance(x, QueryContainer) for x in patterns):
+            raise TypeError('invalid params')
+        elif not all(isinstance(x, (QueryContainer, MoleculeContainer)) for x in products):
+            raise TypeError('invalid params')
+        self._patterns = patterns
+        self._products = products
+
+        self._one_shot = one_shot
+        self._polymerise_limit = polymerise_limit
+        self._products_atoms = tuple(set(m) for m in products)
+        self._automorphism_filter = automorphism_filter
+        super().__init__(reduce(or_, patterns), reduce(or_, products), delete_atoms, canonicalize,
+                         fix_tautomers, ignore_pyrrole_hydrogen)
+
+    def __call__(self, *structures: MoleculeContainer):
+        if any(not isinstance(structure, MoleculeContainer) for structure in structures):
+            raise TypeError('only list of Molecules possible')
+
+        len_patterns = len(self._patterns)
+        structures = fix_mapping_overlap(structures)
+        s_nums = set(range(len(structures)))
+        seen = set()
+        if self._one_shot:
+            for chosen in permutations(s_nums, len_patterns):
+                ignored = [structures[x] for x in s_nums.difference(chosen)]
+                chosen = [structures[x] for x in chosen]
+                for new in self._single_stage(chosen, {x for x in ignored for x in x}):
+                    # store reacted molecules in same order as matched pattern
+                    r = ReactionContainer([x.copy() for x in chosen] + [x.copy() for x in ignored],
+                                          new + [x.copy() for x in ignored])
+                    if len(new) > 1:  # try to keep salts
+                        r.contract_ions()
+                    if str(r) in seen:
+                        continue
+                    seen.add(str(r))
+                    yield r
+        else:
+            queue = deque(([structures[x] for x in chosen], [structures[x] for x in s_nums.difference(chosen)], 0)
+                          for chosen in permutations(s_nums, len_patterns))
+            while queue:
+                chosen, ignored, depth = queue.popleft()
+                depth += 1
+                for new in self._single_stage(chosen, {x for x in ignored for x in x}):
+                    r = ReactionContainer([x.copy() for x in structures], new + [x.copy() for x in ignored])
+                    if len(new) > 1:
+                        r.contract_ions()  # try to keep salts
+                        if str(r) in seen:
+                            continue
+                        seen.add(str(r))
+                        if len(r.products) != len(ignored) + len(self._products_atoms):
+                            logger.info('ambiguous multicomponent structures. skip multistage processing')
+                            yield r
+                            continue
+                    elif str(r) in seen:
+                        continue
+                    else:
+                        seen.add(str(r))
+
+                    if depth < self._polymerise_limit:
+                        prod = r.products
+                        if len_patterns == 1:  # simple case. only products or ignored can be transformed.
+                            for i in range(len(prod)):
+                                queue.append(([prod[i]], [*prod[:i], *prod[i + 1:]], depth))
+                        else:  # one of products molecule combined with previously chosen
+                            for chp in combinations(chosen, len_patterns - 1):
+                                for i in range(len(prod)):
+                                    for ch in permutations(fix_mapping_overlap((prod[i], *chp)), len_patterns):
+                                        queue.append((ch, [*prod[:i], *prod[i + 1:]], depth))
+                    yield r
+
+    def _single_stage(self, chosen, ignored) -> Iterator[List[MoleculeContainer]]:
+        max_ignored_number = united_chosen = None
+        split = len(self._products_atoms) > 1
+        for match in lazy_product(*(x.get_mapping(y, automorphism_filter=self._automorphism_filter) for x, y in
+                                    zip(self._patterns, chosen))):
+            mapping = match[0].copy()
+            for m in match[1:]:
+                mapping.update(m)
+            if united_chosen is None:
+                united_chosen = reduce(or_, chosen)
+                max_ignored_number = max(ignored, default=0)
+            try:
+                new = self._patcher(united_chosen, mapping)
+            except Exception:
+                logger.info('invalid product structure, skipping')
+                continue
+            collision = set(new).intersection(ignored)
+            if collision:
+                new.remap(dict(zip(collision, count(max(max_ignored_number, max(new)) + 1))))
+
+            if split:
+                yield new.split()
+            else:
+                yield [new]
+
+
+def fix_mapping_overlap(structures) -> List[MoleculeContainer]:
+    if len(structures) == 1:
+        return list(structures)
+    checked = []
+    checked_atoms = set()
+    for structure in structures:
+        intersection = set(structure).intersection(checked_atoms)
+        if intersection:
+            mapping = dict(zip(intersection, count(max(max(checked_atoms), max(structure)) + 1)))
+            structure = structure.copy()
+            structure.remap(mapping)
+            logger.info('some atoms in input structures had the same numbers.\n'
+                        f'atoms {list(mapping)} were remapped to {list(mapping.values())}')
+        checked_atoms.update(structure)
+        checked.append(structure)
+    return checked
+
+
+__all__ = ['Reactor', 'fix_mapping_overlap']

chython/reactor/test/__init__.py

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2022-2026 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/>.
+#

chython/reactor/test/test_reactor.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2025, 2026 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 chython import smiles, smarts, Reactor
+from pytest import mark
+
+
+data = [
+    (('[B;D3;x2;z1:4]([O:5])([O:6])-[C;@@;h1:3]1([O;M][C;M]1)', '[Cl,Br,I;D1:1]-[C;a:2]'), ('[A;@:3]-[A:2]',),
+     ('CC1O[C@@H]1B(O)O', 'Brc1ccccc1'), ('CC1O[C@H]1c1ccccc1',)),  # inverse stereo check
+    (('[B;D3;x2;z1:4]([O:5])([O:6])-[C;@@;h1:3]1([O;M][C;M]1)', '[Cl,Br,I;D1:1]-[C;a:2]'), ('[A;@@:3]-[A:2]',),
+     ('CC1O[C@@H]1B(O)O', 'Brc1ccccc1'), ('CC1O[C@@H]1c1ccccc1',)),  # keep stereo on RC
+    (('[B;D3;x2;z1:4]([O:5])([O:6])-[C;@@;h1:3]1([O;M][C;M]1)', '[Cl,Br,I;D1:1]-[C;a:2]'), ('[A:3]-[A:2]',),
+     ('CC1O[C@@H]1B(O)O', 'Brc1ccccc1'), ('CC1OC1c1ccccc1',)),  # drop stereo on RC
+]
+
+
+@mark.parametrize('patterns, products, source, result', data)
+def test_transformer(patterns, products, source, result):
+    for q, m in zip(patterns, source):
+        assert smarts(q) <= smiles(m)
+
+    reactor = Reactor([smarts(x) for x in patterns], [smarts(x) for x in products])
+    out = {format(smiles(x), 'h') for x in result}
+    assert {format(x, 'h') for x in next(reactor(*(smiles(x) for x in source))).products} == out

chython/reactor/test/test_transformer.py

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2025, 2026 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 chython import smiles, smarts, Transformer
+from pytest import mark
+
+
+data = [
+    ('[C:1]Br', '[A:1][O;M]', 'C[C@H](OC)CBr', 'C[C@H](OC)CO'),  # keep stereo out of match
+    ('[C:2][C:1]Br', '[A:2][A:1][O;M]', 'C[C@H](OC)CBr', 'C[C@H](OC)CO'),  # keep stereo inside match
+    ('[C;M][C;@;h1:1]([O;M])[N;M]', '[A;@@:1]', 'CC[C@H](O)N', 'CC[C@@H](O)N'),  # inversion of stereo
+    ('[C:1]Br', '[A:1][O;M]', 'C/C=C/CBr', 'C/C=C/CO'),  # keep stereo out of match
+    ('[C:1]Br', '[A:1][O;M]', 'CC=[C@]=CCBr', 'CC=[C@]=CCO'),  # keep
+    ('[C:1]Br', '[A:1][O;M]', 'CC=[C@]=CBr', 'CC=C=CO'),  # drop stereo on RC
+    ('[C:1]Br', '[A:1][I;M]', 'C/C=C/Br', 'CC=CI'),  # drop stereo on RC
+]
+
+
+@mark.parametrize('pattern, replacement, source, result', data)
+def test_transformer(pattern, replacement, source, result):
+    transformer = Transformer(smarts(pattern), smarts(replacement))
+
+    mol = smiles(source)
+    out = {format(smiles(x), 'h') for x in ([result] if isinstance(result, str) else result)}
+    assert {format(x, 'h') for x in transformer(mol)} == out
+
+
+# Extended stereo test cases.
+#
+# Extended stereo encodes epistemic state (what we know about the mixture), not geometry:
+#   AND group (+N): racemic mixture — all centers in the group share relative config
+#   OR group  (-N): pure compound, unknown absolute config at each center
+#
+# Rules implemented in _patcher:
+#   1. Atoms outside RC: extended stereo always preserved
+#   2. Template overrides stereo (swap/inversion): uncertainty is unchanged, preserve reactant's ext stereo
+#   3. Stereo lost (center destroyed or retranslation fails): ext stereo dropped (masked by property)
+#   4. MoleculeContainer template with extended stereo: template's label takes priority
+
+ext_data = [
+    # AND group outside RC preserved
+    ('[C:1]Br', '[A:1][O;M]', 'C[C@H](CC)CBr |&1:1|', '[C@H](CO)(CC)C |&1:0|'),
+    # OR group outside RC preserved
+    ('[C:1]Br', '[A:1][O;M]', 'C[C@H](CC)CBr |o1:1|', '[C@H](CO)(CC)C |o1:0|'),
+    # AND group in RC, stereo dropped
+    ('[C:1]Br', '[A:1][O;M]', 'CC[C@@H](C)Br |&1:2|', 'CCC(C)O'),
+    # AND group in RC, stereo inverted — swap doesn't resolve uncertainty
+    ('[C;M][C;@;h1:1]([O;M])[N;M]', '[A;@@:1]', 'CC[C@H](O)N |&1:2|', 'O[C@@H](N)CC |&1:1|'),
+    # OR group in RC, stereo inverted — swap doesn't resolve uncertainty
+    ('[C;M][C;@;h1:1]([O;M])[N;M]', '[A;@@:1]', 'CC[C@H](O)N |o1:2|', 'O[C@@H](N)CC |o1:1|'),
+    # two AND members: one loses stereo in RC, other outside RC keeps label
+    ('[C:1]Br', '[A:1][N;M]', 'C[C@H](F)[C@H](O)Br |&1:1,3|', 'OC(N)[C@H](C)F |&1:3|'),
+    # multiple independent AND/OR groups preserved
+    ('[C:1]Br', '[A:1][O;M]', '[C@H](F)(O)[C@@H](Cl)CBr |&1:0,o1:3|',
+     'O[C@@H]([C@@H](Cl)CO)F |&1:1,o1:2|'),
+]
+
+
+@mark.parametrize('pattern, replacement, source, expected', ext_data)
+def test_extended_stereo(pattern, replacement, source, expected):
+    t = Transformer(smarts(pattern), smarts(replacement))
+    p = next(iter(t(smiles(source))))
+    assert p == smiles(expected)

chython/reactor/transformer.py

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2014-2026 Ramil Nugmanov <nougmanoff@protonmail.com>
+#  Copyright 2019 Adelia Fatykhova <adelik21979@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 logging import getLogger
+from typing import Union
+from .base import BaseReactor
+from ..containers import QueryContainer, MoleculeContainer
+
+
+logger = getLogger('chython.reactor')
+
+
+class Transformer(BaseReactor):
+    """
+    Editor for molecules.
+    generates modified molecules from input molecule using template.
+    Transformer calling returns generator of all possible replacements.
+    """
+    def __init__(self, pattern: QueryContainer, replacement: Union[MoleculeContainer, QueryContainer],
+                 delete_atoms: bool = True, automorphism_filter: bool = True, canonicalize: bool = True,
+                 fix_tautomers: bool = True, ignore_pyrrole_hydrogen: bool = False,
+                 copy_metadata: bool = False):
+        """
+        :param pattern: Search pattern.
+        :param replacement: Resulted structure.
+        :param delete_atoms: If True atoms exists in reactants but not exists in products will be removed.
+        :param automorphism_filter: Skip matches to same atoms.
+        :param canonicalize: Run full canonicalization on products (kekule, standardize, thiele, etc.).
+        :param fix_tautomers: Canonicalize tautomer forms. Passed to canonicalize().
+        :param ignore_pyrrole_hydrogen: Fix invalid rings like Cn1cc[nH]c1. Passed to canonicalize().
+        :param copy_metadata: Copy metadata from structure to transformed.
+        """
+        if not isinstance(pattern, QueryContainer) or not isinstance(replacement, (MoleculeContainer, QueryContainer)):
+            raise TypeError('invalid params')
+
+        self._pattern = pattern
+        self._automorphism_filter = automorphism_filter
+        self._copy_metadata = copy_metadata
+        super().__init__(pattern, replacement, delete_atoms, canonicalize, fix_tautomers, ignore_pyrrole_hydrogen)
+
+    def __call__(self, structure: MoleculeContainer):
+        if not isinstance(structure, MoleculeContainer):
+            raise TypeError('only Molecules possible')
+
+        for mapping in self._pattern.get_mapping(structure, automorphism_filter=self._automorphism_filter):
+            try:
+                transformed = self._patcher(structure, mapping)
+            except Exception:
+                logger.info('invalid product structure, skipping')
+                continue
+            if self._copy_metadata:
+                transformed.meta.update(structure.meta)
+            yield transformed
+
+
+__all__ = ['Transformer']

chython/utils/__init__.py

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2019-2026 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 .free_wilson import *
+from .grid import *
+from .retro import *
+from ..containers.graph import Graph
+
+
+_patched = False
+
+
+def patch_pandas():
+    """
+    Fix pandas molecules representation.
+    """
+    # prevent recursive patching
+    global _patched
+    if _patched:
+        return
+    _patched = True
+
+    from pandas.io.formats import printing
+    from pandas.io.formats.printing import is_sequence
+
+    def w(obj):
+        if isinstance(obj, Graph):
+            return False
+        return is_sequence(obj)
+
+    printing.is_sequence = w
+
+
+__all__ = ['fw_prepare_groups', 'fw_decomposition_tree',
+           'grid_depict', 'GridDepict', 'retro_depict', 'RetroDepict', 'patch_pandas']