chython 3.0__tar.gz → 3.0.1__tar.gz

{chython-3.0/chython.egg-info → chython-3.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chython
-Version: 3.0
+Version: 3.0.1
 Summary: Library for processing molecules and reactions in python way
 Author-email: Ramil Nugmanov <nougmanoff@protonmail.com>
 License-Expression: LGPL-3.0-or-later

{chython-3.0 → chython-3.0.1}/build_inchi.py

@@ -63,6 +63,12 @@ def cmake_args() -> list[str]:
     * ``-fsigned-char`` -- plain `char` is unsigned on Linux ARM.  `setup.py` compiles the extension
       with the flag for the same reason, and InChI's own gcc option set lists it; its public types are
       `S_CHAR`, spelled `signed char`, so the flag is about the library's internal bare `char`.
+    * ``CMAKE_SHARED_LINKER_FLAGS=-Wl,-s`` on Linux -- ``INCHI_API/libinchi/src/CMakeLists.txt`` gives
+      gcc-like compilers ``-g;-O1`` through ``target_compile_options``, which lands after
+      ``CMAKE_C_FLAGS`` and after the ``Release`` config's own flags, so neither ``CMAKE_BUILD_TYPE``
+      nor a ``-g0`` above can cancel it.  A link-time strip can: measured on 3.0's Linux wheel,
+      ``.debug*`` was 3.05 MB of a 4.36 MB ``libinchi.so`` whose ``.text`` is 1.00 MB.  Linux only --
+      ld64 deprecates ``-s`` and the linked Mach-O carries no DWARF to begin with.
     * ``CMAKE_OSX_ARCHITECTURES`` -- a universal2 interpreter needs both slices, or InChI is absent on
       the arch the dylib lacks while `import chython` still succeeds and every InChI test skips.
     * ``CMAKE_OSX_DEPLOYMENT_TARGET`` -- ``wheel``'s ``calculate_macosx_platform_tag`` raises the
@@ -78,6 +84,8 @@ def cmake_args() -> list[str]:
     if platform.startswith('win'):
         return []                                       # MSVC's `char` is signed and the rest is mac
     args = ['-DCMAKE_C_FLAGS=-fsigned-char']
+    if platform.startswith('linux'):
+        args.append('-DCMAKE_SHARED_LINKER_FLAGS=-Wl,-s')
     parts = platform.split('-')
     if platform.startswith('macosx') and len(parts) == 3:
         _, target, arch = parts

{chython-3.0 → chython-3.0.1}/chython/test/test_libinchi_staging.py

@@ -44,8 +44,15 @@ the suite's `needs_inchi` marks skip.  Every assertion is therefore about declar
 build output that is checked only if build output exists.
 """
 from ast import Call, Constant, Dict, Name, parse, walk
+from os import environ
 from pathlib import Path
+from platform import system
+from pytest import skip
 from re import DOTALL, finditer, search
+from subprocess import check_output
+from sys import executable
+from tempfile import TemporaryDirectory
+from textwrap import dedent
 
 
 ROOT = Path(__file__).resolve().parent.parent.parent
@@ -105,6 +112,56 @@ def _workflow():
     return '\n'.join(line for line in text.splitlines() if not line.lstrip().startswith('#'))
 
 
+def _retag_probe():
+    """The Linux retag step's shell, dedented as YAML hands it to bash, minus its two effects.
+
+    `pip install` and the `wheel tags` call are dropped by name -- and asserted present, so a rename
+    cannot turn this into a probe of nothing -- which leaves the tag COMPUTATION, side-effect free and
+    runnable here.  The step's own `echo` is what reports the answer, in this probe and in the CI log.
+    """
+    step = search(r'- name: Retag[^\n]*\n(.*?)(?=\n    - name:|\Z)', _workflow(), DOTALL)
+    assert step, 'the release workflow has no Retag step'
+    body = search(r'run: \|\n(.*)', step.group(1), DOTALL)
+    assert body, 'the Retag step has no `run:` block'
+    script = dedent(body.group(1))
+    assert 'python -m wheel tags' in script or 'auditwheel' in script, \
+        'no retag or repair step for Linux: setuptools emits linux_x86_64 and PyPI rejects it'
+    assert 'pip install --upgrade wheel' in script and 'dist/*.whl' in script, \
+        'the retag step no longer installs wheel, or no longer retags dist/*.whl'
+    return '\n'.join(line for line in script.splitlines()
+                     if 'pip install' not in line and 'dist/*.whl' not in line)
+
+
+def _run_probe(*, tags=None):
+    """Run the probe under bash and return the platform tag it chose.
+
+    `python` is shimmed onto PATH because that is the name the workflow uses and a developer's machine
+    need not have it.  `tags` replaces `packaging.tags` with a stub yielding exactly those platforms.
+
+    POSIX only: the shim is a symlink with no `.exe`, which Git Bash cannot exec, and PATH there is
+    `;`-joined.  Nothing is lost -- the step this probes carries `if: runner.os == 'Linux'`.
+    """
+    if system() == 'Windows':
+        skip('the retag step is Linux-only and this probe shims `python` the POSIX way')
+    with TemporaryDirectory() as tmp:
+        tmp = Path(tmp)
+        (tmp / 'bin').mkdir()
+        (tmp / 'bin' / 'python').symlink_to(executable)
+        env = {**environ, 'PATH': '%s:%s' % (tmp / 'bin', environ['PATH'])}
+        if tags is not None:
+            (tmp / 'packaging').mkdir()
+            (tmp / 'packaging' / '__init__.py').write_text('')
+            (tmp / 'packaging' / 'tags.py').write_text(
+                'class Tag:\n'
+                '    def __init__(self, platform):\n'
+                '        self.platform = platform\n'
+                '\n'
+                'def sys_tags():\n'
+                '    return [Tag(p) for p in %r]\n' % (tuple(tags),), encoding='utf-8')
+            env['PYTHONPATH'] = str(tmp)
+        return check_output(['bash', '-e'], input=_retag_probe(), text=True, env=env).split()[-1]
+
+
 # --- the mechanism ---------------------------------------------------------------------------------
 
 def test_libinchi_is_not_package_data():
@@ -195,19 +252,31 @@ def test_the_workflow_builds_with_the_declared_backend():
     assert 'python -m build' in text, 'the workflow has no PEP 517 build step'
 
 
-def test_the_linux_wheel_is_retagged_for_manylinux():
-    """setuptools tags Linux wheels `linux_x86_64`, which PyPI rejects; poetry-core did not.
+def test_the_linux_wheel_is_retagged_by_prefix_and_not_by_the_first_tag_offered():
+    """The step's tag is RUN here, because a step that names `manylinux` need not compute one.
 
-    2.24 published `manylinux_2_39_*` with no repair step because poetry-core took its platform tag from
-    `packaging.tags`.  `bdist_wheel` does not, so the backend migration silently removed the only reason
-    the Linux uploads worked -- a failure that appears at `twine upload`, on Linux only, during a
-    release.
+    `sys_tags()` is ordered best-first, and since packaging 26.3 the best Linux tag is the native
+    `linux_x86_64` rather than a manylinux one (packaging #160).  So `next(iter(sys_tags())).platform`
+    returns the tag PyPI rejects, `wheel tags --platform-tag linux_x86_64` renames nothing, and the step
+    reports success -- the whole failure being one line of the log reading `retagging as linux_x86_64`.
+    The stub is that ordering; the assertion is that the highest manylinux tag is picked out of it.
     """
-    text = _workflow()
-    assert 'wheel tags' in text or 'auditwheel' in text, \
-        'no retag or repair step for Linux: setuptools emits linux_x86_64 and PyPI rejects it'
-    assert 'sys_tags' in text or 'manylinux' in text, \
-        'the retag step does not name a manylinux tag or compute one'
+    assert _run_probe(tags=('linux_x86_64', 'manylinux_2_39_x86_64', 'manylinux_2_5_x86_64')) == \
+        'manylinux_2_39_x86_64', 'the retag step takes the first tag `sys_tags()` offers, which on Linux ' \
+        'is the bare `linux_x86_64` PyPI rejects; select the tag by its `manylinux` prefix instead'
+
+
+def test_the_retag_step_finds_a_manylinux_tag_on_the_platform_it_runs_on():
+    """The same computation against the real `packaging`, which is what the stub above stands in for.
+
+    Linux only: this is the platform the step has an `if` for, and the one every other wheel in the
+    matrix is already tagged correctly on.
+    """
+    if system() != 'Linux':
+        skip('the retag step runs on Linux only')
+    tag = _run_probe()
+    assert tag.startswith('manylinux'), \
+        'the retag step computes %r on this runner; PyPI rejects it and twine fails the release' % tag
 
 
 # --- the staging itself, when there is build output to look at -------------------------------------

{chython-3.0 → chython-3.0.1}/chython/test/test_release_build.py

@@ -45,6 +45,7 @@ from ast import Assign, Constant, List, Name, parse, walk
 from importlib.util import module_from_spec, spec_from_file_location
 from pathlib import Path
 from re import M, finditer
+from struct import unpack_from
 
 
 ROOT = Path(__file__).resolve().parent.parent.parent
@@ -53,6 +54,13 @@ ROOT = Path(__file__).resolve().parent.parent.parent
 # both take it; MSVC's default is already signed and its switch (`/J`) is the opposite one.
 SIGNED_CHAR = '-fsigned-char'
 
+# The two that keep DWARF out of the Linux wheel: `-g0` cancels the `-g` distutils inherits from
+# CPython's `CFLAGS`, and the link-time strip is the only thing that reaches the `-g` InChI's own
+# CMakeLists gives gcc.  Neither has a macOS or MSVC counterpart -- those toolchains put debug info in a
+# `.dSYM` and a `.pdb`, outside the wheel either way.
+NO_DEBUG_INFO = '-g0'
+STRIP = '-Wl,-s'
+
 
 def _build_inchi():
     """The builder module, loaded from the repo root by path.
@@ -166,7 +174,8 @@ def test_the_linux_build_is_told_nothing_about_architectures():
     not something this file expresses."""
     module = _build_inchi()
     module.get_platform = lambda: 'linux-aarch64'
-    assert module.cmake_args() == ['-DCMAKE_C_FLAGS=%s' % SIGNED_CHAR], module.cmake_args()
+    assert module.cmake_args() == ['-DCMAKE_C_FLAGS=%s' % SIGNED_CHAR, '-DCMAKE_SHARED_LINKER_FLAGS=%s' % STRIP], \
+        module.cmake_args()
 
 
 def test_the_libinchi_job_pins_the_interpreter_it_reads_the_platform_from():
@@ -182,6 +191,84 @@ def test_the_libinchi_job_pins_the_interpreter_it_reads_the_platform_from():
         'every wheel carrying this dylib.')
 
 
+# --- debug info stays out of the wheel -------------------------------------------------------------
+
+def test_the_linux_extension_asks_for_no_debug_info():
+    """distutils compiles an extension with CPython's own `CFLAGS`, and those carry `-g`.
+
+    Measured on 3.0's cp312 Linux wheel: `.debug*` was 17.50 MB of a 20.82 MB `_core.so` whose `.text` is
+    2.52 MB, against a 2.18 MB `.pyd` for the same code on Windows.  These flags are appended after
+    CPython's and gcc takes the last of `-g`/`-g0`, which is what lets a flag here cancel one from there.
+    """
+    linux = [flags for flags in _extra_compile_args() if '-O3' in flags]
+    assert len(linux) == 1, \
+        'setup.py no longer has exactly one -O3 branch, so the Linux branch is not identifiable here'
+    assert NO_DEBUG_INFO in linux[0], (
+        'the Linux extension is compiled without %s, so the `-g` in CPython\'s CFLAGS stands and the '
+        'wheel ships DWARF -- 84%% of `_core.so` when this was last measured' % NO_DEBUG_INFO)
+
+
+def test_libinchi_is_stripped_at_link_time_on_linux_and_nowhere_else():
+    """`CMAKE_BUILD_TYPE=Release` does not remove InChI's `-g`, because InChI's own CMakeLists adds it.
+
+    `INCHI_API/libinchi/src/CMakeLists.txt` gives gcc-like compilers `-g;-O1` through
+    `target_compile_options`, which lands after both `CMAKE_C_FLAGS` and the config's flags -- so a `-g0`
+    passed in cannot win and only a link-time strip reaches it.  3.05 MB of a 4.36 MB `libinchi.so`.
+    """
+    module = _build_inchi()
+    for platform, wanted in (('linux-x86_64', True), ('linux-aarch64', True),
+                             ('macosx-10.9-universal2', False), ('macosx-11.0-arm64', False),
+                             ('win-amd64', False)):
+        module.get_platform = lambda p=platform: p
+        stripping = any(STRIP in flag for flag in module.cmake_args())
+        assert stripping is wanted, (
+            '%s: cmake_args() %s the link-time strip.  Without it on Linux libinchi carries 3 MB of '
+            'DWARF into every wheel; with it on macOS, ld64 deprecates `-s` and the linked Mach-O has no '
+            'DWARF to remove.' % (platform, 'lacks' if wanted else 'should not pass'))
+
+
+def _elf_debug_bytes(data):
+    """(total, `.debug*` bytes) for an ELF image, or None when it is not one.
+
+    `struct` and not `readelf`: the property is worth checking on any Linux row of the test matrix, and a
+    binutils dependency would make it skip instead.
+    """
+    if data[:4] != b'\x7fELF' or data[4] != 2:            # ELF64 only; nothing here builds 32-bit
+        return None
+    shoff, = unpack_from('<Q', data, 0x28)
+    shentsize, shnum, shstrndx = unpack_from('<HHH', data, 0x3a)
+    names = unpack_from('<Q', data, shoff + shstrndx * shentsize + 24)[0]
+    debug = 0
+    for i in range(shnum):
+        offset, = unpack_from('<I', data, shoff + i * shentsize)
+        name = data[names + offset:data.index(b'\0', names + offset)]
+        if name.startswith(b'.debug'):
+            debug += unpack_from('<Q', data, shoff + i * shentsize + 32)[0]
+    return len(data), debug
+
+
+def test_a_built_linux_binary_carries_no_dwarf():
+    """The property the two flags above are for, against build output whenever there is some.
+
+    Vacuous off Linux and on a checkout nobody has built -- said out loud, because a silent pass for a
+    structural reason is what the declarations above are the guard against.  This is the assertion that
+    would survive a gcc that ignored `-g0` or a cmake that dropped the linker flag.
+    """
+    offenders = []
+    for path in [*(ROOT / 'chython' / 'core').glob('_core*.so'), ROOT / 'build' / 'inchi' / 'libinchi.so']:
+        if not path.exists():
+            continue
+        measured = _elf_debug_bytes(path.read_bytes())
+        if measured and measured[1]:
+            offenders.append('%s: %.2f MB of %.2f MB is .debug*'
+                             % (path.name, measured[1] / 1048576, measured[0] / 1048576))
+    assert not offenders, (
+        'these binaries would ship their debug info inside the wheel:\n  %s\n'
+        'The extension takes `%s` from setup.py and libinchi takes `%s` from build_inchi.py; a build '
+        'that predates either needs redoing before it is measured.' % ('\n  '.join(offenders),
+                                                                      NO_DEBUG_INFO, STRIP))
+
+
 # --- the source distribution -----------------------------------------------------------------------
 
 def test_the_release_publishes_a_source_distribution():

{chython-3.0 → chython-3.0.1/chython.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chython
-Version: 3.0
+Version: 3.0.1
 Summary: Library for processing molecules and reactions in python way
 Author-email: Ramil Nugmanov <nougmanoff@protonmail.com>
 License-Expression: LGPL-3.0-or-later

{chython-3.0 → chython-3.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = 'setuptools.build_meta'
 
 [project]
 name = 'chython'
-version = '3.0'
+version = '3.0.1'
 description = 'Library for processing molecules and reactions in python way'
 authors = [{name = 'Ramil Nugmanov', email = 'nougmanoff@protonmail.com'}]
 license = 'LGPL-3.0-or-later'

{chython-3.0 → chython-3.0.1}/setup.py

@@ -56,11 +56,18 @@ from build_inchi import build as build_libinchi, libname_for_platform  # noqa: E
 # is what makes the arm wheel the same program as the one the tests ran against; it is a no-op on
 # x86-64, which is why it is not conditional within Linux.  MSVC needs nothing (its default is signed;
 # `/J` is the opposite switch), and the InChI build gets the same flag from `build_inchi.py`.
+#
+# `-g0` ON LINUX ONLY, because distutils compiles an extension with CPython's own `CFLAGS` and those
+# carry `-g`: measured on 3.0's cp312 wheel, `.debug*` was 17.50 MB of a 20.82 MB `_core.so` whose
+# `.text` is 2.52 MB.  These flags are appended after CPython's and gcc takes the last of `-g`/`-g0`,
+# which is what makes a flag here able to cancel one from there.  `.symtab` is not debug info and
+# survives, so a C-level backtrace keeps its function names.  Nothing to do on the other two: clang
+# leaves DWARF in the `.o` files and emits a `.dSYM` only when asked, and MSVC writes a separate `.pdb`.
 platform = get_platform()
 if platform == 'win-amd64':
     extra_compile_args = ['/O2']
 elif platform.startswith('linux'):
-    extra_compile_args = ['-O3', '-fsigned-char']
+    extra_compile_args = ['-O3', '-g0', '-fsigned-char']
 else:
     extra_compile_args = ['-fsigned-char']