pls4all 0.97.0__tar.gz

pls4all-0.97.0/LICENSE

@@ -0,0 +1,52 @@
+CeCILL FREE SOFTWARE LICENSE AGREEMENT
+Version 2.1 dated 2013-06-21
+
+Copyright (c) 2026 Grégory Beurier and contributors.
+
+Notice
+
+This Agreement is a Free Software license agreement that is the result
+of discussions between its authors in order to ensure compliance with
+the two main principles guiding its drafting:
+
+  * firstly, compliance with the principles governing the distribution
+    of Free Software: access to source code, broad rights granted to users,
+  * secondly, the election of a governing law, French law, with which it
+    is conformant, both as regards the law of torts and intellectual
+    property law, and the protection that it offers to both authors and
+    holders of the economic rights over software.
+
+The authors of the CeCILL (for Ce[a] C[nrs] I[nria] L[ogiciel] L[ibre])
+license are:
+
+Commissariat à l'Energie Atomique et aux Energies Alternatives - CEA,
+a public scientific, technical and industrial research establishment,
+having its principal place of business at 25 rue Leblanc, immeuble Le
+Ponant D, 75015 Paris, France.
+
+Centre National de la Recherche Scientifique - CNRS, a public scientific
+and technological establishment, having its principal place of business
+at 3 rue Michel-Ange, 75794 Paris cedex 16, France.
+
+Institut National de Recherche en Informatique et en Automatique - Inria,
+a public scientific and technological establishment, having its principal
+place of business at Domaine de Voluceau, Rocquencourt, BP 105, 78153 Le
+Chesnay cedex, France.
+
+Full license text: https://cecill.info/licences/Licence_CeCILL_V2.1-en.txt
+(or https://cecill.info/licences/Licence_CeCILL_V2.1-fr.txt for the French version)
+
+This software is provided AS IS, without warranty of any kind, express or
+implied. See the CeCILL-2.1 text for the complete legal terms.
+
+---
+
+Vendored third-party components (test-only or build-only - not linked
+into the public `libp4a` shared library):
+
+* doctest (cpp/tests/doctest/doctest.h) - MIT License
+  Copyright (c) 2016-2024 Viktor Kirilov
+  Used to compile the test executable. Not part of any shipped artefact.
+
+Additional vendored components will be listed here as they are added,
+each with their license and the path within the repository.

pls4all-0.97.0/MANIFEST.in

@@ -0,0 +1,7 @@
+# Include the native shared library so the sdist + wheel ship libp4a
+# even though setuptools' default discovery skips arch-specific files.
+recursive-include src/pls4all/lib *
+
+# Include the package README and local license notice.
+include README.md
+include LICENSE

pls4all-0.97.0/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: pls4all
+Version: 0.97.0
+Summary: Python binding for the pls4all C ABI — a portable PLS / NIRS engine.
+Author: Grégory Beurier and contributors
+License-Expression: CECILL-2.1
+Project-URL: Homepage, https://github.com/GBeurier/pls4all
+Project-URL: Repository, https://github.com/GBeurier/pls4all
+Project-URL: Issues, https://github.com/GBeurier/pls4all/issues
+Project-URL: Documentation, https://gbeurier.github.io/pls4all/
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Dynamic: license-file
+
+# Python binding
+
+The current Python package ships a minimal **ctypes-only** binding that:
+
+- loads `libp4a.{so,dll,dylib}` via `ctypes.CDLL`,
+- exposes the version / status / dtype / backend introspection queries,
+- exposes a Pythonic `Context` and `Config` wrapper for the lifecycle calls,
+- raises a typed exception (`Pls4allError`) on any non-OK status, capturing the per-context `last_error` message.
+
+A real wheel with NumPy zero-copy `p4a_matrix_view_t` conversion + a
+sklearn-compatible estimator lands in Phase 2 on top of the live C core.
+
+## Build the underlying library
+
+```bash
+cmake --preset dev-release
+cmake --build --preset dev-release --parallel
+```
+
+This produces `build/dev-release/cpp/src/libp4a.so` (or `.dylib` / `.dll`).
+The binding looks for it on disk via the loader rules below.
+
+## Loader rules
+
+In order:
+
+1. `$PLS4ALL_LIB_PATH` — explicit path to `libp4a` (most direct).
+2. `pls4all/lib/libp4a*` next to the installed package (wheel layout).
+3. `<repo-root>/build/dev-release/cpp/src/libp4a*` (developer convenience).
+4. The standard system search path (`LD_LIBRARY_PATH`, macOS rpath, Windows `PATH`).
+
+## Smoke test
+
+```python
+import pls4all
+print(pls4all.version())       # "0.96.0+abi.1.13.0"
+print(pls4all.abi_version())   # (1, 13, 0)
+
+with pls4all.Context() as ctx:
+    ctx.seed = 42
+    print(ctx.last_error)      # ""
+    try:
+        ctx.backend = pls4all.Backend.CUDA
+    except pls4all.Pls4allError as e:
+        print(e)               # 'backend 5 is not compiled into this build of libp4a'
+
+with pls4all.Config() as cfg:
+    cfg.algorithm = pls4all.Algorithm.PCR
+    cfg.solver = pls4all.Solver.SVD
+    cfg.deflation = pls4all.Deflation.REGRESSION
+    assert cfg.algorithm == pls4all.Algorithm.PCR
+    assert cfg.solver == pls4all.Solver.SVD
+    assert cfg.deflation == pls4all.Deflation.REGRESSION
+    cfg.algorithm = pls4all.Algorithm.PLS_SVD
+    cfg.deflation = pls4all.Deflation.CANONICAL
+    assert cfg.algorithm == pls4all.Algorithm.PLS_SVD
+    assert cfg.deflation == pls4all.Deflation.CANONICAL
+```

pls4all-0.97.0/README.md

@@ -0,0 +1,58 @@
+# Python binding
+
+The current Python package ships a minimal **ctypes-only** binding that:
+
+- loads `libp4a.{so,dll,dylib}` via `ctypes.CDLL`,
+- exposes the version / status / dtype / backend introspection queries,
+- exposes a Pythonic `Context` and `Config` wrapper for the lifecycle calls,
+- raises a typed exception (`Pls4allError`) on any non-OK status, capturing the per-context `last_error` message.
+
+A real wheel with NumPy zero-copy `p4a_matrix_view_t` conversion + a
+sklearn-compatible estimator lands in Phase 2 on top of the live C core.
+
+## Build the underlying library
+
+```bash
+cmake --preset dev-release
+cmake --build --preset dev-release --parallel
+```
+
+This produces `build/dev-release/cpp/src/libp4a.so` (or `.dylib` / `.dll`).
+The binding looks for it on disk via the loader rules below.
+
+## Loader rules
+
+In order:
+
+1. `$PLS4ALL_LIB_PATH` — explicit path to `libp4a` (most direct).
+2. `pls4all/lib/libp4a*` next to the installed package (wheel layout).
+3. `<repo-root>/build/dev-release/cpp/src/libp4a*` (developer convenience).
+4. The standard system search path (`LD_LIBRARY_PATH`, macOS rpath, Windows `PATH`).
+
+## Smoke test
+
+```python
+import pls4all
+print(pls4all.version())       # "0.96.0+abi.1.13.0"
+print(pls4all.abi_version())   # (1, 13, 0)
+
+with pls4all.Context() as ctx:
+    ctx.seed = 42
+    print(ctx.last_error)      # ""
+    try:
+        ctx.backend = pls4all.Backend.CUDA
+    except pls4all.Pls4allError as e:
+        print(e)               # 'backend 5 is not compiled into this build of libp4a'
+
+with pls4all.Config() as cfg:
+    cfg.algorithm = pls4all.Algorithm.PCR
+    cfg.solver = pls4all.Solver.SVD
+    cfg.deflation = pls4all.Deflation.REGRESSION
+    assert cfg.algorithm == pls4all.Algorithm.PCR
+    assert cfg.solver == pls4all.Solver.SVD
+    assert cfg.deflation == pls4all.Deflation.REGRESSION
+    cfg.algorithm = pls4all.Algorithm.PLS_SVD
+    cfg.deflation = pls4all.Deflation.CANONICAL
+    assert cfg.algorithm == pls4all.Algorithm.PLS_SVD
+    assert cfg.deflation == pls4all.Deflation.CANONICAL
+```

pls4all-0.97.0/pyproject.toml

@@ -0,0 +1,60 @@
+[build-system]
+# setuptools >= 77 implements PEP 639 SPDX license validation. It loads
+# packaging.licenses, which exists only in packaging >= 24.2 — older
+# packaging makes setuptools 77 crash with
+# `ImportError: Cannot import 'packaging.licenses'.
+#  Setuptools>=77.0.0 requires "packaging>=24.2" to work properly.`
+requires = ["setuptools>=77", "wheel", "packaging>=24.2"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pls4all"
+version = "0.97.0"
+description = "Python binding for the pls4all C ABI — a portable PLS / NIRS engine."
+authors = [{ name = "Grégory Beurier and contributors" }]
+license = "CECILL-2.1"
+license-files = ["LICENSE"]
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = ["numpy>=1.21"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Science/Research",
+  "Intended Audience :: Developers",
+  "Operating System :: POSIX :: Linux",
+  "Operating System :: MacOS",
+  "Operating System :: Microsoft :: Windows",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Topic :: Scientific/Engineering",
+  "Topic :: Scientific/Engineering :: Chemistry",
+  "Topic :: Scientific/Engineering :: Mathematics",
+]
+
+[project.urls]
+Homepage = "https://github.com/GBeurier/pls4all"
+Repository = "https://github.com/GBeurier/pls4all"
+Issues = "https://github.com/GBeurier/pls4all/issues"
+Documentation = "https://gbeurier.github.io/pls4all/"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+# Bundle the native shared library shipped inside the wheel.
+# cibuildwheel's build_libp4a_in_wheel.sh stages libp4a into
+# src/pls4all/lib/ before the sdist/wheel is built; the patterns below
+# tell setuptools to ship every variant (Linux .so, macOS .dylib,
+# Windows .dll, the auditwheel-renamed forms, and the SONAME symlinks).
+[tool.setuptools.package-data]
+pls4all = [
+  "lib/libp4a*",
+  "lib/p4a*",
+  "lib/*.so",
+  "lib/*.so.*",
+  "lib/*.dylib",
+  "lib/*.dll",
+]

pls4all-0.97.0/setup.cfg

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

pls4all-0.97.0/setup.py

@@ -0,0 +1,41 @@
+# SPDX-License-Identifier: CECILL-2.1
+#
+# setup.py shim — declares the package as **non-pure** so cibuildwheel
+# and setuptools treat it as platform-specific.
+#
+# This binding is **ctypes-only**: there is no CPython extension to
+# compile. By default, setuptools detects this absence and produces a
+# pure-Python wheel tagged ``py3-none-any``. That tag is wrong for us
+# because:
+#
+# 1. The wheel embeds a native shared library (libp4a) shipped under
+#    ``pls4all/lib/``, so the artefact is platform-specific.
+# 2. cibuildwheel skips its ``CIBW_REPAIR_WHEEL_COMMAND_*`` step on
+#    pure wheels — auditwheel / delocate / delvewheel never runs and
+#    the manylinux policy is not enforced.
+#
+# Overriding ``Distribution.has_ext_modules`` flips both behaviours:
+# setuptools generates a platform-tagged wheel
+# (``cp3X-cp3X-manylinux_2_31_x86_64`` initially), and cibuildwheel
+# runs the repair pass. scripts/retag_wheels.py then rewrites the
+# filename + ``WHEEL`` metadata + ``RECORD`` to the canonical
+# ``py3-none-${platform}`` form so the wheel applies to every
+# CPython supported by ``requires-python``.
+
+from setuptools import Distribution, setup
+from setuptools.dist import Distribution as _Distribution
+
+
+def _has_native_payload(self: _Distribution) -> bool:
+    return True
+
+
+# Force the platform-tagged wheel: setuptools.bdist_wheel checks both
+# ``Distribution.has_ext_modules()`` and ``Distribution.is_pure()``.
+Distribution.has_ext_modules = _has_native_payload  # type: ignore[method-assign]
+Distribution.is_pure = lambda self: False           # type: ignore[method-assign]
+
+# All other metadata (name, version, license, dependencies, package_data, …)
+# comes from pyproject.toml. Calling setup() with no kwargs lets the
+# declarative metadata drive the build.
+setup()

pls4all-0.97.0/src/pls4all/__init__.py

@@ -0,0 +1,212 @@
+"""pls4all — Python binding for the pls4all C ABI.
+
+Current scope: version / status / dtype / backend introspection, a Context
+and a Config wrapper, an OperatorBank wrapper, a ValidationPlan wrapper, and
+the AOM global / POP per-component selection result handles
+(`aom_global_select`, `aom_per_component_select`). Full Python model
+wrappers (NIPALS, orthogonal-scores, SIMPLS, kernel, wide-kernel, SVD,
+power, randomized-SVD, PLSCanonical, PLSSVD, PLS-DA, OPLS/OPLS-DA, PCR and
+the cross-validation / metrics / variable-selection surface) land in
+Phase 2 on top of the live C core.
+"""
+
+from ._ffi import lib  # noqa: F401  — eagerly loads libp4a
+from ._errors import Pls4allError
+from ._types import Algorithm, Backend, Deflation, Dtype, Solver, Status
+from ._context import Context
+from ._config import Config
+from ._aom import (
+    AomGlobalResult,
+    AomPerComponentResult,
+    OperatorBank,
+    OperatorKind,
+    ValidationPlan,
+    aom_global_select,
+    aom_per_component_select,
+)
+from ._model import Model, ModelArrayKind
+from ._methods import (
+    MethodResult,
+    sparse_simpls_fit,
+    di_pls_fit,
+    recursive_pls_run,
+    cppls_fit,
+    weighted_pls_fit,
+    robust_pls_fit,
+    ridge_pls_fit,
+    continuum_regression_fit,
+    n_pls_fit,
+    kernel_pls_fit,
+    o2pls_fit,
+    approximate_press_compute,
+    pls_diagnostics_compute,
+    sparse_pls_da_fit,
+    group_sparse_pls_fit,
+    fused_sparse_pls_fit,
+    pds_fit,
+    ds_fit,
+    mir_pls_fit,
+    missing_aware_nipals_fit,
+    pls_glm_fit,
+    pls_qda_fit,
+    pls_cox_fit,
+    bagging_pls_fit,
+    gpr_pls_fit,
+    boosting_pls_fit,
+    random_subspace_pls_fit,
+    so_pls_fit,
+    on_pls_fit,
+    rosa_fit,
+    pls_monitoring_run,
+    one_se_rule_compute,
+    # §17 fit shims
+    mb_pls_fit,
+    lw_pls_fit,
+    pls_lda_fit,
+    pls_logistic_fit,
+    aom_preprocess_fit,
+    # §18 selector shims
+    variable_select_rank,
+    interval_select,
+    stability_select,
+    uve_select,
+    spa_select,
+    cars_select,
+    random_frog_select,
+    scars_select,
+    ga_select,
+    pso_select,
+    vissa_select,
+    shaving_select,
+    bve_select,
+    t2_select,
+    wvc_select,
+    wvc_threshold_select,
+    emcuve_select,
+    randomization_select,
+    bipls_select,
+    sipls_select,
+    rep_select,
+    ipw_select,
+    st_select,
+    # §19 Phase 50+ numerical methods
+    ecr_fit,
+    iriv_select,
+    irf_select,
+    vip_spa_select,
+)
+
+
+def version() -> str:
+    """Return the runtime library version string, e.g. 'X.Y.Z+abi.A.B.C'."""
+    return lib.p4a_get_version_string().decode("utf-8")
+
+
+def abi_version() -> tuple[int, int, int]:
+    return (
+        int(lib.p4a_get_abi_version_major()),
+        int(lib.p4a_get_abi_version_minor()),
+        int(lib.p4a_get_abi_version_patch()),
+    )
+
+
+def build_info() -> str:
+    return lib.p4a_get_build_info().decode("utf-8")
+
+
+__all__ = [
+    "Pls4allError",
+    "Backend",
+    "Dtype",
+    "Deflation",
+    "Algorithm",
+    "Status",
+    "Solver",
+    "Context",
+    "Config",
+    "OperatorKind",
+    "OperatorBank",
+    "ValidationPlan",
+    "AomGlobalResult",
+    "AomPerComponentResult",
+    "aom_global_select",
+    "aom_per_component_select",
+    "Model",
+    "ModelArrayKind",
+    "MethodResult",
+    "sparse_simpls_fit",
+    "di_pls_fit",
+    "recursive_pls_run",
+    "cppls_fit",
+    "weighted_pls_fit",
+    "robust_pls_fit",
+    "ridge_pls_fit",
+    "continuum_regression_fit",
+    "n_pls_fit",
+    "kernel_pls_fit",
+    "o2pls_fit",
+    "approximate_press_compute",
+    "pls_diagnostics_compute",
+    "sparse_pls_da_fit",
+    "group_sparse_pls_fit",
+    "fused_sparse_pls_fit",
+    "pds_fit",
+    "ds_fit",
+    "mir_pls_fit",
+    "missing_aware_nipals_fit",
+    "pls_glm_fit",
+    "pls_qda_fit",
+    "pls_cox_fit",
+    "bagging_pls_fit",
+    "gpr_pls_fit",
+    "boosting_pls_fit",
+    "random_subspace_pls_fit",
+    "so_pls_fit",
+    "on_pls_fit",
+    "rosa_fit",
+    "pls_monitoring_run",
+    "one_se_rule_compute",
+    # §17 fit shims
+    "mb_pls_fit",
+    "lw_pls_fit",
+    "pls_lda_fit",
+    "pls_logistic_fit",
+    "aom_preprocess_fit",
+    # §18 selector shims
+    "variable_select_rank",
+    "interval_select",
+    "stability_select",
+    "uve_select",
+    "spa_select",
+    "cars_select",
+    "random_frog_select",
+    "scars_select",
+    "ga_select",
+    "pso_select",
+    "vissa_select",
+    "shaving_select",
+    "bve_select",
+    "t2_select",
+    "wvc_select",
+    "wvc_threshold_select",
+    "emcuve_select",
+    "randomization_select",
+    "bipls_select",
+    "sipls_select",
+    "rep_select",
+    "ipw_select",
+    "st_select",
+    # §19 Phase 50+ numerical methods
+    "ecr_fit",
+    "iriv_select",
+    "irf_select",
+    "vip_spa_select",
+    "version",
+    "abi_version",
+    "build_info",
+]
+
+# Derive __version__ from the loaded native library so it stays in sync with
+# the C ABI version_string without any manual maintenance. The expected shape
+# of version() is "X.Y.Z+abi.A.B.C" — we strip the "+abi.*" suffix.
+__version__ = version().split("+", 1)[0]