cvmatrix 3.2.3__tar.gz → 3.3.0__tar.gz

{cvmatrix-3.2.3 → cvmatrix-3.3.0}/.github/actions/release/action.yml

@@ -16,7 +16,7 @@ runs:
           name: python-package-distributions
           path: dist/
       - name: Sign the dists with Sigstore
-        uses: sigstore/gh-action-sigstore-python@v3.4.0
+        uses: sigstore/gh-action-sigstore-python@v3.5.0
         with:
           inputs: >-
             ./dist/*.tar.gz

{cvmatrix-3.2.3 → cvmatrix-3.3.0}/.github/actions/test/action.yml

@@ -28,6 +28,26 @@ runs:
       run: uv sync --group dev
       shell: bash
 
+    # On free-threaded Python (e.g. 3.15t), importing an extension module that does not
+    # support free threading silently re-enables the GIL, and the tests would then pass
+    # without exercising free threading. Fail if any test dependency re-enables it.
+    - name: Check that the GIL stays disabled (free-threaded Python only)
+      if: ${{ endsWith(inputs.PYTHON_VERSION, 't') }}
+      run: |
+        uv run python - <<'EOF'
+        import importlib.util
+        import sys
+
+        import coverage, cvmatrix, numpy, pandas, pytest, typeguard  # noqa: E401, F401
+
+        if importlib.util.find_spec("jax") is not None:
+            import jax.numpy  # noqa: F401
+        if sys._is_gil_enabled():
+            sys.exit("The GIL was re-enabled by an imported extension module.")
+        print("The GIL stays disabled with all test dependencies imported.")
+        EOF
+      shell: bash
+
     # The same test suite runs in both modes. With the JAX backend installed it also
     # exercises the parametrized backend="jax" tests; without JAX those parametrizations
     # are skipped (pytest.importorskip), verifying the numpy-only path.

{cvmatrix-3.2.3 → cvmatrix-3.3.0}/.github/workflows/pull_request_test_workflow.yml

@@ -18,7 +18,12 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
-        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14", "3.15"]
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14", "3.15", "3.15t"]
+        # jaxlib publishes no free-threaded (cp315t) wheel for Windows, and no sdist.
+        # Windows x 3.15t is still tested by the numpy-only job below.
+        exclude:
+          - os: windows-latest
+            python-version: "3.15t"
     steps:
       - uses: actions/checkout@v7
       - uses: ./.github/actions/test
@@ -42,7 +47,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
-        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14", "3.15"]
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14", "3.15", "3.15t"]
     steps:
       - uses: actions/checkout@v7
       - uses: ./.github/actions/test

{cvmatrix-3.2.3 → cvmatrix-3.3.0}/.github/workflows/test_workflow.yml

@@ -18,7 +18,12 @@ jobs:
             fail-fast: false
             matrix:
                 os: [ubuntu-latest, windows-latest, macos-latest]
-                python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+                python-version: ["3.10", "3.11", "3.12", "3.13", "3.14", "3.15", "3.15t"]
+                # jaxlib publishes no free-threaded (cp315t) wheel for Windows, and no sdist.
+                # Windows x 3.15t is still tested by the numpy-only job below.
+                exclude:
+                    - os: windows-latest
+                      python-version: "3.15t"
         steps:
             - uses: actions/checkout@v7
             - uses: ./.github/actions/test
@@ -42,7 +47,7 @@ jobs:
             fail-fast: false
             matrix:
                 os: [ubuntu-latest, windows-latest, macos-latest]
-                python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+                python-version: ["3.10", "3.11", "3.12", "3.13", "3.14", "3.15", "3.15t"]
         steps:
             - uses: actions/checkout@v7
             - uses: ./.github/actions/test

{cvmatrix-3.2.3 → cvmatrix-3.3.0}/CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.3.0] - 2026-10-30
+
+### Added
+- `compute_XTX` and `compute_XTY` constructor parameters (both default `True`, the previous behavior) that control whether `fit` computes the dataset-wide `XTX` (`X^T W X`) and `XTY` (`X^T W Y`). A product that is never used can now be skipped: e.g., `compute_XTX=False` avoids the O(NK²) time and K² memory of `XTX` when only `training_XTY` and/or `training_statistics` are used, which can dominate `fit` for wide `X`. A product that is not computed is `None`, and the training methods that need it raise a `ValueError`. The products are still computed in `fit`, so they are pickled along with a fitted `CVMatrix` and are not recomputed per task when cross-validating in parallel worker processes (e.g., with `joblib`).
+- Support for free-threaded Python. The CI test matrices now include free-threaded Python 3.15 (`3.15t`) on Linux, macOS, and Windows, with a check that no dependency re-enables the GIL. The JAX backend is tested on `3.15t` on Linux and macOS only, as jaxlib publishes no free-threaded wheel for Windows. The package declares the `Programming Language :: Python :: Free Threading :: 3 - Stable` classifier. A fitted `CVMatrix` can be shared by multiple threads, as the per-fold training methods only read it.
+
+### Changed
+- The CI test workflow for pushes to `main` now also tests Python 3.15, matching the pull-request workflow.
+- The per-fold training methods now gather only the validation set rows they use. Previously, the unweighted validation set rows of `X` were gathered, but not used, by `training_XTY` and `training_statistics`. With `weights` on the numpy backend, this makes `training_XTY` ~20% faster and `training_statistics` ~25-45% faster. Results are unchanged. Unweighted computations and computations traced by `jax.jit` were not affected.
+
+### Fixed
+- A fitted `CVMatrix` can be pickled with the standard library again. Since 3.2.0, the instance held the array namespace `xp` (the `numpy` or `jax.numpy` module), which cannot be pickled, so `pickle`, `copy.deepcopy`, `multiprocessing`, and `concurrent.futures.ProcessPoolExecutor` failed with `TypeError: cannot pickle 'module' object` (`joblib`'s default `loky` backend was not affected, as it pickles with `cloudpickle`). The module is now left out of the pickled state and resolved again from `backend` when unpickling. With `backend="jax"`, JAX's 64-bit mode is enabled before the arrays are restored, so float64 data stays float64 in fresh worker processes, where it would otherwise silently become float32.
+- Re-fitting a `CVMatrix` now replaces all state derived from `Y` instead of keeping it from the previous fit. Re-fitting without `Y` resets `XTY`, `WY`, `sum_Y`, `sq_Y`, and `sum_sq_Y` to `None`, and re-fitting with weights that do not require `WY` (no `center_X`, `center_Y`, or `scale_Y`) resets `WY` to `None`; likewise, `sq_X` is reset to `None` when `scale_X` is `False`. Results were not affected, but the stale arrays were kept in memory and pickled along with the fitted model (e.g., to parallel worker processes).
+
 ## [3.2.3] - 2026-10-30
 - Increased the maximum supported Python version from 3.14 to 3.15. Python 3.15 is now included in the CI test matrices. No functional changes.
 

{cvmatrix-3.2.3 → cvmatrix-3.3.0}/CONTRIBUTING.md

@@ -30,18 +30,28 @@ The sections below outline the steps in each case.
 1. (**Important**) Announce your plan to the rest of the community *before you start working*. This announcement should be in the form of a (new) issue;
 2. (**Important**) Wait until some kind of consensus is reached about your idea being a good idea;
 3. If needed, fork the repository to your own Github profile and create your own feature branch off of the latest main commit. While working on your feature branch, make sure to stay up to date with the main branch by pulling in changes, possibly from the 'upstream' repository (follow the instructions [here](https://help.github.com/articles/configuring-a-remote-for-a-fork/) and [here](https://help.github.com/articles/syncing-a-fork/));
-4. Make sure the existing tests still work by following the instructions in [Run the test suite](#run-the-test-suite);
-5. Add your own tests (if necessary);
-6. If you added your own tests, make sure they pass by following the instructions in [Run the test suite](#run-the-test-suite);
-7. If your contribution is a performance enhancement, make sure to include benchmarks. See [Benchmarking](#benchmarking) for more information;
-8. Update or expand the documentation;
-9. Make sure the documentation builds without errors by following the instructions in [Build the documentation](#build-the-documentation);
-10. Check that you can build the package locally and that it passes twine check. See [Build from source](#build-from-source) for more information;
-11. [Push](http://rogerdudler.github.io/git-guide/) your feature branch to (your fork of) the CVMatrix repository on GitHub;
-12. Create the pull request, e.g. following the instructions [here](https://help.github.com/articles/creating-a-pull-request/).
+4. Follow the [Design guidelines](#design-guidelines) when changing `CVMatrix`;
+5. Make sure the existing tests still work by following the instructions in [Run the test suite](#run-the-test-suite);
+6. Add your own tests (if necessary);
+7. If you added your own tests, make sure they pass by following the instructions in [Run the test suite](#run-the-test-suite);
+8. If your contribution is a performance enhancement, make sure to include benchmarks. See [Benchmarking](#benchmarking) for more information;
+9. Update or expand the documentation;
+10. Make sure the documentation builds without errors by following the instructions in [Build the documentation](#build-the-documentation);
+11. Check that you can build the package locally and that it passes twine check. See [Build from source](#build-from-source) for more information;
+12. [Push](http://rogerdudler.github.io/git-guide/) your feature branch to (your fork of) the CVMatrix repository on GitHub;
+13. Create the pull request, e.g. following the instructions [here](https://help.github.com/articles/creating-a-pull-request/).
 
 If you feel like you've made a valuable contribution, but you don't know how to write or run tests for it or generate the documentation, don't let this discourage you from making the pull request; we can help you! Just submit the pull request, but remember that you might be asked to append additional commits to your pull request.
 
+## Design guidelines
+
+`CVMatrix` is used in several execution settings: traced by `jax.jit`/`jax.vmap` with `backend="jax"`, called concurrently from multiple threads (including on free-threaded Python, which has no GIL), and pickled to worker processes (e.g., with `joblib`, `multiprocessing`, or `concurrent.futures.ProcessPoolExecutor`). To keep it correct and fast in all of them:
+
+- **The per-fold methods only read the fitted state.** `training_XTX`, `training_XTY`, `training_XTX_XTY`, and `training_statistics` must not modify the instance, e.g., by caching results on it. Compute anything dataset-wide in `fit`. A cache written during a per-fold call would leak tracers under `jax.jit`, race between threads, and, in worker processes, be filled in a throwaway copy, i.e., recomputed for every task.
+- **Route array operations through `self.xp`**, not `np`, so that the NumPy and JAX backends share one implementation and the per-fold methods stay traceable. Data-dependent checks that cannot run under tracing are skipped for tracer inputs (see `_TRACER_TYPES`). The NumPy backend's results must not change.
+- **Keep instances picklable with the standard library's `pickle`.** Do not store modules, locks, open files, or other unpicklable objects on the instance. If one is unavoidable, leave it out in `__reduce__` and restore it in `_reconstruct`, as is done for the array namespace `xp`. `test_pickle` and `test_process_pool` check this.
+- **Test both backends.** Every test runs with both `backend="numpy"` and `backend="jax"` through the `_set_backend` fixture in `tests/test_cvmatrix.py`; JAX-only tests skip themselves under the NumPy parametrization.
+
 ## Build from source
 
 CVMatrix uses [uv](https://docs.astral.sh/uv/) to manage its dependencies and packaging. To build the package from source, follow these steps:
@@ -101,9 +111,25 @@ To run the test suite, follow these steps:
 3. Now, the tests can be run with the following command:
 
     ```shell
-    uv run pytest tests --doctest-modules --junitxml=junit/test-results.xml --cov=cvmatrix/ --cov-report=xml --cov-report=html --typeguard-packages=cvmatrix/
+    uv run pytest tests --doctest-modules
     ```
 
+    The pytest options in `pyproject.toml` enable runtime type checking with [typeguard](https://typeguard.readthedocs.io/) (`--typeguard-packages=cvmatrix`) and coverage reports. Note that `--typeguard-packages` takes the package name `cvmatrix`, not a path: `cvmatrix/` silently instruments nothing.
+
+### Test on free-threaded Python
+
+CVMatrix also runs on free-threaded builds of Python (e.g., `3.15t`), which have no GIL. To run the test suite on one without touching your default environment, let uv create a temporary, isolated environment:
+
+```shell
+uv run --isolated --python 3.15t --extra jax --group dev pytest tests --doctest-modules
+```
+
+A free-threaded interpreter silently re-enables the GIL if it imports an extension module that does not support free threading. Check that the GIL stays disabled with all dependencies imported; this must print `False`:
+
+```shell
+uv run --isolated --python 3.15t --extra jax python -c "import sys, cvmatrix, jax; print(sys._is_gil_enabled())"
+```
+
 ## Build the documentation
 
 1. Install sphinx, the sphinx-rtd-theme, and the MyST-Parser:
@@ -126,4 +152,12 @@ To run the test suite, follow these steps:
 
 ## Benchmarking
 
-To run benchmarks, follow the instructions [here](https://github.com/Sm00thix/CVMatrix/blob/main/benchmarks/README.md).
+To run benchmarks, follow the instructions [here](https://github.com/Sm00thix/CVMatrix/blob/main/benchmarks/README.md).
+
+`benchmarks/benchmark.py` can be configured with environment variables, e.g., `BENCH_CONFIGS=plot` (only the three preprocessing combinations in the plots), `BENCH_PS=3,100,10000` (the numbers of folds), `BENCH_N`/`BENCH_K`/`BENCH_M` (the data size), and `BENCH_CSV` (the output file):
+
+```shell
+OPENBLAS_NUM_THREADS=1 BENCH_CONFIGS=plot BENCH_PS=3,100,10000 BENCH_CSV=my_results.csv uv run python benchmarks/benchmark.py
+```
+
+When you compare the performance of your change against `main`, run both versions on the same machine with a single BLAS thread, as above, and alternate between them over several rounds, also with the order reversed. The per-fold timings depend on the memory allocation history of the process, so identical code can differ by several percent between runs, and a fixed run order can look like a consistent difference.

{cvmatrix-3.2.3 → cvmatrix-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cvmatrix
-Version: 3.2.3
+Version: 3.3.0
 Summary: Fast computation of possibly weighted and possibly centered/scaled training set kernel matrices in a cross-validation setting.
 Project-URL: Homepage, https://cvmatrix.readthedocs.io/en/latest/
 Project-URL: Repository, https://github.com/Sm00thix/CVMatrix
@@ -14,6 +14,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3.15
+Classifier: Programming Language :: Python :: Free Threading :: 3 - Stable
 Requires-Python: <3.16,>=3.10
 Requires-Dist: numpy<3.0.0,>=2.0.0
 Provides-Extra: jax

{cvmatrix-3.2.3 → cvmatrix-3.3.0}/cvmatrix/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "3.2.3"
+__version__ = "3.3.0"
 __all__ = ["CVMatrix", "Partitioner"]
 from .cvmatrix import CVMatrix
 from .partitioner import Partitioner

{cvmatrix-3.2.3 → cvmatrix-3.3.0}/cvmatrix/cvmatrix.py

@@ -100,6 +100,37 @@ def _resolve_backend(backend: str):
     raise ValueError(f"Invalid backend: {backend!r}. Must be 'numpy' or 'jax'.")
 
 
+def _reconstruct(cls: type, backend: str, dtype: FloatDType) -> CVMatrix:
+    """
+    Creates an empty instance of `cls`, a `CVMatrix` or a subclass, with its array
+    backend set up. Used by `CVMatrix.__reduce__` for unpickling: pickle calls it before
+    restoring the pickled arrays, so that, with the jax backend and a 64-bit `dtype`,
+    JAX's 64-bit mode is enabled before the arrays are rebuilt. Otherwise, float64
+    arrays would silently become float32 in a fresh process, e.g., a worker process.
+
+    Parameters
+    ----------
+    cls : type
+        The class of the pickled instance.
+
+    backend : {"numpy", "jax"}
+        The array backend of the pickled instance.
+
+    dtype : type[np.floating]
+        The data type of the pickled instance.
+
+    Returns
+    -------
+    CVMatrix
+        An instance of `cls` with `backend`, `dtype`, and `xp` set.
+    """
+    obj = cls.__new__(cls)
+    obj.backend = backend
+    obj.dtype = dtype
+    obj._init_backend()
+    return obj
+
+
 class CVMatrix:
     r"""
     Implements the fast cross-validation algorithms for kernel matrix-based models such
@@ -156,6 +187,31 @@ class CVMatrix:
         input arrays are not NumPy arrays of type `dtype`, then a copy is made. If
         `True` a copy is always made. If no copy is made, then external modifications
         to `X` or `Y` will result in undefined behavior.
+
+    backend : {"numpy", "jax"}, optional, default="numpy"
+        The array backend used for the computations. `"numpy"` uses NumPy, which is
+        the only required dependency. `"jax"` uses `jax.numpy` so that the per-fold
+        computations of `training_XTX`, `training_XTY`, `training_XTX_XTY`, and
+        `training_statistics` can be traced by `jax.jit` and batched over folds with
+        `jax.vmap` on CPU, GPU, or TPU. It requires the optional JAX dependency, which
+        is installed with `pip install cvmatrix[jax]`; otherwise, an `ImportError` is
+        raised. If `"jax"` is used with a 64-bit `dtype`, JAX's 64-bit mode
+        (`jax_enable_x64`) is enabled globally so that `dtype` is honored instead of
+        being truncated to 32 bits.
+
+    compute_XTX : bool, optional, default=True
+        Whether `fit` computes the dataset-wide
+        :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}`. Its cost grows with the
+        square of the number of predictor variables in `X`, so for wide `X` it can
+        dominate `fit`. Set this to `False` if neither `training_XTX` nor
+        `training_XTX_XTY` will be called. If `False`, these methods raise a
+        `ValueError`.
+
+    compute_XTY : bool, optional, default=True
+        Whether `fit` computes the dataset-wide
+        :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}` when `Y` is provided. Set
+        this to `False` if neither `training_XTY` nor `training_XTX_XTY` will be
+        called. If `False`, these methods raise a `ValueError`.
     """
 
     def __init__(
@@ -168,6 +224,8 @@ class CVMatrix:
         dtype: FloatDType = np.float64,
         copy: bool = True,
         backend: Literal["numpy", "jax"] = "numpy",
+        compute_XTX: bool = True,
+        compute_XTY: bool = True,
     ) -> None:
         self.center_X = center_X
         self.center_Y = center_Y
@@ -176,18 +234,10 @@ class CVMatrix:
         self.ddof = ddof
         self.dtype = dtype.type if isinstance(dtype, np.dtype) else dtype
         self.copy = copy
+        self.compute_XTX = compute_XTX
+        self.compute_XTY = compute_XTY
         self.backend = backend
-        # Array namespace: numpy (default) or jax.numpy. All array operations are routed
-        # through `self.xp` so that, with backend="jax", the per-fold `training_*`
-        # methods can be traced by jax.jit/jax.vmap. The numpy backend is byte-identical
-        # to previous releases.
-        self.xp = _resolve_backend(backend)
-        if backend == "jax" and np.dtype(self.dtype).itemsize >= 8:
-            # JAX defaults to 32-bit; enable 64-bit precision so a requested float64
-            # dtype is honored instead of being silently truncated to float32.
-            import jax
-
-            jax.config.update("jax_enable_x64", True)
+        self._init_backend()
         self.resolution = np.finfo(dtype).resolution * 10
         self.X = None
         self.Y = None
@@ -208,6 +258,18 @@ class CVMatrix:
         self.sum_w = None
         self.num_nonzero_w = None
 
+    def __reduce__(self) -> tuple:
+        """
+        Supports pickling with the standard library, e.g., to send a fitted `CVMatrix`
+        to worker processes with `multiprocessing` or
+        `concurrent.futures.ProcessPoolExecutor`. The array namespace `xp` is a module,
+        which cannot be pickled, so it is left out of the pickled state and resolved
+        again from `backend` by `_reconstruct` before the state is restored.
+        """
+        state = self.__dict__.copy()
+        del state["xp"]
+        return _reconstruct, (type(self), self.backend, self.dtype), state
+
     def fit(
         self,
         X: npt.ArrayLike,
@@ -216,8 +278,9 @@ class CVMatrix:
     ) -> None:
         r"""
         Loads and stores `X`, `Y`, and "weights", for cross-validation. Computes
-        dataset-wide :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}` and, if `Y` is
-        not `None`, :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}`. If `center_X`,
+        dataset-wide :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}` if
+        `compute_XTX` is `True` and, if `Y` is not `None` and `compute_XTY` is `True`,
+        :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}`. If `center_X`,
         `center_Y`, `scale_X`, or `scale_Y` is `True`, the corresponding global
         statistics are also computed.
 
@@ -252,13 +315,14 @@ class CVMatrix:
         M : int or None
             The number of response variables in `Y`. If `Y` is `None`, this is `None`.
 
-        XTX : Array
+        XTX : Array or None
             The total matrix :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}` for the
-            entire dataset.
+            entire dataset. This is computed only if `compute_XTX` is `True`.
 
         XTY : Array or None
             The total matrix :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}` for the
-            entire dataset. This is computed only if `Y` is not `None`.
+            entire dataset. This is computed only if `Y` is not `None` and
+            `compute_XTY` is `True`.
 
         sum_X : Array or None
             The row of column-wise weighted sums of `X` for the entire dataset. This is
@@ -362,6 +426,7 @@ class CVMatrix:
         Raises
         ------
         ValueError
+            - If `fit` did not compute `XTX` because `compute_XTX` was `False`.
             - If `self.center_X` or `self.scale_X` is `True` but cannot be computed due
                 to the training set having no non-zero weights.
             - If `self.scale_X` is `True` and the corresponding weighted standard
@@ -426,6 +491,7 @@ class CVMatrix:
         ------
         ValueError
             - If `Y` is `None`.
+            - If `fit` did not compute `XTY` because `compute_XTY` was `False`.
             - If `self.center_X`, `self.center_Y`, `self.scale_X`, or `self.scale_Y` is
                 `True` and the corresponding weighted means and standard deviations
                 cannot be computed due to the training set having no non-zero
@@ -496,6 +562,8 @@ class CVMatrix:
         ------
         ValueError
             - If `Y` is `None`.
+            - If `fit` did not compute `XTX` because `compute_XTX` was `False`.
+            - If `fit` did not compute `XTY` because `compute_XTY` was `False`.
             - If `self.center_X`, `self.center_Y`, `self.scale_X`, or `self.scale_Y` is
                 `True` and the corresponding weighted means and standard deviations
                 cannot be computed due to the training set having no non-zero
@@ -562,16 +630,22 @@ class CVMatrix:
                 set.
 
         """
-        X_val, X_val_unweighted, Y_val, Y_val_unweighted = self._get_val_matrices(
-            val_indices=validation_indices, return_XTY=self.Y is not None
+        return_X_mean = self.center_X or self.scale_X
+        return_Y_mean = (self.center_Y or self.scale_Y) and self.Y is not None
+        X_val, _, Y_val, _ = self._get_val_matrices(
+            val_indices=validation_indices,
+            return_X_val=return_X_mean,
+            return_X_val_unweighted=False,
+            return_Y_val=return_Y_mean,
+            return_Y_val_unweighted=False,
         )
         return self._compute_training_stats(
             val_indices=validation_indices,
             X_val=X_val,
             Y_val=Y_val,
-            return_X_mean=self.center_X or self.scale_X,
+            return_X_mean=return_X_mean,
             return_X_std=self.scale_X,
-            return_Y_mean=(self.center_Y or self.scale_Y) and self.Y is not None,
+            return_Y_mean=return_Y_mean,
             return_Y_std=self.scale_Y and self.Y is not None,
         )[:-1]  # Exclude the sum of training weights from the return tuple
 
@@ -775,11 +849,11 @@ class CVMatrix:
             Whether to return the training set
             :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}`.
 
-        return_XTY : bool, optional, default=False
+        return_XTY : bool
             Whether to return the training set
             :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}`.
 
-        validation_indices : IndexArray
+        val_indices : IndexArray
             An integer array of indices for the validation set for which to
             return the corresponding training set
             :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}` and
@@ -802,8 +876,10 @@ class CVMatrix:
         Raises
         ------
         ValueError
-            If both `return_XTX` and `return_XTY` are `False` or if `return_XTY` is
-            `True` and `Y` is `None`.
+            If both `return_XTX` and `return_XTY` are `False`, if `return_XTY` is
+            `True` and `Y` is `None`, if `return_XTX` is `True` and `fit` did not
+            compute `XTX` because `compute_XTX` was `False`, or if `return_XTY` is
+            `True` and `fit` did not compute `XTY` because `compute_XTY` was `False`.
         """
         if not return_XTX and not return_XTY:
             raise ValueError(
@@ -811,8 +887,28 @@ class CVMatrix:
             )
         if return_XTY and self.Y is None:
             raise ValueError("Response variables `Y` are not provided.")
+        # Check the fitted products rather than the flags, so that the flags cannot
+        # disagree with what `fit` actually computed.
+        if return_XTX and self.XTX is None:
+            raise ValueError(
+                "`XTX` was not computed by `fit`. Fit a CVMatrix constructed with "
+                "`compute_XTX=True` to use `training_XTX` or `training_XTX_XTY`."
+            )
+        if return_XTY and self.XTY is None:
+            raise ValueError(
+                "`XTY` was not computed by `fit`. Fit a CVMatrix constructed with "
+                "`compute_XTY=True` to use `training_XTY` or `training_XTX_XTY`."
+            )
+        # The weighted `Y_val` feeds the weighted mean and standard deviation of `Y`,
+        # which centering (`center_X` or `center_Y`) and scaling (`scale_Y`) of `XTY`
+        # use.
+        return_Y_val = return_XTY and self._needs_Y_stats
         X_val, X_val_unweighted, Y_val, Y_val_unweighted = self._get_val_matrices(
-            val_indices=val_indices, return_XTY=return_XTY
+            val_indices=val_indices,
+            return_X_val=True,
+            return_X_val_unweighted=return_XTX,
+            return_Y_val=return_Y_val,
+            return_Y_val_unweighted=return_XTY,
         )
         X_train_mean, X_train_std, Y_train_mean, Y_train_std, sum_w_train = (
             self._compute_training_stats(
@@ -822,11 +918,7 @@ class CVMatrix:
                     if self.center_X or self.scale_X or (return_XTY and self.center_Y)
                     else None
                 ),
-                Y_val=(
-                    Y_val
-                    if return_XTY and (self.center_X or self.center_Y or self.scale_Y)
-                    else None
-                ),
+                Y_val=Y_val,
                 return_X_mean=self.center_X or (return_XTY and self.center_Y),
                 return_Y_mean=return_XTY and (self.center_X or self.center_Y),
                 return_X_std=self.scale_X,
@@ -898,50 +990,106 @@ class CVMatrix:
         )
 
     def _get_val_matrices(
-        self, val_indices: IndexArray, return_XTY: bool
+        self,
+        val_indices: IndexArray,
+        *,
+        return_X_val: bool,
+        return_X_val_unweighted: bool,
+        return_Y_val: bool,
+        return_Y_val_unweighted: bool,
     ) -> Tuple[
-        Array,
-        Array,
+        Optional[Array],
+        Optional[Array],
         Optional[Array],
         Optional[Array],
     ]:
         """
-        Returns the validation set matrices for a given fold.
+        Returns the requested validation set matrices for a given fold. Only the
+        requested matrices are gathered, as gathering the validation set rows is a
+        significant part of the cost of each fold.
+
         Parameters
         ----------
         val_indices : Array of shape (N_val,)
             The indices of the validation set samples for the given fold.
-        return_XTY : bool
-            Whether to return the validation set of response variables `Y`. If `False`,
-            the returned `Y_val` and `Y_val_unweighted` will be `None`.
+
+        return_X_val : bool
+            Whether to return the validation set of weighted predictor variables.
+
+        return_X_val_unweighted : bool
+            Whether to return the validation set of unweighted predictor variables.
+
+        return_Y_val : bool
+            Whether to return the validation set of response variables, weighted if
+            `WY` is computed and unweighted otherwise.
+
+        return_Y_val_unweighted : bool
+            Whether to return the validation set of unweighted response variables.
+
         Returns
         -------
-        Tuple of arrays of shapes (N_val, K), (N_val, K), (N_val, M), and (N_val, M)
-            The validation set of predictor variables `X`, the validation set of
-            unweighted predictor variables `X_unweighted`, the validation set of
-            response variables `Y`, and the validation set of unweighted response
-            variables `Y_unweighted`. If `return_XTY` is `False`, `Y` and
-            `Y_unweighted` will be `None`.
+        Tuple of four elements of Optional[Array]
+            The validation sets of predictor variables `X_val` of shape (N_val, K),
+            unweighted predictor variables `X_val_unweighted` of shape (N_val, K),
+            response variables `Y_val` of shape (N_val, M), and unweighted response
+            variables `Y_val_unweighted` of shape (N_val, M). A matrix that is not
+            requested is `None`.
         """
-        X_val = self.WX[val_indices]
-        if self.weights is None:
-            X_val_unweighted = X_val
-        else:
-            X_val_unweighted = self.X[val_indices]
-        if return_XTY:
-            if self.weights is None or not (
-                self.center_X or self.center_Y or self.scale_Y
-            ):
-                Y_val = self.Y[val_indices]
-                Y_val_unweighted = Y_val
-            else:
-                Y_val = self.WY[val_indices]
-                Y_val_unweighted = self.Y[val_indices]
+        X_val, X_val_unweighted = self._gather_val_pair(
+            val_indices, self.WX, self.X, return_X_val, return_X_val_unweighted
+        )
+        if self.weights is None or not self._needs_Y_stats:
+            Y_maybe_weighted = self.Y
         else:
-            Y_val = None
-            Y_val_unweighted = None
+            Y_maybe_weighted = self.WY
+        Y_val, Y_val_unweighted = self._gather_val_pair(
+            val_indices, Y_maybe_weighted, self.Y, return_Y_val, return_Y_val_unweighted
+        )
         return X_val, X_val_unweighted, Y_val, Y_val_unweighted
 
+    @staticmethod
+    def _gather_val_pair(
+        val_indices: IndexArray,
+        mat: Optional[Array],
+        mat_unweighted: Optional[Array],
+        return_val: bool,
+        return_val_unweighted: bool,
+    ) -> Tuple[Optional[Array], Optional[Array]]:
+        """
+        Gathers the requested validation set rows of a possibly weighted matrix and of
+        its unweighted counterpart. If both are requested and they are the same array
+        (e.g., if no weights are used), the rows are gathered only once.
+
+        Parameters
+        ----------
+        val_indices : Array of shape (N_val,)
+            The indices of the validation set samples for the given fold.
+
+        mat : None or Array of shape (N, K) or (N, M)
+            The possibly weighted matrix, `WX` or `WY`.
+
+        mat_unweighted : None or Array of shape (N, K) or (N, M)
+            The unweighted matrix, `X` or `Y`.
+
+        return_val : bool
+            Whether to return the validation set rows of `mat`.
+
+        return_val_unweighted : bool
+            Whether to return the validation set rows of `mat_unweighted`.
+
+        Returns
+        -------
+        Tuple of two elements of Optional[Array]
+            The validation set rows of `mat` and of `mat_unweighted`. A matrix that is
+            not requested is `None`.
+        """
+        mat_val = mat[val_indices] if return_val else None
+        if not return_val_unweighted:
+            return mat_val, None
+        if mat_val is not None and mat is mat_unweighted:
+            return mat_val, mat_val
+        return mat_val, mat_unweighted[val_indices]
+
     def _training_kernel_matrix(
         self,
         total_kernel_mat: Array,
@@ -1130,6 +1278,21 @@ class CVMatrix:
         mat_train_std = xp.where(mat_train_std <= self.resolution, 1, mat_train_std)
         return mat_train_std
 
+    def _init_backend(self) -> None:
+        """
+        Resolves the array namespace `xp` from `backend`: numpy (the default) or
+        jax.numpy. All array operations are routed through `xp` so that, with the jax
+        backend, the per-fold `training_*` methods can be traced by jax.jit/jax.vmap.
+        The numpy backend is byte-identical to previous releases. JAX defaults to 32
+        bits, so with the jax backend and a 64-bit `dtype`, JAX's 64-bit mode is enabled
+        so that `dtype` is honored instead of being silently truncated to float32.
+        """
+        self.xp = _resolve_backend(self.backend)
+        if self.backend == "jax" and np.dtype(self.dtype).itemsize >= 8:
+            import jax
+
+            jax.config.update("jax_enable_x64", True)
+
     def _init_mat(self, mat: Array) -> Array:
         """
         Casts the matrix to the dtype specified in the constructor and reshapes it if
@@ -1192,35 +1355,55 @@ class CVMatrix:
         else:
             self.weights = None
 
+    @property
+    def _needs_Y_stats(self) -> bool:
+        r"""
+        Whether the training set :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}`
+        uses the weighted statistics of `Y`: the row of column-wise weighted means for
+        centering (`center_X` or `center_Y`) and, additionally, the row of column-wise
+        weighted standard deviations for scaling (`scale_Y`). Only then are `WY` (with
+        weights) and `sum_Y` computed and the weighted validation set rows of `Y`
+        gathered.
+        """
+        return self.center_X or self.center_Y or self.scale_Y
+
     def _init_weighted_mats(self):
         """
-        Initializes the weighted matrices `WX` and `WY` if weights are
-        provided. These matrices are computed as the product of the original matrices
-        `X` and `Y` with the `weights`. If `Y` is `None`, then `WY` is not initialized.
-        If `w` is `None`, then this method does nothing.
+        Initializes the weighted matrices `WX` and `WY`. Without weights, they are `X`
+        and `Y` themselves. With weights, they are computed as the product of `X` and
+        `Y` with the `weights`, where `WY` is computed only if `Y` is not `None` and its
+        weighted statistics are needed (see `_needs_Y_stats`). If `WY` is not
+        computed, it is set to `None` so that no `WY` from a previous fit is kept.
         """
         if self.weights is None:
             self.WX = self.X
-            if self.Y is not None:
-                self.WY = self.Y
+            self.WY = self.Y
         else:
             self.WX = self.X * self.weights
-            if self.Y is not None and (self.center_X or self.center_Y or self.scale_Y):
+            if self.Y is not None and self._needs_Y_stats:
                 self.WY = self.Y * self.weights
+            else:
+                self.WY = None
 
     def _init_matrix_products(self) -> None:
         r"""
         Initializes the global matrix products `XTX` and `XTY` for the
         entire dataset. These are :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{X}`
-        and :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}`, respectively.
+        and :math:`\mathbf{X}^{\mathbf{T}}\mathbf{W}\mathbf{Y}`, respectively. A product
+        that is not computed, due to `compute_XTX` or `compute_XTY` being `False` or
+        `Y` being `None`, is set to `None`.
         """
-        self.XTX = self.WX.T @ self.X
-        if self.Y is not None:
+        self.XTX = self.WX.T @ self.X if self.compute_XTX else None
+        if self.compute_XTY and self.Y is not None:
             self.XTY = self.WX.T @ self.Y
+        else:
+            self.XTY = None
 
     def _init_stats(self) -> None:
         """
-        Initializes the global statistics for `X` and `Y`.
+        Initializes the global statistics for `X` and `Y`. The statistics of `Y` and
+        the squared matrices that are not computed are set to `None` so that none from
+        a previous fit are kept.
         """
         if self.center_X or self.center_Y or self.scale_X or self.scale_Y:
             if self.weights is not None:
@@ -1231,15 +1414,19 @@ class CVMatrix:
                 self.num_nonzero_w = self.N
         if self.center_X or self.center_Y or self.scale_X:
             self.sum_X = self.xp.sum(self.WX, axis=0, keepdims=True)
-        if (self.center_X or self.center_Y or self.scale_Y) and self.Y is not None:
+        if self._needs_Y_stats and self.Y is not None:
             self.sum_Y = self.xp.sum(self.WY, axis=0, keepdims=True)
+        else:
+            self.sum_Y = None
         if self.scale_X:
             self.sq_X = self.WX * self.X
             self.sum_sq_X = self.xp.sum(self.sq_X, axis=0, keepdims=True)
         else:
+            self.sq_X = None
             self.sum_sq_X = None
         if self.scale_Y and self.Y is not None:
             self.sq_Y = self.WY * self.Y
             self.sum_sq_Y = self.xp.sum(self.sq_Y, axis=0, keepdims=True)
         else:
+            self.sq_Y = None
             self.sum_sq_Y = None

{cvmatrix-3.2.3 → cvmatrix-3.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cvmatrix"
-version = "3.2.3"
+version = "3.3.0"
 description = "Fast computation of possibly weighted and possibly centered/scaled training set kernel matrices in a cross-validation setting."
 authors = [{ name = "Sm00thix", email = "oleemail@icloud.com" }]
 maintainers = [{ name = "Sm00thix", email = "oleemail@icloud.com" }]
@@ -14,6 +14,7 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
     "Programming Language :: Python :: 3.15",
+    "Programming Language :: Python :: Free Threading :: 3 - Stable",
 ]
 dependencies = [
     "numpy>=2.0.0,<3.0.0",

{cvmatrix-3.2.3 → cvmatrix-3.3.0}/tests/test_cvmatrix.py

@@ -15,8 +15,12 @@ Author: Ole-Christian Galbo Engstrøm
 E-mail: ocge@foss.dk
 """
 
+import multiprocessing
+import pickle
 import sys
 from collections.abc import Hashable
+from concurrent.futures import ProcessPoolExecutor
+from copy import deepcopy
 from itertools import product
 from typing import Iterable, Union
 
@@ -682,6 +686,177 @@ class TestClass:
         (XTWX, _), _ = jax.jit(cvm.training_XTX_XTY)(jnp.asarray(degenerate_val))
         assert XTWX.shape == (4, 4)
 
+    def test_compute_matrix_products(self):
+        """
+        Tests that `compute_XTX` and `compute_XTY` control which dataset-wide matrix
+        products `fit` computes, that the training methods needing a product that is
+        not computed raise a ValueError, and that the remaining methods give the same
+        results as when both products are computed.
+        """
+
+        def leaves(result):
+            if isinstance(result, tuple):
+                return [leaf for r in result for leaf in leaves(r)]
+            return [result]
+
+        X = self.load_X()[:, :5]
+        Y = self.load_Y(["Protein", "Moisture"])
+        weights = self.load_weights(random=True)
+        folds = self.load_Y(["split"]).squeeze()
+        p = Partitioner(folds)
+        val_indices = p.get_validation_indices(next(iter(p.folds_dict)))
+        reference = CVMatrix(backend=self.backend)
+        reference.fit(X, Y, weights)
+        for compute_XTX, compute_XTY in product([True, False], repeat=2):
+            fast = CVMatrix(
+                backend=self.backend, compute_XTX=compute_XTX, compute_XTY=compute_XTY
+            )
+            fast.fit(X, Y, weights)
+            assert (fast.XTX is not None) == compute_XTX
+            assert (fast.XTY is not None) == compute_XTY
+            allowed = {
+                "training_XTX": compute_XTX,
+                "training_XTY": compute_XTY,
+                "training_XTX_XTY": compute_XTX and compute_XTY,
+                "training_statistics": True,
+            }
+            for method, is_allowed in allowed.items():
+                if not is_allowed:
+                    with pytest.raises(ValueError, match="was not computed by `fit`"):
+                        getattr(fast, method)(val_indices)
+                    continue
+                actual = leaves(getattr(fast, method)(val_indices))
+                desired = leaves(getattr(reference, method)(val_indices))
+                assert len(actual) == len(desired)
+                for a, d in zip(actual, desired):
+                    if d is None:
+                        assert a is None
+                    else:
+                        assert_allclose(a, d)
+
+        # The check is on the fitted products, not the flags, so changing a flag after
+        # `fit` still raises the documented ValueError.
+        fast = CVMatrix(backend=self.backend, compute_XTX=False, compute_XTY=False)
+        fast.fit(X, Y, weights)
+        fast.compute_XTX = fast.compute_XTY = True
+        for method in ("training_XTX", "training_XTY", "training_XTX_XTY"):
+            with pytest.raises(ValueError, match="was not computed by `fit`"):
+                getattr(fast, method)(val_indices)
+
+    def test_refit_resets_Y_derived_state(self):
+        """
+        Tests that re-fitting replaces all state derived from `Y` instead of keeping
+        it from the previous fit: re-fitting without `Y` resets `XTY`, `WY`, `sum_Y`,
+        `sq_Y`, and `sum_sq_Y` to `None`, and re-fitting with weights that do not need
+        `WY` resets `WY` to `None` instead of keeping the previous `Y`.
+        """
+        X = self.load_X()[:, :5]
+        Y = self.load_Y(["Protein", "Moisture"])
+        weights = self.load_weights(random=True)
+        Y_derived = ("XTY", "WY", "sum_Y", "sq_Y", "sum_sq_Y")
+        fast = CVMatrix(backend=self.backend)
+        fast.fit(X, Y, weights)
+        assert all(getattr(fast, attr) is not None for attr in Y_derived)
+        fast.fit(X, None, weights)
+        assert all(getattr(fast, attr) is None for attr in Y_derived)
+
+        fast = CVMatrix(
+            center_X=False, center_Y=False, scale_X=False, scale_Y=False,
+            backend=self.backend,
+        )
+        fast.fit(X, Y)  # Unweighted: `WY` is `Y` itself.
+        assert fast.WY is fast.Y
+        fast.fit(X, Y, weights)  # Weighted, but no statistics of `Y` are needed.
+        assert fast.WY is None
+
+    def test_get_val_matrices_returns_only_requested(self):
+        """
+        Tests that `_get_val_matrices` gathers only the requested validation set
+        matrices, returning `None` for the others, that the requested ones equal the
+        validation rows of `WX`, `X`, `WY`, and `Y`, and that without weights a
+        weighted and unweighted matrix requested together share a single gather.
+        """
+        X = self.load_X()[:, :5]
+        Y = self.load_Y(["Protein", "Moisture"])
+        val_indices = np.arange(0, X.shape[0], 7)
+        for weights in (None, self.load_weights(random=True)):
+            fast = CVMatrix(backend=self.backend)
+            fast.fit(X, Y, weights)
+            w = np.ones((X.shape[0], 1)) if weights is None else weights[:, None]
+            expected = (X * w, X, Y * w, Y)
+            for flags in product([True, False], repeat=4):
+                result = fast._get_val_matrices(
+                    val_indices,
+                    return_X_val=flags[0],
+                    return_X_val_unweighted=flags[1],
+                    return_Y_val=flags[2],
+                    return_Y_val_unweighted=flags[3],
+                )
+                for requested, mat_val, mat in zip(flags, result, expected):
+                    if requested:
+                        assert_allclose(mat_val, mat[val_indices])
+                    else:
+                        assert mat_val is None
+                if weights is None:
+                    if flags[0] and flags[1]:
+                        assert result[0] is result[1]
+                    if flags[2] and flags[3]:
+                        assert result[2] is result[3]
+
+    def test_pickle(self):
+        """
+        Tests that a fitted CVMatrix survives a round trip through the standard
+        library's pickle and through copy.deepcopy, which uses the same protocol, with
+        the same settings and results, although it holds the array namespace module
+        `xp`, which cannot be pickled.
+        """
+        X = self.load_X()[:, :5]
+        Y = self.load_Y(["Protein", "Moisture"])
+        weights = self.load_weights(random=True)
+        val_indices = np.arange(0, X.shape[0], 7)
+        fast = CVMatrix(backend=self.backend, compute_XTX=False)
+        fast.fit(X, Y, weights)
+        XTY, stats = fast.training_XTY(val_indices)
+        # Only bytes pickled by this test itself are unpickled, so Bandit's B301
+        # concern about deserializing untrusted data does not apply.
+        unpickled = pickle.loads(pickle.dumps(fast))  # nosec B301
+        for clone in (unpickled, deepcopy(fast)):
+            assert type(clone) is CVMatrix
+            assert clone.xp is fast.xp
+            assert clone.XTX is None and not clone.compute_XTX
+            clone_XTY, clone_stats = clone.training_XTY(val_indices)
+            assert_allclose(clone_XTY, XTY)
+            self.check_equivalent_stats(stats, clone_stats)
+
+    def test_process_pool(self):
+        """
+        Tests that a fitted CVMatrix can be used from worker processes of
+        concurrent.futures.ProcessPoolExecutor, which pickles with the standard
+        library. The workers are started with `spawn`, i.e., as fresh interpreters (the
+        default on Windows and macOS). With the jax backend, this also checks that
+        float64 data stays float64 in a fresh process, where JAX's 64-bit mode is
+        initially disabled.
+        """
+        X = self.load_X()[:, :5]
+        Y = self.load_Y(["Protein", "Moisture"])
+        weights = self.load_weights(random=True)
+        p = Partitioner(self.load_Y(["split"]).squeeze())
+        val_indices = [p.get_validation_indices(fold) for fold in p.folds_dict]
+        fast = CVMatrix(backend=self.backend)
+        fast.fit(X, Y, weights)
+        with ProcessPoolExecutor(
+            max_workers=2, mp_context=multiprocessing.get_context("spawn")
+        ) as executor:
+            results = list(executor.map(fast.training_XTX_XTY, val_indices))
+        for indices, ((XTX, XTY), stats) in zip(val_indices, results):
+            (expected_XTX, expected_XTY), expected_stats = fast.training_XTX_XTY(
+                indices
+            )
+            assert np.asarray(XTX).dtype == np.asarray(XTY).dtype == np.float64
+            assert_allclose(XTX, expected_XTX, rtol=1e-12)
+            assert_allclose(XTY, expected_XTY, rtol=1e-12)
+            self.check_equivalent_stats(expected_stats, stats, atol=1e-12)
+
     def test_naive_hadamard_vs_matmul(self):
         """
         Tests if the NaiveCVMatrix model gives the same result when using Hadamard

{cvmatrix-3.2.3 → cvmatrix-3.3.0}/uv.lock

@@ -1,5 +1,5 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10, <3.16"
 resolution-markers = [
     "python_full_version >= '3.14' and sys_platform == 'win32'",
@@ -159,7 +159,7 @@ wheels = [
 
 [package.optional-dependencies]
 toml = [
-    { name = "tomli", marker = "python_full_version < '3.11'" },
+    { name = "tomli" },
 ]
 
 [[package]]
@@ -304,7 +304,7 @@ wheels = [
 
 [[package]]
 name = "cvmatrix"
-version = "3.2.3"
+version = "3.3.0"
 source = { editable = "." }
 dependencies = [
     { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
@@ -350,7 +350,7 @@ name = "exceptiongroup"
 version = "1.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+    { name = "typing-extensions" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" }
 wheels = [
@@ -374,11 +374,11 @@ resolution-markers = [
     "python_full_version < '3.11'",
 ]
 dependencies = [
-    { name = "jaxlib", version = "0.6.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "ml-dtypes", marker = "python_full_version < '3.11'" },
-    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "opt-einsum", marker = "python_full_version < '3.11'" },
-    { name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "jaxlib", version = "0.6.2", source = { registry = "https://pypi.org/simple" } },
+    { name = "ml-dtypes" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" } },
+    { name = "opt-einsum" },
+    { name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple" } },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/cf/1e/267f59c8fb7f143c3f778c76cb7ef1389db3fd7e4540f04b9f42ca90764d/jax-0.6.2.tar.gz", hash = "sha256:a437d29038cbc8300334119692744704ca7941490867b9665406b7f90665cd96", size = 2334091, upload-time = "2025-06-17T23:10:27.186Z" }
 wheels = [
@@ -395,11 +395,11 @@ resolution-markers = [
     "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32'",
 ]
 dependencies = [
-    { name = "jaxlib", version = "0.10.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" },
-    { name = "ml-dtypes", marker = "python_full_version == '3.11.*'" },
-    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" },
-    { name = "opt-einsum", marker = "python_full_version == '3.11.*'" },
-    { name = "scipy", version = "1.17.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" },
+    { name = "jaxlib", version = "0.10.2", source = { registry = "https://pypi.org/simple" } },
+    { name = "ml-dtypes" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" } },
+    { name = "opt-einsum" },
+    { name = "scipy", version = "1.17.1", source = { registry = "https://pypi.org/simple" } },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/d2/73/eb91d98fcadfa2cbcfdd4e417ab116e47eb20882acc5ee678e47c35d6b57/jax-0.10.2.tar.gz", hash = "sha256:bf77428a8c2e6904c4f46d5ab12aa5cfc6cad2179f07f7e4c0fc75ac86ef0639", size = 2775110, upload-time = "2026-06-17T23:44:57.818Z" }
 wheels = [
@@ -422,11 +422,11 @@ resolution-markers = [
     "python_full_version == '3.12.*' and sys_platform != 'emscripten' and sys_platform != 'win32'",
 ]
 dependencies = [
-    { name = "jaxlib", version = "0.12.0.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
-    { name = "ml-dtypes", marker = "python_full_version >= '3.12'" },
-    { name = "numpy", version = "2.5.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
-    { name = "opt-einsum", marker = "python_full_version >= '3.12'" },
-    { name = "scipy", version = "1.18.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
+    { name = "jaxlib", version = "0.12.0.1", source = { registry = "https://pypi.org/simple" } },
+    { name = "ml-dtypes" },
+    { name = "numpy", version = "2.5.4", source = { registry = "https://pypi.org/simple" } },
+    { name = "opt-einsum" },
+    { name = "scipy", version = "1.18.1", source = { registry = "https://pypi.org/simple" } },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/2e/5b/5b7f007852809973310ed99eede7db6e9e1cd60914f8fe90b091ae264db4/jax-0.12.0.1.tar.gz", hash = "sha256:f543fb1151c351d328b7dd9e40865c01bf9ae10cdf7e21637196172891d51914", size = 3024361, upload-time = "2026-10-21T21:07:07.969Z" }
 wheels = [
@@ -441,9 +441,9 @@ resolution-markers = [
     "python_full_version < '3.11'",
 ]
 dependencies = [
-    { name = "ml-dtypes", marker = "python_full_version < '3.11'" },
-    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "ml-dtypes" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" } },
+    { name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple" } },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/15/c5/41598634c99cbebba46e6777286fb76abc449d33d50aeae5d36128ca8803/jaxlib-0.6.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:da4601b2b5dc8c23d6afb293eacfb9aec4e1d1871cb2f29c5a151d103e73b0f8", size = 54298019, upload-time = "2025-06-17T23:10:36.916Z" },
@@ -476,9 +476,9 @@ resolution-markers = [
     "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32'",
 ]
 dependencies = [
-    { name = "ml-dtypes", marker = "python_full_version == '3.11.*'" },
-    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" },
-    { name = "scipy", version = "1.17.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" },
+    { name = "ml-dtypes" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" } },
+    { name = "scipy", version = "1.17.1", source = { registry = "https://pypi.org/simple" } },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/b2/2c/7038fc73154307389631b5b2dbe5ac529e1918eecc19a27e6644ad114bbf/jaxlib-0.10.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5a98873fc867623b81f2bee15d554b8edd6588a183d01fa50d21b1e3db96ff2b", size = 61429039, upload-time = "2026-06-17T23:43:44.858Z" },
@@ -521,9 +521,9 @@ resolution-markers = [
     "python_full_version == '3.12.*' and sys_platform != 'emscripten' and sys_platform != 'win32'",
 ]
 dependencies = [
-    { name = "ml-dtypes", marker = "python_full_version >= '3.12'" },
-    { name = "numpy", version = "2.5.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
-    { name = "scipy", version = "1.18.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
+    { name = "ml-dtypes" },
+    { name = "numpy", version = "2.5.4", source = { registry = "https://pypi.org/simple" } },
+    { name = "scipy", version = "1.18.1", source = { registry = "https://pypi.org/simple" } },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/17/73/47d66eeab3bb5a48009772f4fa572e46bdf8049ecb180f83d544c933462f/jaxlib-0.12.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:db2cc8584d7d0d166293ef2475b726988a10f6f9b5a8e3b8e3712415e5570380", size = 60710018, upload-time = "2026-10-21T21:05:22.443Z" },
@@ -861,10 +861,10 @@ resolution-markers = [
     "python_full_version < '3.11'",
 ]
 dependencies = [
-    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "python-dateutil", marker = "python_full_version < '3.11'" },
-    { name = "pytz", marker = "python_full_version < '3.11'" },
-    { name = "tzdata", marker = "python_full_version < '3.11'" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" } },
+    { name = "python-dateutil" },
+    { name = "pytz" },
+    { name = "tzdata" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", hash = "sha256:e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b", size = 4495223, upload-time = "2025-09-29T23:34:51.853Z" }
 wheels = [
@@ -936,10 +936,10 @@ resolution-markers = [
     "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32'",
 ]
 dependencies = [
-    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
     { name = "numpy", version = "2.5.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
-    { name = "python-dateutil", marker = "python_full_version >= '3.11'" },
-    { name = "tzdata", marker = "(python_full_version >= '3.11' and sys_platform == 'emscripten') or (python_full_version >= '3.11' and sys_platform == 'win32')" },
+    { name = "python-dateutil" },
+    { name = "tzdata", marker = "sys_platform == 'emscripten' or sys_platform == 'win32'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/55/b1/a10c0d1a7e3ce44eb42635771004aa503e3b9ddde0bd39c524dda65f7eff/pandas-3.1.0.tar.gz", hash = "sha256:ecb9b2d8a817b1e1ba1fdb90c0abe9eab31b4fdf2562b7a56b86ac66ace17e49", size = 5933421, upload-time = "2026-10-22T11:57:03.087Z" }
 wheels = [
@@ -1108,7 +1108,7 @@ resolution-markers = [
     "python_full_version < '3.11'",
 ]
 dependencies = [
-    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" } },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/0f/37/6964b830433e654ec7485e45a00fc9a27cf868d622838f6b6d9c5ec0d532/scipy-1.15.3.tar.gz", hash = "sha256:eae3cf522bc7df64b42cad3925c876e1b0b6c35c1337c93e12c0f366f55b0eaf", size = 59419214, upload-time = "2025-05-08T16:13:05.955Z" }
 wheels = [
@@ -1169,7 +1169,7 @@ resolution-markers = [
     "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32'",
 ]
 dependencies = [
-    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" } },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", hash = "sha256:95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0", size = 30573822, upload-time = "2026-02-23T00:26:24.851Z" }
 wheels = [
@@ -1251,7 +1251,7 @@ resolution-markers = [
     "python_full_version == '3.12.*' and sys_platform != 'emscripten' and sys_platform != 'win32'",
 ]
 dependencies = [
-    { name = "numpy", version = "2.5.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
+    { name = "numpy", version = "2.5.4", source = { registry = "https://pypi.org/simple" } },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/7e/74/66de6258867beb2ef08f35f9f2ac017a52cacd5081714d239ff1a442d458/scipy-1.18.1.tar.gz", hash = "sha256:52c4b7422442aba924d03ad4019852b08a92e64ea187b933135687bfe2747307", size = 30781235, upload-time = "2026-08-21T23:28:50.599Z" }
 wheels = [