chython 2.19__cp313-cp313-win_amd64.whl

chython/algorithms/x3dom.py

@@ -0,0 +1,350 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2020-2026 Ramil Nugmanov <nougmanoff@protonmail.com>
+#  Copyright 2020 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 math import acos, sqrt
+from .depict import _render_config
+
+
+def plane_normal(nmx, nmy, nmz, nox, noy, noz):
+    # return normal to plane of two vectors nm and no
+    # m <--- n
+    #         \
+    #          v
+    #          o
+    return nmy * noz - nmz * noy, nox * nmz - nmx * noz, nmx * noy - nmy * nox
+
+
+def unit_vector(nmx, nmy, nmz):
+    nmd = sqrt(nmx ** 2 + nmy ** 2 + nmz ** 2)
+    return nmx / nmd, nmy / nmd, nmz / nmd
+
+
+def get_angle(nx, ny, nz, mx, my, mz):
+    ch = (nx * mx + ny * my + nz * mz) ** 2
+    zn = (nx ** 2 + ny ** 2 + nz ** 2) * (mx ** 2 + my ** 2 + mz ** 2)
+    if ch < .0001:
+        return 1.
+    elif zn < .0001:
+        return .0
+    else:
+        return sqrt(1 - ch / zn)
+
+
+def vector_normal(nmx, nmy, nmz):
+    # return normal to vector nm
+    if not -.0001 < nmx < .0001:
+        return (- nmy - nmz) / nmx, 1, 1
+    elif not -.0001 < nmy < .0001:
+        return 1, (- nmx - nmz) / nmy, 1
+    else:
+        return 1, 1, (- nmx - nmy) / nmz
+
+
+class JupyterWidget:
+    def __init__(self, xml, width, height):
+        self.xml = xml
+        self.width = width
+        self.height = height
+
+    def _repr_html_(self):
+        return ("<script type='text/javascript' src='https://www.x3dom.org/download/x3dom.js'></script>"
+                "<link rel='stylesheet' type='text/css' href='https://www.x3dom.org/download/x3dom.css'>"
+                f'<div style="width: {self.width}; height: {self.height}">{self.xml}</div>')
+
+    def __html__(self):
+        return self._repr_html_()
+
+
+def _render_aromatic_bond(n_x, n_y, n_z, m_x, m_y, m_z, c_x, c_y, c_z):
+    aromatic_space = _render_config['aromatic_space']
+
+    # n aligned xyz
+    nc_x, nc_y, nc_z = c_x - n_x, c_y - n_y, c_z - n_z
+    mc_x, mc_y, mc_z = c_x - m_x, c_y - m_y, c_z - m_z
+
+    nc_ln = sqrt(nc_x ** 2 + nc_y ** 2 + nc_z ** 2)
+    mc_ln = sqrt(mc_x ** 2 + mc_y ** 2 + mc_z ** 2)
+    sin1 = get_angle(m_x - n_x, m_y - n_y, m_z - n_z, nc_x, nc_y, nc_z)
+    sin2 = get_angle(n_x - m_x, n_y - m_y, n_z - m_z, mc_x, mc_y, mc_z)
+
+    if sin1 < .0001 or sin2 < .0001 or nc_ln < .0001 or mc_ln < .0001:
+        return
+    else:
+        coef1 = aromatic_space / (nc_ln * sin1)
+        coef2 = aromatic_space / (mc_ln * sin2)
+        return nc_x * coef1, nc_y * coef1, nc_z * coef1, mc_x * coef2, mc_y * coef2, mc_z * coef2
+
+
+def _render_dashes(nx, ny, nz, nmx, nmy, nmz, nm_ln, r_angle=None):
+    bond_radius = _render_config['bond_radius']
+    bond_color = _render_config['bond_color']
+
+    if r_angle is None:
+        dash1, dash2 = _render_config['aromatic_dashes']
+        r_angle = acos(nmy / nm_ln)
+    else:
+        dash1, dash2 = _render_config['dashes']
+
+    xml = []
+    dashes_sum = dash1 + dash2
+    if dashes_sum < .0001:
+        raise ValueError('Dashes should be nonzero')
+
+    d = dashes_sum / nm_ln
+    dx, dy, dz = nmx * d, nmy * d, nmz * d
+    b = int((nm_ln - dash1) // dashes_sum)
+    t = (nm_ln - (b * dashes_sum)) / nm_ln
+    nx, ny, nz = nx + nmx * t / 2, ny + nmy * t / 2, nz + nmz * t / 2
+    for _ in range(b):
+        xml.append(f"    <transform translation='{nx:.2f} {ny:.2f} {nz:.2f}' rotation='{nmz:.2f} 0 "
+                   f"{-nmx:.2f} {r_angle:.2f}'>\n      <shape>\n        <appearance>\n"
+                   f"          <material diffusecolor='{bond_color}'>\n          </material>\n"
+                   f"       </appearance>\n        <cylinder radius='{bond_radius}' height='{dash1:.2f}'>\n"
+                   "        </cylinder>\n      </shape>\n    </transform>\n")
+        nx += dx
+        ny += dy
+        nz += dz
+    xml.append(f"    <transform translation='{nx:.2f} {ny:.2f} {nz:.2f}' rotation='{nmz:.2f} 0 "
+               f"{-nmx:.2f} {r_angle:.2f}'>\n      <shape>\n        <appearance>\n"
+               f"          <material diffusecolor='{bond_color}'>\n          </material>\n"
+               f"       </appearance>\n        <cylinder radius='{bond_radius}' height='{dash1:.2f}'>\n"
+               "        </cylinder>\n      </shape>\n    </transform>\n")
+    return xml
+
+
+class X3domMolecule:
+    __slots__ = ()
+
+    def depict3d(self, index: int = 0) -> str:
+        """Get X3DOM XML string.
+
+        :param index: index of conformer
+        """
+        if not hasattr(self, '_conformers'):
+            raise ValueError('No conformers stored within structure')
+        try:
+            xyz = self._conformers[index]
+        except IndexError:
+            raise IndexError('Invalid conformer index')
+
+        mx = sum(x for x, _, _ in xyz.values()) / len(xyz)
+        my = sum(y for _, y, _ in xyz.values()) / len(xyz)
+        mz = sum(z for _, _, z in xyz.values()) / len(xyz)
+        xyz = {n: (x - mx, y - my, z - mz) for n, (x, y, z) in xyz.items()}
+        atoms = self.__render_atoms(xyz)
+        bonds = self.__render_bonds(xyz)
+        return f'<x3d width=100% height=100%>\n  <scene>\n{atoms}{bonds}  </scene>\n</x3d>'
+
+    def view3d(self, index: int = 0, width='600px', height='400px'):
+        """
+        Jupyter widget for 3D visualization.
+
+        :param index: index of conformer
+        :param width: widget width
+        :param height: widget height
+        """
+        return JupyterWidget(self.depict3d(index), width, height)
+
+    def __render_atoms(self, xyz):
+        font = _render_config['font_size']
+        carbon = _render_config['carbon']
+        radius = _render_config['atom_radius']
+        colors = _render_config['atoms_colors']
+        mapping_color = _render_config['mapping_color']
+
+        if radius < 0:
+            multiplier = -radius
+            radius = 0
+        elif not radius:
+            multiplier = .2
+
+        atoms = []
+        if carbon:
+            for n, a in self.atoms():
+                r = radius or a.atomic_radius * multiplier
+                fr = r * 0.71
+                atoms.append(f"    <transform translation='{' '.join(format(x, '.2f') for x in xyz[n])}'>\n"
+                             "      <billboard axisOfRotation='0 0 0'>\n        <group>\n"
+                             f"          <transform translation='{fr:.2f} {fr:.2f} 0'>\n"
+                             '            <shape>\n              <appearance>\n'
+                             f"                <material diffuseColor='{mapping_color}'/>\n"
+                             f"              </appearance>\n              <text string='{a.atomic_symbol}'>\n"
+                             f"                <fontstyle family='sans' size='{font:.2f}' justify='first'/>\n"
+                             "              </text>\n            </shape>\n          </transform>\n"
+                             "          <shape>\n            <appearance>\n"
+                             f"              <material diffuseColor='{colors[a.atomic_number - 1]}'/>\n"
+                             f"            </appearance>\n            <sphere radius='{r:.2f}'/>\n"
+                             "          </shape>\n        </group>\n      </billboard>\n    </transform>\n")
+        else:
+            for n, a in self.atoms():
+                r = radius or a.atomic_radius * multiplier
+                atoms.append(f"    <transform translation='{' '.join(format(x, '.2f') for x in xyz[n])}'>\n"
+                             "      <shape>\n        <appearance>\n"
+                             f"          <material diffuseColor='{colors[a.atomic_number - 1]}'/>\n"
+                             f"        </appearance>\n        <sphere radius='{r:.2f}'/>\n"
+                             "      </shape>\n    </transform>\n")
+        return ''.join(atoms)
+
+    def __render_bonds(self, xyz):
+        bonds = self._bonds
+
+        bond_color = _render_config['bond_color']
+        bond_radius = _render_config['bond_radius']
+        double_space = _render_config['double_space']
+        triple_space = _render_config['triple_space']
+        r1 = triple_space * sqrt(3) / 3
+        r2 = triple_space * sqrt(3) / 6
+
+        xml = []
+        lengths = {}
+        doubles = {}
+        half_triple = triple_space / 2
+        for n, m, bond in self.bonds():
+            nx, ny, nz = xyz[n]
+            mx, my, mz = xyz[m]
+
+            nmx, nmy, nmz = mx - nx, my - ny, mz - nz
+            length = sqrt(nmx ** 2 + nmy ** 2 + nmz ** 2)
+            if length < .001:
+                continue
+
+            rotation_angle = acos(nmy / length)
+            lengths[(n, m)] = lengths[(m, n)] = (length, rotation_angle)
+            x, y, z = nx + nmx / 2, ny + nmy / 2, nz + nmz / 2
+            if bond in (1, 4):
+                xml.append(f"    <transform translation='{x:.2f} {y:.2f} {z:.2f}' rotation='{nmz:.2f} 0 "
+                           f"{-nmx:.2f} {rotation_angle:.2f}'>\n      <shape>\n        <appearance>\n"
+                           f"          <material diffusecolor='{bond_color}'>\n          </material>\n"
+                           f"       </appearance>\n        <cylinder radius='{bond_radius}' height='{length:.2f}'>\n"
+                           "        </cylinder>\n      </shape>\n    </transform>\n")
+            elif bond == 2:
+                if n in doubles:
+                    # normal for plane n m o
+                    norm_x, norm_y, norm_z = plane_normal(nmx, nmy, nmz, *doubles[n])
+                elif m in doubles:
+                    # normal for plane n m o
+                    norm_x, norm_y, norm_z = plane_normal(nmx, nmy, nmz, *doubles[m])
+                else:
+                    third = next((x for x in bonds[n] if x != m), None)
+                    if third:
+                        ox, oy, oz = xyz[third]
+                        nox, noy, noz = ox - nx, oy - ny, oz - nz
+                    else:
+                        third = next((x for x in bonds[m] if x != n), None)
+                        if third:
+                            ox, oy, oz = xyz[third]
+                            nox, noy, noz = ox - nx, oy - ny, oz - nz
+                        else:
+                            nox, noy, noz = vector_normal(nmx, nmy, nmz)
+
+                    # normal for plane n m o
+                    normx, normy, normz = unit_vector(*plane_normal(nmx, nmy, nmz, nox, noy, noz))
+
+                    # normal for plane n m normal
+                    norm_x, norm_y, norm_z = plane_normal(nmx, nmy, nmz, normx, normy, normz)
+
+                doubles[n] = doubles[m] = (norm_x, norm_y, norm_z)
+                norm_dist = sqrt(norm_x ** 2 + norm_y ** 2 + norm_z ** 2)
+
+                if norm_dist < .0001:
+                    coef = double_space * 10000
+                else:
+                    coef = double_space / norm_dist
+
+                dx, dy, dz = norm_x * coef, norm_y * coef, norm_z * coef
+                xml.append(
+                    f"    <transform translation='{x + dx:.2f} {y + dy:.2f} {z + dz:.2f}' rotation='{nmz:.2f} 0 "
+                    f"{-nmx:.2f} {rotation_angle:.2f}'>\n      <shape>\n        <appearance>\n"
+                    f"          <material diffusecolor='{bond_color}'>\n          </material>\n"
+                    f"       </appearance>\n        <cylinder radius='{bond_radius}' height='{length:.2f}'>\n"
+                    "        </cylinder>\n      </shape>\n    </transform>\n")
+                xml.append(
+                    f"    <transform translation='{x - dx:.2f} {y - dy:.2f} {z - dz:.2f}' rotation='{nmz:.2f} 0 "
+                    f"{-nmx:.2f} {rotation_angle:.2f}'>\n      <shape>\n        <appearance>\n"
+                    f"          <material diffusecolor='{bond_color}'>\n          </material>\n"
+                    f"       </appearance>\n        <cylinder radius='{bond_radius}' height='{length:.2f}'>\n"
+                    "        </cylinder>\n      </shape>\n    </transform>\n")
+            elif bond == 3:
+                nox, noy, noz = vector_normal(nmx, nmy, nmz)
+
+                # normal for plane n m o
+                normx, normy, normz = unit_vector(*plane_normal(nmx, nmy, nmz, nox, noy, noz))
+                vecrx, vecry, vecrz = normx * r1, normy * r1, normz * r1
+
+                # normal for plane n m normal
+                norm_x, norm_y, norm_z = unit_vector(*plane_normal(nmx, nmy, nmz, normx, normy, normz))
+                vecx, vecy, vecz = norm_x * half_triple, norm_y * half_triple, norm_z * half_triple
+
+                xml.append(f"    <transform translation='{x + vecrx:.2f} {y + vecry:.2f} {z + vecrz:.2f}'"
+                           f" rotation='{nmz:.2f} 0 {-nmx:.2f} {rotation_angle:.2f}'>\n      <shape>\n"
+                           f"        <appearance>\n          <material diffusecolor='{bond_color}'>\n"
+                           f"          </material>\n       </appearance>\n        <cylinder radius='{bond_radius}'"
+                           f" height='{length:.2f}'>\n        </cylinder>\n      </shape>\n    </transform>\n")
+
+                xx, yy, zz = x - normx * r2, y - normy * r2, z - normz * r2
+                xml.append(f"    <transform translation='{xx - vecx:.2f} {yy - vecy:.2f} {zz - vecz:.2f}'"
+                           f" rotation='{nmz:.2f} 0 {-nmx:.2f} {rotation_angle:.2f}'>\n      <shape>\n"
+                           f"        <appearance>\n          <material diffusecolor='{bond_color}'>\n"
+                           f"          </material>\n       </appearance>\n        <cylinder radius='{bond_radius}'"
+                           f" height='{length:.2f}'>\n        </cylinder>\n      </shape>\n    </transform>\n")
+                xml.append(f"    <transform translation='{xx + vecx:.2f} {yy + vecy:.2f} {zz + vecz:.2f}'"
+                           f" rotation='{nmz:.2f} 0 {-nmx:.2f} {rotation_angle:.2f}'>\n      <shape>\n"
+                           f"        <appearance>\n          <material diffusecolor='{bond_color}'>\n"
+                           f"          </material>\n       </appearance>\n        <cylinder radius='{bond_radius}'"
+                           f" height='{length:.2f}'>\n        </cylinder>\n      </shape>\n    </transform>\n")
+            else:
+                xml.extend(_render_dashes(nx, ny, nz, nmx, nmy, nmz, length, r_angle=rotation_angle))
+
+        for ring in self.aromatic_rings:
+            cx = sum(xyz[n][0] for n in ring) / len(ring)
+            cy = sum(xyz[n][1] for n in ring) / len(ring)
+            cz = sum(xyz[n][2] for n in ring) / len(ring)
+
+            for n, m in zip(ring, ring[1:]):
+                nx, ny, nz = xyz[n]
+                mx, my, mz = xyz[m]
+
+                aromatic = _render_aromatic_bond(nx, ny, nz, mx, my, mz, cx, cy, cz)
+                if aromatic:
+                    veca_x, veca_y, veca_z, vecb_x, vecb_y, vecb_z = aromatic
+                    ax, ay, az = nx + veca_x, ny + veca_y, nz + veca_z
+                    abx, aby, abz = mx + vecb_x - ax, my + vecb_y - ay, mz + vecb_z - az
+                    ab_ln = sqrt(abx ** 2 + aby ** 2 + abz ** 2)
+                    if ab_ln < .0001:
+                        continue
+                    else:
+                        xml.extend(_render_dashes(ax, ay, az, abx, aby, abz, ab_ln))
+
+            i, j = ring[-1], ring[0]
+            nx, ny, nz = xyz[i]
+            mx, my, mz = xyz[j]
+            aromatic = _render_aromatic_bond(nx, ny, nz, mx, my, mz, cx, cy, cz)
+            if aromatic:
+                veca_x, veca_y, veca_z, vecb_x, vecb_y, vecb_z = aromatic
+                ax, ay, az = nx + veca_x, ny + veca_y, nz + veca_z
+                abx, aby, abz = mx + vecb_x - ax, my + vecb_y - ay, mz + vecb_z - az
+                ab_ln = sqrt(abx ** 2 + aby ** 2 + abz ** 2)
+                if ab_ln < .0001:
+                    continue
+                else:
+                    xml.extend(_render_dashes(ax, ay, az, abx, aby, abz, ab_ln))
+        return ''.join(xml)
+
+
+__all__ = ['X3domMolecule']

chython/containers/__init__.py

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2017-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 typing import Union
+from zlib import decompress
+from .bonds import *
+from .cgr import *
+from .molecule import *
+from .query import *
+from .reaction import *
+
+
+def unpach(data: bytes, /, *, compressed=True, skip_labels_calculation=False) -> Union[MoleculeContainer, ReactionContainer]:
+    if compressed:
+        data = decompress(data)
+    try:
+        return MoleculeContainer.unpack(data, compressed=False, skip_labels_calculation=skip_labels_calculation)
+    except ValueError:
+        pass
+    # second try
+    return ReactionContainer.unpack(data, compressed=False)
+
+
+def from_rdkit(mol, /):
+    return MoleculeContainer.from_rdkit(mol)
+
+
+unpack = unpach
+from_rdkit_molecule = from_rdkit
+
+
+__all__ = [x for x in locals() if x.endswith('Container')]
+__all__.extend(['Bond', 'QueryBond', 'unpack', 'unpach', 'from_rdkit', 'from_rdkit_molecule'])

chython/containers/_pack_v2.pyx

@@ -0,0 +1,271 @@
+# 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 ldexp, frexp
+from libc.string cimport memset
+
+# Format V2 specification::
+#
+# Big endian bytes order
+# 8 bit - 0x02 (current format specification)
+# 12 bit - number of atoms
+# 12 bit - cis/trans stereo block size
+#
+# Atom block 9 bytes (repeated):
+# 12 bit - atom number
+# 4 bit - number of neighbors
+# 2 bit tetrahedron sign (00 - not stereo, 10 or 11 - has stereo)
+# 2 bit - allene sign
+# 5 bit - isotope (00000 - not specified, over = isotope - common_isotope + 16)
+# 7 bit - atomic number (<=118)
+# 32 bit - XY float16 coordinates
+# 3 bit - hydrogens (0-7). Note: 7 == None
+# 4 bit - charge (charge + 4. possible range -4 - 4)
+# 1 bit - radical state
+# Connection table: flatten list of neighbors. neighbors count stored in atom block.
+# For example CC(=O)O - {1: [2], 2: [1, 3, 4], 3: [2], 4: [2]} >> [2, 1, 3, 4, 2, 2].
+# Repeated block (equal to bonds count).
+# 24 bit - paired 12 bit numbers.
+# Bonds order block 3 bit per bond zero-padded to full byte at the end.
+# Cis/trans data block (repeated):
+# 24 bit - atoms pair
+# 7 bit - zero padding. in future can be used for extra bond-level stereo, like atropoisomers.
+# 1 bit - sign
+
+
+@cython.nonecheck(False)
+@cython.boundscheck(False)
+@cython.cdivision(True)
+@cython.wraparound(False)
+def pack(object molecule):
+    cdef bint b = True # binary flag
+    cdef char charge
+    cdef unsigned char atomic_number, ngb_count, isotope, bond, s = 0, buffer_b, buffer_o, stereo, hcr
+    cdef unsigned char *data
+    cdef unsigned short atoms_count, bonds_count = 0, cis_trans_count, n, m, tn, tm
+    cdef unsigned int size, atoms_shift = 4, bonds_shift, order_shift, cis_trans_shift  # can be > 2^16
+    cdef unsigned char[4096] seen  # atom number is 12 bit, thus, can be any value up to 4095. numbers are not continuous
+
+    cdef bytes py_pack
+    cdef dict py_ngb, py_atoms, py_bonds, py_stereo
+    cdef tuple py_tuple
+    cdef object py_atom, py_bond, py_nan_int, py_obj
+
+    # map molecule to vars
+    py_atoms = molecule._atoms
+    py_bonds = molecule._bonds
+    py_stereo = molecule._stereo_cis_trans_terminals
+
+    # calculate elements count
+    atoms_count = len(py_atoms)
+    cis_trans_count = molecule._cis_trans_count
+
+    for py_ngb in py_bonds.values():
+        bonds_count += len(py_ngb)
+    bonds_count /= 2  # graph is bidirected
+
+    # calculate pack blocks entries
+    size = bonds_count * 3  # bonds bits
+    if size % 8:  # partial byte fill
+        size = size / 8 + 1
+    else:
+        size /= 8
+    bonds_shift = 4 + 9 * atoms_count  # connection table starting byte
+    order_shift = bonds_shift + 3 * bonds_count  # bond orders block starting byte
+    cis_trans_shift = size + order_shift  # cis-trans block starting byte
+    size = cis_trans_shift + 4 * cis_trans_count  # total pack size
+
+    # allocate pack in memory
+    data = <unsigned char *> PyMem_Malloc(size * sizeof(unsigned char))
+    if not data:
+        raise MemoryError()
+
+    memset(seen, 0, 4096 * sizeof(unsigned char))  # erase random data
+
+    # start pack collection
+    data[0] = 2  # header. specification version 2
+    data[1] = atoms_count >> 4  # 5-12b of atom count value
+    data[2] = atoms_count << 4 | cis_trans_count >> 8  # 1-4b of atom count value, 9-12b of cis-trans count value
+    data[3] = cis_trans_count  # 1-8b of cis-trans count value
+
+    for py_obj, py_atom in py_atoms.items():
+        py_ngb = py_bonds[py_obj]
+        ngb_count = len(py_ngb)
+        n = py_obj  # cast to C
+        seen[n] = 1
+        atomic_number = py_atom.atomic_number
+
+        py_nan_int = py_atom._isotope  # direct access
+        if py_nan_int is None:
+            isotope = 0
+        else:
+            isotope = <short> py_nan_int - common_isotopes[atomic_number]
+
+        py_nan_int = py_atom._stereo
+        if py_nan_int is None:
+            stereo = 0
+        # V2 specification
+        # 2 bit tetrahedron | 2 bit allene | 0000
+        elif py_nan_int:
+            if ngb_count == 2:  # allene
+                stereo = 0x30
+            else:
+                stereo = 0xc0
+        else:
+            if ngb_count == 2:  # allene
+                stereo = 0x20
+            else:
+                stereo = 0x80
+
+        # precalculate atom attrs
+        # should be done independently, due to possible randomness in dicts order.
+        # 3 bit - hydrogens (0-7) | 4 bit - charge | 1 bit - radical
+        py_nan_int = py_atom._implicit_hydrogens
+        if py_nan_int is None:
+            hcr = 0xe0  # 0b11100000
+        else:
+            hcr = <unsigned char> py_nan_int << 5
+
+        charge = py_atom._charge
+        hcr |= (charge + 4) << 1
+        if py_atom._is_radical:
+            hcr |= 1
+
+        data[atoms_shift] = n >> 4  # 5-12b AN
+        data[atoms_shift + 1] = n << 4 | ngb_count  # 1-4b AN, 4b NC
+        data[atoms_shift + 2] = stereo | isotope >> 1  # TS , AS , 4b I
+        data[atoms_shift + 3] = isotope << 7 | atomic_number  # 1bI , A
+
+        # 2 float16 big endian
+        double_to_float16(py_atom.x, &data[atoms_shift + 4])
+        double_to_float16(py_atom.y, &data[atoms_shift + 6])
+
+        data[atoms_shift + 8] = hcr
+        atoms_shift += 9
+
+        # collect connection table
+        for m, py_bond in py_ngb.items():
+            if b:  # 8 + 4
+                data[bonds_shift] = m >> 4
+                bonds_shift += 1
+                buffer_b = m << 4
+                b = False  # switch
+            else:  # 4 + 8
+                data[bonds_shift] = buffer_b | m >> 8
+                bonds_shift += 1
+                data[bonds_shift] = m
+                bonds_shift += 1  # next free 3 bytes block
+                b = True
+
+            if not seen[m]:
+                bond = <unsigned char> py_bond._order - 1
+                # 3 3 2 | 1 3 3 1 | 2 3 3
+                if s == 0:
+                    buffer_o = bond << 5
+                    s = 1
+                elif s == 1:
+                    buffer_o |= bond << 2
+                    s = 2
+                elif s == 2:
+                    data[order_shift] = buffer_o | bond >> 1
+                    order_shift += 1
+                    buffer_o = bond << 7
+                    s = 3
+                elif s == 3:
+                    buffer_o |= bond << 4
+                    s = 4
+                elif s == 4:
+                    buffer_o |= bond << 1
+                    s = 5
+                elif s == 5:
+                    data[order_shift] = buffer_o | bond >> 2
+                    order_shift += 1
+                    buffer_o = bond << 6
+                    s = 6
+                elif s == 6:
+                    buffer_o |= bond << 3
+                    s = 7
+                else:  # 7
+                    data[order_shift] = buffer_o | bond
+                    order_shift += 1
+                    s = 0
+
+                py_nan_int = py_bond._stereo
+                if py_nan_int is not None:
+                    py_tuple = py_stereo[py_obj]
+                    tn, tm = py_tuple
+                    data[cis_trans_shift] = tn >> 4
+                    data[cis_trans_shift + 1] = tn << 4 | tm >> 8
+                    data[cis_trans_shift + 2] = tm
+                    data[cis_trans_shift + 3] = py_nan_int
+                    cis_trans_shift += 4
+
+    if s:  # flush buffer
+        data[order_shift] = buffer_o
+
+    try:
+        py_pack = data[:size]
+    finally:
+        PyMem_Free(data)
+    return py_pack
+
+
+cdef short[119] common_isotopes
+common_isotopes[:] = [0, -15, -12, -9, -7, -5, -4, -2, 0, 3, 4, 7, 8, 11, 12, 15, 16, 19, 24, 23, 24, 29,
+                      32, 35, 36, 39, 40, 43, 43, 48, 49, 54, 57, 59, 63, 64, 68, 69, 72, 73, 75, 77,
+                      80, 82, 85, 87, 90, 92, 96, 99, 103, 106, 112, 111, 115, 117, 121, 123, 124, 125,
+                      128, 129, 134, 136, 141, 143, 147, 149, 151, 153, 157, 159, 162, 165, 168, 170,
+                      174, 176, 179, 181, 185, 188, 191, 193, 193, 194, 206, 207, 210, 211, 216, 215,
+                      222, 221, 228, 227, 231, 231, 235, 236, 241, 242, 243, 244, 245, 254, 253, 254,
+                      254, 262, 265, 265, 269, 262, 273, 273, 277, 281, 278]
+
+
+cdef void double_to_float16(double x, unsigned char* p):
+    # adopted from cpython source code
+    cdef unsigned char sign
+    cdef int e
+    cdef double f
+    cdef unsigned short bits
+
+    if x == 0.:
+        p[0] = p[1] = 0
+        return
+
+    sign = x < 0.
+    if sign:
+        x = -x
+    f = frexp(x, &e)
+    e -= 1
+    if f < .5 or f >= 1. or e >= 16 or e < -25:
+        p[0] = p[1] = 0
+        return  # ignore big values
+
+    f *= 2.0
+    if e < -14:
+        f = ldexp(f, 14 + e)
+        e = 0
+    else:
+        e += 15
+        f -= 1.
+
+    f *= 1024.
+    bits = <unsigned short> f | (e << 10) | (sign << 15)
+    p[0] = bits >> 8
+    p[1] = bits