chython 2.19__cp313-cp313-win_amd64.whl

chython/files/SDFrw.py

@@ -0,0 +1,221 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2014-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 io import BytesIO
+from pickle import dump
+from re import compile, match
+from subprocess import check_output
+from sys import platform
+from typing import Optional, List
+from .mdl import MDLRead, MOLWrite, EMOLWrite, parse_mol_v2000, parse_mol_v3000, postprocess_molecule
+from ._convert import create_molecule
+from ._mapping import postprocess_parsed_molecule
+from ..containers import MoleculeContainer
+from ..exceptions import BufferOverflow, InvalidMolBlock
+
+
+meta_pattern = compile(r'^>([^<]+)<([^>]+)>([^><]*)$')
+
+
+class SDFRead(MDLRead):
+    """
+    MDL SDF files reader. works similar to opened file object. support `with` context manager.
+    on initialization accept opened in text mode file, string path to file,
+    pathlib.Path object or another buffered reader object
+    """
+    escape_map = {'&gt;': '>', '&lt;': '<'}
+    molecule_cls = MoleculeContainer
+
+    def __init__(self, file, *, buffer_size=10000, indexable: bool = False, ignore: bool = True, remap: bool = False,
+                 calc_cis_trans: bool = False, ignore_stereo: bool = False, ignore_bad_isotopes: bool = False):
+        """
+        :param buffer_size: readahead size. increase if you have big molecules or metadata records.
+        :param indexable: if True: supported methods seek, tell, object size and subscription, it only works when
+            dealing with a real file (the path to the file is specified) because the external grep utility is used,
+            supporting in unix-like OS the object behaves like a normal open file.
+
+            if False: works like generator converting a record into MoleculeContainer and returning each object in
+            order, records with errors are skipped
+        :param ignore: Skip some checks of data or try to fix some errors.
+        :param remap: Remap atom numbers started from one.
+        :param calc_cis_trans: Calculate cis/trans marks from 2d coordinates.
+        :param ignore_stereo: Ignore stereo data.
+        :param ignore_bad_isotopes: reset invalid isotope mark to non-isotopic.
+        """
+        super().__init__(file, indexable=indexable, ignore=ignore, remap=remap, ignore_bad_isotopes=ignore_bad_isotopes,
+                         ignore_stereo=ignore_stereo, calc_cis_trans=calc_cis_trans, buffer_size=buffer_size)
+        self.__m_end = None
+
+    def read_structure(self, *, current=True) -> MoleculeContainer:
+        data = self._read_mol(current=current)
+        if data[4].startswith('M  V30 BEGIN CTAB'):
+            tmp = parse_mol_v3000(data)
+        else:
+            tmp = parse_mol_v2000(data)
+
+        postprocess_parsed_molecule(tmp, remap=self._remap, ignore=self._ignore)
+        mol = create_molecule(tmp, ignore_bad_isotopes=self._ignore_bad_isotopes, _cls=self.molecule_cls)
+        if not self._ignore_stereo:
+            postprocess_molecule(mol, tmp, calc_cis_trans=self._calc_cis_trans)
+        meta = self.read_metadata()
+        if meta:
+            mol.meta.update(meta)
+        return mol
+
+    def read_metadata(self, *, current=True):
+        mkey = None
+        meta = defaultdict(list)
+        for line in self._read_metadata(current=current):
+            if matched := match(meta_pattern, line):
+                mkey = ' '.join(y for x in matched.groups() if (y := x.strip()))
+                for e, s in self.escape_map.items():
+                    mkey = mkey.replace(e, s)
+            elif mkey:
+                if line := line.strip():
+                    meta[mkey].append(line)
+            else:
+                meta['chython_unparsed_metadata'].append(line.strip())
+        return {k: '\n'.join(v) for k, v in meta.items()}
+
+    def read_mol(self, *, current: bool = True) -> str:
+        """
+        Read MOL block without metadata
+        """
+        return ''.join(self._read_mol(current=current))
+
+    def seek(self, offset):
+        super().seek(offset)
+        self.__m_end = None
+
+    def reset_index(self):
+        if platform != 'win32' and not self._is_buffer:
+            shifts = [0]
+            for x in BytesIO(check_output(['grep', '-bE', r'\$\$\$\$', self._file.name])):
+                pos, line = x.split(b':', 1)
+                shifts.append(int(pos) + len(line))
+            shifts.pop(-1)
+            with open(self._cache_path, 'wb') as f:
+                dump(shifts, f)
+            self._shifts = shifts
+        else:
+            raise NotImplementedError('Indexable supported in unix-like o.s. and for files stored on disk')
+
+    def _read_block(self, *, current=True) -> List[str]:
+        if current and self._buffer:
+            return self._buffer
+        self.__m_end = m_end = None
+        self._buffer = buffer = []
+        buffer_size = self._buffer_size
+
+        for n, line in enumerate(self._file):
+            if line.startswith('$$$$'):
+                break
+            elif n == buffer_size:
+                raise BufferOverflow
+            buffer.append(line)
+            if not m_end and line.startswith('M  END'):
+                self.__m_end = m_end = len(buffer)
+        if buffer:
+            self._tell += 1
+        else:
+            raise EOFError
+        return buffer
+
+    def _read_mol(self, *, current: bool = True) -> List[str]:
+        data = self._read_block(current=current)
+        if not self.__m_end:
+            raise InvalidMolBlock
+        return data[:self.__m_end]
+
+    def _read_metadata(self, *, current: bool = True):
+        data = self._read_block(current=current)
+        if not self.__m_end:
+            raise InvalidMolBlock
+        return data[self.__m_end:]
+
+
+class SDFWrite(MOLWrite):
+    """
+    MDL SDF files writer. works similar to opened for writing file object. support `with` context manager.
+    on initialization accept opened for writing in text mode file, string path to file,
+    pathlib.Path object or another buffered writer object
+    """
+    escape_map = {'>': '&gt;', '<': '&lt;'}
+
+    def write(self, data: MoleculeContainer, write3d: Optional[int] = None):
+        """
+        write single molecule into file
+
+        :param write3d: write conformer coordinates with given index
+        """
+        self._write_molecule(data, write3d=write3d)
+
+        file = self._file
+        for k, v in data.meta.items():
+            for e, s in self.escape_map.items():
+                k = k.replace(e, s)
+            file.write(f'>  <{k}>\n{v}\n\n')
+        file.write('$$$$\n')
+
+
+class ESDFWrite(EMOLWrite):
+    """
+    MDL V3000 SDF files writer. works similar to opened for writing file object. support `with` context manager.
+    on initialization accept opened for writing in text mode file, string path to file,
+    pathlib.Path object or another buffered writer object
+    """
+    escape_map = {'>': '&gt;', '<': '&lt;'}
+
+    def write(self, data: MoleculeContainer, write3d: Optional[int] = None):
+        """
+        write single molecule into file
+
+        :param write3d: write conformer coordinates with given index
+        """
+        file = self._file
+        file.write(f'{data.name}\n\n\n  0  0  0     0  0            999 V3000\n')
+        self._write_molecule(data, write3d)
+        file.write('M  END\n')
+
+        for k, v in data.meta.items():
+            for e, s in self.escape_map.items():
+                k = k.replace(e, s)
+            file.write(f'>  <{k}>\n{v}\n\n')
+        file.write('$$$$\n')
+
+
+def mdl_mol(data: str, /, *, ignore=True, calc_cis_trans=False, ignore_stereo=False, remap=False,
+            ignore_bad_isotopes=False, _cls=MoleculeContainer) -> MoleculeContainer:
+    """
+    Parse string with mol file.
+    """
+    data = data.splitlines()
+    if data[4].startswith('M  V30 BEGIN CTAB'):
+        tmp = parse_mol_v3000(data)
+    else:
+        tmp = parse_mol_v2000(data)
+
+    postprocess_parsed_molecule(tmp, remap=remap, ignore=ignore)
+    mol = create_molecule(tmp, ignore_bad_isotopes=ignore_bad_isotopes, _cls=_cls)
+    if not ignore_stereo:
+        postprocess_molecule(mol, tmp, calc_cis_trans=calc_cis_trans)
+    return mol
+
+
+__all__ = ['SDFRead', 'SDFWrite', 'ESDFWrite', 'mdl_mol']

chython/files/__init__.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2014-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 *
+from .libinchi import *
+from .MRVrw import *
+from .opsin import *
+from .PDBrw import *
+from .RDFrw import *
+from .SDFrw import *
+from .xyz import *
+
+
+__all__ = ['smiles', 'smarts', 'mdl_mol', 'mdl_rxn', 'xyz', 'xyz_file', 'inchi', 'opsin', 'iupac']
+__all__.extend(x for x in locals() if x.endswith(('Read', 'Write')))

chython/files/_convert.py

@@ -0,0 +1,207 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2023-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 ..containers import MoleculeContainer, ReactionContainer
+from ..containers.bonds import Bond
+from ..exceptions import AtomNotFound
+from ..periodictable import Element
+
+
+# atomic number constants
+B = 5
+C = 6
+N = 7
+P = 15
+
+
+def create_molecule(data, *, ignore_bad_isotopes=False, skip_calc_implicit=False,
+                    keep_implicit=False, keep_radicals=True, ignore_aromatic_radicals=True, ignore=True,
+                    ignore_carbon_radicals=False, _cls=MoleculeContainer):
+    g = _cls()
+    g._name = data.get('title')
+    atoms = g._atoms
+    bonds = g._bonds
+    mapping = data['mapping']
+
+    if any(a.get('z') for a in data['atoms']):
+        # store conformer
+        g._conformers = [{n: (a['x'], a['y'], a['z']) for n, a in zip(mapping, data['atoms'])}]
+
+    for n, atom in zip(mapping, data['atoms']):
+        e = Element.from_symbol(atom.pop('element'))
+        atom.pop('z', None)  # clean up MDL
+        try:
+            atoms[n] = e(**atom)
+        except (ValueError, TypeError):
+            if not ignore_bad_isotopes:
+                raise
+            del atom['isotope']  # reset isotope mark on errors and try again.
+            atoms[n] = e(**atom)
+        bonds[n] = {}
+
+    for n, m, b in data['bonds']:
+        n, m = mapping[n], mapping[m]
+        if n == m:
+            raise ValueError('atom loops impossible')
+        if n not in bonds or m not in bonds:
+            raise AtomNotFound('atoms not found')
+        if n in bonds[m]:
+            raise ValueError('atoms already bonded')
+        bonds[n][m] = bonds[m][n] = Bond(b)
+
+    g.calc_labels()  # set all labels except rings
+
+    if data.get('log'):  # store log to the meta
+        if data.get('meta') is None:
+            data['meta'] = {}
+        data['meta']['chython_parsing_log'] = data['log']
+    g._meta = data.get('meta') or None
+
+    if skip_calc_implicit:  # don't calc Hs. e.g. INCHI
+        return g
+
+    implicit_mismatch = {}
+    radicalized = []
+    # precalculate Hs
+    for n, a in atoms.items():
+        if a.implicit_hydrogens is None:
+            # let's try to calculate. in case of errors just keep as is. radicals in smiles should be in [brackets],
+            # thus has implicit Hs value
+            g.calc_implicit(n)
+        elif keep_implicit:
+            # keep given Hs count as is
+            continue
+        else:  # recheck given Hs count
+            h = a.implicit_hydrogens  # parsed Hs
+            g.calc_implicit(n)  #  recalculate
+            if a.implicit_hydrogens is None:  # atom has invalid valence or aromatic ring.
+                if a.hybridization == 4:
+                    # this is aromatic ring. just restore given H count.
+                    a._implicit_hydrogens = h
+                    # rare H0 case
+                    if (not keep_radicals and not ignore_aromatic_radicals
+                        and not h and not a.charge and not a.is_radical and a in (B, C, N, P)
+                        and sum(b != 8 for b in bonds[n].values()) == 2):
+                        # c[c]c - aromatic B,C,N,P radical
+                        a._is_radical = True
+                        radicalized.append(n)
+                elif not keep_radicals and not a.is_radical:  # CXSMILES radical not set.
+                    # SMILES doesn't code radicals. so, let's try to guess.
+                    a._is_radical = True
+                    if g.check_implicit(n, h):  # radical form is valid
+                        radicalized.append(n)
+                        a._implicit_hydrogens = h
+                    elif ignore:  # radical state also has errors.
+                        a._is_radical = False  # reset radical state
+                        implicit_mismatch[n] = h
+                        if data.get('log') is None:
+                            data['log'] = []
+                        data['log'].append(f'implicit hydrogen count ({h}) mismatch with calculated on atom {n}')
+                    else:
+                        raise ValueError(f'implicit hydrogen count ({h}) mismatch with calculated on atom {n}')
+            elif h != a.implicit_hydrogens:  # H count mismatch.
+                if a.hybridization == 4:
+                    if (not keep_radicals
+                        and not h and not a.charge and not a.is_radical and a in (B, C, N, P)
+                        and sum(b != 8 for b in bonds[n].values()) == 2):
+                        # c[c]c - aromatic B,C,N,P radical
+                        a._implicit_hydrogens = 0
+                        a._is_radical = True
+                        radicalized.append(n)
+                    elif ignore:
+                        implicit_mismatch[n] = h
+                        if data.get('log') is None:
+                            data['log'] = []
+                        data['log'].append(f'implicit hydrogen count ({h}) mismatch with calculated on atom {n}')
+                    else:
+                        raise ValueError(f'implicit hydrogen count ({h}) mismatch with calculated on atom {n}')
+                elif g.check_implicit(n, h):  # set another possible implicit state. probably Al, P
+                    a._implicit_hydrogens = h
+                elif not keep_radicals and not a.is_radical:  # CXSMILES radical is not set. try radical form
+                    a._is_radical = True
+                    if g.check_implicit(n, h):
+                        a._implicit_hydrogens = h
+                        radicalized.append(n)
+                    # radical state also has errors.
+                    elif ignore:
+                        a._is_radical = False  # reset radical state
+                        implicit_mismatch[n] = h
+                        if data.get('log') is None:
+                            data['log'] = []
+                        data['log'].append(f'implicit hydrogen count ({h}) mismatch with calculated on atom {n}')
+                    else:
+                        raise ValueError(f'implicit hydrogen count ({h}) mismatch with calculated on atom {n}')
+                elif ignore:  # just ignore it
+                    implicit_mismatch[n] = h
+                    if data.get('log') is None:
+                        data['log'] = []
+                    data['log'].append(f'implicit hydrogen count ({h}) mismatch with calculated on atom {n}')
+                else:
+                    raise ValueError(f'implicit hydrogen count ({h}) mismatch with calculated on atom {n}')
+
+    if ignore_carbon_radicals:
+        for n in radicalized:
+            if (a := atoms[n]) == C:
+                a._is_radical = False
+                a._implicit_hydrogens += 1
+                if data.get('log') is None:
+                    data['log'] = []
+                data['log'].append(f'carbon radical {n} replaced with implicit hydrogen')
+    elif radicalized:
+        g.meta['chython_radicalized_atoms'] = radicalized
+    if data.get('log') and 'chython_parsing_log' not in g.meta:
+        g.meta['chython_parsing_log'] = data['log']
+    if implicit_mismatch:
+        g.meta['chython_implicit_mismatch'] = implicit_mismatch
+    return g
+
+
+def create_reaction(data, *, ignore=True, skip_calc_implicit=False, ignore_bad_isotopes=False,
+                    keep_implicit=False, keep_radicals=True, ignore_aromatic_radicals=True,
+                    ignore_carbon_radicals=False, _r_cls=ReactionContainer, _m_cls=MoleculeContainer):
+    rc, pr, rg = [], [], []
+    for ms, pms, gr in ((rc, data['reactants'], 'reactant'),
+                        (pr, data['products'], 'products'),
+                        (rg, data['reagents'], 'reagent')):
+        tdl = []
+        for n, m in enumerate(pms):
+            try:
+                ms.append(create_molecule(m, skip_calc_implicit=skip_calc_implicit,
+                                          ignore_bad_isotopes=ignore_bad_isotopes, keep_implicit=keep_implicit,
+                                          keep_radicals=keep_radicals,
+                                          ignore_aromatic_radicals=ignore_aromatic_radicals, ignore=ignore,
+                                          ignore_carbon_radicals=ignore_carbon_radicals, _cls=_m_cls))
+            except ValueError as e:
+                if not ignore:
+                    raise
+                if data.get('log') is None:
+                    data['log'] = []
+                data['log'].append(f'ignored {gr} molecule {n} with {e}')
+                tdl.append(n)
+        if tdl:  # ad-hoc for later postprocessing
+            for n in reversed(tdl):
+                del pms[n]
+
+    if data.get('log'):  # store log to the meta
+        if data.get('meta') is None:
+            data['meta'] = {}
+        data['meta']['chython_parsing_log'] = data['log']
+    return _r_cls(rc, pr, rg, meta=data.get('meta') or None, name=data.get('title'))
+
+
+__all__ = ['create_molecule']

chython/files/_mapping.py

@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2014-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 itertools import count
+from ..exceptions import MappingError
+
+
+def postprocess_parsed_molecule(data, *, remap=False, ignore=True):
+    if remap:
+        remapped = list(range(1, len(data['atoms']) + 1))
+    else:
+        length = count(max(x.get('parsed_mapping') or 0 for x in data['atoms']) + 1)
+        remapped, used = [], set()
+        for n, atom in enumerate(data['atoms']):
+            m = atom.get('parsed_mapping')
+            if not m:
+                remapped.append(next(length))
+            elif m in used:
+                if not ignore:
+                    raise MappingError('mapping in molecules should be unique')
+                remapped.append(next(length))
+                if data.get('log') is None:
+                    data['log'] = []
+                data['log'].append(f'mapping in molecule changed from {m} to {remapped[n]}')
+            else:
+                remapped.append(m)
+                used.add(m)
+    data['mapping'] = remapped
+
+
+def postprocess_parsed_reaction(data, *, remap=False, ignore=True):
+    maps = {'reactants': [], 'products': [], 'reagents': []}
+    for i, tmp in maps.items():
+        for molecule in data[i]:
+            used = set()
+            for atom in molecule['atoms']:
+                m = atom.get('parsed_mapping')
+                if m:
+                    if m in used:
+                        if not ignore:
+                            raise MappingError('mapping in molecules should be unique')
+                        molecule['log'].append(f'non-unique mapping in molecule: {m}')
+                    else:
+                        used.add(m)
+                    tmp.append(m)
+                else:
+                    tmp.append(0)
+
+    length = count(max(max(maps['products'], default=0), max(maps['reactants'], default=0),
+                       max(maps['reagents'], default=0)) + 1)
+
+    # map unmapped atoms.
+    for i, tmp in maps.items():
+        used = set()
+        maps[i] = _remap = []
+        for m in tmp:
+            if not m:
+                _remap.append(next(length))
+            elif m in used:
+                if not ignore:
+                    raise MappingError('mapping in reagents or products or reactants should be unique')
+                # force remap non unique atoms in molecules.
+                _remap.append(next(length))
+                if data.get('log') is None:
+                    data['log'] = []
+                data['log'].append(f'mapping in {i} changed from {m} to {_remap[-1]}')
+            else:
+                _remap.append(m)
+                used.add(m)
+
+    if maps['reagents']:
+        tmp = (set(maps['reactants']) | set(maps['products'])) & set(maps['reagents'])
+        if tmp:
+            e = f'reagents has map intersection with reactants or products: {tmp}'
+            if not ignore:
+                raise MappingError(e)
+            if data.get('log') is None:
+                data['log'] = []
+            data['log'].append(e)
+            maps['reagents'] = [x if x not in tmp else next(length) for x in maps['reagents']]
+
+    # find breaks in map. e.g. 1,2,5,6. 3,4 - skipped
+    if remap:
+        lose = sorted(
+            set(range(1, next(length))) - set(maps['reactants']) - set(maps['products']) - set(maps['reagents']),
+            reverse=True)
+        if lose:
+            for i, tmp in maps.items():
+                if not tmp:
+                    continue
+                for j in lose:
+                    maps[i] = tmp = [x if x < j else x - 1 for x in tmp]
+
+    for i, tmp in maps.items():
+        shift = 0
+        for j in data[i]:
+            atom_len = len(j['atoms'])
+            j['mapping'] = tmp[shift: atom_len + shift]
+            shift += atom_len
+
+
+__all__ = ['postprocess_parsed_molecule', 'postprocess_parsed_reaction']

chython/files/_xyz.pyx

@@ -0,0 +1,74 @@
+# cython: freethreading_compatible=True
+#
+#  Copyright 2022-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/>.
+#
+cimport cython
+from cpython.mem cimport PyMem_Malloc, PyMem_Free
+from libc.math cimport sqrt
+
+
+cdef extern from "Python.h":
+    dict _PyDict_NewPresized(Py_ssize_t minused)
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def possible_bonds(double[:, ::1] xyz not None, double[::1] radii not None, double multiplier):
+    cdef unsigned int size, max_bonds, c = 0, b = 0, n, m, k
+    cdef double d, nx, ny, nz, rn, mx, my, mz
+    cdef dict py_bonds, tmp
+
+    size = xyz.shape[0]
+    max_bonds = size * 10  # each atom has less then 10 neighbors approximately
+
+    cdef unsigned int *ns = <unsigned int *> PyMem_Malloc(size * sizeof(unsigned int))
+    cdef unsigned int *mi = <unsigned int *> PyMem_Malloc(max_bonds * sizeof(unsigned int))
+    cdef double *ds = <double *> PyMem_Malloc(max_bonds * sizeof(double))
+
+    if not ns or not mi or not ds:
+        raise MemoryError()
+
+    for n in range(size - 1):
+        nx, ny, nz = xyz[n, 0], xyz[n, 1], xyz[n, 2]
+        rn = radii[n]
+        for m in range(n + 1, size):
+            mx, my, mz = nx - xyz[m, 0], ny - xyz[m, 1], nz - xyz[m, 2]
+            d = sqrt(mx * mx + my * my + mz * mz)
+            if d <= (rn + radii[m]) * multiplier:
+                mi[c] = m
+                ds[c] = d
+                c += 1
+        ns[n] = c
+
+    # prepare dict of dicts
+    py_bonds = _PyDict_NewPresized(size)
+    for n in range(size):
+        py_bonds[n + 1] = {}
+
+    for n in range(size - 1):
+        c = ns[n]
+        n += 1
+        tmp = py_bonds[n]
+        for m in range(b, c):
+            k = mi[m] + 1
+            tmp[k] = py_bonds[k][n] = ds[m]
+        b = c
+
+    PyMem_Free(ns)
+    PyMem_Free(mi)
+    PyMem_Free(ds)
+    return py_bonds

chython/files/daylight/__init__.py

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2018-2026 Ramil Nugmanov <nougmanoff@protonmail.com>
+#  Copyright 2019 Artem Mukanov <nostro32@mail.ru>
+#  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 .smarts import *
+from .smiles import *
+
+
+__all__ = ['smiles', 'smarts']