chython 2.4__cp312-cp312-win_amd64.whl

chython/files/mdl/emol.py

@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2020-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 ...exceptions import EmptyMolecule
+
+
+def parse_mol_v3000(data, *, _header=True):
+    if _header:
+        title = data[0].strip() or None
+        data = data[4:]
+    else:
+        title = None
+
+    atom_count, bonds_count, *kvs = data[1][13:].split()
+    atom_count = int(atom_count)
+    if not atom_count:
+        raise EmptyMolecule
+    bonds_count = int(bonds_count)
+
+    log = []
+    atoms = []
+    bonds = []
+    stereo = []
+    meta = {}
+    atom_map = {}
+    star_points = []
+
+    for kv in kvs:
+        if '=' in kv:
+            k, v = kv.split('=', 1)
+            if k and v:
+                meta[k] = v
+
+    # concatenate line breaks
+    tmp = []
+    keep = None
+    for line in data[3:]:
+        if line.endswith('-\n'):
+            line = line[7:-2]  # skip `M  V30 ` and `-\n`
+            if keep:
+                keep += line
+            else:
+                keep = line.lstrip()
+        else:
+            line = line[7:]  # skip `M  V30 `
+            if keep:
+                tmp.append(keep + line.rstrip())
+                keep = None
+            else:
+                tmp.append(line.strip())
+    data = tmp
+
+    for line in data[:atom_count]:
+        n, a, x, y, z, m, *kvs = split(line)
+        if a.startswith(('[', 'NOT')):
+            raise ValueError('list of atoms not supported')
+        elif a == '*':
+            star_points.append(n)
+            continue
+        elif a == 'R#':
+            raise ValueError('R-groups not supported')
+
+        i = None
+        c = 0
+        r = False
+        for kv in kvs:
+            k, v = kv.split('=', 1)
+            if k == 'CHG':
+                c = int(v)
+            elif k == 'MASS':
+                i = int(v)
+            elif k == 'RAD':
+                r = True
+        if a == 'D':
+            if i:
+                raise ValueError('isotope on deuterium atom')
+            a = 'H'
+            i = 2
+
+        atom_map[n] = len(atoms)
+        atoms.append({'element': a, 'isotope': i, 'charge': c, 'is_radical': r,
+                      'x': float(x), 'y': float(y), 'z': float(z), 'parsed_mapping': int(m)})
+
+    for line in data[2 + atom_count: 2 + atom_count + bonds_count]:
+        _, t, a1, a2, *kvs = split(line)
+        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('invalid atoms number')
+            endpoints = None
+        elif a2 in star_points:
+            try:
+                star = atom_map[a1]
+            except KeyError:
+                raise ValueError('invalid atoms number')
+            endpoints = None
+        else:
+            star = None
+            try:
+                t = int(t)
+                if t in (9, 10):  # added ad-hoc for bond type 9
+                    t = 8
+                    log.append('coordinate bond replaced to special')
+                bonds.append((atom_map[a1], atom_map[a2], t))
+            except KeyError:
+                raise ValueError('invalid atoms numbers')
+
+        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('invalid ENDPTS block')
+        if star is not None:
+            if endpoints:  # noqa
+                for m in endpoints[1:]:  # noqa
+                    try:
+                        bonds.append((star, atom_map[m], 8))
+                    except KeyError:
+                        raise ValueError('invalid atoms numbers in ENDPTS block')
+            else:
+                log.append('Bond ignored. Star atom not allowed as endpoint')
+
+    drop = True
+    for line in data[3 + atom_count + bonds_count:]:
+        if line.startswith('END CTAB'):
+            break
+        elif drop:
+            if line.startswith('BEGIN SGROUP'):
+                drop = False
+            continue
+        elif line.startswith('END SGROUP'):
+            break
+
+        _, _type, i, *kvs = split(line)
+        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 {i}: {a}\t{f}\t{d}')
+        elif _type.startswith('SRU'):
+            raise ValueError('Polymers not supported')
+
+    return {'title': title, 'atoms': atoms, 'bonds': bonds, 'stereo': stereo, 'meta': meta, 'log': log}
+
+
+def split(line):  # todo optimize
+    collect = []
+    tmp = []
+    until = None
+    for s in line:
+        if until:
+            tmp.append(s)
+            if s == until:
+                until = None
+        elif s == '(':
+            tmp.append('(')
+            until = ')'
+        elif s == '"':
+            tmp.append(s)
+            until = '"'
+        elif s == ' ':
+            if tmp:
+                collect.append(''.join(tmp))
+                tmp = []
+        else:
+            tmp.append(s)
+    if tmp:
+        collect.append(''.join(tmp))
+    return collect
+
+
+__all__ = ['parse_mol_v3000']

chython/files/mdl/erxn.py

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2020-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 .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,144 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2020-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 ...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]
+
+    atoms_count = int(line[0:3])
+    bonds_count = int(line[3:6])
+    if not atoms_count:
+        raise EmptyMolecule
+
+    log = []
+    title = data[0].strip() or None
+    atoms = []
+    bonds = []
+    stereo = []
+    dat = {}
+
+    for line in data[4: 4 + atoms_count]:
+        try:
+            charge = _charge_map[line[36:39]]
+        except KeyError:
+            raise InvalidCharge
+        element = line[31:34].strip()
+        isotope = line[34:36]
+        delta_isotope = None
+
+        if element in 'AL':
+            raise ValueError('queries not supported')
+        elif element == 'D':
+            element = 'H'
+            if isotope != ' 0':
+                raise ValueError('isotope on deuterium atom')
+            isotope = 2
+        elif isotope != ' 0':
+            delta_isotope = int(isotope)
+            isotope = None
+        else:
+            isotope = None
+
+        mapping = line[60:63]
+        atoms.append({'element': element, 'charge': charge, 'isotope': isotope,
+                      'parsed_mapping': int(mapping) if mapping else 0, 'x': float(line[0:10]), 'y': float(line[10:20]),
+                      'z': float(line[20:30]), 'delta_isotope': delta_isotope})
+
+    for line in data[4 + atoms_count: 4 + atoms_count + bonds_count]:
+        a1, a2 = int(line[0:3]) - 1, int(line[3:6]) - 1
+        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:  # added ad-hoc for bond type 9
+            b = 8
+            log.append(f'coordinate bond replaced with special: {line}')
+        bonds.append((a1, a2, b))
+
+    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]]
+            for i in range(int(line[6:9])):
+                i8 = i * 8
+                atom = int(line[10 + i8:13 + i8])
+                if not atom or atom > len(atoms):
+                    raise InvalidV2000('invalid atoms number')
+                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:  # int to bool
+            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']

chython/files/mdl/read.py

@@ -0,0 +1,225 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2021-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 abc import ABCMeta, abstractmethod
+from base64 import urlsafe_b64encode
+from fileinput import FileInput
+from io import StringIO, TextIOWrapper
+from itertools import islice
+from os.path import abspath, join
+from pathlib import Path
+from pickle import load, UnpicklingError
+from sys import platform
+from tempfile import gettempdir
+from typing import Union, Iterator, List, Dict, Optional
+from ...containers import ReactionContainer, MoleculeContainer
+
+
+class MDLReadMeta(ABCMeta):
+    def __call__(cls, *args, **kwargs):
+        if kwargs.get('indexable'):
+            _cls = type(cls.__name__, (cls,), {'__len__': lambda x: len(x._shifts), '__module__': cls.__module__})
+            obj = object.__new__(_cls)  # noqa
+        else:
+            obj = object.__new__(cls)  # noqa
+        obj.__init__(*args, **kwargs)
+        return obj
+
+
+class MDLRead(metaclass=MDLReadMeta):
+    def __init__(self, file, buffer_size=1000, indexable=False, ignore=True, remap=False, ignore_bad_isotopes=False,
+                 ignore_stereo=False, calc_cis_trans=False):
+        if isinstance(file, str):
+            self._file = open(file)
+            self._is_buffer = False
+        elif isinstance(file, Path):
+            self._file = file.open()
+            self._is_buffer = False
+        elif isinstance(file, (TextIOWrapper, StringIO, FileInput)):
+            self._file = file
+            self._is_buffer = True
+        else:
+            raise TypeError('invalid file. TextIOWrapper, StringIO or FileInput subclasses or path to file expected')
+        self._shifts = None
+        self._tell = 0
+        self._buffer_size = buffer_size
+        self._buffer = None
+        self._ignore = ignore
+        self._remap = remap
+        self._ignore_bad_isotopes = ignore_bad_isotopes
+        self._ignore_stereo = ignore_stereo
+        self._calc_cis_trans = calc_cis_trans
+        if indexable:
+            self._load_cache()
+
+    def read(self, amount: Optional[int] = None) -> List[Union[ReactionContainer, MoleculeContainer]]:
+        """
+        Parse whole file
+
+        :param amount: number of records to read
+        """
+        if amount:
+            return list(islice(iter(self), amount))
+        return list(iter(self))
+
+    @abstractmethod
+    def read_structure(self, *, current: bool = True):
+        """
+        Read Reaction or Molecule container.
+
+        :param current: return current structure if already parsed, otherwise read next
+        """
+
+    @abstractmethod
+    def read_metadata(self, *, current: bool = True) -> Dict[str, str]:
+        """
+        Read metadata block
+        """
+
+    def close(self, force: bool = False):
+        """
+        Close opened file
+
+        :param force: force closing of externally opened file or buffer
+        """
+        if not self._is_buffer or force:
+            self._file.close()
+
+    def tell(self):
+        """
+        Number of records processed from the original file
+        """
+        return self._tell
+
+    def seek(self, offset):
+        """
+        Shift to a given record number
+        """
+        if self._shifts:
+            if 0 <= offset < len(self._shifts):
+                self._tell = offset
+                self._buffer = None
+                self._file.seek(self._shifts[offset])
+            else:
+                raise IndexError('invalid offset')
+        else:
+            raise NotImplementedError('Indexable supported in unix-like o.s. and for files stored on disk')
+
+    @abstractmethod
+    def reset_index(self):
+        """
+        Create (rewrite) indexation table. Implemented only for object that
+        is a real file (the path to the file is specified) because the external grep utility is used.
+        """
+
+    def read_block(self, *, current: bool = True) -> str:
+        """
+        Read full record block with metadata
+        """
+        return ''.join(self._read_block(current=current))
+
+    @abstractmethod
+    def _read_block(self, *, current: bool = True) -> List[str]:
+        """
+        Read full record block with metadata
+        """
+
+    def _load_cache(self):
+        """
+        Load existing cache or create new. Working only for UNIX-like systems and local files (not buffers).
+        """
+        if platform == 'win32' or self._is_buffer:
+            return
+        try:
+            with open(self._cache_path, 'rb') as f:
+                self._shifts = load(f)
+        except FileNotFoundError:  # cache not found
+            self.reset_index()
+        except IsADirectoryError as e:
+            raise IsADirectoryError(f'Please delete {self._cache_path} directory') from e
+        except (UnpicklingError, EOFError) as e:  # invalid file. ask user to check it.
+            raise UnpicklingError(f'Invalid cache file {self._cache_path}. Please delete it') from e
+
+    @property
+    def _cache_path(self):
+        return abspath(join(gettempdir(), 'chython_' + urlsafe_b64encode(abspath(self._file.name).encode()).decode()))
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, _type, value, traceback):
+        self.close()
+
+    def __iter__(self) -> Iterator[Union[ReactionContainer, MoleculeContainer]]:
+        while True:
+            try:
+                yield self.read_structure(current=False)
+            except ValueError:
+                pass
+            except EOFError:
+                return
+
+    def __next__(self) -> Union[ReactionContainer, MoleculeContainer]:
+        return next(iter(self))
+
+    def __getitem__(self, item) -> Union[ReactionContainer, MoleculeContainer,
+                                         List[Union[ReactionContainer, MoleculeContainer]]]:
+        """
+        Getting the item by index from the original file,
+        For slices records with errors skipped.
+        """
+        if self._shifts:
+            _len = len(self._shifts)
+            if isinstance(item, int):
+                if item >= _len or item < -_len:
+                    raise IndexError('List index out of range')
+                if item < 0:
+                    item += _len
+                self.seek(item)
+                return self.read_structure()
+            elif isinstance(item, slice):
+                start, stop, step = item.indices(_len)
+                if start == stop:
+                    return []
+                if step == 1:
+                    self.seek(start)
+                    records = []
+                    for _ in range(start, stop):
+                        try:
+                            records.append(self.read_structure(current=False))
+                        except EOFError:
+                            break
+                        except ValueError:
+                            pass
+                else:
+                    records = []
+                    for index in range(start, stop, step):
+                        self.seek(index)
+                        try:
+                            records.append(self.read_structure())
+                        except EOFError:
+                            break
+                        except ValueError:
+                            pass
+                return records
+            else:
+                raise TypeError('Indices must be integers or slices')
+        raise NotImplementedError('Indexable supported in unix-like o.s. and for files stored on disk')
+
+
+__all__ = ['MDLRead']