chython 2.19__cp313-cp313-win_amd64.whl

chython/files/mdl/read.py

@@ -0,0 +1,223 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2021-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 abc import ABCMeta, abstractmethod
+from base64 import urlsafe_b64encode
+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 hasattr(file, '__iter__') and hasattr(file, 'read'):
+            self._file = file
+            self._is_buffer = True
+        else:
+            raise TypeError('invalid file. file-like object 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']

chython/files/mdl/rxn.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 .mol import parse_mol_v2000
+from ...exceptions import EmptyMolecule, EmptyReaction, InvalidV2000
+
+
+def parse_rxn_v2000(data, *, ignore=True):
+    line = data[4]
+    reactants_count = int(line[:3])
+    products_count = int(line[3:6]) + reactants_count
+    reagents_count = int(line[6:].rstrip() or 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 + 6:], start + 7) if x.startswith('$MOL'))
+        except StopIteration:
+            raise InvalidV2000
+
+        try:
+            molecules.append(parse_mol_v2000(data[start:]))
+        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_v2000']

chython/files/mdl/stereo.py

@@ -0,0 +1,63 @@
+# -*- 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 NotChiral, IsChiral, ValenceError
+
+
+def postprocess_molecule(molecule, data, *, ignore_stereo=False, calc_cis_trans=False):
+    if ignore_stereo:
+        return
+    mapping = data['mapping']
+    log = []
+
+    if calc_cis_trans:
+        molecule.calculate_cis_trans_from_2d(clean_cache=False)
+
+    stereo = [(mapping[n], mapping[m], s) for n, m, s in data['stereo']]
+    while stereo:
+        fail_stereo = []
+        old_stereo = len(stereo)
+        for n, m, s in stereo:
+            try:
+                molecule.add_wedge(n, m, s, clean_cache=False)
+            except NotChiral:
+                fail_stereo.append((n, m, s))
+            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()
+            if calc_cis_trans:
+                molecule.calculate_cis_trans_from_2d(clean_cache=False)
+            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__ = ['postprocess_molecule']

chython/files/mdl/write.py

@@ -0,0 +1,201 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2021-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 collections import defaultdict
+from pathlib import Path
+from ...containers import MoleculeContainer
+
+
+charge_map = {-4: '  0', -3: '  7', -2: '  6', -1: '  5', 0: '  0', 1: '  3', 2: '  2', 3: '  1', 4: '  0'}
+
+
+class IO:
+    def __init__(self, file, *, mapping: bool = True, append: bool = False):
+        """
+        :param mapping: write atom mapping.
+        :param append: open file path in append mode.
+        """
+        self._mapping = mapping
+
+        if isinstance(file, str):
+            self._file = open(file, 'a' if append else 'w')
+            self._is_buffer = False
+        elif isinstance(file, Path):
+            self._file = file.open('a' if append else 'w')
+            self._is_buffer = False
+        elif hasattr(file, 'write'):
+            self._file = file
+            self._is_buffer = True
+        else:
+            raise TypeError('invalid file. file-like object or path to file expected')
+
+    def close(self, force=False):
+        """
+        Close opened file
+
+        :param force: force closing of externally opened file or buffer
+        """
+        self.write = self.__write_closed
+
+        if not self._is_buffer or force:
+            self._file.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, _type, value, traceback):
+        self.close()
+
+    @staticmethod
+    def __write_closed(_):
+        raise ValueError('I/O operation on closed writer')
+
+
+class EMOLWrite(IO):
+    def __init__(self, file, *, mapping: bool = True, append: bool = False, absolute: bool = False):
+        """
+        :param mapping: write atom mapping.
+        :param append: open file path in append mode.
+        :param absolute: explicitly write MDLV30/STEABS collection for stereocenters without extended stereo groups.
+            By default chython treats any set chirality flag as absolute if not in an AND/OR group,
+            but some tools require the ABS collection to be explicitly present in the file.
+        """
+        self._absolute = absolute
+        super().__init__(file, mapping=mapping, append=append)
+
+    def _write_molecule(self, g, write3d=None):
+        if not isinstance(g, MoleculeContainer):
+            raise TypeError('MoleculeContainer expected')
+
+        if write3d is not None:
+            xyz = g._conformers[write3d]
+        else:
+            z = 0
+
+        bonds = g._bonds
+
+        file = self._file
+        file.write(f'M  V30 BEGIN CTAB\nM  V30 COUNTS {g.atoms_count} {g.bonds_count} 0 0 0\nM  V30 BEGIN ATOM\n')
+
+        for n, (m, a) in enumerate(g.atoms(), start=1):
+            if write3d is not None:
+                x, y, z = xyz[m]
+                z = f'{z:.4f}'
+            else:
+                x, y = a.x, a.y
+
+            c = f' CHG={a.charge}' if a.charge else ''
+            r = ' RAD=2' if a.is_radical else ''
+            i = f' MASS={a.isotope}' if a.isotope else ''
+
+            if not self._mapping:
+                m = 0
+            file.write(f'M  V30 {n} {a.atomic_symbol} {x:.4f} {y:.4f} {z} {m}{c}{r}{i}\n')
+
+        file.write('M  V30 END ATOM\nM  V30 BEGIN BOND\n')
+
+        mapping = {m: n for n, m in enumerate(g, start=1)}
+        wedge = defaultdict(set)
+        i = 0  # trick for empty wedge_map
+        for i, (n, m, s) in enumerate(g._wedge_map, start=1):
+            file.write(f'M  V30 {i} {bonds[n][m].order} {mapping[n]} {mapping[m]} CFG={s == 1 and "1" or "3"}\n')
+            wedge[n].add(m)
+            wedge[m].add(n)
+
+        for n, m, b in g.bonds():
+            if m not in wedge[n]:
+                i += 1
+                file.write(f'M  V30 {i} {b.order} {mapping[n]} {mapping[m]}\n')
+        file.write('M  V30 END BOND\n')
+
+        # enhanced stereo collection
+        rac = defaultdict(list)  # AND groups: positive extended_stereo
+        rel = defaultdict(list)  # OR groups: negative extended_stereo
+        ast = []  # absolute stereo
+        for m, a in g.atoms():
+            if (es := a.extended_stereo) is not None:
+                if es > 0:
+                    rac[es].append(mapping[m])
+                elif es < 0:
+                    rel[-es].append(mapping[m])
+            elif a.stereo is not None:
+                ast.append(mapping[m])
+        if rac or rel or (self._absolute and ast):
+            file.write('M  V30 BEGIN COLLECTION\n')
+            if self._absolute and ast:
+                file.write(f'M  V30 MDLV30/STEABS ATOMS=({len(ast)} {" ".join(str(x) for x in ast)})\n')
+            for gid in sorted(rac):
+                al = rac[gid]
+                file.write(f'M  V30 MDLV30/STERAC{gid} ATOMS=({len(al)} {" ".join(str(x) for x in al)})\n')
+            for gid in sorted(rel):
+                al = rel[gid]
+                file.write(f'M  V30 MDLV30/STEREL{gid} ATOMS=({len(al)} {" ".join(str(x) for x in al)})\n')
+            file.write('M  V30 END COLLECTION\n')
+
+        file.write('M  V30 END CTAB\n')
+
+
+class MOLWrite(IO):
+    def _write_molecule(self, g, write3d=None):
+        if not isinstance(g, MoleculeContainer):
+            raise TypeError('MoleculeContainer expected')
+        elif max(g) > 999:
+            raise ValueError('MOL file support only small molecules')
+
+        if write3d is not None:
+            xyz = g._conformers[write3d]
+        else:
+            z = 0.
+
+        bonds = g._bonds
+
+        file = self._file
+        file.write(f'{g.name}\n\n\n{g.atoms_count:3d}{g.bonds_count:3d}  0  0  0  0            999 V2000\n')
+
+        for n, (m, a) in enumerate(g.atoms(), start=1):
+            if write3d is not None:
+                x, y, z = xyz[m]
+            else:
+                x, y = a.x, a.y
+
+            c = charge_map[a.charge]
+            if not self._mapping:
+                m = 0
+            file.write(f'{x:10.4f}{y:10.4f}{z:10.4f} {a.atomic_symbol:3s} 0{c}  0  0  0  0  0  0  0{m:3d}  0  0\n')
+
+        atoms = {m: n for n, m in enumerate(g, start=1)}
+        wedge = defaultdict(set)
+        for n, m, s in g._wedge_map:
+            file.write(f'{atoms[n]:3d}{atoms[m]:3d}  {bonds[n][m].order}  {s == 1 and "1" or "6"}  0  0  0\n')
+            wedge[n].add(m)
+            wedge[m].add(n)
+        for n, m, b in g.bonds():
+            if m not in wedge[n]:
+                file.write(f'{atoms[n]:3d}{atoms[m]:3d}  {b.order}  0  0  0  0\n')
+
+        for n, (_, a) in enumerate(g.atoms(), start=1):
+            if a.isotope:
+                file.write(f'M  ISO  1 {n:3d} {a.isotope:3d}\n')
+            if a.is_radical:
+                file.write(f'M  RAD  1 {n:3d}   2\n')  # invalid for carbenes
+            if a.charge in (-4, 4):
+                file.write(f'M  CHG  1 {n:3d} {a.charge:3d}\n')
+        file.write('M  END\n')
+
+
+__all__ = ['MOLWrite', 'EMOLWrite']

chython/files/opsin.py

@@ -0,0 +1,35 @@
+# -*- 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 .daylight import smiles
+
+
+def opsin(string):
+    """Parse IUPAC name into MoleculeContainer."""
+    from .._java import get_opsin
+
+    result = get_opsin().parseChemicalName(string)
+    if str(result.getStatus()) == 'FAILURE':
+        raise ValueError(f'Failed to convert `{string}`: {result.getMessage()}')
+    return smiles(str(result.getSmiles()))
+
+
+iupac = opsin
+
+
+__all__ = ['opsin', 'iupac']

chython/files/test/test_inchi.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+import pytest
+
+try:
+    from chython import inchi
+    HAS_INCHI = True
+except ImportError:
+    HAS_INCHI = False
+
+
+@pytest.mark.skipif(not HAS_INCHI, reason='libinchi not available')
+def test_inchi_parse_ethanol():
+    mol = inchi('InChI=1S/C2H6O/c1-2-3/h3H,2H2,1H3')
+    assert len(mol) == 3
+    assert 'O' in {a.atomic_symbol for _, a in mol.atoms()}
+
+
+@pytest.mark.skipif(not HAS_INCHI, reason='libinchi not available')
+def test_inchi_parse_benzene():
+    mol = inchi('InChI=1S/C6H6/c1-2-4-6-5-3-1/h1-6H')
+    assert len(mol) == 6
+
+
+@pytest.mark.skipif(not HAS_INCHI, reason='libinchi not available')
+def test_inchi_parse_charged():
+    mol = inchi('InChI=1S/Na.H2O/h;1H2/q+1;/p-1')
+    assert mol is not None

chython/files/test/test_mrv.py

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+from io import BytesIO, StringIO
+from chython import smiles
+from chython.files import MRVRead, MRVWrite
+
+
+def test_mrv_read_molecule():
+    with MRVRead('test/implicit.mrv') as f:
+        mol = next(f)
+    assert mol is not None
+    assert len(mol) > 0
+    assert 'N' in {a.atomic_symbol for _, a in mol.atoms()}
+
+
+def test_mrv_read_all():
+    with MRVRead('test/implicit.mrv') as f:
+        mols = f.read()
+    assert len(mols) == 1
+
+
+def test_mrv_write_read_roundtrip():
+    mol = smiles('c1ccccc1')
+    mol.clean2d()
+
+    buf = StringIO()
+    with MRVWrite(buf) as w:
+        w.write(mol)
+
+    xml_bytes = buf.getvalue().encode()
+    with MRVRead(BytesIO(xml_bytes)) as r:
+        mol2 = next(r)
+
+    assert str(mol) == str(mol2)
+
+
+def test_mrv_write_reaction():
+    rxn = smiles('[CH3:1][OH:2]>>[CH3:1][NH2:3]')
+    for m in rxn.molecules():
+        m.clean2d()
+
+    buf = StringIO()
+    with MRVWrite(buf) as w:
+        w.write(rxn)
+
+    assert '<reaction>' in buf.getvalue()
+    assert 'reactantList' in buf.getvalue()
+    assert 'productList' in buf.getvalue()