chython 2.19__cp313-cp313-win_amd64.whl

chython/containers/query.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2018-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 typing import Tuple, Union
+from .bonds import Bond, QueryBond
+from .graph import Graph
+from ..algorithms.isomorphism import QueryIsomorphism
+from ..periodictable import Element, QueryElement
+from ..periodictable.base import Query
+
+
+class QueryContainer(Graph[Query, QueryBond], QueryIsomorphism):
+    __slots__ = ('_smarts',)
+
+    def __init__(self, smarts: str):
+        super().__init__()
+        self._smarts = smarts
+
+    def __str__(self):
+        return self._smarts
+
+    def __repr__(self):
+        return f'smarts({self._smarts})'
+
+    def add_atom(self, atom: Union[Query, Element, int, str], *args, **kwargs):
+        if not isinstance(atom, Query):
+            # set only basic labels: charge, radical, isotope. use Query object directly for the full control.
+            if isinstance(atom, Element):
+                atom = QueryElement.from_atom(atom)
+            elif isinstance(atom, str):
+                atom = QueryElement.from_symbol(atom)()
+            elif isinstance(atom, int):
+                atom = QueryElement.from_atomic_number(atom)()
+            else:
+                raise TypeError('QueryElement object expected')
+        return super().add_atom(atom, *args, **kwargs)
+
+    def add_bond(self, n, m, bond: Union[QueryBond, Bond, int, Tuple[int, ...]]):
+        if isinstance(bond, Bond):
+            bond = QueryBond.from_bond(bond)
+        elif not isinstance(bond, QueryBond):
+            bond = QueryBond(bond)
+        super().add_bond(n, m, bond)
+
+    def union(self, other: 'QueryContainer', *, remap: bool = False, copy: bool = True) -> 'QueryContainer':
+        if not isinstance(other, QueryContainer):
+            raise TypeError('QueryContainer expected')
+        return super().union(other, remap=remap, copy=copy)
+
+    def copy(self):
+        copy = super().copy()
+        copy._smarts = self._smarts
+        return copy
+
+
+__all__ = ['QueryContainer']

chython/containers/rdkit.py

@@ -0,0 +1,183 @@
+# -*- 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 typing import TYPE_CHECKING, Type
+from ..periodictable import Element
+
+
+if TYPE_CHECKING:
+    from chython import MoleculeContainer
+
+
+class RDkit:
+    __slots__ = ()
+
+    @classmethod
+    def from_rdkit(cls: Type['MoleculeContainer'], data):
+        """
+        RDKit molecule object to MoleculeContainer converter
+        """
+        from rdkit.Chem import BondStereo, BondType, ChiralType
+
+        _rdkit_bond_map = {BondType.SINGLE: 1, BondType.DOUBLE: 2, BondType.TRIPLE: 3, BondType.AROMATIC: 4,
+                           BondType.ZERO: 8, BondType.UNSPECIFIED: 8, BondType.DATIVE: 8}
+        _chiral_cw = ChiralType.CHI_TETRAHEDRAL_CW
+        _chiral_ccw = ChiralType.CHI_TETRAHEDRAL_CCW
+        _trans = BondStereo.STEREOE
+        _cis = BondStereo.STEREOZ
+
+        mol = cls()
+
+        mapping = {}
+        tetrahedron_stereo = []
+        for ra in data.GetAtoms():
+            e = Element.from_symbol(ra.GetSymbol())
+            a = e(ra.GetIsotope() or None, charge=ra.GetFormalCharge(), is_radical=bool(ra.GetNumRadicalElectrons()),
+                  parsed_mapping=ra.GetAtomMapNum(), implicit_hydrogens=ra.GetNumExplicitHs() + ra.GetNumImplicitHs())
+            mapping[ra.GetIdx()] = mol.add_atom(a, _skip_calculation=True)
+            s = ra.GetChiralTag()
+            if s in (_chiral_cw, _chiral_ccw):
+                tetrahedron_stereo.append((ra.GetIdx(), [x.GetIdx() for x in ra.GetNeighbors()], s == _chiral_ccw))
+
+        cis_trans_stereo = []
+        for b in data.GetBonds():
+            n, m = mapping[b.GetBeginAtomIdx()], mapping[b.GetEndAtomIdx()]
+            mol.add_bond(n, m, _rdkit_bond_map[b.GetBondType()], _skip_calculation=True)
+            s = b.GetStereo()
+            if s in (_cis, _trans):
+                nn, nm = b.GetStereoAtoms()
+                cis_trans_stereo.append((n, m, mapping[nn], mapping[nm], s == _cis))
+
+        if cs := data.GetConformers():
+            # set coordinates from the first rdkit conformer. usually it's 2d layout
+            for (_, atom), (x, y, _) in zip(mol.atoms(), cs[0].GetPositions()):
+                atom.xy = (x, y)
+
+            conformers = []
+            for c in cs:
+                if c.Is3D():
+                    conformers.append({n: tuple(v) for n, v in enumerate(c.GetPositions(), 1)})
+            if conformers:
+                mol._conformers = conformers
+
+        # move stereo labels as is
+        for n, env, s in tetrahedron_stereo:
+            n = mapping[n]
+            try:
+                mol.atom(n)._stereo = mol._translate_tetrahedron_sign(n, [mapping[x] for x in env], s)
+            except KeyError:
+                pass
+        for n, m, nn, nm, s in cis_trans_stereo:
+            try:
+                mol.bond(n, m)._stereo = mol._translate_cis_trans_sign(n, m, nn, nm, s)
+            except KeyError:
+                pass
+
+        mol.fix_structure(recalculate_hydrogens=False)
+        if tetrahedron_stereo or cis_trans_stereo:
+            mol.fix_stereo()
+        return mol
+
+    def to_rdkit(self: 'MoleculeContainer', *, keep_mapping=True, keep_hydrogens=True):
+        """
+        Convert into RDKit molecule object
+
+        :param keep_mapping: set atom numbers
+        :param keep_hydrogens: set implicit hydrogens
+        """
+        from rdkit.Chem import (AssignStereochemistry, Atom, BondStereo, BondType, ChiralType,
+                                Conformer, RWMol, SanitizeMol)
+
+        _bond_map = {1: BondType.SINGLE, 2: BondType.DOUBLE, 3: BondType.TRIPLE,
+                     4: BondType.AROMATIC, 8: BondType.DATIVE}
+
+        _chiral_cw = ChiralType.CHI_TETRAHEDRAL_CW
+        _chiral_ccw = ChiralType.CHI_TETRAHEDRAL_CCW
+        _trans = BondStereo.STEREOE
+        _cis = BondStereo.STEREOZ
+
+        mol = RWMol()
+        mapping = {}
+
+        for n, a in self.atoms():
+            ra = Atom(a.atomic_number)
+            if keep_hydrogens and a.implicit_hydrogens is not None:
+                ra.SetNumExplicitHs(a.implicit_hydrogens)
+            if keep_mapping:
+                ra.SetAtomMapNum(n)
+            if a.charge:
+                ra.SetFormalCharge(a.charge)
+            if a.isotope:
+                ra.SetIsotope(a.isotope)
+            if a.is_radical:
+                ra.SetNumRadicalElectrons(1)
+            mapping[n] = mol.AddAtom(ra)
+
+        inverted = {v: k for k, v in mapping.items()}
+
+        for n, m, b in self.bonds():
+            if self.atom(n).atomic_symbol not in _inorganic:
+                n, m = m, n  # fix direction of dative bond
+            mol.AddBond(mapping[n], mapping[m], _bond_map[b.order])
+
+        for n, a in self.atoms():
+            if a.stereo is None:
+                continue
+            if n not in self.stereogenic_tetrahedrons:
+                continue  # allenes are not supported
+            ra = mol.GetAtomWithIdx(mapping[n])
+            env = [inverted[x.GetIdx()] for x in ra.GetNeighbors()]
+            s = self._translate_tetrahedron_sign(n, env)
+            ra.SetChiralTag(_chiral_ccw if s else _chiral_cw)
+
+        for n, m, b in self.bonds():
+            if b.stereo is None:
+                continue
+            # check for simple cis-trans
+            nm = self._stereo_cis_trans_centers.get(n)
+            if nm is None or n not in nm or m not in nm:
+                continue
+
+            n1, m1, *_ = self.stereogenic_cis_trans[nm]
+            rb = mol.GetBondBetweenAtoms(mapping[n], mapping[m])
+            rb.SetStereoAtoms(mapping[n1], mapping[m1])
+            rb.SetStereo(_cis if b.stereo else _trans)
+
+        conf = Conformer()
+        for n, a in self.atoms():
+            conf.SetAtomPosition(mapping[n], (a.x, a.y, 0))
+        conf.Set3D(False)
+        mol.AddConformer(conf, assignId=True)
+
+        if hasattr(self, '_conformers'):
+            for c in self._conformers:
+                conf = Conformer()
+                for n, xyz in c.items():
+                    conf.SetAtomPosition(mapping[n], xyz)
+                mol.AddConformer(conf, assignId=True)
+
+        SanitizeMol(mol)
+        AssignStereochemistry(mol, flagPossibleStereoCenters=True, force=True)
+        return mol
+
+
+_inorganic = {'He', 'Ne', 'Ar', 'Kr', 'Xe', 'F', 'Cl', 'Br', 'I', 'C', 'N', 'O',
+              'H', 'Si', 'P', 'S', 'Se', 'Ge', 'As', 'Sb', 'Te'}
+
+
+__all__ = ['RDkit']

chython/containers/reaction.py

@@ -0,0 +1,324 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2017-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 functools import reduce
+from itertools import chain
+from math import ceil
+from operator import itemgetter, or_
+from typing import Dict, Iterator, Optional, Tuple, List, Sequence
+from zlib import compress, decompress
+from .cgr import CGRContainer
+from .molecule import MoleculeContainer
+from ..algorithms.calculate2d import Calculate2DReaction
+from ..algorithms.depict import DepictReaction
+from ..algorithms.mapping import Mapping
+from ..algorithms.standardize import StandardizeReaction
+from .._functions import cached_method
+
+
+class ReactionContainer(StandardizeReaction, Mapping, Calculate2DReaction, DepictReaction):
+    """
+    Reaction storage. Contains reactants, products and reagents lists.
+
+    Reaction storage hashable and comparable. based on reaction unique signature (SMILES).
+    """
+    __slots__ = ('_reactants', '_products', '_reagents', '_meta', '_name', '_arrow', '_signs', '__dict__')
+
+    def __init__(self, reactants: Sequence[MoleculeContainer] = (), products: Sequence[MoleculeContainer] = (),
+                 reagents: Sequence[MoleculeContainer] = (), meta: Optional[Dict] = None, name: Optional[str] = None):
+        """
+        New reaction object creation
+
+        :param reactants: list of MoleculeContainers in left side of reaction
+        :param products: right side of reaction. see reactants
+        :param reagents: middle side of reaction: solvents, catalysts, etc. see reactants
+        :param meta: dictionary of metadata. like DTYPE-DATUM in RDF
+
+        """
+        reactants = tuple(reactants)
+        products = tuple(products)
+        reagents = tuple(reagents)
+        if not reactants and not products and not reagents:
+            raise ValueError('At least one graph object required')
+        elif not all(isinstance(x, MoleculeContainer) for x in chain(reactants, products, reagents)):
+            raise TypeError('MoleculeContainers expected')
+
+        self._reactants = reactants
+        self._products = products
+        self._reagents = reagents
+        if meta is None:
+            self._meta = None
+        else:
+            self._meta = dict(meta)
+        if name is None:
+            self._name = None
+        else:
+            self._name = name
+        self._arrow = None
+        self._signs = None
+
+    @property
+    def reactants(self) -> Tuple[MoleculeContainer, ...]:
+        return self._reactants
+
+    @property
+    def reagents(self) -> Tuple[MoleculeContainer, ...]:
+        return self._reagents
+
+    @property
+    def products(self) -> Tuple[MoleculeContainer, ...]:
+        return self._products
+
+    def molecules(self) -> Iterator[MoleculeContainer]:
+        """
+        Iterator of all reaction molecules
+        """
+        return chain(self.reactants, self.reagents, self.products)
+
+    @property
+    def meta(self) -> Dict:
+        """
+        Dictionary of metadata.
+        Like DTYPE-DATUM in RDF
+        """
+        if self._meta is None:
+            self._meta = {}  # lazy
+        return self._meta
+
+    @property
+    def name(self) -> str:
+        return self._name or ''
+
+    @name.setter
+    def name(self, name: str):
+        if not isinstance(name, str):
+            raise TypeError('name should be string up to 80 symbols')
+        self._name = name
+
+    def copy(self) -> 'ReactionContainer':
+        """
+        Get copy of object
+        """
+        copy = object.__new__(self.__class__)
+        copy._reactants = tuple(x.copy() for x in self.reactants)
+        copy._products = tuple(x.copy() for x in self.products)
+        copy._reagents = tuple(x.copy() for x in self.reagents)
+        copy._name = self._name
+        if self._meta is None:
+            copy._meta = None
+        else:
+            copy._meta = self._meta.copy()
+        copy._arrow = self._arrow
+        copy._signs = self._signs
+        return copy
+
+    def compose(self, *, dynamic=True) -> CGRContainer:
+        """
+        Get CGR of reaction
+
+        Reagents will be presented as unchanged molecules
+        :return: CGRContainer
+        """
+        rr = self.reagents + self.reactants
+        if rr:
+            r = reduce(or_, rr)
+        else:
+            r = MoleculeContainer()
+        if self.products:
+            p = reduce(or_, self.products)
+        else:
+            p = MoleculeContainer()
+        return r.compose(p, dynamic)
+
+    def flush_cache(self, keep_molecule_cache=False, **kwargs):
+        self.__dict__.clear()
+        if not keep_molecule_cache:
+            for m in self.molecules():
+                m.flush_cache(**kwargs)
+
+    def pack(self, *, compressed=True, check=True) -> bytes:
+        """
+        Pack into compressed bytes.
+
+        Note:
+            * Same restrictions as in molecules pack.
+            * reactants, reagents nad products should contain less than 256 molecules.
+
+        Format specification:
+        Big endian bytes order
+        8 bit - header byte = 0x01 (current format specification)
+        8 bit - reactants count
+        8 bit - reagents count
+        8 bit - products count
+        x bit - concatenated molecules packs
+
+        :param compressed: return zlib-compressed pack.
+        :param check: check molecules for format restrictions.
+        """
+        data = b''.join((bytearray((1, len(self.reactants), len(self.reagents), len(self.products))),
+                         *(m.pack(compressed=False, check=check) for m in self.molecules())))
+        if compressed:
+            return compress(data, 9)
+        return data
+
+    def pach(self, *, compressed=True, check=True) -> bytes:
+        """
+        Pack into compressed bytes.
+        """
+        return self.pack(compressed=compressed, check=check)
+
+    @classmethod
+    def pack_len(cls, data: bytes, /, *, compressed=True) -> Tuple[List[int], List[int], List[int]]:
+        """
+        Returns reactants, reagents, products molecules atoms count in reaction pack.
+        """
+        if compressed:
+            data = decompress(data)
+        data = memoryview(data)
+        if data[0] != 1:
+            raise ValueError('invalid pack header')
+        reactants, reagents, products = data[1], data[2], data[3]
+
+        v = data[4]  # mol pack version
+        shift = 5  # RH+RC+RC+PC+MH
+        molecules = []
+        for _ in range(reactants + reagents + products - 1):
+            acs = int.from_bytes(data[shift: shift + 3], 'big')
+            neighbors = 0
+            ac = acs >> 12
+            shift += 4  # AC+CC+AN
+            for _ in range(ac):
+                neighbors += data[shift] & 0x0f
+                shift += 9
+            neighbors //= 2
+            if v == 2:
+                shift += 3 * neighbors + ceil(neighbors * 3 / 8) + (acs & 0x0fff) * 4
+            elif v == 0:
+                shift += 3 * neighbors + ceil(neighbors / 5) * 2 + (acs & 0x0fff) * 4
+            molecules.append(ac)
+        if reactants or reagents or products:
+            molecules.append(int.from_bytes(data[shift: shift + 3], 'big') >> 12)
+        return molecules[:reactants], molecules[reactants: -products], molecules[-products:]
+
+    @classmethod
+    def unpack(cls, data: bytes, /, *, compressed=True) -> 'ReactionContainer':
+        """
+        Unpack from compressed bytes.
+
+        :param compressed: decompress data before processing.
+        """
+        if compressed:
+            data = decompress(data)
+        data = memoryview(data)
+        if data[0] != 1:
+            raise ValueError('invalid pack header')
+
+        reactants, reagents, products = data[1], data[2], data[3]
+        molecules: List[MoleculeContainer] = []
+        shift = 4
+        for _ in range(reactants + reagents + products):
+            m, pl = MoleculeContainer.unpack(data[shift:], compressed=False, _return_pack_length=True)
+            molecules.append(m)
+            shift += pl
+        return cls(molecules[:reactants], molecules[-products:], molecules[reactants: -products])
+
+    @classmethod
+    def unpach(cls, data: bytes, /, *, compressed=True) -> 'ReactionContainer':
+        """
+        Unpack from compressed bytes.
+        """
+        return cls.unpack(data, compressed=compressed)
+
+    def __bytes__(self):
+        return self.pack()
+
+    @cached_method
+    def __invert__(self) -> CGRContainer:
+        """
+        Get CGR of reaction
+        """
+        return self.compose()
+
+    def __eq__(self, other):
+        return isinstance(other, ReactionContainer) and str(self) == str(other)
+
+    @cached_method
+    def __hash__(self):
+        return hash(str(self))
+
+    def __bool__(self):
+        """
+        Exists both reactants and products
+        """
+        return bool(self.reactants and self.products)
+
+    @cached_method
+    def __str__(self):
+        return format(self)
+
+    def __format__(self, format_spec):
+        """
+        :param format_spec:
+            !c - Keep nested containers order.
+            a - Generate asymmetric closures.
+            !s - Disable stereo marks.
+            A - Use aromatic bonds instead aromatic atoms.
+            m - Set atom mapping.
+            r - Generate random-ordered smiles.
+            h - Show implicit hydrogens.
+            !b - Disable bonds tokens.
+            !x - Disable CXSMILES extension.
+            !z - Disable charge representation.
+        """
+        sig = []
+        count = 0
+        contract = []
+        radicals = []
+
+        for ml in (self.reactants, self.reagents, self.products):
+            mso = [(m, *m.__format__(format_spec, _return_order=True)) for m in ml]
+            if not format_spec or '!c' not in format_spec:
+                mso.sort(key=itemgetter(1))
+
+            ss = []
+            for m, s, o in mso:
+                if m.connected_components_count > 1:
+                    contract.append([str(x + count) for x in range(m.connected_components_count)])
+                    count += m.connected_components_count
+                else:
+                    count += 1
+
+                radicals.extend(m.atom(n).is_radical for n in o)
+                ss.append(s)
+            sig.append('.'.join(ss))
+
+        if not format_spec or '!x' not in format_spec:
+            cx = []
+            if r := ','.join(str(n) for n, r in enumerate(radicals) if r):
+                cx.append(f'^1:{r}')
+            if contract:
+                cx.append(f"f:{','.join('.'.join(x) for x in contract)}")
+            if cx:
+                return f"{'>'.join(sig)} |{','.join(cx)}|"
+        return '>'.join(sig)
+
+    def __len__(self):
+        return len(self.reactants) + len(self.products) + len(self.reagents)
+
+
+__all__ = ['ReactionContainer']

chython/containers/test/__init__.py

@@ -0,0 +1,18 @@
+# -*- 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/>.
+#