chython 2.4__cp312-cp312-win_amd64.whl

chython/files/daylight/parser.py

@@ -0,0 +1,157 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2022, 2023 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 ...exceptions import IncorrectSmiles
+
+
+def parser(tokens, strong_cycle):
+    log = []
+    t1 = tokens[0][0]
+    if t1 == 2:
+        if tokens[1][0] not in (0, 8):
+            raise IncorrectSmiles('not atom started')
+    elif t1 not in (0, 8):
+        raise IncorrectSmiles('not atom started')
+
+    atoms = []
+    bonds = []
+    order = defaultdict(list)
+    atoms_types = []
+    atom_num = 0
+    last_num = 0
+    stack = []
+    cycles = {}
+    stereo_atoms = {}
+    stereo_bonds = defaultdict(dict)
+    previous = None
+
+    for token_type, token in tokens:
+        if token_type == 2:  # ((((((
+            if previous:
+                if previous[0] != 4:
+                    raise IncorrectSmiles('bond before side chain')
+                previous = None
+            stack.append(last_num)
+        elif token_type == 3:  # ))))))
+            if previous:
+                raise IncorrectSmiles('bond before closure')
+            try:
+                last_num = stack.pop()
+            except IndexError:
+                raise IncorrectSmiles('close chain more than open')
+        elif token_type in (1, 4, 9, 10, 12):  # bonds. only keeping for atoms connecting
+            if previous:
+                raise IncorrectSmiles('2 bonds in a row')
+            elif not atoms:
+                raise IncorrectSmiles('started from bond')
+            previous = (token_type, token)
+        elif token_type == 6:  # cycle
+            if previous and previous[0] == 4:
+                raise IncorrectSmiles('dot-cycle pattern invalid')
+            elif token not in cycles:
+                cycles[token] = (last_num, previous, len(order[last_num]))
+                order[last_num].append(None)  # Reserve a table
+                previous = None
+            else:
+                a, ob, ind = cycles[token]
+                if ob:
+                    if not previous:
+                        bt, b = ob
+                        if bt == 9:  # closure open is \/ bonded
+                            stereo_bonds[a][last_num] = b
+                            b = 1
+                        elif strong_cycle:
+                            raise IncorrectSmiles('not equal cycle bonds')
+                        else:
+                            log.append('ignored difference in cycle bonds')
+                    else:
+                        bt, b = previous
+                        obt, ob = ob
+                        if bt == 9:  # \/ bonds can be unequal
+                            if obt == 9:
+                                stereo_bonds[a][last_num] = ob
+                            elif ob != 1:
+                                raise IncorrectSmiles('not equal cycle bonds')
+                            stereo_bonds[last_num][a] = b
+                            b = 1
+                        elif obt == 9:
+                            if b != 1:
+                                raise IncorrectSmiles('not equal cycle bonds')
+                            stereo_bonds[a][last_num] = ob
+                        elif b != ob:
+                            raise IncorrectSmiles('not equal cycle bonds')
+                        previous = None
+                elif previous:
+                    bt, b = previous
+                    if bt == 9:  # stereo \/
+                        stereo_bonds[last_num][a] = b
+                        b = 1
+                    elif strong_cycle:
+                        raise IncorrectSmiles('not equal cycle bonds')
+                    else:
+                        log.append('ignored difference in cycle bonds')
+                    previous = None
+                else:
+                    b = 4 if atoms_types[last_num] == atoms_types[a] == 8 else 1
+
+                bonds.append((last_num, a, b))
+                order[a][ind] = last_num
+                order[last_num].append(a)
+                del cycles[token]
+        else:  # atom
+            if atoms:
+                if not previous:
+                    bonds.append((atom_num, last_num, 4 if token_type == atoms_types[last_num] == 8 else 1))
+                    order[last_num].append(atom_num)
+                    order[atom_num].append(last_num)
+                else:
+                    bt, b = previous
+                    if bt == 9:
+                        bonds.append((atom_num, last_num, 4 if token_type == atoms_types[last_num] == 8 else 1))
+                        order[last_num].append(atom_num)
+                        order[atom_num].append(last_num)
+
+                        stereo_bonds[last_num][atom_num] = b
+                        stereo_bonds[atom_num][last_num] = not b
+                    elif bt in (1, 10, 12):
+                        bonds.append((atom_num, last_num, b))
+                        order[last_num].append(atom_num)
+                        order[atom_num].append(last_num)
+                    # else bt == 4 - skip dot
+                    previous = None
+
+            if token.get('stereo') is not None:
+                stereo_atoms[atom_num] = token.pop('stereo')
+            atoms.append(token)
+            atoms_types.append(token_type)
+            last_num = atom_num
+            atom_num += 1
+
+    if stack:
+        raise IncorrectSmiles('number of ( does not equal to number of )')
+    elif cycles:
+        raise IncorrectSmiles('cycle is not finished')
+    elif previous:
+        raise IncorrectSmiles('bond on the end')
+
+    return {'atoms': atoms, 'bonds': bonds, 'order': order, 'stereo_atoms': stereo_atoms,
+            'stereo_bonds': stereo_bonds, 'log': log}
+
+
+__all__ = ['parser']

chython/files/daylight/smarts.py

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2022-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 functools import partial
+from itertools import count
+from re import compile, findall, search
+from .parser import parser
+from .tokenize import smarts_tokenize
+from ...containers import QueryContainer, QueryBond
+from ...periodictable import ListElement, QueryElement
+
+
+cx_radicals = compile(r'\^[1-7]:[0-9]+(?:,[0-9]+)*')
+
+# AD-HOC for masked atoms in SMARTS
+# not thread safe
+global_free_masked = count(10 ** 9 + 1)
+
+
+def smarts(data: str):
+    """
+    Parse SMARTS string.
+
+    * only D, a, h, r and !R atom primitives supported.
+    * bond order list (max 2) and not bond supported.
+    * [not]ring bond supported only in combination with explicit bonds, not bonds and bonds orders lists.
+    * mapping, charge and isotopes supported.
+    * list of elements supported.
+    * A - treats as any element. <A> primitive (aliphatic) ignored.
+    * M - treats as any metal
+    * <&> logic operator unsupported.
+    * <;> logic operator is mandatory except (however preferable) for charge, isotope, stereo marks.
+    * CXSMARTS radicals supported.
+    * masked atom - `chython.Reactor` specific mark for masking reactant atoms from deletion.
+
+    For example::
+
+        [C;r5,r6;a]-;!@[C;h1,h2;z2,z4] |^1:1| - aromatic C member of 5 or 6 atoms ring
+        connected with non-ring single bond to aromatic or SP2 radical C with 1 or 2 hydrogens.
+
+    * primitive <xN> - heteroatoms (e.g. x2 - two heteroatoms)
+    * primitive <zN> - hybridization (N = 1 - sp3, 2 - sp2, 3 - sp, 4 - aromatic)
+    * primitive <M> - masked atom
+
+    Note: atom numbers greater than 10 ** 9 forbidden for usage and reserved for masked atoms numbering.
+    In multiprocess mode has potential bugs in reaction enumeration task then used templates prepared from components
+    from different processes. For avoiding, prepare templates on single process and then share it.
+    """
+    if not isinstance(data, str):
+        raise TypeError('Must be a SMARTS string')
+    smr, *cx = data.split()
+
+    parsed = parser(smarts_tokenize(smr), False)
+
+    if cx and cx[0].startswith('|') and cx[0].endswith('|'):
+        for x in findall(cx_radicals, cx[0]):
+            for i in x[3:].split(','):
+                parsed['atoms'][int(i)]['is_radical'] = True
+
+    for i, s in parsed['stereo_atoms'].items():
+        parsed['atoms'][i]['stereo'] = s
+    stereo_bonds = parsed['stereo_bonds']
+
+    g = QueryContainer(data)
+
+    mapping = {}
+    free = count(max(a.get('parsed_mapping', 0) for a in parsed['atoms']) + 1)
+    for i, a in enumerate(parsed['atoms']):
+        mapping[i] = n = a.pop('parsed_mapping', 0) or next(global_free_masked if a.get('masked') else free)
+        e = a.pop('element')
+        if isinstance(e, int):
+            e = QueryElement.from_atomic_number(e)
+        elif isinstance(e, str):
+            e = QueryElement.from_symbol(e)
+        else:
+            e = partial(ListElement, e)
+        g.add_atom(e(**a), n)
+
+    for n, m, b in parsed['bonds']:
+        if n in stereo_bonds and m in stereo_bonds:
+            if m not in stereo_bonds[n]:  # only simple cis-trans supported, not cumulenes
+                _, s1 = stereo_bonds[n].popitem()
+                _, s2 = stereo_bonds[m].popitem()
+                if isinstance(b, int):
+                    b = QueryBond(b, stereo=s1 == s2)
+                else:
+                    b.stereo = s1 == s2
+        g.add_bond(mapping[n], mapping[m], b)
+    return g
+
+
+__all__ = ['smarts']

chython/files/daylight/smiles.py

@@ -0,0 +1,245 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2022-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 itertools import chain
+from re import compile, findall, search
+from typing import List, Union, Optional
+from .parser import parser
+from .tokenize import smiles_tokenize
+from .._convert import create_molecule, create_reaction
+from .._mapping import postprocess_parsed_molecule, postprocess_parsed_reaction
+from ...containers import MoleculeContainer, ReactionContainer
+from ...exceptions import IsChiral, NotChiral, ValenceError
+
+
+cx_fragments = compile(r'f:(?:[0-9]+(?:\.[0-9]+)+)(?:,(?:[0-9]+(?:\.[0-9]+)+))*')
+cx_radicals = compile(r'\^[1-7]:[0-9]+(?:,[0-9]+)*')
+
+
+def smiles(data, /, *, ignore: bool = True, remap: bool = False, ignore_stereo: bool = False,
+           ignore_bad_isotopes: bool = False, keep_implicit: bool = False, ignore_carbon_radicals: bool = False,
+           ignore_aromatic_radicals: bool = True,
+           _r_cls=ReactionContainer, _m_cls=MoleculeContainer) -> Union[MoleculeContainer, ReactionContainer]:
+    """
+    SMILES string parser
+
+    :param ignore: Skip some checks of data or try to fix some errors.
+    :param remap: Remap atom numbers started from one.
+    :param ignore_stereo: Ignore stereo data.
+    :param keep_implicit: keep given in smiles implicit hydrogen count, otherwise ignore on valence error.
+    :param ignore_bad_isotopes: reset invalid isotope mark to non-isotopic.
+    :param ignore_carbon_radicals: fill carbon radicals with hydrogen (X[C](X)X case).
+    :param ignore_aromatic_radicals: don't treat aromatic tokens like c[c]c as radicals.
+    """
+    if not isinstance(data, str):
+        raise TypeError('Must be a SMILES string')
+    elif not data:
+        raise ValueError('Empty string')
+
+    contract: Optional[List[List[int]]]  # typing
+    log = []
+    smi, *data = data.split()
+    if data and (cxs := data[0]).startswith('|') and cxs.endswith('|'):
+        fr = search(cx_fragments, cxs)
+        if fr is not None:
+            contract = [sorted(int(x) for x in x.split('.')) for x in fr.group()[2:].split(',')]
+            if len({x for x in contract for x in x}) < len([x for x in contract for x in x]):
+                log.append(f'collisions in cxsmiles fragments description: {cxs}')
+                contract = None
+
+            radicals = [int(x) for x in findall(cx_radicals, cxs) for x in x[3:].split(',')]
+            if radicals and len(set(radicals)) != len(radicals):
+                log.append(f'collisions in cxsmiles radicals description: {cxs}')
+                radicals = []
+        else:
+            radicals = [int(x) for x in findall(cx_radicals, cxs) for x in x[3:].split(',')]
+            if radicals:
+                if len(set(radicals)) != len(radicals):
+                    log.append(f'collisions in cxsmiles radicals description: {cxs}')
+                    radicals = []
+            contract = None
+    else:
+        radicals = []
+        contract = None
+
+    if '>' in smi:
+        record = {'reactants': [], 'reagents': [], 'products': [], 'log': log}
+        try:
+            reactants, reagents, products = smi.split('>')
+        except ValueError as e:
+            raise ValueError('invalid reaction smiles') from e
+
+        mol_count = 0
+        for k, d in zip(('reactants', 'products', 'reagents'), (reactants, products, reagents)):
+            if not d:
+                continue
+            for x in d.split('.'):
+                if not x:
+                    if ignore:
+                        log.append('two dots in line ignored')
+                    else:
+                        raise ValueError('invalid reaction smiles. two dots in line')
+                else:
+                    record[k].append(x)
+                    mol_count += 1
+
+        if contract:
+            if max(x for x in contract for x in x) >= mol_count:
+                log.append(f'skipped invalid contract data: {contract}')
+            lr = len(record['reactants'])
+            lp = len(record['products'])
+            reactants = set(range(lr))
+            reagents = set(range(lr, mol_count - lp))
+            products = set(range(mol_count - lp, mol_count))
+            new_molecules: List[Optional[str]] = [None] * mol_count
+            for c in contract:
+                if reactants.issuperset(c):
+                    new_molecules[c[0]] = '.'.join(record['reactants'][x] for x in c)
+                    reactants.difference_update(c)
+                elif products.issuperset(c):
+                    new_molecules[c[0]] = '.'.join(record['products'][x - mol_count] for x in c)
+                    products.difference_update(c)
+                elif reagents.issuperset(c):
+                    new_molecules[c[0]] = '.'.join(record['reagents'][x - lr] for x in c)
+                    reagents.difference_update(c)
+                else:
+                    log.append(f'impossible to contract different parts of reaction: {contract}')
+            for x in reactants:
+                new_molecules[x] = record['reactants'][x]
+            for x in products:
+                new_molecules[x] = record['products'][x - mol_count]
+            for x in reagents:
+                new_molecules[x] = record['reagents'][x - lr]
+
+            record['reactants'] = [x for x in new_molecules[:lr] if x is not None]
+            record['products'] = [x for x in new_molecules[-lp:] if x is not None]
+            record['reagents'] = [x for x in new_molecules[lr: -lp] if x is not None]
+
+        for k in ('reactants', 'products', 'reagents'):
+            tmp = []
+            for x in record[k]:
+                tmp.append(parser(smiles_tokenize(x), not ignore))
+            record[k] = tmp
+
+        if radicals:
+            atom_map = dict(enumerate(a for m in chain(record['reactants'], record['reagents'], record['products'])
+                                      for a in m['atoms']))
+            for x in radicals:
+                atom_map[x]['is_radical'] = True
+
+        postprocess_parsed_reaction(record, remap=remap, ignore=ignore)
+        rxn = create_reaction(record, ignore_bad_isotopes=ignore_bad_isotopes, keep_radicals=False,
+                              ignore_carbon_radicals=ignore_carbon_radicals, keep_implicit=keep_implicit,
+                              ignore_aromatic_radicals=ignore_aromatic_radicals, ignore=ignore,
+                              _r_cls=_r_cls, _m_cls=_m_cls)
+        for mol, tmp in zip(rxn.molecules(), chain(record['reactants'], record['reagents'], record['products'])):
+            postprocess_molecule(mol, tmp, ignore_stereo=ignore_stereo)
+        return rxn
+    else:
+        record = parser(smiles_tokenize(smi), not ignore)
+        for x in radicals:
+            record['atoms'][x]['is_radical'] = True
+        record['log'].extend(log)
+
+        postprocess_parsed_molecule(record, remap=remap, ignore=ignore)
+        mol = create_molecule(record, ignore_bad_isotopes=ignore_bad_isotopes, keep_radicals=False,
+                              ignore_carbon_radicals=ignore_carbon_radicals, keep_implicit=keep_implicit,
+                              ignore_aromatic_radicals=ignore_aromatic_radicals, ignore=ignore,
+                              _cls=_m_cls)
+        postprocess_molecule(mol, record, ignore_stereo=ignore_stereo)
+        return mol
+
+
+def postprocess_molecule(molecule, data, *, ignore_stereo=False):
+    mapping = data['mapping']
+
+    if ignore_stereo:
+        return
+    elif not data['stereo_atoms'] and not data['stereo_bonds']:
+        return
+
+    atoms = molecule._atoms
+    st = molecule.stereogenic_tetrahedrons
+    sa = molecule.stereogenic_allenes
+    sat = molecule._stereo_allenes_terminals
+    ctc = molecule._stereo_cis_trans_counterpart
+
+    order = {mapping[n]: [mapping[m] for m in ms] for n, ms in data['order'].items()}
+
+    log = []
+    stereo = []
+    for i, s in data['stereo_atoms'].items():
+        n = mapping[i]
+        if not i and atoms[n].implicit_hydrogens:  # first atom in smiles has reversed chiral mark
+            s = not s
+
+        if n in st:
+            stereo.append((molecule.add_atom_stereo, n, order[n], s))
+        elif n in sa:
+            t1, t2 = sat[n]
+            env = sa[n]
+            n1 = next(x for x in order[t1] if x in env)
+            n2 = next(x for x in order[t2] if x in env)
+            stereo.append((molecule.add_atom_stereo, n, (n1, n2), s))
+        else:
+            log.append(f'non chiral atom {n} has stereo label in smiles')
+
+    stereo_bonds = {mapping[n]: {mapping[m]: s for m, s in ms.items()}
+                    for n, ms in data['stereo_bonds'].items()}
+    seen = set()
+    for n, ns in stereo_bonds.items():
+        if n in seen:
+            continue
+        if n in ctc:
+            m = ctc[n]
+            if m in stereo_bonds:
+                seen.add(m)
+                n2, s2 = stereo_bonds[m].popitem()
+                n1, s1 = ns.popitem()
+                stereo.append((molecule.add_cis_trans_stereo, n, m, n1, n2, s1 == s2))
+
+    while stereo:
+        fail_stereo = []
+        old_stereo = len(stereo)
+        for f, *args in stereo:
+            try:
+                f(*args, clean_cache=False)
+            except NotChiral:
+                fail_stereo.append((f, *args))
+            except IsChiral:
+                pass
+            except ValenceError:
+                log.append('structure has errors, stereo data skipped')
+                molecule.flush_cache()
+                break
+        else:
+            stereo = fail_stereo
+            if len(stereo) == old_stereo:
+                break
+            molecule.flush_stereo_cache()
+            continue
+        break
+
+    if log:
+        if 'chython_parsing_log' not in molecule.meta:
+            molecule.meta['chython_parsing_log'] = log
+        else:
+            molecule.meta['chython_parsing_log'].extend(log)
+
+
+__all__ = ['smiles']

chython/files/daylight/test/__init__.py

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