diff --git a/.github/workflows/build_dist.yml b/.github/workflows/build_dist.yml index 95fc29b..238b400 100644 --- a/.github/workflows/build_dist.yml +++ b/.github/workflows/build_dist.yml @@ -51,6 +51,9 @@ jobs: uv version ${{steps.version.outputs.new_tag}} uv lock + - name: Install Rust toolchain + uses: dtolnay/rust-toolchain@stable + - name: Build dist run: | uv run python -m build --sdist --wheel --no-isolation --outdir dist/ . diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index cb599e5..e3936e8 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -37,6 +37,10 @@ jobs: run: | uv venv .venv uv sync --locked --dev --extra cpu + - name: Install Rust toolchain + uses: dtolnay/rust-toolchain@stable + - name: Build native extension + run: uv run maturin develop -m rust/Cargo.toml - name: Test Linting run: | uv run ruff format --check src tests @@ -99,6 +103,10 @@ jobs: run: | uv venv .venv uv sync --locked --dev --extra cpu + - name: Install Rust toolchain + uses: dtolnay/rust-toolchain@stable + - name: Build native extension + run: uv run maturin develop -m rust/Cargo.toml - name: Test Unittests with pytest run: | uv run pytest tests --session-timeout=600 diff --git a/.gitignore b/.gitignore index 840287c..59da262 100644 --- a/.gitignore +++ b/.gitignore @@ -306,3 +306,4 @@ tmp_report_dir coverage.json dist/*.whl dist/*.tar.gz +/.claude diff --git a/README.md b/README.md index e2c9feb..b205141 100644 --- a/README.md +++ b/README.md @@ -44,6 +44,43 @@ uv sync --dev --extra cpu Use the `cu128` or `cu130` extra instead of `cpu` to install a CUDA-enabled build of PyTorch. See [.github/CONTRIBUTING.md](.github/CONTRIBUTING.md) for the full contribution workflow. +### Native acceleration (optional) + +A Rust-accelerated signed-Pfaffian strategy (`RustPfaffianParlettReid`) is available when the +package is built with its native extension. Building from source requires a Rust toolchain +(); the project builds with [maturin](https://www.maturin.rs): + +```bash +uv run maturin develop --release -m rust/Cargo.toml +``` + +Use `--release` for an optimized build: `maturin develop` compiles in debug mode by default, +which makes the Rust kernel much slower. Installing a prebuilt wheel (or `maturin build`) is already +optimized, so this only matters for local development builds. + +If the native extension is not present, the package still works using the pure-Python strategies. + + +## Usage + +```python +import torch + +from torch_pfaffian import pfaffian + +# Any skew-symmetric matrix of shape (..., 2n, 2n). +matrix = torch.tensor([[0.0, -3.0], [3.0, 0.0]]) + +pf = pfaffian(matrix) # signed Pfaffian (default) +magnitude = pfaffian(matrix, sign=False) # |pf|, using the faster det-based path +``` + +`pfaffian()` selects a strategy from the input: `sign=True` (the default) returns the +**signed** Pfaffian, using the native `RustPfaffianParlettReid` when the extension is built and +falling back to the pure-Python `PfaffianParlettReid` otherwise; `sign=False` returns the magnitude +using a determinant-based strategy (`PfaffianFDBPf` when gradients are needed, otherwise +`PfaffianDet`). For explicit strategy selection, use `get_pfaffian_function(name)`. + # Important Links - Documentation at [https://MatchCake.github.io/TorchPfaffian/](https://MatchCake.github.io/TorchPfaffian/). diff --git a/archives/_pfaffian.py b/archives/_pfaffian.py deleted file mode 100644 index 13b4aed..0000000 --- a/archives/_pfaffian.py +++ /dev/null @@ -1,378 +0,0 @@ -""" -TODO: This file is a temporary file to test the implementation of the `pfaffian` functions. - -This file will be deleted before the final submission. -It is used as a reference to implement the `pfaffian` functions. -""" - -import warnings -from typing import Literal, Optional, Union - -import numpy as np -import pennylane as qml -import tqdm - -from torch_pfaffian import Pfaffian - - -class TensorLike: - pass - - -def convert_and_cast_like(*args, **kwargs): - return qml.math.convert_like(*args, **kwargs) - - -def _pivot(__matrix, k, kp): - matrix = qml.math.ones_like(__matrix) * __matrix - matrix_shape = qml.math.shape(matrix) - indexes_to_pivot = np.arange(matrix_shape[0]) - if len(matrix_shape) == 2: - matrix[..., [kp, k + 1], k:] = matrix[..., [k + 1, kp], k:] - matrix[..., k:, [kp, k + 1]] = matrix[..., k:, [k + 1, kp]] - return matrix - - # interchange rows k+1 and kp - kp_sub_matrix = matrix[indexes_to_pivot, kp, k:] - temp = qml.math.ones_like(kp_sub_matrix) * kp_sub_matrix - matrix[indexes_to_pivot, kp, k:] = matrix[indexes_to_pivot, k + 1, k:] - matrix[indexes_to_pivot, k + 1, k:] = temp - - # Then interchange columns k+1 and kp - kp_sub_matrix = matrix[indexes_to_pivot, k:, kp] - temp = qml.math.ones_like(kp_sub_matrix) * kp_sub_matrix - matrix[indexes_to_pivot, k:, kp] = matrix[indexes_to_pivot, k:, k + 1] - matrix[indexes_to_pivot, k:, k + 1] = temp - return matrix - - -def _compute_gauss_vector(__matrix, k): - zero_like = convert_and_cast_like(0, __matrix) - tau_norm = __matrix[..., k, k + 1][..., None] - zero_mask = qml.math.isclose(tau_norm, zero_like) - tau = qml.math.where(zero_mask, zero_like, __matrix[..., k, k + 2 :] / tau_norm) - return tau - - -def _update_matrix_block_kp2_kp2(__matrix, k, tau): - add_matrix = qml.math.zeros_like(__matrix) - add_matrix[..., k + 2 :, k + 2 :] += qml.math.einsum( - "...i,...j->...ij", tau, __matrix[..., k + 2 :, k + 1] - ) - qml.math.einsum("...i,...j->...ij", __matrix[..., k + 2 :, k + 1], tau) - return __matrix + add_matrix - - -def batch_pfaffian_ltl( - __matrix: TensorLike, - overwrite_input: bool = False, - test_input: bool = False, - p_bar: Optional[tqdm.tqdm] = None, - show_progress: bool = False, -) -> Union[float, complex, TensorLike]: - r""" - Compute the Pfaffian of a real or complex skew-symmetric - matrix A (A=-A^T). If overwrite_a=True, the matrix A - is overwritten in the process. This function uses - the Parlett-Reid algorithm. - - This code is adapted of the function `pfaffian_LTL` - from https://github.com/basnijholt/pfapack/blob/master/pfapack/pfaffian.py. - - :param __matrix: Matrix to compute the Pfaffian of - :type __matrix: TensorLike - :param overwrite_input: Whether to overwrite the input matrix - :type overwrite_input: bool - :param test_input: Whether to test the input matrix for skew-symmetry - :type test_input: bool - :param p_bar: Progress bar - :type p_bar: Optional[tqdm.tqdm] - :param show_progress: Whether to show progress bar. If no progress bar is provided, a new one is created - :type show_progress: bool - - :return: Pfaffian of the matrix - :rtype: Union[float, complex, TensorLike] - """ - if overwrite_input: - matrix = __matrix - else: - matrix = qml.math.ones_like(__matrix) * __matrix - shape = qml.math.shape(matrix) - n, m = shape[-2:] - p_bar = p_bar or tqdm.tqdm(range(0, n - 1, 2), disable=not show_progress) - - if test_input: - p_bar.set_description("Testing input matrix") - # Check if matrix is square - assert shape[-2] == shape[-1] > 0 - # Check if it's skew-symmetric - matrix_t = qml.math.einsum("...ij->...ji", matrix) - assert qml.math.allclose(matrix, -matrix_t) - - matrix = qml.math.cast(matrix, dtype=complex) - zero_like = convert_and_cast_like(0, matrix) - pfaffian_val = qml.math.convert_like(np.ones(shape[:-2], dtype=complex), matrix) - - # Quick return if possible - if n % 2 == 1: - p_bar.n = n // 2 - p_bar.set_description("Odd-sized matrix") - p_bar.close() - return pfaffian_val * zero_like * matrix[..., 0, 0] # 0.0 but with require grad if needed - - p_bar.set_description(f"Computing Pfaffian of {shape} matrix") - for k in p_bar: - # First, find the largest entry in A[k+1:,k] and permute it to A[k+1,k] - kp = k + 1 + qml.math.abs(matrix[..., k + 1 :, k]).argmax(-1) - kp1 = qml.math.convert_like(k + 1, kp) - - # Check if we need to pivot - pivot_condition = ~qml.math.isclose(kp, kp1) - # interchange rows and cols k+1 and kp (pivot if needed) - matrix = qml.math.where(pivot_condition[..., None, None], _pivot(matrix, k, kp), matrix) - # every interchange corresponds to a "-" in det(P) - pfaffian_val *= qml.math.where(pivot_condition, -1.0, 1.0) - - # if we encounter a zero on the super/subdiagonal, the Pfaffian is 0 - zero_ss_condition = qml.math.isclose(matrix[..., k + 1, k], zero_like) - pfaffian_val *= qml.math.where(zero_ss_condition, zero_like, matrix[..., k, k + 1]) - if qml.math.all(zero_ss_condition): - p_bar.n = n // 2 - p_bar.set_description("Pfaffian is zero") - p_bar.close() - return pfaffian_val - - if k + 2 < n: - tau = _compute_gauss_vector(matrix, k) - # Update the matrix block A(k+2:,k+2) - matrix = _update_matrix_block_kp2_kp2(matrix, k, tau) - - p_bar.set_description("Pfaffian computed") - p_bar.close() - return pfaffian_val - - -def batch_householder_complex(x: TensorLike): - """(v, tau, alpha) = householder_real(x) - - Compute a Householder transformation such that - (1-tau v v^T) x = alpha e_1 - where x and v a complex vectors, tau is 0 or 2, and - alpha a complex number (e_1 is the first unit vector) - """ - sigma = qml.math.einsum("...i,...i->...", qml.math.conjugate(x[..., 1:]), x[..., 1:]) - - # if sigma == 0: - # return qml.math.zeros_like(x), 0, x[..., 0] - # else: - norm_x = qml.math.sqrt(qml.math.conjugate(x[..., 0]) * x[..., 0] + sigma) - - v = qml.math.ones_like(x) * x - phase = qml.math.exp(1j * qml.math.arctan2(qml.math.imag(x[..., 0]), qml.math.real(x[..., 0]))) - v[..., 0] = v[..., 0] + phase * norm_x - - v_frobenius_norm = qml.math.einsum("...i,...i->...", qml.math.conjugate(v), v) ** 0.5 - v = v / v_frobenius_norm[..., None] - - tau = convert_and_cast_like(2.0 + 0.0j, x) - return v, tau, -phase * norm_x - - -def _eliminate_ith_column_householder(matrix, i, alpha): - """ - Eliminate the i-th column of the matrix using the Householder transformation. - Equivalent to: - - matrix[..., i + 1, i] = alpha - matrix[..., i, i + 1] = -alpha - matrix[..., i + 2:, i] = zero_like - matrix[..., i, i + 2:] = zero_like - - :param matrix: - :param i: - :param alpha: - :return: - """ - zero_like = convert_and_cast_like(0, matrix) - - where_mask = qml.math.cast(qml.math.zeros_like(matrix), dtype=bool) - where_mask[..., i + 1, i] = True - where_mask[..., i, i + 1] = True - where_mask[..., i + 2 :, i] = True - where_mask[..., i, i + 2 :] = True - - values = qml.math.zeros_like(matrix) - values[..., i + 1, i] = alpha - values[..., i, i + 1] = -alpha - values[..., i + 2 :, i] = zero_like - values[..., i, i + 2 :] = zero_like - - matrix = qml.math.where(where_mask, values, matrix) - return matrix - - -def _update_matrix_block_householder(matrix, i, v, tau): - """ - Update the matrix block A(i+1:N,i+1:N) using the Householder transformation. - Equivalent to: - - w = tau * A(i+1:N,i+1:N) @ v - A(i+1:N,i+1:N) -= 2 * v @ w^T - - :param matrix: - :param i: - :param v: - :param tau: - :return: - """ - w = tau * qml.math.einsum("...ij,...j->...i", matrix[..., i + 1 :, i + 1 :], qml.math.conjugate(v)) - values = qml.math.zeros_like(matrix) - values[..., i + 1 :, i + 1 :] += qml.math.einsum("...i,...j->...ij", v, w) - qml.math.einsum( - "...i,...j->...ij", w, v - ) - return matrix + values - - -def batch_pfaffian_householder( - __matrix: TensorLike, - overwrite_input: bool = False, - test_input: bool = False, - p_bar: Optional[tqdm.tqdm] = None, - show_progress: bool = False, -): - """pfaffian(A, overwrite_a=False) - - Compute the Pfaffian of a real or complex skew-symmetric - matrix A (A=-A^T). If overwrite_a=True, the matrix A - is overwritten in the process. This function uses the - Householder tridiagonalization. - - Note that the function pfaffian_schur() can also be used in the - real case. That function does not make use of the skew-symmetry - and is only slightly slower than pfaffian_householder(). - """ - if overwrite_input: - matrix = __matrix - else: - matrix = qml.math.ones_like(__matrix) * __matrix - shape = qml.math.shape(matrix) - n, m = shape[-2:] - p_bar = p_bar or tqdm.tqdm(range(n - 2), disable=not show_progress) - - if test_input: - p_bar.set_description("Testing input matrix") - # Check if matrix is square - assert shape[-2] == shape[-1] > 0 - # Check if it's skew-symmetric - matrix_t = qml.math.einsum("...ij->...ji", matrix) - assert qml.math.allclose(matrix, -matrix_t) - - matrix = qml.math.cast(matrix, dtype=complex) - zero_like = convert_and_cast_like(0, matrix) - pfaffian_val = qml.math.convert_like(np.ones(shape[:-2], dtype=complex), matrix) - - # Quick return if possible - if n % 2 == 1: - p_bar.set_description("Odd-sized matrix") - p_bar.close() - return pfaffian_val * zero_like * matrix[..., 0, 0] # 0.0 but with require grad if needed - - p_bar.set_description(f"Computing Pfaffian of {shape} matrix") - for i in p_bar: - # Find a Householder vector to eliminate the i-th column - v, tau, alpha = batch_householder_complex(matrix[..., i + 1 :, i]) - matrix = _eliminate_ith_column_householder(matrix, i, alpha) - matrix = _update_matrix_block_householder(matrix, i, v, tau) - - pfaffian_val = pfaffian_val * qml.math.where(qml.math.isclose(tau, zero_like), 1, 1 - tau) - if i % 2 == 0: - pfaffian_val = pfaffian_val * -alpha - - pfaffian_val = pfaffian_val * matrix[..., n - 2, n - 1] - p_bar.set_description("Pfaffian computed") - p_bar.close() - return pfaffian_val - - -def pfaffian_by_det( - __matrix: TensorLike, p_bar: Optional[tqdm.tqdm] = None, show_progress: bool = False, epsilon: float = 1e-12 -): - shape = qml.math.shape(__matrix) - p_bar = p_bar or tqdm.tqdm(total=1, disable=not show_progress) - p_bar.set_description(f"Computing determinant of {shape} matrix") - backend = qml.math.get_interface(__matrix) - if backend in ["autograd", "numpy"]: - det = qml.math.linalg.det(__matrix) - pf = qml.math.sqrt(qml.math.abs(det) + epsilon) - elif backend == "torch": - pf = Pfaffian.apply(__matrix) - else: - det = qml.math.det(__matrix) - pf = qml.math.sqrt(qml.math.abs(det) + epsilon) - p_bar.set_description(f"Determinant of {shape} matrix computed") - p_bar.update() - p_bar.close() - return pf - - -def pfaffian( - __matrix: TensorLike, - overwrite_input: bool = False, - method: Literal["P", "H", "det", "bLTL", "bH"] = "bLTL", - epsilon: float = 1e-12, - p_bar: Optional[tqdm.tqdm] = None, - show_progress: bool = False, -) -> Union[float, complex, TensorLike]: - """pfaffian(A, overwrite_a=False, method='P') - - Compute the Pfaffian of a real or complex skew-symmetric - matrix A (A=-A^T). If overwrite_a=True, the matrix A - is overwritten in the process. This function uses - either the Parlett-Reid algorithm (method='P', default), - or the Householder tridiagonalization (method='H'). - - This code is adapted of the function `pfaffian` - from https://github.com/basnijholt/pfapack/blob/master/pfapack/pfaffian.py. - - :param __matrix: Matrix to compute the Pfaffian of - :type __matrix: TensorLike - :param overwrite_input: Whether to overwrite the input matrix - :type overwrite_input: bool - :param method: Method to use. 'P' for Parlett-Reid algorithm, 'H' for Householder tridiagonalization, - 'det' for determinant, 'bLTL' for batched Parlett-Reid algorithm - :type method: Literal["P", "H", "det", "bLTL"] - :param epsilon: Tolerance for the determinant method - :type epsilon: float - :param p_bar: Progress bar - :type p_bar: Optional[tqdm.tqdm] - :param show_progress: Whether to show progress bar. If no progress bar is provided, a new one is created - :type show_progress: bool - :return: Pfaffian of the matrix - :rtype: Union[float, complex, TensorLike] - """ - shape = qml.math.shape(__matrix) - assert shape[-2] == shape[-1] > 0, "Matrix must be square" - - if method == "P": - from pfapack.pfaffian import pfaffian - - warnings.warn( - "The method 'P' is not implemented yet. It is recommended to use the method 'det' instead.", - UserWarning, - ) - return pfaffian(__matrix, overwrite_input, method="P") - elif method == "H": - from pfapack.pfaffian import pfaffian_householder - - warnings.warn( - "The method 'H' is not implemented yet. It is recommended to use the method 'det' instead.", - UserWarning, - ) - return pfaffian_householder(__matrix, overwrite_input) - elif method == "det": - return pfaffian_by_det(__matrix, p_bar=p_bar, show_progress=show_progress, epsilon=epsilon) - elif method == "bLTL": - return batch_pfaffian_ltl(__matrix, overwrite_input, show_progress=show_progress, p_bar=p_bar) - elif method == "bH": - return batch_pfaffian_householder(__matrix, overwrite_input, show_progress=show_progress, p_bar=p_bar) - else: - raise ValueError(f"Invalid method. Got {method}, must be 'P', 'H', 'det', 'bLTL', or 'bH'.") diff --git a/archives/_test_pfaffian.py b/archives/_test_pfaffian.py deleted file mode 100644 index a320154..0000000 --- a/archives/_test_pfaffian.py +++ /dev/null @@ -1,171 +0,0 @@ -import numpy as np -import pytest - -from tests.configs import ( - ATOL_MATRIX_COMPARISON, - ATOL_SCALAR_COMPARISON, - N_RANDOM_TESTS_PER_CASE, - RTOL_MATRIX_COMPARISON, - RTOL_SCALAR_COMPARISON, - TEST_SEED, - set_seed, -) -from torch_pfaffian import utils - -set_seed(TEST_SEED) -MIN_MATRIX_SIZE = 2 -MAX_MATRIX_SIZE = 20 -BATCH_SIZE = 3 -RECOMMENDED_METHODS = ["det", "bLTL", "bH"] - - -def gen_skew_symmetric_matrix_and_det(n, batch_size=None): - if batch_size is None: - matrix = np.random.rand(n, n) - else: - matrix = np.random.rand(batch_size, n, n) - matrix = matrix - np.einsum("...ij->...ji", matrix) - return matrix, np.linalg.det(matrix) - - -@pytest.mark.parametrize( - "matrix, det", - [ - gen_skew_symmetric_matrix_and_det(i, batch_size=None) - for i in range(MIN_MATRIX_SIZE, MAX_MATRIX_SIZE + 1) - for _ in range(N_RANDOM_TESTS_PER_CASE) - ], -) -def test_get_skew_symmetric_matrix_and_det(matrix, det): - try: - from pfapack.pfaffian import pfaffian - except ImportError: - pytest.skip("pfapack is not installed.") - pf = pfaffian(matrix) - np.testing.assert_allclose(pf**2, det, atol=ATOL_SCALAR_COMPARISON, rtol=RTOL_SCALAR_COMPARISON) - - -@pytest.mark.parametrize( - "matrix, det, mth", - [ - (*gen_skew_symmetric_matrix_and_det(i, batch_size=batch_size), mth) - for i in range(MIN_MATRIX_SIZE, MAX_MATRIX_SIZE + 1) - for _ in range(N_RANDOM_TESTS_PER_CASE) - for mth in RECOMMENDED_METHODS - for batch_size in [None, BATCH_SIZE] - ], -) -def test_pfaffian_methods(matrix, det, mth): - pf = utils.pfaffian(matrix, method=mth) - np.testing.assert_allclose(pf**2, det, atol=10 * ATOL_SCALAR_COMPARISON, rtol=10 * RTOL_SCALAR_COMPARISON) - - -@pytest.mark.parametrize( - "matrix, det", - [ - gen_skew_symmetric_matrix_and_det(i, batch_size=BATCH_SIZE) - for i in range(MIN_MATRIX_SIZE, MAX_MATRIX_SIZE + 1) - for _ in range(N_RANDOM_TESTS_PER_CASE) - ], -) -def test_batch_pfaffian_ltl(matrix, det): - pf = utils._pfaffian.batch_pfaffian_ltl(matrix) - np.testing.assert_allclose(pf**2, det, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) - - -@pytest.mark.parametrize( - "matrix, det", - [ - gen_skew_symmetric_matrix_and_det(i, batch_size=BATCH_SIZE) - for i in range(MIN_MATRIX_SIZE, MAX_MATRIX_SIZE + 1) - for _ in range(N_RANDOM_TESTS_PER_CASE) - ], -) -def test_pfaffian_bltl(matrix, det): - pf = utils.pfaffian(matrix, method="bLTL") - np.testing.assert_allclose(pf**2, det, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) - - -@pytest.mark.parametrize( - "matrix, det", - [ - gen_skew_symmetric_matrix_and_det(i, batch_size=batch_size) - for batch_size in [None, 1] - for i in range(MIN_MATRIX_SIZE, MAX_MATRIX_SIZE + 1) - for _ in range(N_RANDOM_TESTS_PER_CASE) - ], -) -def test_pfaffian_bltl_single_item(matrix, det): - pf = utils.pfaffian(matrix, method="bLTL") - np.testing.assert_allclose(pf**2, det, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) - - -@pytest.mark.parametrize( - "n, batch_size, mth", - [ - (i, batch_size, mth) - for i in range(MIN_MATRIX_SIZE, MAX_MATRIX_SIZE + 1, 2) - for _ in range(N_RANDOM_TESTS_PER_CASE) - for mth in RECOMMENDED_METHODS - for batch_size in [None, BATCH_SIZE] - ], -) -def test_pfaffian_methods_grads(n, batch_size, mth): - try: - import torch - except ImportError: - pytest.skip("PyTorch is not installed.") - torch.autograd.set_detect_anomaly(True) - - if batch_size is None: - np_matrix = np.random.rand(n, n) - else: - np_matrix = np.random.rand(batch_size, n, n) - np_matrix = np_matrix - np.einsum("...ij->...ji", np_matrix) - torch_matrix = torch.from_numpy(np_matrix).requires_grad_() - det = torch.det(torch_matrix) - torch_loss = torch.sum(det) - torch_loss.backward() - true_grad = torch_matrix.grad - - matrix = torch.from_numpy(np_matrix).requires_grad_() - pf = utils.pfaffian(matrix, method=mth) - pred_det = torch.real(pf**2) - with torch.no_grad(): - np.testing.assert_allclose(pred_det, det, atol=10 * ATOL_SCALAR_COMPARISON, rtol=10 * RTOL_SCALAR_COMPARISON) - - pred_loss = torch.sum(pred_det) - pred_loss.backward() - pred_grad = matrix.grad - assert pred_grad is not None - if mth == "det": - np.testing.assert_allclose( - torch.abs(pred_grad), torch.abs(true_grad), atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON - ) - - -@pytest.mark.parametrize( - "matrix, det", - [ - gen_skew_symmetric_matrix_and_det(i, batch_size=BATCH_SIZE) - for i in range(MIN_MATRIX_SIZE, MAX_MATRIX_SIZE + 1) - for _ in range(N_RANDOM_TESTS_PER_CASE) - ], -) -def test_pfaffian_bh(matrix, det): - pf = utils.pfaffian(matrix, method="bH") - np.testing.assert_allclose(pf**2, det, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) - - -@pytest.mark.parametrize( - "matrix, det", - [ - gen_skew_symmetric_matrix_and_det(i, batch_size=batch_size) - for batch_size in [None, 1] - for i in range(MIN_MATRIX_SIZE, MAX_MATRIX_SIZE + 1) - for _ in range(N_RANDOM_TESTS_PER_CASE) - ], -) -def test_pfaffian_bltl_single_item(matrix, det): - pf = utils.pfaffian(matrix, method="bH") - np.testing.assert_allclose(pf**2, det, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) diff --git a/archives/pfaffian_perm.py b/archives/pfaffian_perm.py deleted file mode 100644 index fd4ce3c..0000000 --- a/archives/pfaffian_perm.py +++ /dev/null @@ -1,61 +0,0 @@ -import numpy as np -import torch - -from .strategy import PfaffianStrategy - - -class PfaffianPerm(PfaffianStrategy): - """ - This class implements the Pfaffian using the determinant of the matrix for the forward pass and the - derivative of the Pfaffian with respect to the input matrix for the backward pass. - """ - - NAME = "PfaffianPerm" - - @staticmethod - def forward(matrix: torch.Tensor): - _2n = matrix.shape[-1] - if _2n % 2 != 0: - return torch.zeros_like(matrix[..., 0, 0]) - _n = _2n // 2 - # Let P be the set of permutations, {i_1, i_2, ..., i_2n} with respect to {1, 2, ..., 2n}, such that - # i_1 < j_1 < i_2 < j_2 < ... < i_2n < j_2n and i_1 < i_2 < ... < i_2n - indexes = np.arange(_2n) - # _i must be all the vector of length n from indexes. It should look like a sliding windows of size n - _i_starting_idx = np.arange(_n - 1) - _i_matrix = indexes[_i_starting_idx[:, None] + np.arange(_n)] - _j_starting_idx = _i_starting_idx + 1 - _j_matrix = indexes[_j_starting_idx[:, None] + np.arange(_n)] - - # build a matrix of each permutation of i and j where j > i - ij_matrix = np.concatenate( - [ - np.concatenate([_i_matrix[i, :, None], _j_matrix[j, :, None]], axis=-1)[None, ...] - for i in range(_i_matrix.shape[0]) - for j in range(i, _j_matrix.shape[0]) - ], - axis=0, - ) - - pf_matrix = torch.prod(matrix[..., ij_matrix[..., 0], ij_matrix[..., 1]], dim=-1) - delta_ij = ij_matrix[..., 0, 1] - ij_matrix[..., 0, 0] - signs = torch.tensor((-1) ** delta_ij).to(pf_matrix.device) - pf = torch.sum(signs * pf_matrix, dim=-1) - return pf - - @staticmethod - def backward(ctx: torch.autograd.function.FunctionCtx, grad_output): - r""" - - ..math: - \frac{\partial \text{pf}(A)}{\partial A_{ij}} = \frac{\text{pf}(A)}{2} A^{-1}_{ji} - - :param ctx: Context - :param grad_output: Gradient of the output - :return: Gradient of the input - """ - matrix, pf = ctx.saved_tensors - grad_matrix = None - if ctx.needs_input_grad[0]: - grad_matrix = torch.einsum("...,...ij->...ji", 0.5 * grad_output * pf, torch.linalg.pinv(matrix)) - return grad_matrix diff --git a/notebooks/_strategies_benchmark_helpers.py b/notebooks/_strategies_benchmark_helpers.py index e7557d0..824c4d2 100644 --- a/notebooks/_strategies_benchmark_helpers.py +++ b/notebooks/_strategies_benchmark_helpers.py @@ -3,37 +3,61 @@ import matplotlib.pyplot as plt import numpy as np +import pandas as pd +import seaborn as sns import torch from torch.profiler import ProfilerActivity, profile +from tqdm.auto import tqdm +from torch_pfaffian.strategies.pfaffian_block_det import PfaffianBlockDet from torch_pfaffian.strategies.strategy import PfaffianStrategy Strategy = type[PfaffianStrategy] -BenchmarkResults = dict[str, dict[str, list[float]]] +BenchmarkResults = pd.DataFrame METRICS = ("forward_time", "backward_time", "forward_memory", "forward_backward_memory") def make_block_antidiagonal( - n: int, batch_size: int, dtype: torch.dtype = torch.float64, device: str = "cpu" + n: int, batch_size: int, dtype: torch.dtype = torch.float32, device: str = "cpu" ) -> torch.Tensor: """ - Build a batch of block-antidiagonal skew matrices ``[[0, B], [-B^T, 0]]``. + Build a batch of block-antidiagonal skew matrices ``[[0, B], [-B^T, 0]]`` of dimension ``n``. - :param n: Half the matrix dimension; the result has shape ``(batch_size, 2n, 2n)``. + :param n: Matrix dimension (even); the result has shape ``(batch_size, n, n)``. :param batch_size: Number of matrices in the batch. :param dtype: Floating dtype of the matrices. :param device: Device on which to allocate the matrices. - :return: A tensor of shape ``(batch_size, 2n, 2n)``. + :return: A tensor of shape ``(batch_size, n, n)``. :rtype: torch.Tensor """ - block = torch.randn(batch_size, n, n, dtype=dtype, device=device) + half = n // 2 + block = torch.randn(batch_size, half, half, dtype=dtype, device=device) zero = torch.zeros_like(block) top = torch.cat([zero, block], dim=-1) bottom = torch.cat([-block.transpose(-1, -2), zero], dim=-1) return torch.cat([top, bottom], dim=-2) +def make_random_skew(n: int, batch_size: int, dtype: torch.dtype = torch.float32, device: str = "cpu") -> torch.Tensor: + """ + Build a batch of general (dense) random skew-symmetric matrices of dimension ``n``. + + Unlike :func:`make_block_antidiagonal`, the result has no block structure, so it is a + representative input for the strategies that accept any skew-symmetric matrix (every strategy + except ``PfaffianBlockDet``, which only computes the true Pfaffian on block-antidiagonal inputs). + + :param n: Matrix dimension (even); the result has shape ``(batch_size, n, n)``. + :param batch_size: Number of matrices in the batch. + :param dtype: Floating dtype of the matrices. + :param device: Device on which to allocate the matrices. + :return: A tensor of shape ``(batch_size, n, n)``. + :rtype: torch.Tensor + """ + full = torch.randn(batch_size, n, n, dtype=dtype, device=device) + return full - full.transpose(-1, -2) + + def _synchronize(is_cuda: bool) -> None: if is_cuda: torch.cuda.synchronize() @@ -74,13 +98,6 @@ def _forward_backward_call(strategy: Strategy, matrix: torch.Tensor) -> torch.Te return grad_matrix -def _confidence_interval(values: np.ndarray, confidence_z: float = 1.96) -> float: - # Half-width of the normal-approximation confidence interval for the mean. - if values.size < 2: - return 0.0 - return float(confidence_z * values.std(ddof=1) / np.sqrt(values.size)) - - def benchmark_strategies( strategies: list[Strategy], sizes_n: list[int], @@ -88,66 +105,62 @@ def benchmark_strategies( device: str = "cpu", n_seeds: int = 20, n_repeats: int = 3, -) -> BenchmarkResults: +) -> pd.DataFrame: """ Benchmark forward/backward time and memory of each strategy over several random seeds. - For each matrix dimension and strategy the metric is measured once per seed; the returned - values are the across-seed mean and the half-width of the 95% confidence interval. + Returns a tidy DataFrame with one row per (strategy, dimension, seed) combination and one + column per metric. Pass it directly to :func:`plot_results` or use pandas/seaborn to + build custom views. :param strategies: The strategy classes to benchmark (each exposes ``NAME`` and ``apply``). - :param sizes_n: Half-dimensions to sweep; each yields matrices of dimension ``2n``. + :param sizes_n: Matrix dimensions to sweep (even integers); each yields ``n x n`` matrices. :param batch_size: Number of matrices per benchmarked batch. :param device: Device on which to run the benchmark. :param n_seeds: Number of random seeds used to build the confidence intervals. :param n_repeats: Number of timed repeats per seed (the median is kept). - :return: A mapping ``strategy_name -> {"dimension", "_mean", "_ci"}``. - :rtype: dict + :return: A DataFrame with columns ``strategy``, ``dimension``, ``seed``, and one column per + metric in :data:`METRICS`. + :rtype: pandas.DataFrame """ is_cuda = device == "cuda" - results: BenchmarkResults = { - strategy.NAME: { - "dimension": [], - **{f"{metric}_mean": [] for metric in METRICS}, - **{f"{metric}_ci": [] for metric in METRICS}, - } - for strategy in strategies - } - + records = [] + p_bar = tqdm(total=len(sizes_n) * len(strategies) * n_seeds, desc="Benchmarking strategies") for n in sizes_n: - per_seed: dict[str, dict[str, list[float]]] = { - strategy.NAME: {metric: [] for metric in METRICS} for strategy in strategies - } for seed in range(n_seeds): torch.manual_seed(seed) - matrix = make_block_antidiagonal(n, batch_size, dtype=torch.float64, device=device) + # PfaffianBlockDet only returns the true Pfaffian on block-antidiagonal inputs; every + # other strategy is valid on any skew matrix. + block_matrix = make_block_antidiagonal(n, batch_size, dtype=torch.float32, device=device) + random_matrix = make_random_skew(n, batch_size, dtype=torch.float32, device=device) for strategy in strategies: + matrix = block_matrix if strategy is PfaffianBlockDet else random_matrix + p_bar.set_description(f"Benchmarking {strategy.NAME:^30} (n: {n:^5} | seed: {seed:^5})") forward_time = _median_time(lambda: _forward_call(strategy, matrix), is_cuda, n_repeats) full_time = _median_time(lambda: _forward_backward_call(strategy, matrix), is_cuda, n_repeats) - record = per_seed[strategy.NAME] - record["forward_time"].append(forward_time) - record["backward_time"].append(max(full_time - forward_time, 0.0)) - record["forward_memory"].append(_peak_memory(lambda: _forward_call(strategy, matrix), is_cuda)) - record["forward_backward_memory"].append( - _peak_memory(lambda: _forward_backward_call(strategy, matrix), is_cuda) + records.append( + { + "strategy": strategy.NAME, + "dimension": n, + "seed": seed, + "forward_time": forward_time, + "backward_time": max(full_time - forward_time, 0.0), + "forward_memory": _peak_memory(lambda: _forward_call(strategy, matrix), is_cuda), + "forward_backward_memory": _peak_memory( + lambda: _forward_backward_call(strategy, matrix), is_cuda + ), + } ) - - for strategy in strategies: - results[strategy.NAME]["dimension"].append(2 * n) - for metric in METRICS: - values = np.asarray(per_seed[strategy.NAME][metric], dtype=float) - results[strategy.NAME][f"{metric}_mean"].append(float(values.mean())) - results[strategy.NAME][f"{metric}_ci"].append(_confidence_interval(values)) - return results + p_bar.update(1) + p_bar.close() + return pd.DataFrame(records) -def plot_results( - results: BenchmarkResults, strategies: list[Strategy], batch_size: int, device: str = "cpu" -) -> plt.Figure: +def plot_results(results: pd.DataFrame, strategies: list[Strategy], batch_size: int, device: str = "cpu") -> plt.Figure: """ Plot the benchmark results as a 2x2 grid of time and memory panels with 95% CI bands. - :param results: The mapping returned by :func:`benchmark_strategies`. + :param results: The DataFrame returned by :func:`benchmark_strategies`. :param strategies: The strategy classes that were benchmarked. :param batch_size: Batch size used for the benchmark (shown in the title). :param device: Device used for the benchmark (shown in the title and memory label). @@ -162,23 +175,23 @@ def plot_results( ("forward_backward_memory", "Forward + backward memory", memory_label), ] + df_long = results.melt( + id_vars=["strategy", "dimension", "seed"], + value_vars=list(METRICS), + var_name="metric", + value_name="value", + ) + fig, axes = plt.subplots(2, 2, figsize=(12, 9)) - for ax, (key, title, ylabel) in zip(axes.flat, panels): - for strategy in strategies: - record = results[strategy.NAME] - dimension = np.asarray(record["dimension"], dtype=float) - mean = np.asarray(record[f"{key}_mean"], dtype=float) - ci = np.asarray(record[f"{key}_ci"], dtype=float) - line = ax.plot(dimension, mean, marker="o", label=strategy.NAME)[0] - lower = np.clip(mean - ci, np.finfo(float).tiny, None) - ax.fill_between(dimension, lower, mean + ci, alpha=0.2, color=line.get_color()) + for ax, (metric_key, title, ylabel) in zip(axes.flat, panels): + subset = df_long[df_long["metric"] == metric_key] + sns.lineplot(data=subset, x="dimension", y="value", hue="strategy", marker="o", ax=ax) ax.set_title(title) - ax.set_xlabel("matrix dimension (2n)") + ax.set_xlabel("matrix dimension") ax.set_ylabel(ylabel) ax.set_xscale("log", base=2) ax.set_yscale("log") ax.grid(True, which="both", linestyle=":", alpha=0.5) - ax.legend() fig.suptitle(f"Pfaffian strategies benchmark (batch_size={batch_size}, device={device}, 95% CI over seeds)") fig.tight_layout() diff --git a/notebooks/strategies_benchmark.ipynb b/notebooks/strategies_benchmark.ipynb index 3742965..4bdeb88 100644 --- a/notebooks/strategies_benchmark.ipynb +++ b/notebooks/strategies_benchmark.ipynb @@ -4,66 +4,23 @@ "cell_type": "markdown", "id": "56c973ab", "metadata": {}, - "source": [ - "# Benchmarking the Pfaffian strategies\n", - "\n", - "This notebook benchmarks the available Pfaffian strategies in terms of **time** and **memory** for both the **forward** and **backward** passes.\n", - "\n", - "Three strategies are compared:\n", - "\n", - "- `PfaffianFDBPf`: computes the Pfaffian from `sqrt(|det(A)|)` with a custom **analytic** backward. Valid for any skew-symmetric matrix.\n", - "- `PfaffianBlockDet`: computes the Pfaffian from the determinant of the upper-right block, with a custom analytic backward.\n", - "- `PfaffianDet`: a reference baseline that also computes `pf = sqrt(|det(A)|)` but differentiates straight through `det`/`sqrt` with **plain autograd** (no custom backward), to expose the cost of naive autodiff against the analytic backward of `PfaffianFDBPf`.\n", - "\n", - "Each strategy is invoked through `Strategy.apply(matrix)`.\n", - "\n", - "For each strategy and matrix size we report, **averaged over 20 random seeds with 95% confidence intervals**:\n", - "\n", - "- the median forward time,\n", - "- the median backward time,\n", - "- the forward peak memory,\n", - "- the forward + backward peak memory." - ] + "source": "# Benchmarking the Pfaffian strategies\n\nThis notebook benchmarks the available Pfaffian strategies in terms of **time** and **memory** for both the **forward** and **backward** passes.\n\nFive strategies are compared:\n\n- `PfaffianFDBPf`: computes the Pfaffian from `sqrt(|det(A)|)` with a custom **analytic** backward. Valid for any skew-symmetric matrix.\n- `PfaffianBlockDet`: computes the Pfaffian from the determinant of the upper-right block, with a custom analytic backward.\n- `PfaffianDet`: a reference baseline that also computes `pf = sqrt(|det(A)|)` but differentiates straight through `det`/`sqrt` with **plain autograd** (no custom backward), to expose the cost of naive autodiff against the analytic backward of `PfaffianFDBPf`.\n- `PfaffianParlettReid`: computes the **signed** Pfaffian via batched Parlett-Reid skew-tridiagonalization, with a custom analytic backward. Valid for any skew-symmetric matrix.\n- `RustPfaffianParlettReid`: the same signed Parlett-Reid forward implemented in Rust (PyO3), with the analytic PyTorch backward. Available when the native extension is built.\n\nEach strategy is invoked through `Strategy.apply(matrix)`.\n\nFor each strategy and matrix size we report, **averaged over 20 random seeds with 95% confidence intervals**:\n\n- the median forward time,\n- the median backward time,\n- the forward peak memory,\n- the forward + backward peak memory." }, { "cell_type": "markdown", "id": "55b95a09", "metadata": {}, - "source": [ - "## Validity note\n", - "\n", - "`PfaffianBlockDet`'s forward only returns the *true* Pfaffian for **block-antidiagonal** skew matrices of the form\n", - "\n", - "$$ A = \\begin{pmatrix} 0 & B \\\\ -B^{T} & 0 \\end{pmatrix}. $$\n", - "\n", - "To keep the comparison both **fair** and **numerically valid**, we benchmark *all* strategies on block-antidiagonal inputs. `PfaffianFDBPf` and `PfaffianDet` are valid on any skew matrix (including this form), so this input shape is a common ground on which all strategies compute the same quantity." - ] + "source": "## Validity note\n\n`PfaffianBlockDet`'s forward only returns the *true* Pfaffian for **block-antidiagonal** skew matrices of the form\n\n$$ A = \\begin{pmatrix} 0 & B \\\\ -B^{T} & 0 \\end{pmatrix}. $$\n\nSo when it is benchmarked, `PfaffianBlockDet` is fed block-antidiagonal inputs, the only shape on which it is valid. Every other strategy is valid on **any** skew-symmetric matrix, so those are benchmarked on **general (dense) random skew-symmetric matrices** — a representative, unstructured workload. Each strategy is therefore measured on an input it computes correctly." }, { "cell_type": "code", - "execution_count": 1, - "id": "2305932f", + "id": "657871cca9161529", "metadata": { "ExecuteTime": { - "end_time": "2026-06-10T14:25:10.025490742Z", - "start_time": "2026-06-10T14:25:08.874486863Z" - }, - "execution": { - "iopub.execute_input": "2026-06-10T14:16:52.667639Z", - "iopub.status.busy": "2026-06-10T14:16:52.667294Z", - "iopub.status.idle": "2026-06-10T14:16:54.207116Z", - "shell.execute_reply": "2026-06-10T14:16:54.205473Z" + "end_time": "2026-06-11T16:23:48.414931740Z", + "start_time": "2026-06-11T16:23:47.000678649Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Running benchmarks on device: cpu\n" - ] - } - ], "source": [ "import os\n", "import sys\n", @@ -75,15 +32,45 @@ "import torch\n", "from _strategies_benchmark_helpers import benchmark_strategies, plot_results\n", "\n", - "from torch_pfaffian.strategies.pfaffian_block_det import PfaffianBlockDet\n", "from torch_pfaffian.strategies.pfaffian_det import PfaffianDet\n", "from torch_pfaffian.strategies.pfaffian_fdbpf import PfaffianFDBPf\n", + "from torch_pfaffian.strategies.pfaffian_parlett_reid import PfaffianParlettReid\n", + "\n", + "try:\n", + " from torch_pfaffian.strategies.pfaffian_rust_parlett_reid import RustPfaffianParlettReid\n", + "except ImportError:\n", + " RustPfaffianParlettReid = None\n", "\n", - "strategies = [PfaffianFDBPf, PfaffianBlockDet, PfaffianDet]\n", + "strategies = [\n", + " PfaffianFDBPf,\n", + " # PfaffianBlockDet,\n", + " PfaffianDet,\n", + " PfaffianParlettReid,\n", + "]\n", + "if RustPfaffianParlettReid is not None:\n", + " strategies.append(RustPfaffianParlettReid)\n", "\n", "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", "print(f\"Running benchmarks on device: {device}\")" - ] + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running benchmarks on device: cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/local/USHERBROOKE/ginj2102/github/TorchPfaffian/.venv/lib/python3.14/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "execution_count": 1 }, { "cell_type": "markdown", @@ -92,148 +79,210 @@ "source": [ "## Running the benchmark\n", "\n", - "The benchmarking and plotting logic lives in `_strategies_benchmark_helpers.py` to keep this notebook focused on the narrative. `benchmark_strategies` sweeps the matrix dimension `2n` and, for every strategy, measures each metric once per seed across `n_seeds` seeds, returning the across-seed mean and the half-width of the 95% confidence interval." + "The benchmarking and plotting logic lives in `_strategies_benchmark_helpers.py` to keep this notebook focused on the narrative. `benchmark_strategies` sweeps the matrix dimension `n` and, for every strategy, measures each metric once per seed across `n_seeds` seeds, returning the across-seed mean and the half-width of the 95% confidence interval." ] }, { "cell_type": "code", - "execution_count": 2, - "id": "b6a3c6b4", + "id": "6ace4294c6d4b34", "metadata": { "ExecuteTime": { - "end_time": "2026-06-10T14:25:22.671153790Z", - "start_time": "2026-06-10T14:25:10.033292322Z" - }, - "execution": { - "iopub.execute_input": "2026-06-10T14:16:54.210625Z", - "iopub.status.busy": "2026-06-10T14:16:54.210309Z", - "iopub.status.idle": "2026-06-10T14:17:21.107161Z", - "shell.execute_reply": "2026-06-10T14:17:21.105779Z" + "end_time": "2026-06-11T16:45:30.960103917Z", + "start_time": "2026-06-11T16:23:48.423661244Z" } }, + "source": [ + "sizes_n = [2, 4, 8, 16, 32, 64, 128, 256]\n", + "batch_size = 32\n", + "n_seeds = 20\n", + "\n", + "results = benchmark_strategies(strategies, sizes_n, batch_size, device=device, n_seeds=n_seeds)\n", + "results" + ], "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/home/local/USHERBROOKE/ginj2102/github/TorchPfaffian/.venv/lib/python3.14/site-packages/torch/profiler/profiler.py:217: UserWarning: Warning: Profiler clears events at the end of each cycle.Only events from the current cycle will be reported.To keep events across cycles, set acc_events=True.\n", - " _warn_once(\n" + "Benchmarking PfaffianFDBPf (n: 2 | seed: 0 ): 0%| | 0/640 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
strategydimensionseedforward_timebackward_timeforward_memoryforward_backward_memory
0PfaffianFDBPf200.0109240.0000004.192000e+031.990900e+04
1PfaffianDet200.0116490.0000004.056000e+031.349800e+04
2PfaffianParlettReid200.0001470.0000553.032000e+031.905000e+04
3RustPfaffianParlettReid200.0004510.0003600.000000e+001.576200e+04
4PfaffianFDBPf210.0059890.0000004.304000e+032.016500e+04
........................
635RustPfaffianParlettReid256180.0078181.2186730.000000e+001.849201e+08
636PfaffianFDBPf256190.0038080.3512908.631040e+061.851625e+08
637PfaffianDet256190.0119550.0224828.630912e+061.261957e+08
638PfaffianParlettReid256190.5630662.2152502.212422e+092.396682e+09
639RustPfaffianParlettReid256190.0069331.0718160.000000e+001.849202e+08
\n", + "

640 rows × 7 columns

\n", + "" ] }, "execution_count": 2, @@ -241,14 +290,7 @@ "output_type": "execute_result" } ], - "source": [ - "sizes_n = [2, 4, 8, 16, 32]\n", - "batch_size = 16\n", - "n_seeds = 20\n", - "\n", - "results = benchmark_strategies(strategies, sizes_n, batch_size, device=device, n_seeds=n_seeds)\n", - "results" - ] + "execution_count": 2 }, { "cell_type": "markdown", @@ -260,46 +302,41 @@ }, { "cell_type": "code", - "execution_count": 4, "id": "e414240b2fc6064e", "metadata": { + "execution": { + "iopub.execute_input": "2026-06-10T18:29:48.418076Z", + "iopub.status.busy": "2026-06-10T18:29:48.417741Z", + "iopub.status.idle": "2026-06-10T18:29:49.863382Z", + "shell.execute_reply": "2026-06-10T18:29:49.862404Z" + }, "ExecuteTime": { - "end_time": "2026-06-10T14:25:48.810201185Z", - "start_time": "2026-06-10T14:25:47.642776418Z" + "end_time": "2026-06-11T16:45:32.958826885Z", + "start_time": "2026-06-11T16:45:31.043008384Z" } }, + "source": [ + "fig = plot_results(results, strategies, batch_size, device=device)" + ], "outputs": [ { "data": { - "image/png": "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", "text/plain": [ "
" - ] + ], + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "source": [ - "fig = plot_results(results, strategies, batch_size, device=device)" - ] + "execution_count": 3 }, { "cell_type": "markdown", "id": "8e444db9", "metadata": {}, - "source": [ - "## Conclusions and caveats\n", - "\n", - "The figure above reports, as a function of the matrix dimension $2n$, the median forward time, the median backward time, the forward peak memory, and the combined forward + backward peak memory for every strategy, evaluated on block-antidiagonal skew matrices. Shaded bands are 95% confidence intervals over the 20 seeds (they are essentially invisible for memory, which is seed-independent for a fixed shape).\n", - "\n", - "**Memory-metric caveat.** The memory numbers depend on the device:\n", - "\n", - "- On **CUDA**, the reported value is a true peak obtained from `torch.cuda.reset_peak_memory_stats()` / `torch.cuda.max_memory_allocated()`.\n", - "- On **CPU** (the continuous-integration case), no equivalent peak counter exists, so we report the **allocated bytes** measured by `torch.profiler` instead. This is an aggregate of allocations rather than a strict instantaneous peak, so CPU and CUDA memory values are not directly comparable and the absolute CPU numbers should be read as a relative indicator across strategies and sizes.\n", - "\n", - "`PfaffianFDBPf` and `PfaffianDet` share the same forward (`sqrt(|det(A)|)`); their difference is the backward, so the backward panels highlight the analytic custom backward against plain autograd." - ] + "source": "## Conclusions and caveats\n\nThe figure above reports, as a function of the matrix dimension $n$, the median forward time, the median backward time, the forward peak memory, and the combined forward + backward peak memory for every strategy. The general-purpose strategies are evaluated on general random skew-symmetric matrices; `PfaffianBlockDet`, when included, is evaluated on block-antidiagonal skew matrices (the only inputs for which it is valid). Shaded bands are 95% confidence intervals over the random seeds (they are essentially invisible for memory, which is seed-independent for a fixed shape).\n\n**Memory-metric caveat.** The memory numbers depend on the device:\n\n- On **CUDA**, the reported value is a true peak obtained from `torch.cuda.reset_peak_memory_stats()` / `torch.cuda.max_memory_allocated()`.\n- On **CPU** (the continuous-integration case), no equivalent peak counter exists, so we report the **allocated bytes** measured by `torch.profiler` instead. This is an aggregate of allocations rather than a strict instantaneous peak, so CPU and CUDA memory values are not directly comparable and the absolute CPU numbers should be read as a relative indicator across strategies and sizes.\n\n`PfaffianFDBPf` and `PfaffianDet` share the same forward (`sqrt(|det(A)|)`); their difference is the backward, so the backward panels highlight the analytic custom backward against plain autograd." } ], "metadata": { diff --git a/pyproject.toml b/pyproject.toml index c789a1b..8386951 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -19,10 +19,9 @@ classifiers = [ ] dependencies = [ "numpy (>=1.23,<3.0.0)", - "setuptools (>=80.10)", "torch (>=2.1,<3.0.0)", ] -dynamic = ["readme"] +readme = "README.md" [project.urls] homepage = "https://github.com/MatchCake/TorchPfaffian" @@ -58,6 +57,9 @@ dev = [ "pytest-timeout>=2.4", "pip>=25", "pre-commit>=4.5.1", + "maturin>=1.0,<2", + "tqdm>=4.68.2", + "seaborn>=0.13.2", ] docs = [ "wheel>=0.45,<0.46", @@ -124,25 +126,15 @@ url = "https://download.pytorch.org/whl/cu130" explicit = true [build-system] -requires = [ - "setuptools>=57.0.0", - "wheel>=0.45.1,<0.46", - "build>=1.2.2.post1,<2", - "twine>=6.1.0,<7", -] -build-backend = "setuptools.build_meta" - -[tool.setuptools.dynamic] -readme = { file = "README.md", content-type = "text/markdown" } - -[tool.setuptools] -package-dir = { "" = "src" } - -[tool.setuptools.packages.find] -where = ["src"] - -[tool.setuptools.package-data] -torch_pfaffian = ["py.typed"] +requires = ["maturin>=1.0,<2"] +build-backend = "maturin" + +[tool.maturin] +python-source = "src" +manifest-path = "rust/Cargo.toml" +module-name = "torch_pfaffian._rust" +features = ["pyo3/extension-module"] +include = ["src/torch_pfaffian/py.typed"] [tool.coverage.report] exclude_also = [ diff --git a/requirements.txt b/requirements.txt index 7141f32..46823c3 100644 --- a/requirements.txt +++ b/requirements.txt @@ -40,6 +40,7 @@ colorama==0.4.6 ; os_name == 'nt' or sys_platform == 'win32' # ipython # pytest # sphinx + # tqdm comm==0.2.3 # via ipykernel contourpy==1.3.2 ; python_full_version < '3.11' @@ -177,10 +178,12 @@ markupsafe==3.0.3 # jinja2 # nbconvert matplotlib==3.10.9 + # via seaborn matplotlib-inline==0.2.2 # via # ipykernel # ipython +maturin==1.13.3 mdit-py-plugins==0.6.1 # via myst-parser mdurl==0.1.2 @@ -230,11 +233,15 @@ numpy==2.2.6 ; python_full_version < '3.11' # via # contourpy # matplotlib + # pandas + # seaborn # torchpfaffian numpy==2.4.6 ; python_full_version >= '3.11' # via # contourpy # matplotlib + # pandas + # seaborn # torchpfaffian packaging==26.2 # via @@ -245,6 +252,10 @@ packaging==26.2 # pytest # sphinx # twine +pandas==2.3.3 ; python_full_version < '3.11' + # via seaborn +pandas==3.0.3 ; python_full_version >= '3.11' + # via seaborn pandocfilters==1.5.1 # via nbconvert parso==0.8.7 @@ -317,8 +328,11 @@ python-dateutil==2.9.0.post0 # via # jupyter-client # matplotlib + # pandas python-discovery==1.4.0 # via virtualenv +pytz==2026.2 ; python_full_version < '3.11' + # via pandas pywin32-ctypes==0.2.3 ; platform_machine != 'ppc64le' and platform_machine != 's390x' and sys_platform == 'win32' # via keyring pyyaml==6.0.3 @@ -358,12 +372,11 @@ rpds-py==2026.5.1 ; python_full_version >= '3.11' # jsonschema # referencing ruff==0.15.16 +seaborn==0.13.2 secretstorage==3.5.0 ; platform_machine != 'ppc64le' and platform_machine != 's390x' and sys_platform == 'linux' # via keyring -setuptools==82.0.1 - # via - # torch - # torchpfaffian +setuptools==82.0.1 ; python_full_version >= '3.12' + # via torch six==1.17.0 # via python-dateutil snowballstemmer==3.1.1 @@ -411,6 +424,7 @@ tomli==2.4.1 ; python_full_version <= '3.11' # via # build # coverage + # maturin # mypy # pytest torch==2.10.0 @@ -419,6 +433,7 @@ tornado==6.5.7 # via # ipykernel # jupyter-client +tqdm==4.68.2 traitlets==5.15.1 # via # ipykernel @@ -444,6 +459,8 @@ typing-extensions==4.15.0 # sqlalchemy # torch # virtualenv +tzdata==2026.2 ; python_full_version < '3.11' or sys_platform == 'emscripten' or sys_platform == 'win32' + # via pandas urllib3==2.7.0 # via # id diff --git a/rust/Cargo.lock b/rust/Cargo.lock new file mode 100644 index 0000000..37519ad --- /dev/null +++ b/rust/Cargo.lock @@ -0,0 +1,323 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + +[[package]] +name = "cfg-if" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" + +[[package]] +name = "crossbeam-deque" +version = "0.8.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51" +dependencies = [ + "crossbeam-epoch", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-epoch" +version = "0.9.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-utils" +version = "0.8.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28" + +[[package]] +name = "either" +version = "1.16.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91622ff5e7162018101f2fea40d6ebf4a78bbe5a49736a2020649edf9693679e" + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "indoc" +version = "2.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706" +dependencies = [ + "rustversion", +] + +[[package]] +name = "libc" +version = "0.2.186" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66" + +[[package]] +name = "matrixmultiply" +version = "0.3.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a06de3016e9fae57a36fd14dba131fccf49f74b40b7fbdb472f96e361ec71a08" +dependencies = [ + "autocfg", + "rawpointer", +] + +[[package]] +name = "memoffset" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a" +dependencies = [ + "autocfg", +] + +[[package]] +name = "ndarray" +version = "0.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "882ed72dce9365842bf196bdeedf5055305f11fc8c03dee7bb0194a6cad34841" +dependencies = [ + "matrixmultiply", + "num-complex", + "num-integer", + "num-traits", + "portable-atomic", + "portable-atomic-util", + "rawpointer", +] + +[[package]] +name = "num-complex" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495" +dependencies = [ + "num-traits", +] + +[[package]] +name = "num-integer" +version = "0.1.46" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f" +dependencies = [ + "num-traits", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "numpy" +version = "0.23.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b94caae805f998a07d33af06e6a3891e38556051b8045c615470a71590e13e78" +dependencies = [ + "libc", + "ndarray", + "num-complex", + "num-integer", + "num-traits", + "pyo3", + "rustc-hash", +] + +[[package]] +name = "once_cell" +version = "1.21.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" + +[[package]] +name = "portable-atomic" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49" + +[[package]] +name = "portable-atomic-util" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2a106d1259c23fac8e543272398ae0e3c0b8d33c88ed73d0cc71b0f1d902618" +dependencies = [ + "portable-atomic", +] + +[[package]] +name = "proc-macro2" +version = "1.0.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "pyo3" +version = "0.23.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7778bffd85cf38175ac1f545509665d0b9b92a198ca7941f131f85f7a4f9a872" +dependencies = [ + "cfg-if", + "indoc", + "libc", + "memoffset", + "once_cell", + "portable-atomic", + "pyo3-build-config", + "pyo3-ffi", + "pyo3-macros", + "unindent", +] + +[[package]] +name = "pyo3-build-config" +version = "0.23.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94f6cbe86ef3bf18998d9df6e0f3fc1050a8c5efa409bf712e661a4366e010fb" +dependencies = [ + "once_cell", + "target-lexicon", +] + +[[package]] +name = "pyo3-ffi" +version = "0.23.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e9f1b4c431c0bb1c8fb0a338709859eed0d030ff6daa34368d3b152a63dfdd8d" +dependencies = [ + "libc", + "pyo3-build-config", +] + +[[package]] +name = "pyo3-macros" +version = "0.23.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fbc2201328f63c4710f68abdf653c89d8dbc2858b88c5d88b0ff38a75288a9da" +dependencies = [ + "proc-macro2", + "pyo3-macros-backend", + "quote", + "syn", +] + +[[package]] +name = "pyo3-macros-backend" +version = "0.23.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fca6726ad0f3da9c9de093d6f116a93c1a38e417ed73bf138472cf4064f72028" +dependencies = [ + "heck", + "proc-macro2", + "pyo3-build-config", + "quote", + "syn", +] + +[[package]] +name = "quote" +version = "1.0.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "rawpointer" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3" + +[[package]] +name = "rayon" +version = "1.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d" +dependencies = [ + "either", + "rayon-core", +] + +[[package]] +name = "rayon-core" +version = "1.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91" +dependencies = [ + "crossbeam-deque", + "crossbeam-utils", +] + +[[package]] +name = "rustc-hash" +version = "2.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe" + +[[package]] +name = "rustversion" +version = "1.0.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" + +[[package]] +name = "syn" +version = "2.0.117" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "target-lexicon" +version = "0.12.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1" + +[[package]] +name = "torch_pfaffian_rust" +version = "0.0.1" +dependencies = [ + "ndarray", + "num-traits", + "numpy", + "pyo3", + "rayon", +] + +[[package]] +name = "unicode-ident" +version = "1.0.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" + +[[package]] +name = "unindent" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3" diff --git a/rust/Cargo.toml b/rust/Cargo.toml new file mode 100644 index 0000000..6b8deef --- /dev/null +++ b/rust/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "torch_pfaffian_rust" +version = "0.0.1" +edition = "2021" + +[lib] +name = "_rust" +crate-type = ["cdylib"] + +[dependencies] +pyo3 = { version = "0.23", features = ["abi3-py310", "extension-module"] } +numpy = "0.23" +ndarray = "0.16" +num-traits = "0.2" +rayon = "1" diff --git a/rust/src/lib.rs b/rust/src/lib.rs new file mode 100644 index 0000000..0fd6912 --- /dev/null +++ b/rust/src/lib.rs @@ -0,0 +1,164 @@ +use num_traits::Float; +use numpy::ndarray::{Array1, Array2, Axis}; +use numpy::{IntoPyArray, PyArray1, PyReadonlyArray3}; +use pyo3::prelude::*; +use rayon::prelude::*; + +const PIVOT_EPSILON: f64 = 1e-30; + +/// Batches with at least this many matrices are evaluated in parallel across threads; smaller +/// batches run serially to avoid thread-pool overhead. +const PARALLEL_BATCH_THRESHOLD: usize = 8; + +/// Signed Pfaffian of a single skew-symmetric matrix via Parlett-Reid elimination. +/// +/// Generic over the floating precision so the same algorithm serves ``f32`` and ``f64`` inputs. +/// The matrix is copied into a flat row-major buffer so the hot rank-2 Schur update runs over a +/// contiguous row slice, which the compiler can auto-vectorize (far cheaper than per-element +/// strided ndarray indexing). +fn pfaffian_one(matrix: Array2) -> T { + let dimension = matrix.nrows(); + if dimension % 2 == 1 { + return T::zero(); + } + if dimension == 0 { + return T::one(); + } + let mut data: Vec = matrix.iter().copied().collect(); // row-major, len dimension * dimension + let epsilon = T::from(PIVOT_EPSILON).unwrap(); + let mut sign = T::one(); + let mut column = 0usize; + while column + 2 < dimension { + // Partial pivoting: largest |data[row, column]| for row > column + 1. + let mut pivot_row = column + 2; + let mut best = data[(column + 2) * dimension + column].abs(); + for row in (column + 3)..dimension { + let candidate = data[row * dimension + column].abs(); + if candidate > best { + best = candidate; + pivot_row = row; + } + } + if best > data[(column + 1) * dimension + column].abs() { + // Congruence swap of rows then columns column+1 <-> pivot_row. + for index in 0..dimension { + data.swap((column + 1) * dimension + index, pivot_row * dimension + index); + } + for index in 0..dimension { + data.swap(index * dimension + (column + 1), index * dimension + pivot_row); + } + sign = -sign; + } + let pivot = data[(column + 1) * dimension + column]; + if pivot.abs() < epsilon { + return T::zero(); + } + // Rank-2 skew Schur-complement update on the trailing block, read from originals. + let base = column + 2; + let length = dimension - base; + let tau: Vec = (0..length).map(|k| data[(base + k) * dimension + column] / pivot).collect(); + let next: Vec = (0..length).map(|k| data[(base + k) * dimension + (column + 1)]).collect(); + for row_offset in 0..length { + let tau_row = tau[row_offset]; + let next_row = next[row_offset]; + let start = (base + row_offset) * dimension + base; + let row = &mut data[start..start + length]; + for column_offset in 0..length { + row[column_offset] = + row[column_offset] + tau_row * next[column_offset] - next_row * tau[column_offset]; + } + } + column += 2; + } + let mut pfaffian = sign; + let mut index = 0usize; + while index < dimension { + pfaffian = pfaffian * data[index * dimension + (index + 1)]; + index += 2; + } + pfaffian +} + +/// Signed Pfaffian of each owned matrix, computed in parallel across the batch above a threshold. +/// +/// The batch elements are independent, so they are mapped over rayon threads; the per-matrix +/// Parlett-Reid elimination itself stays sequential. The caller releases the GIL around this. +fn signed_pfaffian_owned(matrices: Vec>) -> Vec { + if matrices.len() >= PARALLEL_BATCH_THRESHOLD { + matrices.into_par_iter().map(pfaffian_one).collect() + } else { + matrices.into_iter().map(pfaffian_one).collect() + } +} + +/// Copy each ``(n, n)`` slice of a ``(batch, n, n)`` view into an owned matrix. +fn owned_matrices(matrix: &PyReadonlyArray3<'_, T>) -> Vec> { + let view = matrix.as_array(); + let batch = view.shape()[0]; + (0..batch).map(|index| view.index_axis(Axis(0), index).to_owned()).collect() +} + +/// Signed Pfaffian of a batch of ``float64`` skew-symmetric matrices, shape ``(batch, n, n)``. +#[pyfunction] +fn signed_pfaffian_f64<'py>(py: Python<'py>, matrix: PyReadonlyArray3<'py, f64>) -> Bound<'py, PyArray1> { + let matrices = owned_matrices(&matrix); + let results = py.allow_threads(|| signed_pfaffian_owned(matrices)); + Array1::from(results).into_pyarray(py) +} + +/// Signed Pfaffian of a batch of ``float32`` skew-symmetric matrices, shape ``(batch, n, n)``. +#[pyfunction] +fn signed_pfaffian_f32<'py>(py: Python<'py>, matrix: PyReadonlyArray3<'py, f32>) -> Bound<'py, PyArray1> { + let matrices = owned_matrices(&matrix); + let results = py.allow_threads(|| signed_pfaffian_owned(matrices)); + Array1::from(results).into_pyarray(py) +} + +#[pymodule] +fn _rust(module: &Bound<'_, PyModule>) -> PyResult<()> { + module.add_function(wrap_pyfunction!(signed_pfaffian_f64, module)?)?; + module.add_function(wrap_pyfunction!(signed_pfaffian_f32, module)?)?; + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::pfaffian_one; + use numpy::ndarray::array; + + #[test] + fn two_by_two_is_signed() { + // pf([[0, -3], [3, 0]]) = -3 + let m = array![[0.0_f64, -3.0], [3.0, 0.0]]; + assert!((pfaffian_one(m) - (-3.0)).abs() < 1e-12); + } + + #[test] + fn four_by_four_matches_pfaffian_formula() { + // For [[0,a,b,c],[-a,0,d,e],[-b,-d,0,f],[-c,-e,-f,0]], pf = a*f - b*e + c*d. + let (a, b, c, d, e, f) = (1.0_f64, 2.0, 3.0, 4.0, 5.0, 6.0); + let m = array![ + [0.0, a, b, c], + [-a, 0.0, d, e], + [-b, -d, 0.0, f], + [-c, -e, -f, 0.0] + ]; + let expected = a * f - b * e + c * d; // = 6 - 10 + 12 = 8 + assert!((pfaffian_one(m) - expected).abs() < 1e-9); + } + + #[test] + fn f32_two_by_two_is_signed() { + // Same algorithm in single precision. + let m = array![[0.0_f32, -3.0], [3.0, 0.0]]; + assert!((pfaffian_one(m) - (-3.0)).abs() < 1e-5); + } + + #[test] + fn odd_is_zero_and_empty_is_one() { + let odd = array![[0.0_f64, 1.0, 2.0], [-1.0, 0.0, 3.0], [-2.0, -3.0, 0.0]]; + assert_eq!(pfaffian_one(odd), 0.0); + let empty = numpy::ndarray::Array2::::zeros((0, 0)); + assert_eq!(pfaffian_one(empty), 1.0); + } +} diff --git a/setup.py b/setup.py deleted file mode 100644 index 53a465e..0000000 --- a/setup.py +++ /dev/null @@ -1,40 +0,0 @@ -import setuptools -from setuptools import setup - -setup( - name="TorchPfaffian", - long_description="file: README.md", - long_description_content_type="text/markdown", - package_dir={"": "src"}, - packages=setuptools.find_packages(where="src"), - python_requires=">=3.10", - classifiers=[ - "Development Status :: 3 - Alpha", - "Intended Audience :: Science/Research", - "License :: OSI Approved :: Apache Software License", - "Programming Language :: Python :: 3", - "Programming Language :: Python :: 3.10", - "Programming Language :: Python :: 3.11", - "Topic :: Scientific/Engineering", - "Topic :: Scientific/Engineering :: Artificial Intelligence", - "Topic :: Software Development :: Libraries :: Python Modules", - "Operating System :: OS Independent", - ], - project_urls={ - "Homepage": "https://github.com/MatchCake/TorchPfaffian", - "Source": "https://github.com/MatchCake/TorchPfaffian", - "Documentation": "https://MatchCake.github.io/TorchPfaffian", - }, -) - - -# build library -# setup.py sdist bdist_wheel -# With pyproject.toml -# python -m pip install --upgrade build -# python -m build - -# publish on PyPI -# twine check dist/* -# twine upload --repository-url https://test.pypi.org/legacy/ dist/* -# twine upload dist/* diff --git a/src/torch_pfaffian/__init__.py b/src/torch_pfaffian/__init__.py index 53aa80b..266be90 100644 --- a/src/torch_pfaffian/__init__.py +++ b/src/torch_pfaffian/__init__.py @@ -2,12 +2,18 @@ TorchPfaffian is a Python package for efficiently computing the Pfaffian of skew-symmetric matrices using PyTorch. """ +import importlib_metadata + __author__ = "Jérémie Gince" __email__ = "gincejeremie@gmail.com" __copyright__ = "Copyright 2024, Jérémie Gince" __license__ = "Apache 2.0" __url__ = "https://github.com/MatchCake/TorchPfaffian" -__version__ = "0.0.1-beta0" +__package__ = "torch_pfaffian" +try: + __version__ = importlib_metadata.version(__package__) +except importlib_metadata.PackageNotFoundError: + __version__ = importlib_metadata.version("TorchPfaffian") import warnings from collections.abc import Callable @@ -28,3 +34,65 @@ def get_pfaffian_function(name: str = PfaffianFDBPf.NAME) -> Callable[[torch.Ten if name not in pfaffian_strategy_map: raise ValueError(f"Unknown strategy name: {name}. Available strategies: {list(pfaffian_strategy_map.keys())}") return pfaffian_strategy_map[name].apply + + +def pfaffian(matrix: torch.Tensor, *, sign: bool = True, check_input: bool = False) -> torch.Tensor: + """ + Compute the Pfaffian of a skew-symmetric matrix, choosing the strategy from the input. + + The matrix has shape ``(..., 2n, 2n)`` and the result has shape ``(...,)``, sharing the + backend, dtype, and device of ``matrix``. + + Strategy selection: + + =================================== =========================== ========================================= + Condition Strategy Reason + =================================== =========================== ========================================= + ``sign=True``, Rust built, CPU input ``RustPfaffianParlettReid`` fastest signed path (native Rust kernel) + ``sign=True``, otherwise ``PfaffianParlettReid`` GPU-native and pure-Python fallback + ``sign=False``, grad needed ``PfaffianFDBPf`` magnitude only; robust analytic backward + ``sign=False``, no grad ``PfaffianDet`` cheapest: ``sqrt(|det|)`` only + =================================== =========================== ========================================= + + The Rust kernel runs on CPU, so a non-CPU (e.g. CUDA) input is routed to ``PfaffianParlettReid``, + which runs natively on the input device and avoids a host round-trip. + + The Pfaffian is only defined for skew-symmetric matrices; the strategies assume this and do not + check it. Pass ``check_input=True`` to validate the assumption. For large matrices the Pfaffian + can exceed the floating range and overflow to ``inf``; a ``RuntimeWarning`` is emitted when the + result is not finite. + + :param matrix: Skew-symmetric matrix of shape ``(..., 2n, 2n)``. + :param sign: When ``True`` (default) return the signed Pfaffian, otherwise its magnitude. + :param check_input: When ``True``, validate that ``matrix`` is square in its last two dimensions + and skew-symmetric (``A == -A^T``) before computing, raising ``ValueError`` otherwise. Off by + default (``False``) so trusted inputs pay nothing; the check is an O(n^2) comparison, cheap + relative to the O(n^3) Pfaffian. + :return: The Pfaffian of the input, of shape ``(...,)``. + :rtype: torch.Tensor + """ + if check_input: + if matrix.shape[-1] != matrix.shape[-2]: + raise ValueError(f"Expected a square matrix in the last two dimensions, got shape {tuple(matrix.shape)}.") + if not torch.allclose(matrix, -matrix.transpose(-1, -2)): + raise ValueError("Input matrix is not skew-symmetric (A != -A^T).") + + if sign: + # The Rust kernel is CPU-only, so non-CPU inputs use the device-native PyTorch strategy. + if RustPfaffianParlettReid is not None and matrix.device.type == "cpu": + result = RustPfaffianParlettReid.apply(matrix) + else: + result = PfaffianParlettReid.apply(matrix) + elif matrix.requires_grad and torch.is_grad_enabled(): + result = PfaffianFDBPf.apply(matrix) + else: + result = PfaffianDet.apply(matrix) + + if not torch.isfinite(result).all(): + warnings.warn( + "Pfaffian is not finite (overflow to inf/nan): its magnitude exceeds the floating range " + "of the input dtype at this matrix dimension. Consider a higher-precision dtype.", + RuntimeWarning, + stacklevel=2, + ) + return result diff --git a/src/torch_pfaffian/strategies/__init__.py b/src/torch_pfaffian/strategies/__init__.py index 5df968c..482bc29 100644 --- a/src/torch_pfaffian/strategies/__init__.py +++ b/src/torch_pfaffian/strategies/__init__.py @@ -5,4 +5,10 @@ from .pfaffian_block_det import PfaffianBlockDet from .pfaffian_det import PfaffianDet from .pfaffian_fdbpf import PfaffianFDBPf +from .pfaffian_parlett_reid import PfaffianParlettReid from .strategy import PfaffianStrategy + +try: + from .pfaffian_rust_parlett_reid import RustPfaffianParlettReid +except ImportError: # pragma: no cover + RustPfaffianParlettReid = None # pragma: no cover diff --git a/src/torch_pfaffian/strategies/pfaffian_block_det.py b/src/torch_pfaffian/strategies/pfaffian_block_det.py index 526bd59..dd083ee 100644 --- a/src/torch_pfaffian/strategies/pfaffian_block_det.py +++ b/src/torch_pfaffian/strategies/pfaffian_block_det.py @@ -53,3 +53,11 @@ def backward(ctx: torch.autograd.function.BackwardCFunction, grad_output): grad_matrix = torch.zeros_like(matrix) grad_matrix[..., :n, n:] = grad_block return grad_matrix + + @classmethod + def _pfaffian_adjugate(cls, matrices: torch.Tensor) -> torch.Tensor: + # This strategy's forward only accepts block-antidiagonal matrices, but the Pfaffian minors + # are general skew matrices, so the adjugate is computed with the general Parlett-Reid forward. + from .pfaffian_parlett_reid import PfaffianParlettReid + + return PfaffianParlettReid._pfaffian_adjugate(matrices) diff --git a/src/torch_pfaffian/strategies/pfaffian_parlett_reid.py b/src/torch_pfaffian/strategies/pfaffian_parlett_reid.py new file mode 100644 index 0000000..07773db --- /dev/null +++ b/src/torch_pfaffian/strategies/pfaffian_parlett_reid.py @@ -0,0 +1,94 @@ +from typing import cast + +import torch + +from .strategy import PfaffianStrategy + + +class PfaffianParlettReid(PfaffianStrategy): + """ + Compute the signed Pfaffian of a skew-symmetric matrix with the Parlett-Reid algorithm. + + The forward performs a batched skew-tridiagonalization with partial pivoting: the batch is + processed together and only the ``n / 2`` column-elimination steps are sequential. The result + is the signed Pfaffian, unlike the determinant-based strategies which return only the magnitude. + The backward uses the closed form ``d pf(A) / d A = (1 / 2) pf(A) (A^{-1})^T`` via the Pfaffian + adjugate, with no autograd graph over the elimination. For invertible inputs this is a single + pseudo-inverse; for singular inputs (``pf == 0``) the adjugate is computed exactly from minor + Pfaffians, so the gradient is correct everywhere (see :meth:`PfaffianStrategy.pfaffian_grad_matrix`). + + The input is a skew-symmetric matrix of shape ``(..., 2n, 2n)``. + """ + + NAME = "PfaffianParlettReid" + + @staticmethod + def forward(matrix: torch.Tensor) -> torch.Tensor: + dimension = matrix.shape[-1] + if dimension % 2 != 0: + return torch.zeros(matrix.shape[:-2], dtype=matrix.dtype, device=matrix.device) + if dimension == 0: + return torch.ones(matrix.shape[:-2], dtype=matrix.dtype, device=matrix.device) + + working = matrix.reshape(-1, dimension, dimension).clone() # (batch, 2n, 2n) + batch = working.shape[0] + batch_index = torch.arange(batch, device=matrix.device) + sign = torch.ones(batch, dtype=matrix.dtype, device=matrix.device) + valid = torch.ones(batch, dtype=torch.bool, device=matrix.device) + epsilon = PfaffianStrategy.EPSILON + + for column in range(0, dimension - 2, 2): + sub_column = working[:, column + 2 :, column].abs() # (batch, 2n - column - 2) + pivot_relative = sub_column.argmax(dim=1) # (batch,) + pivot_row = pivot_relative + column + 2 # (batch,) + pivot_magnitude = sub_column.gather(1, pivot_relative[:, None]).squeeze(1) # (batch,) + pivot_condition = pivot_magnitude > working[:, column + 1, column].abs() # (batch,) + mask = pivot_condition[:, None] # (batch, 1) + + # Congruence swap of rows/columns column+1 <-> pivot_row where pivoting helps. + row_fixed = working[:, column + 1, :].clone() + row_pivot = working[batch_index, pivot_row, :].clone() + working[:, column + 1, :] = torch.where(mask, row_pivot, row_fixed) + working[batch_index, pivot_row, :] = torch.where(mask, row_fixed, row_pivot) + col_fixed = working[:, :, column + 1].clone() + col_pivot = working[batch_index, :, pivot_row].clone() + working[:, :, column + 1] = torch.where(mask, col_pivot, col_fixed) + working[batch_index, :, pivot_row] = torch.where(mask, col_fixed, col_pivot) + sign = sign * torch.where(pivot_condition, -torch.ones_like(sign), torch.ones_like(sign)) + + pivot_value = working[:, column + 1, column] # (batch,) + zero_pivot = pivot_value.abs() < epsilon + valid = valid & ~zero_pivot + safe_pivot = torch.where(zero_pivot, torch.ones_like(pivot_value), pivot_value) + tau = working[:, column + 2 :, column] / safe_pivot[:, None] # (batch, 2n - column - 2) + column_next = working[:, column + 2 :, column + 1] # (batch, 2n - column - 2) + update = torch.einsum("bi,bj->bij", tau, column_next) - torch.einsum("bi,bj->bij", column_next, tau) + working[:, column + 2 :, column + 2 :] = working[:, column + 2 :, column + 2 :] + update + working[:, column + 2 :, column] = 0 + working[:, column, column + 2 :] = 0 + working[:, column + 2 :, column + 1] = 0 + working[:, column + 1, column + 2 :] = 0 + + super_index = torch.arange(0, dimension, 2, device=matrix.device) + super_entries = working[:, super_index, super_index + 1] # (batch, n) + raw_pfaffian = sign * super_entries.prod(dim=1) # (batch,) + pfaffian = torch.where(valid, raw_pfaffian, torch.zeros_like(raw_pfaffian)) + return pfaffian.reshape(matrix.shape[:-2]) + + @staticmethod + def backward(ctx: torch.autograd.function.BackwardCFunction, grad_output: torch.Tensor) -> torch.Tensor | None: + r""" + Gradient of the signed Pfaffian with respect to the input matrix. + + .. math:: + \frac{\partial \text{pf}(A)}{\partial A_{ij}} = \frac{\text{pf}(A)}{2} (A^{-1})_{ji} + + :param ctx: Context holding the saved input matrix and the forward Pfaffian. + :param grad_output: Gradient of the output with respect to the loss. + :return: Gradient of the input matrix, or ``None`` when the input does not require grad. + :rtype: torch.Tensor | None + """ + matrix, pfaffian = cast("tuple[torch.Tensor, torch.Tensor]", ctx.saved_tensors) + if not ctx.needs_input_grad[0]: + return None + return PfaffianParlettReid.pfaffian_grad_matrix(matrix, pfaffian, grad_output) diff --git a/src/torch_pfaffian/strategies/pfaffian_rust_parlett_reid.py b/src/torch_pfaffian/strategies/pfaffian_rust_parlett_reid.py new file mode 100644 index 0000000..426e652 --- /dev/null +++ b/src/torch_pfaffian/strategies/pfaffian_rust_parlett_reid.py @@ -0,0 +1,61 @@ +from typing import cast + +import torch + +from .. import _rust +from .strategy import PfaffianStrategy + + +class RustPfaffianParlettReid(PfaffianStrategy): + """ + Compute the signed Pfaffian with the Rust Parlett-Reid kernel. + + The forward moves the input to a contiguous CPU array and calls the compiled + ``torch_pfaffian._rust`` kernel at a precision chosen from the input dtype: ``float32`` inputs + use the single-precision kernel and every other floating dtype uses the double-precision kernel. + The result is cast back to the input dtype and device. The backward is the same as + :class:`PfaffianParlettReid` (the Pfaffian adjugate ``d pf(A) / d A = (1 / 2) pf(A) (A^{-1})^T``, + exact for invertible and singular inputs), computed in PyTorch. CUDA inputs are evaluated on CPU + for the forward; the backward runs on the input device. + + The input is a skew-symmetric matrix of shape ``(..., n, n)``. + """ + + NAME = "RustPfaffianParlettReid" + + @staticmethod + def forward(matrix: torch.Tensor) -> torch.Tensor: + dimension = matrix.shape[-1] + if dimension % 2 != 0: + return torch.zeros(matrix.shape[:-2], dtype=matrix.dtype, device=matrix.device) + if dimension == 0: + return torch.ones(matrix.shape[:-2], dtype=matrix.dtype, device=matrix.device) + flat = matrix.reshape(-1, dimension, dimension) # (batch, n, n) + if matrix.dtype == torch.float32: + working_dtype = torch.float32 + kernel = _rust.signed_pfaffian_f32 + else: + working_dtype = torch.float64 + kernel = _rust.signed_pfaffian_f64 + array = flat.detach().to(working_dtype).cpu().contiguous().numpy() + result = kernel(array) # (batch,) in working_dtype + pfaffian = torch.from_numpy(result).to(dtype=matrix.dtype, device=matrix.device) + return pfaffian.reshape(matrix.shape[:-2]) + + @staticmethod + def backward(ctx: torch.autograd.function.BackwardCFunction, grad_output: torch.Tensor) -> torch.Tensor | None: + r""" + Gradient of the signed Pfaffian with respect to the input matrix. + + .. math:: + \frac{\partial \text{pf}(A)}{\partial A_{ij}} = \frac{\text{pf}(A)}{2} (A^{-1})_{ji} + + :param ctx: Context holding the saved input matrix and the forward Pfaffian. + :param grad_output: Gradient of the output with respect to the loss. + :return: Gradient of the input matrix, or ``None`` when the input does not require grad. + :rtype: torch.Tensor | None + """ + matrix, pfaffian = cast("tuple[torch.Tensor, torch.Tensor]", ctx.saved_tensors) + if not ctx.needs_input_grad[0]: + return None + return RustPfaffianParlettReid.pfaffian_grad_matrix(matrix, pfaffian, grad_output) diff --git a/src/torch_pfaffian/strategies/strategy.py b/src/torch_pfaffian/strategies/strategy.py index 7723d9f..236d0c1 100644 --- a/src/torch_pfaffian/strategies/strategy.py +++ b/src/torch_pfaffian/strategies/strategy.py @@ -18,3 +18,65 @@ def forward(matrix: torch.Tensor): @staticmethod def backward(ctx: torch.autograd.function.BackwardCFunction, grad_output): pass + + @classmethod + def pfaffian_grad_matrix( + cls, matrix: torch.Tensor, pfaffian: torch.Tensor, grad_output: torch.Tensor + ) -> torch.Tensor: + r""" + Gradient of the signed Pfaffian with respect to the input matrix. + + Uses the closed form ``d pf(A) / d A = (1 / 2) pf(A) (A^{-1})^T`` via the Pfaffian adjugate + ``pf(A) A^{-1}``. For invertible inputs the adjugate is ``pf(A) * pinv(A)`` (a single inverse); + for singular inputs (``pf == 0``), where that product would be ``0`` and miss the true + derivative, the adjugate is recomputed exactly from minor Pfaffians via + :meth:`_pfaffian_adjugate` (using ``cls``'s own forward). The minor-based path runs only on the + singular batch elements, so invertible inputs keep the single cheap inverse. + + :param matrix: The saved input matrix of shape ``(..., n, n)``. + :param pfaffian: The saved forward Pfaffian of shape ``(...,)``. + :param grad_output: Gradient of the output with respect to the loss, of shape ``(...,)``. + :return: Gradient of the input matrix, of shape ``(..., n, n)``. + :rtype: torch.Tensor + """ + adjugate = pfaffian[..., None, None] * torch.linalg.pinv(matrix) # pf(A) A^{-1}; 0 where pf == 0 + singular = pfaffian == 0 + if bool(singular.any()): + dimension = matrix.shape[-1] + flat_matrix = matrix.reshape(-1, dimension, dimension) + flat_adjugate = adjugate.reshape(-1, dimension, dimension) + singular_index = singular.reshape(-1).nonzero(as_tuple=True)[0] + with torch.no_grad(): + singular_adjugate = cls._pfaffian_adjugate(flat_matrix.index_select(0, singular_index)) + flat_adjugate = flat_adjugate.index_copy(0, singular_index, singular_adjugate.to(flat_adjugate.dtype)) + adjugate = flat_adjugate.reshape_as(matrix) + return torch.einsum("...,...ij->...ji", 0.5 * grad_output, adjugate) + + @classmethod + def _pfaffian_adjugate(cls, matrices: torch.Tensor) -> torch.Tensor: + r""" + Pfaffian adjugate ``P = pf(A) A^{-1}`` of a batch of skew-symmetric matrices. + + The adjugate is a polynomial in the entries of ``A`` (it equals ``pf(A) A^{-1}`` for invertible + ``A`` but stays finite when ``A`` is singular), so it is computed from minor Pfaffians rather + than an inverse: ``P_{ij} = (-1)^{i+j} pf(A^{(ij)})`` for ``i < j``, where ``A^{(ij)}`` is ``A`` + with rows and columns ``i`` and ``j`` removed, and ``P`` is skew-symmetric. The minor Pfaffians + are computed with this class's own :meth:`forward`; subclasses whose forward is not valid on the + minors (e.g. :class:`PfaffianBlockDet`) override this to use a general strategy. + + :param matrices: Skew-symmetric matrices of shape ``(m, n, n)``. + :return: The Pfaffian adjugate, of shape ``(m, n, n)``. + :rtype: torch.Tensor + """ + dimension = matrices.shape[-1] + adjugate = torch.zeros_like(matrices) + indices = torch.arange(dimension, device=matrices.device) + for first in range(dimension): + for second in range(first + 1, dimension): + keep = indices[(indices != first) & (indices != second)] + minor = matrices.index_select(-2, keep).index_select(-1, keep) # (m, n-2, n-2) + minor_pfaffian = cls.forward(minor) # (m,) + sign = 1.0 if (first + second) % 2 == 0 else -1.0 + adjugate[..., first, second] = sign * minor_pfaffian + adjugate[..., second, first] = -sign * minor_pfaffian + return adjugate diff --git a/tests/test_strategies/test_pfaffian_block_det.py b/tests/test_strategies/test_pfaffian_block_det.py index c819f12..a67800f 100644 --- a/tests/test_strategies/test_pfaffian_block_det.py +++ b/tests/test_strategies/test_pfaffian_block_det.py @@ -80,3 +80,15 @@ class _Context: needs_input_grad = (False,) assert PfaffianBlockDet.backward(_Context(), torch.ones_like(pfaffian)) is None + + def test_adjugate_override_delegates_to_parlett_reid(self): + # PfaffianBlockDet.forward is block-only, so its adjugate must defer to the general strategy. + from torch_pfaffian.strategies.pfaffian_parlett_reid import PfaffianParlettReid + + matrices = _block_antidiagonal(_RNG.random((3, 3, 3))) + torch.testing.assert_close( + PfaffianBlockDet._pfaffian_adjugate(matrices), + PfaffianParlettReid._pfaffian_adjugate(matrices), + atol=ATOL_MATRIX_COMPARISON, + rtol=RTOL_MATRIX_COMPARISON, + ) diff --git a/tests/test_strategies/test_pfaffian_parlett_reid.py b/tests/test_strategies/test_pfaffian_parlett_reid.py new file mode 100644 index 0000000..2e6a412 --- /dev/null +++ b/tests/test_strategies/test_pfaffian_parlett_reid.py @@ -0,0 +1,163 @@ +import numpy as np +import pytest +import torch +from torch.autograd import gradcheck + +from tests.configs import ( + ATOL_APPROX_COMPARISON, + ATOL_MATRIX_COMPARISON, + ATOL_SCALAR_COMPARISON, + N_RANDOM_TESTS_PER_CASE, + RTOL_APPROX_COMPARISON, + RTOL_MATRIX_COMPARISON, + RTOL_SCALAR_COMPARISON, + TEST_SEED, +) +from torch_pfaffian.strategies.pfaffian_block_det import PfaffianBlockDet +from torch_pfaffian.strategies.pfaffian_parlett_reid import PfaffianParlettReid + +_RNG = np.random.default_rng(TEST_SEED) +_HALF_SIZES = [1, 2, 3, 4] +_RANDOM_BLOCKS = [_RNG.random((size, size)) for size in _HALF_SIZES for _ in range(N_RANDOM_TESTS_PER_CASE)] + + +def _block_antidiagonal(block: np.ndarray) -> torch.Tensor: + # Skew matrix [[0, block], [-block^T, 0]]; PfaffianBlockDet gives its exact signed Pfaffian. + zero = np.zeros_like(block) + top = np.concatenate([zero, block], axis=-1) + bottom = np.concatenate([-np.einsum("...ij->...ji", block), zero], axis=-1) + return torch.tensor(np.concatenate([top, bottom], axis=-2)) + + +def _random_skew(dimension: int, rng: np.random.Generator) -> torch.Tensor: + upper = rng.random((dimension, dimension)) + skew = np.triu(upper, k=1) + return torch.tensor(skew - skew.T) + + +_GRADCHECK_DIMENSIONS = [2, 4, 6] + + +def _skew_from_parameters(parameters: torch.Tensor, dimension: int) -> torch.Tensor: + # Build a skew-symmetric A(theta) from the free strictly-upper-triangular entries so that + # gradcheck differentiates on the manifold where the Pfaffian is defined. + upper = torch.zeros(dimension, dimension, dtype=parameters.dtype) + indices = torch.triu_indices(dimension, dimension, offset=1) + upper = upper.index_put((indices[0], indices[1]), parameters) + return upper - upper.transpose(-1, -2) + + +class TestPfaffianParlettReid: + @pytest.mark.parametrize("block", _RANDOM_BLOCKS) + def test_forward_square_matches_determinant(self, block): + matrix = _block_antidiagonal(block) + pfaffian = PfaffianParlettReid.apply(matrix) + determinant = torch.linalg.det(matrix) + torch.testing.assert_close(pfaffian**2, determinant, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) + + @pytest.mark.parametrize("block", _RANDOM_BLOCKS) + def test_forward_sign_matches_block_det(self, block): + matrix = _block_antidiagonal(block) + torch.testing.assert_close( + PfaffianParlettReid.apply(matrix), + PfaffianBlockDet.apply(matrix), + atol=ATOL_MATRIX_COMPARISON, + rtol=RTOL_MATRIX_COMPARISON, + ) + + def test_forward_two_by_two_is_signed(self): + matrix = torch.tensor([[0.0, -3.0], [3.0, 0.0]], dtype=torch.float64) + torch.testing.assert_close( + PfaffianParlettReid.apply(matrix), + torch.tensor(-3.0, dtype=torch.float64), + atol=ATOL_SCALAR_COMPARISON, + rtol=RTOL_SCALAR_COMPARISON, + ) + + def test_forward_supports_leading_batch_dims(self): + blocks = _RNG.random((2, 3, 4, 4)) + matrix = _block_antidiagonal(blocks) + pfaffian = PfaffianParlettReid.apply(matrix) + assert pfaffian.shape == matrix.shape[:-2] + torch.testing.assert_close( + pfaffian**2, torch.linalg.det(matrix), atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON + ) + + @pytest.mark.parametrize("dtype", [torch.float32, torch.float64]) + def test_forward_preserves_dtype_and_device(self, dtype): + matrix = _random_skew(6, _RNG).to(dtype) + pfaffian = PfaffianParlettReid.apply(matrix) + assert pfaffian.dtype == dtype + assert pfaffian.device == matrix.device + + def test_forward_odd_dimension_is_zero(self): + matrix = _random_skew(5, _RNG) + torch.testing.assert_close( + PfaffianParlettReid.apply(matrix), + torch.zeros((), dtype=matrix.dtype), + atol=ATOL_SCALAR_COMPARISON, + rtol=RTOL_SCALAR_COMPARISON, + ) + + def test_forward_empty_matrix_is_one(self): + matrix = torch.zeros((0, 0), dtype=torch.float64) + torch.testing.assert_close( + PfaffianParlettReid.apply(matrix), + torch.ones((), dtype=torch.float64), + atol=ATOL_SCALAR_COMPARISON, + rtol=RTOL_SCALAR_COMPARISON, + ) + + def test_forward_singular_matrix_is_zero(self): + # A skew matrix with a zero pivot column has Pfaffian 0. + matrix = torch.zeros((4, 4), dtype=torch.float64) + matrix[2, 3] = 1.0 + matrix[3, 2] = -1.0 + torch.testing.assert_close( + PfaffianParlettReid.apply(matrix), + torch.zeros((), dtype=torch.float64), + atol=ATOL_SCALAR_COMPARISON, + rtol=RTOL_SCALAR_COMPARISON, + ) + + @pytest.mark.parametrize("dimension", _GRADCHECK_DIMENSIONS) + def test_backward_passes_gradcheck_on_skew_parameterization(self, dimension): + count = dimension * (dimension - 1) // 2 + parameters = torch.tensor(_RNG.random(count) + 0.5, dtype=torch.float64, requires_grad=True) + assert gradcheck( + lambda values: PfaffianParlettReid.apply(_skew_from_parameters(values, dimension)), + (parameters,), + eps=1e-6, + atol=ATOL_APPROX_COMPARISON, + rtol=RTOL_APPROX_COMPARISON, + ) + + def test_backward_exact_on_singular_matrix(self): + # At an exactly-singular skew input (pf=0) the gradient must be the TRUE derivative, via the + # Pfaffian adjugate. For the rank-2 matrix with only a_{23}=1, pf = a01*a23 - a02*a13 + a03*a12, + # so d pf / d a01 = a23 = 1 and the rest are 0. + parameters = torch.tensor([0.0, 0.0, 0.0, 0.0, 0.0, 1.0], dtype=torch.float64, requires_grad=True) + PfaffianParlettReid.apply(_skew_from_parameters(parameters, 4)).backward() + expected = torch.tensor([1.0, 0.0, 0.0, 0.0, 0.0, 0.0], dtype=torch.float64) + torch.testing.assert_close(parameters.grad, expected, atol=ATOL_SCALAR_COMPARISON, rtol=RTOL_SCALAR_COMPARISON) + + def test_backward_gradcheck_at_singular_point(self): + # gradcheck centered at an exactly-singular skew point (would fail with the inverse-only form). + parameters = torch.tensor([0.0, 0.0, 0.0, 0.0, 0.0, 1.0], dtype=torch.float64, requires_grad=True) + assert gradcheck( + lambda values: PfaffianParlettReid.apply(_skew_from_parameters(values, 4)), + (parameters,), + eps=1e-6, + atol=ATOL_APPROX_COMPARISON, + rtol=RTOL_APPROX_COMPARISON, + ) + + def test_backward_returns_none_when_input_does_not_require_grad(self): + matrix = _random_skew(4, _RNG) + pfaffian = PfaffianParlettReid.apply(matrix) + + class _Context: + saved_tensors = (matrix, pfaffian) + needs_input_grad = (False,) + + assert PfaffianParlettReid.backward(_Context(), torch.ones_like(pfaffian)) is None diff --git a/tests/test_strategies/test_pfaffian_rust_parlett_reid.py b/tests/test_strategies/test_pfaffian_rust_parlett_reid.py new file mode 100644 index 0000000..61ad21f --- /dev/null +++ b/tests/test_strategies/test_pfaffian_rust_parlett_reid.py @@ -0,0 +1,176 @@ +import numpy as np +import pytest +import torch +from torch.autograd import gradcheck + +pytest.importorskip("torch_pfaffian._rust") + +from tests.configs import ( # noqa: E402 + ATOL_APPROX_COMPARISON, + ATOL_MATRIX_COMPARISON, + ATOL_SCALAR_COMPARISON, + N_RANDOM_TESTS_PER_CASE, + RTOL_APPROX_COMPARISON, + RTOL_MATRIX_COMPARISON, + RTOL_SCALAR_COMPARISON, + TEST_SEED, +) +from torch_pfaffian.strategies.pfaffian_parlett_reid import PfaffianParlettReid # noqa: E402 +from torch_pfaffian.strategies.pfaffian_rust_parlett_reid import RustPfaffianParlettReid # noqa: E402 + +_RNG = np.random.default_rng(TEST_SEED) +_HALF_SIZES = [1, 2, 3, 4] +_RANDOM_BLOCKS = [_RNG.random((size, size)) for size in _HALF_SIZES for _ in range(N_RANDOM_TESTS_PER_CASE)] +_GRADCHECK_DIMENSIONS = [2, 4, 6] + + +def _block_antidiagonal(block: np.ndarray) -> torch.Tensor: + zero = np.zeros_like(block) + top = np.concatenate([zero, block], axis=-1) + bottom = np.concatenate([-np.einsum("...ij->...ji", block), zero], axis=-1) + return torch.tensor(np.concatenate([top, bottom], axis=-2)) + + +def _random_skew(dimension: int, rng: np.random.Generator) -> torch.Tensor: + upper = rng.random((dimension, dimension)) + skew = np.triu(upper, k=1) + return torch.tensor(skew - skew.T) + + +def _skew_from_parameters(parameters: torch.Tensor, dimension: int) -> torch.Tensor: + upper = torch.zeros(dimension, dimension, dtype=parameters.dtype) + indices = torch.triu_indices(dimension, dimension, offset=1) + upper = upper.index_put((indices[0], indices[1]), parameters) + return upper - upper.transpose(-1, -2) + + +class TestRustPfaffianParlettReid: + @pytest.mark.parametrize("block", _RANDOM_BLOCKS) + def test_forward_matches_python_parlett_reid(self, block): + matrix = _block_antidiagonal(block) + torch.testing.assert_close( + RustPfaffianParlettReid.apply(matrix), + PfaffianParlettReid.apply(matrix), + atol=ATOL_MATRIX_COMPARISON, + rtol=RTOL_MATRIX_COMPARISON, + ) + + @pytest.mark.parametrize("block", _RANDOM_BLOCKS) + def test_forward_square_matches_determinant(self, block): + matrix = _block_antidiagonal(block) + torch.testing.assert_close( + RustPfaffianParlettReid.apply(matrix) ** 2, + torch.linalg.det(matrix), + atol=ATOL_MATRIX_COMPARISON, + rtol=RTOL_MATRIX_COMPARISON, + ) + + def test_forward_two_by_two_is_signed(self): + matrix = torch.tensor([[0.0, -3.0], [3.0, 0.0]], dtype=torch.float64) + torch.testing.assert_close( + RustPfaffianParlettReid.apply(matrix), + torch.tensor(-3.0, dtype=torch.float64), + atol=ATOL_SCALAR_COMPARISON, + rtol=RTOL_SCALAR_COMPARISON, + ) + + def test_forward_supports_leading_batch_dims(self): + matrix = _block_antidiagonal(_RNG.random((2, 3, 4, 4))) + pfaffian = RustPfaffianParlettReid.apply(matrix) + assert pfaffian.shape == matrix.shape[:-2] + torch.testing.assert_close( + pfaffian**2, torch.linalg.det(matrix), atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON + ) + + @pytest.mark.parametrize("dtype", [torch.float32, torch.float64]) + def test_forward_preserves_dtype_and_device(self, dtype): + matrix = _random_skew(6, _RNG).to(dtype) + pfaffian = RustPfaffianParlettReid.apply(matrix) + assert pfaffian.dtype == dtype + assert pfaffian.device == matrix.device + + def test_forward_float32_kernel_matches_float64(self): + # The float32 input must route to the single-precision Rust kernel and agree with the + # double-precision result within single-precision tolerance. + matrix_double = _block_antidiagonal(_RNG.random((3, 4, 4))) + matrix_single = matrix_double.to(torch.float32) + result_single = RustPfaffianParlettReid.apply(matrix_single) + result_double = RustPfaffianParlettReid.apply(matrix_double) + assert result_single.dtype == torch.float32 + torch.testing.assert_close( + result_single, + result_double.to(torch.float32), + atol=ATOL_APPROX_COMPARISON, + rtol=RTOL_APPROX_COMPARISON, + ) + + def test_forward_odd_dimension_is_zero(self): + matrix = _random_skew(5, _RNG) + torch.testing.assert_close( + RustPfaffianParlettReid.apply(matrix), + torch.zeros((), dtype=matrix.dtype), + atol=ATOL_SCALAR_COMPARISON, + rtol=RTOL_SCALAR_COMPARISON, + ) + + def test_forward_empty_matrix_is_one(self): + matrix = torch.zeros((0, 0), dtype=torch.float64) + torch.testing.assert_close( + RustPfaffianParlettReid.apply(matrix), + torch.ones((), dtype=torch.float64), + atol=ATOL_SCALAR_COMPARISON, + rtol=RTOL_SCALAR_COMPARISON, + ) + + def test_forward_singular_matrix_is_zero(self): + matrix = torch.zeros((4, 4), dtype=torch.float64) + matrix[2, 3] = 1.0 + matrix[3, 2] = -1.0 + torch.testing.assert_close( + RustPfaffianParlettReid.apply(matrix), + torch.zeros((), dtype=torch.float64), + atol=ATOL_SCALAR_COMPARISON, + rtol=RTOL_SCALAR_COMPARISON, + ) + + @pytest.mark.parametrize("dimension", _GRADCHECK_DIMENSIONS) + def test_backward_passes_gradcheck_on_skew_parameterization(self, dimension): + count = dimension * (dimension - 1) // 2 + parameters = torch.tensor(_RNG.random(count) + 0.5, dtype=torch.float64, requires_grad=True) + assert gradcheck( + lambda values: RustPfaffianParlettReid.apply(_skew_from_parameters(values, dimension)), + (parameters,), + eps=1e-6, + atol=ATOL_APPROX_COMPARISON, + rtol=RTOL_APPROX_COMPARISON, + ) + + def test_backward_exact_on_singular_matrix(self): + # At an exactly-singular skew input (pf=0) the gradient must be the TRUE derivative, via the + # Pfaffian adjugate. For the rank-2 matrix with only a_{23}=1, pf = a01*a23 - a02*a13 + a03*a12, + # so d pf / d a01 = a23 = 1 and the rest are 0. + parameters = torch.tensor([0.0, 0.0, 0.0, 0.0, 0.0, 1.0], dtype=torch.float64, requires_grad=True) + RustPfaffianParlettReid.apply(_skew_from_parameters(parameters, 4)).backward() + expected = torch.tensor([1.0, 0.0, 0.0, 0.0, 0.0, 0.0], dtype=torch.float64) + torch.testing.assert_close(parameters.grad, expected, atol=ATOL_SCALAR_COMPARISON, rtol=RTOL_SCALAR_COMPARISON) + + def test_backward_gradcheck_at_singular_point(self): + # gradcheck centered at an exactly-singular skew point (would fail with the inverse-only form). + parameters = torch.tensor([0.0, 0.0, 0.0, 0.0, 0.0, 1.0], dtype=torch.float64, requires_grad=True) + assert gradcheck( + lambda values: RustPfaffianParlettReid.apply(_skew_from_parameters(values, 4)), + (parameters,), + eps=1e-6, + atol=ATOL_APPROX_COMPARISON, + rtol=RTOL_APPROX_COMPARISON, + ) + + def test_backward_returns_none_when_input_does_not_require_grad(self): + matrix = _random_skew(4, _RNG) + pfaffian = RustPfaffianParlettReid.apply(matrix) + + class _Context: + saved_tensors = (matrix, pfaffian) + needs_input_grad = (False,) + + assert RustPfaffianParlettReid.backward(_Context(), torch.ones_like(pfaffian)) is None diff --git a/tests/test_strategies/test_strategy.py b/tests/test_strategies/test_strategy.py index 2ae0e93..f8644e5 100644 --- a/tests/test_strategies/test_strategy.py +++ b/tests/test_strategies/test_strategy.py @@ -1,8 +1,16 @@ import torch +from tests.configs import ATOL_MATRIX_COMPARISON, RTOL_MATRIX_COMPARISON +from torch_pfaffian.strategies.pfaffian_parlett_reid import PfaffianParlettReid from torch_pfaffian.strategies.strategy import PfaffianStrategy +def _random_skew(dimension: int, seed: int) -> torch.Tensor: + generator = torch.Generator().manual_seed(seed) + full = torch.randn(dimension, dimension, dtype=torch.float64, generator=generator) + return full - full.transpose(-1, -2) + + class _RecordingContext: def save_for_backward(self, *tensors): self.saved_tensors = tensors @@ -26,3 +34,27 @@ def test_base_forward_is_not_implemented(self): def test_base_backward_is_not_implemented(self): assert PfaffianStrategy.backward(None, None) is None + + def test_grad_matrix_matches_inverse_form_on_invertible(self): + # For invertible inputs the adjugate-based gradient equals the inverse-based closed form. + matrix = _random_skew(6, seed=0) + pfaffian = PfaffianParlettReid.forward(matrix) + grad_output = torch.tensor(1.7, dtype=torch.float64) + expected = torch.einsum("...,...ij->...ji", 0.5 * grad_output * pfaffian, torch.linalg.inv(matrix)) + result = PfaffianParlettReid.pfaffian_grad_matrix(matrix, pfaffian, grad_output) + torch.testing.assert_close(result, expected, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) + + def test_grad_matrix_uses_adjugate_on_singular(self): + # Singular batch element (pf=0): the gradient is the exact Pfaffian-adjugate form, not zero. + singular = torch.zeros(4, 4, dtype=torch.float64) + singular[2, 3] = 1.0 + singular[3, 2] = -1.0 + invertible = _random_skew(4, seed=1) + matrix = torch.stack([singular, invertible]) + pfaffian = PfaffianParlettReid.forward(matrix) + assert pfaffian[0] == 0.0 # the singular element really has Pfaffian 0 + grad_output = torch.ones(2, dtype=torch.float64) + result = PfaffianParlettReid.pfaffian_grad_matrix(matrix, pfaffian, grad_output) + # d pf / d A_{01} = a_{23} = 1, so the gradient of the singular element is nonzero. + assert torch.isfinite(result).all() + assert result[0].abs().sum() > 0 diff --git a/tests/test_torch_pfaffian.py b/tests/test_torch_pfaffian.py index dcbea59..cc98b7e 100644 --- a/tests/test_torch_pfaffian.py +++ b/tests/test_torch_pfaffian.py @@ -1,11 +1,22 @@ +from unittest import mock + import pytest import torch -from torch_pfaffian import get_pfaffian_function, pfaffian_strategy_map -from torch_pfaffian.strategies import PfaffianDet, PfaffianFDBPf +import torch_pfaffian +from torch_pfaffian import get_pfaffian_function, pfaffian, pfaffian_strategy_map +from torch_pfaffian.strategies import PfaffianDet, PfaffianFDBPf, PfaffianParlettReid class TestTorchPfaffian: + def test_rust_parlett_reid_registered_when_available(self): + pytest.importorskip("torch_pfaffian._rust") + from torch_pfaffian.strategies import RustPfaffianParlettReid + + assert RustPfaffianParlettReid is not None + assert RustPfaffianParlettReid.NAME.lower().strip() in pfaffian_strategy_map + assert get_pfaffian_function(RustPfaffianParlettReid.NAME) == RustPfaffianParlettReid.apply + def test_pfaffian_strategy_map_contains_registered_strategies(self): assert PfaffianFDBPf.NAME.lower().strip() in pfaffian_strategy_map assert PfaffianDet.NAME.lower().strip() in pfaffian_strategy_map @@ -30,3 +41,99 @@ def test_get_pfaffian_function_is_case_and_whitespace_insensitive(self): def test_get_pfaffian_function_unknown_name_raises_value_error(self): with pytest.raises(ValueError, match="Unknown strategy name"): get_pfaffian_function("not_a_real_strategy") + + def test_parlett_reid_is_registered(self): + assert PfaffianParlettReid.NAME.lower().strip() in pfaffian_strategy_map + assert get_pfaffian_function(PfaffianParlettReid.NAME) == PfaffianParlettReid.apply + + @staticmethod + def _skew_matrix() -> torch.Tensor: + return torch.tensor([[0.0, -3.0], [3.0, 0.0]], dtype=torch.float64) + + def test_pfaffian_signed_by_default_matches_parlett_reid(self): + matrix = self._skew_matrix() + torch.testing.assert_close(pfaffian(matrix), PfaffianParlettReid.apply(matrix)) + assert pfaffian(matrix).item() < 0 # signed, not magnitude + + def test_pfaffian_sign_false_returns_magnitude(self): + matrix = self._skew_matrix() + torch.testing.assert_close(pfaffian(matrix, sign=False), PfaffianDet.apply(matrix)) + assert pfaffian(matrix, sign=False).item() > 0 + + def test_pfaffian_routes_sign_true_to_rust_when_available(self): + pytest.importorskip("torch_pfaffian._rust") + with mock.patch.object(torch_pfaffian, "RustPfaffianParlettReid") as fake: + fake.apply.return_value = torch.zeros(()) + pfaffian(self._skew_matrix(), sign=True) + fake.apply.assert_called_once() + + def test_pfaffian_routes_sign_true_to_python_when_rust_unavailable(self): + with ( + mock.patch.object(torch_pfaffian, "RustPfaffianParlettReid", None), + mock.patch.object(torch_pfaffian, "PfaffianParlettReid") as fake, + ): + fake.apply.return_value = torch.zeros(()) + pfaffian(self._skew_matrix(), sign=True) + fake.apply.assert_called_once() + + def test_pfaffian_sign_true_routes_to_python_on_non_cpu_device(self): + # The Rust kernel is CPU-only, so a non-CPU input must use the device-native PyTorch strategy. + pytest.importorskip("torch_pfaffian._rust") + non_cpu_matrix = mock.MagicMock() + non_cpu_matrix.device.type = "cuda" + with ( + mock.patch.object(torch_pfaffian, "RustPfaffianParlettReid") as fake_rust, + mock.patch.object(torch_pfaffian, "PfaffianParlettReid") as fake_python, + ): + fake_python.apply.return_value = torch.zeros(()) + pfaffian(non_cpu_matrix, sign=True) + fake_python.apply.assert_called_once() + fake_rust.apply.assert_not_called() + + def test_pfaffian_routes_magnitude_no_grad_to_det(self): + with mock.patch.object(torch_pfaffian, "PfaffianDet") as fake: + fake.apply.return_value = torch.zeros(()) + pfaffian(self._skew_matrix(), sign=False) + fake.apply.assert_called_once() + + def test_pfaffian_routes_magnitude_with_grad_to_fdbpf(self): + matrix = self._skew_matrix().requires_grad_(True) + with mock.patch.object(torch_pfaffian, "PfaffianFDBPf") as fake: + fake.apply.return_value = torch.zeros((), requires_grad=True) + pfaffian(matrix, sign=False) + fake.apply.assert_called_once() + + def test_pfaffian_signed_backward_flows(self): + matrix = self._skew_matrix().requires_grad_(True) + pfaffian(matrix).backward() + assert matrix.grad is not None + assert matrix.grad.shape == matrix.shape + + def test_pfaffian_check_input_rejects_non_skew(self): + non_skew = torch.tensor([[1.0, 2.0], [3.0, 4.0]], dtype=torch.float64) + with pytest.raises(ValueError, match="skew-symmetric"): + pfaffian(non_skew, check_input=True) + + def test_pfaffian_check_input_rejects_non_square(self): + non_square = torch.zeros((2, 4), dtype=torch.float64) + with pytest.raises(ValueError, match="square"): + pfaffian(non_square, check_input=True) + + def test_pfaffian_check_input_accepts_skew_matrix(self): + matrix = self._skew_matrix() + torch.testing.assert_close(pfaffian(matrix, check_input=True), pfaffian(matrix)) + + def test_pfaffian_check_input_off_by_default_allows_non_skew(self): + non_skew = torch.tensor([[1.0, 2.0], [3.0, 4.0]], dtype=torch.float64) + pfaffian(non_skew) # no validation by default, so no error is raised + + def test_pfaffian_warns_when_result_overflows(self): + # A 4x4 block-antidiagonal with huge entries makes the Pfaffian overflow to inf. + block = torch.tensor([[1e200, 0.0], [0.0, 1e200]], dtype=torch.float64) + zero = torch.zeros_like(block) + top = torch.cat([zero, block], dim=-1) + bottom = torch.cat([-block.transpose(-1, -2), zero], dim=-1) + matrix = torch.cat([top, bottom], dim=-2) + with pytest.warns(RuntimeWarning, match="not finite"): + result = pfaffian(matrix) + assert not torch.isfinite(result).all() diff --git a/uv.lock b/uv.lock index 55df965..4a86916 100644 --- a/uv.lock +++ b/uv.lock @@ -2,20 +2,49 @@ version = 1 revision = 3 requires-python = ">=3.10, <3.15" resolution-markers = [ - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", "python_full_version == '3.11.*' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", "python_full_version < '3.11' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", "python_full_version < '3.11' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", ] conflicts = [[ @@ -438,16 +467,45 @@ name = "contourpy" version = "1.3.3" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", "python_full_version == '3.11.*' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", ] dependencies = [ { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, @@ -650,7 +708,7 @@ name = "cryptography" version = "48.0.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cffi", marker = "(platform_python_implementation != 'PyPy' and sys_platform != 'darwin') or (platform_python_implementation != 'PyPy' and extra != 'extra-13-torchpfaffian-cpu') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "cffi", marker = "(python_full_version < '3.11' and platform_python_implementation != 'PyPy' and sys_platform == 'emscripten') or (python_full_version < '3.11' and platform_python_implementation != 'PyPy' and sys_platform == 'win32') or (python_full_version >= '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version >= '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version >= '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version >= '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version >= '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version >= '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (platform_python_implementation != 'PyPy' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32') or (platform_python_implementation != 'PyPy' and sys_platform == 'darwin' and extra != 'extra-13-torchpfaffian-cpu') or (platform_python_implementation == 'PyPy' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (platform_python_implementation == 'PyPy' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (platform_python_implementation == 'PyPy' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, { name = "typing-extensions", marker = "(python_full_version < '3.11' and sys_platform != 'darwin') or (python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/12/45/870e7f4bef50e5f53b9f51d4428aee5290eedf58ba443f16b1ebb7ab8e66/cryptography-48.0.1.tar.gz", hash = "sha256:266f4ee051abb2f725b74ef8072b521ce1feacf685a3364fa6a6b45548db791a", size = 832989, upload-time = "2026-06-09T22:32:31.8Z" } @@ -710,12 +768,13 @@ name = "cuda-bindings" version = "12.9.4" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "python_full_version >= '3.12'", - "python_full_version == '3.11.*'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", "python_full_version < '3.11'", ] dependencies = [ - { name = "cuda-pathfinder", marker = "extra == 'extra-13-torchpfaffian-cu128' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "cuda-pathfinder", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/37/31/bfcc870f69c6a017c4ad5c42316207fc7551940db6f3639aa4466ec5faf3/cuda_bindings-12.9.4-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a022c96b8bd847e8dc0675523431149a4c3e872f440e3002213dbb9e08f0331a", size = 11800959, upload-time = "2025-10-21T14:51:26.458Z" }, @@ -746,12 +805,13 @@ name = "cuda-bindings" version = "13.0.3" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "python_full_version >= '3.12'", - "python_full_version == '3.11.*'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", "python_full_version < '3.11'", ] dependencies = [ - { name = "cuda-pathfinder", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "cuda-pathfinder", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/3b/98/0666ee759cd2e5306f911cbc95d2c6c814326906ed6b9c09e817a4b4a7c8/cuda_bindings-13.0.3-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d56e46a9e984bb754e56b9d060cf027fe99f08a97651ce6d8aa1c2032476d01e", size = 11762523, upload-time = "2025-10-21T15:08:45.913Z" }, @@ -1170,16 +1230,45 @@ name = "ipython" version = "9.14.1" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", "python_full_version == '3.11.*' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", ] dependencies = [ { name = "colorama", marker = "(python_full_version >= '3.11' and sys_platform == 'win32') or (python_full_version < '3.11' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version < '3.11' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version < '3.11' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, @@ -1793,6 +1882,30 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/41/09/5b161152e2d90f7b87f781c2e1267494aef9c32498df793f73ad0a0a494a/matplotlib_inline-0.2.2-py3-none-any.whl", hash = "sha256:3c821cf1c209f59fb2d2d64abbf5b23b67bcb2210d663f9918dd851c6da1fcf6", size = 9534, upload-time = "2026-05-08T17:33:32.055Z" }, ] +[[package]] +name = "maturin" +version = "1.13.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "tomli", marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9c/1c/612d23d33ec21b9ae7ece7b3f0dd5f9dfd57b4009e9d2938165869ebd6ae/maturin-1.13.3.tar.gz", hash = "sha256:771e1e9e71a278e56db01552e0d1acfd1464259f9575b6e72842f893cd299079", size = 357934, upload-time = "2026-05-11T07:43:39.027Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/66/18c2aaac0b2a5dea9f1db5984ce83b905ad205cfc7c02d0091e707c0c2e7/maturin-1.13.3-py3-none-linux_armv6l.whl", hash = "sha256:3cc13929ca82aefa4adbf0f2c35419369796213c6fb0eb24e914945f50ef5d8c", size = 10190971, upload-time = "2026-05-11T07:43:10.431Z" }, + { url = "https://files.pythonhosted.org/packages/bc/71/26a988d092e4fd6a9523d46d44400a46cad7cdf3fd206ce702240c748aee/maturin-1.13.3-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:53b08bd075649ce96513ad9abf241a43cb685ed6e9e7790f8dbc2d66e95d8323", size = 19716714, upload-time = "2026-05-11T07:43:36.911Z" }, + { url = "https://files.pythonhosted.org/packages/82/5c/f3fd0e184255d9fc7e272c62af3dfa84c617b2577ef83af9ce615f5279cc/maturin-1.13.3-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:4cd478e6e4c56251e48ed079b8efd55b30bc5c09cf695a1bdafaeb582ee735a0", size = 10194726, upload-time = "2026-05-11T07:43:07.05Z" }, + { url = "https://files.pythonhosted.org/packages/a9/e1/f4edb69fb647b77c4769a9bfd4d6fb62961e653d164bc277ecdffac3ab61/maturin-1.13.3-py3-none-manylinux_2_12_i686.manylinux2010_i686.musllinux_1_1_i686.whl", hash = "sha256:a2675e25f313034ae6f57388cf14818f87d8961c4a96795287f3e155f59beb11", size = 10172781, upload-time = "2026-05-11T07:43:40.796Z" }, + { url = "https://files.pythonhosted.org/packages/c7/7d/a1be934690cdcc3c6609769ceaad322ab7501c2ee5bafcac1b14d609e403/maturin-1.13.3-py3-none-manylinux_2_12_x86_64.manylinux2010_x86_64.musllinux_1_1_x86_64.whl", hash = "sha256:4667ef609ab446c1b5e0bfe4f9fb99699ab6d8548433f8d1a684256e0b67217f", size = 10682670, upload-time = "2026-05-11T07:43:13.132Z" }, + { url = "https://files.pythonhosted.org/packages/18/f5/372ae19b72ce8f6e37e5864ae4dc5b252ee9fce0619ccc3aa366aa3a7f97/maturin-1.13.3-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:3db93337ed97e60ffc878aa8b493cd7ae44d3a5e1a37256db3a4491f57565018", size = 10060363, upload-time = "2026-05-11T07:43:21.107Z" }, + { url = "https://files.pythonhosted.org/packages/cb/5b/c68340cca09368af0df80965dfabed4234205a492a93da00793c7b9aae20/maturin-1.13.3-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l.whl", hash = "sha256:1cc0a110b224ca90406b668a3e3c1f5a515062e59e26292f6dbaf5fd4909c6f3", size = 10017551, upload-time = "2026-05-11T07:43:33.916Z" }, + { url = "https://files.pythonhosted.org/packages/28/1e/f90fb2b000bad9e6d850cd5afb88b2f1e2a279cfb4de02ea40078484690e/maturin-1.13.3-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.musllinux_1_1_ppc64le.whl", hash = "sha256:c00ea6428dea17bf616fe93770837634454b28c2de1a876e42ef8036c616079a", size = 13301712, upload-time = "2026-05-11T07:43:26.492Z" }, + { url = "https://files.pythonhosted.org/packages/be/58/1670f68a8f04ccd7b90df11047bd9a046585310e84e1967cc9849cd1c5a3/maturin-1.13.3-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:49fd6ab08da28098ccf37afca24cdba72376ba9c1eedf9dd25ff82ed771961ff", size = 10946765, upload-time = "2026-05-11T07:43:16.135Z" }, + { url = "https://files.pythonhosted.org/packages/4b/ac/00c955c2ef134817b1a7bdaa76b0309e9c5291eb17d9ff88069eecd08bc2/maturin-1.13.3-py3-none-manylinux_2_31_riscv64.musllinux_1_1_riscv64.whl", hash = "sha256:b6741d7bf4af97da937528fd1e523c6ab54f53d9a21870fa735d6e67fd88e273", size = 10388661, upload-time = "2026-05-11T07:43:18.727Z" }, + { url = "https://files.pythonhosted.org/packages/97/c6/cbf8a51dde19c19aeba0d9b075095a2effb9b31fd312b1aae3ac79f8aea2/maturin-1.13.3-py3-none-win32.whl", hash = "sha256:0ef257e692cc756c87af5bea95ddfe7d3ac49d3376a7a87f728d63f06e7b6f8b", size = 8901838, upload-time = "2026-05-11T07:43:23.76Z" }, + { url = "https://files.pythonhosted.org/packages/a1/ff/c6a50a59dc8313097d43ac5f4d74df6a500c8cb62b0dc9e054f53e203a48/maturin-1.13.3-py3-none-win_amd64.whl", hash = "sha256:def4a435ea9d2ee93b18ba579dc8c9cf898889a66f312cd379b5e374ec3e3ad6", size = 10340801, upload-time = "2026-05-11T07:43:29.239Z" }, + { url = "https://files.pythonhosted.org/packages/6c/93/e32e79333f0902ba292b996f504f5f06be59587f7d02ab8d5ed1e3066445/maturin-1.13.3-py3-none-win_arm64.whl", hash = "sha256:2389fe92d017cea9d94e521fa0175314a4c52f79a1057b901fbc9f8686ef7d0b", size = 9706562, upload-time = "2026-05-11T07:43:31.743Z" }, +] + [[package]] name = "mdit-py-plugins" version = "0.6.1" @@ -2051,16 +2164,45 @@ name = "networkx" version = "3.6.1" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", "python_full_version == '3.11.*' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", ] sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", hash = "sha256:26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509", size = 2517025, upload-time = "2025-12-08T17:02:39.908Z" } wheels = [ @@ -2184,16 +2326,45 @@ name = "numpy" version = "2.4.6" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", "python_full_version == '3.11.*' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", ] sdist = { url = "https://files.pythonhosted.org/packages/d0/ad/fed0499ce6a338d2a03ebae59cd15093910c8875328855781952abf6c2fe/numpy-2.4.6.tar.gz", hash = "sha256:f3a3570c4a2a16746ac2c31a7c7c7b0c186b95ce902e33db6f28094ed7387dda", size = 20735807, upload-time = "2026-05-18T23:37:14.07Z" } wheels = [ @@ -2355,7 +2526,7 @@ name = "nvidia-cudnn-cu12" version = "9.10.2.21" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-cublas-cu12", marker = "extra == 'extra-13-torchpfaffian-cu128' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cublas-cu12", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/fa/41/e79269ce215c857c935fd86bcfe91a451a584dfc27f1e068f568b9ad1ab7/nvidia_cudnn_cu12-9.10.2.21-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:c9132cc3f8958447b4910a1720036d9eff5928cc3179b0a51fb6d167c6cc87d8", size = 705026878, upload-time = "2025-06-06T21:52:51.348Z" }, @@ -2368,7 +2539,7 @@ name = "nvidia-cudnn-cu13" version = "9.15.1.9" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-cublas", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cublas", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/ff/93/b3c9db2c35d6183361333d2dcfea50e094c012d012c8a4d7effbfb53ef62/nvidia_cudnn_cu13-9.15.1.9-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:44cd2ec83c3ef62a7357614bd02ce7f3dac35ffcbb04ad20999e730741f0ba17", size = 415636241, upload-time = "2025-11-12T20:22:26.582Z" }, @@ -2381,7 +2552,7 @@ name = "nvidia-cufft" version = "12.0.0.61" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-nvjitlink", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-nvjitlink", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/8b/ae/f417a75c0259e85c1d2f83ca4e960289a5f814ed0cea74d18c353d3e989d/nvidia_cufft-12.0.0.61-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2708c852ef8cd89d1d2068bdbece0aa188813a0c934db3779b9b1faa8442e5f5", size = 214053554, upload-time = "2025-09-04T08:31:38.196Z" }, @@ -2394,7 +2565,7 @@ name = "nvidia-cufft-cu12" version = "11.3.3.83" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-nvjitlink-cu12", marker = "extra == 'extra-13-torchpfaffian-cu128' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-nvjitlink-cu12", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/60/bc/7771846d3a0272026c416fbb7e5f4c1f146d6d80704534d0b187dd6f4800/nvidia_cufft_cu12-11.3.3.83-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:848ef7224d6305cdb2a4df928759dca7b1201874787083b6e7550dd6765ce69a", size = 193109211, upload-time = "2025-03-07T01:44:56.873Z" }, @@ -2445,9 +2616,9 @@ name = "nvidia-cusolver" version = "12.0.4.66" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-cublas", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, - { name = "nvidia-cusparse", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, - { name = "nvidia-nvjitlink", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cublas", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cusparse", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-nvjitlink", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/c8/c3/b30c9e935fc01e3da443ec0116ed1b2a009bb867f5324d3f2d7e533e776b/nvidia_cusolver-12.0.4.66-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:02c2457eaa9e39de20f880f4bd8820e6a1cfb9f9a34f820eb12a155aa5bc92d2", size = 223467760, upload-time = "2025-09-04T08:33:04.222Z" }, @@ -2460,9 +2631,9 @@ name = "nvidia-cusolver-cu12" version = "11.7.3.90" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-cublas-cu12", marker = "extra == 'extra-13-torchpfaffian-cu128' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, - { name = "nvidia-cusparse-cu12", marker = "extra == 'extra-13-torchpfaffian-cu128' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, - { name = "nvidia-nvjitlink-cu12", marker = "extra == 'extra-13-torchpfaffian-cu128' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cublas-cu12", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cusparse-cu12", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-nvjitlink-cu12", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/c8/32/f7cd6ce8a7690544d084ea21c26e910a97e077c9b7f07bf5de623ee19981/nvidia_cusolver_cu12-11.7.3.90-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:db9ed69dbef9715071232caa9b69c52ac7de3a95773c2db65bdba85916e4e5c0", size = 267229841, upload-time = "2025-03-07T01:46:54.356Z" }, @@ -2475,7 +2646,7 @@ name = "nvidia-cusparse" version = "12.6.3.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-nvjitlink", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-nvjitlink", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/f8/94/5c26f33738ae35276672f12615a64bd008ed5be6d1ebcb23579285d960a9/nvidia_cusparse-12.6.3.3-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:80bcc4662f23f1054ee334a15c72b8940402975e0eab63178fc7e670aa59472c", size = 162155568, upload-time = "2025-09-04T08:33:42.864Z" }, @@ -2488,7 +2659,7 @@ name = "nvidia-cusparse-cu12" version = "12.5.8.93" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-nvjitlink-cu12", marker = "extra == 'extra-13-torchpfaffian-cu128' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-nvjitlink-cu12", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/bc/f7/cd777c4109681367721b00a106f491e0d0d15cfa1fd59672ce580ce42a97/nvidia_cusparse_cu12-12.5.8.93-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:9b6c161cb130be1a07a27ea6923df8141f3c295852f4b260c65f18f3e0a091dc", size = 288117129, upload-time = "2025-03-07T01:47:40.407Z" }, @@ -2601,6 +2772,175 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/df/b2/87e62e8c3e2f4b32e5fe99e0b86d576da1312593b39f47d8ceef365e95ed/packaging-26.2-py3-none-any.whl", hash = "sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e", size = 100195, upload-time = "2026-04-24T20:15:22.081Z" }, ] +[[package]] +name = "pandas" +version = "2.3.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", +] +dependencies = [ + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "python-dateutil", marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "pytz", marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "tzdata", marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +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 = [ + { url = "https://files.pythonhosted.org/packages/3d/f7/f425a00df4fcc22b292c6895c6831c0c8ae1d9fac1e024d16f98a9ce8749/pandas-2.3.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:376c6446ae31770764215a6c937f72d917f214b43560603cd60da6408f183b6c", size = 11555763, upload-time = "2025-09-29T23:16:53.287Z" }, + { url = "https://files.pythonhosted.org/packages/13/4f/66d99628ff8ce7857aca52fed8f0066ce209f96be2fede6cef9f84e8d04f/pandas-2.3.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e19d192383eab2f4ceb30b412b22ea30690c9e618f78870357ae1d682912015a", size = 10801217, upload-time = "2025-09-29T23:17:04.522Z" }, + { url = "https://files.pythonhosted.org/packages/1d/03/3fc4a529a7710f890a239cc496fc6d50ad4a0995657dccc1d64695adb9f4/pandas-2.3.3-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5caf26f64126b6c7aec964f74266f435afef1c1b13da3b0636c7518a1fa3e2b1", size = 12148791, upload-time = "2025-09-29T23:17:18.444Z" }, + { url = "https://files.pythonhosted.org/packages/40/a8/4dac1f8f8235e5d25b9955d02ff6f29396191d4e665d71122c3722ca83c5/pandas-2.3.3-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dd7478f1463441ae4ca7308a70e90b33470fa593429f9d4c578dd00d1fa78838", size = 12769373, upload-time = "2025-09-29T23:17:35.846Z" }, + { url = "https://files.pythonhosted.org/packages/df/91/82cc5169b6b25440a7fc0ef3a694582418d875c8e3ebf796a6d6470aa578/pandas-2.3.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:4793891684806ae50d1288c9bae9330293ab4e083ccd1c5e383c34549c6e4250", size = 13200444, upload-time = "2025-09-29T23:17:49.341Z" }, + { url = "https://files.pythonhosted.org/packages/10/ae/89b3283800ab58f7af2952704078555fa60c807fff764395bb57ea0b0dbd/pandas-2.3.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:28083c648d9a99a5dd035ec125d42439c6c1c525098c58af0fc38dd1a7a1b3d4", size = 13858459, upload-time = "2025-09-29T23:18:03.722Z" }, + { url = "https://files.pythonhosted.org/packages/85/72/530900610650f54a35a19476eca5104f38555afccda1aa11a92ee14cb21d/pandas-2.3.3-cp310-cp310-win_amd64.whl", hash = "sha256:503cf027cf9940d2ceaa1a93cfb5f8c8c7e6e90720a2850378f0b3f3b1e06826", size = 11346086, upload-time = "2025-09-29T23:18:18.505Z" }, + { url = "https://files.pythonhosted.org/packages/c1/fa/7ac648108144a095b4fb6aa3de1954689f7af60a14cf25583f4960ecb878/pandas-2.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:602b8615ebcc4a0c1751e71840428ddebeb142ec02c786e8ad6b1ce3c8dec523", size = 11578790, upload-time = "2025-09-29T23:18:30.065Z" }, + { url = "https://files.pythonhosted.org/packages/9b/35/74442388c6cf008882d4d4bdfc4109be87e9b8b7ccd097ad1e7f006e2e95/pandas-2.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8fe25fc7b623b0ef6b5009149627e34d2a4657e880948ec3c840e9402e5c1b45", size = 10833831, upload-time = "2025-09-29T23:38:56.071Z" }, + { url = "https://files.pythonhosted.org/packages/fe/e4/de154cbfeee13383ad58d23017da99390b91d73f8c11856f2095e813201b/pandas-2.3.3-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b468d3dad6ff947df92dcb32ede5b7bd41a9b3cceef0a30ed925f6d01fb8fa66", size = 12199267, upload-time = "2025-09-29T23:18:41.627Z" }, + { url = "https://files.pythonhosted.org/packages/bf/c9/63f8d545568d9ab91476b1818b4741f521646cbdd151c6efebf40d6de6f7/pandas-2.3.3-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b98560e98cb334799c0b07ca7967ac361a47326e9b4e5a7dfb5ab2b1c9d35a1b", size = 12789281, upload-time = "2025-09-29T23:18:56.834Z" }, + { url = "https://files.pythonhosted.org/packages/f2/00/a5ac8c7a0e67fd1a6059e40aa08fa1c52cc00709077d2300e210c3ce0322/pandas-2.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37b5848ba49824e5c30bedb9c830ab9b7751fd049bc7914533e01c65f79791", size = 13240453, upload-time = "2025-09-29T23:19:09.247Z" }, + { url = "https://files.pythonhosted.org/packages/27/4d/5c23a5bc7bd209231618dd9e606ce076272c9bc4f12023a70e03a86b4067/pandas-2.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:db4301b2d1f926ae677a751eb2bd0e8c5f5319c9cb3f88b0becbbb0b07b34151", size = 13890361, upload-time = "2025-09-29T23:19:25.342Z" }, + { url = "https://files.pythonhosted.org/packages/8e/59/712db1d7040520de7a4965df15b774348980e6df45c129b8c64d0dbe74ef/pandas-2.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:f086f6fe114e19d92014a1966f43a3e62285109afe874f067f5abbdcbb10e59c", size = 11348702, upload-time = "2025-09-29T23:19:38.296Z" }, + { url = "https://files.pythonhosted.org/packages/9c/fb/231d89e8637c808b997d172b18e9d4a4bc7bf31296196c260526055d1ea0/pandas-2.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d21f6d74eb1725c2efaa71a2bfc661a0689579b58e9c0ca58a739ff0b002b53", size = 11597846, upload-time = "2025-09-29T23:19:48.856Z" }, + { url = "https://files.pythonhosted.org/packages/5c/bd/bf8064d9cfa214294356c2d6702b716d3cf3bb24be59287a6a21e24cae6b/pandas-2.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3fd2f887589c7aa868e02632612ba39acb0b8948faf5cc58f0850e165bd46f35", size = 10729618, upload-time = "2025-09-29T23:39:08.659Z" }, + { url = "https://files.pythonhosted.org/packages/57/56/cf2dbe1a3f5271370669475ead12ce77c61726ffd19a35546e31aa8edf4e/pandas-2.3.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ecaf1e12bdc03c86ad4a7ea848d66c685cb6851d807a26aa245ca3d2017a1908", size = 11737212, upload-time = "2025-09-29T23:19:59.765Z" }, + { url = "https://files.pythonhosted.org/packages/e5/63/cd7d615331b328e287d8233ba9fdf191a9c2d11b6af0c7a59cfcec23de68/pandas-2.3.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b3d11d2fda7eb164ef27ffc14b4fcab16a80e1ce67e9f57e19ec0afaf715ba89", size = 12362693, upload-time = "2025-09-29T23:20:14.098Z" }, + { url = "https://files.pythonhosted.org/packages/a6/de/8b1895b107277d52f2b42d3a6806e69cfef0d5cf1d0ba343470b9d8e0a04/pandas-2.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a68e15f780eddf2b07d242e17a04aa187a7ee12b40b930bfdd78070556550e98", size = 12771002, upload-time = "2025-09-29T23:20:26.76Z" }, + { url = "https://files.pythonhosted.org/packages/87/21/84072af3187a677c5893b170ba2c8fbe450a6ff911234916da889b698220/pandas-2.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:371a4ab48e950033bcf52b6527eccb564f52dc826c02afd9a1bc0ab731bba084", size = 13450971, upload-time = "2025-09-29T23:20:41.344Z" }, + { url = "https://files.pythonhosted.org/packages/86/41/585a168330ff063014880a80d744219dbf1dd7a1c706e75ab3425a987384/pandas-2.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:a16dcec078a01eeef8ee61bf64074b4e524a2a3f4b3be9326420cabe59c4778b", size = 10992722, upload-time = "2025-09-29T23:20:54.139Z" }, + { url = "https://files.pythonhosted.org/packages/cd/4b/18b035ee18f97c1040d94debd8f2e737000ad70ccc8f5513f4eefad75f4b/pandas-2.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:56851a737e3470de7fa88e6131f41281ed440d29a9268dcbf0002da5ac366713", size = 11544671, upload-time = "2025-09-29T23:21:05.024Z" }, + { url = "https://files.pythonhosted.org/packages/31/94/72fac03573102779920099bcac1c3b05975c2cb5f01eac609faf34bed1ca/pandas-2.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bdcd9d1167f4885211e401b3036c0c8d9e274eee67ea8d0758a256d60704cfe8", size = 10680807, upload-time = "2025-09-29T23:21:15.979Z" }, + { url = "https://files.pythonhosted.org/packages/16/87/9472cf4a487d848476865321de18cc8c920b8cab98453ab79dbbc98db63a/pandas-2.3.3-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e32e7cc9af0f1cc15548288a51a3b681cc2a219faa838e995f7dc53dbab1062d", size = 11709872, upload-time = "2025-09-29T23:21:27.165Z" }, + { url = "https://files.pythonhosted.org/packages/15/07/284f757f63f8a8d69ed4472bfd85122bd086e637bf4ed09de572d575a693/pandas-2.3.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:318d77e0e42a628c04dc56bcef4b40de67918f7041c2b061af1da41dcff670ac", size = 12306371, upload-time = "2025-09-29T23:21:40.532Z" }, + { url = "https://files.pythonhosted.org/packages/33/81/a3afc88fca4aa925804a27d2676d22dcd2031c2ebe08aabd0ae55b9ff282/pandas-2.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4e0a175408804d566144e170d0476b15d78458795bb18f1304fb94160cabf40c", size = 12765333, upload-time = "2025-09-29T23:21:55.77Z" }, + { url = "https://files.pythonhosted.org/packages/8d/0f/b4d4ae743a83742f1153464cf1a8ecfafc3ac59722a0b5c8602310cb7158/pandas-2.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:93c2d9ab0fc11822b5eece72ec9587e172f63cff87c00b062f6e37448ced4493", size = 13418120, upload-time = "2025-09-29T23:22:10.109Z" }, + { url = "https://files.pythonhosted.org/packages/4f/c7/e54682c96a895d0c808453269e0b5928a07a127a15704fedb643e9b0a4c8/pandas-2.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:f8bfc0e12dc78f777f323f55c58649591b2cd0c43534e8355c51d3fede5f4dee", size = 10993991, upload-time = "2025-09-29T23:25:04.889Z" }, + { url = "https://files.pythonhosted.org/packages/f9/ca/3f8d4f49740799189e1395812f3bf23b5e8fc7c190827d55a610da72ce55/pandas-2.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:75ea25f9529fdec2d2e93a42c523962261e567d250b0013b16210e1d40d7c2e5", size = 12048227, upload-time = "2025-09-29T23:22:24.343Z" }, + { url = "https://files.pythonhosted.org/packages/0e/5a/f43efec3e8c0cc92c4663ccad372dbdff72b60bdb56b2749f04aa1d07d7e/pandas-2.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:74ecdf1d301e812db96a465a525952f4dde225fdb6d8e5a521d47e1f42041e21", size = 11411056, upload-time = "2025-09-29T23:22:37.762Z" }, + { url = "https://files.pythonhosted.org/packages/46/b1/85331edfc591208c9d1a63a06baa67b21d332e63b7a591a5ba42a10bb507/pandas-2.3.3-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6435cb949cb34ec11cc9860246ccb2fdc9ecd742c12d3304989017d53f039a78", size = 11645189, upload-time = "2025-09-29T23:22:51.688Z" }, + { url = "https://files.pythonhosted.org/packages/44/23/78d645adc35d94d1ac4f2a3c4112ab6f5b8999f4898b8cdf01252f8df4a9/pandas-2.3.3-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:900f47d8f20860de523a1ac881c4c36d65efcb2eb850e6948140fa781736e110", size = 12121912, upload-time = "2025-09-29T23:23:05.042Z" }, + { url = "https://files.pythonhosted.org/packages/53/da/d10013df5e6aaef6b425aa0c32e1fc1f3e431e4bcabd420517dceadce354/pandas-2.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a45c765238e2ed7d7c608fc5bc4a6f88b642f2f01e70c0c23d2224dd21829d86", size = 12712160, upload-time = "2025-09-29T23:23:28.57Z" }, + { url = "https://files.pythonhosted.org/packages/bd/17/e756653095a083d8a37cbd816cb87148debcfcd920129b25f99dd8d04271/pandas-2.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c4fc4c21971a1a9f4bdb4c73978c7f7256caa3e62b323f70d6cb80db583350bc", size = 13199233, upload-time = "2025-09-29T23:24:24.876Z" }, + { url = "https://files.pythonhosted.org/packages/04/fd/74903979833db8390b73b3a8a7d30d146d710bd32703724dd9083950386f/pandas-2.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:ee15f284898e7b246df8087fc82b87b01686f98ee67d85a17b7ab44143a3a9a0", size = 11540635, upload-time = "2025-09-29T23:25:52.486Z" }, + { url = "https://files.pythonhosted.org/packages/21/00/266d6b357ad5e6d3ad55093a7e8efc7dd245f5a842b584db9f30b0f0a287/pandas-2.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1611aedd912e1ff81ff41c745822980c49ce4a7907537be8692c8dbc31924593", size = 10759079, upload-time = "2025-09-29T23:26:33.204Z" }, + { url = "https://files.pythonhosted.org/packages/ca/05/d01ef80a7a3a12b2f8bbf16daba1e17c98a2f039cbc8e2f77a2c5a63d382/pandas-2.3.3-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6d2cefc361461662ac48810cb14365a365ce864afe85ef1f447ff5a1e99ea81c", size = 11814049, upload-time = "2025-09-29T23:27:15.384Z" }, + { url = "https://files.pythonhosted.org/packages/15/b2/0e62f78c0c5ba7e3d2c5945a82456f4fac76c480940f805e0b97fcbc2f65/pandas-2.3.3-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ee67acbbf05014ea6c763beb097e03cd629961c8a632075eeb34247120abcb4b", size = 12332638, upload-time = "2025-09-29T23:27:51.625Z" }, + { url = "https://files.pythonhosted.org/packages/c5/33/dd70400631b62b9b29c3c93d2feee1d0964dc2bae2e5ad7a6c73a7f25325/pandas-2.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c46467899aaa4da076d5abc11084634e2d197e9460643dd455ac3db5856b24d6", size = 12886834, upload-time = "2025-09-29T23:28:21.289Z" }, + { url = "https://files.pythonhosted.org/packages/d3/18/b5d48f55821228d0d2692b34fd5034bb185e854bdb592e9c640f6290e012/pandas-2.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6253c72c6a1d990a410bc7de641d34053364ef8bcd3126f7e7450125887dffe3", size = 13409925, upload-time = "2025-09-29T23:28:58.261Z" }, + { url = "https://files.pythonhosted.org/packages/a6/3d/124ac75fcd0ecc09b8fdccb0246ef65e35b012030defb0e0eba2cbbbe948/pandas-2.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:1b07204a219b3b7350abaae088f451860223a52cfb8a6c53358e7948735158e5", size = 11109071, upload-time = "2025-09-29T23:32:27.484Z" }, + { url = "https://files.pythonhosted.org/packages/89/9c/0e21c895c38a157e0faa1fb64587a9226d6dd46452cac4532d80c3c4a244/pandas-2.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2462b1a365b6109d275250baaae7b760fd25c726aaca0054649286bcfbb3e8ec", size = 12048504, upload-time = "2025-09-29T23:29:31.47Z" }, + { url = "https://files.pythonhosted.org/packages/d7/82/b69a1c95df796858777b68fbe6a81d37443a33319761d7c652ce77797475/pandas-2.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0242fe9a49aa8b4d78a4fa03acb397a58833ef6199e9aa40a95f027bb3a1b6e7", size = 11410702, upload-time = "2025-09-29T23:29:54.591Z" }, + { url = "https://files.pythonhosted.org/packages/f9/88/702bde3ba0a94b8c73a0181e05144b10f13f29ebfc2150c3a79062a8195d/pandas-2.3.3-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a21d830e78df0a515db2b3d2f5570610f5e6bd2e27749770e8bb7b524b89b450", size = 11634535, upload-time = "2025-09-29T23:30:21.003Z" }, + { url = "https://files.pythonhosted.org/packages/a4/1e/1bac1a839d12e6a82ec6cb40cda2edde64a2013a66963293696bbf31fbbb/pandas-2.3.3-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2e3ebdb170b5ef78f19bfb71b0dc5dc58775032361fa188e814959b74d726dd5", size = 12121582, upload-time = "2025-09-29T23:30:43.391Z" }, + { url = "https://files.pythonhosted.org/packages/44/91/483de934193e12a3b1d6ae7c8645d083ff88dec75f46e827562f1e4b4da6/pandas-2.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d051c0e065b94b7a3cea50eb1ec32e912cd96dba41647eb24104b6c6c14c5788", size = 12699963, upload-time = "2025-09-29T23:31:10.009Z" }, + { url = "https://files.pythonhosted.org/packages/70/44/5191d2e4026f86a2a109053e194d3ba7a31a2d10a9c2348368c63ed4e85a/pandas-2.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3869faf4bd07b3b66a9f462417d0ca3a9df29a9f6abd5d0d0dbab15dac7abe87", size = 13202175, upload-time = "2025-09-29T23:31:59.173Z" }, +] + +[[package]] +name = "pandas" +version = "3.0.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", +] +dependencies = [ + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "python-dateutil", marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "tzdata", marker = "(python_full_version >= '3.11' and sys_platform == 'emscripten') or (python_full_version >= '3.11' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f8/87/4341c6252d1c47b08768c3d25ac487362bf403f0313ddae4a2a26c9b1b4c/pandas-3.0.3.tar.gz", hash = "sha256:696a4a00a2a2a35d4e5deb3fc946641b96c944f02230e4f76137fe35d806c4fc", size = 4651414, upload-time = "2026-05-11T18:54:29.21Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/42/16/b5c76b838fd9bf6ce84d3a53346b8874ec05c5f0040d75ef2c320100cd2a/pandas-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:455f6f8139d4282188f526868dbc3c828470e88a3d9d59a891bd46a455f21b98", size = 10338495, upload-time = "2026-05-11T18:52:11.558Z" }, + { url = "https://files.pythonhosted.org/packages/5a/b0/a4ffc4ae74d2d822200dcc46898987d8eb6032d1e2b219cae39da6f5cbcc/pandas-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4e15135e2ee5df1063313e2425ceef8ac0f4ae775893815b0923651b806a5639", size = 9938250, upload-time = "2026-05-11T18:52:17.005Z" }, + { url = "https://files.pythonhosted.org/packages/2e/b2/3323601a52caee42c019e370090ca4544b241437240ca04f786cce82b0cf/pandas-3.0.3-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:05f1f1752b8533ea03f7f39a9c15b1a058d067bb48f4748948e7a8691e0510f2", size = 10770558, upload-time = "2026-05-11T18:52:19.865Z" }, + { url = "https://files.pythonhosted.org/packages/32/f1/bbecd2f867b97abebe0f9b53d750f862251b40337e061b36676ded3d920f/pandas-3.0.3-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8a1e45c80cceb3b4a21bc5939d52e8cbd8d9b7305309219d59e9754d9ce09e27", size = 11274611, upload-time = "2026-05-11T18:52:22.622Z" }, + { url = "https://files.pythonhosted.org/packages/7f/4f/eafabf2d5fae5adf143b4d18d3706c5efdc368a7c4eb1ee8a3eddabbd0f6/pandas-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:14da8316da4d0c5a77618425996bfb1248ca87fc2c1486e6fde4652bd18b5824", size = 11784670, upload-time = "2026-05-11T18:52:25.4Z" }, + { url = "https://files.pythonhosted.org/packages/49/44/1eb20389301b57b19cc099a1c2f662501f72f08a65f912d05822613c1532/pandas-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a55066a0505dae0ba2b50a46637db34b46f9094c65c5d4800794ef6335010938", size = 12353708, upload-time = "2026-05-11T18:52:28.139Z" }, + { url = "https://files.pythonhosted.org/packages/eb/62/c321f13b5ba1819fc8dca456c7fce578da2dcfecff1abbf0eaddf8406c0f/pandas-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:6674ab18ad8c57802867264b00e15e7bb904700cdd9046e3b2fa1fce237439ea", size = 9907609, upload-time = "2026-05-11T18:52:30.982Z" }, + { url = "https://files.pythonhosted.org/packages/53/85/1b7f563ebc6357c27233a02a96b589bcce1fa9c6eb89fb4f0e56421d277e/pandas-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:5cc09a68b3120e0f54870dede8287a7bb1fa463907e4fcec1ea77cab6179bf7a", size = 9165596, upload-time = "2026-05-11T18:52:33.334Z" }, + { url = "https://files.pythonhosted.org/packages/24/f1/392f8c5bfc16f66a0d2d41561c01627c228fe7ed2a0d056ef11315042570/pandas-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fed2ff7fd9779120e388e285fc029bd5cf9490cdd2e4166a9ee22c0e49a9ab09", size = 10357846, upload-time = "2026-05-11T18:52:36.143Z" }, + { url = "https://files.pythonhosted.org/packages/cf/3d/b16412745651e855f357e5e66930248688378853a6e2698a214e331fba1f/pandas-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b168fc218fd80a6cbdbdbc1a97ddc7889ed057d7eb45f50d866ceab5f39904c4", size = 9899550, upload-time = "2026-05-11T18:52:38.976Z" }, + { url = "https://files.pythonhosted.org/packages/31/a8/fa2535168fffcedf67f4f6de28d2dd903a747ca7c8ea6989451aaeb3a92f/pandas-3.0.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0383c72c75cdcca61a9e116e611143902dbfd08bff356829c2f6d1cf40a9ca8c", size = 10412965, upload-time = "2026-05-11T18:52:41.915Z" }, + { url = "https://files.pythonhosted.org/packages/65/b6/09b01cdbc15224e2850365192d17b7bdebb8bdbd8780ed221fcdf0d9a515/pandas-3.0.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6dc0b3fd2169c9157deed50b4d519553a3655c8c6a96027136d654592be973a9", size = 10894600, upload-time = "2026-05-11T18:52:45.02Z" }, + { url = "https://files.pythonhosted.org/packages/c9/a4/2eb28f2fccb4ced4a2c79ab2a5dee9ade1ebf44922ebad6fea158c9f95d4/pandas-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7e65d5407dc0b394f509699650e4a2ec01c0514f21850f453fa60f3be79a5dbf", size = 11422824, upload-time = "2026-05-11T18:52:48.058Z" }, + { url = "https://files.pythonhosted.org/packages/f8/45/830bb57f533a4604b355e07edcb8ea18cf88b5f94e5fca92f27052d7c597/pandas-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f8894dc474d648fe7b6ff0ca9b0bd73950d19952bc1a6534540762c5d79d305c", size = 11950889, upload-time = "2026-05-11T18:52:50.905Z" }, + { url = "https://files.pythonhosted.org/packages/b9/c5/fc1b368f303087d20e8c9bf3d6ceb186263cfac0ade735cd938538bea839/pandas-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:c7be265b62cef88e253a941e4698604973736dcfe242fdb5198f0f7bc473cdcc", size = 9755463, upload-time = "2026-05-11T18:52:53.386Z" }, + { url = "https://files.pythonhosted.org/packages/86/bd/fda8f9705b1b09c6ebe14bfc0fa0e4ec8584d54ea673628f157ff55131af/pandas-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:557409bc4178e70ee8d9ddb494798e51ebf6ea59330f6be22c51bab2a7db6c49", size = 9066158, upload-time = "2026-05-11T18:52:56.038Z" }, + { url = "https://files.pythonhosted.org/packages/c5/90/62d8302883c44308c477e222c3daf7c813a34c8e96985882fbd53d964352/pandas-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:67b3b64c11910cfa29f4e94a14d3bff9ee693b6fc76055e7cad549cee0aec5fa", size = 10331071, upload-time = "2026-05-11T18:52:58.838Z" }, + { url = "https://files.pythonhosted.org/packages/7f/ae/6a6493c783a101f165e4356953ba3c74d6f77f0042fa7d753da9dfbb640c/pandas-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:39436b377d56d2a2e52d0395bdbee171f01068e99af5250509aceeb929f765c7", size = 9875690, upload-time = "2026-05-11T18:53:01.431Z" }, + { url = "https://files.pythonhosted.org/packages/62/7c/5df8e9f56c69a2769fbe9382a5ef8f2658c007e376434e1e2cbb57ad895f/pandas-3.0.3-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d4be06d68f9ddcfc645b87534911da79a8fbffc7573c80e0edcf42a5020624d8", size = 10381634, upload-time = "2026-05-11T18:53:04.393Z" }, + { url = "https://files.pythonhosted.org/packages/99/68/1237369725aa617bb358263d535803e3053fdbc593513ec5ed9c9896b5b6/pandas-3.0.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a4eeb6830daf35a71cc09649bd823e2b542dac246cdee9614c6e4bd65028cd6a", size = 10891243, upload-time = "2026-05-11T18:53:07.643Z" }, + { url = "https://files.pythonhosted.org/packages/25/93/77d108e8af7222b4a503ebde0e30215b1c2e4f8e53a526431890f22d5586/pandas-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1928e07221f82db493cd4af1e23c1bfca524a19a4699887975bff68f49a72bfb", size = 11388659, upload-time = "2026-05-11T18:53:10.634Z" }, + { url = "https://files.pythonhosted.org/packages/d0/bd/eff5b4399f332ac386c853f6cd2bd3fa2ca0061b9f36ecd9c4d7c4265649/pandas-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51b1fe551acb77dac643c6fda86084d8d446c10fe64b06a9cc29c4cc8540e7f2", size = 11942880, upload-time = "2026-05-11T18:53:13.536Z" }, + { url = "https://files.pythonhosted.org/packages/2c/20/559ace4200982c3887d0b86bfd0d856a2143ef8ddab63cc07934951a964c/pandas-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:a82d532a3351d435432cd913edbccaf8b8e01d4dd0e5ced5a8d2e8ecd94c7e44", size = 9757091, upload-time = "2026-05-11T18:53:16.306Z" }, + { url = "https://files.pythonhosted.org/packages/3a/66/69055a09fe200f29f922a3eeec4804611900b95f52d932ece3393c3c0c19/pandas-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:275c14e0fce14a2ec20eee474aecd305478ea3c1e6f6a9d8fe219a165542717e", size = 9057282, upload-time = "2026-05-11T18:53:18.768Z" }, + { url = "https://files.pythonhosted.org/packages/57/0e/efe801b0e6811e8e650cd21b7f2608e30f08a7067e2bf6e8752b0d56ee3c/pandas-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:46997386d528eb40376ecd6b033cf4a8a1e5282580f68f43de875b78cba2199d", size = 10767016, upload-time = "2026-05-11T18:53:21.227Z" }, + { url = "https://files.pythonhosted.org/packages/ea/dc/eb55135a1d5f0f0519f28da1f609a206d2cad1f9c35c32d51e38dd7261ae/pandas-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:261e308dfb22448384b7580cf719d2f998fe2966c92893c3e77d14008af1f066", size = 10420210, upload-time = "2026-05-11T18:53:23.982Z" }, + { url = "https://files.pythonhosted.org/packages/c6/3e/b1d5d955ce33ffecb407465a60bc32769d74fcf68224b7ae67ae11d4dea4/pandas-3.0.3-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dd1a5d1def6a46002e964510bdc67c368aa0951df5d1d9f8365336f5a1f490cd", size = 10336126, upload-time = "2026-05-11T18:53:26.731Z" }, + { url = "https://files.pythonhosted.org/packages/f5/76/a01261711ab60a22d71b862f0de20e4c504bf80457270ad8cb42110f6abc/pandas-3.0.3-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d72828c20c6d6e83e1e22a6a3b47b326b71664112fa9705dcbccfd7a39b62085", size = 10728051, upload-time = "2026-05-11T18:53:29.125Z" }, + { url = "https://files.pythonhosted.org/packages/e9/21/ea191195e587b18cf682e97f433f81b2d0fbe341380e80a3e0d6e4403c8e/pandas-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:d26cbe1fcfc12e8fd900e2454163e466b2d3af84f7c75481df7683ffc073d870", size = 11350796, upload-time = "2026-05-11T18:53:32.056Z" }, + { url = "https://files.pythonhosted.org/packages/64/69/f0eaaf54939f0e8c6768fd06be9af2cef9b36048b96dfb9e1b2c685a807e/pandas-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:3e91cec1879ada0624fc3dc9953c5cbd60208e59c0db28f540c5d6d47502422f", size = 11799741, upload-time = "2026-05-11T18:53:34.985Z" }, + { url = "https://files.pythonhosted.org/packages/45/a4/865e0e510cae5fc2194de4db28be638952de942571ba9125934fd9c01d47/pandas-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:08d789b41f87e0905880e293cedf6197ce71fe67cc081358b1e148a491b9bd13", size = 10499958, upload-time = "2026-05-11T18:53:37.857Z" }, + { url = "https://files.pythonhosted.org/packages/86/54/effdcc3c0ff7a08037889200e148ebe94c16c4f653be078c7b3675955df1/pandas-3.0.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:3650109c0f22879df8bd6179ab9ee3d7f1d1d4e7e0094a3f0032d9f51e2e64ac", size = 10336065, upload-time = "2026-05-11T18:53:41.099Z" }, + { url = "https://files.pythonhosted.org/packages/68/10/bf2d6738d72748b961a3751ab89522d58c54efc36a8e1a12161216cd45cf/pandas-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:bab900348131a7db1f69a7309ef141fd5680f1487094193bcbbb61791573bf8f", size = 9926101, upload-time = "2026-05-11T18:53:43.515Z" }, + { url = "https://files.pythonhosted.org/packages/ae/e9/e35cf11c8a136e757b956f5f0efdcaa50aecde85ea055f1898dfc68262f3/pandas-3.0.3-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ba7e08b9ac1d54569cd1e256e3668975ed624d6826f7b68df0342b012007bddb", size = 10457553, upload-time = "2026-05-11T18:53:46.394Z" }, + { url = "https://files.pythonhosted.org/packages/58/3b/1cdec6772bdbaf7b25dab360c59f03cadf05492dd724c6540af905389b07/pandas-3.0.3-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d71c63ae4ebdbf70209742096f1fc46a83a0613c99d4b23766cced9ff8cd62a", size = 10914065, upload-time = "2026-05-11T18:53:49.134Z" }, + { url = "https://files.pythonhosted.org/packages/c4/c2/1ef644445fcd72e3627bceec77e3560636f87ddce4ed841afe76b83b5bf9/pandas-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e3a2ec42c98ffa2565a67e08e218d06d72576d758d90facb7c00805194d8f360", size = 11459188, upload-time = "2026-05-11T18:53:52.527Z" }, + { url = "https://files.pythonhosted.org/packages/7e/49/4d8d4f42cbc9c4adc7a1870f269c02cbd6cd40d059622c06fb298addcbad/pandas-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:335f62418ed562cfc3c49e9e196375c28b729dcef8543abf4f9438e381bf3c76", size = 11982966, upload-time = "2026-05-11T18:53:55.043Z" }, + { url = "https://files.pythonhosted.org/packages/38/55/792619469bab9882d8bbd5865d45a72f6478762d04a9af4bf0d08c503e95/pandas-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:3c20a521bbb85902f79f7270c80a59e1b5452d96d170c034f207181870f97ac5", size = 9876755, upload-time = "2026-05-11T18:53:58.067Z" }, + { url = "https://files.pythonhosted.org/packages/2a/af/33c469653b0ba03b50c3a98192d4c07f0c75c66b263ceb097fce0ee97d31/pandas-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:a2d2dff8a04f3917b55ab3910c32990f8ddf7eceba114947838cefa976a68977", size = 9198658, upload-time = "2026-05-11T18:54:00.733Z" }, + { url = "https://files.pythonhosted.org/packages/a2/fa/b8c257bd76b8bd060c3a9151c1fca05e9b9c5e3af5d0f549c0356f6d143d/pandas-3.0.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:0d589105b3c14645af1738ff279b2995102d8f7a03b0a66dc8d95550eb513e04", size = 10787242, upload-time = "2026-05-11T18:54:03.564Z" }, + { url = "https://files.pythonhosted.org/packages/54/eb/f19206ffb0bf1919002969aa448b4702c6594845156a6f8050674855aac3/pandas-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:13fc1e853d9e04743d11ba75a985ccbc2a317fe07d8af61e445a6fd24dacd6a6", size = 10436369, upload-time = "2026-05-11T18:54:06.311Z" }, + { url = "https://files.pythonhosted.org/packages/fd/24/c7c39fb4fe22b71a0c2d78bf0c585c600092d85f94f086d2b3b2f6ca27e2/pandas-3.0.3-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:819959dab7bbd0049c15623fbac4e29a191b9528160a61fb1032242d8ced2d9c", size = 10358306, upload-time = "2026-05-11T18:54:09.085Z" }, + { url = "https://files.pythonhosted.org/packages/16/ec/dd2a9eb7fa1204df88c0864164e35b228ac581062ac612ba0a67fd812e4c/pandas-3.0.3-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:60ae316d3fd75d1858d450d0db0103ea2be3e7d4a95ec2f064f7e2ae63f7b028", size = 10758394, upload-time = "2026-05-11T18:54:11.956Z" }, + { url = "https://files.pythonhosted.org/packages/95/6e/00c61ea8e85b4f6d8d35e11852a1a4998fc7fafc91c6a602d1cc9c972d64/pandas-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bd3a518890b400d32f9023722dc9a9a5c969f00b415419a3c06c043f09bb5d7d", size = 11375717, upload-time = "2026-05-11T18:54:14.539Z" }, + { url = "https://files.pythonhosted.org/packages/31/89/8fc1c268969fac43688d65fd92e67df24bd128d53cb4d2eee534cd307399/pandas-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:9c39be2d709d01fa972a0cabc522389fceca4f3969332ba25a7d6c5802cf976a", size = 11828897, upload-time = "2026-05-11T18:54:17.146Z" }, + { url = "https://files.pythonhosted.org/packages/56/3b/e7d20dea247a3e6dc0bd8a6953854afbedc03951def4e7371e05e7263e25/pandas-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4db8c527972a821cf5286b40ccc57642a39bc62e62022b42f99f8a67fca8c3a1", size = 10900855, upload-time = "2026-05-11T18:54:19.72Z" }, + { url = "https://files.pythonhosted.org/packages/0f/54/68a0978d1ef8502b8492099beaa6e7a0c1b32e3b5d4f677f5810cb08711c/pandas-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b2c95f8bfc1ee412bf482605d7bfd30c12d1d26bd59fdd91efeef1d4718decb1", size = 9466464, upload-time = "2026-05-11T18:54:22.754Z" }, +] + [[package]] name = "pandocfilters" version = "1.5.1" @@ -2633,7 +2973,7 @@ name = "pexpect" version = "4.9.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "ptyprocess" }, + { name = "ptyprocess", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (python_full_version < '3.11' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'win32') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" } wheels = [ @@ -3008,6 +3348,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c8/8d/3d316429f65029532bb1e28ff77b797d86b5ac3915bb44ca4e19aa283d43/python_discovery-1.4.0-py3-none-any.whl", hash = "sha256:26ed78d703e234879a66244c7d4114563fb13ec5cd30a2d1357e5fb4850782da", size = 33217, upload-time = "2026-05-28T01:15:36.573Z" }, ] +[[package]] +name = "pytz" +version = "2026.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ff/46/dd499ec9038423421951e4fad73051febaa13d2df82b4064f87af8b8c0c3/pytz-2026.2.tar.gz", hash = "sha256:0e60b47b29f21574376f218fe21abc009894a2321ea16c6754f3cad6eb7cdd6a", size = 320861, upload-time = "2026-05-04T01:35:29.667Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/dd/96da98f892250475bdf2328112d7468abdd4acc7b902b6af23f4ed958ea0/pytz-2026.2-py2.py3-none-any.whl", hash = "sha256:04156e608bee23d3792fd45c94ae47fae1036688e75032eea2e3bf0323d1f126", size = 510141, upload-time = "2026-05-04T01:35:27.408Z" }, +] + [[package]] name = "pywin32-ctypes" version = "0.2.3" @@ -3366,16 +3715,45 @@ name = "rpds-py" version = "2026.5.1" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", "python_full_version == '3.11.*' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", ] sdist = { url = "https://files.pythonhosted.org/packages/2e/43/25a8dcd3feedd735039a8f0b5b7e3b118232b5eae288c4fd9ab200d41094/rpds_py-2026.5.1.tar.gz", hash = "sha256:07b24fea40541e28570e5b795a4a38fbdcd12550c06bd0748005ecc8116ca256", size = 64459, upload-time = "2026-05-28T12:02:13.232Z" } wheels = [ @@ -3506,13 +3884,29 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/15/19/016553f86f207450aebebc2b2b5088d086b901cc8186c02ac4284db3bd88/ruff-0.15.16-py3-none-win_arm64.whl", hash = "sha256:8cd61783afb39638a7133ef0d2dfb1e91277593962f81b5a8423eb0b888a6121", size = 11134555, upload-time = "2026-06-04T16:33:00.136Z" }, ] +[[package]] +name = "seaborn" +version = "0.13.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "matplotlib" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "pandas", version = "2.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "pandas", version = "3.0.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/86/59/a451d7420a77ab0b98f7affa3a1d78a313d2f7281a57afb1a34bae8ab412/seaborn-0.13.2.tar.gz", hash = "sha256:93e60a40988f4d65e9f4885df477e2fdaff6b73a9ded434c1ab356dd57eefff7", size = 1457696, upload-time = "2024-01-25T13:21:52.551Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/83/11/00d3c3dfc25ad54e731d91449895a79e4bf2384dc3ac01809010ba88f6d5/seaborn-0.13.2-py3-none-any.whl", hash = "sha256:636f8336facf092165e27924f223d3c62ca560b1f2bb5dff7ab7fad265361987", size = 294914, upload-time = "2024-01-25T13:21:49.598Z" }, +] + [[package]] name = "secretstorage" version = "3.5.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cryptography", marker = "sys_platform != 'darwin' or extra != 'extra-13-torchpfaffian-cpu' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, - { name = "jeepney", marker = "sys_platform != 'darwin' or extra != 'extra-13-torchpfaffian-cpu' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "cryptography", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (python_full_version < '3.11' and sys_platform == 'win32') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32') or (sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'darwin' and extra != 'extra-13-torchpfaffian-cpu') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "jeepney", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (python_full_version < '3.11' and sys_platform == 'win32') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32') or (sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'darwin' and extra != 'extra-13-torchpfaffian-cpu') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/1c/03/e834bcd866f2f8a49a85eaff47340affa3bfa391ee9912a952a1faa68c7b/secretstorage-3.5.0.tar.gz", hash = "sha256:f04b8e4689cbce351744d5537bf6b1329c6fc68f91fa666f60a380edddcd11be", size = 19884, upload-time = "2025-11-23T19:02:53.191Z" } wheels = [ @@ -3862,7 +4256,8 @@ name = "torch" version = "2.10.0" source = { registry = "https://download.pytorch.org/whl/cpu" } resolution-markers = [ - "python_full_version >= '3.12' and sys_platform == 'darwin'", + "python_full_version >= '3.14' and sys_platform == 'darwin'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'darwin'", "python_full_version == '3.11.*' and sys_platform == 'darwin'", "python_full_version < '3.11' and sys_platform == 'darwin'", ] @@ -3899,8 +4294,15 @@ name = "torch" version = "2.10.0" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "python_full_version >= '3.12'", - "python_full_version == '3.11.*'", + "python_full_version >= '3.14' and sys_platform == 'win32'", + "python_full_version >= '3.14' and sys_platform == 'emscripten'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and sys_platform == 'win32'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", "python_full_version < '3.11'", ] dependencies = [ @@ -3960,8 +4362,15 @@ name = "torch" version = "2.10.0+cpu" source = { registry = "https://download.pytorch.org/whl/cpu" } resolution-markers = [ - "python_full_version >= '3.12' and sys_platform != 'darwin'", - "python_full_version == '3.11.*' and sys_platform != 'darwin'", + "python_full_version >= '3.14' and sys_platform == 'win32'", + "python_full_version >= '3.14' and sys_platform == 'emscripten'", + "python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and sys_platform == 'win32'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten'", + "python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32'", "python_full_version < '3.11' and sys_platform != 'darwin'", ] dependencies = [ @@ -4020,8 +4429,15 @@ name = "torch" version = "2.10.0+cu128" source = { registry = "https://download.pytorch.org/whl/cu128" } resolution-markers = [ - "python_full_version >= '3.12'", - "python_full_version == '3.11.*'", + "python_full_version >= '3.14' and sys_platform == 'win32'", + "python_full_version >= '3.14' and sys_platform == 'emscripten'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and sys_platform == 'win32'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", "python_full_version < '3.11'", ] dependencies = [ @@ -4080,8 +4496,15 @@ name = "torch" version = "2.10.0+cu130" source = { registry = "https://download.pytorch.org/whl/cu130" } resolution-markers = [ - "python_full_version >= '3.12'", - "python_full_version == '3.11.*'", + "python_full_version >= '3.14' and sys_platform == 'win32'", + "python_full_version >= '3.14' and sys_platform == 'emscripten'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and sys_platform == 'win32'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", "python_full_version < '3.11'", ] dependencies = [ @@ -4142,7 +4565,6 @@ source = { editable = "." } dependencies = [ { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, - { name = "setuptools" }, { name = "torch", version = "2.10.0", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "(sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, { name = "torch", version = "2.10.0", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130')" }, { name = "torch", version = "2.10.0+cpu", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "(sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, @@ -4165,6 +4587,7 @@ cu130 = [ [package.dev-dependencies] dev = [ { name = "build" }, + { name = "maturin" }, { name = "mypy" }, { name = "nbmake" }, { name = "pip" }, @@ -4175,6 +4598,8 @@ dev = [ { name = "pytest-timeout" }, { name = "pytest-xdist" }, { name = "ruff" }, + { name = "seaborn" }, + { name = "tqdm" }, { name = "twine" }, { name = "wheel" }, ] @@ -4199,7 +4624,6 @@ docs = [ [package.metadata] requires-dist = [ { name = "numpy", specifier = ">=1.23,<3.0.0" }, - { name = "setuptools", specifier = ">=80.10" }, { name = "torch", specifier = ">=2.1,<3.0.0" }, { name = "torch", marker = "extra == 'cpu'", specifier = ">=2.1.2,<3.0.0", index = "https://download.pytorch.org/whl/cpu", conflict = { package = "torchpfaffian", extra = "cpu" } }, { name = "torch", marker = "extra == 'cu128'", specifier = ">=2.1.2,<3.0.0", index = "https://download.pytorch.org/whl/cu128", conflict = { package = "torchpfaffian", extra = "cu128" } }, @@ -4210,6 +4634,7 @@ provides-extras = ["cpu", "cu128", "cu130"] [package.metadata.requires-dev] dev = [ { name = "build", specifier = ">=1.4,<2" }, + { name = "maturin", specifier = ">=1.0,<2" }, { name = "mypy", specifier = ">=1.15,<2" }, { name = "nbmake", specifier = ">=1.5,<2" }, { name = "pip", specifier = ">=25" }, @@ -4220,6 +4645,8 @@ dev = [ { name = "pytest-timeout", specifier = ">=2.4" }, { name = "pytest-xdist", specifier = ">=3.7,<4" }, { name = "ruff", specifier = ">=0.9,<1" }, + { name = "seaborn", specifier = ">=0.13.2" }, + { name = "tqdm", specifier = ">=4.68.2" }, { name = "twine", specifier = ">=6.1,<7" }, { name = "wheel", specifier = ">=0.45,<0.46" }, ] @@ -4258,6 +4685,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/71/2e/7b1c769803121b809112cf9a00681c472eae1d80e32d7ec0e0bd61d0d0e1/tornado-6.5.7-cp39-abi3-win_arm64.whl", hash = "sha256:ff934fce95643af5f11efdae618eaa73d469dc588641e5c8d19295a0c65c4796", size = 450506, upload-time = "2026-06-08T17:34:49.702Z" }, ] +[[package]] +name = "tqdm" +version = "4.68.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/85/05/0d5260f1f1ca784f4a4a0def9cbe6affe587f5b4025328d446c3d67765f4/tqdm-4.68.2.tar.gz", hash = "sha256:89c230e8dbc67c7615c142487111222f878c77427ea09549960f62389e258add", size = 171923, upload-time = "2026-06-09T13:26:42.539Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/75/1a0392bcc21c44dcdf87b3cf2d137e7829be2c083a1e38d44efca3d57a16/tqdm-4.68.2-py3-none-any.whl", hash = "sha256:d4240441fb5353290b87d6a85968c9decc131a99b8c7faa28269d829de669ede", size = 78578, upload-time = "2026-06-09T13:26:40.731Z" }, +] + [[package]] name = "traitlets" version = "5.15.1" @@ -4317,6 +4756,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" }, ] +[[package]] +name = "tzdata" +version = "2026.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ba/19/1b9b0e29f30c6d35cb345486df41110984ea67ae69dddbc0e8a100999493/tzdata-2026.2.tar.gz", hash = "sha256:9173fde7d80d9018e02a662e168e5a2d04f87c41ea174b139fbef642eda62d10", size = 198254, upload-time = "2026-04-24T15:22:08.651Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ce/e4/dccd7f47c4b64213ac01ef921a1337ee6e30e8c6466046018326977efd95/tzdata-2026.2-py2.py3-none-any.whl", hash = "sha256:bbe9af844f658da81a5f95019480da3a89415801f6cc966806612cc7169bffe7", size = 349321, upload-time = "2026-04-24T15:22:05.876Z" }, +] + [[package]] name = "urllib3" version = "2.7.0"