sciforge-build 2026.6.8__tar.gz

sciforge_build-2026.6.8/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: sciforge-build
+Version: 2026.6.8
+Summary: Build-time C++ binding-substrate headers for the SciForge ecosystem (never a runtime dependency).
+Project-URL: Homepage, https://github.com/RECHE23/sciforge
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# sciforge-build
+
+Build-time distribution of the SciForge C++ **binding substrate** headers
+(`<sciforge/binding/...>`). It is **never a runtime dependency** — list it in your
+`build-system.requires` and add `sciforge_build.get_include()` to your extension's
+`include_dirs` at wheel-build time. Pure-Python (`py3-none-any`); CalVer, aligned with
+the SciForge tag.

sciforge_build-2026.6.8/README.md

@@ -0,0 +1,7 @@
+# sciforge-build
+
+Build-time distribution of the SciForge C++ **binding substrate** headers
+(`<sciforge/binding/...>`). It is **never a runtime dependency** — list it in your
+`build-system.requires` and add `sciforge_build.get_include()` to your extension's
+`include_dirs` at wheel-build time. Pure-Python (`py3-none-any`); CalVer, aligned with
+the SciForge tag.

sciforge_build-2026.6.8/pyproject.toml

@@ -0,0 +1,26 @@
+# sciforge-build — BUILD-TIME-ONLY distribution of the SciForge C++ binding-substrate
+# headers (<sciforge/binding/...>). It is NEVER a runtime dependency: a consumer lists
+# it in build-system.requires and adds sciforge_build.get_include() to its extension's
+# include_dirs at wheel-build time. Pure-Python, py3-none-any (built with
+# `python -m build`, not cibuildwheel). CalVer, aligned with the SciForge tag.
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sciforge-build"
+version = "2026.6.8"
+description = "Build-time C++ binding-substrate headers for the SciForge ecosystem (never a runtime dependency)."
+requires-python = ">=3.8"
+readme = "README.md"
+
+[project.urls]
+Homepage = "https://github.com/RECHE23/sciforge"
+
+[tool.setuptools]
+packages = ["sciforge_build"]
+
+[tool.setuptools.package-data]
+# The headers are vendored into the package by setup.py (copied from the repo's
+# canonical include/) so the wheel + sdist are self-contained and build off-sibling.
+sciforge_build = ["include/sciforge/binding/*.hpp"]

sciforge_build-2026.6.8/sciforge_build/__init__.py

@@ -0,0 +1,22 @@
+"""Build-time access to the SciForge C++ binding-substrate headers.
+
+Usage (in a consumer's setup.py):
+
+    import sciforge_build
+    Extension(..., include_dirs=[sciforge_build.get_include()])
+
+so that `#include <sciforge/binding/error.hpp>` resolves at wheel-build time. This
+package is never a runtime dependency.
+"""
+import os
+
+__all__ = ["get_include"]
+
+
+def get_include() -> str:
+    """Return the directory to put on a C/C++ extension's include path.
+
+    The returned path carries the ``sciforge/binding/`` header tree, so
+    ``#include <sciforge/binding/error.hpp>`` resolves against it.
+    """
+    return os.path.join(os.path.dirname(os.path.abspath(__file__)), "include")

sciforge_build-2026.6.8/sciforge_build/include/sciforge/binding/error.hpp

@@ -0,0 +1,63 @@
+// SciForge binding substrate — error bridge (Limited-API, abi3-safe).
+//
+// One place for the C++ -> Python exception bridge every ecosystem binding needs:
+// no C++ exception is allowed to cross the C-API. Parameterized by the module's
+// error type so each binding keeps its own exception class (e.g. real.error).
+//
+// Uses only Py_LIMITED_API functions (PyErr_NoMemory / PyErr_SetString /
+// PyErr_NewException / PyModule_AddObjectRef), so it compiles into one abi3 wheel
+// per platform (cp310+). The consumer defines Py_LIMITED_API before including this.
+#pragma once
+
+#include <Python.h>
+
+#include <cstring>
+#include <exception>
+#include <new>
+
+namespace sciforge::binding {
+
+// Translate the in-flight C++ exception into a Python error and return nullptr, so a
+// binding entry point can write
+//   try { ... } catch (...) { return set_cpp_error(module_error_type); }
+// The argument is the module's error TYPE (catch (...) binds no exception object — the
+// in-flight exception is re-examined here via a bare `throw;`). Branch order matters:
+// bad_alloc maps to MemoryError, every other std::exception to `error_type` with
+// .what(), and anything else to a generic "internal error".
+inline PyObject* set_cpp_error(PyObject* error_type)
+{
+    try {
+        throw;
+    } catch (const std::bad_alloc&) {
+        return PyErr_NoMemory();
+    } catch (const std::exception& ex) {
+        PyErr_SetString(error_type, ex.what());
+        return nullptr;
+    } catch (...) {
+        PyErr_SetString(error_type, "internal error");
+        return nullptr;
+    }
+}
+
+// Create the module's exception type and attach it. `qualified_name` is the dotted
+// name for the exception (e.g. "real.error"); the module attribute is its trailing
+// component. `base` is optional — pass a base class (e.g. re.error) or nullptr to
+// derive from Exception. Returns a new reference to the error type (the caller keeps
+// it for set_cpp_error), or nullptr on failure with a Python error set.
+inline PyObject* register_error(PyObject* module, const char* qualified_name,
+                                PyObject* base = nullptr)
+{
+    PyObject* err = PyErr_NewException(qualified_name, base, nullptr);
+    if (err == nullptr) {
+        return nullptr;
+    }
+    const char* dot  = std::strrchr(qualified_name, '.');
+    const char* attr = (dot != nullptr) ? dot + 1 : qualified_name;
+    if (PyModule_AddObjectRef(module, attr, err) < 0) {
+        Py_DECREF(err);
+        return nullptr;
+    }
+    return err;
+}
+
+}  // namespace sciforge::binding

sciforge_build-2026.6.8/sciforge_build/include/sciforge/binding/gil.hpp

@@ -0,0 +1,55 @@
+// SciForge binding substrate — GIL release (Limited-API, abi3-safe).
+//
+// RAII GIL release that restores the GIL on EVERY scope exit, including a C++
+// exception propagating out — unlike the bare Py_BEGIN/END_ALLOW_THREADS macros,
+// whose END is skipped on a throw, leaving the GIL released (undefined behaviour
+// afterwards). That restore-on-throw guarantee is the load-bearing reason this is
+// RAII. The substrate owns the mechanism; the release *policy* (the threshold value)
+// stays with the consumer, which measures it per workload.
+#pragma once
+
+#include <Python.h>
+
+namespace sciforge::binding {
+
+// Release the GIL for the lifetime of the object; restore it on destruction (every
+// path, including stack unwinding from a throw).
+class gil_release {
+public:
+    gil_release() : saved_(PyEval_SaveThread()) {}
+    ~gil_release() { PyEval_RestoreThread(saved_); }
+
+    gil_release(const gil_release&)            = delete;
+    gil_release& operator=(const gil_release&) = delete;
+    gil_release(gil_release&&)                 = delete;
+    gil_release& operator=(gil_release&&)      = delete;
+
+private:
+    PyThreadState* saved_;
+};
+
+// Release the GIL only when `above` is true (the consumer's threshold test); below
+// it the GIL is simply kept — releasing/re-acquiring would dominate a tiny scan.
+class scoped_gil_release {
+public:
+    explicit scoped_gil_release(bool above)
+        : saved_(above ? PyEval_SaveThread() : nullptr)
+    {
+    }
+    ~scoped_gil_release()
+    {
+        if (saved_ != nullptr) {
+            PyEval_RestoreThread(saved_);
+        }
+    }
+
+    scoped_gil_release(const scoped_gil_release&)            = delete;
+    scoped_gil_release& operator=(const scoped_gil_release&) = delete;
+    scoped_gil_release(scoped_gil_release&&)                 = delete;
+    scoped_gil_release& operator=(scoped_gil_release&&)      = delete;
+
+private:
+    PyThreadState* saved_;
+};
+
+}  // namespace sciforge::binding

sciforge_build-2026.6.8/sciforge_build.egg-info/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: sciforge-build
+Version: 2026.6.8
+Summary: Build-time C++ binding-substrate headers for the SciForge ecosystem (never a runtime dependency).
+Project-URL: Homepage, https://github.com/RECHE23/sciforge
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# sciforge-build
+
+Build-time distribution of the SciForge C++ **binding substrate** headers
+(`<sciforge/binding/...>`). It is **never a runtime dependency** — list it in your
+`build-system.requires` and add `sciforge_build.get_include()` to your extension's
+`include_dirs` at wheel-build time. Pure-Python (`py3-none-any`); CalVer, aligned with
+the SciForge tag.

sciforge_build-2026.6.8/sciforge_build.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+setup.py
+sciforge_build/__init__.py
+sciforge_build.egg-info/PKG-INFO
+sciforge_build.egg-info/SOURCES.txt
+sciforge_build.egg-info/dependency_links.txt
+sciforge_build.egg-info/top_level.txt
+sciforge_build/include/sciforge/binding/error.hpp
+sciforge_build/include/sciforge/binding/gil.hpp

sciforge_build-2026.6.8/sciforge_build.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sciforge_build-2026.6.8/sciforge_build.egg-info/top_level.txt

@@ -0,0 +1 @@
+sciforge_build

sciforge_build-2026.6.8/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sciforge_build-2026.6.8/setup.py

@@ -0,0 +1,23 @@
+"""Vendor the canonical <sciforge/binding/...> headers into the package at build time.
+
+The headers live once, canonically, at the repo's include/sciforge/binding/. Copying
+them under the package (rather than committing a second copy) keeps a single source of
+truth while making the wheel + sdist self-contained — a consumer can build its
+extension purely from `pip install sciforge-build`, with no sibling checkout.
+"""
+import pathlib
+import shutil
+
+from setuptools import setup
+
+_HERE = pathlib.Path(__file__).resolve().parent
+_CANONICAL = _HERE.parent.parent / "include" / "sciforge" / "binding"
+_VENDORED = _HERE / "sciforge_build" / "include" / "sciforge" / "binding"
+
+if _CANONICAL.is_dir():
+    _VENDORED.parent.mkdir(parents=True, exist_ok=True)
+    if _VENDORED.exists():
+        shutil.rmtree(_VENDORED)
+    shutil.copytree(_CANONICAL, _VENDORED)
+
+setup()