chython 2.19__cp313-cp313-win_amd64.whl

chython/files/mdl/emol.py

@@ -0,0 +1,251 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2020-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 re import compile
+from ...exceptions import EmptyMolecule
+
+
+_stereo_collection = compile(r'MDLV30/STE(ABS|RAC|REL)(\d*)\s+ATOMS=\((.+)\)')
+_v3000_token_re = compile(r'(?:[^\s"(]|"[^"]*"|\([^)]*\))+')
+
+
+def parse_mol_v3000(data, *, _header=True):
+    if _header:
+        title = data[0].strip() or None
+        data = data[4:]
+    else:
+        title = None
+
+    try:
+        counts_tokens = data[1][13:].split()
+        atom_count = int(counts_tokens[0])
+    except (IndexError, ValueError):
+        raise ValueError(f'V3000: cannot parse counts line: {data[1]!r:.80}')
+    if not atom_count:
+        raise EmptyMolecule
+    try:
+        bonds_count = int(counts_tokens[1])
+    except (IndexError, ValueError):
+        raise ValueError(f'V3000: cannot parse bond count from counts line: {data[1]!r:.80}')
+
+    log = []
+    atoms = []
+    bonds = []
+    stereo = []
+    meta = {}
+    atom_map = {}
+    star_points = set()
+
+    for kv in counts_tokens[2:]:
+        if '=' in kv:
+            k, v = kv.split('=', 1)
+            if k and v:
+                meta[k] = v
+
+    # concatenate line continuations using list+join
+    tmp = []
+    parts = []
+    for line in data[3:]:
+        if line.endswith('-\n'):
+            parts.append(line[7:-2])  # skip `M  V30 ` prefix and `-\n` suffix
+        else:
+            content = line[7:].rstrip()
+            if parts:
+                parts.append(content)
+                tmp.append(''.join(parts))
+                parts = []
+            else:
+                tmp.append(content.lstrip())
+    data = tmp
+    if len(data) < atom_count:
+        raise ValueError(f'V3000: expected {atom_count} atom lines but only {len(data)} lines available')
+
+    # parse atom block
+    _split = _v3000_token_re.findall
+    for i, line in enumerate(data[:atom_count], 1):
+        try:
+            tokens = _split(line)
+            n, a, x, y, z, m = tokens[0], tokens[1], tokens[2], tokens[3], tokens[4], tokens[5]
+            kvs = tokens[6:]
+        except (IndexError, ValueError):
+            raise ValueError(f'V3000 atom line {i}: cannot parse: {line!r:.80}')
+
+        if a.startswith(('[', 'NOT')):
+            raise ValueError(f'V3000 atom line {i}: list of atoms not supported')
+        elif a == '*':
+            star_points.add(n)
+            continue
+        elif a == 'R#':
+            raise ValueError(f'V3000 atom line {i}: R-groups not supported')
+
+        isotope = None
+        charge = 0
+        is_radical = False
+        for kv in kvs:
+            k, v = kv.split('=', 1)
+            if k == 'CHG':
+                charge = int(v)
+            elif k == 'MASS':
+                isotope = int(v)
+            elif k == 'RAD':
+                is_radical = True
+        if a == 'D':
+            if isotope:
+                raise ValueError(f'V3000 atom line {i}: isotope on deuterium atom')
+            a = 'H'
+            isotope = 2
+
+        try:
+            fx, fy, fz = float(x), float(y), float(z)
+        except ValueError:
+            raise ValueError(f'V3000 atom line {i}: cannot parse coordinates from {x!r}, {y!r}, {z!r}')
+
+        atom_map[n] = len(atoms)
+        atoms.append({'element': a, 'isotope': isotope, 'charge': charge, 'is_radical': is_radical,
+                      'x': fx, 'y': fy, 'z': fz, 'parsed_mapping': int(m)})
+
+    # parse bond block
+    bond_start = 2 + atom_count
+    bond_end = bond_start + bonds_count
+    if bond_end > len(data):
+        raise ValueError(f'V3000: expected {bonds_count} bond lines but only {len(data) - bond_start} available')
+    for i, line in enumerate(data[bond_start:bond_end], 1):
+        try:
+            tokens = _split(line)
+            _, t, a1, a2 = tokens[0], tokens[1], tokens[2], tokens[3]
+            kvs = tokens[4:]
+        except (IndexError, ValueError):
+            raise ValueError(f'V3000 bond line {i}: cannot parse: {line!r:.80}')
+
+        if a1 in star_points:
+            if a2 in star_points:
+                log.append('invalid bond ignored: star-point to star-point')
+                continue
+            try:
+                star = atom_map[a2]
+            except KeyError:
+                raise ValueError(f'V3000 bond line {i}: invalid atom number {a2}')
+            endpoints = None
+        elif a2 in star_points:
+            try:
+                star = atom_map[a1]
+            except KeyError:
+                raise ValueError(f'V3000 bond line {i}: invalid atom number {a1}')
+            endpoints = None
+        else:
+            star = None
+            try:
+                bt = int(t)
+                if bt in (9, 10):
+                    bt = 8
+                    log.append('coordinate bond replaced to special')
+                bonds.append((atom_map[a1], atom_map[a2], bt))
+            except KeyError:
+                raise ValueError(f'V3000 bond line {i}: invalid atom numbers {a1}, {a2}')
+            except ValueError:
+                raise ValueError(f'V3000 bond line {i}: invalid bond type {t!r}')
+
+        for kv in kvs:
+            k, v = kv.split('=')
+            if k == 'CFG':
+                if v == '1':
+                    stereo.append((atom_map[a1], atom_map[a2], 1))
+                elif v == '3':
+                    stereo.append((atom_map[a1], atom_map[a2], -1))
+                else:
+                    log.append('invalid or unsupported stereo')
+            elif k == 'ENDPTS':
+                endpoints = v[1:-1].split()
+                if len(endpoints) != int(endpoints[0]) + 1:
+                    raise ValueError(f'V3000 bond line {i}: invalid ENDPTS block')
+        if star is not None:
+            if endpoints:  # noqa
+                for ep in endpoints[1:]:  # noqa
+                    try:
+                        bonds.append((star, atom_map[ep], 8))
+                    except KeyError:
+                        raise ValueError(f'V3000 bond line {i}: invalid atom number {ep} in ENDPTS block')
+            else:
+                log.append('Bond ignored. Star atom not allowed as endpoint')
+
+    # parse remaining blocks (SGROUP, COLLECTION, etc.)
+    in_sgroup = False
+    in_collection = False
+    remaining_start = 3 + atom_count + bonds_count
+    for line in data[remaining_start:]:
+        if line.startswith('END CTAB'):
+            break
+        elif line.startswith('BEGIN SGROUP'):
+            in_sgroup = True
+        elif line.startswith('END SGROUP'):
+            in_sgroup = False
+        elif line.startswith('BEGIN COLLECTION'):
+            in_collection = True
+        elif line.startswith('END COLLECTION'):
+            in_collection = False
+        elif in_sgroup:
+            tokens = _split(line)
+            try:
+                _, _type, idx = tokens[0], tokens[1], tokens[2]
+                kvs = tokens[3:]
+            except IndexError:
+                log.append(f'V3000 SGROUP: cannot parse line: {line!r:.80}')
+                continue
+            if _type.startswith('DAT'):
+                a = f = d = None
+                for kv in kvs:
+                    k, v = kv.split('=', 1)
+                    if k == 'ATOMS':
+                        a = tuple(atom_map[x] for x in v[1:-1].split()[1:] if x not in star_points)
+                    elif k == 'FIELDNAME':
+                        f = v.strip('"')
+                    if k == 'FIELDDATA':
+                        d = v.strip('"')
+                if a and f and d:
+                    if f == 'MRV_IMPLICIT_H':
+                        atoms[a[0]]['implicit_hydrogens'] = int(d[6:])
+                    else:
+                        log.append(f'ignored SGROUP DAT {idx}: {a}\t{f}\t{d}')
+            elif _type.startswith('SRU'):
+                raise ValueError('Polymers not supported')
+        elif in_collection:
+            m = _stereo_collection.search(line)
+            if m:
+                stype, gid, atom_list = m.group(1), m.group(2), m.group(3)
+                atom_indices = atom_list.split()
+                atom_indices = atom_indices[1:]  # skip count
+                if stype == 'RAC':  # AND group = positive
+                    sg = int(gid) if gid else 1
+                    for a in atom_indices:
+                        try:
+                            atoms[atom_map[a]]['extended_stereo'] = sg
+                        except KeyError:
+                            log.append(f'invalid atom in STERAC collection: {a}')
+                elif stype == 'REL':  # OR group = negative
+                    sg = -(int(gid) if gid else 1)
+                    for a in atom_indices:
+                        try:
+                            atoms[atom_map[a]]['extended_stereo'] = sg
+                        except KeyError:
+                            log.append(f'invalid atom in STEREL collection: {a}')
+                # STEABS is the default (no extended_stereo needed)
+
+    return {'title': title, 'atoms': atoms, 'bonds': bonds, 'stereo': stereo, 'meta': meta, 'log': log}
+
+
+__all__ = ['parse_mol_v3000']

chython/files/mdl/erxn.py

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2020-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 .emol import parse_mol_v3000
+from ...exceptions import EmptyMolecule, EmptyReaction, InvalidV2000
+
+
+def parse_rxn_v3000(data, *, ignore=True):
+    tmp = data[4][13:].split()
+    reactants_count = int(tmp[0])
+    products_count = int(tmp[1]) + reactants_count
+    reagents_count = (int(tmp[2]) if len(tmp) == 3 else 0) + products_count
+
+    if not reagents_count:
+        raise EmptyReaction
+
+    title = data[1].strip() or None
+    log = []
+    molecules = []
+
+    start = 1
+    for n in range(0, reagents_count):
+        try:
+            start = next(n for n, x in enumerate(data[start + 5:], start + 5) if x.startswith('M  V30 BEGIN CTAB'))
+        except StopIteration:
+            raise InvalidV2000
+
+        try:
+            molecules.append(parse_mol_v3000(data[start:], _header=False))
+        except ValueError as e:
+            if isinstance(e, EmptyMolecule):
+                log.append(f'ignored empty molecule {n}')
+            elif ignore:
+                log.append(f'ignored molecule {n} with {e}')
+            else:
+                raise
+
+            if (lm := len(molecules)) < reactants_count:
+                reactants_count -= 1
+                products_count -= 1
+                reagents_count -= 1
+            elif lm < products_count:
+                products_count -= 1
+                reagents_count -= 1
+            else:
+                reagents_count -= 1
+
+    return {'reactants': molecules[:reactants_count], 'products': molecules[reactants_count:products_count],
+            'reagents': molecules[products_count:], 'title': title, 'log': log}
+
+
+__all__ = ['parse_rxn_v3000']

chython/files/mdl/mol.py

@@ -0,0 +1,186 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2020-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 ...exceptions import EmptyMolecule, InvalidCharge, InvalidV2000
+
+
+_ctf_data = {'R': 'is_radical', 'C': 'charge', 'I': 'isotope'}
+_charge_map = {'  0': 0, '  1': 3, '  2': 2, '  3': 1, '  4': 0, '  5': -1, '  6': -2, '  7': -3}
+
+
+def parse_mol_v2000(data):
+    line = data[3]
+
+    try:
+        atoms_count = int(line[0:3])
+    except (ValueError, IndexError):
+        raise InvalidV2000(f'V2000 counts line: cannot parse atom count from {line!r:.80}')
+    try:
+        bonds_count = int(line[3:6])
+    except (ValueError, IndexError):
+        raise InvalidV2000(f'V2000 counts line: cannot parse bond count from {line!r:.80}')
+
+    if not atoms_count:
+        raise EmptyMolecule
+
+    available_lines = len(data) - 4
+    if available_lines < atoms_count:
+        raise InvalidV2000(f'V2000: expected {atoms_count} atom lines but only {available_lines} lines available')
+    if available_lines < atoms_count + bonds_count:
+        raise InvalidV2000(f'V2000: expected {bonds_count} bond lines but only {available_lines - atoms_count} '
+                           f'lines available after atom block')
+
+    log = []
+    title = data[0].strip() or None
+    atoms = []
+    bonds = []
+    stereo = []
+    dat = {}
+
+    # parse atom block
+    _cm = _charge_map
+    for i, line in enumerate(data[4: 4 + atoms_count], 1):
+        try:
+            charge = _cm[line[36:39]]
+        except KeyError:
+            raise InvalidCharge(f'V2000 atom line {i}: invalid charge field {line[36:39]!r} in: {line!r:.80}')
+
+        element = line[31:34].strip()
+        isotope = line[34:36]
+
+        if element in 'AL':
+            raise ValueError(f'V2000 atom line {i}: queries not supported')
+        elif element == 'D':
+            element = 'H'
+            if isotope != ' 0':
+                raise ValueError(f'V2000 atom line {i}: isotope on deuterium atom')
+            isotope = 2
+            delta_isotope = None
+        elif isotope != ' 0':
+            delta_isotope = int(isotope)
+            isotope = None
+        else:
+            isotope = None
+            delta_isotope = None
+
+        try:
+            x = float(line[0:10])
+            y = float(line[10:20])
+            z = float(line[20:30])
+        except ValueError:
+            raise InvalidV2000(f'V2000 atom line {i}: cannot parse coordinates from {line[0:30]!r}')
+
+        mapping = line[60:63]
+        atoms.append({'element': element, 'charge': charge, 'isotope': isotope,
+                      'parsed_mapping': int(mapping) if mapping.strip() else 0,
+                      'x': x, 'y': y, 'z': z, 'delta_isotope': delta_isotope})
+
+    # parse bond block
+    for i, line in enumerate(data[4 + atoms_count: 4 + atoms_count + bonds_count], 1):
+        try:
+            a1 = int(line[0:3]) - 1
+            a2 = int(line[3:6]) - 1
+        except ValueError:
+            raise InvalidV2000(f'V2000 bond line {i}: cannot parse atom indices from {line[0:6]!r}')
+        if a1 < 0 or a1 >= atoms_count or a2 < 0 or a2 >= atoms_count:
+            raise InvalidV2000(f'V2000 bond line {i}: atom index out of range '
+                               f'(a1={a1 + 1}, a2={a2 + 1}, atoms={atoms_count})')
+        s = line[9:12]
+        if s == '  1':
+            stereo.append((a1, a2, 1))
+        elif s == '  6':
+            stereo.append((a1, a2, -1))
+        elif s != '  0':
+            log.append(f'unsupported or invalid stereo: {line}')
+        b = int(line[6:9])
+        if b == 9:
+            b = 8
+            log.append(f'coordinate bond replaced with special: {line}')
+        bonds.append((a1, a2, b))
+
+    # parse properties block
+    for line in data[4 + atoms_count + bonds_count:]:
+        if line.startswith('M  END'):
+            break
+        elif line.startswith('M  ALS'):
+            raise ValueError('list of atoms not supported')
+        elif line.startswith(('M  ISO', 'M  RAD', 'M  CHG')):
+            _type = _ctf_data[line[3]]
+            try:
+                count = int(line[6:9])
+            except ValueError:
+                raise InvalidV2000(f'V2000 properties: cannot parse entry count from {line!r:.80}')
+            for i in range(count):
+                i8 = i * 8
+                try:
+                    atom = int(line[10 + i8:13 + i8])
+                except ValueError:
+                    raise InvalidV2000(f'V2000 properties: cannot parse atom number in {line!r:.80}')
+                if not atom or atom > atoms_count:
+                    raise InvalidV2000(f'V2000 properties: atom number {atom} out of range [1, {atoms_count}] '
+                                       f'in: {line!r:.80}')
+                atom = atoms[atom - 1]
+                atom[_type] = int(line[14 + i8:17 + i8])
+
+        elif line.startswith('M  STY'):
+            for i in range(int(line[6:9])):
+                i8 = i * 8
+                if (st := line[14 + i8:17 + i8]) == 'DAT':
+                    dat[int(line[10 + i8:13 + i8])] = {}
+                elif st == 'SUP':
+                    dat[int(line[10 + i8:13 + i8])] = {'type': 'MDL_SUP'}
+        elif line.startswith('M  SAL'):
+            i = int(line[7:10])
+            if i in dat:
+                dat[i]['atoms'] = tuple(int(line[14 + 4 * i:17 + 4 * i]) - 1 for i in range(int(line[10:13])))
+        elif line.startswith('M  SDT'):
+            i = int(line[7:10])
+            if i in dat:
+                dat[i]['type'] = line.split()[-1].lower()
+        elif line.startswith('M  SED'):
+            i = int(line[7:10])
+            if i in dat:
+                dat[i]['value'] = line[10:].strip().replace('/', '').lower()
+        elif line.startswith('M  SMT'):
+            i = int(line[7:10])
+            if i in dat:
+                dat[i]['value'] = line[10:].strip()
+        elif not line.startswith('M  SDD'):
+            log.append(f'ignored line: {line}')
+
+    for a in atoms:
+        if 'is_radical' in a:
+            a['is_radical'] = True
+    for x in dat.values():
+        try:
+            _type = x['type']
+            if _type == 'mrv_implicit_h':
+                _atoms = x['atoms']
+                value = x['value']
+                if len(_atoms) != 1 or _atoms[0] == -1 or not value:
+                    raise InvalidV2000(f'MRV_IMPLICIT_H spec invalid {x}')
+                atoms[_atoms[0]]['implicit_hydrogens'] = int(value[6:])
+            else:
+                log.append(f'ignored data: {x}')
+        except KeyError:
+            raise InvalidV2000(f'Invalid SGROUP {x}')
+
+    return {'title': title, 'atoms': atoms, 'bonds': bonds, 'stereo': stereo, 'log': log}
+
+
+__all__ = ['parse_mol_v2000']