samcore 0.1.0__tar.gz

samcore-0.1.0/.github/actions/setup-conda-toolchain/action.yml

@@ -0,0 +1,93 @@
+name: Set up Clang/conda toolchain (Windows & macOS)
+description: >-
+  Install Clang, the LLVM OpenMP runtime and HDF5 from conda-forge for
+  building samcore on Windows and macOS.
+
+# samcore's OpenMP loops use unsigned (size_t) loop indices, which MSVC's
+# OpenMP 2.0 implementation rejects with error C3016. GCC/Clang accept them,
+# so the README recommends LLVM Clang, and this mirrors it: conda-forge
+# provides Clang, llvm-openmp and HDF5 in one ABI-consistent environment.
+#
+# Windows: conda-forge does NOT ship the Windows SDK import libraries
+# (kernel32.lib, ...) - the `vc`/`ucrt` packages only contain the runtime.
+# clang and lld-link trust %INCLUDE%/%LIB% when set and then skip
+# auto-detecting the SDK, so the MSVC developer environment must be
+# initialized as well and the conda prefix prepended to it.
+#
+# macOS: AppleClang has no OpenMP, hence the conda-forge clang + libomp.
+#
+# On Linux runners every step below is a no-op.
+
+runs:
+  using: composite
+  steps:
+    # Initializes the MSVC + Windows SDK %INCLUDE%/%LIB%/%PATH% environment.
+    - name: Initialize MSVC environment (Windows)
+      if: runner.os == 'Windows'
+      uses: ilammy/msvc-dev-cmd@v1
+      with:
+        arch: x64
+
+    - name: Create conda-forge toolchain environment
+      if: runner.os != 'Linux'
+      id: conda
+      uses: mamba-org/setup-micromamba@v3
+      with:
+        environment-name: samcore-build
+        create-args: >-
+          clangxx
+          llvm-openmp
+          hdf5=1.14
+          cmake
+          ninja
+        init-shell: none
+        cache-environment: true
+
+    - name: Export toolchain env (Windows)
+      if: runner.os == 'Windows'
+      shell: pwsh
+      run: |
+        $prefix = "${{ steps.conda.outputs.environment-path }}"
+        if (-not $env:INCLUDE -or -not $env:LIB) {
+          throw "MSVC environment (INCLUDE/LIB) was not initialized by the previous step"
+        }
+        "$prefix\bin" | Out-File -FilePath $env:GITHUB_PATH -Append
+        "$prefix\Library\bin" | Out-File -FilePath $env:GITHUB_PATH -Append
+        # Prepend the conda prefix to the MSVC-provided INCLUDE/LIB so the
+        # build finds omp.h / libomp / HDF5 while the Windows SDK import libs
+        # stay on the search path.  LTO is disabled because clang's -flto
+        # needs lld-link on Windows (link.exe cannot consume LLVM bitcode).
+        @(
+          "HDF5_ROOT=$prefix\Library"
+          "CMAKE_PREFIX_PATH=$prefix\Library"
+          "INCLUDE=$prefix\Library\include;$env:INCLUDE"
+          "LIB=$prefix\Library\lib;$env:LIB"
+          "CC=$prefix\Library\bin\clang.exe"
+          "CXX=$prefix\Library\bin\clang++.exe"
+          "CMAKE_ARGS=-G Ninja -DSAMCORE_ENABLE_LTO=OFF"
+        ) | Out-File -FilePath $env:GITHUB_ENV -Append
+        Write-Host "Windows toolchain prefix: $prefix"
+
+    - name: Export toolchain env (macOS)
+      if: runner.os == 'macOS'
+      shell: bash
+      run: |
+        prefix="${{ steps.conda.outputs.environment-path }}"
+        if [ ! -x "$prefix/bin/clang++" ]; then
+          echo "clang++ not found in $prefix/bin" >&2
+          exit 1
+        fi
+        echo "$prefix/bin" >> "$GITHUB_PATH"
+        # CPATH/LIBRARY_PATH let the build find omp.h/libomp/HDF5 while
+        # CMAKE_PREFIX_PATH/HDF5_ROOT cover CMake's find_package.
+        {
+          echo "CC=$prefix/bin/clang"
+          echo "CXX=$prefix/bin/clang++"
+          echo "HDF5_ROOT=$prefix"
+          echo "CMAKE_PREFIX_PATH=$prefix"
+          echo "CPATH=$prefix/include"
+          echo "LIBRARY_PATH=$prefix/lib"
+          echo "SDKROOT=$(xcrun --show-sdk-path)"
+          echo "CMAKE_ARGS=-G Ninja"
+        } >> "$GITHUB_ENV"
+        echo "macOS toolchain prefix: $prefix"

samcore-0.1.0/.github/workflows/tests.yml

@@ -0,0 +1,69 @@
+name: Tests
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  python-tests:
+    name: Python ${{ matrix.python }} on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        python: ["3.9", "3.10", "3.11", "3.12", "3.13", "3.14"]
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          submodules: recursive
+
+      - name: Install HDF5 (Linux)
+        if: runner.os == 'Linux'
+        run: sudo apt-get update && sudo apt-get -y install libhdf5-dev ninja-build
+
+      # Windows/macOS use the conda-forge LLVM toolchain (as the README
+      # recommends): MSVC's OpenMP 2.0 rejects the unsigned loop indices
+      # (error C3016) and AppleClang has no OpenMP.  The action also installs
+      # HDF5 and llvm-openmp and exports the compiler env.
+      - uses: ./.github/actions/setup-conda-toolchain
+
+      - name: Set up Python
+        uses: actions/setup-python@v7
+        with:
+          python-version: ${{ matrix.python }}
+
+      - name: Build and install package
+        run: |
+          python -m pip install --upgrade pip
+          pip install .[test]
+
+      - name: Run Python tests
+        env:
+          SAMCORE_TEST_DATA_DIR: tests/data
+        run: pytest tests/python -v
+
+  cpp-tests:
+    name: C++ (sanitizers) on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest]
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          submodules: recursive
+
+      - name: Install HDF5
+        run: sudo apt-get update && sudo apt-get -y install libhdf5-dev ninja-build
+
+      - name: Configure, build, test (debug + sanitizers)
+        run: |
+          cmake -B build-debug -G Ninja -DCMAKE_BUILD_TYPE=Debug
+          cmake --build build-debug
+          ASAN_OPTIONS=detect_leaks=1:halt_on_error=1 \
+          UBSAN_OPTIONS=halt_on_error=1 \
+          ctest --test-dir build-debug --output-on-failure

samcore-0.1.0/.github/workflows/wheels.yml

@@ -0,0 +1,183 @@
+name: Build wheels & attach to release
+
+on:
+  push:
+    tags:
+      - "v*"
+      - "ci-test*"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  build-wheels:
+    name: Build wheel on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os:
+          - ubuntu-latest   # manylinux/musllinux x86_64
+          - ubuntu-24.04-arm # manylinux/musllinux aarch64
+          - macos-latest
+          - windows-latest
+
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          submodules: recursive
+
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+
+      - name: Install cibuildwheel
+        run: python -m pip install --upgrade pip cibuildwheel
+
+      # HDF5 is required (find_package(HDF5 COMPONENTS CXX REQUIRED)). On
+      # Linux it is installed inside the manylinux/musllinux container (see
+      # CIBW_BEFORE_ALL_LINUX below). On Windows and macOS the conda-forge
+      # toolchain action installs HDF5, Clang and llvm-openmp and exports the
+      # compiler env (Clang is required on Windows because MSVC's OpenMP 2.0
+      # rejects the unsigned loop indices, error C3016; on macOS because
+      # AppleClang has no OpenMP).
+      - uses: ./.github/actions/setup-conda-toolchain
+
+      - name: Build wheels
+        run: python -m cibuildwheel --output-dir wheelhouse
+        env:
+          CIBW_BUILD: cp39-* cp310-* cp311-* cp312-* cp313-* cp314-*
+          CIBW_ARCHS_LINUX: auto
+          CIBW_ARCHS_MACOS: auto
+          # 64-bit only: the LLVM clang GNU driver cannot target 32-bit
+          # Windows against the win32 CPython the way MSVC's vcvars does.
+          CIBW_ARCHS_WINDOWS: AMD64
+          # HDF5 + ninja inside the Linux containers. CIBW_BEFORE_ALL_* runs
+          # once per container (before the whole CPython matrix), so the
+          # system packages are not re-installed for every Python version.
+          # manylinux is RHEL-based (yum on manylinux2014, dnf on
+          # manylinux_2_28+); musllinux is Alpine and uses apk, where HDF5's
+          # C++ headers ship in hdf5-dev (community repo).
+          CIBW_BEFORE_ALL_LINUX: |
+            if command -v apk >/dev/null 2>&1; then
+              apk add --no-cache --repository "https://dl-cdn.alpinelinux.org/alpine/v$(cut -d. -f1,2 /etc/alpine-release)/community" build-base cmake hdf5-dev ninja
+            elif command -v dnf >/dev/null 2>&1; then
+              dnf install -y hdf5-devel ninja-build
+            else
+              yum install -y hdf5-devel ninja-build
+            fi
+          # numpy is intentionally NOT installed here: pip's build isolation
+          # pulls it from [build-system].requires in pyproject.toml, and the
+          # wheel test env gets it as the package's declared dependency.
+          # Windows: bundle the HDF5/OpenMP runtime DLLs into the wheel
+          # (delvewheel is installed into the build env; HDF5_ROOT is exported
+          # by the toolchain action above). Commands on Windows run under
+          # cmd.exe, so use %VAR% syntax here, not PowerShell's $env:VAR.
+          CIBW_BEFORE_BUILD_WINDOWS: python -m pip install delvewheel
+          CIBW_REPAIR_WHEEL_COMMAND_WINDOWS: >-
+            delvewheel repair --add-path "%HDF5_ROOT%\bin" -w {dest_dir} {wheel}
+          CIBW_TEST_REQUIRES: pytest
+          CIBW_TEST_COMMAND: >-
+            pytest {project}/tests/python -v -p no:cacheprovider
+
+      - name: Show artifacts
+        shell: bash
+        run: ls -lh wheelhouse
+
+      - uses: actions/upload-artifact@v7
+        with:
+          name: wheels-${{ matrix.os }}
+          path: wheelhouse/*.whl
+
+  build-sdist:
+    name: Build sdist
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          submodules: recursive
+
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+
+      - name: Install HDF5
+        run: |
+          sudo apt-get update
+          sudo apt-get -y install libhdf5-dev ninja-build
+
+      - name: Build sdist
+        run: |
+          python -m pip install --upgrade pip build
+          python -m build --sdist --outdir dist
+
+      - uses: actions/upload-artifact@v7
+        with:
+          name: sdist
+          path: dist/*.tar.gz
+
+  publish:
+    name: Attach artifacts to GitHub Release
+    needs: [build-wheels, build-sdist]
+    runs-on: ubuntu-latest
+    # Run for every tag this workflow is triggered by ("v*" and "ci-test*").
+    # A tag-less run (workflow_dispatch on a branch) skips this job.
+    # Note: a job skipped via `if` cannot be re-run on its own, so the CI
+    # test tags must be allowed here too, otherwise publish stays skipped.
+    if: startsWith(github.ref, 'refs/tags/')
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/download-artifact@v8
+        with:
+          pattern: wheels-*
+          path: dist
+          merge-multiple: true
+
+      - uses: actions/download-artifact@v8
+        with:
+          name: sdist
+          path: dist
+
+      - name: List artifacts
+        run: ls -lh dist
+
+      - name: Attach wheels to GitHub Release
+        uses: softprops/action-gh-release@v3
+        with:
+          files: dist/*
+          # ci-test* releases are marked prerelease so they never become
+          # the repository's "Latest" release.
+          prerelease: ${{ !startsWith(github.ref, 'refs/tags/v') }}
+
+  publish-pypi:
+    name: Publish to PyPI
+    needs: [build-wheels, build-sdist]
+    runs-on: ubuntu-latest
+    # Real releases only - the ci-test* tags must never reach PyPI.
+    if: startsWith(github.ref, 'refs/tags/v')
+    # Must match the "Environment name" configured for the trusted publisher
+    # on PyPI (see README).  Add required reviewers here for a manual gate.
+    environment:
+      name: pypi
+      url: https://pypi.org/p/samcore
+    permissions:
+      id-token: write # OIDC trusted publishing (no API token/secret)
+      contents: read
+    steps:
+      - uses: actions/download-artifact@v8
+        with:
+          pattern: wheels-*
+          path: dist
+          merge-multiple: true
+
+      - uses: actions/download-artifact@v8
+        with:
+          name: sdist
+          path: dist
+
+      # Trusted Publishing: authenticates via the GitHub OIDC token.  PEP 740
+      # attestations are enabled by default.  `dist/` holds the wheels + sdist.
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

samcore-0.1.0/.gitignore

@@ -0,0 +1,40 @@
+# build artifacts
+build/
+build-*/
+_skbuild/
+dist/
+*.egg-info/
+*.so
+*.dylib
+*.dll
+*.whl
+result
+
+# python
+__pycache__/
+*.py[cod]
+.venv/
+.pytest_cache/
+
+# nix
+.nix-shell/
+
+# test data: keep the sample testdata files, ignore everything else
+tests/data/*
+!tests/data/testdata.h5sam
+!tests/data/testdata.h5samd
+
+# All markdown/text except README.md and version.txt
+*.md
+*.txt
+!version.txt
+!README.md
+
+# Notebooks
+*.ipynb
+
+# Images
+*.tiff
+*.tif
+*.TIFF
+*.png

samcore-0.1.0/.gitmodules

@@ -0,0 +1,6 @@
+[submodule "external/pocketfft"]
+	path = external/pocketfft
+	# The upstream host (gitlab.mpcdf.mpg.de) is often unreachable from CI,
+	# so use the original author's GitHub mirror of the same repository. The
+	# pinned commit is the tip of its `cpp` branch and is byte-identical.
+	url = https://github.com/mreineck/pocketfft.git

samcore-0.1.0/CMakeLists.txt

@@ -0,0 +1,254 @@
+cmake_minimum_required(VERSION 3.22)
+
+# Read version from version.txt; register it as a configure dependency so
+# the build re-runs automatically when the file changes.
+set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS
+  "${CMAKE_SOURCE_DIR}/version.txt")
+file(READ "${CMAKE_SOURCE_DIR}/version.txt" VERSION_STRING)
+string(STRIP "${VERSION_STRING}" PROJECT_VERSION)
+
+project(samcore VERSION ${PROJECT_VERSION} LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED True)
+set(CMAKE_CXX_EXTENSIONS Off)
+
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE Release)
+endif()
+
+option(SAMCORE_BUILD_TESTS "Build the libsamcore test suite" ${PROJECT_IS_TOP_LEVEL})
+option(SAMCORE_BUILD_EXECUTABLES "Build executables (bench, gen_data)" OFF)
+option(SAMCORE_BUILD_PYTHON "Build the samcore Python bindings (nanobind)" OFF)
+option(SAMCORE_ENABLE_OPENMP "Enable OpenMP parallelism" ON)
+option(SAMCORE_NATIVE_ARCH "Compile with -march=native" OFF)
+option(SAMCORE_WARNINGS_AS_ERRORS "Treat warnings as errors" OFF)
+option(SAMCORE_ENABLE_SANITIZERS "Enable ASan+UBSan in Debug builds" ON)
+option(SAMCORE_ENABLE_FAST_MATH "Enable -ffast-math in Release builds" ON)
+option(SAMCORE_ENABLE_LTO "Enable link-time optimization in Release builds" ON)
+
+# Alpine's fortify-headers (musl) define libc functions as always_inline
+# wrappers that GCC cannot inline under -flto ("function body can be
+# overwritten at link time"), which breaks the link.  Disable LTO on musl
+# targets (e.g. musllinux wheels); glibc and the other platforms are fine.
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+  execute_process(COMMAND "${CMAKE_CXX_COMPILER}" -dumpmachine
+    OUTPUT_VARIABLE _samcore_target_triple
+    OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET)
+  if(_samcore_target_triple MATCHES "musl"
+     OR CMAKE_CXX_LIBRARY_ARCHITECTURE MATCHES "musl")
+    if(SAMCORE_ENABLE_LTO)
+      message(STATUS "samcore: disabling LTO for musl target (fortify-headers)")
+    endif()
+    set(SAMCORE_ENABLE_LTO OFF)
+  endif()
+endif()
+
+if(SAMCORE_NATIVE_ARCH)
+  add_compile_options(-march=native)
+endif()
+
+include(cmake/dependencies.cmake)
+
+add_library(samcore
+  src/sam_header.cpp
+  src/sam_labels.cpp
+  src/sam_scan.cpp
+  src/sam_dataset.cpp
+  src/io/fileio_h5sam.cpp
+  src/io/fileio_h5samd.cpp
+  src/signal/filters.cpp
+  src/signal/spectral.cpp
+  src/preprocessing.cpp
+  src/utils.cpp
+)
+add_library(samcore::samcore ALIAS samcore)
+
+target_include_directories(samcore
+  PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+  PRIVATE
+    # pocketfft is an internal dependency: no public header includes it, so
+    # it must not leak into the exported interface.
+    ${SAMCORE_POCKETFFT_INCLUDE_DIR})
+
+target_link_libraries(samcore
+  PUBLIC
+    HDF5::HDF5
+  PRIVATE
+    # OpenMP is an implementation detail: apply it only in the build tree
+    # so the exported package does not reference OpenMP::OpenMP_CXX.
+    $<$<BOOL:${SAMCORE_ENABLE_OPENMP}>:$<BUILD_INTERFACE:OpenMP::OpenMP_CXX>>)
+
+target_compile_definitions(samcore PUBLIC SAMCORE_VERSION="${PROJECT_VERSION}")
+
+if(SAMCORE_ENABLE_OPENMP)
+  target_compile_definitions(samcore PUBLIC SAMCORE_HAS_OPENMP=1)
+endif()
+
+target_compile_options(samcore PRIVATE
+  $<$<CXX_COMPILER_ID:MSVC>:/W4;/permissive->
+  $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-Wall;-Wextra;-Wpedantic>
+  $<$<AND:$<NOT:$<CXX_COMPILER_ID:MSVC>>,$<BOOL:${SAMCORE_WARNINGS_AS_ERRORS}>>:-Werror>)
+
+# ---- build modes ---------------------------------------------------------
+# Build-interface targets so the flags reach every final link target
+# (tests, executables, python module) without leaking into the installed
+# package interface.
+add_library(samcore_debug_flags INTERFACE)
+target_compile_options(samcore_debug_flags INTERFACE
+  $<$<AND:$<COMPILE_LANG_AND_ID:CXX,GNU,Clang>,$<CONFIG:Debug>,$<BOOL:${SAMCORE_ENABLE_SANITIZERS}>>:-fsanitize=address,undefined;-fno-omit-frame-pointer>)
+target_link_options(samcore_debug_flags INTERFACE
+  $<$<AND:$<COMPILE_LANG_AND_ID:CXX,GNU,Clang>,$<CONFIG:Debug>,$<BOOL:${SAMCORE_ENABLE_SANITIZERS}>>:-fsanitize=address,undefined>)
+
+add_library(samcore_release_flags INTERFACE)
+target_compile_options(samcore_release_flags INTERFACE
+  $<$<COMPILE_LANG_AND_ID:CXX,GNU,Clang>:$<$<CONFIG:Release>:-O2>>
+  $<$<AND:$<COMPILE_LANG_AND_ID:CXX,GNU,Clang>,$<CONFIG:Release>,$<BOOL:${SAMCORE_ENABLE_FAST_MATH}>>:-ffast-math>
+  $<$<AND:$<COMPILE_LANG_AND_ID:CXX,GNU,Clang>,$<CONFIG:Release>,$<BOOL:${SAMCORE_ENABLE_LTO}>>:-flto>)
+target_link_options(samcore_release_flags INTERFACE
+  $<$<AND:$<COMPILE_LANG_AND_ID:CXX,GNU,Clang>,$<CONFIG:Release>,$<BOOL:${SAMCORE_ENABLE_LTO}>>:-flto>)
+
+target_link_libraries(samcore PUBLIC
+  $<BUILD_INTERFACE:samcore_debug_flags>
+  $<BUILD_INTERFACE:samcore_release_flags>)
+
+set_target_properties(samcore PROPERTIES
+  POSITION_INDEPENDENT_CODE ON
+  CXX_VISIBILITY_PRESET hidden
+  VISIBILITY_INLINES_HIDDEN ON)
+
+# ---- install / export ----------------------------------------------------
+include(GNUInstallDirs)
+include(CMakePackageConfigHelpers)
+
+install(TARGETS samcore
+  EXPORT samcoreTargets
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+
+install(EXPORT samcoreTargets
+  FILE samcoreTargets.cmake
+  NAMESPACE samcore::
+  DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/samcore)
+
+configure_package_config_file(
+  cmake/samcoreConfig.cmake.in
+  "${CMAKE_CURRENT_BINARY_DIR}/samcoreConfig.cmake"
+  INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/samcore)
+write_basic_package_version_file(
+  "${CMAKE_CURRENT_BINARY_DIR}/samcoreConfigVersion.cmake"
+  VERSION ${PROJECT_VERSION}
+  COMPATIBILITY SameMajorVersion)
+
+install(FILES
+  "${CMAKE_CURRENT_BINARY_DIR}/samcoreConfig.cmake"
+  "${CMAKE_CURRENT_BINARY_DIR}/samcoreConfigVersion.cmake"
+  DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/samcore)
+
+# ---- tests & executables ---------------------------------------------------
+if(SAMCORE_BUILD_TESTS)
+  enable_testing()
+  add_subdirectory(tests)
+endif()
+
+if(SAMCORE_BUILD_EXECUTABLES)
+  add_subdirectory(executables)
+endif()
+
+if(SAMCORE_BUILD_PYTHON)
+  # ---- nanobind extension (samcore python package) ------------------------
+  # Built via scikit-build-core (pip install .), which exposes nanobind to
+  # CMake automatically; the execute_process lookup is only a fallback for
+  # direct -DSAMCORE_BUILD_PYTHON=ON builds outside pip.
+  find_package(Python COMPONENTS Interpreter Development.Module REQUIRED)
+
+  find_package(nanobind CONFIG QUIET)
+  if(NOT nanobind_FOUND)
+    execute_process(COMMAND "${Python_EXECUTABLE}" -m nanobind --cmake_dir
+      OUTPUT_VARIABLE NB_CMAKE_DIR OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if(NB_CMAKE_DIR)
+      list(APPEND CMAKE_PREFIX_PATH "${NB_CMAKE_DIR}")
+    endif()
+    find_package(nanobind CONFIG REQUIRED)
+  endif()
+
+  # Per-version extension (no abi3): keeps wheel builds uniform across the
+  # whole CPython range.  Bindings are split per type under src/bindings/.
+  nanobind_add_module(_samcore NB_DOMAIN numpy
+    src/bindings/module.cpp
+    src/bindings/header.cpp
+    src/bindings/labels.cpp
+    src/bindings/scan.cpp
+    src/bindings/dataset.cpp
+    src/bindings/submodules.cpp)
+  target_link_libraries(_samcore PRIVATE samcore)
+
+  if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+    target_compile_options(_samcore PRIVATE -w)
+  endif()
+
+  install(TARGETS _samcore LIBRARY DESTINATION samcore)
+
+  # package version, generated from version.txt (single source of truth)
+  configure_file("${CMAKE_SOURCE_DIR}/cmake/_version.py.in"
+                 "${CMAKE_CURRENT_BINARY_DIR}/_version.py" @ONLY)
+  install(FILES "${CMAKE_CURRENT_BINARY_DIR}/_version.py"
+          DESTINATION samcore)
+
+  # ---- typed stubs (nanobind stubgen) -------------------------------------
+  # Generate .pyi stubs + the py.typed marker at build time and ship them
+  # in the wheel.  stubgen must be able to import the assembled samcore
+  # package (pure Python modules + generated _version.py + the compiled
+  # extension), so stage an importable copy of the package in the build
+  # tree, run stubgen against it, and install the results.  Stub generation
+  # is optional tooling and never fails the build (see cmake/stubgen.cmake);
+  # the install below uses OPTIONAL so a skipped run ships no stubs.
+  execute_process(
+    COMMAND "${Python_EXECUTABLE}" -c "import nanobind.stubgen"
+    RESULT_VARIABLE SAMCORE_HAS_NB_STUBGEN OUTPUT_QUIET ERROR_QUIET)
+  if(SAMCORE_HAS_NB_STUBGEN EQUAL 0)
+    set(SAMCORE_STUB_DIR "${CMAKE_CURRENT_BINARY_DIR}/_stub")
+    set(SAMCORE_STUB_PKG "${SAMCORE_STUB_DIR}/samcore")
+
+    add_custom_command(
+      OUTPUT "${SAMCORE_STUB_PKG}/py.typed"
+      COMMAND ${CMAKE_COMMAND} -E rm -rf "${SAMCORE_STUB_PKG}"
+      COMMAND ${CMAKE_COMMAND} -E copy_directory
+              "${CMAKE_CURRENT_SOURCE_DIR}/src/samcore" "${SAMCORE_STUB_PKG}"
+      COMMAND ${CMAKE_COMMAND} -E rm -rf "${SAMCORE_STUB_PKG}/__pycache__"
+      COMMAND ${CMAKE_COMMAND} -E copy
+              "${CMAKE_CURRENT_BINARY_DIR}/_version.py"
+              "${SAMCORE_STUB_PKG}/_version.py"
+      COMMAND ${CMAKE_COMMAND} -E copy
+              "$<TARGET_FILE:_samcore>"
+              "${SAMCORE_STUB_PKG}/$<TARGET_FILE_NAME:_samcore>"
+      COMMAND ${CMAKE_COMMAND} -DSTUB_DIR=${SAMCORE_STUB_DIR}
+              -DSTUB_PKG=${SAMCORE_STUB_PKG}
+              -DPYTHON=${Python_EXECUTABLE}
+              -P "${CMAKE_CURRENT_SOURCE_DIR}/cmake/stubgen.cmake"
+      DEPENDS _samcore "${CMAKE_CURRENT_BINARY_DIR}/_version.py"
+      COMMENT "Generating samcore .pyi stubs (nanobind stubgen)"
+      VERBATIM)
+    add_custom_target(samcore_stub ALL
+      DEPENDS "${SAMCORE_STUB_PKG}/py.typed")
+
+    install(FILES
+      "${SAMCORE_STUB_PKG}/__init__.pyi"
+      "${SAMCORE_STUB_PKG}/_samcore.pyi"
+      "${SAMCORE_STUB_PKG}/_scan.pyi"
+      "${SAMCORE_STUB_PKG}/_labels.pyi"
+      "${SAMCORE_STUB_PKG}/_dataset.pyi"
+      "${SAMCORE_STUB_PKG}/_io.pyi"
+      "${SAMCORE_STUB_PKG}/py.typed"
+      DESTINATION samcore
+      OPTIONAL)
+  else()
+    message(STATUS
+      "nanobind.stubgen not importable by ${Python_EXECUTABLE}; "
+      "skipping .pyi stub generation")
+  endif()
+endif()

samcore-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Freiburg INATECH BDS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.