chython 2.4__cp312-cp312-win_amd64.whl

chython/files/mdl/rxn.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 .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-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 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,165 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2021-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 collections import defaultdict
+from io import StringIO, TextIOWrapper
+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 isinstance(file, (TextIOWrapper, StringIO)):
+            self._file = file
+            self._is_buffer = True
+        else:
+            raise TypeError('invalid file. TextIOWrapper, StringIO subclasses 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 _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\nM  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/xyz.py

@@ -0,0 +1,78 @@
+# -*- 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 numpy import array
+from typing import Sequence, Tuple, Optional
+from ..containers import MoleculeContainer
+from ..periodictable import Element
+
+
+def xyz(matrix: Sequence[Tuple[str, float, float, float]], charge=0, radical=0, radius_multiplier=1.25,
+        atom_charge: Optional[Sequence[int]] = None, _cls=MoleculeContainer) -> MoleculeContainer:
+    from ._xyz import possible_bonds  # windows?
+
+    if atom_charge and len(atom_charge) != len(matrix):
+        raise ValueError('atom_charge should be None or the same size as matrix')
+
+    mol = _cls()
+    conformer = {}
+    mol._conformers = [conformer]
+
+    atoms = mol._atoms
+    bonds = mol._bonds
+    for n, (a, x, y, z) in enumerate(matrix, 1):
+        atoms[n] = Element.from_symbol(a)(x=x, y=y, implicit_hydrogens=0)
+        bonds[n] = {}
+        conformer[n] = (x, y, z)
+
+    if atom_charge is not None and None not in atom_charge:
+        for n, c in enumerate(atom_charge, 1):
+            atoms[n]._charge = c
+        charge = sum(atom_charge)
+
+    mol.calc_labels()
+    pb = possible_bonds(array(list(conformer.values())), array([a.atomic_radius for a in atoms.values()]),
+                        radius_multiplier)
+
+    log = mol.saturate(pb, expected_charge=charge, expected_radicals_count=radical, logging=True)
+    mol.meta['saturation_log'] = log
+    return mol
+
+
+def xyz_file(data) -> MoleculeContainer:
+    data = data.splitlines()
+
+    size = int(data[0])
+    charge = 0
+    radical = 0
+
+    for x in data[1].split():
+        if x.startswith('charge='):
+            charge = int(x[7:])
+        elif x.startswith('radical='):
+            radical = int(x[8:])
+
+    _xyz = []
+    for n, line in enumerate(data[2: size + 2]):
+        symbol, x, y, z = line.split()
+        _xyz.append((symbol, float(x), float(y), float(z)))
+
+    return xyz(_xyz, charge, radical)
+
+
+__all__ = ['xyz', 'xyz_file']

chython/periodictable/__init__.py

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2018-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 abc import ABCMeta
+from .base import *
+from .base.groups import *
+from .base.periods import *
+from .groupI import *
+from .groupII import *
+from .groupIII import *
+from .groupIV import *
+from .groupV import *
+from .groupVI import *
+from .groupVII import *
+from .groupVIII import *
+from .groupIX import *
+from .groupX import *
+from .groupXI import *
+from .groupXII import *
+from .groupXIII import *
+from .groupXIV import *
+from .groupXV import *
+from .groupXVI import *
+from .groupXVII import *
+from .groupXVIII import *
+
+
+modules = {v.__name__: v for k, v in globals().items() if k.startswith('group') and k != 'groups'}
+elements = {k: v for k, v in globals().items() if isinstance(v, ABCMeta) and k != 'Element' and issubclass(v, Element)}
+
+__all__ = ['Element', 'DynamicElement', 'QueryElement', 'AnyElement', 'ListElement', 'AnyMetal']
+__all__.extend(k for k in globals() if k.startswith('Group'))
+__all__.extend(k for k in globals() if k.startswith('Period'))
+__all__.extend(elements)
+
+
+for k, v in elements.items():
+    name = f'Dynamic{k}'
+    globals()[name] = cls = type(name, (DynamicElement,),
+                                 {'__module__': v.__module__, '__slots__': (),
+                                  'atomic_number': v.atomic_number})
+    setattr(modules[v.__module__], name, cls)
+    modules[v.__module__].__all__.append(name)
+    __all__.append(name)
+
+for k, v in elements.items():
+    name = f'Query{k}'
+    globals()[name] = cls = type(name, (QueryElement,),
+                                 {'__module__': v.__module__, '__slots__': (),
+                                  'atomic_number': v.atomic_number,
+                                  'mdl_isotope': v.mdl_isotope})
+    setattr(modules[v.__module__], name, cls)
+    modules[v.__module__].__all__.append(name)
+    __all__.append(name)

chython/periodictable/base/__init__.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2019-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 .dynamic import *
+from .element import *
+from .query import *
+
+
+__all__ = ['Element', 'DynamicElement', 'Query', 'ExtendedQuery',
+           'QueryElement', 'AnyElement', 'AnyMetal', 'ListElement']

chython/periodictable/base/dynamic.py

@@ -0,0 +1,149 @@
+# -*- 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 abc import ABC, abstractmethod
+from typing import Type, Optional
+from .element import Element
+
+
+class DynamicElement(ABC):
+    __slots__ = ('_charge', '_is_radical', '_p_charge', '_p_is_radical', '_isotope')
+
+    def __init__(self, isotope: Optional[int]):
+        self._isotope = isotope
+        self._charge = self._p_charge = 0
+        self._is_radical = self._p_is_radical = False
+
+    @property
+    def isotope(self):
+        return self._isotope
+
+    @property
+    def atomic_symbol(self) -> str:
+        return self.__class__.__name__[7:]
+
+    @property
+    @abstractmethod
+    def atomic_number(self) -> int:
+        """
+        Element number
+        """
+
+    @classmethod
+    def from_symbol(cls, symbol: str) -> Type['DynamicElement']:
+        """
+        get DynamicElement class by its symbol
+        """
+        try:
+            element = next(x for x in DynamicElement.__subclasses__() if x.__name__ == f'Dynamic{symbol}')
+        except StopIteration:
+            raise ValueError(f'DynamicElement with symbol "{symbol}" not found')
+        return element
+
+    @classmethod
+    def from_atomic_number(cls, number: int) -> Type['DynamicElement']:
+        """
+        get DynamicElement class by its number
+        """
+        try:
+            element = next(x for x in DynamicElement.__subclasses__() if x.atomic_number.fget(None) == number)
+        except StopIteration:
+            raise ValueError(f'DynamicElement with number "{number}" not found')
+        return element
+
+    @classmethod
+    def from_atom(cls, atom: 'Element') -> 'DynamicElement':
+        """
+        get DynamicElement object from Element object
+        """
+        if not isinstance(atom, Element):
+            raise TypeError('Element expected')
+        dynamic = object.__new__(cls.from_atomic_number(atom.atomic_number))
+        dynamic._isotope = atom.isotope
+        dynamic._charge = dynamic._p_charge = atom.charge
+        dynamic._is_radical = dynamic._p_is_radical = atom.is_radical
+        return dynamic
+
+    @classmethod
+    def from_atoms(cls, atom1: 'Element', atom2: 'Element') -> 'DynamicElement':
+        """
+        get DynamicElement object from pair of Element objects
+        """
+        if not isinstance(atom1, Element) or not isinstance(atom2, Element):
+            raise TypeError('Element expected')
+        if atom1.atomic_number != atom2.atomic_number:
+            raise ValueError('elements should be of the same type')
+        if atom1.isotope != atom2.isotope:
+            raise ValueError('elements should be of the same isotope')
+        dynamic = object.__new__(cls.from_atomic_number(atom1.atomic_number))
+        dynamic._isotope = atom1.isotope
+        dynamic._charge = atom1.charge
+        dynamic._p_charge = atom2.charge
+        dynamic._is_radical = atom1.is_radical
+        dynamic._p_is_radical = atom2.is_radical
+        return dynamic
+
+    @property
+    def charge(self) -> int:
+        return self._charge
+
+    @property
+    def is_radical(self) -> bool:
+        return self._is_radical
+
+    @property
+    def p_charge(self) -> int:
+        return self._p_charge
+
+    @property
+    def p_is_radical(self) -> bool:
+        return self._p_is_radical
+
+    def __eq__(self, other):
+        """
+        compare attached to molecules dynamic elements
+        """
+        return isinstance(other, DynamicElement) and self.atomic_number == other.atomic_number and \
+            self.isotope == other.isotope and self.charge == other.charge and self.is_radical == other.is_radical and \
+            self.p_charge == other.p_charge and self.p_is_radical == other.p_is_radical
+
+    def __hash__(self):
+        return hash((self.isotope or 0, self.atomic_number, self.charge, self.p_charge,
+                     self.is_radical, self.p_is_radical))
+
+    @property
+    def is_dynamic(self) -> bool:
+        """
+        Atom has dynamic features
+        """
+        return self.charge != self.p_charge or self.is_radical != self.p_is_radical
+
+    def copy(self):
+        copy = object.__new__(self.__class__)
+        copy._isotope = self.isotope
+        copy._charge = self.charge
+        copy._is_radical = self.is_radical
+        copy._p_is_radical = self.p_is_radical
+        copy._p_charge = self.p_charge
+        return copy
+
+    def __copy__(self):
+        return self.copy()
+
+
+__all__ = ['DynamicElement']