c2ImageD11 0.2.1__py2-none-win_amd64.whl

c2ImageD11/__init__.py

@@ -0,0 +1,136 @@
+"""
+c2ImageD11 - compiled C extensions for ImageD11, built with c2py23.
+
+Provides:
+  - All C functions re-exported from the arch-named .so
+  - Blob property constants (s_1, s_I, NPROPERTY, etc.)
+  - Allocation wrappers for f2py-compatible tuple returns
+  - __version__
+"""
+
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+__version__ = "0.2.1"
+
+import os
+import platform
+import sys
+import warnings
+
+# ---------------------------------------------------------------------------
+# Arch-aware .so loader
+#
+# The .so files in this directory follow the naming convention:
+#   _cImageD11_{arch}.so   (Linux)
+#   _cImageD11_{arch}.pyd  (Windows)
+#
+# Where {arch} matches platform.machine() output:
+#   x86_64, aarch64, ppc64le, AMD64 (Windows), arm64 (Windows)
+#
+# The same binary works across Python 2.7-3.14 because c2py23 emits both
+# init_cImageD11 (Py2) and PyInit__cImageD11 (Py3) entry points.
+# ---------------------------------------------------------------------------
+
+_here = os.path.dirname(__file__)
+_arch = platform.machine()
+_ext = ".pyd" if sys.platform == "win32" else ".so"
+_lib_name = "_cImageD11_{}{}".format(_arch, _ext)
+_lib_path = os.path.join(_here, _lib_name)
+
+# Fallback: plain name _cImageD11.so (no arch suffix)
+if not os.path.exists(_lib_path):
+    _lib_path = os.path.join(_here, "_cImageD11" + _ext)
+
+if not os.path.exists(_lib_path):
+    # .so not built yet (e.g. during setuptools metadata reading).
+    # __version__ is still available; C functions will not be.
+    _mod = None
+else:
+    if sys.version_info[0] >= 3:
+        import importlib.util
+        _spec = importlib.util.spec_from_file_location(
+            "c2ImageD11._cImageD11", _lib_path)
+        _mod = importlib.util.module_from_spec(_spec)
+        sys.modules["c2ImageD11._cImageD11"] = _mod
+        _spec.loader.exec_module(_mod)
+    else:
+        import imp
+        _mod = imp.load_dynamic("c2ImageD11._cImageD11", _lib_path)
+
+if _mod is not None:
+    # Make _cImageD11 importable as c2ImageD11._cImageD11
+    sys.modules[__name__]._cImageD11 = _mod
+
+    # Re-export all non-private names from the loaded module
+    for _k in dir(_mod):
+        if not _k.startswith("_"):
+            globals()[_k] = getattr(_mod, _k)
+
+
+    _blobproperties_c = _mod.blobproperties  # save raw C function
+
+    def blobproperties(data, labels, npk, omega=0.0, verbose=0):
+        """Allocate results and call C blobproperties, matching f2py convention."""
+        import numpy as np
+        results = np.zeros((npk, 36), dtype=np.float64)
+        _blobproperties_c(data, labels, npk, results, omega, verbose)
+        return results
+
+    _sparse_blob2Dproperties_c = _mod.sparse_blob2Dproperties
+
+    def sparse_blob2Dproperties(v, i, j, labels, npk):
+        """Allocate results and call C sparse_blob2Dproperties, matching f2py convention."""
+        import numpy as np
+        results = np.zeros((npk, 11), dtype=np.float64)
+        _sparse_blob2Dproperties_c(v, i, j, labels, npk, results)
+        return results
+
+    # Replace raw C functions on submodule with allocation wrappers
+    _mod.blobproperties = blobproperties
+    _mod.sparse_blob2Dproperties = sparse_blob2Dproperties
+
+
+    # -----------------------------------------------------------------------
+    # OpenMP safety
+    # -----------------------------------------------------------------------
+
+    def _check_multiprocessing(patch=False):
+        """Warn about fork+threads interaction with OpenMP.
+
+        You cannot safely use os.fork together with threads.
+        But the cImageD11 codes uses threads via openmp, and you are importing them.
+        So please use forkserver or spawn for multiprocessing.
+        """
+        if not hasattr(os, "fork"):
+            return
+        import multiprocessing
+        if not hasattr(multiprocessing, "get_start_method"):
+            warnings.warn(
+                "python2.7 with c2ImageD11: for multiprocessing use spawn\n"
+            )
+            return
+        method = multiprocessing.get_start_method(allow_none=True)
+        if method == "fork":
+            warnings.warn(_check_multiprocessing.__doc__)
+        parent = None
+        if hasattr(multiprocessing, "parent_process"):
+            parent = multiprocessing.parent_process()
+            if parent is not None:
+                if "OMP_NUM_THREADS" not in os.environ:
+                    cimaged11_omp_set_num_threads(1)
+
+
+    check_multiprocessing = _check_multiprocessing  # public alias (f2py compat)
+
+    if cimaged11_omp_get_max_threads() == 0:
+        OPENMP = False
+    else:
+        OPENMP = True
+        _check_multiprocessing()
+
+
+    # -----------------------------------------------------------------------
+    # Sanity check
+    # -----------------------------------------------------------------------
+
+    assert verify_rounding(20) == 0, "Problem with cImageD11 fast rounding code"

c2imaged11-0.2.1.dist-info/METADATA

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: c2ImageD11
+Version: 0.2.1
+Summary: C extensions for ImageD11 (c2py23 binding)
+Author-email: Jon Wright <wright@esrf.fr>
+Project-URL: Homepage, https://github.com/jonwright/c2ImageD11
+Project-URL: Source, https://github.com/jonwright/c2ImageD11
+Project-URL: Bug tracker, https://github.com/jonwright/c2ImageD11/issues
+Keywords: imageD11,diffraction,xray,crystallography
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: C
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Requires-Python: >=2.7
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+
+# c2ImageD11
+
+> All code in this repository was generated by [DeepSeek V4](https://deepseek.com)
+> and other large language models, in collaboration with jonwright.
+
+Standalone C extensions for ImageD11, ported from f2py to **c2py23**.
+C functions are exposed by a generated CPython extension wrapper.
+Two functions (`blobproperties`, `sparse_blob2Dproperties`) have thin
+Python allocation wrappers in `__init__.py` to match f2py's convention
+of auto-allocating output arrays.
+
+## Build
+
+A normal build needs only meson + ninja + a C compiler.  The generated
+files in `lib/interface/` are checked into git, so c2py23 is **not**
+required.
+
+```bash
+mkdir -p build/libc2ImageD11
+cd build/libc2ImageD11
+meson setup ../../lib
+ninja
+cp _cImageD11.so ../../c2ImageD11/
+```
+
+## Regenerate `lib/interface/`
+
+Run this when C2PY_BLOCKs change or c2py23 is updated (requires c2py23):
+
+```bash
+python3 tools/harvester.py --output-dir lib/interface
+```
+
+## Test
+
+```bash
+python3 -m pytest tests/
+```
+
+## Distributing
+
+Copy `_cImageD11.so` into `c2ImageD11/` and the package is ready --
+same pattern as a ctypes library.

c2imaged11-0.2.1.dist-info/RECORD

@@ -0,0 +1,6 @@
+c2ImageD11/__init__.py,sha256=ybxdyUGoxXdo_USrawgibdoSSqTRTtCVcT3RItedyc0,5028
+c2ImageD11/_cImageD11_AMD64.pyd,sha256=kODIkD6BnHYjNuzuPFf3JjuxUf2ElHKdFVSqoukO_cI,535552
+c2imaged11-0.2.1.dist-info/METADATA,sha256=afrGQ40CwudLhQNGHcg9HalikchC0Ic4NkOR-nZUdBo,2080
+c2imaged11-0.2.1.dist-info/WHEEL,sha256=E7_2keCVFfKMIq0kiQu-iEup9Yz5uqe35RtC3nD1cQg,98
+c2imaged11-0.2.1.dist-info/top_level.txt,sha256=Zisg4zXBajKHAbtdPf0ik4OXFXJvGCq7GfSjomZw478,11
+c2imaged11-0.2.1.dist-info/RECORD,,

c2imaged11-0.2.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: false
+Tag: py2-none-win_amd64
+

c2imaged11-0.2.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+c2ImageD11