chython 2.19__cp313-cp313-win_amd64.whl

chython/files/test/test_sdf_rdf.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+from io import StringIO
+from chython import smiles
+from chython.files import SDFRead, SDFWrite, RDFRead, RDFWrite
+
+
+def test_sdf_read():
+    with SDFRead('test/implicit.sdf') as f:
+        mols = f.read()
+    assert len(mols) > 0
+    for mol in mols:
+        assert len(mol) > 0
+
+
+def test_sdf_read_stereo():
+    with SDFRead('test/stereo.sdf') as f:
+        mols = f.read(amount=10)
+    assert len(mols) == 10
+
+
+def test_sdf_write_read_roundtrip():
+    mol = smiles('CCO')
+    mol.clean2d()
+    mol.meta['name'] = 'ethanol'
+
+    buf = StringIO()
+    with SDFWrite(buf) as w:
+        w.write(mol)
+
+    buf.seek(0)
+    with SDFRead(buf) as r:
+        mol2 = next(r)
+
+    assert str(mol) == str(mol2)
+    assert mol2.meta.get('name') == 'ethanol'
+
+
+def test_rdf_read():
+    from chython import ReactionContainer
+    with RDFRead('test/MR.rdf') as f:
+        records = f.read()
+    assert len(records) > 0
+    rxns = [r for r in records if isinstance(r, ReactionContainer)]
+    assert len(rxns) > 0
+    for rxn in rxns:
+        assert len(rxn.reactants) > 0
+        assert len(rxn.products) > 0
+
+
+def test_rdf_write_read_roundtrip():
+    rxn = smiles('[CH3:1][OH:2]>>[CH3:1][NH2:3]')
+    for m in rxn.molecules():
+        m.clean2d()
+
+    buf = StringIO()
+    with RDFWrite(buf) as w:
+        w.write(rxn)
+
+    buf.seek(0)
+    with RDFRead(buf) as r:
+        rxn2 = next(r)
+
+    assert len(rxn2.reactants) == 1
+    assert len(rxn2.products) == 1

chython/files/test/test_xyz.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+from chython import xyz
+
+
+def test_xyz_water():
+    mol = xyz((('O', 0., 0., 0.), ('H', 1., 0., 0.), ('H', 0., 1., 0.)))
+    assert len(mol) == 3
+    assert 'O' in {a.atomic_symbol for _, a in mol.atoms()}
+
+
+def test_xyz_methane():
+    mol = xyz((
+        ('C', 0., 0., 0.),
+        ('H', 1.09, 0., 0.),
+        ('H', -0.36, 1.03, 0.),
+        ('H', -0.36, -0.51, 0.89),
+        ('H', -0.36, -0.51, -0.89),
+    ))
+    assert len(mol) == 5
+    assert mol.atoms_count == 5

chython/files/xyz.py

@@ -0,0 +1,78 @@
+# -*- 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 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-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
+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-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 .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-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 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']