chython 2.19__cp313-cp313-win_amd64.whl

chython/files/PDBrw.py

@@ -0,0 +1,255 @@
+# -*- 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 itertools import islice
+from pathlib import Path
+from typing import Optional, Sequence, Iterator, List
+from .xyz import xyz
+from ..containers import MoleculeContainer
+from ..exceptions import BufferOverflow
+
+
+one_symbol_names = {'ALA', 'CYS', 'ASP', 'GLU', 'PHE', 'GLY', 'HIS', 'ILE', 'LYS', 'LEU', 'MET', 'ASN', 'PRO', 'GLN',
+                    'ARG', 'SER', 'THR', 'VAL', 'TRP', 'TYR',  # Amino acids
+                    'ASH',  # H-asparagine
+                    'HID', 'HIE', 'HIP',  # H-histidines
+                    'DA', 'DC', 'DG', 'DT', 'DI',  # Deoxyribonucleotides
+                    'A', 'C', 'G', 'U', 'I',  # Ribonucleotides
+                    'IOD', 'K'}  # Elements
+two_symbol_names = {'CL', 'BR', 'NA', 'CA', 'MG', 'CO', 'MN', 'FE', 'CU', 'ZN'}
+
+
+class PDBRead:
+    """PDB 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.
+
+    Supported multiple structures in same file separated by ENDMDL. Supported only ATOM and HETATM parsing.
+    END or ENDMDL required in the end.
+    """
+    molecule_cls = MoleculeContainer
+
+    def __init__(self, file, *, buffer_size=10000, ignore: bool = True, element_name_priority: bool = False,
+                 parse_as_single: bool = False, atom_name_map=None, charge_map: Optional[Sequence[int]] = None,
+                 radical_map: Optional[Sequence[int]] = None, radius_multiplier: float = 1.25):
+        """
+        :param ignore: Skip some checks of data or try to fix some errors.
+        :param element_name_priority: For ligands use element symbol column value and ignore atom name column.
+        :param parse_as_single: Usable if all models in file is the same structure.
+            2d graph will be restored only from first model.
+        :param atom_name_map: dictionary with atom names replacements. e.g.: {'Ow': 'O'}. Keys should be capitalized.
+        :param charge_map: iterable with total charges of each model in file.
+        :param radical_map: iterable with total radicals count of each model in file.
+        """
+        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.__radius_multiplier = radius_multiplier
+        self.__ignore = ignore
+        self.__element_name_priority = element_name_priority
+        self.__parse_as_single = parse_as_single
+        self.__parsed_first = None
+        self.__atom_name_map = atom_name_map or {}
+        self.__charge_map = charge_map
+        self.__radical_map = radical_map
+
+        self.__buffer = None
+        self.__buffer_size = buffer_size
+        self.__tell = 0
+
+    def read(self, amount: Optional[int] = None) -> List[MoleculeContainer]:
+        """
+        Parse whole file
+
+        :param amount: number of records to read
+        """
+        if amount:
+            return list(islice(iter(self), amount))
+        return list(iter(self))
+
+    def read_structure(self, *, current: bool = True) -> MoleculeContainer:
+        """
+        Read Molecule container.
+
+        :param current: return current structure if already parsed, otherwise read next
+        """
+        data = self._read_block(current=current)
+        element_name_priority = self.__element_name_priority
+        atom_name_map = self.__atom_name_map
+
+        atoms = []
+        res = []
+        charges = []
+        log = []
+        for line in data:
+            if line.startswith(('ATOM', 'HETATM')):
+                # COLUMNS        DATA  TYPE    FIELD        DEFINITION
+                # -------------------------------------------------------------------------------------
+                #  1 -  6        Record name   "ATOM  " or "HETATM"
+                #  7 - 11        Integer       serial       Atom  serial number.
+                # 13 - 16        Atom          name         Atom name.
+                # 17             Character     altLoc       Alternate location indicator.
+                # 18 - 20        Residue name  resName      Residue name.
+                # 22             Character     chainID      Chain identifier.
+                # 23 - 26        Integer       resSeq       Residue sequence number.
+                # 27             AChar         iCode        Code for insertion of residues.
+                # 31 - 38        Real(8.3)     x            Orthogonal coordinates for X in Angstroms.
+                # 39 - 46        Real(8.3)     y            Orthogonal coordinates for Y in Angstroms.
+                # 47 - 54        Real(8.3)     z            Orthogonal coordinates for Z in Angstroms.
+                # 55 - 60        Real(6.2)     occupancy    Occupancy.
+                # 61 - 66        Real(6.2)     tempFactor   Temperature  factor.
+                # 77 - 78        LString(2)    element      Element symbol, right-justified.
+                # 79 - 80        LString(2)    charge       Charge  on the atom.
+                charge = line[78:80].strip()
+                if charge:
+                    charge = int(charge)
+                else:
+                    charge = None
+                x, y, z = float(line[30:38]), float(line[38:46]), float(line[46:54])
+                element = line[76:78].strip()
+                residue = line[17:20].strip()
+                atom_name = line[12:16].strip(' 0123456789-+')
+                if residue in one_symbol_names:  # bio-polymers and I
+                    atom_name = atom_name[0]
+                elif residue in two_symbol_names:
+                    atom_name = atom_name[:2].capitalize()
+                elif residue == 'MSE':
+                    if atom_name.startswith('SE'):
+                        atom_name = 'Se'
+                    else:
+                        atom_name = atom_name[0]
+                elif residue == 'CBR':
+                    if atom_name.startswith('BR'):
+                        atom_name = 'Br'
+                    else:
+                        atom_name = atom_name[0]
+                # ligands
+                elif element_name_priority:
+                    atom_name = element
+                else:
+                    atom_name = atom_name.capitalize()
+                    atom_name = atom_name_map.get(atom_name, atom_name)
+
+                if atom_name != element:
+                    log.append(f'Atom name and Element symbol is not equal: {line[:-1]}')
+                    if not self.__ignore:
+                        raise ValueError('Atom name and Element symbol is not equal')
+                atoms.append((atom_name, x, y, z))
+                res.append(residue)
+                charges.append(charge)
+
+        if not atoms:
+            raise ValueError('invalid PDB')
+
+        if self.__charge_map:
+            t_charge = self.__charge_map[self.__tell - 1]
+            radical = self.__radical_map[self.__tell - 1]
+        else:
+            t_charge = radical = 0
+
+        if self.__parsed_first is None:
+            mol = xyz(atoms, charge=t_charge, radical=radical, radius_multiplier=self.__radius_multiplier,
+                      atom_charge=charges, _cls=self.molecule_cls)
+
+            mol.meta['RESIDUE'] = dict(enumerate(res, 1))
+            if log:
+                mol.meta['chython_parsing_log'] = log
+            if self.__parse_as_single:
+                self.__parsed_first = mol.copy()
+            return mol
+        else:
+            if len(self.__parsed_first) != len(atoms):
+                raise ValueError('models not equal')
+            c = {}
+            for (n, a), (e, x, y, z) in zip(self.__parsed_first.atoms(), atoms):
+                if a.atomic_symbol != e:
+                    raise ValueError('models or atom order not equal')
+                c[n] = (x, y, z)
+            mol = self.__parsed_first.copy()
+            mol._conformers[0] = c
+            if log:
+                if 'chython_parsing_log' in mol.meta:
+                    mol.meta['chython_parsing_log'] = mol.meta['chython_parsing_log'] + log
+                else:
+                    mol.meta['chython_parsing_log'] = log
+            return mol
+
+    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 __enter__(self):
+        return self
+
+    def __exit__(self, _type, value, traceback):
+        self.close()
+
+    def __iter__(self) -> Iterator[MoleculeContainer]:
+        while True:
+            try:
+                yield self.read_structure(current=False)
+            except ValueError:
+                pass
+            except EOFError:
+                return
+
+    def __next__(self) -> MoleculeContainer:
+        return next(iter(self))
+
+    def _read_block(self, *, current=True) -> List[str]:
+        if current and self.__buffer:
+            return self.__buffer
+        self.__buffer = None
+        buffer_size = self.__buffer_size
+        buffer = []
+
+        for n, line in enumerate(self.__file):
+            buffer.append(line)
+            if line.startswith('END'):
+                break
+            elif n == buffer_size:
+                raise BufferOverflow
+        else:
+            raise EOFError
+
+        self.__tell += 1
+        self.__buffer = buffer
+        return buffer
+
+
+__all__ = ['PDBRead']

chython/files/RDFrw.py

@@ -0,0 +1,309 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2014-2026 Ramil Nugmanov <nougmanoff@protonmail.com>
+#  Copyright 2019 Dinar Batyrshin <batyrshin-dinar@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 collections import defaultdict
+from io import BytesIO
+from itertools import chain
+from pickle import dump
+from subprocess import check_output
+from sys import platform
+from time import strftime
+from typing import Union, Dict, List
+from .mdl import (MDLRead, MOLWrite, EMOLWrite, parse_mol_v2000, parse_mol_v3000, parse_rxn_v2000, parse_rxn_v3000,
+                  postprocess_molecule)
+from ._convert import create_molecule, create_reaction
+from ._mapping import postprocess_parsed_molecule, postprocess_parsed_reaction
+from ..containers import ReactionContainer, MoleculeContainer
+from ..exceptions import BufferOverflow
+
+
+class RDFRead(MDLRead):
+    """
+    MDL RDF 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
+    """
+    molecule_cls = MoleculeContainer
+    reaction_cls = ReactionContainer
+
+    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_start = None
+
+    def read_structure(self, *, current=True) -> Union[ReactionContainer, MoleculeContainer]:
+        data = self._read_block(current=current)
+        meta = self.read_metadata()
+        if data[0].startswith('$RXN'):
+            if data[4].startswith('M  V30 COUNTS'):
+                tmp = parse_rxn_v3000(data, ignore=self._ignore)
+            else:
+                tmp = parse_rxn_v2000(data, ignore=self._ignore)
+
+            postprocess_parsed_reaction(tmp, remap=self._remap, ignore=self._ignore)
+            rxn = create_reaction(tmp, ignore_bad_isotopes=self._ignore_bad_isotopes, _m_cls=self.molecule_cls,
+                                  _r_cls=self.reaction_cls)
+            if not self._ignore_stereo:
+                for mol, tmp in zip(rxn.molecules(), chain(tmp['reactants'], tmp['reagents'], tmp['products'])):
+                    postprocess_molecule(mol, tmp, calc_cis_trans=self._calc_cis_trans)
+            if meta:
+                rxn.meta.update(meta)
+            return rxn
+        elif data[4].startswith('M  V30 BEGIN CTAB'):
+            tmp = parse_mol_v3000(data)
+        else:
+            tmp = parse_mol_v2000(data)
+
+        postprocess_parsed_molecule(tmp)
+        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)
+        if meta:
+            mol.meta.update(meta)
+        return mol
+
+    def read_metadata(self, *, current=True) -> Dict[str, str]:
+        mkey = None
+        meta = defaultdict(list)
+        for line in self._read_metadata(current=current):
+            if line.startswith('$DTYPE'):
+                mkey = line[7:].strip()
+                if not mkey:
+                    meta['chython_unparsed_metadata'].append(line.strip())
+            elif mkey:
+                data = line.lstrip("$DATUM").strip()
+                if data:
+                    meta[mkey].append(data)
+            else:
+                meta['chython_unparsed_metadata'].append(line.strip())
+        return {k: '\n'.join(v) for k, v in meta.items()}
+
+    def read_rxn(self, *, current: bool = True) -> str:
+        """
+        Read rxn block without metadata
+        """
+        return ''.join(self._read_block(current=current)[:self.__m_start])
+
+    def read_mol(self, n: int, /, *, current: bool = True) -> str:
+        """
+        Read requested MOL block
+        """
+        data = self._read_block(current=current)
+        if data[0].startswith('$RXN'):
+            if data[4].startswith('M  V30 COUNTS'):
+                idx_l = [i for i, x in enumerate(data) if x.startswith('M  V30 BEGIN CTAB')]
+                idx_r = [i for i, x in enumerate(data, 1) if x.startswith('M  V30 END CTAB')]
+                if 0 <= n < len(idx_l):
+                    ct = ''.join(data[idx_l[n]: idx_r[n]])
+                    return f'\n\n\n  0  0  0     0  0            999 V3000\n{ct}M  END\n'
+                else:
+                    raise IndexError('molecule number is out of range')
+            else:
+                idx = [i for i, x in enumerate(data) if x.startswith('$MOL')]
+                if 0 <= n < len(idx):
+                    idx.append(self.__m_start)
+                    return ''.join(data[idx[n] + 1: idx[n + 1]])
+                else:
+                    raise IndexError('molecule number is out of range')
+        elif n:
+            raise IndexError('molecule number is out of range')
+        return ''.join(data[:self.__m_start])
+
+    def seek(self, offset):
+        super().seek(offset)
+        self.__m_start = None
+
+    def reset_index(self):
+        if platform != 'win32' and not self._is_buffer:
+            shifts = []
+            for x in BytesIO(check_output(['grep', '-bE', r'^\$[RM]FMT', self._file.name])):
+                pos, _ = x.split(b':', 1)
+                shifts.append(int(pos))
+            shifts[0] = 0  # first record parsing always starts from the beginning
+            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]:
+        """
+        Read RXN or MOL block with metadata
+        """
+        if current and self._buffer:
+            return self._buffer
+        self.__m_start = m_start = None
+        self._buffer = buffer = []
+        buffer_size = self._buffer_size
+
+        drop = not self._tell  # only first record starts from [RM]FMT search
+        for n, line in enumerate(self._file):
+            if drop:
+                if line.startswith('$RXN'):  # RXN file
+                    drop = False
+                    buffer.append(line)
+                elif line.startswith(('$RFMT', '$MFMT')):  # first occurrence found
+                    drop = False
+                continue
+            elif n == buffer_size:
+                raise BufferOverflow
+            elif not m_start and line.startswith('$DTYPE'):
+                self.__m_start = m_start = len(buffer)
+            elif line.startswith(('$RFMT', '$MFMT')):  # next record found
+                break
+            buffer.append(line)
+        if buffer:
+            self._tell += 1
+        else:
+            raise EOFError
+        return buffer
+
+    def _read_metadata(self, *, current: bool = True):
+        data = self._read_block(current=current)
+        if not self.__m_start:
+            return []
+        return data[self.__m_start:]
+
+
+class RDFWrite(MOLWrite):
+    """
+    MDL RDF 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
+    """
+    def __init__(self, file, *, append: bool = False, mapping: bool = True):
+        """
+        :param append: append to existing file (True) or rewrite it (False). For buffered writer object append = False
+            will write RDF header and append = True will omit the header.
+        :param mapping: write atom mapping.
+        """
+        super().__init__(file, append=append, mapping=mapping)
+        if not append or not (self._is_buffer or self._file.tell() != 0):
+            self.write = self.__write
+
+    def __write(self, data):
+        del self.write
+        self._file.write(strftime('$RDFILE 1\n$DATM    %m/%d/%y %H:%M\n'))
+        self.write(data)
+
+    def write(self, data: Union[ReactionContainer, MoleculeContainer]):
+        file = self._file
+        if isinstance(data, ReactionContainer):
+            file.write(f'$RFMT\n$RXN\n{data.name}\n\n\n{len(data.reactants):3d}{len(data.products):3d}')
+            if data.reagents:
+                file.write(f'{len(data.reagents):3d}\n')
+            else:
+                file.write('\n')
+            for m in chain(data.reactants, data.products, data.reagents):
+                file.write('$MOL\n')
+                self._write_molecule(m)
+        else:
+            file.write('$MFMT\n')
+            self._write_molecule(data)
+        for k, v in data.meta.items():
+            file.write(f'$DTYPE {k}\n$DATUM {v}\n')
+
+
+class ERDFWrite(EMOLWrite):
+    """
+    MDL V3000 RDF 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
+    """
+    def __init__(self, file, *, append: bool = False, mapping: bool = True, absolute: bool = False):
+        """
+        :param append: append to existing file (True) or rewrite it (False). For buffered writer object append = False
+            will write RDF header and append = True will omit the header.
+        :param mapping: write atom mapping.
+        :param absolute: explicitly write MDLV30/STEABS collection for stereocenters without extended stereo groups.
+        """
+        super().__init__(file, append=append, mapping=mapping, absolute=absolute)
+        if not append or not (self._is_buffer or self._file.tell() != 0):
+            self.write = self.__write
+
+    def __write(self, data):
+        del self.write
+        self._file.write(strftime('$RDFILE 1\n$DATM    %m/%d/%y %H:%M\n'))
+        self.write(data)
+
+    def write(self, data: Union[ReactionContainer, MoleculeContainer]):
+        file = self._file
+        if isinstance(data, ReactionContainer):
+            file.write(f'$RFMT\n$RXN V3000\n{data.name}\n\n\nM  V30 COUNTS {len(data.reactants)} {len(data.products)}')
+            if data.reagents:
+                file.write(f' {len(data.reagents)}\nM  V30 BEGIN REACTANT\n')
+            else:
+                file.write('\nM  V30 BEGIN REACTANT\n')
+            for m in data.reactants:
+                self._write_molecule(m)
+            file.write('M  V30 END REACTANT\nM  V30 BEGIN PRODUCT\n')
+            for m in data.products:
+                self._write_molecule(m)
+            file.write('M  V30 END PRODUCT\n')
+            if data.reagents:
+                file.write('M  V30 BEGIN AGENT\n')
+                for m in data.reagents:
+                    self._write_molecule(m)
+                file.write('M  V30 END AGENT\n')
+            file.write('M  END\n')
+        else:
+            file.write(f'$MFMT\n{data.name}\n\n\n  0  0  0     0  0            999 V3000\n')
+            self._write_molecule(data)
+            file.write('M  END\n')
+        for k, v in data.meta.items():
+            file.write(f'$DTYPE {k}\n$DATUM {v}\n')
+
+
+def mdl_rxn(data: str, /, *, ignore=True, calc_cis_trans=False, ignore_stereo=False, remap=False,
+            ignore_bad_isotopes=False, _r_cls=ReactionContainer, _m_cls=MoleculeContainer) -> ReactionContainer:
+    """
+    Parse string with rxn file.
+    """
+    data = data.splitlines()
+    if not data[0].startswith('$RXN'):
+        raise ValueError('invalid RXN')
+    if data[4].startswith('M  V30 COUNTS'):
+        tmp = parse_rxn_v3000(data, ignore=ignore)
+    else:
+        tmp = parse_rxn_v2000(data, ignore=ignore)
+
+    postprocess_parsed_reaction(tmp, remap=remap, ignore=ignore)
+    rxn = create_reaction(tmp, ignore_bad_isotopes=ignore_bad_isotopes, _m_cls=_m_cls, _r_cls=_r_cls)
+    if not ignore_stereo:
+        for mol, tmp in zip(rxn.molecules(), chain(tmp['reactants'], tmp['reagents'], tmp['products'])):
+            postprocess_molecule(mol, tmp, calc_cis_trans=calc_cis_trans)
+    return rxn
+
+
+__all__ = ['RDFRead', 'RDFWrite', 'ERDFWrite', 'mdl_rxn']