diff --git a/.github/workflows/extremes.yml b/.github/workflows/extremes.yml index eda9d5d55a..6dc1d7c163 100644 --- a/.github/workflows/extremes.yml +++ b/.github/workflows/extremes.yml @@ -6,6 +6,7 @@ on: env: PY_COLORS: 1 PYTEST_ADDOPTS: "--numprocesses=logical" + COVERAGE_PROCESS_START: pyproject.toml UV_LOCKED: 1 UV_NO_DEV: 1 @@ -30,7 +31,7 @@ jobs: cache-suffix: min-versions-${{ matrix.python-version }} cache-dependency-glob: "pyproject.toml" - name: Run pytest - run: make run-ci DEPS="--group extreme-minimum-versions --group plugins" CMD="pytest tests --cov=src --cov=tests --cov-fail-under=50 --runslow --constructors=pandas,pyarrow,polars[eager],polars[lazy],duckdb" + run: make run-ci-coverage DEPS="--group extreme-minimum-versions --group plugins" FAIL_UNDER="50" CMD="pytest tests --runslow --nw-backends=pandas,pyarrow,polars[eager],polars[lazy],duckdb" pretty_old_versions: strategy: @@ -48,7 +49,7 @@ jobs: cache-suffix: pretty-old-versions-${{ matrix.python-version }} cache-dependency-glob: "pyproject.toml" - name: Run pytest - run: make run-ci DEPS="--group extreme-pretty-old-versions --group plugins" CMD="pytest tests --cov=src --cov=tests --cov-fail-under=50 --runslow --constructors=pandas,pyarrow,polars[eager],polars[lazy],duckdb" + run: make run-ci-coverage DEPS="--group extreme-pretty-old-versions --group plugins" FAIL_UNDER="50" CMD="pytest tests --runslow --nw-backends=pandas,pyarrow,polars[eager],polars[lazy],duckdb" not_so_old_versions: strategy: @@ -66,7 +67,7 @@ jobs: cache-suffix: not-so-old-versions-${{ matrix.python-version }} cache-dependency-glob: "pyproject.toml" - name: Run pytest - run: make run-ci DEPS="--group extreme-not-so-old-versions --group plugins" CMD="pytest tests --cov=src --cov=tests --cov-fail-under=50 --runslow --constructors=pandas,pyarrow,polars[eager],polars[lazy],dask,duckdb" + run: make run-ci-coverage DEPS="--group extreme-not-so-old-versions --group plugins" FAIL_UNDER="50" CMD="pytest tests --runslow --nw-backends=pandas,pyarrow,polars[eager],polars[lazy],dask,duckdb" nightlies: strategy: @@ -126,5 +127,7 @@ jobs: echo "$DEPS" | grep 'dask.*@' - name: Run pytest run: | - uv run --no-sync pytest tests --cov=src --cov=tests --cov-fail-under=50 --runslow \ - --constructors="pandas,pandas[nullable],pandas[pyarrow],pyarrow,polars[eager],polars[lazy],dask,duckdb" + uv run --no-sync coverage run -m pytest tests --runslow \ + --nw-backends="pandas,pandas[nullable],pandas[pyarrow],pyarrow,polars[eager],polars[lazy],dask,duckdb" + uv run --no-sync coverage combine + uv run --no-sync coverage report --fail-under=50 diff --git a/.github/workflows/pytest-ibis.yml b/.github/workflows/pytest-ibis.yml index 58d29efa0f..3877ef2045 100644 --- a/.github/workflows/pytest-ibis.yml +++ b/.github/workflows/pytest-ibis.yml @@ -7,6 +7,7 @@ on: env: PY_COLORS: 1 PYTEST_ADDOPTS: "--numprocesses=logical" + COVERAGE_PROCESS_START: pyproject.toml UV_LOCKED: 1 UV_NO_DEV: 1 @@ -31,4 +32,4 @@ jobs: cache-suffix: ibis-${{ matrix.python-version }} cache-dependency-glob: "pyproject.toml" - name: Run pytest - run: make run-ci DEPS="--group core-tests --extra ibis --extra pandas" CMD="pytest tests --constructors=ibis" + run: make run-ci DEPS="--group core-tests --extra ibis --extra pandas" CMD="pytest tests --nw-backends=ibis" diff --git a/.github/workflows/pytest-modin.yml b/.github/workflows/pytest-modin.yml index 34452ec730..9a5839a45d 100644 --- a/.github/workflows/pytest-modin.yml +++ b/.github/workflows/pytest-modin.yml @@ -7,6 +7,7 @@ on: env: PY_COLORS: 1 PYTEST_ADDOPTS: "--numprocesses=logical" + COVERAGE_PROCESS_START: pyproject.toml UV_LOCKED: 1 UV_NO_DEV: 1 @@ -31,4 +32,4 @@ jobs: cache-suffix: modin-${{ matrix.python-version }} cache-dependency-glob: "pyproject.toml" - name: Run pytest - run: make run-ci DEPS="--group core-tests --extra modin" CMD="pytest tests --constructors=modin[pyarrow]" + run: make run-ci DEPS="--group core-tests --extra modin" CMD="pytest tests --nw-backends=modin[pyarrow]" diff --git a/.github/workflows/pytest-pyspark.yml b/.github/workflows/pytest-pyspark.yml index 9e4438c6c9..76f5b8f925 100644 --- a/.github/workflows/pytest-pyspark.yml +++ b/.github/workflows/pytest-pyspark.yml @@ -15,6 +15,7 @@ on: env: PY_COLORS: 1 PYTEST_ADDOPTS: "--numprocesses=logical" + COVERAGE_PROCESS_START: pyproject.toml UV_LOCKED: 1 UV_NO_DEV: 1 @@ -39,7 +40,7 @@ jobs: cache-suffix: pyspark-${{ matrix.python-version }} cache-dependency-glob: "pyproject.toml" - name: Run pytest - run: make run-ci DEPS="--group core-tests --extra pyspark --extra pandas" CMD="pytest tests --cov=src/narwhals/_spark_like --cov-fail-under=95 --runslow --constructors=pyspark" + run: make run-ci-coverage DEPS="--group core-tests --extra pyspark --extra pandas" COV_SOURCE="src/narwhals/_spark_like" FAIL_UNDER="95" CMD="pytest tests --runslow --nw-backends=pyspark" pytest-pyspark-min-version-constructor: if: github.head_ref != 'bump-version' @@ -58,7 +59,7 @@ jobs: cache-suffix: pyspark-min-${{ matrix.python-version }} cache-dependency-glob: "pyproject.toml" - name: Run pytest - run: make run-ci DEPS="--group min-pyspark-version --extra pandas" CMD="pytest tests --cov=src/narwhals/_spark_like --cov-fail-under=95 --runslow --constructors=pyspark" + run: make run-ci-coverage DEPS="--group min-pyspark-version --extra pandas" COV_SOURCE="src/narwhals/_spark_like" FAIL_UNDER="95" CMD="pytest tests --runslow --nw-backends=pyspark" pytest-pyspark-connect-constructor: if: github.head_ref != 'bump-version' @@ -126,7 +127,10 @@ jobs: echo "Spark Connect server started" - name: Run pytest - run: uv run --no-sync pytest tests --cov=src/narwhals/_spark_like --cov-fail-under=95 --runslow --constructors "pyspark[connect]" + run: | + uv run --no-sync coverage run --source=src/narwhals/_spark_like -m pytest tests --runslow --nw-backends "pyspark[connect]" + uv run --no-sync coverage combine + uv run --no-sync coverage report --include="src/narwhals/_spark_like/*" --fail-under=95 - name: Stop Spark Connect server if: always() && env.SPARK_HOME != '' diff --git a/.github/workflows/pytest.yml b/.github/workflows/pytest.yml index bcbdacaa01..b24ce5ab8c 100644 --- a/.github/workflows/pytest.yml +++ b/.github/workflows/pytest.yml @@ -7,6 +7,7 @@ on: env: PY_COLORS: 1 PYTEST_ADDOPTS: "--numprocesses=logical" + COVERAGE_PROCESS_START: pyproject.toml UV_LOCKED: 1 UV_NO_DEV: 1 @@ -32,7 +33,7 @@ jobs: cache-dependency-glob: "pyproject.toml" - name: Run pytest shell: bash - run: make run-ci DEPS="--group tests --group plugins --extra pandas --extra polars --extra pyarrow" CMD="pytest tests --cov=src --cov=tests --cov-fail-under=75 --constructors=pandas,pyarrow,polars[eager],polars[lazy]" + run: make run-ci-coverage DEPS="--group tests --group plugins --extra pandas --extra polars --extra pyarrow" FAIL_UNDER="75" CMD="pytest tests --nw-backends=pandas,pyarrow,polars[eager],polars[lazy]" pytest-windows: if: github.head_ref != 'bump-version' @@ -53,7 +54,7 @@ jobs: # we are not testing pyspark, modin, or dask on Windows here because nobody got time for that - name: Run pytest shell: bash - run: make run-ci DEPS="--group core-tests --group extra --group plugins --extra pandas" CMD="pytest tests --cov=src --cov=tests --runslow --cov-fail-under=95 --durations=30 --constructors=pandas,pandas[nullable],pandas[pyarrow],pyarrow,polars[eager],polars[lazy],duckdb,sqlframe" + run: make run-ci-coverage DEPS="--group core-tests --group extra --group plugins --extra pandas" FAIL_UNDER="95" CMD="pytest tests --runslow --durations=30 --nw-backends=pandas,pandas[nullable],pandas[pyarrow],pyarrow,polars[eager],polars[lazy],duckdb,sqlframe" pytest-full-coverage: if: github.head_ref != 'bump-version' @@ -77,7 +78,7 @@ jobs: cache-suffix: pytest-full-coverage-${{ matrix.python-version }} cache-dependency-glob: "pyproject.toml" - name: Run pytest - run: make run-ci DEPS="--extra pandas --extra dask --group core-tests --group extra --group plugins" CMD="pytest tests --cov=src --cov=tests --cov-fail-under=100 --runslow --durations=30 --constructors=pandas,pandas[nullable],pandas[pyarrow],pyarrow,polars[eager],polars[lazy],dask,duckdb,sqlframe" + run: make run-ci-coverage DEPS="--extra pandas --extra dask --group core-tests --group extra --group plugins" FAIL_UNDER="100" CMD="pytest tests --runslow --durations=30 --nw-backends=pandas,pandas[nullable],pandas[pyarrow],pyarrow,polars[eager],polars[lazy],dask,duckdb,sqlframe" - name: Run doctests # reprs differ between versions, so we only run doctests on the latest Python if: matrix.python-version == '3.13' @@ -103,11 +104,11 @@ jobs: cache-suffix: pytest-narrower-deps-${{ matrix.python-version }} cache-dependency-glob: "pyproject.toml" - name: Run pytest (pandas and pandas[nullable]) - run: make run-ci DEPS="-U --group tests --extra pandas" RUN_ONLY="--isolated" CMD="pytest tests --runslow --constructors=pandas,pandas[nullable]" + run: make run-ci DEPS="-U --group tests --extra pandas" RUN_ONLY="--isolated" CMD="pytest tests --runslow --nw-backends=pandas,pandas[nullable]" - name: Run pytest (pandas[pyarrow] and pyarrow) - run: make run-ci DEPS="-U --group tests --extra pandas --extra pyarrow" RUN_ONLY="--isolated" CMD="pytest tests --runslow --constructors=pandas[pyarrow],pyarrow" + run: make run-ci DEPS="-U --group tests --extra pandas --extra pyarrow" RUN_ONLY="--isolated" CMD="pytest tests --runslow --nw-backends=pandas[pyarrow],pyarrow" - name: Run pytest (polars) - run: make run-ci DEPS="-U --group tests --extra polars" RUN_ONLY="--isolated" CMD="pytest tests --runslow --constructors=polars[eager],polars[lazy]" + run: make run-ci DEPS="-U --group tests --extra polars" RUN_ONLY="--isolated" CMD="pytest tests --runslow --nw-backends=polars[eager],polars[lazy]" python-314: if: github.head_ref != 'bump-version' @@ -126,7 +127,7 @@ jobs: cache-suffix: python-314-${{ matrix.python-version }} cache-dependency-glob: "pyproject.toml" - name: Run pytest - run: make run-ci DEPS="--group core-tests --group plugins --extra pandas" CMD="pytest tests --cov=src --cov=tests --cov-fail-under=50 --runslow --durations=30 --constructors=pandas,pandas[nullable],pandas[pyarrow],pyarrow,polars[eager],polars[lazy],duckdb,sqlframe" + run: make run-ci-coverage DEPS="--group core-tests --group plugins --extra pandas" FAIL_UNDER="50" CMD="pytest tests --runslow --durations=30 --nw-backends=pandas,pandas[nullable],pandas[pyarrow],pyarrow,polars[eager],polars[lazy],duckdb,sqlframe" python-314t: if: github.head_ref != 'bump-version' @@ -148,4 +149,4 @@ jobs: cache-suffix: python-314t-${{ matrix.python-version }} cache-dependency-glob: "pyproject.toml" - name: Run pytest - run: make run-ci DEPS="--pre --group tests --group plugins --extra pandas --extra pyarrow" CMD="pytest tests --cov=src --cov=tests --cov-fail-under=50 --runslow --durations=30 --constructors=pandas,pandas[nullable],pandas[pyarrow],pyarrow" + run: make run-ci-coverage DEPS="--pre --group tests --group plugins --extra pandas --extra pyarrow" FAIL_UNDER="50" CMD="pytest tests --runslow --durations=30 --nw-backends=pandas,pandas[nullable],pandas[pyarrow],pyarrow" diff --git a/.github/workflows/random_ci_pytest.yml b/.github/workflows/random_ci_pytest.yml index fb99977593..c5b8e7a61a 100644 --- a/.github/workflows/random_ci_pytest.yml +++ b/.github/workflows/random_ci_pytest.yml @@ -8,6 +8,7 @@ env: PYTEST_ADDOPTS: "--numprocesses=logical" UV_LOCKED: 1 UV_NO_DEV: 1 + COVERAGE_PROCESS_START: pyproject.toml permissions: contents: read @@ -36,5 +37,7 @@ jobs: - name: Run pytest with random versions run: | uv run --group tests --group plugins --with-requirements random-requirements.txt \ - pytest tests --cov=src --cov=tests --cov-fail-under=75 \ - --constructors="pandas,pyarrow,polars[eager],polars[lazy]" + coverage run -m pytest tests \ + --nw-backends="pandas,pyarrow,polars[eager],polars[lazy]" + uv run --group tests --group plugins --with-requirements random-requirements.txt coverage combine + uv run --group tests --group plugins --with-requirements random-requirements.txt coverage report --fail-under=75 diff --git a/.github/workflows/test_sdist.yml b/.github/workflows/test_sdist.yml index d349369622..7c0e086f45 100644 --- a/.github/workflows/test_sdist.yml +++ b/.github/workflows/test_sdist.yml @@ -65,4 +65,4 @@ jobs: src=$(echo "${RUNNER_TEMP}/sdist"/narwhals-*) cd "${src}" "${RUNNER_TEMP}/venv/bin/python" -m pytest tests \ - --constructors="pandas,pyarrow,polars[eager],polars[lazy]" + --nw-backends="pandas,pyarrow,polars[eager],polars[lazy]" diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 8cc0ff3324..c59025a9e2 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -147,12 +147,12 @@ If you add code that should be tested, please add tests. - To run tests on the doctests, use `uv run pytest src --doctest-modules` - To run unit tests and doctests at the same time, run `uv run pytest src tests --cov=src --doctest-modules` - To run tests multiprocessed, you may also want to use [pytest-xdist](https://github.com/pytest-dev/pytest-xdist) (optional) -- To choose which backends to run tests with, you can use the `--constructors` flag: - - To only run tests for pandas, Polars, and PyArrow, use `uv run pytest --constructors="pandas,pyarrow,polars[eager]"` - - To run tests for all CPU constructors, use `uv run --extra modin --extra pyspark pytest --all-cpu-constructors` +- To choose which backends to run tests with, you can use the `--nw-backends` flag: + - To only run tests for pandas, Polars, and PyArrow, use `uv run pytest --nw-backends="pandas,pyarrow,polars[eager]"` + - To run tests for all CPU constructors, use `uv run --extra modin --extra pyspark pytest --all-nw-backends` - By default, tests run for pandas, pandas (PyArrow dtypes), PyArrow, and Polars. - To run tests using `cudf.pandas`, run `NARWHALS_DEFAULT_CONSTRUCTORS=pandas uv run --extra cudf --module cudf.pandas --module pytest` - - To run tests using `polars[gpu]`, run `NARWHALS_POLARS_GPU=1 uv run pytest --constructors="polars[lazy]"` + - To run tests using `polars[gpu]`, run `NARWHALS_POLARS_GPU=1 uv run pytest --nw-backends="polars[lazy]"` Tip: passing extras (`--extra `) or groups (`--group `) to `uv run` will transparently sync the environment to include those dependencies before running the command. diff --git a/Makefile b/Makefile index 3a20692e8a..47ee88fc60 100644 --- a/Makefile +++ b/Makefile @@ -3,6 +3,14 @@ .DEFAULT_GOAL := help +# coverage's execv/fork patches raise on Windows; collapse them to `subprocess` +# there (coverage dedupes) and keep the default values elsewhere. +# See `tool.coverage.run.patch` in pyproject.toml. +ifeq ($(OS),Windows_NT) +export COVERAGE_PATCH_EXECV ?= subprocess +export COVERAGE_PATCH_FORK ?= subprocess +endif + .PHONY: help help: ## Display this help screen @echo -e "\033[1mAvailable commands:\033[0m" @@ -31,6 +39,13 @@ docs-clean-serve: ## Rebuild docs from a clean state and serve them locally $(MAKE) docs-serve .PHONY: run-ci -run-ci: ## Print resolved deps, then run a command via uv. Usage: make run-ci DEPS="" CMD="" [RUN_ONLY=""] +run-ci: ## Print resolved deps, then run a command via uv (no coverage; used by doctests, narrow-dep runs, tpch, ibis, modin). Usage: make run-ci DEPS="" CMD="" [RUN_ONLY=""] uv export --no-annotate --no-hashes $(DEPS) uv run $(DEPS) $(RUN_ONLY) $(CMD) + +.PHONY: run-ci-coverage +run-ci-coverage: ## Like run-ci but under coverage (run -> combine -> report). Usage: make run-ci-coverage DEPS="" CMD="" [FAIL_UNDER=""] [COV_SOURCE=""] [RUN_ONLY=""] + uv export --no-annotate --no-hashes $(DEPS) + uv run $(DEPS) $(RUN_ONLY) coverage run $(if $(COV_SOURCE),--source=$(COV_SOURCE)) -m $(CMD) + uv run $(DEPS) $(RUN_ONLY) coverage combine + uv run $(DEPS) $(RUN_ONLY) coverage report $(if $(COV_SOURCE),--include=$(COV_SOURCE)/*) $(if $(FAIL_UNDER),--fail-under=$(FAIL_UNDER)) diff --git a/docs/api-reference/testing.md b/docs/api-reference/testing.md index db83c6930e..2cc088c941 100644 --- a/docs/api-reference/testing.md +++ b/docs/api-reference/testing.md @@ -1,8 +1,88 @@ # `narwhals.testing` +## Assertions + ::: narwhals.testing handler: python options: + show_root_heading: false + heading_level: 3 members: - assert_frame_equal - assert_series_equal + +## `pytest` plugin + +Narwhals register a pytest plugin that exposes parametrized fixtures with callables +to build Narwhals frames from a column-oriented python `dict`. + +### Available fixtures + +| Fixture | Backends | +|---|---| +| `nw_frame` | every selected backend (eager + lazy) | +| `nw_lazyframe` | only lazy backends | +| `nw_dataframe` | only eager backends | +| `nw_pandas_like_frame` | pandas-like backends | + +### Pytest options + +The backend selection is controlled by the following CLI options: + +* `--nw-backends=pandas,polars[lazy],duckdb`: comma-separated list. + Defaults to the following list: `pandas,pandas[pyarrow],polars[eager],pyarrow,duckdb,sqlframe,ibis` + intersected with the backends installed in the current environment. +* `--nw-all-backends`: shortcut for "every **CPU** backend that is installed". +* `--use-nw-external-constructor`: Skip narwhals.testing's parametrisation and let + another plugin provide the `constructor*` fixtures. + +Set the `NARWHALS_DEFAULT_BACKENDS` environment variable to override the default +list (useful e.g. when running under `cudf.pandas`). + +### Quick start + +The plugin auto-loads as soon as you `pip install narwhals`. Just write a test: + +```python +from typing import TYPE_CHECKING + +import narwhals as nw +import narwhals.stable.v2 as nw_v2 + +if TYPE_CHECKING: + from narwhals.testing.typing import Data, DataFrameConstructor, LazyFrameConstructor + + +def test_shape(nw_dataframe: DataFrameConstructor) -> None: + data: Data = {"x": [1, 2, 3]} + df = nw_dataframe(data, namespace=nw) + assert df.shape == (3, 1) + + +def test_laziness(nw_lazyframe: LazyFrameConstructor) -> None: + data: Data = {"x": [1, 2, 3]} + lf = nw_lazyframe(data, namespace=nw_v2) + assert isinstance(lf, nw_v2.LazyFrame) +``` + +The fixtures are parametrised against every supported backend that is installed +in the current environment. Filter the matrix on the command line: + +```bash +pytest --nw-backends="pandas,polars[lazy]" +pytest --all-nw-backends +``` + +## Type aliases + +::: narwhals.testing.typing + handler: python + options: + show_root_heading: false + heading_level: 3 + members: + - Data + - FrameConstructor + - DataFrameConstructor + - LazyFrameConstructor + - NarwhalsNamespace diff --git a/pyproject.toml b/pyproject.toml index 4be1690da4..e4bcff7eb1 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -35,6 +35,10 @@ Documentation = "https://narwhals-dev.github.io/narwhals/" Repository = "https://github.com/narwhals-dev/narwhals" "Bug Tracker" = "https://github.com/narwhals-dev/narwhals/issues" +[project.entry-points.pytest11] +narwhals_testing = "narwhals.testing.pytest_plugin" +# See: https://docs.pytest.org/en/stable/how-to/writing_plugins.html#making-your-plugin-installable-by-others + [project.optional-dependencies] # These should be aligned with MIN_VERSIONS in narwhals/utils.py # Exception: modin, because `modin.__version__` isn't aligned with @@ -72,7 +76,6 @@ plugins = [ tests = [ "covdefaults", "pytest>=9.0.3", - "pytest-cov", "pytest-env", "pytest-randomly", "pytest-xdist", @@ -419,7 +422,12 @@ env = [ ] [tool.coverage.run] +# execv and fork patches are unsupported on Windows (coverage raises), so Windows +# CI jobs set these env vars to "subprocess" — coverage dedupes the final list. +patch = ["${COVERAGE_PATCH_EXECV-execv}", "${COVERAGE_PATCH_FORK-fork}", "subprocess"] plugins = ["covdefaults"] +source = ["narwhals", "tests"] +parallel = true [tool.coverage.report] fail_under = 80 # This is just for local development, in CI we set it to 100 diff --git a/src/narwhals/testing/__init__.py b/src/narwhals/testing/__init__.py index 649463383f..6eb8c0b0d0 100644 --- a/src/narwhals/testing/__init__.py +++ b/src/narwhals/testing/__init__.py @@ -2,5 +2,6 @@ from narwhals.testing.asserts.frame import assert_frame_equal from narwhals.testing.asserts.series import assert_series_equal +from narwhals.testing.constructors import frame_constructor -__all__ = ("assert_frame_equal", "assert_series_equal") +__all__ = ("assert_frame_equal", "assert_series_equal", "frame_constructor") diff --git a/src/narwhals/testing/constructors.py b/src/narwhals/testing/constructors.py new file mode 100644 index 0000000000..74a8ca9c75 --- /dev/null +++ b/src/narwhals/testing/constructors.py @@ -0,0 +1,723 @@ +"""Constructor registry for `narwhals.testing`. + +Each constructor wraps one backend library (pandas, Polars, DuckDB, ...) and +knows how to turn a column-oriented `dict` into a native frame. + +Registration is explicit: wrap a plain builder function with `@frame_constructor.register(...)`. +The decorator instantiates a [`narwhals.testing.frame_constructor`][] with the +declared metadata and stores it in the shared `_registry`. + +## Adding a new constructor + +```py +from narwhals.testing import frame_constructor + + +@frame_constructor.register( + name="my_backend", + implementation=Implementation.MY_BACKEND, + requirements=("my_backend",), +) +def my_backend_lazy_constructor(obj: Data, /, **kwds: Any) -> IntoLazyFrame: + import my_backend + + return my_backend.from_dict(obj) +``` +""" + +from __future__ import annotations + +import os +import uuid +import warnings +from copy import deepcopy +from functools import lru_cache +from importlib.util import find_spec +from typing import TYPE_CHECKING, Any, ClassVar, Generic, Literal, TypeVar, cast, overload + +from narwhals._utils import Implementation, generate_temporary_column_name + +if TYPE_CHECKING: + from collections.abc import Callable, Iterable + from typing import Concatenate, TypeAlias + + import ibis + import pandas as pd + import polars as pl + import pyarrow as pa + from ibis.backends.duckdb import Backend as IbisDuckDBBackend + from pyspark.sql import SparkSession + from sqlframe.duckdb import DuckDBSession + + from narwhals import DataFrame, LazyFrame + from narwhals._native import NativeDask, NativeDuckDB, NativePySpark, NativeSQLFrame + from narwhals.testing.typing import Data, NarwhalsNamespace + from narwhals.typing import ( + IntoDataFrame, + IntoDataFrameT, + IntoFrame, + IntoLazyFrame, + IntoLazyFrameT, + ) + + +__all__ = ( + "available_backends", + "available_cpu_backends", + "available_default_cpu_backends", + "frame_constructor", + "get_backend_constructor", + "is_backend_available", + "prepare_backends", + "pyspark_session", + "sqlframe_session", +) + +T_co = TypeVar("T_co", covariant=True, bound="IntoFrame") +R = TypeVar("R", bound="IntoFrame") + + +class frame_constructor(Generic[T_co]): # noqa: N801 + """Callable wrapper around a backend frame builder. + + Turns a column-oriented `dict` (typed as [`Data`][narwhals.testing.typing.Data]) + into a native frame. Metadata (implementation, requirements, eager/lazy, + nullability, GPU need) lives on the instance, alongside the wrapped + `func`. Equality and hashing are keyed on `(type, name)`, so two lookups + of the same registered constructor compare equal. + + Warning: + Instances should be created via [`narwhals.testing.constructors.frame_constructor.register`][], + which is the only supported entry point. + + Direct instantiation is allowed but **does not** register the instance. + """ + + _registry: ClassVar[dict[str, frame_constructor[IntoFrame]]] = {} + + func: Callable[Concatenate[Data, ...], T_co] + + def __init__( + self, + func: Callable[Concatenate[Data, ...], T_co], + /, + *, + name: str, + implementation: Implementation, + requirements: tuple[str, ...] = (), + is_eager: bool = False, + nan_is_null: bool = False, + needs_gpu: bool = False, + default_include: bool = True, + ) -> None: + self.func = func + self.name = name + self.implementation = implementation + self.requirements = requirements + self.is_eager = is_eager + self.nan_is_null = nan_is_null + self.needs_gpu = needs_gpu + self.default_include = default_include + + @classmethod + def register( + cls, + *, + name: str, + implementation: Implementation, + requirements: tuple[str, ...] = (), + is_eager: bool = False, + nan_is_null: bool = False, + needs_gpu: bool = False, + default_include: bool = True, + ) -> Callable[[Callable[Concatenate[Data, ...], R]], frame_constructor[R]]: + """Decorator: register `func` as the constructor named `name`. + + Arguments: + name: The string identifier of the constructor (e.g. `"pandas[pyarrow]"`). + implementation: The [`Implementation`][] this constructor belongs to. + requirements: Package names that must be importable for this constructor + to be available (checked via `importlib.util.find_spec`). + is_eager: Whether the backend returns an eager dataframe. + nan_is_null: Whether floating-point NaN values are considered null. + needs_gpu: Whether the backend requires GPU hardware. + default_include: Whether this backend is included by default when running + `--all-nw-backends`. Set to `False` for backends that require + explicit opt-in (e.g. modin, pyspark[connect]). + + Returns: + A decorator that replaces `func` with a `frame_constructor` + instance registered into the shared `_registry`. + """ + + def decorator(func: Callable[Concatenate[Data, ...], R]) -> frame_constructor[R]: + inst: frame_constructor[R] = frame_constructor( + func, + name=name, + implementation=implementation, + requirements=requirements, + is_eager=is_eager, + nan_is_null=nan_is_null, + needs_gpu=needs_gpu, + default_include=default_include, + ) + cls._registry[name] = inst + return inst + + return decorator + + @overload + def __call__( + self: frame_constructor[IntoDataFrameT], + obj: Data, + /, + namespace: NarwhalsNamespace, + **kwds: Any, + ) -> DataFrame[IntoDataFrameT]: ... + @overload + def __call__( + self: frame_constructor[IntoLazyFrameT], + obj: Data, + /, + namespace: NarwhalsNamespace, + **kwds: Any, + ) -> LazyFrame[IntoLazyFrameT]: ... + @overload + def __call__( + self: frame_constructor[IntoFrame], + obj: Data, + /, + namespace: NarwhalsNamespace, + **kwds: Any, + ) -> DataFrame[Any] | LazyFrame[Any]: ... + + def __call__( + self, obj: Data, /, namespace: NarwhalsNamespace, **kwds: Any + ) -> DataFrame[Any] | LazyFrame[Any]: + """Build a native frame and wrap it with `namespace.from_native`. + + Arguments: + obj: Column-oriented mapping passed to the wrapped builder. + namespace: A narwhals namespace (e.g. `narwhals`, `narwhals.stable.v1`) + whose `from_native` performs the wrapping. + **kwds: Forwarded to the wrapped builder. + """ + native = self.func(obj, **kwds) + return namespace.from_native(native) # type: ignore[no-any-return] + + @property + def identifier(self) -> str: + """Instance-level string identifier for test IDs.""" + return self.name + + @property + def is_lazy(self) -> bool: + """Whether this constructor produces a lazy native frame.""" + return not self.is_eager + + @property + def is_pandas(self) -> bool: + """Whether this is one of the pandas constructors.""" + return self.implementation.is_pandas() + + @property + def is_modin(self) -> bool: + """Whether this is one of the modin constructors.""" + return self.implementation.is_modin() + + @property + def is_cudf(self) -> bool: + """Whether this is the cudf constructor.""" + return self.implementation.is_cudf() + + @property + def is_pandas_like(self) -> bool: + """Whether this constructor produces a pandas-like dataframe (pandas, modin, cudf).""" + return self.implementation.is_pandas_like() + + @property + def is_polars(self) -> bool: + """Whether this is one of the polars constructors.""" + return self.implementation.is_polars() + + @property + def is_pyarrow(self) -> bool: + """Whether this is the pyarrow table constructor.""" + return self.implementation.is_pyarrow() + + @property + def is_dask(self) -> bool: + """Whether this is the dask constructor.""" + return self.implementation.is_dask() + + @property + def is_duckdb(self) -> bool: + """Whether this is the duckdb constructor.""" + return self.implementation.is_duckdb() + + @property + def is_pyspark(self) -> bool: + """Whether this is one of the pyspark constructors.""" + impl = self.implementation + return impl.is_pyspark() or impl.is_pyspark_connect() + + @property + def is_sqlframe(self) -> bool: + """Whether this is the sqlframe constructor.""" + return self.implementation.is_sqlframe() + + @property + def is_ibis(self) -> bool: + """Whether this is the ibis constructor.""" + return self.implementation.is_ibis() + + @property + def is_spark_like(self) -> bool: + """Whether this constructor uses a spark-like backend (pyspark, sqlframe).""" + return self.implementation.is_spark_like() + + @property + def needs_pyarrow(self) -> bool: + """Whether this constructor requires `pyarrow` to be installed.""" + return "pyarrow" in self.requirements + + @property + def is_available(self) -> bool: + """Whether every package this constructor needs is importable.""" + return is_backend_available(*self.requirements) + + def __str__(self) -> str: + # NOTE: This is a temporary hack + # TODO(FBruzzesi): Remove once all the `"backend" in str(constructor)` + # statements in the test suite are properly replaced + return self.func.__name__ + + def __repr__(self) -> str: + return f"{type(self).__name__}(name={self.name!r})" + + def __hash__(self) -> int: + return hash((type(self), self.name)) + + def __eq__(self, other: object) -> bool: + return isinstance(other, frame_constructor) and self.name == other.name + + +# Eager constructors + + +@frame_constructor.register( + name="pandas", + implementation=Implementation.PANDAS, + requirements=("pandas",), + is_eager=True, + nan_is_null=True, +) +def pandas_constructor(obj: Data, /, **kwds: Any) -> pd.DataFrame: + import pandas as pd + + return pd.DataFrame(obj, **kwds) + + +@frame_constructor.register( + name="pandas[nullable]", + implementation=Implementation.PANDAS, + requirements=("pandas",), + is_eager=True, +) +def pandas_nullable_constructor(obj: Data, /, **kwds: Any) -> pd.DataFrame: + import pandas as pd + + return pd.DataFrame(obj, **kwds).convert_dtypes(dtype_backend="numpy_nullable") + + +@frame_constructor.register( + name="pandas[pyarrow]", + implementation=Implementation.PANDAS, + requirements=("pandas", "pyarrow"), + is_eager=True, +) +def pandas_pyarrow_constructor(obj: Data, /, **kwds: Any) -> pd.DataFrame: + import pandas as pd + + return pd.DataFrame(obj, **kwds).convert_dtypes(dtype_backend="pyarrow") + + +@frame_constructor.register( + name="pyarrow", + implementation=Implementation.PYARROW, + requirements=("pyarrow",), + is_eager=True, +) +def pyarrow_table_constructor(obj: Data, /, **kwds: Any) -> pa.Table: + import pyarrow as pa + + return pa.table(obj, **kwds) + + +@frame_constructor.register( + name="modin", + implementation=Implementation.MODIN, + requirements=("modin",), + is_eager=True, + nan_is_null=True, + default_include=False, +) +def modin_constructor(obj: Data, /, **kwds: Any) -> IntoDataFrame: # pragma: no cover + import modin.pandas as mpd + import pandas as pd + + return cast("IntoDataFrame", mpd.DataFrame(pd.DataFrame(obj, **kwds))) + + +@frame_constructor.register( + name="modin[pyarrow]", + implementation=Implementation.MODIN, + requirements=("modin", "pyarrow"), + is_eager=True, + default_include=False, +) +def modin_pyarrow_constructor( + obj: Data, /, **kwds: Any +) -> IntoDataFrame: # pragma: no cover + import modin.pandas as mpd + import pandas as pd + + df = mpd.DataFrame(pd.DataFrame(obj, **kwds)).convert_dtypes(dtype_backend="pyarrow") + return cast("IntoDataFrame", df) + + +@frame_constructor.register( + name="cudf", + implementation=Implementation.CUDF, + requirements=("cudf",), + is_eager=True, + needs_gpu=True, +) +def cudf_constructor(obj: Data, /, **kwds: Any) -> IntoDataFrame: # pragma: no cover + import cudf + + return cast("IntoDataFrame", cudf.DataFrame(obj, **kwds)) + + +@frame_constructor.register( + name="polars[eager]", + implementation=Implementation.POLARS, + requirements=("polars",), + is_eager=True, +) +def polars_eager_constructor(obj: Data, /, **kwds: Any) -> pl.DataFrame: + import polars as pl + + return pl.DataFrame(obj, **kwds) + + +# Lazy constructors + + +@frame_constructor.register( + name="polars[lazy]", implementation=Implementation.POLARS, requirements=("polars",) +) +def polars_lazy_constructor(obj: Data, /, **kwds: Any) -> pl.LazyFrame: + import polars as pl + + return pl.LazyFrame(obj, **kwds) + + +@frame_constructor.register( + name="dask", + implementation=Implementation.DASK, + requirements=("dask",), + nan_is_null=True, +) +def dask_lazy_p2_constructor( + obj: Data, /, npartitions: int = 2, **kwds: Any +) -> NativeDask: # pragma: no cover + import dask.dataframe as dd + + return cast("NativeDask", dd.from_dict(obj, npartitions=npartitions, **kwds)) + + +@frame_constructor.register( + name="duckdb", + implementation=Implementation.DUCKDB, + requirements=("duckdb", "pyarrow"), +) +def duckdb_lazy_constructor(obj: Data, /, **kwds: Any) -> NativeDuckDB: + import duckdb + import pyarrow as pa + + duckdb.sql("""set timezone = 'UTC'""") + _df = pa.table(obj, **kwds) + return duckdb.sql("select * from _df") + + +def _pyspark_build(obj: Data, /, **kwds: Any) -> NativePySpark: # pragma: no cover + session = _pyspark_session_lazy() + _obj = deepcopy(obj) + index_col_name = generate_temporary_column_name(n_bytes=8, columns=list(_obj)) + _obj[index_col_name] = list(range(len(_obj[next(iter(_obj))]))) + result = ( + session.createDataFrame( + [*zip(*_obj.values(), strict=True)], schema=[*_obj.keys()], **kwds + ) + .repartition(2) + .orderBy(index_col_name) + .drop(index_col_name) + ) + return cast("NativePySpark", result) + + +@frame_constructor.register( + name="pyspark", implementation=Implementation.PYSPARK, requirements=("pyspark",) +) +def pyspark_lazy_constructor( + obj: Data, /, **kwds: Any +) -> NativePySpark: # pragma: no cover + return _pyspark_build(obj, **kwds) + + +@frame_constructor.register( + name="pyspark[connect]", + implementation=Implementation.PYSPARK_CONNECT, + requirements=("pyspark",), + default_include=False, +) +def pyspark_connect_lazy_constructor( + obj: Data, /, **kwds: Any +) -> NativePySpark: # pragma: no cover + return _pyspark_build(obj, **kwds) + + +@frame_constructor.register( + name="sqlframe", + implementation=Implementation.SQLFRAME, + requirements=("sqlframe", "duckdb"), +) +def sqlframe_pyspark_lazy_constructor(obj: Data, /, **kwds: Any) -> NativeSQLFrame: + session = sqlframe_session() + return session.createDataFrame( + [*zip(*obj.values(), strict=True)], schema=[*obj.keys()], **kwds + ) + + +@frame_constructor.register( + name="ibis", + implementation=Implementation.IBIS, + requirements=("ibis", "duckdb", "pyarrow"), +) +def ibis_lazy_constructor(obj: Data, /, **kwds: Any) -> ibis.Table: # pragma: no cover + import pyarrow as pa + + table = pa.table(obj) + table_name = str(uuid.uuid4()) + return _ibis_backend().create_table(table_name, table, **kwds) + + +DEFAULT_BACKENDS: frozenset[str] = frozenset( + { + "pandas", + "pandas[pyarrow]", + "polars[eager]", + "pyarrow", + "duckdb", + "sqlframe", + "ibis", + } +) +"""Subset of backends enabled by default for parametrised tests when the +user does not pass `--nw-backends` (mirrors the historical Narwhals defaults). +""" + + +def available_backends() -> frozenset[str]: + """Return the names of every constructor whose backend is importable. + + Examples: + >>> from narwhals.testing.constructors import available_backends + >>> "pandas" in available_backends() + True + """ + return frozenset( + name for name, c in frame_constructor._registry.items() if c.is_available + ) + + +def available_cpu_backends() -> frozenset[str]: # pragma: no cover + """Return the names of every CPU constructor whose backend is importable. + + Examples: + >>> from narwhals.testing.constructors import available_cpu_backends + >>> "pandas" in available_cpu_backends() + True + """ + return frozenset( + name + for name, c in frame_constructor._registry.items() + if c.is_available and not c.needs_gpu + ) + + +def available_default_cpu_backends() -> frozenset[str]: # pragma: no cover + """Return the names of every CPU constructor that is available and included by default. + + Backends registered with `default_include=False` (e.g. modin, pyspark[connect]) are + excluded — they must be requested explicitly via `--nw-backends`. + + Examples: + >>> from narwhals.testing.constructors import available_default_cpu_backends + >>> "pandas" in available_default_cpu_backends() + True + """ + return frozenset( + name + for name, c in frame_constructor._registry.items() + if c.is_available and not c.needs_gpu and c.default_include + ) + + +EagerName: TypeAlias = Literal[ + "pandas", + "pandas[nullable]", + "pandas[pyarrow]", + "modin", + "modin[pyarrow]", + "cudf", + "polars[eager]", + "pyarrow", +] +LazyName: TypeAlias = Literal[ + "polars[lazy]", "dask", "duckdb", "pyspark", "pyspark[connect]", "sqlframe", "ibis" +] + + +@overload +def get_backend_constructor(name: EagerName) -> frame_constructor[IntoDataFrame]: ... +@overload +def get_backend_constructor(name: LazyName) -> frame_constructor[IntoLazyFrame]: ... +@overload +def get_backend_constructor(name: str) -> frame_constructor[IntoFrame]: ... + + +def get_backend_constructor(name: str) -> frame_constructor[IntoFrame]: + """Return the registered constructor for `name`. + + Arguments: + name: The string identifier of a registered constructor + (e.g. `"pandas[pyarrow]"`). + + Raises: + ValueError: If `name` is not a registered constructor identifier. + + Examples: + >>> from narwhals.testing.constructors import get_backend_constructor + >>> get_backend_constructor("pandas") + frame_constructor(name='pandas') + """ + try: + return frame_constructor._registry[name] + except KeyError as exc: + valid = sorted(frame_constructor._registry) + msg = f"Unknown constructor {name!r}. Expected one of: {valid}." + raise ValueError(msg) from exc + + +def prepare_backends( + *, include: Iterable[str] | None = None, exclude: Iterable[str] | None = None +) -> list[frame_constructor[IntoFrame]]: + """Return available constructors, optionally filtered. + + Note: + `exclude` is given precedence in the selection. + + Arguments: + include: If given, only return backends whose name is in this set. + exclude: If given, remove backends whose name is in this set. + + Examples: + >>> from narwhals.testing.constructors import prepare_backends + >>> backends = prepare_backends(include=["pandas", "polars[eager]"]) + """ + available = available_backends() + candidates: list[frame_constructor[Any]] = [ + c for name, c in frame_constructor._registry.items() if name in available + ] + + include_set: frozenset[str] = ( + frozenset(include) if include is not None else frozenset() + ) + exclude_set: frozenset[str] = ( + frozenset(exclude) if exclude is not None else frozenset() + ) + + if unknown := (include_set.union(exclude_set).difference(available)): + msg = f"The following names are not known constructors: {sorted(unknown)}" + raise ValueError(msg) + + if include is not None: + candidates = [c for c in candidates if c.name in include_set] + if exclude is not None: + candidates = [c for c in candidates if c.name not in exclude_set] + return sorted(candidates, key=lambda c: c.name) + + +def is_backend_available(*packages: str) -> bool: + """Whether every package in `packages` can be imported in this environment. + + Examples: + >>> from narwhals.testing.constructors import is_backend_available + >>> is_backend_available("pandas") + True + """ + return all(find_spec(pkg) is not None for pkg in packages) + + +def sqlframe_session() -> DuckDBSession: + """Return a fresh in-memory `sqlframe` DuckDB session.""" + from sqlframe.duckdb import DuckDBSession + + # NOTE: `__new__` override inferred by `pyright` only + # https://github.com/eakmanrq/sqlframe/blob/772b3a6bfe5a1ffd569b7749d84bea2f3a314510/sqlframe/base/session.py#L181-L184 + return cast("DuckDBSession", DuckDBSession()) # type: ignore[redundant-cast] + + +def pyspark_session() -> SparkSession: # pragma: no cover + """Return a singleton local `pyspark` (or pyspark[connect]) session.""" + if is_spark_connect := os.environ.get("SPARK_CONNECT", None): + from pyspark.sql.connect.session import SparkSession + else: + from pyspark.sql import SparkSession + builder = cast("SparkSession.Builder", SparkSession.builder).appName("unit-tests") + builder = ( + builder.remote(f"sc://localhost:{os.environ.get('SPARK_PORT', '15002')}") + if is_spark_connect + else builder.master("local[1]").config("spark.ui.enabled", "false") + ) + return ( + builder.config("spark.default.parallelism", "1") + .config("spark.sql.shuffle.partitions", "2") + .config("spark.sql.session.timeZone", "UTC") + .getOrCreate() + ) + + +@lru_cache(maxsize=1) +def _ibis_backend() -> IbisDuckDBBackend: # pragma: no cover + """Cached singleton in-memory ibis backend, so all tables share one database.""" + import ibis + + return ibis.duckdb.connect() + + +@lru_cache(maxsize=1) +def _pyspark_session_lazy() -> SparkSession: # pragma: no cover + """Cached pyspark session; created on first use, stopped at interpreter exit.""" + from atexit import register + + with warnings.catch_warnings(): + # The spark session seems to trigger a polars warning. + warnings.filterwarnings( + "ignore", r"Using fork\(\) can cause Polars", category=RuntimeWarning + ) + session = pyspark_session() + register(session.stop) + return session diff --git a/src/narwhals/testing/pytest_plugin.py b/src/narwhals/testing/pytest_plugin.py new file mode 100644 index 0000000000..7c0a02e600 --- /dev/null +++ b/src/narwhals/testing/pytest_plugin.py @@ -0,0 +1,131 @@ +"""Narwhals pytest plugin - auto-parametrises fixtures. + +NOTE: All imports from `narwhals.*` are deferred inside the hook functions so that +the entry-point module can be loaded by pytest without pulling in the narwhals package tree. + +This is critical because entry-point plugins are loaded *before* `coveragepy` starts +coverage measurement; any narwhals module imported at that stage would have its +module-level code (class definitions, constants, etc.) executed outside the coverage tracer. +""" + +from __future__ import annotations + +import os +from typing import TYPE_CHECKING, cast + +if TYPE_CHECKING: + from collections.abc import Callable + + import pytest + + from narwhals.testing.typing import FrameConstructor + + +_MIN_PANDAS_NULLABLE_VERSION: tuple[int, ...] = (2, 0, 0) +"""`pandas.convert_dtypes(dtype_backend=...)` requires pandas >= 2.0.0.""" + + +def _pandas_version() -> tuple[int, ...]: + try: + import pandas as pd + except ImportError: # pragma: no cover + return (0, 0, 0) + + from narwhals._utils import parse_version + + return parse_version(pd.__version__) + + +def _default_backend_ids() -> list[str]: + """Resolve the default `--nw-backends` value for the current environment. + + Honours `NARWHALS_DEFAULT_BACKENDS` if set, otherwise restricts + [`DEFAULT_BACKENDS`][] to backends whose libraries are importable. + """ + if env := os.environ.get("NARWHALS_DEFAULT_BACKENDS"): + return env.split(",") + from narwhals.testing.constructors import DEFAULT_BACKENDS, frame_constructor + + return [ + name + for name, constructor in frame_constructor._registry.items() + if constructor.is_available and name in DEFAULT_BACKENDS + ] + + +def pytest_addoption(parser: pytest.Parser) -> None: + from narwhals.testing.constructors import DEFAULT_BACKENDS + + group = parser.getgroup("narwhals", "narwhals-testing") + defaults = ", ".join(f"'{c}'" for c in sorted(DEFAULT_BACKENDS)) + group.addoption( + "--nw-backends", + action="store", + default=",".join(_default_backend_ids()), + type=str, + help=( + "Comma-separated list of (data|lazy) frame backend constructors to" + f"parametrise. Defaults to the installed subset of ({defaults})" + ), + ) + group.addoption( + "--all-nw-backends", + action="store_true", + default=False, + help=("Run tests against every installed CPU backend (overrides --nw-backends)."), + ) + # Escape hatch for downstream test suites that ship their own backend plugin. + # When set, this plugin still adds the CLI options but stops parametrising the fixtures. + group.addoption( + "--use-external-nw-backend", + action="store_true", + default=False, + help=( + "Skip narwhals-testing's parametrisation and let another plugin " + "provide the `nw_*frame_constructor` fixtures." + ), + ) + + +def _select_backends(config: pytest.Config) -> list[FrameConstructor]: # pragma: no cover + from narwhals.testing.constructors import ( + available_default_cpu_backends, + prepare_backends, + ) + + if config.getoption("all_nw_backends"): + selected = prepare_backends(include=available_default_cpu_backends()) + else: + opt = cast("str", config.getoption("nw_backends")) + names = [c for c in opt.split(",") if c] + selected = prepare_backends(include=names) + + if _pandas_version() < _MIN_PANDAS_NULLABLE_VERSION: + _pandas_nullables = {"pandas[nullable]", "pandas[pyarrow]"} + selected = [c for c in selected if c.name not in _pandas_nullables] + return selected + + +def pytest_generate_tests(metafunc: pytest.Metafunc) -> None: + if metafunc.config.getoption("use_external_nw_backend"): # pragma: no cover + return + + fixture_filters: dict[str, Callable[[FrameConstructor], bool]] = { + "nw_dataframe": lambda c: c.is_eager, + "nw_lazyframe": lambda c: not c.is_eager, + "nw_frame": lambda _: True, + "nw_pandas_like_frame": lambda c: c.is_eager and c.is_pandas_like, + } + fixturenames = set(metafunc.fixturenames) + if not (matched_fixtures := fixturenames & fixture_filters.keys()): + return + if len(matched_fixtures) > 1: + msg = ( + f"A test may only request one narwhals frame fixture, got: {matched_fixtures}" + ) + raise ValueError(msg) + selected = _select_backends(metafunc.config) + fixture_name = next(iter(matched_fixtures)) + filter_fn = fixture_filters[fixture_name] + params = [c for c in selected if filter_fn(c)] + metafunc.parametrize(fixture_name, params, ids=[c.name for c in params]) diff --git a/src/narwhals/testing/typing.py b/src/narwhals/testing/typing.py new file mode 100644 index 0000000000..a5d5144bd7 --- /dev/null +++ b/src/narwhals/testing/typing.py @@ -0,0 +1,31 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING, Any, Protocol + +if TYPE_CHECKING: + from collections.abc import Callable + from typing import TypeAlias + + from narwhals.testing.constructors import frame_constructor + from narwhals.typing import IntoDataFrame, IntoFrame, IntoLazyFrame + + +__all__ = ("Data", "DataFrameConstructor", "FrameConstructor", "LazyFrameConstructor") + +FrameConstructor: TypeAlias = "frame_constructor[IntoFrame]" +"""Type alias for a constructor that returns a native eager or lazy frame.""" + +DataFrameConstructor: TypeAlias = "frame_constructor[IntoDataFrame]" +"""Type alias for a constructor that returns an eager native dataframe.""" + +LazyFrameConstructor: TypeAlias = "frame_constructor[IntoLazyFrame]" +"""Type alias for a constructor that returns a lazy native frame.""" + +Data: TypeAlias = dict[str, Any] # TODO(Unassined): This should have a better annotation +"""A column-oriented mapping used as input to a frame constructor.""" + + +class NarwhalsNamespace(Protocol): + """Minimal specs of a narwhals namespace (e.g. `narwhals`, `narwhals.stable.v1`).""" + + from_native: Callable[..., Any] diff --git a/tests/conftest.py b/tests/conftest.py index 84ff43c41a..a1b2fbf6e1 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1,80 +1,41 @@ from __future__ import annotations -import os -import uuid -from copy import deepcopy -from functools import lru_cache from importlib.util import find_spec from typing import TYPE_CHECKING, Any, cast import pytest import narwhals as nw -from narwhals._utils import Implementation, generate_temporary_column_name -from tests.utils import ID_PANDAS_LIKE, PANDAS_VERSION, pyspark_session, sqlframe_session +from narwhals._utils import Implementation -if TYPE_CHECKING: - from collections.abc import Callable, Sequence - from typing import TypeAlias +# `narwhals.testing.pytest_plugin` registers itself via the `pytest11` entry point (see pyproject.toml) +# so it auto-loads as soon as Narwhals is installed. +# That plugin is what owns the `--nw-backends`, `--all-nw-backends`, and `--use-external-constructor` +# CLI options as well as parametrising the `constructor*` fixtures. - import ibis - import pandas as pd - import polars as pl - import pyarrow as pa - from ibis.backends.duckdb import Backend as IbisDuckDBBackend +if TYPE_CHECKING: + from collections.abc import Sequence - from narwhals._native import NativeDask, NativeDuckDB, NativePySpark, NativeSQLFrame from narwhals._typing import EagerAllowed - from narwhals.typing import IntoDataFrame, NonNestedDType - from tests.utils import ( - Constructor, - ConstructorEager, - ConstructorLazy, - NestedOrEnumDType, + from narwhals.dataframe import DataFrame, LazyFrame + from narwhals.testing.constructors import frame_constructor + from narwhals.testing.typing import ( + Data, + DataFrameConstructor, + FrameConstructor, + NarwhalsNamespace, ) - - Data: TypeAlias = "dict[str, list[Any]]" + from narwhals.typing import IntoFrame, NonNestedDType + from tests.utils import NestedOrEnumDType -MIN_PANDAS_NULLABLE_VERSION = (2,) - -# When testing cudf.pandas in Kaggle, we get an error if we try to run -# python -m cudf.pandas -m pytest --constructors=pandas. This gives us -# a way to run `python -m cudf.pandas -m pytest` and control which constructors -# get tested. -if default_constructors := os.environ.get( - "NARWHALS_DEFAULT_CONSTRUCTORS", None -): # pragma: no cover - DEFAULT_CONSTRUCTORS = default_constructors -else: - DEFAULT_CONSTRUCTORS = ( - "pandas,pandas[pyarrow],polars[eager],pyarrow,duckdb,sqlframe,ibis" - ) +# Narwhals-internal pytest options (not part of the public testing plugin) def pytest_addoption(parser: pytest.Parser) -> None: parser.addoption( "--runslow", action="store_true", default=False, help="run slow tests" ) - parser.addoption( - "--all-cpu-constructors", - action="store_true", - default=False, - help="run tests with all cpu constructors", - ) - parser.addoption( - "--use-external-constructor", - action="store_true", - default=False, - help="run tests with external constructor", - ) - parser.addoption( - "--constructors", - action="store", - default=DEFAULT_CONSTRUCTORS, - type=str, - help="libraries to test", - ) def pytest_configure(config: pytest.Config) -> None: @@ -85,7 +46,6 @@ def pytest_collection_modifyitems( config: pytest.Config, items: Sequence[pytest.Function] ) -> None: # pragma: no cover if config.getoption("--runslow"): - # --runslow given in cli: do not skip slow tests return skip_slow = pytest.mark.skip(reason="need --runslow option to run") for item in items: @@ -93,237 +53,6 @@ def pytest_collection_modifyitems( item.add_marker(skip_slow) -def pandas_constructor(obj: Data) -> pd.DataFrame: - import pandas as pd - - return pd.DataFrame(obj) - - -def pandas_nullable_constructor(obj: Data) -> pd.DataFrame: - import pandas as pd - - return pd.DataFrame(obj).convert_dtypes(dtype_backend="numpy_nullable") - - -def pandas_pyarrow_constructor(obj: Data) -> pd.DataFrame: - pytest.importorskip("pyarrow") - import pandas as pd - - return pd.DataFrame(obj).convert_dtypes(dtype_backend="pyarrow") - - -def modin_constructor(obj: Data) -> IntoDataFrame: # pragma: no cover - import modin.pandas as mpd - import pandas as pd - - df = mpd.DataFrame(pd.DataFrame(obj)) - return cast("IntoDataFrame", df) - - -def modin_pyarrow_constructor(obj: Data) -> IntoDataFrame: # pragma: no cover - import modin.pandas as mpd - import pandas as pd - - df = mpd.DataFrame(pd.DataFrame(obj)).convert_dtypes(dtype_backend="pyarrow") - return cast("IntoDataFrame", df) - - -def cudf_constructor(obj: Data) -> IntoDataFrame: # pragma: no cover - import cudf - - df = cudf.DataFrame(obj) - return cast("IntoDataFrame", df) - - -def polars_eager_constructor(obj: Data) -> pl.DataFrame: - pytest.importorskip("polars") - import polars as pl - - return pl.DataFrame(obj) - - -def polars_lazy_constructor(obj: Data) -> pl.LazyFrame: - import polars as pl - - return pl.LazyFrame(obj) - - -def duckdb_lazy_constructor(obj: dict[str, Any]) -> NativeDuckDB: - pytest.importorskip("duckdb") - pytest.importorskip("pyarrow") - import duckdb - import pyarrow as pa - - duckdb.sql("""set timezone = 'UTC'""") - - _df = pa.table(obj) - return duckdb.sql("select * from _df") - - -def dask_lazy_p1_constructor(obj: Data) -> NativeDask: # pragma: no cover - import dask.dataframe as dd - - return cast("NativeDask", dd.from_dict(obj, npartitions=1)) - - -def dask_lazy_p2_constructor(obj: Data) -> NativeDask: # pragma: no cover - import dask.dataframe as dd - - return cast("NativeDask", dd.from_dict(obj, npartitions=2)) - - -def pyarrow_table_constructor(obj: dict[str, Any]) -> pa.Table: - pytest.importorskip("pyarrow") - import pyarrow as pa - - return pa.table(obj) - - -def pyspark_lazy_constructor() -> Callable[[Data], NativePySpark]: # pragma: no cover - pytest.importorskip("pyspark") - import warnings - from atexit import register - - with warnings.catch_warnings(): - # The spark session seems to trigger a polars warning. - # Polars is imported in the tests, but not used in the spark operations - warnings.filterwarnings( - "ignore", r"Using fork\(\) can cause Polars", category=RuntimeWarning - ) - session = pyspark_session() - - register(session.stop) - - def _constructor(obj: Data) -> NativePySpark: - _obj = deepcopy(obj) - index_col_name = generate_temporary_column_name(n_bytes=8, columns=list(_obj)) - _obj[index_col_name] = list(range(len(_obj[next(iter(_obj))]))) - result = ( - session.createDataFrame( - [*zip(*_obj.values(), strict=False)], schema=[*_obj.keys()] - ) - .repartition(2) - .orderBy(index_col_name) - .drop(index_col_name) - ) - return cast("NativePySpark", result) - - return _constructor - - -def sqlframe_pyspark_lazy_constructor(obj: Data) -> NativeSQLFrame: # pragma: no cover - pytest.importorskip("sqlframe") - pytest.importorskip("duckdb") - session = sqlframe_session() - return session.createDataFrame([*zip(*obj.values(), strict=False)], schema=list(obj)) - - -@lru_cache(maxsize=1) -def _ibis_backend() -> IbisDuckDBBackend: # pragma: no cover - """Cached (singleton) in-memory backend to ensure all tables exist within the same in-memory database.""" - import ibis - - return ibis.duckdb.connect() - - -def ibis_lazy_constructor(obj: Data) -> ibis.Table: # pragma: no cover - pytest.importorskip("ibis") - pytest.importorskip("polars") - import polars as pl - - ldf = pl.LazyFrame(obj) - table_name = str(uuid.uuid4()) - return _ibis_backend().create_table(table_name, ldf) - - -EAGER_CONSTRUCTORS: dict[str, ConstructorEager] = { - "pandas": pandas_constructor, - "pandas[nullable]": pandas_nullable_constructor, - "pandas[pyarrow]": pandas_pyarrow_constructor, - "pyarrow": pyarrow_table_constructor, - "modin": modin_constructor, - "modin[pyarrow]": modin_pyarrow_constructor, - "cudf": cudf_constructor, - "polars[eager]": polars_eager_constructor, -} -LAZY_CONSTRUCTORS: dict[str, ConstructorLazy] = { # pyrefly: ignore[bad-assignment] - "dask": dask_lazy_p2_constructor, - "polars[lazy]": polars_lazy_constructor, - "duckdb": duckdb_lazy_constructor, - "pyspark": pyspark_lazy_constructor, # type: ignore[dict-item] - "sqlframe": sqlframe_pyspark_lazy_constructor, - "ibis": ibis_lazy_constructor, -} -GPU_CONSTRUCTORS: dict[str, ConstructorEager] = {"cudf": cudf_constructor} - - -def pytest_generate_tests(metafunc: pytest.Metafunc) -> None: - if metafunc.config.getoption("use_external_constructor"): # pragma: no cover - return # let the plugin handle this - if metafunc.config.getoption("all_cpu_constructors"): # pragma: no cover - selected_constructors: list[str] = [ - *iter(EAGER_CONSTRUCTORS.keys()), - *iter(LAZY_CONSTRUCTORS.keys()), - ] - selected_constructors = [ - x - for x in selected_constructors - if x not in GPU_CONSTRUCTORS - and x - not in { - "modin", # too slow - "spark[connect]", # complex local setup; can't run together with local spark - } - ] - else: # pragma: no cover - opt = cast("str", metafunc.config.getoption("constructors")) - selected_constructors = opt.split(",") - - eager_constructors: list[ConstructorEager] = [] - eager_constructors_ids: list[str] = [] - constructors: list[Constructor] = [] - constructors_ids: list[str] = [] - - for constructor in selected_constructors: - if ( - constructor in {"pandas[nullable]", "pandas[pyarrow]"} - and MIN_PANDAS_NULLABLE_VERSION > PANDAS_VERSION - ): - continue # pragma: no cover - - if constructor in EAGER_CONSTRUCTORS: - eager_constructors.append(EAGER_CONSTRUCTORS[constructor]) - eager_constructors_ids.append(constructor) - constructors.append(EAGER_CONSTRUCTORS[constructor]) - elif constructor in {"pyspark", "pyspark[connect]"}: # pragma: no cover - constructors.append(pyspark_lazy_constructor()) - elif constructor in LAZY_CONSTRUCTORS: - constructors.append(LAZY_CONSTRUCTORS[constructor]) - else: # pragma: no cover - msg = f"Expected one of {EAGER_CONSTRUCTORS.keys()} or {LAZY_CONSTRUCTORS.keys()}, got {constructor}" - raise ValueError(msg) - constructors_ids.append(constructor) - - if "constructor_eager" in metafunc.fixturenames: - metafunc.parametrize( - "constructor_eager", eager_constructors, ids=eager_constructors_ids - ) - elif "constructor" in metafunc.fixturenames: - metafunc.parametrize("constructor", constructors, ids=constructors_ids) - elif "constructor_pandas_like" in metafunc.fixturenames: - pandas_like_constructors = [] - pandas_like_constructors_ids = [] - for fn, name in zip(eager_constructors, eager_constructors_ids, strict=False): - if name in ID_PANDAS_LIKE: - pandas_like_constructors.append(fn) - pandas_like_constructors_ids.append(name) - metafunc.parametrize( - "constructor_pandas_like", - pandas_like_constructors, - ids=pandas_like_constructors_ids, - ) - - TEST_EAGER_BACKENDS: list[EagerAllowed] = [] TEST_EAGER_BACKENDS.extend( (Implementation.POLARS, "polars") if find_spec("polars") is not None else () @@ -392,3 +121,64 @@ def non_nested_type(request: pytest.FixtureRequest) -> type[NonNestedDType]: def nested_dtype(request: pytest.FixtureRequest) -> NestedOrEnumDType: dtype: NestedOrEnumDType = request.param return dtype + + +# The following fixtures are aliases of those registered in `narwhals/testing/pytest_plugin.py`, +# wrapped so that calling them without an explicit `namespace` defaults to the main +# `narwhals` namespace. Tests can still pass `nw_v1` / `nw_v2` explicitly to opt in +# to a stable namespace; the legacy pattern `nw.from_native(constructor(data))` keeps +# working because `nw.from_native` is idempotent on narwhals objects. +# TODO(FBruzzesi): Drop these aliases once every test calls `nw_frame` / `nw_dataframe` +# directly with an explicit namespace. + + +class _PatchedFrameConstructor: + """Proxy over a `frame_constructor` defaulting `namespace` to `narwhals`. + + Delegates attribute access, `str()`, and `repr()` to the wrapped instance + so that test helpers (e.g. `constructor.nan_is_null`, `"pandas" in str(constructor)`) + keep working unchanged. + """ + + __slots__ = ("_inner",) + + def __init__(self, inner: frame_constructor[IntoFrame]) -> None: + self._inner = inner + + def __call__( + self, obj: Data, /, namespace: NarwhalsNamespace = nw, **kwds: Any + ) -> DataFrame[Any] | LazyFrame[Any]: + return self._inner(obj, namespace=namespace, **kwds) + + def __getattr__(self, name: str) -> Any: + return getattr(self._inner, name) + + def __str__(self) -> str: + return str(self._inner) + + def __repr__(self) -> str: + return repr(self._inner) + + +class _PatchedDataFrameConstructor(_PatchedFrameConstructor): + def __call__( + self, obj: Data, /, namespace: NarwhalsNamespace = nw, **kwds: Any + ) -> DataFrame[Any]: + return cast("DataFrame[Any]", self._inner(obj, namespace=namespace, **kwds)) + + +@pytest.fixture +def constructor(nw_frame: FrameConstructor) -> _PatchedFrameConstructor: + return _PatchedFrameConstructor(nw_frame) + + +@pytest.fixture +def constructor_eager(nw_dataframe: DataFrameConstructor) -> _PatchedDataFrameConstructor: + return _PatchedDataFrameConstructor(nw_dataframe) + + +@pytest.fixture +def constructor_pandas_like( + nw_pandas_like_frame: DataFrameConstructor, +) -> _PatchedDataFrameConstructor: + return _PatchedDataFrameConstructor(nw_pandas_like_frame) diff --git a/tests/dependencies/is_into_dataframe_test.py b/tests/dependencies/is_into_dataframe_test.py index 4e31b71afd..95544d593c 100644 --- a/tests/dependencies/is_into_dataframe_test.py +++ b/tests/dependencies/is_into_dataframe_test.py @@ -42,7 +42,7 @@ def join(self, *args: Any, **kwargs: Any) -> Any: ... def test_is_into_dataframe(constructor: Constructor) -> None: - native_frame = constructor(data) + native_frame = constructor(data).to_native() nw_frame = nw.from_native(native_frame) nw_v1_frame = nw_v1.from_native(native_frame) nw_v2_frame = nw_v2.from_native(native_frame) diff --git a/tests/dependencies/is_into_lazyframe_test.py b/tests/dependencies/is_into_lazyframe_test.py index b9cabdea83..b0edfd5ab5 100644 --- a/tests/dependencies/is_into_lazyframe_test.py +++ b/tests/dependencies/is_into_lazyframe_test.py @@ -40,7 +40,7 @@ def join(self, *args: Any, **kwargs: Any) -> Any: ... def test_is_into_lazyframe(constructor: Constructor) -> None: - native_frame = constructor(data) + native_frame = constructor(data).to_native() nw_frame = nw.from_native(native_frame) nw_v1_frame = nw_v1.from_native(native_frame) nw_v2_frame = nw_v2.from_native(native_frame) diff --git a/tests/dependencies/is_into_series_test.py b/tests/dependencies/is_into_series_test.py index 06dc1fb8b1..4a8b68d34b 100644 --- a/tests/dependencies/is_into_series_test.py +++ b/tests/dependencies/is_into_series_test.py @@ -38,7 +38,7 @@ def unique(self, *args: Any, **kwargs: Any) -> Any: ... def test_is_into_series(constructor_eager: ConstructorEager) -> None: - native_frame = constructor_eager(data) + native_frame = constructor_eager(data).to_native() nw_series = nw.from_native(native_frame)["a"] nw_v1_series = nw_v1.from_native(native_frame)["a"] nw_v2_series = nw_v2.from_native(native_frame)["a"] diff --git a/tests/dependencies/is_narwhals_dataframe_test.py b/tests/dependencies/is_narwhals_dataframe_test.py index aeedf15981..0897e64cc8 100644 --- a/tests/dependencies/is_narwhals_dataframe_test.py +++ b/tests/dependencies/is_narwhals_dataframe_test.py @@ -2,7 +2,6 @@ from typing import TYPE_CHECKING -import narwhals as nw from narwhals.stable.v1.dependencies import is_narwhals_dataframe if TYPE_CHECKING: @@ -12,5 +11,5 @@ def test_is_narwhals_dataframe(constructor_eager: ConstructorEager) -> None: df = constructor_eager({"col1": [1, 2], "col2": [3, 4]}) - assert is_narwhals_dataframe(nw.from_native(df)) - assert not is_narwhals_dataframe(df) + assert is_narwhals_dataframe(df) + assert not is_narwhals_dataframe(df.to_native()) diff --git a/tests/dependencies/is_narwhals_lazyframe_test.py b/tests/dependencies/is_narwhals_lazyframe_test.py index 0e4c6e1bd9..113fd4a511 100644 --- a/tests/dependencies/is_narwhals_lazyframe_test.py +++ b/tests/dependencies/is_narwhals_lazyframe_test.py @@ -2,7 +2,6 @@ from typing import TYPE_CHECKING -import narwhals as nw from narwhals.stable.v1.dependencies import is_narwhals_lazyframe from tests.utils import Constructor @@ -13,5 +12,5 @@ def test_is_narwhals_lazyframe(constructor: Constructor) -> None: lf = constructor({"a": [1, 2, 3]}) - assert is_narwhals_lazyframe(nw.from_native(lf).lazy()) - assert not is_narwhals_lazyframe(lf) + assert is_narwhals_lazyframe(lf.lazy()) + assert not is_narwhals_lazyframe(lf.to_native()) diff --git a/tests/dtypes/dtypes_test.py b/tests/dtypes/dtypes_test.py index d508eee2d8..60342a3c5e 100644 --- a/tests/dtypes/dtypes_test.py +++ b/tests/dtypes/dtypes_test.py @@ -9,13 +9,8 @@ import narwhals as nw from narwhals.exceptions import InvalidOperationError, PerformanceWarning -from tests.utils import ( - PANDAS_VERSION, - POLARS_VERSION, - PYARROW_VERSION, - assert_equal_hash, - pyspark_session, -) +from narwhals.testing.constructors import pyspark_session +from tests.utils import PANDAS_VERSION, POLARS_VERSION, PYARROW_VERSION, assert_equal_hash if TYPE_CHECKING: from collections.abc import Iterable diff --git a/tests/expr_and_series/arithmetic_test.py b/tests/expr_and_series/arithmetic_test.py index 3e9130fbf4..4ae7a14db6 100644 --- a/tests/expr_and_series/arithmetic_test.py +++ b/tests/expr_and_series/arithmetic_test.py @@ -45,7 +45,7 @@ def test_arithmetic_expr( request.applymarker(pytest.mark.xfail) data = {"a": [1.0, 2.0, 3.0]} - df = nw.from_native(constructor(data)) + df = constructor(data, nw) result = df.select(getattr(nw.col("a"), attr)(rhs)) assert_equal_data(result, {"a": expected}) @@ -76,7 +76,7 @@ def test_right_arithmetic_expr( ): request.applymarker(pytest.mark.xfail) data = {"a": [1, 2, 3]} - df = nw.from_native(constructor(data)) + df = constructor(data) result = df.select(getattr(nw.col("a"), attr)(rhs)) assert_equal_data(result, {"literal": expected}) @@ -98,16 +98,16 @@ def test_arithmetic_series( attr: str, rhs: Any, expected: list[Any], - constructor_eager: ConstructorEager, + nw_dataframe: ConstructorEager, request: pytest.FixtureRequest, ) -> None: if attr == "__mod__" and any( - x in str(constructor_eager) for x in ["pandas_pyarrow", "modin_pyarrow"] + x in str(nw_dataframe) for x in ["pandas_pyarrow", "modin_pyarrow"] ): request.applymarker(pytest.mark.xfail) data = {"a": [1, 2, 3]} - df = nw.from_native(constructor_eager(data), eager_only=True) + df = nw_dataframe(data, nw) result = df.select(getattr(df["a"], attr)(rhs)) assert_equal_data(result, {"a": expected}) @@ -128,29 +128,29 @@ def test_right_arithmetic_series( attr: str, rhs: Any, expected: list[Any], - constructor_eager: ConstructorEager, + nw_dataframe: ConstructorEager, request: pytest.FixtureRequest, ) -> None: if attr == "__rmod__" and any( - x in str(constructor_eager) for x in ["pandas_pyarrow", "modin_pyarrow"] + x in str(nw_dataframe) for x in ["pandas_pyarrow", "modin_pyarrow"] ): request.applymarker(pytest.mark.xfail) data = {"a": [1, 2, 3]} - df = nw.from_native(constructor_eager(data), eager_only=True) + df = nw_dataframe(data, nw) result_series = getattr(df["a"], attr)(rhs) assert result_series.name == "a" assert_equal_data({"a": result_series}, {"a": expected}) def test_truediv_same_dims( - constructor_eager: ConstructorEager, request: pytest.FixtureRequest + nw_dataframe: ConstructorEager, request: pytest.FixtureRequest ) -> None: - if "polars" in str(constructor_eager): + if "polars" in str(nw_dataframe): # https://github.com/pola-rs/polars/issues/17760 request.applymarker(pytest.mark.xfail) - s_left = nw.from_native(constructor_eager({"a": [1, 2, 3]}), eager_only=True)["a"] - s_right = nw.from_native(constructor_eager({"a": [2, 2, 1]}), eager_only=True)["a"] + s_left = nw_dataframe({"a": [1, 2, 3]}, nw)["a"] + s_right = nw_dataframe({"a": [2, 2, 1]}, nw)["a"] result = s_left / s_right assert_equal_data({"a": result}, {"a": [0.5, 1.0, 3.0]}) result = s_left.__rtruediv__(s_right) @@ -160,31 +160,27 @@ def test_truediv_same_dims( @given(left=st.integers(-100, 100), right=st.integers(-100, 100)) @pytest.mark.skipif(PANDAS_VERSION < (2, 0), reason="convert_dtypes not available") @pytest.mark.slow -def test_floordiv(constructor_eager: ConstructorEager, *, left: int, right: int) -> None: - if any(x in str(constructor_eager) for x in ["modin", "cudf"]): +def test_floordiv(nw_dataframe: ConstructorEager, *, left: int, right: int) -> None: + if any(x in str(nw_dataframe) for x in ["modin", "cudf"]): # modin & cudf are too slow here pytest.skip() assume(right != 0) expected = {"a": [left // right]} - result = nw.from_native(constructor_eager({"a": [left]}), eager_only=True).select( - nw.col("a") // right - ) + result = nw_dataframe({"a": [left]}, nw).select(nw.col("a") // right) assert_equal_data(result, expected) @pytest.mark.slow @given(left=st.integers(-100, 100), right=st.integers(-100, 100)) @pytest.mark.skipif(PANDAS_VERSION < (2, 0), reason="convert_dtypes not available") -def test_mod(constructor_eager: ConstructorEager, *, left: int, right: int) -> None: - if any(x in str(constructor_eager) for x in ["pandas_pyarrow", "modin", "cudf"]): +def test_mod(nw_dataframe: ConstructorEager, *, left: int, right: int) -> None: + if any(x in str(nw_dataframe) for x in ["pandas_pyarrow", "modin", "cudf"]): # pandas[pyarrow] does not implement mod # modin & cudf are too slow here pytest.skip() assume(right != 0) expected = {"a": [left % right]} - result = nw.from_native(constructor_eager({"a": [left]}), eager_only=True).select( - nw.col("a") % right - ) + result = nw_dataframe({"a": [left]}, nw).select(nw.col("a") % right) assert_equal_data(result, expected) @@ -218,7 +214,7 @@ def test_arithmetic_expr_left_literal( request.applymarker(pytest.mark.xfail) data = {"a": [1.0, 2.0, 4.0]} - df = nw.from_native(constructor(data)) + df = constructor(data, nw) result = df.select(getattr(lhs, attr)(nw.col("a"))) assert_equal_data(result, {"literal": expected}) @@ -240,16 +236,16 @@ def test_arithmetic_series_left_literal( attr: str, lhs: Any, expected: list[Any], - constructor_eager: ConstructorEager, + nw_dataframe: ConstructorEager, request: pytest.FixtureRequest, ) -> None: if attr == "__mod__" and any( - x in str(constructor_eager) for x in ["pandas_pyarrow", "modin_pyarrow"] + x in str(nw_dataframe) for x in ["pandas_pyarrow", "modin_pyarrow"] ): request.applymarker(pytest.mark.xfail) data = {"a": [1.0, 2.0, 4.0]} - df = nw.from_native(constructor_eager(data)) + df = nw_dataframe(data, nw) result = df.select(getattr(lhs, attr)(nw.col("a"))) assert_equal_data(result, {"literal": expected}) @@ -258,7 +254,7 @@ def test_std_broadcating(constructor: Constructor) -> None: if "duckdb" in str(constructor) and DUCKDB_VERSION < (1, 3): # `std(ddof=2)` fails for duckdb here pytest.skip() - df = nw.from_native(constructor({"a": [1, 2, 3]})) + df = constructor({"a": [1, 2, 3]}, nw) result = df.with_columns(b=nw.col("a").std()).sort("a") expected = {"a": [1, 2, 3], "b": [1.0, 1.0, 1.0]} assert_equal_data(result, expected) diff --git a/tests/expr_and_series/corr_test.py b/tests/expr_and_series/corr_test.py index 9152df69c8..15e371d62d 100644 --- a/tests/expr_and_series/corr_test.py +++ b/tests/expr_and_series/corr_test.py @@ -25,7 +25,7 @@ def test_corr_expr( output_name: str, a: str | nw.Expr, b: str | nw.Expr, - expected_corr: float, + expected_corr: float | None, ) -> None: if "pyspark" in str(constructor) and expected_corr is None: request.applymarker( @@ -51,7 +51,7 @@ def test_corr_expr_spearman( output_name: str, a: str | nw.Expr, b: str | nw.Expr, - expected_corr: float, + expected_corr: float | None, ) -> None: context = ( does_not_raise() @@ -75,7 +75,7 @@ def test_corr_series( output_name: str, a: str, b: str, - expected_corr: float, + expected_corr: float | None, ) -> None: if "pyspark" in str(constructor_eager) and expected_corr is None: request.applymarker( @@ -97,7 +97,7 @@ def test_corr_series_spearman( output_name: str, a: str, b: str, - expected_corr: float, + expected_corr: float | None, ) -> None: if "pyspark" in str(constructor_eager) and expected_corr is None: request.applymarker( diff --git a/tests/expr_and_series/dt/convert_time_zone_test.py b/tests/expr_and_series/dt/convert_time_zone_test.py index 65d1a6e3b6..8fd654ad6d 100644 --- a/tests/expr_and_series/dt/convert_time_zone_test.py +++ b/tests/expr_and_series/dt/convert_time_zone_test.py @@ -7,13 +7,13 @@ import pytest import narwhals as nw +from narwhals.testing.constructors import pyspark_session from tests.utils import ( PANDAS_VERSION, POLARS_VERSION, Constructor, assert_equal_data, is_windows, - pyspark_session, ) if TYPE_CHECKING: diff --git a/tests/expr_and_series/dt/datetime_attributes_test.py b/tests/expr_and_series/dt/datetime_attributes_test.py index c7bf55e7c0..830666cac2 100644 --- a/tests/expr_and_series/dt/datetime_attributes_test.py +++ b/tests/expr_and_series/dt/datetime_attributes_test.py @@ -123,10 +123,10 @@ def test_to_date(request: pytest.FixtureRequest, constructor: Constructor) -> No request.applymarker(pytest.mark.xfail) dates = {"a": [datetime(2001, 1, 1), None, datetime(2001, 1, 3)]} if "dask" in str(constructor): - df_dask = cast("dd.DataFrame", constructor(dates)) + df_dask = cast("dd.DataFrame", constructor(dates).to_native()) df_dask = cast("dd.DataFrame", df_dask.astype({"a": "timestamp[ns][pyarrow]"})) df = nw.from_native(df_dask) else: - df = nw.from_native(constructor(dates)) + df = constructor(dates) result = df.select(nw.col("a").dt.date()) assert result.collect_schema() == {"a": nw.Date} diff --git a/tests/expr_and_series/dt/datetime_duration_test.py b/tests/expr_and_series/dt/datetime_duration_test.py index b84ecfa66e..ac7d132bfc 100644 --- a/tests/expr_and_series/dt/datetime_duration_test.py +++ b/tests/expr_and_series/dt/datetime_duration_test.py @@ -74,7 +74,7 @@ def test_duration_attributes_nano( import numpy as np data = {"c": np.array([None, 20], dtype="timedelta64[ns]")} - df = nw.from_native(constructor(data)) + df = constructor(data, nw) result_c = df.select(getattr(nw.col("c").dt, attribute)().fill_null(0)) assert_equal_data(result_c, {"c": expected_c}) diff --git a/tests/expr_and_series/dt/replace_time_zone_test.py b/tests/expr_and_series/dt/replace_time_zone_test.py index 1c9dff7d59..27bc394b69 100644 --- a/tests/expr_and_series/dt/replace_time_zone_test.py +++ b/tests/expr_and_series/dt/replace_time_zone_test.py @@ -7,13 +7,8 @@ import pytest import narwhals as nw -from tests.utils import ( - PANDAS_VERSION, - Constructor, - assert_equal_data, - is_windows, - pyspark_session, -) +from narwhals.testing.constructors import pyspark_session +from tests.utils import PANDAS_VERSION, Constructor, assert_equal_data, is_windows if TYPE_CHECKING: from tests.utils import ConstructorEager diff --git a/tests/expr_and_series/fill_nan_test.py b/tests/expr_and_series/fill_nan_test.py index 132b553c50..f74310cd82 100644 --- a/tests/expr_and_series/fill_nan_test.py +++ b/tests/expr_and_series/fill_nan_test.py @@ -3,21 +3,8 @@ import pytest import narwhals as nw -from tests.conftest import ( - dask_lazy_p1_constructor, - dask_lazy_p2_constructor, - modin_constructor, - pandas_constructor, -) from tests.utils import PANDAS_VERSION, Constructor, ConstructorEager, assert_equal_data -NON_NULLABLE_CONSTRUCTORS = [ - pandas_constructor, - dask_lazy_p1_constructor, - dask_lazy_p2_constructor, - modin_constructor, -] - def test_fill_nan(request: pytest.FixtureRequest, constructor: Constructor) -> None: if "cudf" in str(constructor): @@ -36,8 +23,7 @@ def test_fill_nan(request: pytest.FixtureRequest, constructor: Constructor) -> N assert_equal_data(result, expected) assert result.lazy().collect()["float_na"].null_count() == 2 result = df.select(nw.all().fill_nan(3.0)) - if any(constructor is c for c in NON_NULLABLE_CONSTRUCTORS): - # no nan vs null distinction + if constructor.nan_is_null: expected = {"float": [-1.0, 1.0, 3.0], "float_na": [3.0, 1.0, 3.0]} assert result.lazy().collect()["float_na"].null_count() == 0 elif "pandas" in str(constructor) and PANDAS_VERSION >= (3,): @@ -55,8 +41,7 @@ def test_fill_nan_series(constructor_eager: ConstructorEager) -> None: "float_na" ] result = s.fill_nan(999) - if any(constructor_eager is c for c in NON_NULLABLE_CONSTRUCTORS): - # no nan vs null distinction + if constructor_eager.nan_is_null: assert_equal_data({"a": result}, {"a": [999.0, 1.0, 999.0]}) elif "pandas" in str(constructor_eager) and PANDAS_VERSION >= (3,): assert_equal_data({"a": result}, {"a": [None, 1.0, None]}) diff --git a/tests/expr_and_series/is_close_test.py b/tests/expr_and_series/is_close_test.py index 16c59536ca..8e51264897 100644 --- a/tests/expr_and_series/is_close_test.py +++ b/tests/expr_and_series/is_close_test.py @@ -12,12 +12,6 @@ import narwhals as nw from narwhals.exceptions import ComputeError, InvalidOperationError -from tests.conftest import ( - dask_lazy_p1_constructor, - dask_lazy_p2_constructor, - modin_constructor, - pandas_constructor, -) from tests.utils import ( PANDAS_VERSION, PYARROW_VERSION, @@ -29,12 +23,6 @@ if TYPE_CHECKING: from narwhals.typing import NumericLiteral -NON_NULLABLE_CONSTRUCTORS = ( - pandas_constructor, - dask_lazy_p1_constructor, - dask_lazy_p2_constructor, - modin_constructor, -) NULL_PLACEHOLDER, NAN_PLACEHOLDER = 9999.0, -1.0 INF_POS, INF_NEG = float("inf"), float("-inf") @@ -126,7 +114,7 @@ def test_is_close_series_with_series( y = y.zip_with(y != NAN_PLACEHOLDER, y**0.5).zip_with(y != NULL_PLACEHOLDER, nulls) result = x.is_close(y, abs_tol=abs_tol, rel_tol=rel_tol, nans_equal=nans_equal) - if constructor_eager in NON_NULLABLE_CONSTRUCTORS: + if constructor_eager.nan_is_null: expected = [v if v is not None else nans_equal for v in expected] elif "pandas" in str(constructor_eager) and PANDAS_VERSION >= (3,): expected = [ @@ -154,7 +142,7 @@ def test_is_close_series_with_scalar( y = y.zip_with(y != NAN_PLACEHOLDER, y**0.5).zip_with(y != NULL_PLACEHOLDER, nulls) result = y.is_close(other, abs_tol=abs_tol, rel_tol=rel_tol, nans_equal=nans_equal) - if constructor_eager in NON_NULLABLE_CONSTRUCTORS: + if constructor_eager.nan_is_null: expected = [v if v is not None else False for v in expected] elif "pandas" in str(constructor_eager) and PANDAS_VERSION >= (3,): expected = [ @@ -199,7 +187,7 @@ def test_is_close_expr_with_expr( ) .sort("idx") ) - if constructor in NON_NULLABLE_CONSTRUCTORS: + if constructor.nan_is_null: expected = [v if v is not None else nans_equal for v in expected] elif "pandas" in str(constructor) and PANDAS_VERSION >= (3,): expected = [ @@ -240,7 +228,7 @@ def test_is_close_expr_with_scalar( ) .sort("idx") ) - if constructor in NON_NULLABLE_CONSTRUCTORS: + if constructor.nan_is_null: expected = [v if v is not None else False for v in expected] elif "pandas" in str(constructor) and PANDAS_VERSION >= (3,): expected = [ diff --git a/tests/expr_and_series/is_finite_test.py b/tests/expr_and_series/is_finite_test.py index eb07b2a41e..bd6dc588fd 100644 --- a/tests/expr_and_series/is_finite_test.py +++ b/tests/expr_and_series/is_finite_test.py @@ -5,21 +5,8 @@ import pytest import narwhals as nw -from tests.conftest import ( - dask_lazy_p1_constructor, - dask_lazy_p2_constructor, - modin_constructor, - pandas_constructor, -) from tests.utils import POLARS_VERSION, Constructor, ConstructorEager, assert_equal_data -NON_NULLABLE_CONSTRUCTORS = [ - pandas_constructor, - dask_lazy_p1_constructor, - dask_lazy_p2_constructor, - modin_constructor, -] - data = {"a": [float("nan"), float("inf"), 2.0, None]} @@ -77,7 +64,7 @@ def test_is_finite_column_with_null(constructor: Constructor, data: list[float]) result = df.select(nw.col("a").is_finite()) expected: dict[str, list[Any]] - if any(constructor is c for c in NON_NULLABLE_CONSTRUCTORS): + if constructor.nan_is_null: # Null values are coerced to NaN for non-nullable datatypes expected = {"a": [True, True, False]} else: diff --git a/tests/expr_and_series/is_nan_test.py b/tests/expr_and_series/is_nan_test.py index 27790e27b2..1fe5e714e6 100644 --- a/tests/expr_and_series/is_nan_test.py +++ b/tests/expr_and_series/is_nan_test.py @@ -5,21 +5,8 @@ import pytest import narwhals as nw -from tests.conftest import ( - dask_lazy_p1_constructor, - dask_lazy_p2_constructor, - modin_constructor, - pandas_constructor, -) from tests.utils import PANDAS_VERSION, Constructor, ConstructorEager, assert_equal_data -NON_NULLABLE_CONSTRUCTORS = [ - pandas_constructor, - dask_lazy_p1_constructor, - dask_lazy_p2_constructor, - modin_constructor, -] - def test_nan(constructor: Constructor) -> None: data_na = {"int": [-1, 1, None]} @@ -33,7 +20,7 @@ def test_nan(constructor: Constructor) -> None: ) expected: dict[str, list[Any]] - if any(constructor is c for c in NON_NULLABLE_CONSTRUCTORS): + if constructor.nan_is_null: # Null values are coerced to NaN for non-nullable datatypes expected = { "int": [False, False, True], @@ -70,7 +57,7 @@ def test_nan_series(constructor_eager: ConstructorEager) -> None: "float_na": df["float_na"].is_nan(), } expected: dict[str, list[Any]] - if any(constructor_eager is c for c in NON_NULLABLE_CONSTRUCTORS): + if constructor_eager.nan_is_null: # Null values are coerced to NaN for non-nullable datatypes expected = { "int": [False, False, True], diff --git a/tests/expr_and_series/list/get_test.py b/tests/expr_and_series/list/get_test.py index 52ca3386ba..338ab6197a 100644 --- a/tests/expr_and_series/list/get_test.py +++ b/tests/expr_and_series/list/get_test.py @@ -45,9 +45,8 @@ def test_get_series( pytest.skip() pytest.importorskip("pyarrow") - if ( - constructor_eager.__name__.startswith("pandas") - and "pyarrow" not in constructor_eager.__name__ + if str(constructor_eager).startswith("pandas") and "pyarrow" not in str( + constructor_eager ): df = nw.from_native(constructor_eager(data), eager_only=True) msg = re.escape("Series must be of PyArrow List type to support list namespace.") diff --git a/tests/expr_and_series/nth_test.py b/tests/expr_and_series/nth_test.py index 1249f7f2e2..86f9bfe2eb 100644 --- a/tests/expr_and_series/nth_test.py +++ b/tests/expr_and_series/nth_test.py @@ -1,17 +1,14 @@ from __future__ import annotations import re -from typing import TYPE_CHECKING, Any +from typing import Any import pytest import narwhals as nw from tests.utils import POLARS_VERSION, Constructor, assert_equal_data -if TYPE_CHECKING: - from collections.abc import Mapping - -data: Mapping[str, Any] = {"a": [1, 3, 2], "b": [4, 4, 6], "z": [7.1, 8.0, 9.0]} +data: dict[str, list[Any]] = {"a": [1, 3, 2], "b": [4, 4, 6], "z": [7.1, 8.0, 9.0]} @pytest.mark.parametrize( diff --git a/tests/expr_and_series/over_test.py b/tests/expr_and_series/over_test.py index 5f83b95e93..0cee2ed6ba 100644 --- a/tests/expr_and_series/over_test.py +++ b/tests/expr_and_series/over_test.py @@ -472,10 +472,10 @@ def test_over_quantile(constructor: Constructor, request: pytest.FixtureRequest) data = {"a": [1, 2, 3, 4, 5, 6], "b": ["x", "x", "x", "y", "y", "y"]} quantile_expr = nw.col("a").quantile(quantile=0.5, interpolation="linear") - native_frame = constructor(data) + native_frame = constructor(data).to_native() if "dask" in str(constructor): - native_frame = native_frame.repartition(npartitions=1) # type: ignore[union-attr] + native_frame = native_frame.repartition(npartitions=1) result = ( nw.from_native(native_frame) diff --git a/tests/expr_and_series/str/split_test.py b/tests/expr_and_series/str/split_test.py index b6b25cd024..f206b84e35 100644 --- a/tests/expr_and_series/str/split_test.py +++ b/tests/expr_and_series/str/split_test.py @@ -20,8 +20,7 @@ ) def test_str_split(constructor: Constructor, by: str, expected: Any) -> None: if "cudf" not in str(constructor) and ( - constructor.__name__.startswith("pandas") - and "pyarrow" not in constructor.__name__ + str(constructor).startswith("pandas") and "pyarrow" not in str(constructor) ): df = nw.from_native(constructor(data)) msg = re.escape("This operation requires a pyarrow-backed series. ") @@ -44,8 +43,8 @@ def test_str_split_series( constructor_eager: ConstructorEager, by: str, expected: Any ) -> None: if "cudf" not in str(constructor_eager) and ( - constructor_eager.__name__.startswith("pandas") - and "pyarrow" not in constructor_eager.__name__ + str(constructor_eager).startswith("pandas") + and "pyarrow" not in str(constructor_eager) ): df = nw.from_native(constructor_eager(data), eager_only=True) msg = re.escape("This operation requires a pyarrow-backed series. ") diff --git a/tests/expr_and_series/str/to_time_test.py b/tests/expr_and_series/str/to_time_test.py index fceed2688d..29af4c0225 100644 --- a/tests/expr_and_series/str/to_time_test.py +++ b/tests/expr_and_series/str/to_time_test.py @@ -21,7 +21,7 @@ def requires_time_support( Skip or mark tests as expected failures depending on backend capabilities, version, and pyarrow availability when testing Time dtype support. """ - if constructor.__name__.startswith(("pandas", "modin")): + if str(constructor).startswith(("pandas", "modin")): if PANDAS_VERSION < (2, 2, 0): pytest.skip( "pandas < 2.2.0 has no pyarrow dtype support (and therefore does not support the Time dtype)" diff --git a/tests/expr_and_series/struct_/field_test.py b/tests/expr_and_series/struct_/field_test.py index a351c31500..dd8dd26790 100644 --- a/tests/expr_and_series/struct_/field_test.py +++ b/tests/expr_and_series/struct_/field_test.py @@ -1,84 +1,53 @@ from __future__ import annotations -from typing import cast - import pytest import narwhals as nw -from tests.utils import PANDAS_VERSION, Constructor, ConstructorEager, assert_equal_data +from tests.utils import ( + DUCKDB_VERSION, + PANDAS_VERSION, + Constructor, + ConstructorEager, + assert_equal_data, +) def test_get_field_expr(request: pytest.FixtureRequest, constructor: Constructor) -> None: pytest.importorskip("pyarrow") - import pyarrow as pa - if any(backend in str(constructor) for backend in ("dask", "modin")): + if any(backend in str(constructor) for backend in ("dask",)): request.applymarker(pytest.mark.xfail) - if "pandas" in str(constructor) and PANDAS_VERSION < (2, 2, 0): + if ("pandas" in str(constructor) and PANDAS_VERSION < (2, 2, 0)) or ( + "duckdb" in str(constructor) and DUCKDB_VERSION < (1, 3, 0) + ): pytest.skip() - data = {"user": [{"id": "0", "name": "john"}, {"id": "1", "name": "jane"}]} - - df_native = constructor(data) - - if "pandas" in str(constructor): - import pandas as pd - df_native = cast("pd.DataFrame", df_native).assign( - user=pd.Series( - data["user"], - dtype=pd.ArrowDtype( - pa.struct([("id", pa.string()), ("name", pa.string())]) - ), - ) - ) - - df = nw.from_native(df_native) + data = {"id": ["0", "1"], "name": ["john", "jane"]} + expected = data.copy() + df = constructor(data, nw).select(user=nw.struct("id", "name")) result = nw.from_native(df).select( nw.col("user").struct.field("id"), nw.col("user").struct.field("name") ) - expected = {"id": ["0", "1"], "name": ["john", "jane"]} assert_equal_data(result, expected) result = nw.from_native(df).select(nw.col("user").struct.field("id").name.keep()) expected = {"user": ["0", "1"]} assert_equal_data(result, expected) -def test_get_field_series( - request: pytest.FixtureRequest, constructor_eager: ConstructorEager -) -> None: +def test_get_field_series(constructor_eager: ConstructorEager) -> None: pytest.importorskip("pyarrow") - import pyarrow as pa - if any(backend in str(constructor_eager) for backend in ("modin",)): - request.applymarker(pytest.mark.xfail) if "pandas" in str(constructor_eager) and PANDAS_VERSION < (2, 2, 0): pytest.skip() - data = {"user": [{"id": "0", "name": "john"}, {"id": "1", "name": "jane"}]} - expected = {"id": ["0", "1"], "name": ["john", "jane"]} - - _expected = expected.copy() - df_native = constructor_eager(data) - - if "pandas" in str(constructor_eager): - import pandas as pd - - df_native = cast("pd.DataFrame", df_native).assign( - user=pd.Series( - data["user"], - dtype=pd.ArrowDtype( - pa.struct([("id", pa.string()), ("name", pa.string())]) - ), - ) - ) - - df = nw.from_native(df_native, eager_only=True) + data = {"id": ["0", "1"], "name": ["john", "jane"]} + expected = data.copy() + df = constructor_eager(data, nw).select(user=nw.struct("id", "name")) result = nw.from_native(df).select( df["user"].struct.field("id"), df["user"].struct.field("name") ) - expected = {"id": ["0", "1"], "name": ["john", "jane"]} - assert_equal_data(result, _expected) + assert_equal_data(result, expected) def test_pandas_object_series() -> None: diff --git a/tests/frame/group_by_test.py b/tests/frame/group_by_test.py index 85388c6dda..08d64804b4 100644 --- a/tests/frame/group_by_test.py +++ b/tests/frame/group_by_test.py @@ -25,7 +25,7 @@ from narwhals.typing import NonNestedLiteral -data: Mapping[str, Any] = {"a": [1, 1, 3], "b": [4, 4, 6], "c": [7.0, 8.0, 9.0]} +data: dict[str, list[Any]] = {"a": [1, 1, 3], "b": [4, 4, 6], "c": [7.0, 8.0, 9.0]} def test_group_by_complex() -> None: diff --git a/tests/frame/interchange_native_namespace_test.py b/tests/frame/interchange_native_namespace_test.py index 79a92ef6c9..a2faeaa480 100644 --- a/tests/frame/interchange_native_namespace_test.py +++ b/tests/frame/interchange_native_namespace_test.py @@ -1,7 +1,5 @@ from __future__ import annotations -from typing import TYPE_CHECKING, Any - import pytest import narwhals.stable.v1 as nw_v1 @@ -9,10 +7,7 @@ pytest.importorskip("polars") import polars as pl -if TYPE_CHECKING: - from collections.abc import Mapping - -data: Mapping[str, Any] = {"a": [1, 2, 3], "b": [4.5, 6.7, 8.9], "z": ["x", "y", "w"]} +data = {"a": [1, 2, 3], "b": [4.5, 6.7, 8.9], "z": ["x", "y", "w"]} def test_interchange() -> None: @@ -60,9 +55,9 @@ def test_duckdb() -> None: pytest.importorskip("duckdb") import duckdb - df_pl = pl.DataFrame(data) # noqa: F841 + _df_pl = pl.DataFrame(data) - rel = duckdb.sql("select * from df_pl") + rel = duckdb.sql("select * from _df_pl") df = nw_v1.from_native(rel, eager_or_interchange_only=True) series = df["a"] diff --git a/tests/frame/interchange_select_test.py b/tests/frame/interchange_select_test.py index a927ba18c6..045ad257d6 100644 --- a/tests/frame/interchange_select_test.py +++ b/tests/frame/interchange_select_test.py @@ -1,16 +1,13 @@ from __future__ import annotations -from typing import TYPE_CHECKING, Any +from typing import Any import pytest import narwhals as nw import narwhals.stable.v1 as nw_v1 -if TYPE_CHECKING: - from collections.abc import Mapping - -data: Mapping[str, Any] = {"a": [1, 2, 3], "b": [4.0, 5.0, 6.1], "z": ["x", "y", "z"]} +data = {"a": [1, 2, 3], "b": [4.0, 5.0, 6.1], "z": ["x", "y", "z"]} class InterchangeDataFrame: diff --git a/tests/frame/interchange_to_arrow_test.py b/tests/frame/interchange_to_arrow_test.py index 2277d498ea..e8604f816d 100644 --- a/tests/frame/interchange_to_arrow_test.py +++ b/tests/frame/interchange_to_arrow_test.py @@ -1,15 +1,12 @@ from __future__ import annotations -from typing import TYPE_CHECKING, Any +from typing import Any import pytest import narwhals.stable.v1 as nw_v1 -if TYPE_CHECKING: - from collections.abc import Mapping - -data: Mapping[str, Any] = {"a": [1, 2, 3], "b": [4.0, 5.0, 6.1], "z": ["x", "y", "z"]} +data: dict[str, list[Any]] = {"a": [1, 2, 3], "b": [4.0, 5.0, 6.1], "z": ["x", "y", "z"]} pytest.importorskip("polars") pytest.importorskip("pyarrow") diff --git a/tests/frame/join_test.py b/tests/frame/join_test.py index 07a9f24add..51ff17c316 100644 --- a/tests/frame/join_test.py +++ b/tests/frame/join_test.py @@ -16,19 +16,7 @@ ) if TYPE_CHECKING: - from narwhals.typing import IntoDataFrame, IntoLazyFrameT, JoinStrategy - - -def from_native_lazy( - native: IntoLazyFrameT | IntoDataFrame, -) -> nw.LazyFrame[IntoLazyFrameT] | nw.LazyFrame[Any]: - """Every join test [needs to use `.lazy()` for typing]*. - - *Unless both left/right frames are of the same concrete type. - - [needs to use `.lazy()` for typing]: https://github.com/narwhals-dev/narwhals/pull/2944#discussion_r2286264815 - """ - return nw.from_native(native).lazy() + from narwhals.typing import JoinStrategy @pytest.mark.parametrize( @@ -107,8 +95,8 @@ def test_full_join( right_on: None | str | list[str], constructor: Constructor, ) -> None: - df_left = from_native_lazy(constructor(df1)) - df_right = from_native_lazy(constructor(df2)) + df_left = constructor(df1).lazy() + df_right = constructor(df2).lazy() result = df_left.join( df_right, on=on, left_on=left_on, right_on=right_on, how="full" ).sort("id", nulls_last=True) @@ -123,8 +111,8 @@ def test_full_join_duplicate( df1 = {"foo": [1, 2, 3], "val1": [1, 2, 3]} df2 = {"foo": [1, 2, 3], "foo_right": [1, 2, 3]} - df_left = from_native_lazy(constructor(df1)) - df_right = from_native_lazy(constructor(df2)) + df_left = constructor(df1).lazy() + df_right = constructor(df2).lazy() exceptions: list[type[Exception]] = [nw.exceptions.NarwhalsError] if "pyspark" in str(constructor) and "sqlframe" not in str(constructor): @@ -146,7 +134,7 @@ def test_inner_join_two_keys(constructor: Constructor) -> None: "zor ro": [7.0, 8.0, 9.0], "idx": [0, 1, 2], } - df = from_native_lazy(constructor(data)) + df = constructor(data).lazy() df_right = df result = df.join( df_right, @@ -175,7 +163,7 @@ def test_inner_join_single_key(constructor: Constructor) -> None: "zor ro": [7.0, 8.0, 9.0], "idx": [0, 1, 2], } - df = from_native_lazy(constructor(data)) + df = constructor(data).lazy() df_right = df result = df.join( df_right, left_on="antananarivo", right_on="antananarivo", how="inner" @@ -199,7 +187,7 @@ def test_cross_join(constructor: Constructor) -> None: if "duckdb" in str(constructor) and DUCKDB_VERSION < (1, 1, 4): pytest.skip() data = {"antananarivo": [1, 3, 2]} - df = from_native_lazy(constructor(data)) + df = constructor(data).lazy() result = df.join(df, how="cross").sort("antananarivo", "antananarivo_right") expected = { "antananarivo": [1, 1, 1, 2, 2, 2, 3, 3, 3], @@ -219,7 +207,7 @@ def test_suffix( constructor: Constructor, how: Literal["inner", "left"], suffix: str ) -> None: data = {"antananarivo": [1, 3, 2], "bob": [4, 4, 6], "zor ro": [7.0, 8.0, 9.0]} - df = from_native_lazy(constructor(data)) + df = constructor(data).lazy() df_right = df result = df.join( df_right, @@ -237,7 +225,7 @@ def test_cross_join_suffix(constructor: Constructor, suffix: str) -> None: if "duckdb" in str(constructor) and DUCKDB_VERSION < (1, 1, 4): pytest.skip() data = {"antananarivo": [1, 3, 2]} - df = from_native_lazy(constructor(data)) + df = constructor(data).lazy() result = df.join(df, how="cross", suffix=suffix).sort( "antananarivo", f"antananarivo{suffix}" ) @@ -287,7 +275,7 @@ def test_anti_join( expected: dict[str, list[Any]], ) -> None: data = {"antananarivo": [1, 3, 2], "bob": [4, 4, 6], "zor ro": [7.0, 8.0, 9.0]} - df = from_native_lazy(constructor(data)) + df = constructor(data).lazy() other = df.filter(filter_expr) result = df.join(other, how="anti", left_on=join_key, right_on=join_key) assert_equal_data(result, expected) @@ -325,7 +313,7 @@ def test_semi_join( expected: dict[str, list[Any]], ) -> None: data = {"antananarivo": [1, 3, 2], "bob": [4, 4, 6], "zor ro": [7.0, 8.0, 9.0]} - df = from_native_lazy(constructor(data)) + df = constructor(data).lazy() other = df.filter(filter_expr) result = df.join(other, how="semi", left_on=join_key, right_on=join_key).sort( "antananarivo" @@ -336,7 +324,7 @@ def test_semi_join( @pytest.mark.parametrize("how", ["right"]) def test_join_not_implemented(constructor: Constructor, how: str) -> None: data = {"antananarivo": [1, 3, 2], "bob": [4, 4, 6], "zor ro": [7.0, 8.0, 9.0]} - df = from_native_lazy(constructor(data)) + df = constructor(data).lazy() with pytest.raises( NotImplementedError, @@ -363,8 +351,8 @@ def test_left_join(constructor: Constructor) -> None: "co": [4.0, 5.0, 7.0], "idx": [0.0, 1.0, 2.0], } - df_left = from_native_lazy(constructor(data_left)) - df_right = from_native_lazy(constructor(data_right)) + df_left = constructor(data_left).lazy() + df_right = constructor(data_right).lazy() result = df_left.join(df_right, left_on="bob", right_on="co", how="left") result = result.sort("idx") result = result.drop("idx_right") @@ -389,8 +377,8 @@ def test_left_join(constructor: Constructor) -> None: def test_left_join_multiple_column(constructor: Constructor) -> None: data_left = {"antananarivo": [1, 2, 3], "bob": [4, 5, 6], "idx": [0, 1, 2]} data_right = {"antananarivo": [1, 2, 3], "c": [4, 5, 6], "idx": [0, 1, 2]} - df_left = from_native_lazy(constructor(data_left)) - df_right = from_native_lazy(constructor(data_right)) + df_left = constructor(data_left).lazy() + df_right = constructor(data_right).lazy() result = df_left.join( df_right, left_on=["antananarivo", "bob"], @@ -416,8 +404,8 @@ def test_left_join_overlapping_column(constructor: Constructor) -> None: "d": [1.0, 4.0, 2.0], "idx": [0.0, 1.0, 2.0], } - df_left = from_native_lazy(constructor(data_left)) - df_right = from_native_lazy(constructor(data_right)) + df_left = constructor(data_left).lazy() + df_right = constructor(data_right).lazy() result = df_left.join(df_right, left_on="bob", right_on="c", how="left").sort("idx") result = result.drop("idx_right") expected: dict[str, list[Any]] = { @@ -446,7 +434,7 @@ def test_left_join_overlapping_column(constructor: Constructor) -> None: @pytest.mark.parametrize("how", ["inner", "left", "semi", "anti"]) def test_join_keys_exceptions(constructor: Constructor, how: JoinStrategy) -> None: data = {"antananarivo": [1, 3, 2], "bob": [4, 4, 6], "zor ro": [7.0, 8.0, 9.0]} - df = from_native_lazy(constructor(data)) + df = constructor(data).lazy() with pytest.raises( ValueError, @@ -512,16 +500,27 @@ def test_joinasof_numeric( ("pandas_pyarrow" in str(constructor)) or ("pandas_nullable" in str(constructor)) ): request.applymarker(pytest.mark.xfail) - df = from_native_lazy( - constructor({"antananarivo": [1, 5, 10], "val": ["a", "b", "c"]}) - ).sort("antananarivo") - df_right = from_native_lazy( - constructor({"antananarivo": [1, 2, 3, 6, 7], "val": [1, 2, 3, 6, 7]}) - ).sort("antananarivo") - result = df.join_asof( - df_right, left_on="antananarivo", right_on="antananarivo", strategy=strategy - ) - result_on = df.join_asof(df_right, on="antananarivo", strategy=strategy) + + data_left = {"antananarivo": [1, 5, 10], "val": ["a", "b", "c"]} + data_right = {"antananarivo": [1, 2, 3, 6, 7], "val": [1, 2, 3, 6, 7]} + left_lf = constructor(data_left).lazy().sort("antananarivo") + right_lf = constructor(data_right).lazy().sort("antananarivo") + + result: nw.DataFrame[Any] | nw.LazyFrame[Any] + result_on: nw.DataFrame[Any] | nw.LazyFrame[Any] + if constructor.is_lazy: + result = left_lf.join_asof( + right_lf, left_on="antananarivo", right_on="antananarivo", strategy=strategy + ) + result_on = left_lf.join_asof(right_lf, on="antananarivo", strategy=strategy) + + else: + left_df, right_df = left_lf.collect(), right_lf.collect() + result = left_df.join_asof( + right_df, left_on="antananarivo", right_on="antananarivo", strategy=strategy + ) + result_on = left_df.join_asof(right_df, on="antananarivo", strategy=strategy) + assert_equal_data(result.sort(by="antananarivo"), expected) assert_equal_data(result_on.sort(by="antananarivo"), expected) @@ -581,7 +580,7 @@ def test_joinasof_time( request.applymarker(pytest.mark.xfail) if PANDAS_VERSION < (2, 1) and ("pandas_pyarrow" in str(constructor)): request.applymarker(pytest.mark.xfail) - df = from_native_lazy( + df = ( constructor( { "datetime": [ @@ -592,8 +591,10 @@ def test_joinasof_time( "population": [82.19, 82.66, 83.12], } ) - ).sort("datetime") - df_right = from_native_lazy( + .lazy() + .sort("datetime") + ) + df_right = ( constructor( { "datetime": [ @@ -606,7 +607,9 @@ def test_joinasof_time( "gdp": [4164, 4411, 4566, 4696, 4827], } ) - ).sort("datetime") + .lazy() + .sort("datetime") + ) result = df.join_asof( df_right, left_on="datetime", right_on="datetime", strategy=strategy ) @@ -622,7 +625,7 @@ def test_joinasof_by(constructor: Constructor, request: pytest.FixtureRequest) - ("pandas_pyarrow" in str(constructor)) or ("pandas_nullable" in str(constructor)) ): request.applymarker(pytest.mark.xfail) - df = from_native_lazy( + df = ( constructor( { "antananarivo": [1, 5, 7, 10], @@ -630,12 +633,16 @@ def test_joinasof_by(constructor: Constructor, request: pytest.FixtureRequest) - "c": [9, 2, 1, 1], } ) - ).sort("antananarivo") - df_right = from_native_lazy( + .lazy() + .sort("antananarivo") + ) + df_right = ( constructor( {"antananarivo": [1, 4, 5, 8], "bob": ["D", "D", "A", "F"], "d": [1, 3, 4, 1]} ) - ).sort("antananarivo") + .lazy() + .sort("antananarivo") + ) result = df.join_asof(df_right, on="antananarivo", by_left="bob", by_right="bob") result_by = df.join_asof(df_right, on="antananarivo", by="bob") expected = { @@ -657,12 +664,16 @@ def test_joinasof_suffix( ("pandas_pyarrow" in str(constructor)) or ("pandas_nullable" in str(constructor)) ): request.applymarker(pytest.mark.xfail) - df = from_native_lazy( + df = ( constructor({"antananarivo": [1, 5, 10], "val": ["a", "b", "c"]}) - ).sort("antananarivo") - df_right = from_native_lazy( + .lazy() + .sort("antananarivo") + ) + df_right = ( constructor({"antananarivo": [1, 2, 3, 6, 7], "val": [1, 2, 3, 6, 7]}) - ).sort("antananarivo") + .lazy() + .sort("antananarivo") + ) result = df.join_asof( df_right, left_on="antananarivo", right_on="antananarivo", suffix="_y" ) @@ -675,7 +686,7 @@ def test_joinasof_not_implemented( constructor: Constructor, strategy: Literal["backward", "forward"] ) -> None: data = {"antananarivo": [1, 3, 2], "bob": [4, 4, 6], "zor ro": [7.0, 8.0, 9.0]} - df = from_native_lazy(constructor(data)) + df = constructor(data).lazy() with pytest.raises( NotImplementedError, @@ -688,7 +699,7 @@ def test_joinasof_not_implemented( def test_joinasof_keys_exceptions(constructor: Constructor) -> None: data = {"antananarivo": [1, 3, 2], "bob": [4, 4, 6], "zor ro": [7.0, 8.0, 9.0]} - df = from_native_lazy(constructor(data)) + df = constructor(data).lazy() with pytest.raises( ValueError, @@ -754,13 +765,16 @@ def test_joinasof_by_exceptions( message: str, ) -> None: data = {ON: [1, 3, 2], BY: [4, 4, 6], "zor ro": [7.0, 8.0, 9.0]} - df = nw.from_native(constructor(data)) - if isinstance(df, nw.LazyFrame): + frame = constructor(data).lazy() + + if constructor.is_lazy: with pytest.raises(ValueError, match=message): - df.join_asof(df, on=on, by_left=by_left, by_right=by_right, by=by) + frame.join_asof(frame, on=on, by_left=by_left, by_right=by_right, by=by) else: with pytest.raises(ValueError, match=message): - df.join_asof(df, on=on, by_left=by_left, by_right=by_right, by=by) + frame.collect().join_asof( + frame.collect(), on=on, by_left=by_left, by_right=by_right, by=by + ) def test_join_duplicate_column_names( @@ -777,7 +791,7 @@ def test_join_duplicate_column_names( ): request.applymarker(pytest.mark.xfail) data = {"a": [1, 2, 3, 4, 5], "b": [6, 6, 6, 6, 6]} - df = nw.from_native(constructor(data)) + lf = constructor(data).lazy() if any( x in str(constructor) for x in ("pandas", "pandas[pyarrow]", "pandas[nullable]", "dask") @@ -796,10 +810,12 @@ def test_join_duplicate_column_names( request.applymarker(pytest.mark.xfail) else: exception = nw.exceptions.DuplicateError - if isinstance(df, nw.LazyFrame): + + if constructor.is_lazy: with pytest.raises(exception): # pyrefly: ignore[unbound-name] - df.join(df, on=["a"]).join(df, on=["a"]).collect() + lf.join(lf, on=["a"]).join(lf, on=["a"]).collect() else: + df = lf.collect() with pytest.raises(exception): # pyrefly: ignore[unbound-name] df.join(df, on=["a"]).join(df, on=["a"]) @@ -875,8 +891,8 @@ def test_join_on_null_values( data_left = {**keys, "x": [1, 2, 3, 4]} data_right = {**keys, "y": [1.2, 3.4, 5.6, 7.8]} - df_left = from_native_lazy(constructor(data_left)) - df_right = from_native_lazy(constructor(data_right)) + df_left = constructor(data_left).lazy() + df_right = constructor(data_right).lazy() on = None if how == "cross" else list(keys) sort_by = ["a", "x", "y"] if how in {"cross", "full"} else ["a", "x"] @@ -896,8 +912,8 @@ def test_join_on_null_values_single_key( # incorrectly matched `null == null` here (the two-key case in # `test_join_on_null_values` only triggers it on 0.20.21). # See https://github.com/narwhals-dev/narwhals/issues/3307 - df_left = from_native_lazy(constructor({"a": [1, 2, None], "x": [10, 20, 30]})) - df_right = from_native_lazy(constructor({"a": [1, None], "y": [1.2, 3.4]})) + df_left = constructor({"a": [1, 2, None], "x": [10, 20, 30]}).lazy() + df_right = constructor({"a": [1, None], "y": [1.2, 3.4]}).lazy() result = df_left.join(df_right, on="a", how=how).sort("a", nulls_last=True) assert_equal_data(result, expected) @@ -920,8 +936,8 @@ def test_full_join_with_overlapping_non_key_columns_and_nulls( "right_only": [100, 200, 300], } - df_left = from_native_lazy(constructor(data_left)) - df_right = from_native_lazy(constructor(data_right)) + df_left = constructor(data_left).lazy() + df_right = constructor(data_right).lazy() result = df_left.join(df_right, on="id", how="full", suffix="_r").sort( "id", nulls_last=True diff --git a/tests/frame/lazy_test.py b/tests/frame/lazy_test.py index 9e671c68d2..658a61c68b 100644 --- a/tests/frame/lazy_test.py +++ b/tests/frame/lazy_test.py @@ -9,13 +9,8 @@ import narwhals as nw from narwhals._utils import Implementation from narwhals.dependencies import get_cudf, get_modin -from tests.utils import ( - DUCKDB_VERSION, - PANDAS_VERSION, - assert_equal_data, - pyspark_session, - sqlframe_session, -) +from narwhals.testing.constructors import pyspark_session, sqlframe_session +from tests.utils import DUCKDB_VERSION, PANDAS_VERSION, assert_equal_data if TYPE_CHECKING: from narwhals._typing import LazyAllowed, SparkLike diff --git a/tests/frame/sample_test.py b/tests/frame/sample_test.py index b86ddaee1d..8db480e02c 100644 --- a/tests/frame/sample_test.py +++ b/tests/frame/sample_test.py @@ -19,9 +19,7 @@ def test_sample_n(constructor_eager: ConstructorEager) -> None: def test_sample_fraction(constructor_eager: ConstructorEager) -> None: - df = nw.from_native( - constructor_eager({"a": [1, 2, 3, 4], "b": ["x", "y", "x", "y"]}), eager_only=True - ) + df = constructor_eager({"a": [1, 2, 3, 4], "b": ["x", "y", "x", "y"]}) result_expr = df.sample(fraction=0.5).shape expected_expr = (2, 2) @@ -30,11 +28,11 @@ def test_sample_fraction(constructor_eager: ConstructorEager) -> None: def test_sample_with_seed(constructor_eager: ConstructorEager) -> None: size, n = 100, 10 - df = nw.from_native(constructor_eager({"a": range(size)}), eager_only=True) + df = constructor_eager({"a": range(size)}) r1 = nw.to_native(df.sample(n=n, seed=123)) r2 = nw.to_native(df.sample(n=n, seed=123)) r3 = nw.to_native(df.sample(n=n, seed=42)) - assert r1.equals(r2) # type: ignore[attr-defined] - assert not r1.equals(r3) # type: ignore[attr-defined] + assert r1.equals(r2) + assert not r1.equals(r3) diff --git a/tests/frame/schema_test.py b/tests/frame/schema_test.py index 892559b99e..0246904493 100644 --- a/tests/frame/schema_test.py +++ b/tests/frame/schema_test.py @@ -9,7 +9,7 @@ import narwhals as nw from narwhals.exceptions import PerformanceWarning -from tests.utils import PANDAS_VERSION, POLARS_VERSION, ConstructorPandasLike +from tests.utils import PANDAS_VERSION, POLARS_VERSION if TYPE_CHECKING: from collections.abc import Callable, Sequence @@ -23,7 +23,7 @@ IntoPandasSchema, IntoPolarsSchema, ) - from tests.utils import Constructor, ConstructorEager + from tests.utils import Constructor, ConstructorEager, ConstructorPandasLike TimeUnit: TypeAlias = Literal["ns", "us"] @@ -581,7 +581,7 @@ def origin_pandas_like( "d": [5.3, 4.99], "e": [datetime(2006, 1, 1), datetime(2001, 9, 3)], } - return constructor_pandas_like(data).dtypes.to_dict() + return constructor_pandas_like(data).to_native().dtypes.to_dict() # type: ignore[no-any-return] @pytest.fixture @@ -591,8 +591,8 @@ def origin_pandas_like_pyarrow( if PANDAS_VERSION < (1, 5): pytest.skip(reason="pandas too old for `pyarrow`") name_pandas_like = {"pandas_pyarrow_constructor", "modin_pyarrow_constructor"} - if constructor_pandas_like.__name__ not in name_pandas_like: - pytest.skip(f"{constructor_pandas_like.__name__!r} is not pandas_like_pyarrow") + if str(constructor_pandas_like) not in name_pandas_like: + pytest.skip(f"{constructor_pandas_like!s} is not pandas_like_pyarrow") data = { "a": [2, 1], "b": ["hello", "hi"], @@ -606,7 +606,7 @@ def origin_pandas_like_pyarrow( df_nw = nw.from_native(df_pd).with_columns( nw.col("f").cast(nw.Date()), nw.col("g").cast(nw.Time()) ) - return df_nw.to_native().dtypes.to_dict() + return df_nw.to_native().dtypes.to_dict() # type: ignore[no-any-return] def test_schema_from_polars( diff --git a/tests/frame/to_native_test.py b/tests/frame/to_native_test.py index 0ef0ae885a..cdb03e2675 100644 --- a/tests/frame/to_native_test.py +++ b/tests/frame/to_native_test.py @@ -10,7 +10,7 @@ def test_to_native(constructor: Constructor) -> None: data = {"a": [1, 3, 2], "b": [4, 4, 6], "z": [7.1, 8.0, 9.0]} - df_raw = constructor(data) + df_raw = constructor(data).to_native() df = nw.from_native(df_raw) assert isinstance(df.to_native(), df_raw.__class__) diff --git a/tests/frame/to_pandas_test.py b/tests/frame/to_pandas_test.py index 473b685c19..bcdcc10fc3 100644 --- a/tests/frame/to_pandas_test.py +++ b/tests/frame/to_pandas_test.py @@ -7,7 +7,6 @@ pytest.importorskip("pandas") import pandas as pd -import narwhals as nw from tests.utils import PANDAS_VERSION if TYPE_CHECKING: @@ -19,11 +18,10 @@ def test_convert_pandas(constructor_eager: ConstructorEager) -> None: pytest.importorskip("pyarrow") data = {"a": [1, 3, 2], "b": [4, 4, 6], "z": [7.0, 8.0, 9.0]} - df_raw = constructor_eager(data) - result = nw.from_native(df_raw, eager_only=True).to_pandas() + result = constructor_eager(data).to_pandas() - if constructor_eager.__name__.startswith("pandas"): - expected = cast("pd.DataFrame", constructor_eager(data)) + if str(constructor_eager).startswith("pandas"): + expected = cast("pd.DataFrame", constructor_eager(data).to_native()) elif "modin_pyarrow" in str(constructor_eager): expected = pd.DataFrame(data).convert_dtypes(dtype_backend="pyarrow") else: diff --git a/tests/frame/to_polars_test.py b/tests/frame/to_polars_test.py index 60ca653f32..89d4a65b2a 100644 --- a/tests/frame/to_polars_test.py +++ b/tests/frame/to_polars_test.py @@ -1,14 +1,13 @@ from __future__ import annotations -from typing import TYPE_CHECKING, Any +from typing import TYPE_CHECKING import pytest import narwhals as nw if TYPE_CHECKING: - from collections.abc import Mapping - + from narwhals.testing.typing import Data from tests.utils import ConstructorEager pytest.importorskip("polars") @@ -20,7 +19,7 @@ def test_convert_polars(constructor_eager: ConstructorEager) -> None: pytest.importorskip("pyarrow") from polars.testing import assert_frame_equal - data: Mapping[str, Any] = {"a": [1, 3, 2], "b": [4, 4, 6], "z": [7.1, 8.0, 9.0]} + data: Data = {"a": [1, 3, 2], "b": [4, 4, 6], "z": [7.1, 8.0, 9.0]} df_raw = constructor_eager(data) result = nw.from_native(df_raw).to_polars() diff --git a/tests/hypothesis/getitem_test.py b/tests/hypothesis/getitem_test.py index 115154ea61..c18f860872 100644 --- a/tests/hypothesis/getitem_test.py +++ b/tests/hypothesis/getitem_test.py @@ -7,23 +7,24 @@ from hypothesis import assume, given import narwhals as nw -from tests.conftest import pandas_constructor, pyarrow_table_constructor +from narwhals.testing.constructors import get_backend_constructor from tests.utils import assert_equal_data if TYPE_CHECKING: - from collections.abc import Callable, Sequence + from collections.abc import Sequence - from narwhals.typing import IntoDataFrame + from narwhals.testing.typing import DataFrameConstructor pytest.importorskip("pandas") pytest.importorskip("polars") import polars as pl -@pytest.fixture(params=[pandas_constructor, pyarrow_table_constructor], scope="module") -def pandas_or_pyarrow_constructor( - request: pytest.FixtureRequest, -) -> Callable[[Any], IntoDataFrame]: +@pytest.fixture( + params=[get_backend_constructor("pandas"), get_backend_constructor("pyarrow")], + scope="module", +) +def pandas_or_pyarrow_constructor(request: pytest.FixtureRequest) -> DataFrameConstructor: return request.param # type: ignore[no-any-return] @@ -117,7 +118,9 @@ def tuple_selector(draw: st.DrawFn) -> tuple[Any, Any]: @given(selector=st.one_of(single_selector, tuple_selector())) @pytest.mark.slow -def test_getitem(pandas_or_pyarrow_constructor: Any, selector: Any) -> None: +def test_getitem( + pandas_or_pyarrow_constructor: DataFrameConstructor, selector: Any +) -> None: """Compare __getitem__ against polars.""" # TODO(PR - clean up): documenting current differences # These assume(...) lines each filter out a known difference. @@ -125,7 +128,7 @@ def test_getitem(pandas_or_pyarrow_constructor: Any, selector: Any) -> None: # NotImplementedError: Slicing with step is not supported on PyArrow tables assume( not ( - pandas_or_pyarrow_constructor is pyarrow_table_constructor + pandas_or_pyarrow_constructor.is_pyarrow and isinstance(selector, slice) and selector.step is not None ) @@ -134,7 +137,7 @@ def test_getitem(pandas_or_pyarrow_constructor: Any, selector: Any) -> None: # NotImplementedError: Slicing with step is not supported on PyArrow tables assume( not ( - pandas_or_pyarrow_constructor is pyarrow_table_constructor + pandas_or_pyarrow_constructor.is_pyarrow and isinstance(selector, tuple) and ( (isinstance(selector[0], slice) and selector[0].step is not None) @@ -155,7 +158,7 @@ def test_getitem(pandas_or_pyarrow_constructor: Any, selector: Any) -> None: # rows/columns sides. return - df_other = nw.from_native(pandas_or_pyarrow_constructor(TEST_DATA)) + df_other = pandas_or_pyarrow_constructor(TEST_DATA, nw) result_other = df_other[cast("Any", selector)] if isinstance(result_polars, nw.Series): diff --git a/tests/ibis_test.py b/tests/ibis_test.py index 14a93c8ef8..a03ef07fba 100644 --- a/tests/ibis_test.py +++ b/tests/ibis_test.py @@ -1,30 +1,14 @@ from __future__ import annotations -from typing import TYPE_CHECKING, Any - import pytest import narwhals as nw - -if TYPE_CHECKING: - import ibis - import polars as pl - - from tests.utils import Constructor -else: - ibis = pytest.importorskip("ibis") - pl = pytest.importorskip("polars") - - -@pytest.fixture -def ibis_constructor() -> Constructor: - def func(data: dict[str, Any]) -> ibis.Table: - df = pl.DataFrame(data) - return ibis.memtable(df) - - return func +from narwhals.testing.constructors import get_backend_constructor -def test_from_native(ibis_constructor: Constructor) -> None: - df = nw.from_native(ibis_constructor({"a": [1, 2, 3], "b": [4, 5, 6]})) +def test_from_native() -> None: + ibis_constructor = get_backend_constructor("ibis") + for requirement in ibis_constructor.requirements: + pytest.importorskip(requirement) + df = ibis_constructor({"a": [1, 2, 3], "b": [4, 5, 6]}, nw) assert df.columns == ["a", "b"] diff --git a/tests/modern_polars/method_chaining_test.py b/tests/modern_polars/method_chaining_test.py index 611f85973e..ba7a06b894 100644 --- a/tests/modern_polars/method_chaining_test.py +++ b/tests/modern_polars/method_chaining_test.py @@ -38,10 +38,7 @@ def test_split_list_get(request: pytest.FixtureRequest, constructor: Constructor if PANDAS_VERSION < (2, 2): pytest.skip() pytest.importorskip("pyarrow") - if ( - constructor.__name__.startswith("pandas") - and "pyarrow" not in constructor.__name__ - ): + if str(constructor).startswith("pandas") and "pyarrow" not in str(constructor): df = nw.from_native(constructor(data)) msg = re.escape("This operation requires a pyarrow-backed series. ") with pytest.raises(TypeError, match=msg): diff --git a/tests/namespace_test.py b/tests/namespace_test.py index 03aa8df37c..6f9a406b7e 100644 --- a/tests/namespace_test.py +++ b/tests/namespace_test.py @@ -74,7 +74,7 @@ def test_namespace_from_backend_name(backend: BackendName) -> None: def test_namespace_from_native_object(constructor: Constructor) -> None: data = {"a": [1, 2, 3], "b": [4, 5, 6]} - frame = constructor(data) + frame = constructor(data, nw).to_native() namespace = Namespace.from_native_object(frame) nw_frame = nw.from_native(frame) assert namespace.implementation == nw_frame.implementation diff --git a/tests/preserve_pandas_like_columns_name_attr_test.py b/tests/preserve_pandas_like_columns_name_attr_test.py index 70e7d06e24..546b388f67 100644 --- a/tests/preserve_pandas_like_columns_name_attr_test.py +++ b/tests/preserve_pandas_like_columns_name_attr_test.py @@ -7,13 +7,11 @@ import narwhals as nw if TYPE_CHECKING: - from collections.abc import Callable - - import pandas as pd + from tests.utils import Constructor def test_ops_preserve_column_index_name( - constructor: Callable[..., pd.DataFrame], request: pytest.FixtureRequest + constructor: Constructor, request: pytest.FixtureRequest ) -> None: if not any(x in str(constructor) for x in ("pandas", "modin", "cudf", "dask")): pytest.skip( @@ -24,7 +22,7 @@ def test_ops_preserve_column_index_name( request.applymarker(pytest.mark.xfail) data = {"a": [1, 3, 2], "b": [4, 4, 6], "z": [7.0, 8.0, 9.0]} - df_native = constructor(data) + df_native = constructor(data).to_native() df_native.columns.name = "foo" df = nw.from_native(df_native) diff --git a/tests/read_scan_test.py b/tests/read_scan_test.py index 532502691c..372779f93e 100644 --- a/tests/read_scan_test.py +++ b/tests/read_scan_test.py @@ -6,13 +6,8 @@ import pytest import narwhals as nw -from tests.utils import ( - PANDAS_VERSION, - Constructor, - assert_equal_data, - pyspark_session, - sqlframe_session, -) +from narwhals.testing.constructors import pyspark_session, sqlframe_session +from tests.utils import PANDAS_VERSION, Constructor, assert_equal_data pytest.importorskip("polars") pytest.importorskip("pyarrow") @@ -31,7 +26,7 @@ IOSourceKind: TypeAlias = Literal["str", "Path", "PathLike"] -data: Mapping[str, Any] = {"a": [1, 2, 3], "b": [4.5, 6.7, 8.9], "z": ["x", "y", "w"]} +data: dict[str, list[Any]] = {"a": [1, 2, 3], "b": [4.5, 6.7, 8.9], "z": ["x", "y", "w"]} skipif_pandas_lt_1_5 = pytest.mark.skipif( PANDAS_VERSION < (1, 5), reason="too old for pyarrow" ) diff --git a/tests/series_only/hist_test.py b/tests/series_only/hist_test.py index 183c0a13ff..7db42c31bc 100644 --- a/tests/series_only/hist_test.py +++ b/tests/series_only/hist_test.py @@ -11,11 +11,14 @@ import narwhals as nw from narwhals.exceptions import ComputeError -from tests.utils import POLARS_VERSION, ConstructorEager, assert_equal_data +from tests.utils import POLARS_VERSION, assert_equal_data if TYPE_CHECKING: from collections.abc import Sequence + from narwhals.testing.typing import DataFrameConstructor + + rnd = Random(0) # noqa: S311 data: dict[str, Any] = { @@ -43,7 +46,8 @@ param_include_breakpoint = pytest.mark.parametrize( "include_breakpoint", [True, False], ids=["breakpoint-True", "breakpoint-False"] ) -param_library = pytest.mark.parametrize("library", ["pandas", "polars", "pyarrow"]) +param_name = pytest.mark.parametrize("name", ["pandas", "polars[eager]", "pyarrow"]) + SHIFT_BINS_BY = 10 """shift bins property""" @@ -63,34 +67,14 @@ ], ids=str, ) -@param_library def test_hist_bin( - library: str, + nw_dataframe: DataFrameConstructor, bins: list[float], expected: Sequence[float], *, include_breakpoint: bool, ) -> None: - constructor_eager: ConstructorEager - pytest.importorskip(library) - if library == "pandas": - import pandas as pd - - constructor_eager = pd.DataFrame - elif library == "polars": - import polars as pl - - constructor_eager = pl.DataFrame - else: - import pyarrow as pa - - pytest.importorskip("numpy") - - constructor_eager = pa.table - - df = nw.from_native(constructor_eager(data)).with_columns( - float=nw.col("int").cast(nw.Float64) - ) + df = nw_dataframe(data, nw).with_columns(float=nw.col("int").cast(nw.Float64)) expected_full = {"count": expected} if include_breakpoint: expected_full = {"breakpoint": bins[1:], **expected_full} @@ -115,10 +99,8 @@ def test_hist_bin( assert_equal_data(result, expected_full) # missing/nan results - df = nw.from_native( - constructor_eager( - {"has_nan": [float("nan"), *data["int"]], "has_null": [None, *data["int"]]} - ) + df = nw_dataframe( + {"has_nan": [float("nan"), *data["int"]], "has_null": [None, *data["int"]]}, nw ) expected_full = {"count": expected} if include_breakpoint: @@ -130,25 +112,13 @@ def test_hist_bin( @pytest.mark.parametrize("params", counts_and_expected) @param_include_breakpoint -@param_library def test_hist_count( - library: str, *, params: dict[str, Any], include_breakpoint: bool + nw_dataframe: DataFrameConstructor, + *, + params: dict[str, Any], + include_breakpoint: bool, ) -> None: - if library == "pandas": - pytest.importorskip("pandas") - import pandas as pd - - constructor_eager: Any = pd.DataFrame - elif library == "polars": - pl = pytest.importorskip("polars") - constructor_eager = pl.DataFrame - else: - pa = pytest.importorskip("pyarrow") - pytest.importorskip("numpy") - constructor_eager = pa.table - df = nw.from_native(constructor_eager(data)).with_columns( - float=nw.col("int").cast(nw.Float64) - ) + df = nw_dataframe(data, nw).with_columns(float=nw.col("int").cast(nw.Float64)) bin_count = params["bin_count"] expected_bins = params["expected_bins"] @@ -168,10 +138,8 @@ def test_hist_count( assert result["count"].sum() == df[col].count() # missing/nan results - df = nw.from_native( - constructor_eager( - {"has_nan": [float("nan"), *data["int"]], "has_null": [None, *data["int"]]} - ) + df = nw_dataframe( + {"has_nan": [float("nan"), *data["int"]], "has_null": [None, *data["int"]]}, nw ) for col in df.columns: @@ -186,22 +154,9 @@ def test_hist_count( ) -@param_library -def test_hist_count_no_spread(library: str) -> None: - if library == "pandas": - pytest.importorskip("pandas") - import pandas as pd - - constructor_eager: Any = pd.DataFrame - elif library == "polars": - pl = pytest.importorskip("polars") - constructor_eager = pl.DataFrame - else: - pa = pytest.importorskip("pyarrow") - pytest.importorskip("numpy") - constructor_eager = pa.table +def test_hist_count_no_spread(nw_dataframe: DataFrameConstructor) -> None: data = {"all_zero": [0, 0, 0], "all_non_zero": [5, 5, 5]} - df = nw.from_native(constructor_eager(data)) + df = nw_dataframe(data, nw) result = df["all_zero"].hist(bin_count=4, include_breakpoint=True) expected = {"breakpoint": [-0.25, 0.0, 0.25, 0.5], "count": [0, 3, 0, 0]} @@ -229,23 +184,12 @@ def test_hist_bin_and_bin_count() -> None: @param_include_breakpoint -@param_library -def test_hist_no_data(library: str, *, include_breakpoint: bool) -> None: - if library == "pandas": - pytest.importorskip("pandas") - import pandas as pd - - constructor_eager: Any = pd.DataFrame - elif library == "polars": - pl = pytest.importorskip("polars") - constructor_eager = pl.DataFrame - else: - pa = pytest.importorskip("pyarrow") - pytest.importorskip("numpy") - constructor_eager = pa.table - s = nw.from_native(constructor_eager({"values": []})).select( - nw.col("values").cast(nw.Float64) - )["values"] +def test_hist_no_data( + nw_dataframe: DataFrameConstructor, *, include_breakpoint: bool +) -> None: + s = nw_dataframe({"values": []}, nw).select(nw.col("values").cast(nw.Float64))[ + "values" + ] for bin_count in [1, 10]: result = s.hist(bin_count=bin_count, include_breakpoint=include_breakpoint) assert len(result) == bin_count @@ -262,21 +206,8 @@ def test_hist_no_data(library: str, *, include_breakpoint: bool) -> None: assert result["count"].sum() == 0 -@param_library -def test_hist_small_bins(library: str) -> None: - if library == "pandas": - pytest.importorskip("pandas") - import pandas as pd - - constructor_eager: Any = pd.DataFrame - elif library == "polars": - pl = pytest.importorskip("polars") - constructor_eager = pl.DataFrame - else: - pa = pytest.importorskip("pyarrow") - pytest.importorskip("numpy") - constructor_eager = pa.table - s = nw.from_native(constructor_eager({"values": [1, 2, 3]})) +def test_hist_small_bins(nw_dataframe: DataFrameConstructor) -> None: + s = nw_dataframe({"values": [1, 2, 3]}, nw) result = s["values"].hist(bins=None, bin_count=None) assert len(result) == 10 @@ -284,11 +215,11 @@ def test_hist_small_bins(library: str) -> None: s["values"].hist(bins=[1, 3], bin_count=4) -def test_hist_non_monotonic(constructor_eager: ConstructorEager) -> None: - if "cudf" in str(constructor_eager): +def test_hist_non_monotonic(nw_dataframe: DataFrameConstructor) -> None: + if "cudf" in str(nw_dataframe): # TODO(unassigned): too many spurious failures, report and revisit return - df = nw.from_native(constructor_eager({"int": [0, 1, 2, 3, 4, 5, 6]})) + df = nw_dataframe({"int": [0, 1, 2, 3, 4, 5, 6]}, nw) with pytest.raises(ComputeError, match="monotonic"): df["int"].hist(bins=[5, 0, 2]) @@ -323,33 +254,17 @@ def test_hist_non_monotonic(constructor_eager: ConstructorEager) -> None: POLARS_VERSION < (1, 27), reason="polars cannot be used for compatibility checks since narwhals aims to mimic polars>=1.27 behavior", ) -@param_library @pytest.mark.filterwarnings("ignore:invalid value encountered in cast:RuntimeWarning") @pytest.mark.slow def test_hist_bin_hypotheis( - library: str, data: list[float], bin_deltas: list[float] + nw_dataframe: DataFrameConstructor, data: list[float], bin_deltas: list[float] ) -> None: - if library == "pandas": - pytest.importorskip("pandas") - import pandas as pd - - constructor_eager: Any = pd.DataFrame - elif library == "polars": - pl = pytest.importorskip("polars") - constructor_eager = pl.DataFrame - else: - pa = pytest.importorskip("pyarrow") - pytest.importorskip("numpy") - constructor_eager = pa.table pytest.importorskip("polars") import polars as pl - df = nw.from_native(constructor_eager({"values": data})).select( - nw.col("values").cast(nw.Float64) - ) - df_bins_native = constructor_eager({"bins": bin_deltas}) + df = nw_dataframe({"values": data}, nw).select(nw.col("values").cast(nw.Float64)) bins = ( - nw.from_native(df_bins_native, eager_only=True) + nw_dataframe({"bins": bin_deltas}, nw) .get_column("bins") .cast(nw.Float64) .cum_sum() @@ -376,28 +291,17 @@ def test_hist_bin_hypotheis( reason="polars cannot be used for compatibility checks since narwhals aims to mimic polars>=1.27 behavior", ) @pytest.mark.filterwarnings("ignore:invalid value encountered in cast:RuntimeWarning") -@param_library @pytest.mark.slow def test_hist_count_hypothesis( - library: str, data: list[float], bin_count: int, request: pytest.FixtureRequest + nw_dataframe: DataFrameConstructor, + data: list[float], + bin_count: int, + request: pytest.FixtureRequest, ) -> None: pytest.importorskip("polars") import polars as pl - if library == "pandas": - pytest.importorskip("pandas") - import pandas as pd - - constructor_eager: Any = pd.DataFrame - elif library == "polars": - constructor_eager = pl.DataFrame - else: - pa = pytest.importorskip("pyarrow") - pytest.importorskip("numpy") - constructor_eager = pa.table - df = nw.from_native(constructor_eager({"values": data})).select( - nw.col("values").cast(nw.Float64) - ) + df = nw_dataframe({"values": data}, nw).select(nw.col("values").cast(nw.Float64)) try: result = df["values"].hist(bin_count=bin_count, include_breakpoint=True) @@ -418,9 +322,7 @@ def test_hist_count_hypothesis( if expected[ "count" - ].sum() != expected_data.is_not_nan().sum() and "polars" not in str( - constructor_eager - ): + ].sum() != expected_data.is_not_nan().sum() and "polars" not in str(nw_dataframe): request.applymarker(pytest.mark.xfail) assert_equal_data(result, expected.to_dict(as_series=False)) diff --git a/tests/series_only/is_sorted_test.py b/tests/series_only/is_sorted_test.py index 046669aac0..4efddf542f 100644 --- a/tests/series_only/is_sorted_test.py +++ b/tests/series_only/is_sorted_test.py @@ -16,7 +16,7 @@ ) def test_is_sorted( constructor_eager: ConstructorEager, - input_data: str, + input_data: list[int], descending: bool, # noqa: FBT001 expected: bool, # noqa: FBT001 ) -> None: diff --git a/tests/series_only/to_native_test.py b/tests/series_only/to_native_test.py index 350d81764d..c2a7ad5ecb 100644 --- a/tests/series_only/to_native_test.py +++ b/tests/series_only/to_native_test.py @@ -11,7 +11,7 @@ def test_to_native(constructor_eager: ConstructorEager) -> None: - orig_series = constructor_eager({"a": data})["a"] # type: ignore[index] + orig_series = constructor_eager({"a": data})["a"].to_native() nw_series = nw.from_native(constructor_eager({"a": data}), eager_only=True)["a"] result = nw_series.to_native() assert isinstance(result, orig_series.__class__) diff --git a/tests/testing/assert_frame_equal_test.py b/tests/testing/assert_frame_equal_test.py index c1b3b4e357..3e9d453592 100644 --- a/tests/testing/assert_frame_equal_test.py +++ b/tests/testing/assert_frame_equal_test.py @@ -12,8 +12,8 @@ from tests.utils import PANDAS_VERSION if TYPE_CHECKING: - from narwhals.typing import IntoSchema - from tests.conftest import Data + from narwhals.testing.typing import Data + from narwhals.typing import IntoFrame, IntoSchema from tests.utils import Constructor, ConstructorEager @@ -24,7 +24,7 @@ def _assertion_error(detail: str) -> pytest.RaisesExc: def test_check_narwhals_objects(constructor: Constructor) -> None: """Test that a type error is raised if the input is not a Narwhals object.""" - frame = constructor({"a": [1, 2, 3]}) + frame: IntoFrame = constructor({"a": [1, 2, 3]}).to_native() msg = re.escape( "Expected `narwhals.DataFrame` or `narwhals.LazyFrame` instance, found" ) @@ -40,11 +40,11 @@ def test_implementation_mismatch() -> None: import pandas as pd import pyarrow as pa + left = nw.from_native(pd.DataFrame({"a": [1]})) + right = nw.from_native(pa.table({"a": [1]})) + with _assertion_error("implementation mismatch"): - assert_frame_equal( - nw.from_native(pd.DataFrame({"a": [1]})), - nw.from_native(pa.table({"a": [1]})), # type: ignore[type-var] # pyright: ignore[reportArgumentType] - ) + assert_frame_equal(left, right) # type: ignore[type-var] # pyright: ignore[reportArgumentType] def test_check_same_input_type(constructor_eager: ConstructorEager) -> None: diff --git a/tests/testing/assert_series_equal_test.py b/tests/testing/assert_series_equal_test.py index 778a314c80..f42ef1de73 100644 --- a/tests/testing/assert_series_equal_test.py +++ b/tests/testing/assert_series_equal_test.py @@ -14,8 +14,8 @@ from collections.abc import Callable from typing import TypeAlias + from narwhals.testing.typing import Data from narwhals.typing import IntoSchema, IntoSeriesT - from tests.conftest import Data from tests.utils import ConstructorEager SetupFn: TypeAlias = Callable[[nw.Series[Any]], tuple[nw.Series[Any], nw.Series[Any]]] @@ -407,7 +407,7 @@ def test_categorical_as_str( "left": ["beluga", "dolphin", "narwhal", "orca"], "right": ["unicorn", "orca", "narwhal", "orca"], } - frame = nw.from_native(constructor_eager(data), eager_only=True) + frame = constructor_eager(data, namespace=nw) left = frame["left"].cast(nw.Categorical())[2:] right = frame["right"].cast(nw.Categorical())[2:] diff --git a/tests/testing/conftest.py b/tests/testing/conftest.py index a41d4fdce4..0ff5e9935f 100644 --- a/tests/testing/conftest.py +++ b/tests/testing/conftest.py @@ -8,8 +8,8 @@ import narwhals as nw if TYPE_CHECKING: + from narwhals.testing.typing import Data from narwhals.typing import IntoSchema - from tests.conftest import Data @pytest.fixture(scope="module") diff --git a/tests/testing/constructors_test.py b/tests/testing/constructors_test.py new file mode 100644 index 0000000000..20b8b31af2 --- /dev/null +++ b/tests/testing/constructors_test.py @@ -0,0 +1,124 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING + +import pytest + +import narwhals as nw +from narwhals._utils import Implementation +from narwhals.testing.constructors import ( + available_backends, + get_backend_constructor, + prepare_backends, +) + +if TYPE_CHECKING: + from typing import TypeAlias + + PropertyName: TypeAlias = str + TrueNames: TypeAlias = set[str] + FalseNames: TypeAlias = set[str] + + +def test_eager_returns_eager_frame() -> None: + c = get_backend_constructor("pandas") + if not c.is_available: + pytest.skip() + + df = c({"x": [1, 2, 3]}, nw) + assert isinstance(df, nw.DataFrame) + + +def test_lazy_returns_lazy_frame() -> None: + c = get_backend_constructor("polars[lazy]") + if not c.is_available: + pytest.skip() + + lf = c({"x": [1, 2, 3]}, nw) + assert isinstance(lf, nw.LazyFrame) + + +_IS_PROPERTY_CASES: list[tuple[PropertyName, TrueNames, FalseNames]] = [ + ("is_pandas", {"pandas", "pandas[nullable]", "pandas[pyarrow]"}, {"polars[eager]"}), + ("is_modin", {"modin", "modin[pyarrow]"}, {"pandas"}), + ("is_cudf", {"cudf"}, {"pandas"}), + ("is_pandas_like", {"pandas", "modin", "cudf"}, {"polars[eager]"}), + ("is_polars", {"polars[eager]", "polars[lazy]"}, {"pandas"}), + ("is_pyarrow", {"pyarrow"}, {"pandas"}), + ("is_dask", {"dask"}, {"pandas"}), + ("is_duckdb", {"duckdb"}, {"pandas"}), + ("is_pyspark", {"pyspark", "pyspark[connect]"}, {"pandas"}), + ("is_sqlframe", {"sqlframe"}, {"pandas"}), + ("is_ibis", {"ibis"}, {"pandas"}), + ("is_spark_like", {"pyspark", "sqlframe", "pyspark[connect]"}, {"pandas"}), + ("is_lazy", {"polars[lazy]", "dask", "duckdb"}, {"pandas"}), + ("needs_pyarrow", {"pyarrow", "duckdb", "ibis"}, {"pandas"}), + ("nan_is_null", {"pandas", "modin", "dask"}, {"polars[eager]"}), +] + + +@pytest.mark.parametrize(("prop", "true_names", "false_names"), _IS_PROPERTY_CASES) +def test_constructor_is_properties( + prop: str, true_names: TrueNames, false_names: FalseNames +) -> None: + for name in true_names: + c = get_backend_constructor(name) + assert getattr(c, prop), f"{name}.{prop} should be True" + for name in false_names: + c = get_backend_constructor(name) + assert not getattr(c, prop), f"{name}.{prop} should be False" + + +def test_constructor_implementation() -> None: + assert get_backend_constructor("pandas").implementation is Implementation.PANDAS + assert ( + get_backend_constructor("pandas[pyarrow]").implementation is Implementation.PANDAS + ) + assert ( + get_backend_constructor("polars[eager]").implementation is Implementation.POLARS + ) + assert ( + get_backend_constructor("pyspark[connect]").implementation + is Implementation.PYSPARK_CONNECT + ) + + +def test_constructor_dunder() -> None: + c1 = get_backend_constructor("pandas") + c2 = get_backend_constructor("pandas") + assert c1.identifier == "pandas" + assert c1 == c2 + assert hash(c1) == hash(c2) + assert c1 != get_backend_constructor("polars[eager]") + assert c1 != "not a constructor" + + +def test_get_backend_constructor_invalid_name() -> None: + with pytest.raises(ValueError, match="Unknown constructor"): + get_backend_constructor("not_a_backend") + + +@pytest.mark.parametrize( + ("include", "exclude", "expected"), + [ + (None, None, available_backends()), + (None, ["pandas"], available_backends() - {"pandas"}), + (["pandas", "polars[eager]"], None, {"pandas", "polars[eager]"}), + (["pandas", "polars[eager]"], ["pandas"], {"polars[eager]"}), + ([], None, frozenset()), + ], +) +def test_prepare_backends( + include: list[str] | None, exclude: list[str] | None, expected: frozenset[str] +) -> None: + for name in (*(include or ()), *(exclude or ())): + if not get_backend_constructor(name).is_available: + pytest.skip(f"{name} not installed") + result = prepare_backends(include=include, exclude=exclude) + assert {c.name for c in result} == expected + + +@pytest.mark.parametrize("kwarg", ["include", "exclude"]) +def test_prepare_backends_unknown_name_raises(kwarg: str) -> None: + with pytest.raises(ValueError, match="not known constructors"): + prepare_backends(**{kwarg: ["not_a_backend"]}) diff --git a/tests/testing/plugin_test.py b/tests/testing/plugin_test.py new file mode 100644 index 0000000000..e8b4ba5ff6 --- /dev/null +++ b/tests/testing/plugin_test.py @@ -0,0 +1,95 @@ +from __future__ import annotations + +from unittest import mock + +import pytest + +from narwhals.testing.pytest_plugin import _default_backend_ids + +pytest_plugins = ["pytester"] + + +def test_constructor_eager_fixture_runs_for_each_backend( + pytester: pytest.Pytester, +) -> None: + pytest.importorskip("pandas") + pytest.importorskip("polars") + pytest.importorskip("pyarrow") + + pytester.makeconftest("") + pytester.makepyfile(""" + import narwhals as nw + from narwhals.testing.typing import DataFrameConstructor + + def test_shape(nw_dataframe: DataFrameConstructor) -> None: + df = nw_dataframe({"x": [1, 2, 3]}, namespace=nw) + assert df.shape == (3, 1) + """) + result = pytester.runpytest_subprocess( + "-v", "-p", "no:randomly", "--nw-backends=pandas,polars[eager],pyarrow" + ) + result.assert_outcomes(passed=3) + result.stdout.fnmatch_lines( + [ + "*test_shape?pandas?*", + "*test_shape?polars[[]eager[]]?*", + "*test_shape?pyarrow?*", + ] + ) + + +def test_constructor_fixture_includes_lazy_backends(pytester: pytest.Pytester) -> None: + pytest.importorskip("pandas") + pytest.importorskip("polars") + pytest.importorskip("duckdb") + + pytester.makeconftest("") + pytester.makepyfile(""" + import narwhals as nw + from narwhals.testing.typing import FrameConstructor + + def test_columns(nw_frame: FrameConstructor) -> None: + df = nw_frame({"x": [1, 2, 3]}, namespace=nw) + assert df.collect_schema().names() == ["x"] + """) + result = pytester.runpytest_subprocess( + "-v", "--nw-backends=pandas,polars[lazy],duckdb" + ) + result.assert_outcomes(passed=3) + + +def test_external_constructor_disables_parametrisation(pytester: pytest.Pytester) -> None: + pytester.makeconftest("") + pytester.makepyfile(""" + from narwhals.testing.typing import DataFrameConstructor + + def test_unparam(nw_dataframe: DataFrameConstructor) -> None: + pass + """) + result = pytester.runpytest_subprocess("--use-external-nw-backend") + # Without external parametrisation in place, the fixture is missing. + result.assert_outcomes(errors=1) + + +def test_multiple_frame_fixtures_raises(pytester: pytest.Pytester) -> None: + pytester.makeconftest("") + pytester.makepyfile(""" + from narwhals.testing.typing import DataFrameConstructor, LazyFrameConstructor + + def test_too_many( + nw_dataframe: DataFrameConstructor, nw_lazyframe: LazyFrameConstructor + ) -> None: + pass + """) + result = pytester.runpytest_subprocess() + result.assert_outcomes(errors=1) + result.stdout.fnmatch_lines( + ["*A test may only request one narwhals frame fixture, got:*"] + ) + + +def test_default_backends_env_var() -> None: + with mock.patch.dict( + "os.environ", {"NARWHALS_DEFAULT_BACKENDS": "pandas,polars[eager]"} + ): + assert _default_backend_ids() == ["pandas", "polars[eager]"] diff --git a/tests/translate/from_native_test.py b/tests/translate/from_native_test.py index 9f87b5220b..6c72eb9fa6 100644 --- a/tests/translate/from_native_test.py +++ b/tests/translate/from_native_test.py @@ -30,7 +30,7 @@ import narwhals as nw from narwhals._utils import Version -from tests.conftest import sqlframe_pyspark_lazy_constructor +from narwhals.testing.constructors import get_backend_constructor from tests.utils import Constructor, maybe_get_modin_df if TYPE_CHECKING: @@ -294,10 +294,10 @@ def test_eager_only_lazy_dask(eager_only: Any, context: Any) -> None: def test_series_only_sqlframe() -> None: # pragma: no cover pytest.importorskip("sqlframe") - df = sqlframe_pyspark_lazy_constructor(data) + df = get_backend_constructor("sqlframe")(data, nw).to_native() with pytest.raises(TypeError, match="Cannot only use `series_only`"): - nw.from_native(df, series_only=True) # pyright: ignore[reportArgumentType, reportCallIssue] # pyrefly: ignore[no-matching-overload] + nw.from_native(df, series_only=True) # type: ignore[call-overload] # pyrefly: ignore[no-matching-overload] @pytest.mark.parametrize( @@ -315,7 +315,7 @@ def test_series_only_sqlframe() -> None: # pragma: no cover ) def test_eager_only_sqlframe(eager_only: Any, context: Any) -> None: # pragma: no cover pytest.importorskip("sqlframe") - df = sqlframe_pyspark_lazy_constructor(data) + df = get_backend_constructor("sqlframe")(data, nw).to_native() with context: res = nw.from_native(df, eager_only=eager_only) @@ -509,7 +509,7 @@ def test_from_native_roundtrip_identity(native: Any, kwds: dict[str, Any]) -> No def test_pyspark_connect_deps_2517(constructor: Constructor) -> None: # pragma: no cover if not ("pyspark" in str(constructor) and "sqlframe" not in str(constructor)): - # Only run this slow test if `--constructors=pyspark` is passed + # Only run this slow test if `--nw-backends=pyspark` is passed return pytest.importorskip("pyspark") # Don't delete this! It's crucial for the test that @@ -528,7 +528,7 @@ def test_eager_only_pass_through_main(constructor: Constructor) -> None: if not any(s in str(constructor) for s in ("pyspark", "dask", "ibis", "duckdb")): pytest.skip(reason="Non lazy or polars") - df = constructor(data) + df = constructor(data).to_native() r1 = nw.from_native(df, eager_only=False, pass_through=False) r2 = nw.from_native(df, eager_only=False, pass_through=True) @@ -539,7 +539,7 @@ def test_eager_only_pass_through_main(constructor: Constructor) -> None: assert not isinstance(r3, nw.LazyFrame) with pytest.raises(TypeError, match=r"Cannot.+use.+eager_only"): - nw.from_native(df, eager_only=True, pass_through=False) # type: ignore[type-var] + nw.from_native(df, eager_only=True, pass_through=False) def test_from_native_lazyframe_exhaustive() -> None: # noqa: PLR0914, PLR0915 diff --git a/tests/translate/get_native_namespace_test.py b/tests/translate/get_native_namespace_test.py index 821443ea64..5a15069ed2 100644 --- a/tests/translate/get_native_namespace_test.py +++ b/tests/translate/get_native_namespace_test.py @@ -76,7 +76,7 @@ def test_native_namespace_frame(constructor: Constructor) -> None: def test_native_namespace_series(constructor_eager: ConstructorEager) -> None: - constructor_name = constructor_eager.__name__ + constructor_name = str(constructor_eager) expected_namespace = _get_expected_namespace(constructor_name=constructor_name) diff --git a/tests/utils.py b/tests/utils.py index 4e4b4e133f..ffa167d5f7 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -4,10 +4,9 @@ import os import sys import warnings -from collections.abc import Callable from datetime import date, datetime from pathlib import Path -from typing import TYPE_CHECKING, Any, cast +from typing import TYPE_CHECKING, Any import pytest @@ -16,16 +15,25 @@ from narwhals.dependencies import get_pandas from narwhals.translate import from_native +# TODO(FBruzzesi): Replace these aliases once all the test suite migrates to *FrameConstructor's +from tests.conftest import ( + _PatchedDataFrameConstructor as ConstructorEager, + _PatchedDataFrameConstructor as ConstructorPandasLike, + _PatchedFrameConstructor as Constructor, +) + if TYPE_CHECKING: from collections.abc import Mapping, Sequence from typing import TypeAlias import pandas as pd - from pyspark.sql import SparkSession - from sqlframe.duckdb import DuckDBSession - from narwhals._native import NativeLazyFrame - from narwhals.typing import Frame, IntoDataFrame, TimeUnit + from narwhals.typing import Frame, TimeUnit + +# TODO(FBruzzesi): Remove these aliases once all the test suite migrates to *FrameConstructor's +# NOTE: Explicitly exported otherwise mypy will raise an [attr-defined] error for each file +# importing them from `tests.utils` rather than `narwhals.testing.typing` directly. +__all__ = ("Constructor", "ConstructorEager", "ConstructorPandasLike") def get_module_version_as_tuple(module_name: str) -> tuple[int, ...]: @@ -45,11 +53,6 @@ def get_module_version_as_tuple(module_name: str) -> tuple[int, ...]: PYSPARK_VERSION: tuple[int, ...] = get_module_version_as_tuple("pyspark") CUDF_VERSION: tuple[int, ...] = get_module_version_as_tuple("cudf") -Constructor: TypeAlias = Callable[[Any], "NativeLazyFrame | IntoDataFrame"] -ConstructorEager: TypeAlias = Callable[[Any], "IntoDataFrame"] -ConstructorLazy: TypeAlias = Callable[[Any], "NativeLazyFrame"] -ConstructorPandasLike: TypeAlias = Callable[[Any], "pd.DataFrame"] - NestedOrEnumDType: TypeAlias = "nw.List | nw.Array | nw.Struct | nw.Enum" """`DType`s which **cannot** be used as bare types.""" @@ -176,34 +179,6 @@ def assert_equal_hash(left: Any, right: Any) -> None: ) -def sqlframe_session() -> DuckDBSession: - from sqlframe.duckdb import DuckDBSession - - # NOTE: `__new__` override inferred by `pyright` only - # https://github.com/eakmanrq/sqlframe/blob/772b3a6bfe5a1ffd569b7749d84bea2f3a314510/sqlframe/base/session.py#L181-L184 - return cast("DuckDBSession", DuckDBSession()) # type: ignore[redundant-cast] - - -def pyspark_session() -> SparkSession: # pragma: no cover - if is_spark_connect := os.environ.get("SPARK_CONNECT", None): - from pyspark.sql.connect.session import SparkSession - else: - from pyspark.sql import SparkSession - builder = cast("SparkSession.Builder", SparkSession.builder).appName("unit-tests") - builder = ( - builder.remote(f"sc://localhost:{os.environ.get('SPARK_PORT', '15002')}") - if is_spark_connect - else builder.master("local[1]").config("spark.ui.enabled", "false") - ) - return ( - # Don't remove pyrefly-ignore, needed in CI when pyspark is installed. - builder.config("spark.default.parallelism", "1") # pyrefly: ignore[bad-return] - .config("spark.sql.shuffle.partitions", "2") - .config("spark.sql.session.timeZone", "UTC") - .getOrCreate() - ) - - def maybe_get_modin_df(df_pandas: pd.DataFrame) -> Any: # pragma: no cover """Convert a pandas DataFrame to a Modin DataFrame if Modin is available.""" try: @@ -233,10 +208,7 @@ def is_pyarrow_windows_no_tzdata(constructor: Constructor, /) -> bool: def uses_pyarrow_backend(constructor: Constructor | ConstructorEager) -> bool: """Checks if the pandas-like constructor uses pyarrow backend.""" - return constructor.__name__ in { - "pandas_pyarrow_constructor", - "modin_pyarrow_constructor", - } + return str(constructor) in {"pandas_pyarrow_constructor", "modin_pyarrow_constructor"} def maybe_collect(df: Frame) -> Frame: diff --git a/tests/v1_test.py b/tests/v1_test.py index 21c0ce1826..b014693470 100644 --- a/tests/v1_test.py +++ b/tests/v1_test.py @@ -318,11 +318,11 @@ def test_cast_to_enum_v1( ): request.applymarker(pytest.mark.xfail) - df_native = constructor({"a": ["a", "b"]}) + df = constructor({"a": ["a", "b"]}, nw_v1) msg = re.escape("Converting to Enum is not supported in narwhals.stable.v1") with pytest.raises(NotImplementedError, match=msg): - nw_v1.from_native(df_native).select(nw_v1.col("a").cast(nw_v1.Enum)) # type: ignore[arg-type] + df.select(nw_v1.col("a").cast(nw_v1.Enum)) # type: ignore[arg-type] def test_v1_ordered_categorical_pandas() -> None: @@ -459,7 +459,7 @@ def test_with_row_index(constructor: Constructor) -> None: pytest.skip() data = {"abc": ["foo", "bars"], "xyz": [100, 200], "const": [42, 42]} - frame = nw_v1.from_native(constructor(data)) + frame = constructor(data, nw_v1) msg = "Cannot pass `order_by`" context = ( @@ -469,7 +469,7 @@ def test_with_row_index(constructor: Constructor) -> None: ) with context: - result = frame.with_row_index() + result = frame.with_row_index() # type: ignore[call-arg] expected = {"index": [0, 1], **data} assert_equal_data(result, expected) @@ -888,7 +888,7 @@ def test_is_frame() -> None: def test_with_version(constructor: Constructor) -> None: - lf = nw_v1.from_native(constructor({"a": [1, 2]})).lazy() + lf = constructor({"a": [1, 2]}, nw_v1).lazy() assert isinstance(lf, nw_v1.LazyFrame) assert lf._compliant_frame._with_version(Version.MAIN)._version is Version.MAIN @@ -897,7 +897,7 @@ def test_with_version(constructor: Constructor) -> None: @pytest.mark.parametrize("offset", [1, 2]) def test_gather_every(constructor_eager: ConstructorEager, n: int, offset: int) -> None: data = {"a": list(range(10))} - df_v1 = nw_v1.from_native(constructor_eager(data)) + df_v1 = constructor_eager(data, nw_v1) result = df_v1.gather_every(n=n, offset=offset) expected = {"a": data["a"][offset::n]} assert_equal_data(result, expected) @@ -1157,7 +1157,7 @@ def test_series_from_iterable( def test_mode_single_expr(constructor_eager: ConstructorEager) -> None: data = {"a": [1, 1, 2, 2, 3], "b": [1, 2, 3, 3, 4]} - df = nw_v1.from_native(constructor_eager(data)) + df = constructor_eager(data, nw_v1) result = df.select(nw_v1.col("a").mode()).sort("a") expected = {"a": [1, 2]} assert_equal_data(result, expected) @@ -1165,7 +1165,7 @@ def test_mode_single_expr(constructor_eager: ConstructorEager) -> None: def test_mode_series(constructor_eager: ConstructorEager) -> None: data = {"a": [1, 1, 2, 2, 3], "b": [1, 2, 3, 3, 4]} - series = nw_v1.from_native(constructor_eager(data), eager_only=True)["a"] + series = constructor_eager(data, nw_v1)["a"] result = series.mode().sort() expected = {"a": [1, 2]} assert_equal_data({"a": result}, expected) @@ -1174,7 +1174,7 @@ def test_mode_series(constructor_eager: ConstructorEager) -> None: def test_mode_different_lengths(constructor_eager: ConstructorEager) -> None: if "polars" in str(constructor_eager) and POLARS_VERSION < (1, 10): pytest.skip() - df = nw_v1.from_native(constructor_eager({"a": [1, 1, 2], "b": [4, 5, 6]})) + df = constructor_eager({"a": [1, 1, 2], "b": [4, 5, 6]}, nw_v1) with pytest.raises(ShapeError): df.select(nw_v1.col("a", "b").mode()) @@ -1197,7 +1197,7 @@ def test_any_value_expr(constructor: Constructor, request: pytest.FixtureRequest "b": [1, 2, 3, 4, 5, 6], "c": [None, None, 1, None, 2, None], } - df = nw_v1.from_native(constructor(data)) + df = constructor(data, nw_v1) with pytest.warns(NarwhalsUnstableWarning): df.select(nw_v1.col("a", "b").any_value()) @@ -1205,7 +1205,7 @@ def test_any_value_expr(constructor: Constructor, request: pytest.FixtureRequest def test_any_value_series(constructor_eager: ConstructorEager) -> None: data = {"a": [1, 1, 1, 2, 2, 3]} - df = nw_v1.from_native(constructor_eager(data)) + df = constructor_eager(data, nw_v1) with pytest.warns(NarwhalsUnstableWarning): df["a"].any_value() diff --git a/tests/v2_test.py b/tests/v2_test.py index 7a1903425c..d33ae97edb 100644 --- a/tests/v2_test.py +++ b/tests/v2_test.py @@ -347,7 +347,7 @@ def fun2(self, df: Any) -> Any: # pragma: no cover def test_with_version(constructor: Constructor) -> None: - lf = nw_v2.from_native(constructor({"a": [1, 2]})).lazy() + lf = constructor({"a": [1, 2]}, nw_v2).lazy() assert isinstance(lf, nw_v2.LazyFrame) assert lf._compliant_frame._with_version(Version.MAIN)._version is Version.MAIN @@ -503,7 +503,7 @@ def test_series_from_iterable( def test_mode_single_expr(constructor_eager: ConstructorEager) -> None: data = {"a": [1, 1, 2, 2, 3], "b": [1, 2, 3, 3, 4]} - df = nw_v2.from_native(constructor_eager(data)) + df = constructor_eager(data, nw_v2) result = df.select(nw_v2.col("a").mode()).sort("a") expected = {"a": [1, 2]} assert_equal_data(result, expected) @@ -511,7 +511,7 @@ def test_mode_single_expr(constructor_eager: ConstructorEager) -> None: def test_mode_series(constructor_eager: ConstructorEager) -> None: data = {"a": [1, 1, 2, 2, 3], "b": [1, 2, 3, 3, 4]} - series = nw_v2.from_native(constructor_eager(data), eager_only=True)["a"] + series = constructor_eager(data, nw_v2)["a"] result = series.mode().sort() expected = {"a": [1, 2]} assert_equal_data({"a": result}, expected) @@ -520,7 +520,7 @@ def test_mode_series(constructor_eager: ConstructorEager) -> None: def test_mode_different_lengths(constructor_eager: ConstructorEager) -> None: if "polars" in str(constructor_eager) and POLARS_VERSION < (1, 10): pytest.skip() - df = nw_v2.from_native(constructor_eager({"a": [1, 1, 2], "b": [4, 5, 6]})) + df = constructor_eager({"a": [1, 1, 2], "b": [4, 5, 6]}, nw_v2) with pytest.raises(ShapeError): df.select(nw_v2.col("a", "b").mode()) @@ -535,7 +535,7 @@ def test_any_value_expr(constructor: Constructor, request: pytest.FixtureRequest "b": [1, 2, 3, 4, 5, 6], "c": [None, None, 1, None, 2, None], } - df = nw_v2.from_native(constructor(data)) + df = constructor(data, nw_v2) with pytest.warns(NarwhalsUnstableWarning): df.select(nw_v2.col("a", "b").any_value()) @@ -543,7 +543,7 @@ def test_any_value_expr(constructor: Constructor, request: pytest.FixtureRequest def test_any_value_series(constructor_eager: ConstructorEager) -> None: data = {"a": [1, 1, 1, 2, 2, 3]} - df = nw_v2.from_native(constructor_eager(data)) + df = constructor_eager(data, nw_v2) with pytest.warns(NarwhalsUnstableWarning): df["a"].any_value() diff --git a/tpch/tests/conftest.py b/tpch/tests/conftest.py index d98c4b401a..499571a567 100644 --- a/tpch/tests/conftest.py +++ b/tpch/tests/conftest.py @@ -36,13 +36,6 @@ def pytest_configure(config: pytest.Config) -> None: def pytest_addoption(parser: pytest.Parser) -> None: - from tests.conftest import DEFAULT_CONSTRUCTORS - - parser.addoption( - "--constructors", - default=DEFAULT_CONSTRUCTORS, - help="", - ) parser.addoption( "--scale-factor", default=constants.SCALE_FACTOR_DEFAULT, diff --git a/utils/import_check.py b/utils/import_check.py index d292b40790..d97b488509 100644 --- a/utils/import_check.py +++ b/utils/import_check.py @@ -27,6 +27,20 @@ "_polars": {"polars"}, "_duckdb": {"duckdb"}, "_ibis": {"ibis", "ibis._", "ibis.expr.types"}, + # narwhals.testing constructors deliberately lazy-import every supported + # backend inside `__call__` so test fixtures can build native frames. + "testing": { + "cudf", + "dask", + "dask.dataframe", + "duckdb", + "ibis", + "modin", + "pandas", + "polars", + "pyarrow", + "pyspark", + }, } diff --git a/utils/sort_api_reference.py b/utils/sort_api_reference.py index 1b417ed63a..243ccbcd6d 100644 --- a/utils/sort_api_reference.py +++ b/utils/sort_api_reference.py @@ -42,7 +42,7 @@ def sort_list(match: re.Match[str]) -> str: PATH = Path("docs") / "api-reference" -FILES_TO_SKIP = {"dtypes", "typing"} +FILES_TO_SKIP = {"dtypes", "typing", "testing"} ret = max( sort_members_in_markdown(file_path=file_path) diff --git a/uv.lock b/uv.lock index 2146dd9fc9..075689eb8b 100644 --- a/uv.lock +++ b/uv.lock @@ -244,23 +244,23 @@ wheels = [ [[package]] name = "cachetools" -version = "7.1.3" +version = "7.1.4" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/8f/c1/67cfb86aa21144796ff51068326d467fbef8ee42f8d08a3a8a926106cf0c/cachetools-7.1.3.tar.gz", hash = "sha256:135cfe944bc3c1e805505f65dae0bef375a2f96261171ab66c79ef77d0bda39d", size = 45780, upload-time = "2026-05-18T18:21:03.819Z" } +sdist = { url = "https://files.pythonhosted.org/packages/f4/8b/0d3945a13955303b81272f759a0331e54c5c793da455e6f5706b89d2639c/cachetools-7.1.4.tar.gz", hash = "sha256:437f55a4e0c1b01a4f3077cc470e6991d47430970e36fbcb77e2be0df4fc1cd6", size = 40085, upload-time = "2026-05-21T22:40:43.376Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/68/52/8ff5c1a3b2e821ced9b2998fba3ee29aa4525c0bf51e5ee55dd6f61a4ed5/cachetools-7.1.3-py3-none-any.whl", hash = "sha256:9876787e2346e20584d5cca236cb5d49d04e7193de91646f230725b2e1e8b804", size = 16763, upload-time = "2026-05-18T18:21:02.386Z" }, + { url = "https://files.pythonhosted.org/packages/8c/7b/1fc1c09cc0756cf25861a3be10565915953876da48bb228fb9a672b20a42/cachetools-7.1.4-py3-none-any.whl", hash = "sha256:323dc4127934744db5b54eb4924482d7edafbf9554e820d1531c2e08c0e4ef54", size = 16761, upload-time = "2026-05-21T22:40:41.845Z" }, ] [[package]] name = "click" -version = "8.4.0" +version = "8.4.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "colorama", marker = "sys_platform == 'win32' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing')" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/23/e4/796662cd90cf80e3a363c99db2b88e0e394b988a575f60a17e16440cd011/click-8.4.0.tar.gz", hash = "sha256:638f1338fe1235c8f4e008e4a8a254fb5c5fbdcbb40ece3c9142ebb78e792973", size = 350843, upload-time = "2026-05-17T00:47:58.425Z" } +sdist = { url = "https://files.pythonhosted.org/packages/9b/98/518d8e5081007684232226f475082b30087d0f585e8457db087298259f49/click-8.4.1.tar.gz", hash = "sha256:918b5633eddf6b41c32d4f454bf0de810065c74e3f7dbf8ee5452f8be88d3e96", size = 353007, upload-time = "2026-05-22T04:08:37.769Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ee/ae/8e92f8058baf87f6c7d86ee7e457668690195cc77efedb8d3797a06e3940/click-8.4.0-py3-none-any.whl", hash = "sha256:40c50b7c6c6adac2823d411041ec84f3f103f1b280d5e9ce0d7f998995832f81", size = 116147, upload-time = "2026-05-17T00:47:56.842Z" }, + { url = "https://files.pythonhosted.org/packages/c7/0d/67e5b4109ea4a837e80daa87c2c696711955e40449a97e8926672534def2/click-8.4.1-py3-none-any.whl", hash = "sha256:482be17c6991b8c19c5429a1e995d9b0efdbb63172824c41f99965dc0ade8ec2", size = 116639, upload-time = "2026-05-22T04:08:35.26Z" }, ] [[package]] @@ -295,151 +295,146 @@ wheels = [ [[package]] name = "coverage" -version = "7.14.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/23/7f/d0720730a397a999ffc0fd3f5bebef347338e3a47b727da66fbb228e2ff2/coverage-7.14.0.tar.gz", hash = "sha256:057a6af2f160a85384cde4ab36f0d2777bae1057bae255f95413cdd382aa5c74", size = 919489, upload-time = "2026-05-10T18:02:31.397Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/59/9d/7c83ef51c3eb495f10010094e661833588b7709946da634c8b66520b97c7/coverage-7.14.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:84c32d90bf4537f0e7b4dec9aaa9a938fb8205136b9d2ecf4d7629d5262dc075", size = 219668, upload-time = "2026-05-10T17:59:23.106Z" }, - { url = "https://files.pythonhosted.org/packages/24/34/898546aefbd28f0af131201d0dc852c9e976f817bd7d5bfb8dc4e02863bb/coverage-7.14.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:7c843572c605ab51cfdb5c6b5f2586e2a8467c0d28eca4bdef4ec70c5fecbd82", size = 220192, upload-time = "2026-05-10T17:59:26.095Z" }, - { url = "https://files.pythonhosted.org/packages/df/4a/b457c88aca72b0df13a98167ebd5d947135ccd9881ea88ce6a570e13aa9b/coverage-7.14.0-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0c451757d3fa2603354fdc789b5e58a0e327a117c370a40e3476ba4eabab228c", size = 246932, upload-time = "2026-05-10T17:59:27.806Z" }, - { url = "https://files.pythonhosted.org/packages/b5/d9/92600e89486fd074c50f0117422b2c9592c3e144e2f25bd5ac0bc62bc7a0/coverage-7.14.0-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:3fd43f0616e765ab78d069cf8358def7363957a45cee446d65c502dcfeea7893", size = 248762, upload-time = "2026-05-10T17:59:29.479Z" }, - { url = "https://files.pythonhosted.org/packages/0d/e1/9ea1eb9c311da7f15853559dc1d9d82bef88ecd3e59fbeb51f16bc2ffa91/coverage-7.14.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:731e535b1498b27d13594a0527a79b0510867b0ad891532be41cb883f2128e20", size = 250625, upload-time = "2026-05-10T17:59:31.33Z" }, - { url = "https://files.pythonhosted.org/packages/a5/03/57afca1b8106f8549a5329139315041fe166d6099bd9381346b9430dfbd1/coverage-7.14.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c7492f2d493b976941c7ca050f273cbda2f43c381124f7586a3e3c16d1804fec", size = 252539, upload-time = "2026-05-10T17:59:32.692Z" }, - { url = "https://files.pythonhosted.org/packages/57/5e/2e9fc63c9928119c1dbae02222be51407d3e7ebac5811ebbda4af3557795/coverage-7.14.0-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dc38367eaa2abb1b766ac333142bce7655335a73537f5c8b75aaa89c2b987757", size = 247636, upload-time = "2026-05-10T17:59:34.599Z" }, - { url = "https://files.pythonhosted.org/packages/f0/e2/0b7898cda21041cc67546e19b80ba66cbbb47cbece52a76a5904de6a3aaf/coverage-7.14.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0a951308cde22cf77f953955a754d04dccb57fe3bb8e345d685778ed9fc1632a", size = 248666, upload-time = "2026-05-10T17:59:36.232Z" }, - { url = "https://files.pythonhosted.org/packages/d6/e3/d33662a2fdaef23229c15921f39c84ec38441f3069ba26e134ed402c833b/coverage-7.14.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:fab3877e4ebb06bd9d4d4d00ee53309ee5478e66873c66a382272e3ee33eb7ea", size = 246670, upload-time = "2026-05-10T17:59:38.029Z" }, - { url = "https://files.pythonhosted.org/packages/99/b2/533942c3bfbf6770b5c32d7f2ff029fe013dba31f3fe8b45cabbb250365e/coverage-7.14.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:b812eb847b19876ebf33fb6c4f11819af05ab6050b0bfa1bc53412ae81779adb", size = 250484, upload-time = "2026-05-10T17:59:39.974Z" }, - { url = "https://files.pythonhosted.org/packages/d8/00/15acbad83a96de13c73831486c7627bfed73dfaec53b04e4a6315edf3fd8/coverage-7.14.0-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:d9c8ef6ed820c433de075657d72dda1f89a2984955e58b8a75feb3f184250218", size = 246942, upload-time = "2026-05-10T17:59:41.659Z" }, - { url = "https://files.pythonhosted.org/packages/70/db/cef0228de493f2c740c760a9057a61d00c6849480073b70a75b87c7d4bab/coverage-7.14.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:d128b1bba9361fbaaf6a19e179e6cfd6a9103ce0c0555876f72780acc93efd85", size = 247544, upload-time = "2026-05-10T17:59:43.471Z" }, - { url = "https://files.pythonhosted.org/packages/77/a0/d9ef8e148f3025c2ae8401d77cda1502b6d2a4d8102603a8af31460aedb6/coverage-7.14.0-cp310-cp310-win32.whl", hash = "sha256:65f267ca1370726ec2c1aa38bbe4df9a71a740f22878d2d4bf59d71a4cd8d323", size = 222285, upload-time = "2026-05-10T17:59:44.908Z" }, - { url = "https://files.pythonhosted.org/packages/85/c0/30c454c7d3cf47b2805d4e06f12443f5eece8a5d030d3b0350e7b74ecb49/coverage-7.14.0-cp310-cp310-win_amd64.whl", hash = "sha256:b34ece8065914f938ed7f2c5872bb865336977a52919149846eac3744327267a", size = 223215, upload-time = "2026-05-10T17:59:46.779Z" }, - { url = "https://files.pythonhosted.org/packages/fc/e4/649c8d4f7f1709b6dbfc474358aa1bba02f67bcd52e2fec291a5014006cd/coverage-7.14.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6a78e2a9d9c5e3b8d4ab9b9d28c985ea66fced0a7d7c2aec1f216e03a2011480", size = 219795, upload-time = "2026-05-10T17:59:48.198Z" }, - { url = "https://files.pythonhosted.org/packages/7f/8d/46692d24b3f395d4cbf17bfcc57136b4f2f9c0c0df864b0bddfc1d71a014/coverage-7.14.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a1816c505187592dcd1c5a5f226601a549f70365fbd00930ac88b0c225b76bb4", size = 220299, upload-time = "2026-05-10T17:59:49.683Z" }, - { url = "https://files.pythonhosted.org/packages/12/c2/a40f5cb295bbcbb697a76947a56081c494c61950366294ee426ffe261099/coverage-7.14.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d8e1762f0e9cbc26ec315471e7b47855218e833cd5a032d706fbf43845d878c7", size = 250721, upload-time = "2026-05-10T17:59:51.494Z" }, - { url = "https://files.pythonhosted.org/packages/fd/35/202235eb5c3c14c212462cd91d61b7386bf8fc44bc7a77f4742d2a69174b/coverage-7.14.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9336e23e8bb3a3925398261385e2a1533957d3e760e91070dcb0e98bfa514eed", size = 252633, upload-time = "2026-05-10T17:59:53.244Z" }, - { url = "https://files.pythonhosted.org/packages/bb/80/5f596e8995785124ee191c42535664c5e62c65995b66f4ca21e28ae04c81/coverage-7.14.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cd1169b2230f9cbe9c638ba38022ed7a2b1e641cc07f7cea0365e4be2a74980", size = 254743, upload-time = "2026-05-10T17:59:55.021Z" }, - { url = "https://files.pythonhosted.org/packages/1e/6d/0d178825be2350f0adb27984d0aa7cf84bbdab201f6fb926b535d23a8f5f/coverage-7.14.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d1bb3543b58fea74d2cd1abc4054cc927e4724687cb4560cd2ed88d2c7d820c0", size = 256700, upload-time = "2026-05-10T17:59:56.511Z" }, - { url = "https://files.pythonhosted.org/packages/19/5b/9e549c2f6e9dfea472adadba06c294e64735dabc2dd19015fac082095013/coverage-7.14.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a93bac2cb577ef60074999ed56d8a1535894398e2ed920d4185c3ec0c8864742", size = 250854, upload-time = "2026-05-10T17:59:57.94Z" }, - { url = "https://files.pythonhosted.org/packages/3d/1c/b94f9f5f36396021ee2f62c5834b12e6a3d31f0bed5d6fc6d1c3caec087c/coverage-7.14.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:5904abf7e18cddc463219b17552229650c6b79e061d31a1059283051169cf7d5", size = 252433, upload-time = "2026-05-10T17:59:59.688Z" }, - { url = "https://files.pythonhosted.org/packages/b5/cb/d192cd8e1345eccabc32016f2d39072ecd10cb4f4b983ed8d0ebdeaf00dc/coverage-7.14.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:741f57cddc9004a8c81b084660215f33a6b597dbe62c31386b983ee26310e327", size = 250494, upload-time = "2026-05-10T18:00:01.953Z" }, - { url = "https://files.pythonhosted.org/packages/53/c5/aac9f460a41d835dbddef1d377f105f6ac2311d0f3c1588e9f51046d8813/coverage-7.14.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:664123feb0929d7affc135717dbd70d61d98688a08ab1e5ba464739620c6252d", size = 254261, upload-time = "2026-05-10T18:00:03.779Z" }, - { url = "https://files.pythonhosted.org/packages/23/aa/7af7c0081980a9cb3d289c5a435a4b7657dcecbd128e25c580e6a50389b5/coverage-7.14.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:c83d2399a51bbec8429266905d33616f04bc5726b1138c35844d5fcd896b2e20", size = 250216, upload-time = "2026-05-10T18:00:05.262Z" }, - { url = "https://files.pythonhosted.org/packages/35/60/a4257538ce2f6b978aeb51870d6c4208c510928a03db7e0339bb625dccb7/coverage-7.14.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bcb2e855b87321259a037429288ae85216d191c74de3e79bf57cd2bc0761992c", size = 251125, upload-time = "2026-05-10T18:00:06.858Z" }, - { url = "https://files.pythonhosted.org/packages/a1/ab/f91af47642ec1aa53490e835a95847168d9c77fc39aa58527604c051e145/coverage-7.14.0-cp311-cp311-win32.whl", hash = "sha256:731dc15b385ac52289743d476245b61e1a2927e803bef655b52bc3b2a75a21f3", size = 222300, upload-time = "2026-05-10T18:00:08.608Z" }, - { url = "https://files.pythonhosted.org/packages/f0/f0/a71ddbd874431e7a7cd96071f0c331cfbbad07704833c765d24ffbab8a67/coverage-7.14.0-cp311-cp311-win_amd64.whl", hash = "sha256:bfb0ed8ec5d25e93face268115d7964db9df8b9aae8edcde9ec6b16c726a7cc1", size = 223241, upload-time = "2026-05-10T18:00:10.746Z" }, - { url = "https://files.pythonhosted.org/packages/d8/6e/d9d312a5151a96cd110efee32efc3fc97b01ebd86203fe618ccb29cf4c92/coverage-7.14.0-cp311-cp311-win_arm64.whl", hash = "sha256:7ebb1c6df9f78046a1b1e0a89674cd4bf73b7c648914eebcf976a57fd99a5627", size = 221908, upload-time = "2026-05-10T18:00:12.242Z" }, - { url = "https://files.pythonhosted.org/packages/09/1e/2f996b2c8415cbb6f54b0f5ec1ee850c96d7911961afb4fc05f4a89d8c58/coverage-7.14.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7ffd19fc8aed057fd686a17a4935eef5f9859d69208f96310e893e64b9b6ccf5", size = 219967, upload-time = "2026-05-10T18:00:13.756Z" }, - { url = "https://files.pythonhosted.org/packages/34/23/35c7aea1274aef7525bdd2dc92f710bdde6d11652239d71d1ec450067939/coverage-7.14.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:829994cfe1aeb773ca27bf246d4badc1e764893e3bfb98fff820fcecd1ca4662", size = 220329, upload-time = "2026-05-10T18:00:15.264Z" }, - { url = "https://files.pythonhosted.org/packages/75/cf/a8f4b43a16e194b0261257ad28ded5853ec052570afef4a84e1d81189f3b/coverage-7.14.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:b4f07cf7edcb7ec39431a5074d7ea83b29a9f71fcfc494f0f40af4e65180420f", size = 251839, upload-time = "2026-05-10T18:00:17.16Z" }, - { url = "https://files.pythonhosted.org/packages/69/ff/6699e7b71e60d3049eb2bdcbc95ee3f35707b2b0e48f32e9e63d3ce30c08/coverage-7.14.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:ca3d9cf2c32b521bd9518385608787fa86f38daf993695307531822c3430ed67", size = 254576, upload-time = "2026-05-10T18:00:18.829Z" }, - { url = "https://files.pythonhosted.org/packages/22/ec/c936d495fcd67f48f03a9c4ad3297ff80d1f222a5df3980f15b34c186c21/coverage-7.14.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92af52828e7f29d827346b0294e5a0853fa206db77db0395b282918d41e28db9", size = 255690, upload-time = "2026-05-10T18:00:20.648Z" }, - { url = "https://files.pythonhosted.org/packages/5c/42/5af63f636cc62a4a2b1b3ba9146f6ee6f53a35a50d5cefc54d5670f60999/coverage-7.14.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7b2bb6c9d7e769360d0f20a0f219603fd64f0c8f97de17ab25853261602be0fb", size = 257949, upload-time = "2026-05-10T18:00:22.28Z" }, - { url = "https://files.pythonhosted.org/packages/26/d3/a225317bd2012132a27e1176d51660b826f99bb975876463c44ea0d7ee5a/coverage-7.14.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1c9ed6ef99f88fb8c14aa8e2bf8eb0fe55fa2edfea68f8675d78741df1a5ac0e", size = 252242, upload-time = "2026-05-10T18:00:24.076Z" }, - { url = "https://files.pythonhosted.org/packages/f1/7f/9e65495298c3ea414742998539c37d048b5e81cc818fb1828cc6b51d10bf/coverage-7.14.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8231ade007f37959fbf58acc677f26b922c02eda6f0428ea307da0fd39681bf3", size = 253608, upload-time = "2026-05-10T18:00:25.588Z" }, - { url = "https://files.pythonhosted.org/packages/94/46/1522b524a35bdad22b2b8c4f9d32d0a104b524726ec380b2db68db1746f5/coverage-7.14.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:d8b013632cc1ce1d09dbe4f32667b4d320ec2f54fc326ebeffcd0b0bcc2bb6c4", size = 251753, upload-time = "2026-05-10T18:00:27.104Z" }, - { url = "https://files.pythonhosted.org/packages/f3/e9/cdf00d38817742c541ade405e115a3f7bf36e6f2a8b99d4f209861b85a2d/coverage-7.14.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1733198802d71ec4c524f322e2867ee05c62e9e75df86bdca545407a221827d1", size = 255823, upload-time = "2026-05-10T18:00:29.038Z" }, - { url = "https://files.pythonhosted.org/packages/38/fc/5e7877cf5f902d08a17ff1c532511476d87e1bea355bd5028cb97f902e79/coverage-7.14.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:72a305291fa8ee01332f1aaf38b348ca34097f6aa0b0ef627eef2837e57bbba5", size = 251323, upload-time = "2026-05-10T18:00:30.647Z" }, - { url = "https://files.pythonhosted.org/packages/18/9d/50f05a72dff8487464fdd4178dda5daed642a060e60afb644e3d45123559/coverage-7.14.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fcaba850dd317c65423a9d63d88f9573c53b00354d6dd95724576cc98a131595", size = 253197, upload-time = "2026-05-10T18:00:32.211Z" }, - { url = "https://files.pythonhosted.org/packages/00/3f/6f61ffe6439df266c3cf60f5c99cfaa21103d0210d706a42fc6c30683ff8/coverage-7.14.0-cp312-cp312-win32.whl", hash = "sha256:5ac83957a80d0701310e96d8bec68cdcf4f90a7674b7d13f15a344315b41ab27", size = 222515, upload-time = "2026-05-10T18:00:33.717Z" }, - { url = "https://files.pythonhosted.org/packages/85/19/93853133df2cb371083285ef6a93982a0173e7a233b0f61373ba9fd30eb2/coverage-7.14.0-cp312-cp312-win_amd64.whl", hash = "sha256:70390b0da32cb90b501953716302906e8bcce087cb283e70d8c97729f22e92b2", size = 223324, upload-time = "2026-05-10T18:00:35.172Z" }, - { url = "https://files.pythonhosted.org/packages/74/18/9f7fe62f659f24b7a82a0be56bf94c1bd0a89e0ae7ab4c668f6e82404294/coverage-7.14.0-cp312-cp312-win_arm64.whl", hash = "sha256:91b993743d959b8be85b4abf9d5478216a69329c321efe5be0433c1a841d691d", size = 221944, upload-time = "2026-05-10T18:00:37.014Z" }, - { url = "https://files.pythonhosted.org/packages/6b/76/b7c66ee3c66e1b0f9d894c8125983aa0c03fb2336f2fd16559f9c966157f/coverage-7.14.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f2bbb8254370eb4c628ff3d6fa8a7f74ddc40565394d4f7ab791d1fe568e37ef", size = 219990, upload-time = "2026-05-10T18:00:38.887Z" }, - { url = "https://files.pythonhosted.org/packages/b3/af/e567cbad5ba69c013a50146dfa886dc7193361fda77521f51274ff620e1b/coverage-7.14.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:23b81107f46d3f21d0cbce30664fcec0f5d9f585638a67081750f99738f6bf66", size = 220365, upload-time = "2026-05-10T18:00:40.864Z" }, - { url = "https://files.pythonhosted.org/packages/44/6f/9ad575d505b4d805b254febc8a5b338a2efe278f8786e56ff1cb8413f9c3/coverage-7.14.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:22a7e06a5f11a757cdfe79018e9095f9f69ae283c5cd8123774c788deec8717b", size = 251363, upload-time = "2026-05-10T18:00:42.489Z" }, - { url = "https://files.pythonhosted.org/packages/6f/5f/b5370068b2f57787454592ed7dcd1002f0f1703b7db1fa30f6a325a4ca6e/coverage-7.14.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9d1aa57a1dc8e05bdc42e81c5d671d849577aeedf279f4c449d6d286f9ed88ca", size = 253961, upload-time = "2026-05-10T18:00:44.079Z" }, - { url = "https://files.pythonhosted.org/packages/29/1e/51adf17738976e8f2b85ddef7b7aa12a0838b056c92f175941d8862767c1/coverage-7.14.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:90c1a51bcfddf645b3bb7ec333d9e94393a8e94f55642380fa8a9a5a9e636cb7", size = 255193, upload-time = "2026-05-10T18:00:45.623Z" }, - { url = "https://files.pythonhosted.org/packages/9e/7b/5bfd7ac1df3b881c2ac7a5cbc99c7609e6296c402f5ef587cd81c6f355b3/coverage-7.14.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a841fae2fadcae4f438d43b6ccc4aac2ad609f47cdb6cfdce60cbb3fe5ca7bc2", size = 257326, upload-time = "2026-05-10T18:00:47.173Z" }, - { url = "https://files.pythonhosted.org/packages/7d/38/1d37d316b174fad3843a1d76dbdfe4398771c9ecd0515935dd9ece9cd627/coverage-7.14.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c79d2319cabef1fe8e86df73371126931550804738f78ad7d31e3aad85a67367", size = 251582, upload-time = "2026-05-10T18:00:49.152Z" }, - { url = "https://files.pythonhosted.org/packages/34/46/746704f95980ba220214e1a41e18cec5aea80a898eaa53c51bf2d645ff36/coverage-7.14.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1b23b0c6f0b1db6ad769b7050c8b641c0bf215ded26c1816955b17b7f26edfa9", size = 253325, upload-time = "2026-05-10T18:00:51.252Z" }, - { url = "https://files.pythonhosted.org/packages/e1/b9/bbe87206d9687b192352f893797825b5f5b15ecd3aa9c68fbff0c074d77b/coverage-7.14.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:55d3089079ce181a4566b1065ab28d2575eb76d8ac8f81f4fcda2bf037fee087", size = 251291, upload-time = "2026-05-10T18:00:52.816Z" }, - { url = "https://files.pythonhosted.org/packages/46/57/b8cdb12ac0d73ef0243218bd5e22c9df8f92edab8018213a86aec67c5324/coverage-7.14.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:49c005cba1e2f9677fb2845dcdf9a2e72a52a17d63e8231aaaae35d9f50215ef", size = 255448, upload-time = "2026-05-10T18:00:54.548Z" }, - { url = "https://files.pythonhosted.org/packages/1f/d4/5002019538b2036ce3c84340f54d2fd5100d55b0a6b0894eee56128d03c7/coverage-7.14.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:9117377b823daa28aa8635fbb08cda1cd6be3d7143257345459559aeef852d52", size = 251110, upload-time = "2026-05-10T18:00:56.122Z" }, - { url = "https://files.pythonhosted.org/packages/37/53/20c5009477660f084e6ed60bc02a91894b8e234e617e86ecfd9aaf78e27b/coverage-7.14.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7b79d646cf46d5cf9a9f40281d4441df5849e445726e369006d2b117710b33fe", size = 252885, upload-time = "2026-05-10T18:00:57.967Z" }, - { url = "https://files.pythonhosted.org/packages/ae/ab/3cf6427ac9c1f1db747dbb1ce71dde47984876d4c2cfd018a3fef0a78d4d/coverage-7.14.0-cp313-cp313-win32.whl", hash = "sha256:fb609b3658479e33f9516d46f1a89dbb9b6c261366e3a11844a96ec487533dae", size = 222539, upload-time = "2026-05-10T18:00:59.581Z" }, - { url = "https://files.pythonhosted.org/packages/8f/b8/9228523e80321c2cb4880d1f589bc0171f2f71432c35118ad04dc01decce/coverage-7.14.0-cp313-cp313-win_amd64.whl", hash = "sha256:0773d8329cf32b6fd222e4b52622c61fe8d503eb966cfc8d3c3c10c96266d50e", size = 223344, upload-time = "2026-05-10T18:01:01.531Z" }, - { url = "https://files.pythonhosted.org/packages/a3/99/118daa192f95e3a6cb2740100fbf8797cda1734b4134ef0b5d501a7fa8f3/coverage-7.14.0-cp313-cp313-win_arm64.whl", hash = "sha256:b4e26a0f1b696faf283bffe5b8569e44e336c582439df5d53281ab89ee0cba96", size = 221966, upload-time = "2026-05-10T18:01:03.16Z" }, - { url = "https://files.pythonhosted.org/packages/e6/f1/a46cc0c013be170216253184a32366d7cbdb9252feaec866b05c2d12a894/coverage-7.14.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:953f521ca9445300397e65fda3dca58b2dbd68fee983777420b57ac3c77e9f90", size = 220679, upload-time = "2026-05-10T18:01:05.058Z" }, - { url = "https://files.pythonhosted.org/packages/64/8c/9c30a3d311a34177fa432995be7fbfc64477d8bac5630bd38055b1c9b424/coverage-7.14.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:98af83fd65ae24b1fdd03aaead967a9f523bcd2f1aab2d4f3ffda65bb568a6f1", size = 221033, upload-time = "2026-05-10T18:01:07.002Z" }, - { url = "https://files.pythonhosted.org/packages/9a/cd/3fb5e06c3badefd0c1b47e2044fdca67f8220a4ec2e7fcfb476aa0a67c6c/coverage-7.14.0-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:668b92e6958c4db7cf92e81caac328dfbbdbb215db2850ad28f0cbe1eea0bfbd", size = 262333, upload-time = "2026-05-10T18:01:08.903Z" }, - { url = "https://files.pythonhosted.org/packages/a8/e6/fbc322325c7294d3e22c1ad6b79e45d0806b25228c8e5842aed6d8169aa7/coverage-7.14.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9fbd898551762dea00d3fef2b1c4f99afd2c6a3ff952ea07d60a9bd5ed4f34bc", size = 264410, upload-time = "2026-05-10T18:01:10.531Z" }, - { url = "https://files.pythonhosted.org/packages/08/92/c497b264bec1673c47cc77e26f760fcda4654cabf1f39546d1a23a3b8c35/coverage-7.14.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:68af363c07ecd8d4b7d4043d85cb376d7d227eceb54e5323ee45da73dbd3e426", size = 266836, upload-time = "2026-05-10T18:01:12.19Z" }, - { url = "https://files.pythonhosted.org/packages/78/fc/045da320987f401af5d2815d351e8aa799aec859f60e29f445e3089eeedb/coverage-7.14.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6e57054a583da8ac55edf24117ea4c9133032cfc4cf72aa2d48c1e5d4b52f899", size = 267974, upload-time = "2026-05-10T18:01:13.926Z" }, - { url = "https://files.pythonhosted.org/packages/1b/ae/227b1e379497fb7a4fc3286e620f80c8a1e7cec66d45695a01639eb1af65/coverage-7.14.0-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cc3499459bbcdd51a65b64c35ab7ed2764eaf3cba826e0df3f1d7fe2e102b70b", size = 261578, upload-time = "2026-05-10T18:01:15.564Z" }, - { url = "https://files.pythonhosted.org/packages/a0/f5/3570342900f2acea31d33ff1590c5d8bac1a8e1a2e1c6d34a5d5e61de681/coverage-7.14.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:45899ec2138a4346ed34d601dedf5076fb74edf2d1dd9dc76a78e82397edee90", size = 264394, upload-time = "2026-05-10T18:01:17.607Z" }, - { url = "https://files.pythonhosted.org/packages/16/29/de1bbc01c935b28f89b1dc3db85b011c055e843a8e5e3b83141c3f80af7f/coverage-7.14.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:8767486808c436f05b23ab98eb963fb29185e32a9357a166971685cb3459900f", size = 262022, upload-time = "2026-05-10T18:01:19.304Z" }, - { url = "https://files.pythonhosted.org/packages/35/95/f53890b0bf2fc10ab168e05d38869215e73ca24c4cb521c3bb0eb62fe16b/coverage-7.14.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:a3b5ddfd6aa7ddad53ee3edb231e88a2151507a43229b7d71b953916deca127d", size = 265732, upload-time = "2026-05-10T18:01:21.494Z" }, - { url = "https://files.pythonhosted.org/packages/ed/ea/c919e259081dd2bdf0e43b87209709ba7ec2e4117c2a7f5185379c43463c/coverage-7.14.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:63df0fe568e698e1045792399f8ab6da3a6c2dce3182813fb92afa2641087b47", size = 260921, upload-time = "2026-05-10T18:01:23.533Z" }, - { url = "https://files.pythonhosted.org/packages/1a/2c/c2831889705a81dc5d1c6ca12e4d8e9b95dfc146d153488a6c0ea685d28e/coverage-7.14.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:827d6397dbd95144939b18f89edf31f63e1f99633e8d5f32f22ba8bdda567477", size = 263109, upload-time = "2026-05-10T18:01:25.165Z" }, - { url = "https://files.pythonhosted.org/packages/5a/a9/2fcae5003cac3d63fe344d2166243c2756935f48420863c5272b240d550b/coverage-7.14.0-cp313-cp313t-win32.whl", hash = "sha256:7bf43e000d24012599b879791cff41589af90674722421ef11b11a5431920bab", size = 223212, upload-time = "2026-05-10T18:01:27.157Z" }, - { url = "https://files.pythonhosted.org/packages/3f/bb/18e94d7b14b9b398164197114a587a04ab7c9fdbe1d237eef57311c5e883/coverage-7.14.0-cp313-cp313t-win_amd64.whl", hash = "sha256:3f5549365af25d770e06b1f8f5682d9a5637d06eb494db91c6fa75d3950cc917", size = 224272, upload-time = "2026-05-10T18:01:29.107Z" }, - { url = "https://files.pythonhosted.org/packages/db/56/4f14fad782b035c81c4ffd09159e7103d42bb1d93ac8496d04b90a11b7da/coverage-7.14.0-cp313-cp313t-win_arm64.whl", hash = "sha256:6d160217ec6fe890f16ad3a9531761589443749e448f91986c972714fad361c8", size = 222530, upload-time = "2026-05-10T18:01:31.151Z" }, - { url = "https://files.pythonhosted.org/packages/1c/18/b9a6586d73992807c26f9a5f274131be3d76b56b18a82b9392e2a25d2e45/coverage-7.14.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:9aed9fa983514ca032790f3fe0d1c0e42ca7e16b42432af1706b50a9a46bef5d", size = 220036, upload-time = "2026-05-10T18:01:33.057Z" }, - { url = "https://files.pythonhosted.org/packages/f3/9b/4165a1d56ddc302a0e2d518fd9d412a4fd0b57562618c78c5f21c57194f5/coverage-7.14.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ba3b8390db29296dbbf49e91b6fe08f990743a90c8f447ba4c2ffc29670dfa63", size = 220368, upload-time = "2026-05-10T18:01:34.705Z" }, - { url = "https://files.pythonhosted.org/packages/69/aa/c12e52a5ba148d9995229d557e3be6e554fe469addc0e9241b2f0956d8ea/coverage-7.14.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3a5d8e876dfa2f102e970b183863d6dedd023d3c0eeca1fe7a9787bc5f28b212", size = 251417, upload-time = "2026-05-10T18:01:36.949Z" }, - { url = "https://files.pythonhosted.org/packages/d7/51/ec641c26e6dca1b25a7d2035ba6ecb7c884ef1a100a9e42fbe4ce4405139/coverage-7.14.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5ebb8f4614a3787d567e610bbfdf96a4798dd69a1afb1bd8ad228d4111fe6ff3", size = 253924, upload-time = "2026-05-10T18:01:38.985Z" }, - { url = "https://files.pythonhosted.org/packages/33/c4/59c3de0bd1b538824173fd518fed51c1ce740ca5ed68e74545983f4053a9/coverage-7.14.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b9bf47223dd8db3d4c4b2e443b02bace480d428f0822c3f991600448a176c97", size = 255269, upload-time = "2026-05-10T18:01:40.957Z" }, - { url = "https://files.pythonhosted.org/packages/7b/a9/36dfa153a62040296f6e7febfdb20a5720622f6ef5a81a41e8237b9a5344/coverage-7.14.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3485a836550b303d006d57cc06e3d5afaabc642c77050b7c985a97b13e3776b8", size = 257583, upload-time = "2026-05-10T18:01:42.607Z" }, - { url = "https://files.pythonhosted.org/packages/26/7b/cc2c048d4114d9ab1c2409e9ee365e5ae10736df6dffcfc9444effa6c708/coverage-7.14.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3e7e88110bae996d199d1693ca8ec3fd52441d426401ae963437598667b4c5eb", size = 251434, upload-time = "2026-05-10T18:01:44.537Z" }, - { url = "https://files.pythonhosted.org/packages/ee/df/6770eaa576e604575e9a78055313250faef5faa84bd6f71a39fece519c43/coverage-7.14.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:15228a6800ce7bdf1b74800595e56db7138cecb338fdbf044806e10dcf182dfe", size = 253280, upload-time = "2026-05-10T18:01:46.175Z" }, - { url = "https://files.pythonhosted.org/packages/ad/9e/1c0264514a3f98259a6d64765a397b2c8373e3ba59ee722a4802d3ec0c61/coverage-7.14.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:9d26ac7f5398bafc5b57421ad994e8a4749e8a7a0e62d05ec7d53014d5963bfa", size = 251241, upload-time = "2026-05-10T18:01:48.732Z" }, - { url = "https://files.pythonhosted.org/packages/64/16/4efdf3e3c4079cdbf0ece56a2fea872df9e8a3e15a13a0af4400e1075944/coverage-7.14.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:2fb73254ff43c911c967a899e1359bc5049b4b115d6e8fbdde4937d0a2246cd5", size = 255516, upload-time = "2026-05-10T18:01:50.819Z" }, - { url = "https://files.pythonhosted.org/packages/93/69/b1de96346603881b3d1bc8d6447c83200e1c9700ffbaff926ba01ff5724c/coverage-7.14.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:454a380af72c6adada298ed270d38c7a391288198dbfb8467f786f588751a90c", size = 251059, upload-time = "2026-05-10T18:01:52.773Z" }, - { url = "https://files.pythonhosted.org/packages/a4/66/2881853e0363a5e0a724d1103e53650795367471b6afb234f8b49e713bc6/coverage-7.14.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:65c86fb646d2bd2972e96bd1a8b45817ed907cee68655d6295fe7ec031d04cca", size = 252716, upload-time = "2026-05-10T18:01:54.506Z" }, - { url = "https://files.pythonhosted.org/packages/55/5c/0d3305d002c41dcde873dbe456491e663dc55152ca526b630b5c47efd62f/coverage-7.14.0-cp314-cp314-win32.whl", hash = "sha256:6a6516b02a6101398e19a3f44820f69bab2590697f7def4331f668b14adaf828", size = 222788, upload-time = "2026-05-10T18:01:56.487Z" }, - { url = "https://files.pythonhosted.org/packages/f9/58/6e1b8f52fdc3184b47dc5037f5070d83a3d11042db1594b02d2a44d786c8/coverage-7.14.0-cp314-cp314-win_amd64.whl", hash = "sha256:45e0f79d8351fa76e256716df91eab12890d32678b9590df7ae1042e4bd4cf5d", size = 223600, upload-time = "2026-05-10T18:01:58.497Z" }, - { url = "https://files.pythonhosted.org/packages/00/70/a18c408e674bc26281cadaedc7351f929bd2094e191e4b15271c30b084cc/coverage-7.14.0-cp314-cp314-win_arm64.whl", hash = "sha256:4b899594a8b2d81e5cc064a0d7f9cac2081fed91049456cae7676787e41549c9", size = 222168, upload-time = "2026-05-10T18:02:00.411Z" }, - { url = "https://files.pythonhosted.org/packages/3d/89/2681f071d238b62aff8dfc2ab44fc24cfdb38d1c01f391a80522ff5d3a16/coverage-7.14.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:f580f8c80acd94ac72e863efe2cab791d8c38d153e0b463b92dfa000d5c84cd1", size = 220766, upload-time = "2026-05-10T18:02:02.313Z" }, - { url = "https://files.pythonhosted.org/packages/bd/c7/c987babafd9207ffa1995e1ef1f9b26762cf4963aa768a66b6f0501e4616/coverage-7.14.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a2bd259c442cd43c49b30fbafc51776eb19ea396faf159d26a83e6a0a5f13b0c", size = 221035, upload-time = "2026-05-10T18:02:04.017Z" }, - { url = "https://files.pythonhosted.org/packages/5a/e9/d6a5ac3b333088143d6fc877d398a9a674dc03124a2f776e131f03864823/coverage-7.14.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:a706b908dfa85538863504c624b237a3cc34232bf403c057414ebfdb3b4d9f84", size = 262405, upload-time = "2026-05-10T18:02:05.915Z" }, - { url = "https://files.pythonhosted.org/packages/38/b1/e70838d29a7c08e22d44398a46db90815bbcbf28de06992bd9210d1a8d8e/coverage-7.14.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:7333cd944ee4393b9b3d3c1b598c936d4fc8d70573a4c7dacfec5590dd50e436", size = 264530, upload-time = "2026-05-10T18:02:07.582Z" }, - { url = "https://files.pythonhosted.org/packages/6b/73/5c31ef97763288d03d9995152b96d5475b527c63d91c84b01caea894b83a/coverage-7.14.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0f162bc9a15b82d947b02651b0c7e1609d6f7a8735ca330cfadec8481dd97d5a", size = 266932, upload-time = "2026-05-10T18:02:09.401Z" }, - { url = "https://files.pythonhosted.org/packages/e1/76/dd56d80f29c5f05b4d76f7e7c6d47cafacae017189c75c5759d24f9ff0cc/coverage-7.14.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:362cb78e01a5dc82009d88004cf60f2e6b6d6fcbfdec05b05af73b0abf40118f", size = 268062, upload-time = "2026-05-10T18:02:11.399Z" }, - { url = "https://files.pythonhosted.org/packages/6e/c7/27ba85cd5b95614f159ff93ebff1901584a8d192e2e5e24c4943a7453f59/coverage-7.14.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:acebd068fca5512c3a6fde9c045f901613478781a73f0e82b307b214daef23fb", size = 261504, upload-time = "2026-05-10T18:02:13.257Z" }, - { url = "https://files.pythonhosted.org/packages/13/2e/e8149f60ab5d5684c6eee881bdf34b127115cddbb958b196768dd9d63473/coverage-7.14.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:29fe3da551dface75deb2ccbf87b6b66e2e7ef38f6d89050b428be94afff3490", size = 264398, upload-time = "2026-05-10T18:02:15.063Z" }, - { url = "https://files.pythonhosted.org/packages/d9/7f/1261b025285323225f4b4abffa5a643649dfd67e25ddca7ebcbdea3b7cb3/coverage-7.14.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:b4cc4fce8672fffcb09b0eafc167b396b3ba53c4a7230f54b7aaffbf6c835fa9", size = 262000, upload-time = "2026-05-10T18:02:16.756Z" }, - { url = "https://files.pythonhosted.org/packages/d3/dc/829c54f60b9d08389439c00f813c752781c496fc5788c78d8006db4b4f2b/coverage-7.14.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:5d4a51aad8ba8bdcd2b8bd8f03d4aca19693fa2327a3470e4718a25b03481020", size = 265732, upload-time = "2026-05-10T18:02:18.817Z" }, - { url = "https://files.pythonhosted.org/packages/ed/b0/70bd1419941652fa062689cba9c3eeafb8f5e6fbb890bce41c3bdda5dbd6/coverage-7.14.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:9f323af3e1e4f68b60b7b247e37b8515563a61375518fa59de1af48ba28a3db6", size = 260847, upload-time = "2026-05-10T18:02:20.528Z" }, - { url = "https://files.pythonhosted.org/packages/f2/73/be40b2390656c654d35ea0015ea7ba3d945769cf80790ad5e0bb2d56d2ba/coverage-7.14.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:1a0abc7342ea9711c469dd8b821c6c311e6bc6aac1442e5fbd6b27fae0a8f3db", size = 263166, upload-time = "2026-05-10T18:02:22.337Z" }, - { url = "https://files.pythonhosted.org/packages/29/55/4a643f712fcf7cf2881f8ec1e0ccb7b164aff3108f69b51801246c8799f2/coverage-7.14.0-cp314-cp314t-win32.whl", hash = "sha256:a9f864ef57b7172e2db87a096642dd51e179e085ab6b2c371c29e885f65c8fb2", size = 223573, upload-time = "2026-05-10T18:02:24.11Z" }, - { url = "https://files.pythonhosted.org/packages/27/96/3acae5da0953be042c0b4dea6d6789d2f080701c77b88e44d5bd41b9219b/coverage-7.14.0-cp314-cp314t-win_amd64.whl", hash = "sha256:29943e552fdc08e082eb51400fb2f58e118a83b5542bd06531214e084399b644", size = 224680, upload-time = "2026-05-10T18:02:25.896Z" }, - { url = "https://files.pythonhosted.org/packages/93/3d/6ab5d2dd8325d838737c6f8d83d62eb6230e0d70b87b51b57bbfd08fa767/coverage-7.14.0-cp314-cp314t-win_arm64.whl", hash = "sha256:742a73ea621953b012f2c4c2219b512180dd84489acf5b1596b0aafc55b9100b", size = 222703, upload-time = "2026-05-10T18:02:27.822Z" }, - { url = "https://files.pythonhosted.org/packages/61/e8/cb8e80d6f9f55b99588625062822bf946cf03ed06315df4bd8397f5632a1/coverage-7.14.0-py3-none-any.whl", hash = "sha256:8de5b61163aee3d05c8a2beab6f47913df7981dad1baf82c414d99158c286ab1", size = 211764, upload-time = "2026-05-10T18:02:29.538Z" }, -] - -[package.optional-dependencies] -toml = [ - { name = "tomli", marker = "python_full_version <= '3.11' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing')" }, +version = "7.14.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/54/fd/0ab2772530e946e1be1abd0bc09e647ec9b02e88f0867857601fefca8953/coverage-7.14.1.tar.gz", hash = "sha256:30c08f7d90415aa98b3c990385dea2939b0da55f38515e5b369b83655f8523be", size = 920132, upload-time = "2026-05-26T20:41:36.783Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/92/69/0d2ef01ff4b8fcecd4cba920d11e92fa4f96ae412441d3b56a90a258e69b/coverage-7.14.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:3e3680291c4a1d0dadfa84a2c459576a4af5133abb617905714339a0c73138cf", size = 219722, upload-time = "2026-05-26T20:38:14.002Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ae/9afdeaa31b9d9ce98124b6abf8bb49119bf71aecae04f8567c189d91299f/coverage-7.14.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a5274669f37f2343635a347b91a60777621341ab3378e9c6ac9335eee704bddf", size = 220240, upload-time = "2026-05-26T20:38:17.424Z" }, + { url = "https://files.pythonhosted.org/packages/51/69/c998589871df7ea7dba865cc5ee32b5a3e1d47ba6c68ef91104c7c46fa5e/coverage-7.14.1-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cfe5a5fec635799ef33428f1e5e61bafa45a92a96190ba731561ba558ccc214d", size = 246981, upload-time = "2026-05-26T20:38:19.266Z" }, + { url = "https://files.pythonhosted.org/packages/fc/10/1c7d04c13040dac531d21b712bbe08f902e6dd9b58f5d77875c4d030f8f2/coverage-7.14.1-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:62a9f70b52e0b5a95cfef4a5c5641b06983cadc5e538a3feeb5c00211f523ac2", size = 248812, upload-time = "2026-05-26T20:38:20.75Z" }, + { url = "https://files.pythonhosted.org/packages/c1/65/2a38a4607ef27cadcfbcee034dba5830ae2569f90144a0f4c7dbf47d30b0/coverage-7.14.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3c18ebc343e15be53049b3a2dce38fe82d58f37e20ab9094b3a39c0aa4f6bb47", size = 250675, upload-time = "2026-05-26T20:38:22.159Z" }, + { url = "https://files.pythonhosted.org/packages/c9/a2/a446ed9752a4a59b79e0fb6cbb319f6facb2183045c0725462625e66f87e/coverage-7.14.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b84ffdf877644e7096aa936991efeed873f7f3df57b9cd001312b7668ab08550", size = 252590, upload-time = "2026-05-26T20:38:23.63Z" }, + { url = "https://files.pythonhosted.org/packages/9e/fd/e81fbd7ba752365546e9842b1cbdaad3d6919d2a522c590aef16a281ec5e/coverage-7.14.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e854312c4103f2ad4c0dc023b69b77ebfd2c89db5f86c4c94dc2353f9a92167e", size = 247691, upload-time = "2026-05-26T20:38:25.057Z" }, + { url = "https://files.pythonhosted.org/packages/53/35/f3c26fdaae9ea937d154ca4d372e5ea0a4167ff70d36c6074ac2eacb2f83/coverage-7.14.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:c643734307300234fafa36bf2a040a7235f8f177ea1fd6ec1423aea6fb7b929f", size = 248716, upload-time = "2026-05-26T20:38:26.406Z" }, + { url = "https://files.pythonhosted.org/packages/2e/14/940b6c49551fd343e8507ee2b0ba7af5d0aa04ed5bf768285cb7c72a9884/coverage-7.14.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:84ac9499e48700399a5dd0ea7085b5091961fec52c68d66b4ec0d3cf7f4441b1", size = 246721, upload-time = "2026-05-26T20:38:28.282Z" }, + { url = "https://files.pythonhosted.org/packages/aa/2c/40fc0634186c28292a662dff578866b3913983d6c375a3c2a74020938719/coverage-7.14.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:7f02d09f70776579b926d889a4c9c235070a1f47c40458aeaca563fae5acfdb5", size = 250533, upload-time = "2026-05-26T20:38:29.753Z" }, + { url = "https://files.pythonhosted.org/packages/de/e3/2c26bf1e811f9df991ff2a9bdddebdd13ee0665d564df7d05979f9146297/coverage-7.14.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:ce66d8e46da2bb5ee313a745cbd2e391d319176c1f7a9451bfcd3a2fb920859b", size = 246990, upload-time = "2026-05-26T20:38:31.516Z" }, + { url = "https://files.pythonhosted.org/packages/a8/b0/060260ef56bd92363ebdce0c7095ce422b06e69aae71828efeca473ab1ca/coverage-7.14.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c912c259304cfb5ee584481cfb7ce1ff932b4d61e6c9140b8f19cb7b5ed82332", size = 247593, upload-time = "2026-05-26T20:38:33.065Z" }, + { url = "https://files.pythonhosted.org/packages/63/f3/501502046efeb0d6d94b5ca54941d95f1184183dd6bdb7f283985783bb4a/coverage-7.14.1-cp310-cp310-win32.whl", hash = "sha256:1238cb94638e610e972c60dac68e813f868dc7d6e982535270558443058d9d59", size = 222330, upload-time = "2026-05-26T20:38:35.36Z" }, + { url = "https://files.pythonhosted.org/packages/a0/5d/1bf99f2c558f128faf7906817ccbdb576ba815d3b41ce2ac1719b70a3663/coverage-7.14.1-cp310-cp310-win_amd64.whl", hash = "sha256:fc459e5d73be2d6332fcfe8dbf3d8994671fe33c700f4565988ecfa511547253", size = 223261, upload-time = "2026-05-26T20:38:37.196Z" }, + { url = "https://files.pythonhosted.org/packages/7d/d7/477ad149490e6cb849f28abea1dabb9c823cea72e7500c81b4240ce619c0/coverage-7.14.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:478b5bcd63c2e1357c5c7e16c070690df7b07f676b1c114d7b93e533c664309f", size = 219848, upload-time = "2026-05-26T20:38:38.715Z" }, + { url = "https://files.pythonhosted.org/packages/91/82/a5eb47257c50601bb7b9a9d2857c67b7a3a85ad74180eb2c98bb1fbe0ce5/coverage-7.14.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a24a81f9715ee42ef59a316cc11611c98fe23920f7c81861315c9f3ff4a230f4", size = 220354, upload-time = "2026-05-26T20:38:40.232Z" }, + { url = "https://files.pythonhosted.org/packages/43/8b/78419b5391a5cb706b6544390507e469d83ffc9a8248b02c4011aceb9365/coverage-7.14.1-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:196a13319ad88d6d8ef5ab489ec4f44ddde2143c0c7d5b27786f6c3ffd56a7e1", size = 250771, upload-time = "2026-05-26T20:38:41.782Z" }, + { url = "https://files.pythonhosted.org/packages/77/63/e77aaacd491182210d639636b7a8bba23ffffa9b82aa3762da9431855fa9/coverage-7.14.1-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:3d452fd08b5c72c5167c93e6867b5c08500bd40f2a21e1e854a500550b6cc36f", size = 252683, upload-time = "2026-05-26T20:38:43.305Z" }, + { url = "https://files.pythonhosted.org/packages/65/1c/a022e3cfbec2ac241640003cb3a817e161d9c7f5aa9b49173756cdc03204/coverage-7.14.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:23bf7fa51ac02e07fc7c96849b82946da47ae862dc8f86d183b2a4864fc38129", size = 254791, upload-time = "2026-05-26T20:38:45.361Z" }, + { url = "https://files.pythonhosted.org/packages/61/d6/967e408aca4c1ceb88cb0cc677169110ae7f5995fb5eaf5fb1f5a1bb8f5d/coverage-7.14.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bcaa50684dcaadfa599ac48f81103c756d791cfd85c97203d2217c593d48b860", size = 256748, upload-time = "2026-05-26T20:38:46.91Z" }, + { url = "https://files.pythonhosted.org/packages/b8/be/869188f7fe28638078ec479331ace6dc5f7b40b7153eb616f47ab79404d8/coverage-7.14.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4ea1c034f95c9b056e856b794630b17f9fa3d57e4800ff1e503d3be0f9c9078c", size = 250907, upload-time = "2026-05-26T20:38:48.493Z" }, + { url = "https://files.pythonhosted.org/packages/07/aa/adb7d3b4278d690e68703abcd76ab1b948242e3668d921711551b78f9ddb/coverage-7.14.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c7e057326434e441306226fbeb5d1aaf14a2637efe97ba668306635835f32ad7", size = 252483, upload-time = "2026-05-26T20:38:50.074Z" }, + { url = "https://files.pythonhosted.org/packages/43/61/331c74103c62dcb0c4b9b3a0de9a61aca016208b0a90f109592a9f9ecc28/coverage-7.14.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:59baf88468dbc8d63b1887afd92bda52e40bb1561696e5819670601403810cec", size = 250545, upload-time = "2026-05-26T20:38:51.613Z" }, + { url = "https://files.pythonhosted.org/packages/f6/b6/c5dae3c104d89be04828f61810e6b3473825482e4c288cc4ed04553e08ae/coverage-7.14.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:d34d75f892b3ab73ba11cab5442cce7b3e168fd64162b16f0e1e0d09c508edef", size = 254310, upload-time = "2026-05-26T20:38:53.503Z" }, + { url = "https://files.pythonhosted.org/packages/ad/a1/2b9d5863e3b83c01ad8199e3c597802fbb3a9dc90b058885804c20296d31/coverage-7.14.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:3a56abc20a472baf0304c455721bc601477440d28ecfde8a03dde79ede07e0df", size = 250266, upload-time = "2026-05-26T20:38:55.414Z" }, + { url = "https://files.pythonhosted.org/packages/7f/5e/0e511fbdb269359be26fe678a1c3fa1f2aa2a01573cc3f54268c8d6d4797/coverage-7.14.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6a3cb83d1552c0cd1b4906655b6a33fd4a8473229633a901c6b73bf86914dee9", size = 251174, upload-time = "2026-05-26T20:38:57.141Z" }, + { url = "https://files.pythonhosted.org/packages/85/10/e55307b622b3dd9671cb321824502dc10f93e72f2802b9946159a8edadeb/coverage-7.14.1-cp311-cp311-win32.whl", hash = "sha256:10274a1fbeb8ec5d72966e17bb198a3104257aca4ac09d98667c5f8aca8c8548", size = 222354, upload-time = "2026-05-26T20:38:58.727Z" }, + { url = "https://files.pythonhosted.org/packages/71/cf/107421693cfb71e4f1ca5bf70443f64d4161878068d07a3e51c7ad21d17b/coverage-7.14.1-cp311-cp311-win_amd64.whl", hash = "sha256:87ebdf787d4888e3f3f2d523eadc6e18c6d18c6d0eb173801a189641627fb37e", size = 223290, upload-time = "2026-05-26T20:39:00.413Z" }, + { url = "https://files.pythonhosted.org/packages/b8/1d/3e3644585eb29e9dafefb19555078529a4d7cce12bd21929664eea989277/coverage-7.14.1-cp311-cp311-win_arm64.whl", hash = "sha256:dd34767fa19848d35659ffc0a75314f58c7af3f1cd87ec521e8292a1238398a3", size = 221953, upload-time = "2026-05-26T20:39:02.159Z" }, + { url = "https://files.pythonhosted.org/packages/3d/b7/bdbb725ba02c5b42825b200c940f38b7a54fcad24627b7192f78f8110d76/coverage-7.14.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a06c76364a9360e33d6d23769aefdf7f66f38e2ffb60ceb1baaa4989d83b695c", size = 220022, upload-time = "2026-05-26T20:39:03.702Z" }, + { url = "https://files.pythonhosted.org/packages/72/81/fdc0898a55c6219223291ec1a1fe89966ef212ce82276aa0899df84b5de0/coverage-7.14.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fad54e871165f6ec2f536063ac74c3104508a12963e64072ba44bd822de52b0c", size = 220379, upload-time = "2026-05-26T20:39:05.381Z" }, + { url = "https://files.pythonhosted.org/packages/de/72/de048c4a25e13bce59ac6a339351c10bdf2515e07459afcdaf04dc3143a2/coverage-7.14.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:84b535f00655ecafe1d929d1fb00ed5d6fa3051ea643ab2c161a3887b86f294b", size = 251888, upload-time = "2026-05-26T20:39:07.367Z" }, + { url = "https://files.pythonhosted.org/packages/28/30/300c343f68beb9d4cbb64ec81e58c5b6b80b56927f72d2b38654ac26e013/coverage-7.14.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6b6b0853b895fe0e98cbfc580d1ec3393d9302b4b1e96a77b3f5c91fdab899e6", size = 254624, upload-time = "2026-05-26T20:39:09.037Z" }, + { url = "https://files.pythonhosted.org/packages/b1/ed/7b25642496e8170b6bac14adce00537c6e5fa2d586159401a4de3e8b49e6/coverage-7.14.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:442cc9c952b2df400cda54bb04ab87330cf2cd08a8692cbbea36773531eb6f37", size = 255739, upload-time = "2026-05-26T20:39:10.889Z" }, + { url = "https://files.pythonhosted.org/packages/7f/a2/abd210b8c4e29c24e4624916db97bb519097a91034aaeb767f937e7da794/coverage-7.14.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8270544c361ed405a27a060dbc9ed2c124b084d96dfdc2d9a2510482aef981ad", size = 257998, upload-time = "2026-05-26T20:39:12.722Z" }, + { url = "https://files.pythonhosted.org/packages/7f/24/7c50beed3792fe62f6ce0545c6686ce83379719e2c0276179333d97eae92/coverage-7.14.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:48b283b1dd6372e8de2a7a9a4c4d5dc06f4d4fd209b876f3c88a7a205a0c8f84", size = 252296, upload-time = "2026-05-26T20:39:14.259Z" }, + { url = "https://files.pythonhosted.org/packages/15/05/0f874628ebcbfc77ead559ff210281ef06a97db08481832e7dd39274a135/coverage-7.14.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5b0c99ba93a07d56f6df340bb79be53202a082b2fdb81bfe6190b741a3470d54", size = 253658, upload-time = "2026-05-26T20:39:15.923Z" }, + { url = "https://files.pythonhosted.org/packages/99/6f/ca6ad067364b337ef997802115e7ecad2abd2248b05471464b0dea02b4d4/coverage-7.14.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:e471bc5769ff073b058cfadb0d736b56ce067c8560eabeb0da88462df98c23e7", size = 251803, upload-time = "2026-05-26T20:39:17.537Z" }, + { url = "https://files.pythonhosted.org/packages/c0/30/b9b4d377cd9f40baf228068f5a81faf8450c6228503011bd499708483a50/coverage-7.14.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:f497a1ea81d4cd7c10ddcaa685135b9aabd291af3d55775a9ddf3cb7a364cdd9", size = 255873, upload-time = "2026-05-26T20:39:19.414Z" }, + { url = "https://files.pythonhosted.org/packages/3c/21/7c721a9e5e6bb88547d30a787aefb97512d3f54c1324c7488d9b3743f7f9/coverage-7.14.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:2222be86d0b54f5dd5a38f45f17f315f737245e857bf0bdedc70734f84a13c02", size = 251372, upload-time = "2026-05-26T20:39:21.169Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8c/f8ae5a2200130e1503cd7661a6cd3b2b7bacef98277fbf3571fb13f8b766/coverage-7.14.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:85e85586565842f6932abebd4c18bcb1074223dc0b3576e7d173ca710622813a", size = 253245, upload-time = "2026-05-26T20:39:23.097Z" }, + { url = "https://files.pythonhosted.org/packages/34/62/70a9024672a5f6910517d9628c52c9afbdd3cf8f46426af52bb148a56fff/coverage-7.14.1-cp312-cp312-win32.whl", hash = "sha256:4a28fd227808366b196a75476dced2eb35b351d6766ba9c858dc93319e87f4f1", size = 222567, upload-time = "2026-05-26T20:39:24.868Z" }, + { url = "https://files.pythonhosted.org/packages/f6/81/8b7cd386839b039ebe1855733b9f9449a8dec5d79564018234f185a7fa70/coverage-7.14.1-cp312-cp312-win_amd64.whl", hash = "sha256:54acdb6674a4661768d7bf7db32dfb9f46ab1d764f8aba6df75ce1a6a088724e", size = 223372, upload-time = "2026-05-26T20:39:26.603Z" }, + { url = "https://files.pythonhosted.org/packages/ae/ba/b44d472022f620d289d95fa830143235c0c36461c6f2437ea8d51e5481ed/coverage-7.14.1-cp312-cp312-win_arm64.whl", hash = "sha256:99cd41ff91afd94896fea3bc002706b6ae4ce95727d06e4a0f39c0a8d8bd8b1a", size = 221989, upload-time = "2026-05-26T20:39:28.242Z" }, + { url = "https://files.pythonhosted.org/packages/8a/9e/5f6d56327c62b185225d145191c607e07515294a0aa6338e58805cd4a5ac/coverage-7.14.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:be9f2c802dcfce3f71298303aa5dad0dce440a76c52f2f60dacd8656dab78793", size = 220044, upload-time = "2026-05-26T20:39:29.902Z" }, + { url = "https://files.pythonhosted.org/packages/75/92/e82aca356744cbbc0f77a0b623e38918c1872361963413a3bab5d0340393/coverage-7.14.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6223a72fd0e4c7156353ec0f08a5f93623e1d3034d0e2683b9bb8ea674131b1d", size = 220412, upload-time = "2026-05-26T20:39:31.561Z" }, + { url = "https://files.pythonhosted.org/packages/27/c9/385bde0bf7ed0f4bf3a7ee5367060a86b5d218718cfd6fb943c0f836b34f/coverage-7.14.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:7279d2110a28cebc738b6459ecda2771735a4c18465fbbd36b3288fe5ed92247", size = 251412, upload-time = "2026-05-26T20:39:33.337Z" }, + { url = "https://files.pythonhosted.org/packages/51/8c/23faf6a2343a0d17f960a4bd56c43bc7eb4cf312f774dd6ceebd82c7d8fc/coverage-7.14.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9eeb3fcbc13ba40dfbdb22d01d196a28e9cef9ed4c29b60061a1e0e823a9929d", size = 254008, upload-time = "2026-05-26T20:39:35.009Z" }, + { url = "https://files.pythonhosted.org/packages/42/06/36f4aa9ca8a815e6036156e80706a67828bb97bd826948244f6996dda957/coverage-7.14.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f0cfc27c539f07cf5c0a4cfe211d0b6cae039f8f40526dbaa71944e64b50a7b", size = 255241, upload-time = "2026-05-26T20:39:36.71Z" }, + { url = "https://files.pythonhosted.org/packages/ca/79/95266316352f90f6b1c6736bb413302edfde2453fb32422d3911642691b3/coverage-7.14.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:221c70f316241a78e77e607c227cefc8808d4e08f28d99c04f35694690e940be", size = 257373, upload-time = "2026-05-26T20:39:38.412Z" }, + { url = "https://files.pythonhosted.org/packages/e3/9c/58316d1f66c488b5fca8a0eb3e98348807813efa8a0d0833b9021be27488/coverage-7.14.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:da028256b04ec30e5e0114b6f76172938c313991f0a2d3d894271315cf5d5e43", size = 251635, upload-time = "2026-05-26T20:39:40.268Z" }, + { url = "https://files.pythonhosted.org/packages/ef/5a/ca2398a568e16fed7bb713e84ba3603a7164fb65779abe645c565ec890d5/coverage-7.14.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:76a085d7005236a767e3426148b2c407e53ad61695c562f8a81da2d373324901", size = 253373, upload-time = "2026-05-26T20:39:42.145Z" }, + { url = "https://files.pythonhosted.org/packages/6e/2c/0396562c32deaebe7be51d865b3a41e9a87d7561acafe1a28f53b07e019a/coverage-7.14.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b553d04b5e778a8e56d57eb134aff42a92718ecba45e79c4764ecfa40efd92ff", size = 251341, upload-time = "2026-05-26T20:39:43.907Z" }, + { url = "https://files.pythonhosted.org/packages/fd/8f/a94f9221184c9cae1ee115820e3798e48b6b17777a9f19e46fb9a0c8dc74/coverage-7.14.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:46f714d2fb8ae2f4f29f23ada7f1e79b759fff5a70f94a1dac23af204c3ec9e4", size = 255497, upload-time = "2026-05-26T20:39:46.166Z" }, + { url = "https://files.pythonhosted.org/packages/71/69/505d70e47db1eaebcd002c39759707621ef184cd6b1ae084d9f41293f323/coverage-7.14.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:1896f5e19ff3f0431c7ce2172adc54890fd97f86b59ced8ca1649145d9ffe35d", size = 251159, upload-time = "2026-05-26T20:39:48.03Z" }, + { url = "https://files.pythonhosted.org/packages/e0/aa/58681c383aa33a9d2ed40a02d7a22fbf780d1fa4d575396365777828198c/coverage-7.14.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:62fd185ef9df3c33d1c8178c5af105f762afbad96038de9a4ae100aa6297ca33", size = 252934, upload-time = "2026-05-26T20:39:49.872Z" }, + { url = "https://files.pythonhosted.org/packages/eb/fd/11c928cd6bdffc7074bb5965c173d9ebf517fb00205e1da524b98d29ef92/coverage-7.14.1-cp313-cp313-win32.whl", hash = "sha256:ab4af6352741a604c431c6072fce5bee33bf0f20dc7a56618d6bf6bb89e9810c", size = 222584, upload-time = "2026-05-26T20:39:51.68Z" }, + { url = "https://files.pythonhosted.org/packages/6f/92/fb416fc26d340dcba19518c418d6048e913186e17243982c5e435e41fa7a/coverage-7.14.1-cp313-cp313-win_amd64.whl", hash = "sha256:7af486dabe8954d03b087f0021540897afe084f04e16ff5579e08cc46f871416", size = 223394, upload-time = "2026-05-26T20:39:53.472Z" }, + { url = "https://files.pythonhosted.org/packages/73/c6/02d56e3867972f77d5036de924643f26c056e848f00452cafb4dbc3c29b4/coverage-7.14.1-cp313-cp313-win_arm64.whl", hash = "sha256:2224f89ffd0c5605ccce1ed7a584da162bc7c55f601ab1c946bc9de31a486b42", size = 222015, upload-time = "2026-05-26T20:39:55.374Z" }, + { url = "https://files.pythonhosted.org/packages/4d/9e/fcc77914050df73f7662fa1f00902774c79c075a8388ab334074574bf77e/coverage-7.14.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:de286598cc65d2b489411174b1faec2f5a7775fb3201fd925db2a76b4030f37d", size = 220733, upload-time = "2026-05-26T20:39:57.189Z" }, + { url = "https://files.pythonhosted.org/packages/f7/67/2963cbdaf5cbadec44efa3a1e39eaa1f02df4079585f05387607a221e126/coverage-7.14.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:042c46ded7c288aeb07cf14a28b6c1e10b78fcba40171c3fa1e939377eeef0b5", size = 221086, upload-time = "2026-05-26T20:39:59.019Z" }, + { url = "https://files.pythonhosted.org/packages/c8/c5/8701645574e11881f2f47d8930f98bc48b5d43b25eb5b4430dfc4a2f9f48/coverage-7.14.1-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:f4ddbe407477f04c45115d1a4e5bc480f753553b534d338d4c3358b1cdd0ea52", size = 262381, upload-time = "2026-05-26T20:40:00.822Z" }, + { url = "https://files.pythonhosted.org/packages/7c/28/7a64d73598263e0c5abd5084211a8474488d31b3c552ff531c719dfcff62/coverage-7.14.1-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:d13e6725992e2d2fd7d81d4f5241952d13740121dfd501da09201be39b2c003a", size = 264458, upload-time = "2026-05-26T20:40:02.506Z" }, + { url = "https://files.pythonhosted.org/packages/fa/d8/4969179db9f7eb4df218e69540adf829d1c835f59452513d065d15446802/coverage-7.14.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f747dc8edcfe740130f28f32f3995e955494285717e86ee25af51db2219df08a", size = 266884, upload-time = "2026-05-26T20:40:04.421Z" }, + { url = "https://files.pythonhosted.org/packages/a6/78/a45d5794dbc9bafd97afc96a4377c86c7820d78b6cf51b89bc1d4e919275/coverage-7.14.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ced2f09ef276fd58611a1ef502164ad266d2b75174e5a40cabbdb4033f9f6cf2", size = 268022, upload-time = "2026-05-26T20:40:06.298Z" }, + { url = "https://files.pythonhosted.org/packages/21/cb/4f5e354e9e3e67af96bd4e57113e6db6b22298c7168b13eec408a549903d/coverage-7.14.1-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b84800013769a78ccb9ef4659402e26d06867e337b61ec365f77ad008adea80e", size = 261631, upload-time = "2026-05-26T20:40:08.226Z" }, + { url = "https://files.pythonhosted.org/packages/ec/49/eced49af4cb996d5d8b7e94e736175c513e4facd3398507b89892b4326d8/coverage-7.14.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:ea8cd6ca0ee9f616aaef3afc6882e32c2cbf18b00d96313ffd76af650574034d", size = 264443, upload-time = "2026-05-26T20:40:10.137Z" }, + { url = "https://files.pythonhosted.org/packages/f1/d8/5603a88a7c5913a6b54f6cb1a8c46f7b39cbb30f27cd3f492908da09b2d7/coverage-7.14.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:aa5e304a873fabddc11e484e9b6b738bd38bd7bed17b09aa84eecf5332e8b8bb", size = 262069, upload-time = "2026-05-26T20:40:11.999Z" }, + { url = "https://files.pythonhosted.org/packages/f0/59/2ae3cb79da554a06c8619d6c88ea19dd1e4aed4b834b6a83bb1fa243bdc5/coverage-7.14.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:5a1c5215be81035e629d5bc756650634d0bf31991038db7a0eccb90f025ce16d", size = 265780, upload-time = "2026-05-26T20:40:13.858Z" }, + { url = "https://files.pythonhosted.org/packages/af/5f/b130c1dc999031f2648bd25317fbce505ad8d5562079b4ed81e736a84967/coverage-7.14.1-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:79058c47dae6788504b5effb319961bcd72d7240551464b91d474bc0ed186d69", size = 260970, upload-time = "2026-05-26T20:40:16.142Z" }, + { url = "https://files.pythonhosted.org/packages/87/d1/ec13ccddeb48ec963bdfa72a11224bac2584bd045ba13beca82f8113e9c7/coverage-7.14.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:370c5afae3fa0658e11694a32b24c2778f6bc2d17718121f94ee185e69f26b54", size = 263157, upload-time = "2026-05-26T20:40:18.382Z" }, + { url = "https://files.pythonhosted.org/packages/cf/c2/cd91ead503045161092d3845f7bb95ea2f25131ce96d3e314dd835d91b9c/coverage-7.14.1-cp313-cp313t-win32.whl", hash = "sha256:3758dd0a7f1fa57365ef2e781df0f0731d38b6e3772259d13dae4bd8a958d4b1", size = 223259, upload-time = "2026-05-26T20:40:20.381Z" }, + { url = "https://files.pythonhosted.org/packages/71/9f/1e28d97e6bd2c76b07f38b7c02870f1371255ff6717f54eca578fcbbdd0e/coverage-7.14.1-cp313-cp313t-win_amd64.whl", hash = "sha256:6ff665fb023a77386fe11685190cee1f60a7d635994a30d9b0a061533d470fce", size = 224320, upload-time = "2026-05-26T20:40:22.316Z" }, + { url = "https://files.pythonhosted.org/packages/a9/e0/d936e908f0e1efa55e52b91e01b52f1055cef5e1ab2718493390ed8e2fb8/coverage-7.14.1-cp313-cp313t-win_arm64.whl", hash = "sha256:17a5a241e5997621a956a7f402a7433ef4221e5152809b785bec79e2323799f1", size = 222577, upload-time = "2026-05-26T20:40:24.894Z" }, + { url = "https://files.pythonhosted.org/packages/d6/34/fc2f101b151af3799a101f0550b0454aa008afdc0add677394ec4aa8ea10/coverage-7.14.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d5ed429d0b8edaac649e889b4ffcedb6c80b06629a3f93050e3dddfb99235bee", size = 220091, upload-time = "2026-05-26T20:40:27.249Z" }, + { url = "https://files.pythonhosted.org/packages/3d/a7/1ebae2ab5b961b5c79bb09fe7b3ac99edb190d8be4a8c510b2cf66f46468/coverage-7.14.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:8011224a62280e50dab346960c03cf47aca1a1e09e608c0fb33fd6e0cc8e9500", size = 220421, upload-time = "2026-05-26T20:40:30.084Z" }, + { url = "https://files.pythonhosted.org/packages/5e/90/92aca9cf0acc95123c96cd1eb1f08917897a7f5dee01e15738922971ec31/coverage-7.14.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:12c42ec1e14f553c4f817e989365982e646e27211f10a0f717855b94a79c8906", size = 251466, upload-time = "2026-05-26T20:40:32.542Z" }, + { url = "https://files.pythonhosted.org/packages/26/2b/78048cbe3b999f6cbf9cc0d90abba6a88a3e0863a8c1c6cbc762f3f8802f/coverage-7.14.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:06144cd511cf2624873a035c5069cf297144f6e77a73ee3d7a55b605ec5efb42", size = 253973, upload-time = "2026-05-26T20:40:34.473Z" }, + { url = "https://files.pythonhosted.org/packages/8e/21/c2e33b29d1cfde484a19d437afc343c6cd30b08d78cbbf9f5aff14e57b2b/coverage-7.14.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a311d8e1da24be5c1ccf85cbfb06315dbaa1703d5a1eab3f6432c72b837917c8", size = 255318, upload-time = "2026-05-26T20:40:38.154Z" }, + { url = "https://files.pythonhosted.org/packages/8e/ee/aad2f108d63b769121005302f16bf66db8625c88ceaba466942e09a2607e/coverage-7.14.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c79cead5b5bc584d9c71451cb984d0e3a84e0c0937379c8efcbf27c8d661b851", size = 257633, upload-time = "2026-05-26T20:40:40.164Z" }, + { url = "https://files.pythonhosted.org/packages/c2/f8/11a2c29b4fd76d9849f81d0bb812ec0017a9396df3217214e38934a8c837/coverage-7.14.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dcbf65f1f66a26cdd88c35cf68fb4729c5d1cd2e88added72420541dfb212034", size = 251488, upload-time = "2026-05-26T20:40:42.631Z" }, + { url = "https://files.pythonhosted.org/packages/c9/b8/9a5820de4b8ac2b71d85e3b5fb49108d7469c665f0e2ad0dd7569023e305/coverage-7.14.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fd86572566fb40189a8260446158235159bc7a82dfbc87a3b39cf4fb57fcec1c", size = 253329, upload-time = "2026-05-26T20:40:45.208Z" }, + { url = "https://files.pythonhosted.org/packages/6b/ff/f33e4823667e27548e8fd8df44217515303f9808d0ff29817db56f87d990/coverage-7.14.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:7771b601718fdde84832c3a434ca9bbf4ae9adbc49d84198b4110700c3c77c36", size = 251291, upload-time = "2026-05-26T20:40:47.502Z" }, + { url = "https://files.pythonhosted.org/packages/68/9b/489db0ebb209054766b90a9014a45f6d26eb724c02ec21311c3733b5a644/coverage-7.14.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:39b21e212c55af06fa375e3dbf90a8a8e38792f3a910c580066d23563830ddd5", size = 255564, upload-time = "2026-05-26T20:40:49.372Z" }, + { url = "https://files.pythonhosted.org/packages/27/b5/16bc2d4c2409b23c7737edb68c83bc89e345f378050549fe1d75ac7d34d5/coverage-7.14.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:f2302660e32562a532b442480121aef8aa61a5bdb20b30bf0adab29f10a5a4b4", size = 251107, upload-time = "2026-05-26T20:40:51.677Z" }, + { url = "https://files.pythonhosted.org/packages/7d/0c/2629997469a00cd069d588a41c9dc887610f2775ae89d250c4791e65272a/coverage-7.14.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:03a6f93c1ec3b7f2e77b5dbcc5573a2c21f12529a5c6bbe0f16f72303cc2fa4d", size = 252764, upload-time = "2026-05-26T20:40:54.267Z" }, + { url = "https://files.pythonhosted.org/packages/d2/ee/f78d63c8f079e0d7211c7e2401fa17e311514534ba61bae03e4b287ce4ab/coverage-7.14.1-cp314-cp314-win32.whl", hash = "sha256:8a3ce026d73290f42f08dafecbd82c193a74df280461fbf97300fec51fd133ee", size = 222837, upload-time = "2026-05-26T20:40:56.496Z" }, + { url = "https://files.pythonhosted.org/packages/dc/b9/be539854f93a70dfbeec69117f33ec70dc42ff0b65b5b07ab8d40d04228e/coverage-7.14.1-cp314-cp314-win_amd64.whl", hash = "sha256:114c95ef29302423b87d159075805f4ab973254a2638a5d7d046c94887cc87d7", size = 223650, upload-time = "2026-05-26T20:40:58.351Z" }, + { url = "https://files.pythonhosted.org/packages/fe/9e/24e2842fef40f35ac82ba3a7719c8023d011bf3bf652d0675316a9d088a1/coverage-7.14.1-cp314-cp314-win_arm64.whl", hash = "sha256:a07891c3f4805442b31b71e84ba3cf29ed1aa9a428284e06deeb4b23e5b46343", size = 222218, upload-time = "2026-05-26T20:41:00.321Z" }, + { url = "https://files.pythonhosted.org/packages/0a/1d/ac0a9df5fe31c1e8bdd658074905fc12844a05c1a7e3fdb8417e97c31e23/coverage-7.14.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:1101a5ebb083aecb625ebb6209d4105b58f647b093cb2dc8122d7b33f743cfe1", size = 220822, upload-time = "2026-05-26T20:41:02.281Z" }, + { url = "https://files.pythonhosted.org/packages/32/cf/f964fd9aff20323f9f1a726c97135f8a76bcd87b92dad141a456a43f3c64/coverage-7.14.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:851b9e1e4e8a4608e77c79714b2e77c0970d2ed7202a05e92ae407817481887b", size = 221084, upload-time = "2026-05-26T20:41:04.593Z" }, + { url = "https://files.pythonhosted.org/packages/d8/5e/7e5ef2aba844de2b80d678619fcf0841b42e3f37f16411226f3fe4c1016f/coverage-7.14.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d5b89cdfb2ee051b71e8c3c70bd81a9eff81100f736a269136fe1a68efe00474", size = 262454, upload-time = "2026-05-26T20:41:06.641Z" }, + { url = "https://files.pythonhosted.org/packages/64/62/75809bded87015cc4935524218a2a8ed8dd1a8498bfed30a2f4f7a4b4d34/coverage-7.14.1-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0177614a0370f227888b4e436a7c55686d6a9f90eb1ade2b624ba685a1686e86", size = 264578, upload-time = "2026-05-26T20:41:08.556Z" }, + { url = "https://files.pythonhosted.org/packages/f3/42/d33392dc14633525012d2d504fa1a33b05538bf535f5c1d64675e5754b78/coverage-7.14.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2d69af5dea2de76fc485a83032a630523f985198b7e25be901ec60181587b01e", size = 266981, upload-time = "2026-05-26T20:41:10.824Z" }, + { url = "https://files.pythonhosted.org/packages/2a/49/0157c4428c2aca7f1e09d5565930586fd5ae36f1655f08b0daa7cf1fcae1/coverage-7.14.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:35ab22d91de736e8966b980dc355cbcdd2c6dbbcfe275f9a2991bc8a91b3df65", size = 268112, upload-time = "2026-05-26T20:41:12.966Z" }, + { url = "https://files.pythonhosted.org/packages/96/26/86b9ce71f4092b1ed325ce1421698081df1286b833400b6836912834d6e0/coverage-7.14.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:357d4e32935c36588aaba057d734fa32428c360c9fc2e4442afbf1b646beee6e", size = 261558, upload-time = "2026-05-26T20:41:15Z" }, + { url = "https://files.pythonhosted.org/packages/20/4c/c311210c5472cf5401d8422b0d7812cdd520f24417673afabda6c323faca/coverage-7.14.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:51bd64741cc6fa065abd300ede1afe5a5291ece9c31da8b24884deda48bcc3f8", size = 264447, upload-time = "2026-05-26T20:41:17.369Z" }, + { url = "https://files.pythonhosted.org/packages/fb/71/59513f8710ed3e6b0ac0a050a5b7e977bb9c9e880354863b5d00d8809256/coverage-7.14.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:9132cd363a68a4c3daa7c8704a654b1e39d3360f6f5b8ddd470608a945236c07", size = 262048, upload-time = "2026-05-26T20:41:19.309Z" }, + { url = "https://files.pythonhosted.org/packages/84/8d/bceed32dc494f5bbf50f775cd2e78ca814953942b5ea28d3c1c3ac316f14/coverage-7.14.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:07c6290b1697b862c0478eab545eec949a0d0e4d6d03497f446d706da3b4f2de", size = 265781, upload-time = "2026-05-26T20:41:21.559Z" }, + { url = "https://files.pythonhosted.org/packages/e7/c5/9348fe40dbfd4991aaf78df2c6c3098bfb2cc834d1fd362a64b4efef855a/coverage-7.14.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:5ea0c297e27133853b4d8a3eb799bff5a2dbd9f2f41537a240d337ac9b4df890", size = 260896, upload-time = "2026-05-26T20:41:23.428Z" }, + { url = "https://files.pythonhosted.org/packages/ca/92/1ea0f03929da7cf87206b1fa24f4c8e9c158be0455481af29ec0a1f3503f/coverage-7.14.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:01b7733daad0237daa01ef80fe2dfceffc911e6a17fa7b55d14aa8214eaaaecd", size = 263214, upload-time = "2026-05-26T20:41:25.419Z" }, + { url = "https://files.pythonhosted.org/packages/f6/a9/b2493c054c0e01a643266742ab45e15744e60743f9260cd930c7142b1124/coverage-7.14.1-cp314-cp314t-win32.whl", hash = "sha256:6adc5a36984624a70bf11d7184e20fa0a49aa7c47ffab43804106a1a695ea22e", size = 223624, upload-time = "2026-05-26T20:41:27.795Z" }, + { url = "https://files.pythonhosted.org/packages/fc/bd/3e1e6a57fccd2d7c83fcdf338e93ba98eb85c6e877dd34731ac585375490/coverage-7.14.1-cp314-cp314t-win_amd64.whl", hash = "sha256:ddf799247318f34dbcd2efa8c95a8d0642674e926bb1774cf9b63dfd2a389d1c", size = 224728, upload-time = "2026-05-26T20:41:30.098Z" }, + { url = "https://files.pythonhosted.org/packages/bb/d7/31066cf1d2f0c6c797fce911bcfa01dd35642dc6da992a950256097c5860/coverage-7.14.1-cp314-cp314t-win_arm64.whl", hash = "sha256:145986fe66647eb489f18d9a997567a3fd358584c4b5a808769113abc07466af", size = 222752, upload-time = "2026-05-26T20:41:32.123Z" }, + { url = "https://files.pythonhosted.org/packages/8a/3c/1a983b9a745d7f83d53f057bcc5bf79ba6a2bbc08266b3f0c7d6fe630c9b/coverage-7.14.1-py3-none-any.whl", hash = "sha256:a252f21c27e38347e60111a3266b03827422a7d5525951aceee313aa68bab1d2", size = 211815, upload-time = "2026-05-26T20:41:34.078Z" }, ] [[package]] name = "cuda-bindings" -version = "12.9.6" +version = "12.9.7" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "cuda-pathfinder" }, ] wheels = [ - { url = "https://files.pythonhosted.org/packages/08/9d/dd87e1071bcb2e438c14e2e4497aa0037faf2c9775ac1d172f578f448668/cuda_bindings-12.9.6-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bb2f1eedc8f65902b34e807c21a3b7c922dc8de1f51d0829ecbb5c6a5e9c5ff1", size = 7094433, upload-time = "2026-03-11T14:47:22.811Z" }, - { url = "https://files.pythonhosted.org/packages/8c/1d/5631df2faa5e5f6bd3e8fef098d6fc1b7c6f38811821332ef28ad82ce0d4/cuda_bindings-12.9.6-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d9f9031e7a265e74f1517668139987253552d1677d995da4b0d990aa19b9b9b0", size = 7626833, upload-time = "2026-03-11T14:47:25.046Z" }, - { url = "https://files.pythonhosted.org/packages/1b/76/d1783a73719c3e083305766b097115c21311a0e6c939af99910826419e99/cuda_bindings-12.9.6-cp310-cp310-win_amd64.whl", hash = "sha256:69e820e72af29bac65cf821a0a7b2546ef4cca5685640739a828c00ef91fdbef", size = 7148460, upload-time = "2026-03-11T14:47:27.469Z" }, - { url = "https://files.pythonhosted.org/packages/1f/a5/e9d37c10f6c27c9c65d53c6cd6d9763e1df99c004780585fc2ad9041fbe3/cuda_bindings-12.9.6-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2662f59db67d9aeaf8959c593c91f600792c2970cf02cae2814387fc687b115a", size = 7090971, upload-time = "2026-03-11T14:47:29.526Z" }, - { url = "https://files.pythonhosted.org/packages/66/d5/bd4c03e9516d3cf788a270debe28d687e5c48b13a9931599bbddf01de302/cuda_bindings-12.9.6-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e8519707644ea630a365b101703a9136f4cb144760cc2c73281c38a05e07d08d", size = 7618785, upload-time = "2026-03-11T14:47:31.531Z" }, - { url = "https://files.pythonhosted.org/packages/ca/7b/178b040b35638e93a601aabc6061d52150f6685c7520536b4e7e108db5f9/cuda_bindings-12.9.6-cp311-cp311-win_amd64.whl", hash = "sha256:e0ac0a4facdb9a6563984ae4917c7a658cbc6a5d0feb858e5a79ba4047c36397", size = 7175051, upload-time = "2026-03-11T14:47:33.213Z" }, - { url = "https://files.pythonhosted.org/packages/50/04/8a4d45dc154a8a32982658cc55be291e9778d1197834b15d33427e2f65c1/cuda_bindings-12.9.6-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ea331bc47d9988cc61f0ecc5fa8df9dd188b4493ae1c6688bb1ee8ce8ba1af4", size = 7050347, upload-time = "2026-03-11T14:47:35.221Z" }, - { url = "https://files.pythonhosted.org/packages/3b/69/4b0375e1b120dfa7427c31c8420cfdee596ecd03955fd291a96116fa375d/cuda_bindings-12.9.6-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b2b54b95a47104eff56b5155818ab5790e3ccdba8dd51e2928ae56782aaf5b02", size = 7590574, upload-time = "2026-03-11T14:47:37.452Z" }, - { url = "https://files.pythonhosted.org/packages/a4/35/71b818233e1ea503face2a0e6f6f2c73ca02b946ca9613104667ba4a8454/cuda_bindings-12.9.6-cp312-cp312-win_amd64.whl", hash = "sha256:407b85671c363a5ddf77cd4bdeb05355340a88ac2cd0c6adc1a0f4b4d11c13c2", size = 7364562, upload-time = "2026-03-11T14:47:39.188Z" }, - { url = "https://files.pythonhosted.org/packages/dd/ad/2d9b80c28deae971ce4bbe991c23b81347a2a8918b2672020d07f070a596/cuda_bindings-12.9.6-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:da30d89db8188b9beb5a6467d72b2f11d1b667ab901d2d373bcde51b97765b21", size = 6950608, upload-time = "2026-03-11T14:47:40.944Z" }, - { url = "https://files.pythonhosted.org/packages/b2/ca/729781d11445cfbacd1af1bf0edfe147c311212cfdf1d5c292e0565fabef/cuda_bindings-12.9.6-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3d1be8bd80b34f51dcbaf138dafd817e888cf2d12c47833019fd933beb32d7ef", size = 7439531, upload-time = "2026-03-11T14:47:42.757Z" }, - { url = "https://files.pythonhosted.org/packages/be/43/596306849cce32b3fea0f9efa739651b37818ede2fff57a6b7912fc28401/cuda_bindings-12.9.6-cp313-cp313-win_amd64.whl", hash = "sha256:ee82fd3588ad28ec9887503bf81b329b89ea9ac0df726e0e50fb377abd57d2a0", size = 7321230, upload-time = "2026-03-11T14:47:44.664Z" }, - { url = "https://files.pythonhosted.org/packages/fe/f3/51768221aade33e711dcf7e4a52fdc0d0446c1baf39f6bcc9d69cfbceb0b/cuda_bindings-12.9.6-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48666e666f083a4c4387ffe20594b05e092b535a4453d1e4817d71237d02aa13", size = 6861186, upload-time = "2026-03-11T14:47:46.335Z" }, - { url = "https://files.pythonhosted.org/packages/71/34/14afff4aabe3b5bd84c647dea4a4dfb917c94b8a8df0adb6b1622c2b465b/cuda_bindings-12.9.6-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b4f82f8f8061f3a39446bf854c4edd9bcc2d0da3f58d8f6f54541b3e4d5c933d", size = 7356548, upload-time = "2026-03-11T14:47:48.209Z" }, - { url = "https://files.pythonhosted.org/packages/9d/d0/887866f28e15f021ea42f298ede9de2477ef9f2eeac6c14e2dba8bea7a0f/cuda_bindings-12.9.6-cp313-cp313t-win_amd64.whl", hash = "sha256:b1731d651fe05e795295bf011e98bae0ad5cc29759da7ccb6ff946cc541b50c1", size = 7736392, upload-time = "2026-03-11T14:47:50.229Z" }, - { url = "https://files.pythonhosted.org/packages/3d/d3/a29faf4fb371c2f43ffda23a938ec0bebf6dbab676350e137ae0f61e5ec0/cuda_bindings-12.9.6-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f00290f9468d2cfeee92aaad2275be32dfd2f4967a97ac0f12314b7e6281ad78", size = 7046617, upload-time = "2026-03-11T14:47:52.46Z" }, - { url = "https://files.pythonhosted.org/packages/2a/97/71e66b2ed65d80f7b70a1538af72d73cd798e22bc93d240d7e69f2366322/cuda_bindings-12.9.6-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d3bc6e28cf5d133f72050c515db72876870fb009f1431bcbf45b54a179be2284", size = 7481379, upload-time = "2026-03-11T14:47:54.281Z" }, - { url = "https://files.pythonhosted.org/packages/cb/74/7aaaf7f29fa972da0e9e0c07dfdef4f18225df78c152b30f08763ffe03e5/cuda_bindings-12.9.6-cp314-cp314-win_amd64.whl", hash = "sha256:2b23ac88152b2b09f9c12fb70d5e07c25f17e915ab2e1b1dec7b702b25ae5dc6", size = 7458439, upload-time = "2026-03-11T14:47:56.386Z" }, - { url = "https://files.pythonhosted.org/packages/49/91/c10b575a001aad39c036efd649869aac8d97ef0ba9f1d8ad17b4946b3366/cuda_bindings-12.9.6-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e88d38fdf07cc777dec1afaba8139c2eedb3819063f6b42f1e2ea8516bdd6806", size = 6879714, upload-time = "2026-03-11T14:47:58.095Z" }, - { url = "https://files.pythonhosted.org/packages/2a/9a/998471e76bea78e96d3d7fdf0bc5f46c3210858e81e6d13d8186a9dbb636/cuda_bindings-12.9.6-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4df01e34cefd3275170b2ac0426d325271ab435e85f59a69300eacd8ff23d34c", size = 7367020, upload-time = "2026-03-11T14:47:59.781Z" }, - { url = "https://files.pythonhosted.org/packages/4b/98/8e5363d00c959d4172b1d619a4f03af454bf9952636224f0ac0f5c35c067/cuda_bindings-12.9.6-cp314-cp314t-win_amd64.whl", hash = "sha256:7f0a08eba6e807d041bf6f2ba66d84db1ddf54787399dfac716497ef40fb5fc3", size = 8162218, upload-time = "2026-03-11T14:48:01.554Z" }, + { url = "https://files.pythonhosted.org/packages/cd/2e/b1b14be5884519917f9df4d9106d3e16575c19fa847d13a3f6e9d272b5cd/cuda_bindings-12.9.7-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a318075ef3277ca2fdd7df5d4bf671388696b4f2b65e2c4483f1853517692e3b", size = 7127291, upload-time = "2026-05-27T18:44:02.409Z" }, + { url = "https://files.pythonhosted.org/packages/82/1f/0809c53f694693d703c9efee0379875089db17ab50196845e08f6c686fd4/cuda_bindings-12.9.7-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f95debd2c54c5f087462668511bcb2b1295baa389cd6de9e768212f3cab2bbe2", size = 7657751, upload-time = "2026-05-27T18:44:04.365Z" }, + { url = "https://files.pythonhosted.org/packages/19/26/fdd044c00e8f20f783bcb8b9cce0144fbefacf6ed23a64318dc1c4d8db99/cuda_bindings-12.9.7-cp310-cp310-win_amd64.whl", hash = "sha256:62e245bfa4830d473b038d0d7e5ab9cc1b377a09d2bc9afceaf5c5bab96ab1c6", size = 7190277, upload-time = "2026-05-27T18:44:06.044Z" }, + { url = "https://files.pythonhosted.org/packages/40/f3/f9d1095f90d2a4df24cfcafe7487fd9444c6dacb94e3722be6fedd8ac26c/cuda_bindings-12.9.7-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:16043ef5b15ab88fe9954c5c2061b1d8007591b27f2c916331056de0ebc6187e", size = 7114834, upload-time = "2026-05-27T18:44:07.746Z" }, + { url = "https://files.pythonhosted.org/packages/3a/8a/1251e1794b69865aacd5629936006b18ea0816a495de4ecea9a825556eb3/cuda_bindings-12.9.7-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c6496a88d84b1209d6651b0370c19c26319e157c22f6d018bf9a358cd8049041", size = 7647147, upload-time = "2026-05-27T18:44:09.4Z" }, + { url = "https://files.pythonhosted.org/packages/1e/39/158392f6572e6e0def70ca39029c46b75e02ea4a43c63ff7320b3d180a29/cuda_bindings-12.9.7-cp311-cp311-win_amd64.whl", hash = "sha256:c392ffa5010ef4073bfd9dfff4d1ae56032094ed52d3d732014f8e41a73e6b59", size = 7218081, upload-time = "2026-05-27T18:44:11.104Z" }, + { url = "https://files.pythonhosted.org/packages/32/45/557d4ed1fa54f0c7db8aee083229f624990d69f7d00f55477eed5c7e169a/cuda_bindings-12.9.7-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0666d3c082ef8f4b2d670950589373550e9f3bf564d635dd883f24a0b40402ff", size = 7071026, upload-time = "2026-05-27T18:44:13.356Z" }, + { url = "https://files.pythonhosted.org/packages/91/97/e3c6e58ece26a053419ba0a18444b5443cfc64451bbf37f84e8143b8bdca/cuda_bindings-12.9.7-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4c7ef48c5e13ae90f3b2ecfb72f8e99ac43c8f4c43e67e1325b8aae331453687", size = 7611059, upload-time = "2026-05-27T18:44:15.252Z" }, + { url = "https://files.pythonhosted.org/packages/6d/39/afaa3de4d491a55af8961081e0b69c08d51bfbe471c359a7bddb4a28ca41/cuda_bindings-12.9.7-cp312-cp312-win_amd64.whl", hash = "sha256:3c089aaf4f5f570ec50244c68f5a2b00a2c9a8e01e04219fd2e36e340be0d88b", size = 7400841, upload-time = "2026-05-27T18:44:17.164Z" }, + { url = "https://files.pythonhosted.org/packages/eb/7b/f1575e41e1a17dc2f2a408b2e8e864c9324e41e3e23f6401e5efc54c152a/cuda_bindings-12.9.7-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:266379e4942051f544a8e7ea1a30ead8d7e8199b6b30fcdc8917cae2bf614e61", size = 6978549, upload-time = "2026-05-27T18:44:18.839Z" }, + { url = "https://files.pythonhosted.org/packages/9d/dc/62d62eb4f91eb721bcf46da51b13e9872ccd8fa7e60eb8ba7b7baeac72c6/cuda_bindings-12.9.7-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:59cf4a37b0d662ba15037c9ceebe1a306ebf2c01a8235a09be13cd07094fdb74", size = 7457675, upload-time = "2026-05-27T18:44:20.637Z" }, + { url = "https://files.pythonhosted.org/packages/43/b2/753fe88151001d0dc23f56a8e119fe06b991b0d1a885fa02f9852b12f523/cuda_bindings-12.9.7-cp313-cp313-win_amd64.whl", hash = "sha256:5bd89dcb78475a6d8a4620ea94b74edf0cbbeacee6d1622d8f94452c1e8d3f15", size = 7360097, upload-time = "2026-05-27T18:44:22.405Z" }, + { url = "https://files.pythonhosted.org/packages/f9/77/94d9b85f26add6fe9c9cb7c4ec3b96bc598f7ea5cfbd7490cc0a36adf5be/cuda_bindings-12.9.7-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2dbcd4801954eb3508f4dc2fa0d0c8eb93eb3f45326fd61be2731418c371e7a0", size = 6870886, upload-time = "2026-05-27T18:44:24.164Z" }, + { url = "https://files.pythonhosted.org/packages/04/dd/3ec34b569e1b990b11276feba306bf8f446656cc38e8ed0f49b5facfeffa/cuda_bindings-12.9.7-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3747ea132642416786a8e31bf229032df3a7856911ae5426a7be53d032df183d", size = 7345663, upload-time = "2026-05-27T18:44:26.333Z" }, + { url = "https://files.pythonhosted.org/packages/b8/c8/d79a20ba396e7ab2dfdd4b72b62356972b25b88aee2ded49a70c797ddea1/cuda_bindings-12.9.7-cp313-cp313t-win_amd64.whl", hash = "sha256:64f7ade7a7a3b69001489753acc21706d9dbda32db8deb68a767a0a0aab30b68", size = 7780136, upload-time = "2026-05-27T18:44:28.121Z" }, + { url = "https://files.pythonhosted.org/packages/68/e4/075052d42872cf8162da53f14447a4b8abc004c3750e4b724ee502428da0/cuda_bindings-12.9.7-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:775960ac9e530717f3b48e165cc6f68684fa9a4141764fd923e4c1a9820acc73", size = 7060090, upload-time = "2026-05-27T18:44:30.281Z" }, + { url = "https://files.pythonhosted.org/packages/ec/cd/3289c810a4d45e5364a3387a74b4c9b6f6f57ee96ae0e5b537cc61dec242/cuda_bindings-12.9.7-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3c47ec1a7a441d91aab32339951df7a1be53451121a12c094bba51467717a35a", size = 7504419, upload-time = "2026-05-27T18:44:31.992Z" }, + { url = "https://files.pythonhosted.org/packages/5b/a0/c429fdcfa5aae181415504c5085ea5944f782b417dd16a7f2a14be0da80d/cuda_bindings-12.9.7-cp314-cp314-win_amd64.whl", hash = "sha256:1e2a4f2ec5b67408c04bb4fbed45d214b66de1f00ee2e972865cacb8708d4e1e", size = 7493876, upload-time = "2026-05-27T18:44:33.618Z" }, + { url = "https://files.pythonhosted.org/packages/11/43/472a6281c3d94e71687e27c657a8f60718d3579b4d94c41deea503165f8a/cuda_bindings-12.9.7-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:00a833d399b31071fab4cf3de2929840ae462dc4848116eeff033d09219e7116", size = 6899146, upload-time = "2026-05-27T18:44:35.556Z" }, + { url = "https://files.pythonhosted.org/packages/2b/13/10c1d0b32a9da65142d213e0733d748457fb3fd066aee4317335266f15c6/cuda_bindings-12.9.7-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11aeafa2b33995f890086b3fb0f062075176d956e9b6a6fe1a699dddc413f6ad", size = 7369087, upload-time = "2026-05-27T18:44:37.359Z" }, + { url = "https://files.pythonhosted.org/packages/33/10/c71a07cd2a1d4db119bada1848b4752a874ccfe4927d419bfdd05f250920/cuda_bindings-12.9.7-cp314-cp314t-win_amd64.whl", hash = "sha256:ece8dfbc22e6de96a26940ab9887eb3cfe1fc1bc3966169391cdb866bb82bb64", size = 8208198, upload-time = "2026-05-27T18:44:39.053Z" }, ] [[package]] @@ -474,21 +469,21 @@ wheels = [ [[package]] name = "cuda-pathfinder" -version = "1.5.4" +version = "1.5.5" source = { registry = "https://pypi.org/simple" } wheels = [ - { url = "https://files.pythonhosted.org/packages/11/d0/c177e29701cf1d3008d7d2b16b5fc626592ce13bd535f8795c5f57187e0e/cuda_pathfinder-1.5.4-py3-none-any.whl", hash = "sha256:9563d3175ce1828531acf4b94e1c1c7d67208c347ca002493e2654878b26f4b7", size = 51657, upload-time = "2026-04-27T22:42:07.712Z" }, + { url = "https://files.pythonhosted.org/packages/11/c8/26f2e4aae92f11522a96043892ba39a90eac610d5242523aa863212bc1c7/cuda_pathfinder-1.5.5-py3-none-any.whl", hash = "sha256:0228c023f95d1480f143ef5c8922d27a2ab052087a942e81dc289c9eb8f91689", size = 51671, upload-time = "2026-05-27T01:21:25.413Z" }, ] [[package]] name = "cuda-python" -version = "12.9.6" +version = "12.9.7" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "cuda-bindings" }, ] wheels = [ - { url = "https://files.pythonhosted.org/packages/57/69/4a79126959ad6f1653504122ee1eb22d089dd6272d3fa37694dcdeb78ba5/cuda_python-12.9.6-py3-none-any.whl", hash = "sha256:ed5cf30e1129729eecf4605dff6e8bce84f2d30c17b17c7e5ac4b76448de35d2", size = 7596, upload-time = "2026-03-11T15:35:17.282Z" }, + { url = "https://files.pythonhosted.org/packages/c1/9d/05e753afbaac3f92691059b3ba875589c98a425d69e5808cec32b31b580c/cuda_python-12.9.7-py3-none-any.whl", hash = "sha256:23a1fc406d491eef7a7e985095725cb7b20a04a7bd9b7a66400e5c86e082e0aa", size = 7597, upload-time = "2026-05-27T19:50:32.605Z" }, ] [[package]] @@ -585,7 +580,7 @@ wheels = [ [[package]] name = "cupy-cuda12x" -version = "14.0.1" +version = "14.1.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "cuda-pathfinder" }, @@ -593,21 +588,23 @@ dependencies = [ { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.11' and extra == 'extra-8-narwhals-cudf') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing')" }, ] wheels = [ - { url = "https://files.pythonhosted.org/packages/ef/8f/43961a56021be9e211d359524582b10d3e618d1e821942fc19530addd0a8/cupy_cuda12x-14.0.1-cp310-cp310-manylinux2014_aarch64.whl", hash = "sha256:b42da54c9da0d5a7748e4120f13c47594d3e1fc2741b712591aa915517741096", size = 144959483, upload-time = "2026-02-20T10:22:13.493Z" }, - { url = "https://files.pythonhosted.org/packages/c6/9c/21360d0db48912d06724c4f4c37fb60aa1146048aa35b79fd610adc71e23/cupy_cuda12x-14.0.1-cp310-cp310-manylinux2014_x86_64.whl", hash = "sha256:7c775e1e1ebc0c4c9f94a4c6bb66a0c07d109de5dfcef671f9e4056df4bd81ca", size = 133738643, upload-time = "2026-02-20T10:22:18.684Z" }, - { url = "https://files.pythonhosted.org/packages/ce/4c/e66e5ea7b6363b4b17f2cdb58859be8058af8cd65aef17861442a737548f/cupy_cuda12x-14.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:41bec7346b017cde81a32cd2c10391ec4ad7b5f1c4d34e53de646d5cda3c47fb", size = 96362151, upload-time = "2026-02-20T10:22:23.563Z" }, - { url = "https://files.pythonhosted.org/packages/d9/11/6d089629f44591864bc8a11fa64c9d4fcd1afb4a7217954c806fb47c4fe5/cupy_cuda12x-14.0.1-cp311-cp311-manylinux2014_aarch64.whl", hash = "sha256:31e6a33579a06fde3ff238b8b6b72446384d17554b2a3b14f818c9ee44b0c2e6", size = 146237981, upload-time = "2026-02-20T10:22:29.065Z" }, - { url = "https://files.pythonhosted.org/packages/37/f0/0f1d79c0c7fccbc2ed0c0ff3be1b0562be60b764c729ca8ded1bd6d953aa/cupy_cuda12x-14.0.1-cp311-cp311-manylinux2014_x86_64.whl", hash = "sha256:bfbde2e9f7946021b49414f9c800991163f2a56a1318f3d7d69cbb06001a1585", size = 135080693, upload-time = "2026-02-20T10:22:35.843Z" }, - { url = "https://files.pythonhosted.org/packages/6d/1b/b3a26fd36e066e9bc25d875488468c9a40e8c7a90acadfacc524a17da457/cupy_cuda12x-14.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:c289e78876c6840b3c512868b8c5d43ac76bc3c581eab1a75c4f2f4a88d5b430", size = 96361678, upload-time = "2026-02-20T10:22:41.718Z" }, - { url = "https://files.pythonhosted.org/packages/38/ca/b93ef9fca1471a65f136a73e10819634c0b83427362fc08fc9f29f935bf0/cupy_cuda12x-14.0.1-cp312-cp312-manylinux2014_aarch64.whl", hash = "sha256:f244bc14fad6f1ef0c74abd98afa4b82d2534aecdba911197810ec0047f0d1f3", size = 145578614, upload-time = "2026-02-20T10:22:49.108Z" }, - { url = "https://files.pythonhosted.org/packages/5a/a6/944406223a190815d9df156a1d66f3b0352bd8827dc4a8c752196d616dbc/cupy_cuda12x-14.0.1-cp312-cp312-manylinux2014_x86_64.whl", hash = "sha256:9f0c81c3509f77be3ae8444759d5b314201b2dfcbbf2ae0d0b5fb7a61f20893c", size = 134613763, upload-time = "2026-02-20T10:22:56.792Z" }, - { url = "https://files.pythonhosted.org/packages/11/fd/62e6e3f3c0c9f785b2dbdc2bff01bc375f5c6669d52e5e151f7aeb577801/cupy_cuda12x-14.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:63dc8a3a88d2ffd0386796b915d27acc7f2332c2291efd1ff4f0021b96f02051", size = 96267167, upload-time = "2026-02-20T10:23:02.263Z" }, - { url = "https://files.pythonhosted.org/packages/99/67/f967c5aff77bd6ae6765faf20580db80bb8a7e2574e999166de1d4e50146/cupy_cuda12x-14.0.1-cp313-cp313-manylinux2014_aarch64.whl", hash = "sha256:9d9b1bdcf9fa777593017867e8733192c071b94639a1b3e8b2ee99eb3f3ea760", size = 145128055, upload-time = "2026-02-20T10:23:08.765Z" }, - { url = "https://files.pythonhosted.org/packages/80/53/037c931731151c504cfc00069eb295c903927c92145115623f13bd2ea076/cupy_cuda12x-14.0.1-cp313-cp313-manylinux2014_x86_64.whl", hash = "sha256:21fcb4e917e43237edcc5e3a1a1241e2a2946ba9e577ce36fd580bd9856f91e8", size = 134227269, upload-time = "2026-02-20T10:23:16.147Z" }, - { url = "https://files.pythonhosted.org/packages/a3/70/ce8344426effda22152bf30cfb8f9b6477645d0f41df784674369af8f422/cupy_cuda12x-14.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:b7399e7fe4e2be3b5c3974fc892a661e10082836a4c78d0152b39cb483608a89", size = 96250134, upload-time = "2026-02-20T10:23:22.631Z" }, - { url = "https://files.pythonhosted.org/packages/5d/cb/ba61bcd602856aeabf362280cb3c17ed5fe03ae23e84578eb99f5245546c/cupy_cuda12x-14.0.1-cp314-cp314-manylinux2014_aarch64.whl", hash = "sha256:3be87da86d808d9fec23b0a1df001f15f8f145698bc4bebc6d6938fa7e11519f", size = 144976386, upload-time = "2026-02-20T10:23:29.877Z" }, - { url = "https://files.pythonhosted.org/packages/ba/73/34e5f334f6b1e5c5dff80af8109979fb0e8461b27e4454517e0e47486455/cupy_cuda12x-14.0.1-cp314-cp314-manylinux2014_x86_64.whl", hash = "sha256:fa356384760e01498d010af2d96de536ef3dad19db1d3a1ad0764e4323fb919f", size = 133521354, upload-time = "2026-02-20T10:23:37.063Z" }, - { url = "https://files.pythonhosted.org/packages/e5/a3/80ff83dcad1ac61741714d97fce5a3ef42c201bb40005ec5cc413e34d75f/cupy_cuda12x-14.0.1-cp314-cp314-win_amd64.whl", hash = "sha256:cafe62131caef63b5e90b71b617bb4bf47d7bd9e11cccabea8104db1e01db02e", size = 96822848, upload-time = "2026-02-20T10:23:42.684Z" }, + { url = "https://files.pythonhosted.org/packages/dd/18/8ec57a901a11d6955f90e1fbf3e04c8f26721066c99dfa25276e3e3b1f1d/cupy_cuda12x-14.1.1-cp310-cp310-manylinux2014_aarch64.whl", hash = "sha256:909c4b8ac05eee43edfbe791522ee5d593e3504be7bd5c20e2de12b050db2a26", size = 143787561, upload-time = "2026-06-01T04:51:46.125Z" }, + { url = "https://files.pythonhosted.org/packages/7c/79/6a4e1562b3b6b18e93365955adfd4f66a84b60bdacf559becc0e3e0f1012/cupy_cuda12x-14.1.1-cp310-cp310-manylinux2014_x86_64.whl", hash = "sha256:71b8de628a4a9ab24b6cc2af2162db2898e65a44a50a6d79cbc131c4f36405de", size = 132662808, upload-time = "2026-06-01T04:51:54.719Z" }, + { url = "https://files.pythonhosted.org/packages/b2/df/39530cffd84a00dfe98484a9ece77eed4acdc14717e1f77fa2a3e82a40dc/cupy_cuda12x-14.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:519e50b7dec2400e3fddbe9e6c4066937fd622a16774f375ab5be9d1cb1ea05e", size = 95338688, upload-time = "2026-06-01T04:51:59.685Z" }, + { url = "https://files.pythonhosted.org/packages/6a/65/13c173fec4923b9c4e1573344fc4a5585bf0e4efe5d9a5632e9bb18b2a31/cupy_cuda12x-14.1.1-cp311-cp311-manylinux2014_aarch64.whl", hash = "sha256:5d4c1c74f9f7fc9de0aa5781cf3ec54f9f05143f5761e21a8798772c8eedd0be", size = 145089362, upload-time = "2026-06-01T04:52:05.643Z" }, + { url = "https://files.pythonhosted.org/packages/dd/5e/ccd2fea320ece269dd7237649da384cad71fbb1ba30937a1eb3311c31b77/cupy_cuda12x-14.1.1-cp311-cp311-manylinux2014_x86_64.whl", hash = "sha256:8889cb83dbb7dbea593e60c85fcc91e21b0ccd10cd5380dfdfaac70b6bd9390a", size = 134012855, upload-time = "2026-06-01T04:52:11.526Z" }, + { url = "https://files.pythonhosted.org/packages/bc/59/93970d536e8401cf31d8f5602141f1c2edfc304e6d6b8702041688509509/cupy_cuda12x-14.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:e39a081fc4fe2166f95ef8be38fe2a95b2c4decb3ec991b4f26bfc9673d16b17", size = 95336905, upload-time = "2026-06-01T04:52:17.262Z" }, + { url = "https://files.pythonhosted.org/packages/a3/6e/290ee2d7cc4ad63d66e67acfd7ff3026f2b648dd04449a1bf88ffaa36b1e/cupy_cuda12x-14.1.1-cp312-cp312-manylinux2014_aarch64.whl", hash = "sha256:7aae7d3bed37985e2aa39f0914b88ad90dbd3a6141d3e8198d73fce65859013c", size = 144383812, upload-time = "2026-06-01T04:52:23.799Z" }, + { url = "https://files.pythonhosted.org/packages/f6/6e/dc03c1ddc940f33b3d32803898e2fdae5c9538a2127a25f499494c84b183/cupy_cuda12x-14.1.1-cp312-cp312-manylinux2014_x86_64.whl", hash = "sha256:a1138f20080489a46209291498cd12f792226d0a57d50c64a586c162a875a069", size = 133516927, upload-time = "2026-06-01T04:52:35.765Z" }, + { url = "https://files.pythonhosted.org/packages/cc/da/d4a8045b533af634bc791572e8c87981065e4a27b5d3e09d0d4d285742fd/cupy_cuda12x-14.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:85bebce86ffc25ecf31727b25da7b3793daf07b6fd9952704546af574d250988", size = 95238722, upload-time = "2026-06-01T04:52:46.296Z" }, + { url = "https://files.pythonhosted.org/packages/30/90/00fe874c47207b26c9b6ac950d0cecc533b4a145491641932df17e573f3c/cupy_cuda12x-14.1.1-cp313-cp313-manylinux2014_aarch64.whl", hash = "sha256:afbb3d1fa9484b0ae20d76372c5939a8c5da327e3fc8711b77b2354566cac355", size = 143920086, upload-time = "2026-06-01T04:52:51.726Z" }, + { url = "https://files.pythonhosted.org/packages/89/a4/c46ff91dba0dbe2a0a557974faf4c090a3159d6e7296431ca6846038d047/cupy_cuda12x-14.1.1-cp313-cp313-manylinux2014_x86_64.whl", hash = "sha256:76ea35469e2aa0a8332b88f72505ea2f7871a0bc8f9b0c87184f57e47c9aa3bf", size = 133071615, upload-time = "2026-06-01T04:52:57.428Z" }, + { url = "https://files.pythonhosted.org/packages/ec/a0/46778424035ad3fc920d49471f079687a054f74d179142e9520014c2514e/cupy_cuda12x-14.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:64072f4139b44df38215f0519a6badc14138fa0e4bb5b2db44fe94d05f8b9c8b", size = 95219598, upload-time = "2026-06-01T04:53:02.774Z" }, + { url = "https://files.pythonhosted.org/packages/b6/99/d72336481264c3483b162ea128d58f80abb50009f1df82ca82905e0b8fd7/cupy_cuda12x-14.1.1-cp314-cp314-manylinux2014_aarch64.whl", hash = "sha256:22d0ff2755a7f29cb225d1d5fb979a73428c5534ea0bca91b0c02698e9948f84", size = 143788629, upload-time = "2026-06-01T04:53:09.404Z" }, + { url = "https://files.pythonhosted.org/packages/c7/77/c43a67e6809e03780d88caf690fa44a8b3152db2d8f848714bec327c9881/cupy_cuda12x-14.1.1-cp314-cp314-manylinux2014_x86_64.whl", hash = "sha256:1059581507343e7cf6231facce30932a195c7aad4fa7771d00e4a252683915a1", size = 132406367, upload-time = "2026-06-01T04:53:16.232Z" }, + { url = "https://files.pythonhosted.org/packages/7d/dc/96cd37de6da41239e02fc7f17e3364d60f99bd6816673d622916a06113ec/cupy_cuda12x-14.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:e707e0eceee174d323be21652e87bb97be982e6966b5dc241756307df42842aa", size = 95793971, upload-time = "2026-06-01T04:53:21.478Z" }, + { url = "https://files.pythonhosted.org/packages/20/c6/0ddec1be851de546e883ae3da5f03c1ea69738628b38234dce4362b5e38b/cupy_cuda12x-14.1.1-cp314-cp314t-manylinux2014_aarch64.whl", hash = "sha256:e09897636b7468a90efa1152109f0b19ba49ebc9a423d5dbd4682ed589e57843", size = 144093057, upload-time = "2026-06-01T04:53:28.647Z" }, + { url = "https://files.pythonhosted.org/packages/a4/80/5e05de89ba61df072aab6f8a6ee3ffeec57db68a0a456825b3b4ce608426/cupy_cuda12x-14.1.1-cp314-cp314t-manylinux2014_x86_64.whl", hash = "sha256:238080487174268d0f09770fe518de7c5b206527bef5c6792aef7ba0626a1c48", size = 132635338, upload-time = "2026-06-01T04:53:35.229Z" }, ] [[package]] @@ -978,7 +975,7 @@ name = "exceptiongroup" version = "1.3.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "typing-extensions", marker = "python_full_version < '3.11' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing')" }, + { name = "typing-extensions", marker = "python_full_version < '3.11' or (python_full_version >= '3.13' and extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (python_full_version >= '3.13' and extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (python_full_version >= '3.13' and extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (python_full_version >= '3.13' and extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (python_full_version >= '3.13' and extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (python_full_version >= '3.13' and extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (python_full_version >= '3.13' and extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (python_full_version >= '3.13' and extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (python_full_version < '3.13' and extra == 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-core' and extra == 'group-8-narwhals-core-tests') or (python_full_version < '3.13' and extra == 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-core' and extra == 'group-8-narwhals-dev-core') or (python_full_version < '3.13' and extra == 'extra-8-narwhals-dask' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra == 'group-8-narwhals-core-tests') or (python_full_version < '3.13' and extra == 'extra-8-narwhals-dask' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra == 'group-8-narwhals-dev-core') or (python_full_version < '3.13' and extra == 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions') or (python_full_version < '3.13' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra == 'group-8-narwhals-core-tests') or (python_full_version < '3.13' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra == 'group-8-narwhals-dev-core') or (python_full_version >= '3.13' and extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (python_full_version < '3.13' and extra == 'extra-8-narwhals-dask' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions') or (python_full_version >= '3.13' and extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (python_full_version >= '3.13' and extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing') or (python_full_version >= '3.13' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (python_full_version >= '3.13' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing') or (python_full_version < '3.13' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing') or (extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra != 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra != 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra != 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" } wheels = [ @@ -1038,90 +1035,90 @@ wheels = [ [[package]] name = "grpcio" -version = "1.80.0" +version = "1.81.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/b7/48/af6173dbca4454f4637a4678b67f52ca7e0c1ed7d5894d89d434fecede05/grpcio-1.80.0.tar.gz", hash = "sha256:29aca15edd0688c22ba01d7cc01cb000d72b2033f4a3c72a81a19b56fd143257", size = 12978905, upload-time = "2026-03-30T08:49:10.502Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/9d/cd/bb7b7e54084a344c03d68144450da7ddd5564e51a298ae1662de65f48e2d/grpcio-1.80.0-cp310-cp310-linux_armv7l.whl", hash = "sha256:886457a7768e408cdce226ad1ca67d2958917d306523a0e21e1a2fdaa75c9c9c", size = 6050363, upload-time = "2026-03-30T08:46:20.894Z" }, - { url = "https://files.pythonhosted.org/packages/16/02/1417f5c3460dea65f7a2e3c14e8b31e77f7ffb730e9bfadd89eda7a9f477/grpcio-1.80.0-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:7b641fc3f1dc647bfd80bd713addc68f6d145956f64677e56d9ebafc0bd72388", size = 12026037, upload-time = "2026-03-30T08:46:25.144Z" }, - { url = "https://files.pythonhosted.org/packages/43/98/c910254eedf2cae368d78336a2de0678e66a7317d27c02522392f949b5c6/grpcio-1.80.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:33eb763f18f006dc7fee1e69831d38d23f5eccd15b2e0f92a13ee1d9242e5e02", size = 6602306, upload-time = "2026-03-30T08:46:27.593Z" }, - { url = "https://files.pythonhosted.org/packages/7c/f8/88ca4e78c077b2b2113d95da1e1ab43efd43d723c9a0397d26529c2c1a56/grpcio-1.80.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:52d143637e3872633fc7dd7c3c6a1c84e396b359f3a72e215f8bf69fd82084fc", size = 7301535, upload-time = "2026-03-30T08:46:29.556Z" }, - { url = "https://files.pythonhosted.org/packages/f9/96/f28660fe2fe0f153288bf4a04e4910b7309d442395135c88ed4f5b3b8b40/grpcio-1.80.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c51bf8ac4575af2e0678bccfb07e47321fc7acb5049b4482832c5c195e04e13a", size = 6808669, upload-time = "2026-03-30T08:46:31.984Z" }, - { url = "https://files.pythonhosted.org/packages/47/eb/3f68a5e955779c00aeef23850e019c1c1d0e032d90633ba49c01ad5a96e0/grpcio-1.80.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:50a9871536d71c4fba24ee856abc03a87764570f0c457dd8db0b4018f379fed9", size = 7409489, upload-time = "2026-03-30T08:46:34.684Z" }, - { url = "https://files.pythonhosted.org/packages/5b/a7/d2f681a4bfb881be40659a309771f3bdfbfdb1190619442816c3f0ffc079/grpcio-1.80.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:a72d84ad0514db063e21887fbacd1fd7acb4d494a564cae22227cd45c7fbf199", size = 8423167, upload-time = "2026-03-30T08:46:36.833Z" }, - { url = "https://files.pythonhosted.org/packages/97/8a/29b4589c204959aa35ce5708400a05bba72181807c45c47b3ec000c39333/grpcio-1.80.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f7691a6788ad9196872f95716df5bc643ebba13c97140b7a5ee5c8e75d1dea81", size = 7846761, upload-time = "2026-03-30T08:46:40.091Z" }, - { url = "https://files.pythonhosted.org/packages/6b/d2/ed143e097230ee121ac5848f6ff14372dba91289b10b536d54fb1b7cbae7/grpcio-1.80.0-cp310-cp310-win32.whl", hash = "sha256:46c2390b59d67f84e882694d489f5b45707c657832d7934859ceb8c33f467069", size = 4156534, upload-time = "2026-03-30T08:46:42.026Z" }, - { url = "https://files.pythonhosted.org/packages/d5/c9/df8279bb49b29409995e95efa85b72973d62f8aeff89abee58c91f393710/grpcio-1.80.0-cp310-cp310-win_amd64.whl", hash = "sha256:dc053420fc75749c961e2a4c906398d7c15725d36ccc04ae6d16093167223b58", size = 4889869, upload-time = "2026-03-30T08:46:44.219Z" }, - { url = "https://files.pythonhosted.org/packages/5d/db/1d56e5f5823257b291962d6c0ce106146c6447f405b60b234c4f222a7cde/grpcio-1.80.0-cp311-cp311-linux_armv7l.whl", hash = "sha256:dfab85db094068ff42e2a3563f60ab3dddcc9d6488a35abf0132daec13209c8a", size = 6055009, upload-time = "2026-03-30T08:46:46.265Z" }, - { url = "https://files.pythonhosted.org/packages/6e/18/c83f3cad64c5ca63bca7e91e5e46b0d026afc5af9d0a9972472ceba294b3/grpcio-1.80.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:5c07e82e822e1161354e32da2662f741a4944ea955f9f580ec8fb409dd6f6060", size = 12035295, upload-time = "2026-03-30T08:46:49.099Z" }, - { url = "https://files.pythonhosted.org/packages/0f/8e/e14966b435be2dda99fbe89db9525ea436edc79780431a1c2875a3582644/grpcio-1.80.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ba0915d51fd4ced2db5ff719f84e270afe0e2d4c45a7bdb1e8d036e4502928c2", size = 6610297, upload-time = "2026-03-30T08:46:52.123Z" }, - { url = "https://files.pythonhosted.org/packages/cc/26/d5eb38f42ce0e3fdc8174ea4d52036ef8d58cc4426cb800f2610f625dd75/grpcio-1.80.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:3cb8130ba457d2aa09fa6b7c3ed6b6e4e6a2685fce63cb803d479576c4d80e21", size = 7300208, upload-time = "2026-03-30T08:46:54.859Z" }, - { url = "https://files.pythonhosted.org/packages/25/51/bd267c989f85a17a5b3eea65a6feb4ff672af41ca614e5a0279cc0ea381c/grpcio-1.80.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:09e5e478b3d14afd23f12e49e8b44c8684ac3c5f08561c43a5b9691c54d136ab", size = 6813442, upload-time = "2026-03-30T08:46:57.056Z" }, - { url = "https://files.pythonhosted.org/packages/9e/d9/d80eef735b19e9169e30164bbf889b46f9df9127598a83d174eb13a48b26/grpcio-1.80.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:00168469238b022500e486c1c33916acf2f2a9b2c022202cf8a1885d2e3073c1", size = 7414743, upload-time = "2026-03-30T08:46:59.682Z" }, - { url = "https://files.pythonhosted.org/packages/de/f2/567f5bd5054398ed6b0509b9a30900376dcf2786bd936812098808b49d8d/grpcio-1.80.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8502122a3cc1714038e39a0b071acb1207ca7844208d5ea0d091317555ee7106", size = 8426046, upload-time = "2026-03-30T08:47:02.474Z" }, - { url = "https://files.pythonhosted.org/packages/62/29/73ef0141b4732ff5eacd68430ff2512a65c004696997f70476a83e548e7e/grpcio-1.80.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ce1794f4ea6cc3ca29463f42d665c32ba1b964b48958a66497917fe9069f26e6", size = 7851641, upload-time = "2026-03-30T08:47:05.462Z" }, - { url = "https://files.pythonhosted.org/packages/46/69/abbfa360eb229a8623bab5f5a4f8105e445bd38ce81a89514ba55d281ad0/grpcio-1.80.0-cp311-cp311-win32.whl", hash = "sha256:51b4a7189b0bef2aa30adce3c78f09c83526cf3dddb24c6a96555e3b97340440", size = 4154368, upload-time = "2026-03-30T08:47:08.027Z" }, - { url = "https://files.pythonhosted.org/packages/6f/d4/ae92206d01183b08613e846076115f5ac5991bae358d2a749fa864da5699/grpcio-1.80.0-cp311-cp311-win_amd64.whl", hash = "sha256:02e64bb0bb2da14d947a49e6f120a75e947250aebe65f9629b62bb1f5c14e6e9", size = 4894235, upload-time = "2026-03-30T08:47:10.839Z" }, - { url = "https://files.pythonhosted.org/packages/5c/e8/a2b749265eb3415abc94f2e619bbd9e9707bebdda787e61c593004ec927a/grpcio-1.80.0-cp312-cp312-linux_armv7l.whl", hash = "sha256:c624cc9f1008361014378c9d776de7182b11fe8b2e5a81bc69f23a295f2a1ad0", size = 6015616, upload-time = "2026-03-30T08:47:13.428Z" }, - { url = "https://files.pythonhosted.org/packages/3e/97/b1282161a15d699d1e90c360df18d19165a045ce1c343c7f313f5e8a0b77/grpcio-1.80.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:f49eddcac43c3bf350c0385366a58f36bed8cc2c0ec35ef7b74b49e56552c0c2", size = 12014204, upload-time = "2026-03-30T08:47:15.873Z" }, - { url = "https://files.pythonhosted.org/packages/6e/5e/d319c6e997b50c155ac5a8cb12f5173d5b42677510e886d250d50264949d/grpcio-1.80.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d334591df610ab94714048e0d5b4f3dd5ad1bee74dfec11eee344220077a79de", size = 6563866, upload-time = "2026-03-30T08:47:18.588Z" }, - { url = "https://files.pythonhosted.org/packages/ae/f6/fdd975a2cb4d78eb67769a7b3b3830970bfa2e919f1decf724ae4445f42c/grpcio-1.80.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:0cb517eb1d0d0aaf1d87af7cc5b801d686557c1d88b2619f5e31fab3c2315921", size = 7273060, upload-time = "2026-03-30T08:47:21.113Z" }, - { url = "https://files.pythonhosted.org/packages/db/f0/a3deb5feba60d9538a962913e37bd2e69a195f1c3376a3dd44fe0427e996/grpcio-1.80.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4e78c4ac0d97dc2e569b2f4bcbbb447491167cb358d1a389fc4af71ab6f70411", size = 6782121, upload-time = "2026-03-30T08:47:23.827Z" }, - { url = "https://files.pythonhosted.org/packages/ca/84/36c6dcfddc093e108141f757c407902a05085e0c328007cb090d56646cdf/grpcio-1.80.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2ed770b4c06984f3b47eb0517b1c69ad0b84ef3f40128f51448433be904634cd", size = 7383811, upload-time = "2026-03-30T08:47:26.517Z" }, - { url = "https://files.pythonhosted.org/packages/7c/ef/f3a77e3dc5b471a0ec86c564c98d6adfa3510d38f8ee99010410858d591e/grpcio-1.80.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:256507e2f524092f1473071a05e65a5b10d84b82e3ff24c5b571513cfaa61e2f", size = 8393860, upload-time = "2026-03-30T08:47:29.439Z" }, - { url = "https://files.pythonhosted.org/packages/9b/8d/9d4d27ed7f33d109c50d6b5ce578a9914aa68edab75d65869a17e630a8d1/grpcio-1.80.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9a6284a5d907c37db53350645567c522be314bac859a64a7a5ca63b77bb7958f", size = 7830132, upload-time = "2026-03-30T08:47:33.254Z" }, - { url = "https://files.pythonhosted.org/packages/14/e4/9990b41c6d7a44e1e9dee8ac11d7a9802ba1378b40d77468a7761d1ad288/grpcio-1.80.0-cp312-cp312-win32.whl", hash = "sha256:c71309cfce2f22be26aa4a847357c502db6c621f1a49825ae98aa0907595b193", size = 4140904, upload-time = "2026-03-30T08:47:35.319Z" }, - { url = "https://files.pythonhosted.org/packages/2f/2c/296f6138caca1f4b92a31ace4ae1b87dab692fc16a7a3417af3bb3c805bf/grpcio-1.80.0-cp312-cp312-win_amd64.whl", hash = "sha256:9fe648599c0e37594c4809d81a9e77bd138cc82eb8baa71b6a86af65426723ff", size = 4880944, upload-time = "2026-03-30T08:47:37.831Z" }, - { url = "https://files.pythonhosted.org/packages/2f/3a/7c3c25789e3f069e581dc342e03613c5b1cb012c4e8c7d9d5cf960a75856/grpcio-1.80.0-cp313-cp313-linux_armv7l.whl", hash = "sha256:e9e408fc016dffd20661f0126c53d8a31c2821b5c13c5d67a0f5ed5de93319ad", size = 6017243, upload-time = "2026-03-30T08:47:40.075Z" }, - { url = "https://files.pythonhosted.org/packages/04/19/21a9806eb8240e174fd1ab0cd5b9aa948bb0e05c2f2f55f9d5d7405e6d08/grpcio-1.80.0-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:92d787312e613754d4d8b9ca6d3297e69994a7912a32fa38c4c4e01c272974b0", size = 12010840, upload-time = "2026-03-30T08:47:43.11Z" }, - { url = "https://files.pythonhosted.org/packages/18/3a/23347d35f76f639e807fb7a36fad3068aed100996849a33809591f26eca6/grpcio-1.80.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8ac393b58aa16991a2f1144ec578084d544038c12242da3a215966b512904d0f", size = 6567644, upload-time = "2026-03-30T08:47:46.806Z" }, - { url = "https://files.pythonhosted.org/packages/ff/40/96e07ecb604a6a67ae6ab151e3e35b132875d98bc68ec65f3e5ab3e781d7/grpcio-1.80.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:68e5851ac4b9afe07e7f84483803ad167852570d65326b34d54ca560bfa53fb6", size = 7277830, upload-time = "2026-03-30T08:47:49.643Z" }, - { url = "https://files.pythonhosted.org/packages/9b/e2/da1506ecea1f34a5e365964644b35edef53803052b763ca214ba3870c856/grpcio-1.80.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:873ff5d17d68992ef6605330127425d2fc4e77e612fa3c3e0ed4e668685e3140", size = 6783216, upload-time = "2026-03-30T08:47:52.817Z" }, - { url = "https://files.pythonhosted.org/packages/44/83/3b20ff58d0c3b7f6caaa3af9a4174d4023701df40a3f39f7f1c8e7c48f9d/grpcio-1.80.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2bea16af2750fd0a899bf1abd9022244418b55d1f37da2202249ba4ba673838d", size = 7385866, upload-time = "2026-03-30T08:47:55.687Z" }, - { url = "https://files.pythonhosted.org/packages/47/45/55c507599c5520416de5eefecc927d6a0d7af55e91cfffb2e410607e5744/grpcio-1.80.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ba0db34f7e1d803a878284cd70e4c63cb6ae2510ba51937bf8f45ba997cefcf7", size = 8391602, upload-time = "2026-03-30T08:47:58.303Z" }, - { url = "https://files.pythonhosted.org/packages/10/bb/dd06f4c24c01db9cf11341b547d0a016b2c90ed7dbbb086a5710df7dd1d7/grpcio-1.80.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8eb613f02d34721f1acf3626dfdb3545bd3c8505b0e52bf8b5710a28d02e8aa7", size = 7826752, upload-time = "2026-03-30T08:48:01.311Z" }, - { url = "https://files.pythonhosted.org/packages/f9/1e/9d67992ba23371fd63d4527096eb8c6b76d74d52b500df992a3343fd7251/grpcio-1.80.0-cp313-cp313-win32.whl", hash = "sha256:93b6f823810720912fd131f561f91f5fed0fda372b6b7028a2681b8194d5d294", size = 4142310, upload-time = "2026-03-30T08:48:04.594Z" }, - { url = "https://files.pythonhosted.org/packages/cf/e6/283326a27da9e2c3038bc93eeea36fb118ce0b2d03922a9cda6688f53c5b/grpcio-1.80.0-cp313-cp313-win_amd64.whl", hash = "sha256:e172cf795a3ba5246d3529e4d34c53db70e888fa582a8ffebd2e6e48bc0cba50", size = 4882833, upload-time = "2026-03-30T08:48:07.363Z" }, - { url = "https://files.pythonhosted.org/packages/c5/6d/e65307ce20f5a09244ba9e9d8476e99fb039de7154f37fb85f26978b59c3/grpcio-1.80.0-cp314-cp314-linux_armv7l.whl", hash = "sha256:3d4147a97c8344d065d01bbf8b6acec2cf86fb0400d40696c8bdad34a64ffc0e", size = 6017376, upload-time = "2026-03-30T08:48:10.005Z" }, - { url = "https://files.pythonhosted.org/packages/69/10/9cef5d9650c72625a699c549940f0abb3c4bfdb5ed45a5ce431f92f31806/grpcio-1.80.0-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:d8e11f167935b3eb089ac9038e1a063e6d7dbe995c0bb4a661e614583352e76f", size = 12018133, upload-time = "2026-03-30T08:48:12.927Z" }, - { url = "https://files.pythonhosted.org/packages/04/82/983aabaad82ba26113caceeb9091706a0696b25da004fe3defb5b346e15b/grpcio-1.80.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f14b618fc30de822681ee986cfdcc2d9327229dc4c98aed16896761cacd468b9", size = 6574748, upload-time = "2026-03-30T08:48:16.386Z" }, - { url = "https://files.pythonhosted.org/packages/07/d7/031666ef155aa0bf399ed7e19439656c38bbd143779ae0861b038ce82abd/grpcio-1.80.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:4ed39fbdcf9b87370f6e8df4e39ca7b38b3e5e9d1b0013c7b6be9639d6578d14", size = 7277711, upload-time = "2026-03-30T08:48:19.627Z" }, - { url = "https://files.pythonhosted.org/packages/e8/43/f437a78f7f4f1d311804189e8f11fb311a01049b2e08557c1068d470cb2e/grpcio-1.80.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2dcc70e9f0ba987526e8e8603a610fb4f460e42899e74e7a518bf3c68fe1bf05", size = 6785372, upload-time = "2026-03-30T08:48:22.373Z" }, - { url = "https://files.pythonhosted.org/packages/93/3d/f6558e9c6296cb4227faa5c43c54a34c68d32654b829f53288313d16a86e/grpcio-1.80.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:448c884b668b868562b1bda833c5fce6272d26e1926ec46747cda05741d302c1", size = 7395268, upload-time = "2026-03-30T08:48:25.638Z" }, - { url = "https://files.pythonhosted.org/packages/06/21/0fdd77e84720b08843c371a2efa6f2e19dbebf56adc72df73d891f5506f0/grpcio-1.80.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a1dc80fe55685b4a543555e6eef975303b36c8db1023b1599b094b92aa77965f", size = 8392000, upload-time = "2026-03-30T08:48:28.974Z" }, - { url = "https://files.pythonhosted.org/packages/f5/68/67f4947ed55d2e69f2cc199ab9fd85e0a0034d813bbeef84df6d2ba4d4b7/grpcio-1.80.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:31b9ac4ad1aa28ffee5503821fafd09e4da0a261ce1c1281c6c8da0423c83b6e", size = 7828477, upload-time = "2026-03-30T08:48:32.054Z" }, - { url = "https://files.pythonhosted.org/packages/44/b6/8d4096691b2e385e8271911a0de4f35f0a6c7d05aff7098e296c3de86939/grpcio-1.80.0-cp314-cp314-win32.whl", hash = "sha256:367ce30ba67d05e0592470428f0ec1c31714cab9ef19b8f2e37be1f4c7d32fae", size = 4218563, upload-time = "2026-03-30T08:48:34.538Z" }, - { url = "https://files.pythonhosted.org/packages/e5/8c/bbe6baf2557262834f2070cf668515fa308b2d38a4bbf771f8f7872a7036/grpcio-1.80.0-cp314-cp314-win_amd64.whl", hash = "sha256:3b01e1f5464c583d2f567b2e46ff0d516ef979978f72091fd81f5ab7fa6e2e7f", size = 5019457, upload-time = "2026-03-30T08:48:37.308Z" }, +sdist = { url = "https://files.pythonhosted.org/packages/15/f3/23f47b24f8d8c2028eba501db3acfbb2f592cbb5995eaa6e363a627b74d7/grpcio-1.81.0.tar.gz", hash = "sha256:a5acd7efd3b1fe9b4eb0bcaaa1507eed68a0ad0678b654c3f7b464df9ba9dca5", size = 13032272, upload-time = "2026-06-01T05:56:22.827Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/25/a0/13f7dd9602a44c2852eb5ca29dfcb14de5547e1d37672dbf20e3cf17d5d2/grpcio-1.81.0-cp310-cp310-linux_armv7l.whl", hash = "sha256:b4108e5d9d0f651b7eea749116181fe6c315b145661a80ec31f05ec2dbe21af7", size = 6087534, upload-time = "2026-06-01T05:54:04.541Z" }, + { url = "https://files.pythonhosted.org/packages/da/8a/439070efa430b3c51c8e319b67521957688905f27b294302c6077e9d4ef5/grpcio-1.81.0-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:b76ea9d55cd08fcdbda25d28e0f76679536710acb7fbd5b1f70cb4ac49317265", size = 12062452, upload-time = "2026-06-01T05:54:10.137Z" }, + { url = "https://files.pythonhosted.org/packages/4a/6f/7802953eb46ab7082f70a139dac02a5544e8b784c4647f9750af28f64348/grpcio-1.81.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:4e032feb3bfb4e2749b140a2302a6baa8ead1b9781ff5cf7094e4402b5e9372e", size = 6635199, upload-time = "2026-06-01T05:54:12.739Z" }, + { url = "https://files.pythonhosted.org/packages/09/33/91d7fd2392923407fc89e7f1493011dacd3f1a6972cff5fa2237ac1efd5d/grpcio-1.81.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:725801c7086d7e4cd160e42bb2f54e0aeb976b9568df3cc6f843b15d29b79fb1", size = 7333482, upload-time = "2026-06-01T05:54:15.474Z" }, + { url = "https://files.pythonhosted.org/packages/9a/df/ec0a4e04472df2618f8741151fa026bc877648e952ebb0e421169e0b992b/grpcio-1.81.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f750a091fff3a3991731abc1f818bdc64874bb3528162732cb4d45f2e07821a6", size = 6837709, upload-time = "2026-06-01T05:54:18.036Z" }, + { url = "https://files.pythonhosted.org/packages/86/82/9f69147bbd723ff07fea0242e5877a9026be1819410996e6086aae8f00a6/grpcio-1.81.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:8226ba097eed660ef14d36c6a69b85038552bb8b6d17b44a5aa6f9abf48b8e08", size = 7440601, upload-time = "2026-06-01T05:54:20.662Z" }, + { url = "https://files.pythonhosted.org/packages/89/3b/52c1558e94941022b7ee046583fe4a007164c7e18087d55f82fd23c567b8/grpcio-1.81.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:40edffb4ec3689373825d367c4457727047a6e554f03245265ecc8cc03215f22", size = 8442803, upload-time = "2026-06-01T05:54:22.941Z" }, + { url = "https://files.pythonhosted.org/packages/4a/5d/1264d086c5d3cc81c59084de1ccc87d1a037f91ce9cb1f611caaa19b70cc/grpcio-1.81.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f85570a016d794c29b1e76cf22f67af4486ddbe779e0f30674f138fa4e1769ec", size = 7868964, upload-time = "2026-06-01T05:54:25.627Z" }, + { url = "https://files.pythonhosted.org/packages/a5/b4/3b3339e661669d545f09ee7ea33fec3b1b438e623b3105597d3457c39391/grpcio-1.81.0-cp310-cp310-win32.whl", hash = "sha256:3755c9669307cad18e7e009860fdea98118978d2300451bd8530a53048e741e7", size = 4202292, upload-time = "2026-06-01T05:54:28.261Z" }, + { url = "https://files.pythonhosted.org/packages/c2/c3/cd81087855dfd4bbef2db50e58e1f7ce93a9a1675bc89a6cb76aa438ffaa/grpcio-1.81.0-cp310-cp310-win_amd64.whl", hash = "sha256:909bb3222b53235498d2c5817a0596d82b0aaea490ba93fdf1b060e2938a543c", size = 4937038, upload-time = "2026-06-01T05:54:30.376Z" }, + { url = "https://files.pythonhosted.org/packages/45/a8/9916ab10a0201f4c7afb6918125aa2f38a7626ee18ffbc066dd9cb04a74d/grpcio-1.81.0-cp311-cp311-linux_armv7l.whl", hash = "sha256:794e6aa648e8df47d8f908dc8c3b42347d04ec58438f1dcd4e445f09b4f6b0ce", size = 6093557, upload-time = "2026-06-01T05:54:32.64Z" }, + { url = "https://files.pythonhosted.org/packages/a7/43/99e969a048904a65df3129ee53c5f523b7c4e43127786460cac4bee82470/grpcio-1.81.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:cd78145b7f7784661c524624f3526c9c6f891b30a4b54cb93a40806d0d0d61e9", size = 12075345, upload-time = "2026-06-01T05:54:35.77Z" }, + { url = "https://files.pythonhosted.org/packages/83/70/4c3a204e190333768d4f63f4ff56bd0bf405f05b9188f3a59a8bcf161f8b/grpcio-1.81.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:638ccc1b86f7540170a169cb900799b9296a1381e47879ce60b0de9d3db73d33", size = 6640664, upload-time = "2026-06-01T05:54:38.854Z" }, + { url = "https://files.pythonhosted.org/packages/2e/a9/0fa17ac8b4e29cf59b26915be6cab8c0d4583ce24a6208a287b6e5f6d072/grpcio-1.81.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:21ec30b9ea320c8207ea7cd05873ad64aa69fdd0e81b6758b3347983ba20b50a", size = 7332542, upload-time = "2026-06-01T05:54:41.39Z" }, + { url = "https://files.pythonhosted.org/packages/f4/18/7c8e3d0dda2fb7a17076fcd6c9085209eabad3354696c64230f87b3a14eb/grpcio-1.81.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:dbdb99986548a7e87f8343805ef315fd4eb50ffaabf4fb1206e42f2542bb805d", size = 6842564, upload-time = "2026-06-01T05:54:43.57Z" }, + { url = "https://files.pythonhosted.org/packages/f6/19/2f1726c2e03ad3f3fe241e6b41534532ad580d595de14a4054ad84999c80/grpcio-1.81.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c36f5d5e97944cbda2d4096b4ae262e6e68506246b61582acf1b8591607f3ccc", size = 7446236, upload-time = "2026-06-01T05:54:46.042Z" }, + { url = "https://files.pythonhosted.org/packages/a7/dc/0321f892212e2c0bfe248cea24c00d7d7111639688ec5ffd8e36b5c02fe6/grpcio-1.81.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:9f355384e5543ab77a755a7085225ecc19f32b76032e851cbd8145715d79dec8", size = 8445633, upload-time = "2026-06-01T05:54:48.809Z" }, + { url = "https://files.pythonhosted.org/packages/e5/20/0e7ea7494955cf1beea3077b2fd2c04c84d4480c2ae85a1e1cfa150c62d7/grpcio-1.81.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:77eb4e9fe61486bd1198cc7236ebb0f70e66234e63c0348f40bc2553ed16a88b", size = 7873958, upload-time = "2026-06-01T05:54:52.135Z" }, + { url = "https://files.pythonhosted.org/packages/d3/9e/6438e226046c2a0778060e2b1d791a4827277bbd9d223013c2c63ee7435e/grpcio-1.81.0-cp311-cp311-win32.whl", hash = "sha256:7915a2e63acdc05264a206e1bddfd8e1fb8a29e406c18d72d30f8c124e021374", size = 4202110, upload-time = "2026-06-01T05:54:54.134Z" }, + { url = "https://files.pythonhosted.org/packages/42/6b/d0895e93d65b186f5f1737fcc186d7faa487e2d9d934eda111a37a309869/grpcio-1.81.0-cp311-cp311-win_amd64.whl", hash = "sha256:5e925a70fe99fe5794f7beca0ea034c75f068afcc356d79047e73f99cdcca34c", size = 4940942, upload-time = "2026-06-01T05:54:56.749Z" }, + { url = "https://files.pythonhosted.org/packages/82/d5/896a3aaf07068d707d88b282a04914b872db4d32d3c7e6d88e43a3b911fa/grpcio-1.81.0-cp312-cp312-linux_armv7l.whl", hash = "sha256:57b3b0e73a518fa286959b40c3eddd02703504ca186e8b7b2945954519bd8b2c", size = 6053538, upload-time = "2026-06-01T05:54:58.965Z" }, + { url = "https://files.pythonhosted.org/packages/68/6a/7e3eafa4727cd405ff917605ed2949e2af162f233f5cbdd773723a5fea7d/grpcio-1.81.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:8bb1789c94322a13336a2b6c58d9c14d68f8628b6e24205a799c69f5bf8516ce", size = 12053447, upload-time = "2026-06-01T05:55:01.862Z" }, + { url = "https://files.pythonhosted.org/packages/16/79/a4302aa82428de48a922421f522b027a1a727ab4d0926368454aa953d36d/grpcio-1.81.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e4d053900a0d24b75d7521139a3872150301b3d6bde3bed5e12318fb25791e4d", size = 6595872, upload-time = "2026-06-01T05:55:04.946Z" }, + { url = "https://files.pythonhosted.org/packages/b4/1f/7ff2850eaefbecf99af3f624dbb28dd1ad6c5fd4c1d8c26909ed6482673b/grpcio-1.81.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:db217c2e52931719f9937bd12082cd4d7b495b35803d5760686975c285924bf8", size = 7303857, upload-time = "2026-06-01T05:55:07.205Z" }, + { url = "https://files.pythonhosted.org/packages/e2/98/1f3896a9baae1f2aedf4e99c55291d6fa1f30ad9603d63bc18bda967b53e/grpcio-1.81.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:19f201da7b4e5c0559198abe5a97157e726f3abe6e8f5e832d4a50740f6dcc22", size = 6809676, upload-time = "2026-06-01T05:55:09.513Z" }, + { url = "https://files.pythonhosted.org/packages/34/8b/3441983718095208c5d797fd3239882e97ea89a629f41c8df94b4eef4df9/grpcio-1.81.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:275144b0115353339dbb8a6f28a9cf8997b5bf40e37f8f66ac0b0ea57e95b43f", size = 7412654, upload-time = "2026-06-01T05:55:12.777Z" }, + { url = "https://files.pythonhosted.org/packages/3c/98/1eddf07df6e4fe85cf67502a793f7b05468b2dca3d1ef35b972cf5d54468/grpcio-1.81.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5192857589f223e5a98ff0e31f6e551b19040e647d17bfe10116c8a2ce3b8696", size = 8408026, upload-time = "2026-06-01T05:55:15.514Z" }, + { url = "https://files.pythonhosted.org/packages/5c/73/3860341e6a1f5347be6ab35c6c0e1e3a8eb59d010388207fd561dcf01a88/grpcio-1.81.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c6ff087cb1f563f47b504b4e29e684129fc5ae4863faf3ebca08a327764ee6cb", size = 7849498, upload-time = "2026-06-01T05:55:18.078Z" }, + { url = "https://files.pythonhosted.org/packages/ae/3f/0ea06bd85c701966aa3f8f37314f2ed83520d2b7590f42d643d445d8bc8b/grpcio-1.81.0-cp312-cp312-win32.whl", hash = "sha256:98c6240f563178fc5877bd50e6ff274463e53e1472128f4110742450739659fa", size = 4184161, upload-time = "2026-06-01T05:55:20.127Z" }, + { url = "https://files.pythonhosted.org/packages/39/e3/a7c387406827a86f99ad7838b995bf9b4a182ffe2d2c439ed2873efec952/grpcio-1.81.0-cp312-cp312-win_amd64.whl", hash = "sha256:87e33b7afcfb3585121b5f007d2c52b8c534104d18f556e840d35193ca2a9141", size = 4929958, upload-time = "2026-06-01T05:55:22.736Z" }, + { url = "https://files.pythonhosted.org/packages/f3/29/779ee53c931d0fd55c1d459fde43e485172caa3ac87cbd43d003a13a0185/grpcio-1.81.0-cp313-cp313-linux_armv7l.whl", hash = "sha256:62bbe463c9f0f2ff24e31bd25f8dd8b4bae78900e315915a3195a0ef1471a855", size = 6054973, upload-time = "2026-06-01T05:55:25.043Z" }, + { url = "https://files.pythonhosted.org/packages/9e/b6/7211807926b5a17f8d9a5d47c739a163d6812fefe3e4714e81cf92945ed7/grpcio-1.81.0-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:43c121e135ae44d1559b430db2b2dfad7421cbbe40e1deba506c7dc62b439719", size = 12048662, upload-time = "2026-06-01T05:55:28.453Z" }, + { url = "https://files.pythonhosted.org/packages/64/89/b1b93ef6b34bd20bbaf707fa99133bc9cc302139d5ec6f77a165c7169796/grpcio-1.81.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f345de40ef2e65f63645d53d251824e6070e07804827c5b00ec2e44555f9f901", size = 6599116, upload-time = "2026-06-01T05:55:31.185Z" }, + { url = "https://files.pythonhosted.org/packages/eb/bc/c89f9b9d1c22895715356a1e009554dae66319e97826bb4d30bcda7d29e8/grpcio-1.81.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:8c0855a350886f713b9e458e2a10d208009dcaa849f574e39cd6067db1fe1279", size = 7307591, upload-time = "2026-06-01T05:55:33.463Z" }, + { url = "https://files.pythonhosted.org/packages/65/4a/1df2a4cb4a1386e066ab7e4175e34bb884b35ccb60d3621c09c84af6aabb/grpcio-1.81.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a524cd530900bd24511fcb7f2ed144da4ea37711c4b094475d0bceca7a93a170", size = 6811797, upload-time = "2026-06-01T05:55:36.731Z" }, + { url = "https://files.pythonhosted.org/packages/8d/dc/fa189d20601a1be25b08850cfb733879bbb1047b62a8feec3a60e3e1a87b/grpcio-1.81.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e7746ba3e6efc9e2b748eff59470a2b8684d5a9ec607c6580bcaa5be175820bc", size = 7415131, upload-time = "2026-06-01T05:55:39.451Z" }, + { url = "https://files.pythonhosted.org/packages/ad/a3/5625c48cb48d23c6631b3e5294f88e4c751f22a52591ae78859fab96dca1/grpcio-1.81.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:aaaa4f7f2057d795952e4eacf3f342be8b5b156992f6ac85023c8b98794ebd47", size = 8408398, upload-time = "2026-06-01T05:55:42.219Z" }, + { url = "https://files.pythonhosted.org/packages/75/34/0f8202c6809a46c2b4d69125ef3667c40b1c211f8e19930e5fa1f1197039/grpcio-1.81.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0fba53cb96004b2b7fb758b46b2288cb49d0b658316a4e73f3ef67230616ee65", size = 7844481, upload-time = "2026-06-01T05:55:44.849Z" }, + { url = "https://files.pythonhosted.org/packages/c0/95/c3366b5b5edf4c4adc90f2e29ca16e57965a8e56dc8d2ee89565ba1905bb/grpcio-1.81.0-cp313-cp313-win32.whl", hash = "sha256:c197e2ef75a442528072b29e9755da299110e8610e8bcbb59a6b4cf55384f005", size = 4182777, upload-time = "2026-06-01T05:55:47.459Z" }, + { url = "https://files.pythonhosted.org/packages/a9/a7/932f2f748511a32e641a2aba0d30dded3ed6e8bc330e0924e4d5d86853e6/grpcio-1.81.0-cp313-cp313-win_amd64.whl", hash = "sha256:194eddfacc84d80f50512e9fd4ee851d5f2499f18f299c95aa8fb4748f0537e0", size = 4928085, upload-time = "2026-06-01T05:55:50.158Z" }, + { url = "https://files.pythonhosted.org/packages/c5/1d/28b231333857deb840bc3d182ae087510170ea6d68f21393aeb0fe499530/grpcio-1.81.0-cp314-cp314-linux_armv7l.whl", hash = "sha256:a9351055f52660b58f3d4890ea66188b5134399f82b11aa0c55bd4b99eff5390", size = 6055712, upload-time = "2026-06-01T05:55:52.889Z" }, + { url = "https://files.pythonhosted.org/packages/e8/b8/999c14f9dff0fc47549d2e827cba1343ddc18e1d1bf0d06d2cf628eecbd9/grpcio-1.81.0-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:300f3337b6425fd16ead9a4f9b2ac25801acb64aa5bc0b99eb69901645b2b1d2", size = 12057189, upload-time = "2026-06-01T05:55:55.952Z" }, + { url = "https://files.pythonhosted.org/packages/1e/3d/1fbde079572562af65351151d840525a13879eb7b481d35b55cd64c6127a/grpcio-1.81.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:97bbd623f7ded558fd4f7cb5a4f600c4d4de65c5dd364c83a5b14b2a10a2d3b5", size = 6608136, upload-time = "2026-06-01T05:55:59.069Z" }, + { url = "https://files.pythonhosted.org/packages/32/89/1f17cb6882abfd8e5a303a25d5d1665abef5a8c499a96198c65a651d1b85/grpcio-1.81.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:ff83d889e3ebf6341c8c7864ad8031591ad5ca61599072fc511644d1eb962d2b", size = 7307045, upload-time = "2026-06-01T05:56:02.376Z" }, + { url = "https://files.pythonhosted.org/packages/48/5a/f98e91b2e755652e637ea2144318b0229b290062199f761b445fe1fa6015/grpcio-1.81.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c4fe218c5a35e1d87a5a26544237f1fa41dfd9cbd3c856b0810a30061f8b0aaf", size = 6812794, upload-time = "2026-06-01T05:56:05.777Z" }, + { url = "https://files.pythonhosted.org/packages/0a/0c/77892d715ac41e7ec0ace2a50080ffb64e189188056f607a66fe0014d1ee/grpcio-1.81.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b8b025b6af43ee0ad4a70307025d77bcab5adde7c4597786010d802c203e9fc5", size = 7422767, upload-time = "2026-06-01T05:56:08.524Z" }, + { url = "https://files.pythonhosted.org/packages/3f/b8/aa04590c6564714d94954515f15a236e59d4b9b3ad01e615f1b706d7792d/grpcio-1.81.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:3d4e0ce5a40a998cf608c8ba60ecfe18fdf364a9aa193ae4ac3faeecd0e86757", size = 8408551, upload-time = "2026-06-01T05:56:11.283Z" }, + { url = "https://files.pythonhosted.org/packages/43/3d/4f4a3450a1973568910c6909cb74abbf2126f68aefae5976962f9f7ad50d/grpcio-1.81.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:aa948712c8e5fa40ec250870bda14bc7578e1bb832a8912d9d2a0f720518edbe", size = 7846468, upload-time = "2026-06-01T05:56:14.536Z" }, + { url = "https://files.pythonhosted.org/packages/88/f4/5827fd248221ad3b44161c23ce9b5f4ee405b04fc6da5fd402a9aa87a84a/grpcio-1.81.0-cp314-cp314-win32.whl", hash = "sha256:fbbe81314a9d92156abce8b62c09364eb8bafc0ca2a19919a45ec64b5c6cb664", size = 4264427, upload-time = "2026-06-01T05:56:17.192Z" }, + { url = "https://files.pythonhosted.org/packages/0c/e8/127dc2b246096ad50ef7c8d9b7b31d757787aeb796368bcdd4454e4204c4/grpcio-1.81.0-cp314-cp314-win_amd64.whl", hash = "sha256:b93cee313cae4e113fbb3a0ce1ea5633db6f63cfde2b2dc1d817429026b2a50b", size = 5070848, upload-time = "2026-06-01T05:56:19.735Z" }, ] [[package]] name = "grpcio-status" -version = "1.80.0" +version = "1.81.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "googleapis-common-protos" }, { name = "grpcio" }, { name = "protobuf" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/b1/ed/105f619bdd00cb47a49aa2feea6232ea2bbb04199d52a22cc6a7d603b5cb/grpcio_status-1.80.0.tar.gz", hash = "sha256:df73802a4c89a3ea88aa2aff971e886fccce162bc2e6511408b3d67a144381cd", size = 13901, upload-time = "2026-03-30T08:54:34.784Z" } +sdist = { url = "https://files.pythonhosted.org/packages/01/b6/cdc177114997d15c887fb09ccfd16705c8ceb8b4ca2487902b54a7bfd1af/grpcio_status-1.81.0.tar.gz", hash = "sha256:b6fe9788cfdd1f0f63c0528a1e0bfdb41e8ff0583e920d2d8e8888598c01bb69", size = 13900, upload-time = "2026-06-01T06:00:32.638Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/76/80/58cd2dfc19a07d022abe44bde7c365627f6c7cb6f692ada6c65ca437d09a/grpcio_status-1.80.0-py3-none-any.whl", hash = "sha256:4b56990363af50dbf2c2ebb80f1967185c07d87aa25aa2bea45ddb75fc181dbe", size = 14638, upload-time = "2026-03-30T08:54:01.569Z" }, + { url = "https://files.pythonhosted.org/packages/f3/b7/5aa346bf1cdecd4ed64b86c10a4d5a089ce3da89145f8328caf0b22b240d/grpcio_status-1.81.0-py3-none-any.whl", hash = "sha256:10eb4c2309db902dc26c1873e80a821bf794be772c10dfd83030f7f59f165fab", size = 14634, upload-time = "2026-06-01T06:00:13.345Z" }, ] [[package]] name = "hypothesis" -version = "6.152.9" +version = "6.155.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "exceptiongroup", marker = "python_full_version < '3.11' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing')" }, { name = "sortedcontainers" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/3b/fb/a5651eb0cd03ecee644e8f4d8cd2027b40a08bf1488f46201e794aebe9b5/hypothesis-6.152.9.tar.gz", hash = "sha256:de4711d69ce3a18009047c3b44882810fd0c0348c1558e920a4b0d2c45f59e1e", size = 472009, upload-time = "2026-05-19T17:10:19.586Z" } +sdist = { url = "https://files.pythonhosted.org/packages/49/ef/4a94c12429986a90076057513e084bf32106a9bdc62c8e29f58673dd85a2/hypothesis-6.155.1.tar.gz", hash = "sha256:07c102031612b98d7c1be15ca3608c43e1234d9d07e3a190a53fa01536700196", size = 477300, upload-time = "2026-05-29T23:12:57.515Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/79/d9/40ef7ed22f0c45c2316467edb9afb8fc172cd089cb329c0ee6da6b74416c/hypothesis-6.152.9-py3-none-any.whl", hash = "sha256:9c4fdccb1eac0b12ec740c12290d0e6a0bea3526a3f0bf812b7643bb563c2d8b", size = 538148, upload-time = "2026-05-19T17:10:16.131Z" }, + { url = "https://files.pythonhosted.org/packages/26/6e/8c9cf32201238617454303b1605dfa667d90cd1ef51226f92d9c2b3b8f7c/hypothesis-6.155.1-py3-none-any.whl", hash = "sha256:2753f469df3ba3c483b08e0c37dbcbc41d8316ebb921abcc07493ee9c8a7d187", size = 543715, upload-time = "2026-05-29T23:12:54.77Z" }, ] [[package]] @@ -1147,7 +1144,7 @@ name = "importlib-metadata" version = "9.0.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "zipp", marker = "(python_full_version < '3.14' and extra == 'extra-8-narwhals-dask') or (python_full_version < '3.14' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core') or (python_full_version < '3.14' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core-tests') or (python_full_version < '3.14' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-dev-core') or (python_full_version < '3.14' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing') or (extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing') or (extra != 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra != 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra != 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra != 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions')" }, + { name = "zipp", marker = "(python_full_version < '3.15' and extra == 'extra-8-narwhals-dask') or (python_full_version < '3.15' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-core') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-core-tests') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-dev-core') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core') or (extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core-tests') or (extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-dev-core') or (extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing') or (extra != 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra != 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra != 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra != 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra != 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/a9/01/15bb152d77b21318514a96f43af312635eb2500c96b55398d020c93d86ea/importlib_metadata-9.0.0.tar.gz", hash = "sha256:a4f57ab599e6a2e3016d7595cfd72eb4661a5106e787a95bcc90c7105b831efc", size = 56405, upload-time = "2026-03-20T06:42:56.999Z" } wheels = [ @@ -1719,11 +1716,11 @@ wheels = [ [[package]] name = "more-itertools" -version = "11.0.2" +version = "11.1.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a2/f7/139d22fef48ac78127d18e01d80cf1be40236ae489769d17f35c3d425293/more_itertools-11.0.2.tar.gz", hash = "sha256:392a9e1e362cbc106a2457d37cabf9b36e5e12efd4ebff1654630e76597df804", size = 144659, upload-time = "2026-04-09T15:01:33.297Z" } +sdist = { url = "https://files.pythonhosted.org/packages/de/1d/f4da6f02cdffe04d6362210b807146a26044c88d839208aec273bb0d9184/more_itertools-11.1.0.tar.gz", hash = "sha256:48e8f4d9e7e5878571ecf6f2b4e57634f93cd474cc8cfbd2376f2d11b396e30d", size = 145772, upload-time = "2026-05-22T14:14:29.909Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/cb/98/6af411189d9413534c3eb691182bff1f5c6d44ed2f93f2edfe52a1bbceb8/more_itertools-11.0.2-py3-none-any.whl", hash = "sha256:6e35b35f818b01f691643c6c611bc0902f2e92b46c18fffa77ae1e7c46e912e4", size = 71939, upload-time = "2026-04-09T15:01:32.21Z" }, + { url = "https://files.pythonhosted.org/packages/e8/3d/1087453384dbde46a8c7f9356eead2c58be8a7bf156bca40243377c85715/more_itertools-11.1.0-py3-none-any.whl", hash = "sha256:4b65538ae22f6fed0ce4874efd317463a7489796a0939fa66824dd542125a192", size = 72226, upload-time = "2026-05-22T14:14:28.824Z" }, ] [[package]] @@ -1834,7 +1831,7 @@ pandas = [ polars = [ { name = "polars", version = "0.20.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'group-8-narwhals-extreme-minimum-versions' or extra == 'group-8-narwhals-extreme-pretty-old-versions' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing')" }, { name = "polars", version = "0.20.8", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'group-8-narwhals-extreme-not-so-old-versions' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing')" }, - { name = "polars", version = "1.40.1", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-8-narwhals-cudf' or extra == 'group-8-narwhals-core' or extra == 'group-8-narwhals-core-tests' or extra == 'group-8-narwhals-dev-core' or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions')" }, + { name = "polars", version = "1.41.2", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-8-narwhals-cudf' or extra == 'group-8-narwhals-core' or extra == 'group-8-narwhals-core-tests' or extra == 'group-8-narwhals-dev-core' or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions')" }, ] pyarrow = [ { name = "pyarrow", version = "13.0.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'group-8-narwhals-extreme-minimum-versions' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing')" }, @@ -1843,14 +1840,12 @@ pyarrow = [ { name = "pyarrow", version = "23.0.1", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-8-narwhals-cudf' or extra == 'group-8-narwhals-core' or extra == 'group-8-narwhals-core-tests' or extra == 'group-8-narwhals-dev-core' or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions')" }, ] pyspark = [ - { name = "pyspark", version = "3.5.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-8-narwhals-cudf' or extra == 'group-8-narwhals-core' or extra == 'group-8-narwhals-core-tests' or extra == 'group-8-narwhals-dev-core' or extra == 'group-8-narwhals-local-dev' or extra == 'group-8-narwhals-min-pyspark-version' or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing')" }, - { name = "pyspark", version = "3.5.8", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'group-8-narwhals-extreme-minimum-versions' or extra == 'group-8-narwhals-extreme-not-so-old-versions' or extra == 'group-8-narwhals-extreme-pretty-old-versions' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing')" }, - { name = "pyspark", version = "4.1.1", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'group-8-narwhals-typing' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version')" }, + { name = "pyspark", version = "3.5.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-8-narwhals-cudf' or extra == 'group-8-narwhals-core' or extra == 'group-8-narwhals-core-tests' or extra == 'group-8-narwhals-dev-core' or extra == 'group-8-narwhals-extreme-minimum-versions' or extra == 'group-8-narwhals-extreme-not-so-old-versions' or extra == 'group-8-narwhals-extreme-pretty-old-versions' or extra == 'group-8-narwhals-local-dev' or extra == 'group-8-narwhals-min-pyspark-version' or extra != 'group-8-narwhals-typing' or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas')" }, + { name = "pyspark", version = "4.1.2", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'group-8-narwhals-typing' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version')" }, ] pyspark-connect = [ - { name = "pyspark", version = "3.5.0", source = { registry = "https://pypi.org/simple" }, extra = ["connect"], marker = "extra == 'extra-8-narwhals-cudf' or extra == 'group-8-narwhals-core' or extra == 'group-8-narwhals-core-tests' or extra == 'group-8-narwhals-dev-core' or extra == 'group-8-narwhals-local-dev' or extra == 'group-8-narwhals-min-pyspark-version' or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing')" }, - { name = "pyspark", version = "3.5.8", source = { registry = "https://pypi.org/simple" }, extra = ["connect"], marker = "extra == 'group-8-narwhals-extreme-minimum-versions' or extra == 'group-8-narwhals-extreme-not-so-old-versions' or extra == 'group-8-narwhals-extreme-pretty-old-versions' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing')" }, - { name = "pyspark", version = "4.1.1", source = { registry = "https://pypi.org/simple" }, extra = ["connect"], marker = "extra == 'group-8-narwhals-typing' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version')" }, + { name = "pyspark", version = "3.5.0", source = { registry = "https://pypi.org/simple" }, extra = ["connect"], marker = "extra == 'extra-8-narwhals-cudf' or extra == 'group-8-narwhals-core' or extra == 'group-8-narwhals-core-tests' or extra == 'group-8-narwhals-dev-core' or extra == 'group-8-narwhals-extreme-minimum-versions' or extra == 'group-8-narwhals-extreme-not-so-old-versions' or extra == 'group-8-narwhals-extreme-pretty-old-versions' or extra == 'group-8-narwhals-local-dev' or extra == 'group-8-narwhals-min-pyspark-version' or extra != 'group-8-narwhals-typing' or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas')" }, + { name = "pyspark", version = "4.1.2", source = { registry = "https://pypi.org/simple" }, extra = ["connect"], marker = "extra == 'group-8-narwhals-typing' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version')" }, ] sql = [ { name = "duckdb", version = "1.1.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'group-8-narwhals-extreme-minimum-versions' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing')" }, @@ -1878,7 +1873,6 @@ core-tests = [ { name = "pandas", version = "2.3.3", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.11' and extra == 'group-8-narwhals-core') or (python_full_version < '3.11' and extra == 'group-8-narwhals-core-tests') or (python_full_version < '3.11' and extra == 'group-8-narwhals-dev-core') or (python_full_version < '3.11' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (python_full_version < '3.11' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (python_full_version < '3.11' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing') or extra == 'extra-8-narwhals-cudf' or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core-tests') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-dev-core') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-local-dev') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions')" }, { name = "pandas", version = "3.0.3", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-core') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-core-tests') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-dev-core') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-local-dev') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-min-pyspark-version') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core-tests') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-dev-core') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-local-dev') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-min-pyspark-version') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing')" }, { name = "pytest" }, - { name = "pytest-cov" }, { name = "pytest-env" }, { name = "pytest-randomly" }, { name = "pytest-xdist" }, @@ -1888,7 +1882,6 @@ dev = [ { name = "hypothesis" }, { name = "prek" }, { name = "pytest" }, - { name = "pytest-cov" }, { name = "pytest-env" }, { name = "pytest-randomly" }, { name = "pytest-xdist" }, @@ -1903,7 +1896,6 @@ dev-core = [ { name = "pandas", version = "3.0.3", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-core') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-core-tests') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-dev-core') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-local-dev') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-min-pyspark-version') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core-tests') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-dev-core') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-local-dev') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-min-pyspark-version') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing')" }, { name = "prek" }, { name = "pytest" }, - { name = "pytest-cov" }, { name = "pytest-env" }, { name = "pytest-randomly" }, { name = "pytest-xdist" }, @@ -1939,7 +1931,6 @@ extreme-minimum-versions = [ { name = "pyarrow", version = "13.0.0", source = { registry = "https://pypi.org/simple" } }, { name = "pyarrow-stubs", version = "10.0.1.9", source = { registry = "https://pypi.org/simple" } }, { name = "pytest" }, - { name = "pytest-cov" }, { name = "pytest-env" }, { name = "pytest-randomly" }, { name = "pytest-xdist" }, @@ -1959,7 +1950,6 @@ extreme-not-so-old-versions = [ { name = "pyarrow", version = "15.0.0", source = { registry = "https://pypi.org/simple" } }, { name = "pyarrow-stubs", version = "10.0.1.9", source = { registry = "https://pypi.org/simple" } }, { name = "pytest" }, - { name = "pytest-cov" }, { name = "pytest-env" }, { name = "pytest-randomly" }, { name = "pytest-xdist" }, @@ -1978,7 +1968,6 @@ extreme-pretty-old-versions = [ { name = "pyarrow", version = "14.0.0", source = { registry = "https://pypi.org/simple" } }, { name = "pyarrow-stubs", version = "10.0.1.9", source = { registry = "https://pypi.org/simple" } }, { name = "pytest" }, - { name = "pytest-cov" }, { name = "pytest-env" }, { name = "pytest-randomly" }, { name = "pytest-xdist" }, @@ -2001,7 +1990,6 @@ local-dev = [ { name = "pandas", version = "3.0.3", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-core') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-core-tests') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-dev-core') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-local-dev') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-min-pyspark-version') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core-tests') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-dev-core') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-local-dev') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-min-pyspark-version') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing')" }, { name = "prek" }, { name = "pytest" }, - { name = "pytest-cov" }, { name = "pytest-env" }, { name = "pytest-randomly" }, { name = "pytest-xdist" }, @@ -2018,7 +2006,6 @@ min-pyspark-version = [ { name = "pandas", version = "3.0.3", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-core') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-core-tests') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-dev-core') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-local-dev') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-min-pyspark-version') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core-tests') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-dev-core') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-local-dev') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-min-pyspark-version') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing')" }, { name = "pyspark", version = "3.5.0", source = { registry = "https://pypi.org/simple" } }, { name = "pytest" }, - { name = "pytest-cov" }, { name = "pytest-env" }, { name = "pytest-randomly" }, { name = "pytest-xdist" }, @@ -2030,7 +2017,6 @@ tests = [ { name = "covdefaults" }, { name = "hypothesis" }, { name = "pytest" }, - { name = "pytest-cov" }, { name = "pytest-env" }, { name = "pytest-randomly" }, { name = "pytest-xdist" }, @@ -2085,7 +2071,6 @@ core-tests = [ { name = "narwhals", extras = ["duckdb", "polars", "pyarrow", "sqlframe", "sql"] }, { name = "pandas", specifier = ">=1.3.4" }, { name = "pytest", specifier = ">=9.0.3" }, - { name = "pytest-cov" }, { name = "pytest-env" }, { name = "pytest-randomly" }, { name = "pytest-xdist" }, @@ -2095,7 +2080,6 @@ dev = [ { name = "hypothesis", specifier = ">=6.0.0" }, { name = "prek" }, { name = "pytest", specifier = ">=9.0.3" }, - { name = "pytest-cov" }, { name = "pytest-env" }, { name = "pytest-randomly" }, { name = "pytest-xdist" }, @@ -2109,7 +2093,6 @@ dev-core = [ { name = "pandas", specifier = ">=1.3.4" }, { name = "prek" }, { name = "pytest", specifier = ">=9.0.3" }, - { name = "pytest-cov" }, { name = "pytest-env" }, { name = "pytest-randomly" }, { name = "pytest-xdist" }, @@ -2136,7 +2119,6 @@ extreme-minimum-versions = [ { name = "pyarrow", specifier = "==13.0.0" }, { name = "pyarrow-stubs", specifier = "<17" }, { name = "pytest", specifier = ">=9.0.3" }, - { name = "pytest-cov" }, { name = "pytest-env" }, { name = "pytest-randomly" }, { name = "pytest-xdist" }, @@ -2156,7 +2138,6 @@ extreme-not-so-old-versions = [ { name = "pyarrow", specifier = "==15.0.0" }, { name = "pyarrow-stubs", specifier = "<17" }, { name = "pytest", specifier = ">=9.0.3" }, - { name = "pytest-cov" }, { name = "pytest-env" }, { name = "pytest-randomly" }, { name = "pytest-xdist" }, @@ -2175,7 +2156,6 @@ extreme-pretty-old-versions = [ { name = "pyarrow", specifier = "==14.0.0" }, { name = "pyarrow-stubs", specifier = "<17" }, { name = "pytest", specifier = ">=9.0.3" }, - { name = "pytest-cov" }, { name = "pytest-env" }, { name = "pytest-randomly" }, { name = "pytest-xdist" }, @@ -2198,7 +2178,6 @@ local-dev = [ { name = "pandas", specifier = ">=1.3.4" }, { name = "prek" }, { name = "pytest", specifier = ">=9.0.3" }, - { name = "pytest-cov" }, { name = "pytest-env" }, { name = "pytest-randomly" }, { name = "pytest-xdist" }, @@ -2214,7 +2193,6 @@ min-pyspark-version = [ { name = "pandas", specifier = ">=1.3.4" }, { name = "pyspark", specifier = "==3.5.0" }, { name = "pytest", specifier = ">=9.0.3" }, - { name = "pytest-cov" }, { name = "pytest-env" }, { name = "pytest-randomly" }, { name = "pytest-xdist" }, @@ -2224,7 +2202,6 @@ tests = [ { name = "covdefaults" }, { name = "hypothesis", specifier = ">=6.0.0" }, { name = "pytest", specifier = ">=9.0.3" }, - { name = "pytest-cov" }, { name = "pytest-env" }, { name = "pytest-randomly" }, { name = "pytest-xdist" }, @@ -3095,11 +3072,11 @@ wheels = [ [[package]] name = "platformdirs" -version = "4.9.6" +version = "4.10.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/9f/4a/0883b8e3802965322523f0b200ecf33d31f10991d0401162f4b23c698b42/platformdirs-4.9.6.tar.gz", hash = "sha256:3bfa75b0ad0db84096ae777218481852c0ebc6c727b3168c1b9e0118e458cf0a", size = 29400, upload-time = "2026-04-09T00:04:10.812Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d7/47/e4501f49c178ae1d9f4a75073fda4204f52647993f075a9db4d14930e0c5/platformdirs-4.10.0.tar.gz", hash = "sha256:31e761a6a0ca04faf7353ea759bdba55652be214725111e5aac52dfa29d4bef7", size = 31224, upload-time = "2026-05-28T03:32:53.587Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/75/a6/a0a304dc33b49145b21f4808d763822111e67d1c3a32b524a1baf947b6e1/platformdirs-4.9.6-py3-none-any.whl", hash = "sha256:e61adb1d5e5cb3441b4b7710bea7e4c12250ca49439228cc1021c00dcfac0917", size = 21348, upload-time = "2026-04-09T00:04:09.463Z" }, + { url = "https://files.pythonhosted.org/packages/81/e6/cd9575ac904136b3cbf7aa7ee819ef86eedb7274e46f230e94ea4342e729/platformdirs-4.10.0-py3-none-any.whl", hash = "sha256:fb516cdb12eb0d857d0cd85a7c57cea4d060bee4578d6cf5a14dfdf8cbf8784a", size = 22743, upload-time = "2026-05-28T03:32:52.175Z" }, ] [[package]] @@ -3147,7 +3124,7 @@ wheels = [ [[package]] name = "polars" -version = "1.40.1" +version = "1.41.2" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version >= '3.15' and sys_platform == 'win32' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing'", @@ -3222,25 +3199,25 @@ resolution-markers = [ dependencies = [ { name = "polars-runtime-32", marker = "extra == 'extra-8-narwhals-cudf' or extra == 'group-8-narwhals-core' or extra == 'group-8-narwhals-core-tests' or extra == 'group-8-narwhals-dev-core' or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions')" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/b3/8c/bc9bc948058348ed43117cecc3007cd608f395915dae8a00974579a5dab1/polars-1.40.1.tar.gz", hash = "sha256:ab2694134b137596b5a59bfd7b4c54ebbc9b59f9403127f18e32d363777552e8", size = 733574, upload-time = "2026-04-22T19:15:55.507Z" } +sdist = { url = "https://files.pythonhosted.org/packages/ff/f9/aeda46259b0669247a160315d2d51269de9504b9dd2f70acadbcb22f46b7/polars-1.41.2.tar.gz", hash = "sha256:256d6731162371b77f3f29a55eacb8c0fc740ddb1a293a01d2ef5b5393c5c708", size = 737996, upload-time = "2026-05-29T17:39:15.604Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ea/91/74fc60d94488685a92ac9d49d7ec55f3e91fe9b77942a6235a5fa7f249c3/polars-1.40.1-py3-none-any.whl", hash = "sha256:c0f861219d1319cdea45c4ce4d30355a47176b8f98dcedf95ea8269f131b8abd", size = 828723, upload-time = "2026-04-22T19:14:25.452Z" }, + { url = "https://files.pythonhosted.org/packages/1f/22/28f62d24f7db56ac4343588f9362d49b7b4177e55ac47a466fe696b0099b/polars-1.41.2-py3-none-any.whl", hash = "sha256:23ce9a2910b6e3e8d4258770bf44aa17170958df7af6e85feedf4458a04d8d29", size = 833445, upload-time = "2026-05-29T17:37:05.576Z" }, ] [[package]] name = "polars-runtime-32" -version = "1.40.1" +version = "1.41.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/54/ba/26d40f039be9f552b5fd7365a621bdfc0f8e912ef77094ae4693491b0bae/polars_runtime_32-1.40.1.tar.gz", hash = "sha256:37f3065615d1bf90d03b5326222df4c5c1f8a5d33e50470aa588e3465e6eb814", size = 2935843, upload-time = "2026-04-22T19:15:57.26Z" } +sdist = { url = "https://files.pythonhosted.org/packages/f9/56/54e3ea0e9b64f327179049e4742241cc6b1d3e8fa414b05a057dd26df367/polars_runtime_32-1.41.2.tar.gz", hash = "sha256:7af09ec1ab053da2c9669e8d15f809a4083a29be05db57111688b8051062af56", size = 2989474, upload-time = "2026-05-29T17:39:17.257Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/7d/46/22c8af5eed68ac2eeb556e0fa3ca8a7b798e984ceff4450888f3b5ac61fd/polars_runtime_32-1.40.1-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:b748ef652270cc49e9e69f99a035e0eb4d5f856d42bcd6ac4d9d80a40142aa1e", size = 52098755, upload-time = "2026-04-22T19:14:28.555Z" }, - { url = "https://files.pythonhosted.org/packages/c6/3e/48599a38009ca60ff82a6f38c8a621ce3c0286aa7397c7d79e741bd9060e/polars_runtime_32-1.40.1-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:d249b3743e05986060cec0a7aaa542d020df6c6b876e556023a310efd581f9be", size = 46367542, upload-time = "2026-04-22T19:14:32.433Z" }, - { url = "https://files.pythonhosted.org/packages/43/e9/384bc069367a1a36ee31c13782c178dbd039b2b873b772d4a0fc23a2373d/polars_runtime_32-1.40.1-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5987b30e7aa1059d069498496e8dda35afd592b0ac3d46ed87e3ff8df1ad652c", size = 50252104, upload-time = "2026-04-22T19:14:35.945Z" }, - { url = "https://files.pythonhosted.org/packages/15/ef/7d57ceb0651af74194e97ed6583e148d352f03d696090221b8059cdfc90b/polars_runtime_32-1.40.1-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8d7f42a8b3f16fc66002cc0f6516f7dd7653396886ae0ed362ab95c0b3408b59", size = 56250788, upload-time = "2026-04-22T19:14:39.743Z" }, - { url = "https://files.pythonhosted.org/packages/10/0f/e4b3ffc748827a14a474ec9c42e45c066050e440fec57e914091d9adda75/polars_runtime_32-1.40.1-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:e5f7becc237a7ec9d9a10878dc8e54b73bbf4e2d94a2991c37d7a0b38590d8f9", size = 50432590, upload-time = "2026-04-22T19:14:43.388Z" }, - { url = "https://files.pythonhosted.org/packages/d9/0b/b8d95fbed869fa4caabe9c400e4210374913b376e925e96fdcfa9be6416b/polars_runtime_32-1.40.1-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:992d14cf191dde043d36fbdbc98a65e43fbc7e9a5024cecd45f838ac4988c1ee", size = 54155564, upload-time = "2026-04-22T19:14:47.239Z" }, - { url = "https://files.pythonhosted.org/packages/06/d9/d091d8fb5cbed5e9536adfed955c4c89987a4cc3b8e73ae4532402b91c74/polars_runtime_32-1.40.1-cp310-abi3-win_amd64.whl", hash = "sha256:f78bb2abd00101cbb23cc0cb068f7e36e081057a15d2ec2dde3dda280709f030", size = 51829755, upload-time = "2026-04-22T19:14:50.85Z" }, - { url = "https://files.pythonhosted.org/packages/65/ad/b33c3022a394f3eb55c3310597cec615412a8a33880055eee191d154a628/polars_runtime_32-1.40.1-cp310-abi3-win_arm64.whl", hash = "sha256:b5cbfaf6b085b420b4bfcbe24e8f665076d1cccfdb80c0484c02a023ce205537", size = 45822104, upload-time = "2026-04-22T19:14:54.192Z" }, + { url = "https://files.pythonhosted.org/packages/d6/9b/fe72a3811c0357cdb06c67bdc7695fa1623ad47948fc523195f5ac31037f/polars_runtime_32-1.41.2-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:95a08346dac337357cdb825c8076df7d36da54c4caa59a5cb41d0a30691c5edd", size = 52265283, upload-time = "2026-05-29T17:37:09.407Z" }, + { url = "https://files.pythonhosted.org/packages/0a/93/fab9da803fd80d9e83ef88c20932f637a10bc611b20415fc322eec84bc44/polars_runtime_32-1.41.2-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:dedfaeec2c7f995298da7319dd9431d662e5dd1d0ec51b1459df4a0234ceff52", size = 46571222, upload-time = "2026-05-29T17:37:13.698Z" }, + { url = "https://files.pythonhosted.org/packages/c8/2a/8843f34a8ac57acd058a39b87b03b580dd352a490e9dae0415e02033bdd4/polars_runtime_32-1.41.2-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:18eea22c5cc34e27f8a60950458ad81e6a9ea75e89363ca1367e14e7e7f781fc", size = 50409372, upload-time = "2026-05-29T17:37:17.875Z" }, + { url = "https://files.pythonhosted.org/packages/6c/c6/92b352fe88cf51bd0a19fb99e1c0cbe46aa26c14dcf7995b89869cd932ae/polars_runtime_32-1.41.2-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2630540dfdfb0f36f9b04a07c7c2e3f50bf2ad384113263c1c812007ee9141e0", size = 56405484, upload-time = "2026-05-29T17:37:22.684Z" }, + { url = "https://files.pythonhosted.org/packages/74/c4/bae3174c3b02f6b441d2e58594387abcd509f67a098f682a83b195f08966/polars_runtime_32-1.41.2-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:20e969e08f9b137e233c04cc04de73d9795f89eb77d34854e40a025965a43763", size = 50603512, upload-time = "2026-05-29T17:37:27.422Z" }, + { url = "https://files.pythonhosted.org/packages/f4/ed/f2d26ae02d92c2689056838ed59e2a626326ad23c2831d58637d25f6c82a/polars_runtime_32-1.41.2-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e7016a3deb641b64a31447abbbee0f34bd020a6a9ae34ee6b743837def15e2a4", size = 54328561, upload-time = "2026-05-29T17:37:32.587Z" }, + { url = "https://files.pythonhosted.org/packages/9b/c4/9c3831cc885dc7769e59abf8f583821a5fb4403fd0e4eba0ccc6d47a3d4b/polars_runtime_32-1.41.2-cp310-abi3-win_amd64.whl", hash = "sha256:1e5e5377c315e0dcafdfb2a31adc546abbaeb3f9cb1864e6536523d2af473265", size = 51978643, upload-time = "2026-05-29T17:37:37.443Z" }, + { url = "https://files.pythonhosted.org/packages/cd/c6/79e9f3f270270d7ed5575d92b7bfef49f01abd9275447161275b23b553a8/polars_runtime_32-1.41.2-cp310-abi3-win_arm64.whl", hash = "sha256:843d96f69d18eca53429c1198e58891db7f18111f83b9c419bb45ad9d73eaed5", size = 46006901, upload-time = "2026-05-29T17:37:42.522Z" }, ] [[package]] @@ -3281,17 +3258,17 @@ wheels = [ [[package]] name = "protobuf" -version = "6.33.6" +version = "7.35.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/66/70/e908e9c5e52ef7c3a6c7902c9dfbb34c7e29c25d2f81ade3856445fd5c94/protobuf-6.33.6.tar.gz", hash = "sha256:a6768d25248312c297558af96a9f9c929e8c4cee0659cb07e780731095f38135", size = 444531, upload-time = "2026-03-18T19:05:00.988Z" } +sdist = { url = "https://files.pythonhosted.org/packages/60/fd/5b1491d9e4b586d621c54f4c36b888714164b6875f8d6afa3f9072906a51/protobuf-7.35.0.tar.gz", hash = "sha256:a2efd84605f41e559f1881b0912b44099d0a2ac9bf46b3474823f10fb393b0e6", size = 458677, upload-time = "2026-05-19T23:02:29.197Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/fc/9f/2f509339e89cfa6f6a4c4ff50438db9ca488dec341f7e454adad60150b00/protobuf-6.33.6-cp310-abi3-win32.whl", hash = "sha256:7d29d9b65f8afef196f8334e80d6bc1d5d4adedb449971fefd3723824e6e77d3", size = 425739, upload-time = "2026-03-18T19:04:48.373Z" }, - { url = "https://files.pythonhosted.org/packages/76/5d/683efcd4798e0030c1bab27374fd13a89f7c2515fb1f3123efdfaa5eab57/protobuf-6.33.6-cp310-abi3-win_amd64.whl", hash = "sha256:0cd27b587afca21b7cfa59a74dcbd48a50f0a6400cfb59391340ad729d91d326", size = 437089, upload-time = "2026-03-18T19:04:50.381Z" }, - { url = "https://files.pythonhosted.org/packages/5c/01/a3c3ed5cd186f39e7880f8303cc51385a198a81469d53d0fdecf1f64d929/protobuf-6.33.6-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:9720e6961b251bde64edfdab7d500725a2af5280f3f4c87e57c0208376aa8c3a", size = 427737, upload-time = "2026-03-18T19:04:51.866Z" }, - { url = "https://files.pythonhosted.org/packages/ee/90/b3c01fdec7d2f627b3a6884243ba328c1217ed2d978def5c12dc50d328a3/protobuf-6.33.6-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:e2afbae9b8e1825e3529f88d514754e094278bb95eadc0e199751cdd9a2e82a2", size = 324610, upload-time = "2026-03-18T19:04:53.096Z" }, - { url = "https://files.pythonhosted.org/packages/9b/ca/25afc144934014700c52e05103c2421997482d561f3101ff352e1292fb81/protobuf-6.33.6-cp39-abi3-manylinux2014_s390x.whl", hash = "sha256:c96c37eec15086b79762ed265d59ab204dabc53056e3443e702d2681f4b39ce3", size = 339381, upload-time = "2026-03-18T19:04:54.616Z" }, - { url = "https://files.pythonhosted.org/packages/16/92/d1e32e3e0d894fe00b15ce28ad4944ab692713f2e7f0a99787405e43533a/protobuf-6.33.6-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:e9db7e292e0ab79dd108d7f1a94fe31601ce1ee3f7b79e0692043423020b0593", size = 323436, upload-time = "2026-03-18T19:04:55.768Z" }, - { url = "https://files.pythonhosted.org/packages/c4/72/02445137af02769918a93807b2b7890047c32bfb9f90371cbc12688819eb/protobuf-6.33.6-py3-none-any.whl", hash = "sha256:77179e006c476e69bf8e8ce866640091ec42e1beb80b213c3900006ecfba6901", size = 170656, upload-time = "2026-03-18T19:04:59.826Z" }, + { url = "https://files.pythonhosted.org/packages/83/ee/93d06e358a4aa32280b00e722d3ea0a1f25fc3cc5778d80581c9cca2c10e/protobuf-7.35.0-cp310-abi3-macosx_10_9_universal2.whl", hash = "sha256:66be6c513931c794fa92c080ffee41671390da3d79da219cf9c0c0907f035dda", size = 433225, upload-time = "2026-05-19T23:02:19.884Z" }, + { url = "https://files.pythonhosted.org/packages/8b/39/1c76c2da93f3c507e958e0aecee2391cc44d4625de6c728bbc555195b5a8/protobuf-7.35.0-cp310-abi3-manylinux2014_aarch64.whl", hash = "sha256:fcbe42a4ac09d3ec9c987ddfcd956afd0b15f1ff613bd8371bde9405ffd5c8e5", size = 328847, upload-time = "2026-05-19T23:02:22.3Z" }, + { url = "https://files.pythonhosted.org/packages/91/1a/39f7ce90a238c1a987a4d81ec26379e02ca0aff367de68e4a1fa474215b9/protobuf-7.35.0-cp310-abi3-manylinux2014_s390x.whl", hash = "sha256:4cbf5cc286130e06a6c9bbefac442431173906dfcc979712183d4adcc01b37ee", size = 344030, upload-time = "2026-05-19T23:02:23.591Z" }, + { url = "https://files.pythonhosted.org/packages/70/5b/6baf9008817964454055ff3fe65f1de0b5f1e26c80c82f7fb108b7cd4ea3/protobuf-7.35.0-cp310-abi3-manylinux2014_x86_64.whl", hash = "sha256:6c0f98f10c8a05ea30f8993dfef2de093d27b490fdae78bb60c8343795d55011", size = 327130, upload-time = "2026-05-19T23:02:24.637Z" }, + { url = "https://files.pythonhosted.org/packages/8e/e5/e46adb0badc388bfb84877a5f9f026aff63f60e611016cf64dbe77e05446/protobuf-7.35.0-cp310-abi3-win32.whl", hash = "sha256:4c4617b83ade0e279d1d2bfe04025a1adb87f9ed657de038620dc0ff959357f6", size = 428946, upload-time = "2026-05-19T23:02:25.741Z" }, + { url = "https://files.pythonhosted.org/packages/a7/ab/547fbd9e16d879dd13c167478f8ae0a83a428008ca07a5e06acdc23ad473/protobuf-7.35.0-cp310-abi3-win_amd64.whl", hash = "sha256:f05bcadf9a2a6b8dda047007075135fb7d08c73d9177aabc067e1be46881a201", size = 439996, upload-time = "2026-05-19T23:02:26.808Z" }, + { url = "https://files.pythonhosted.org/packages/b8/ef/50433d346c56657a70d27f156c7b349ac59a068b01de4eb796e747eecc43/protobuf-7.35.0-py3-none-any.whl", hash = "sha256:c13f325cf242bad135c350629eeb5d54b24228eb472fb3e2e9ebbd4c5dc20ca0", size = 171659, upload-time = "2026-05-19T23:02:27.842Z" }, ] [[package]] @@ -3334,6 +3311,12 @@ resolution-markers = [ "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", + "python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", + "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", + "python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", + "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", + "python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", + "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", @@ -3344,6 +3327,8 @@ resolution-markers = [ "python_full_version >= '3.12' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", "python_full_version == '3.11.*' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", + "python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", + "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", "python_full_version >= '3.12' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", "python_full_version == '3.11.*' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", @@ -3364,6 +3349,12 @@ resolution-markers = [ "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", + "python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", + "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", + "python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", + "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", + "python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", + "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", @@ -3392,18 +3383,10 @@ resolution-markers = [ "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing'", "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing'", "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing'", - "python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", - "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", - "python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", - "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", - "python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", - "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", "python_full_version >= '3.15' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing'", "python_full_version >= '3.12' and python_full_version < '3.15' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing'", "python_full_version == '3.11.*' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing'", "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing'", - "python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", - "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", "python_full_version >= '3.15' and sys_platform == 'win32' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing'", "python_full_version >= '3.15' and sys_platform == 'emscripten' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing'", "python_full_version >= '3.15' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing'", @@ -3414,12 +3397,6 @@ resolution-markers = [ "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing'", "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing'", "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing'", - "python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", - "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", - "python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", - "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", - "python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", - "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", ] sdist = { url = "https://files.pythonhosted.org/packages/38/31/0b210511177070c8d5d3059556194352e5753602fa64b85b7ab81ec1a009/py4j-0.10.9.9.tar.gz", hash = "sha256:f694cad19efa5bd1dee4f3e5270eb406613c974394035e5bfc4ec1aba870b879", size = 761089, upload-time = "2025-01-15T03:53:18.624Z" } wheels = [ @@ -3836,6 +3813,12 @@ resolution-markers = [ "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", + "python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", + "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", + "python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", + "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", + "python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", + "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", @@ -3846,6 +3829,8 @@ resolution-markers = [ "python_full_version >= '3.12' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", "python_full_version == '3.11.*' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", + "python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", + "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", "python_full_version >= '3.12' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", "python_full_version == '3.11.*' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", @@ -3866,6 +3851,12 @@ resolution-markers = [ "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", + "python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", + "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", + "python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", + "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", + "python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", + "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-dask' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra != 'group-8-narwhals-typing'", "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", @@ -3875,54 +3866,34 @@ resolution-markers = [ "python_full_version < '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing'", ] dependencies = [ - { name = "py4j", version = "0.10.9.7", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-8-narwhals-cudf' or extra == 'group-8-narwhals-core' or extra == 'group-8-narwhals-core-tests' or extra == 'group-8-narwhals-dev-core' or extra == 'group-8-narwhals-local-dev' or extra == 'group-8-narwhals-min-pyspark-version' or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing')" }, + { name = "py4j", version = "0.10.9.7", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-8-narwhals-cudf' or extra == 'group-8-narwhals-core' or extra == 'group-8-narwhals-core-tests' or extra == 'group-8-narwhals-dev-core' or extra == 'group-8-narwhals-extreme-minimum-versions' or extra == 'group-8-narwhals-extreme-not-so-old-versions' or extra == 'group-8-narwhals-extreme-pretty-old-versions' or extra == 'group-8-narwhals-local-dev' or extra == 'group-8-narwhals-min-pyspark-version' or extra != 'group-8-narwhals-typing' or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/92/11/5c0f24537fa68624cb6271d2a8a8982e81bd05f5cb51e9d2d2a89baa0e1a/pyspark-3.5.0.tar.gz", hash = "sha256:d41a9b76bd2aca370a6100d075c029e22ba44c5940927877e9435a3a9c566558", size = 316890381, upload-time = "2023-09-26T20:30:58.621Z" } [package.optional-dependencies] connect = [ - { name = "googleapis-common-protos", marker = "extra == 'extra-8-narwhals-cudf' or extra == 'group-8-narwhals-core' or extra == 'group-8-narwhals-core-tests' or extra == 'group-8-narwhals-dev-core' or extra == 'group-8-narwhals-local-dev' or extra == 'group-8-narwhals-min-pyspark-version' or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing')" }, - { name = "grpcio", marker = "extra == 'extra-8-narwhals-cudf' or extra == 'group-8-narwhals-core' or extra == 'group-8-narwhals-core-tests' or extra == 'group-8-narwhals-dev-core' or extra == 'group-8-narwhals-local-dev' or extra == 'group-8-narwhals-min-pyspark-version' or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing')" }, - { name = "grpcio-status", marker = "extra == 'extra-8-narwhals-cudf' or extra == 'group-8-narwhals-core' or extra == 'group-8-narwhals-core-tests' or extra == 'group-8-narwhals-dev-core' or extra == 'group-8-narwhals-local-dev' or extra == 'group-8-narwhals-min-pyspark-version' or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing')" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.11' and extra == 'extra-8-narwhals-cudf') or (python_full_version < '3.11' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core') or (python_full_version < '3.11' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core-tests') or (python_full_version < '3.11' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-dev-core') or (python_full_version < '3.11' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-core') or (python_full_version < '3.11' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-core-tests') or (python_full_version < '3.11' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-dev-core') or (python_full_version < '3.11' and extra != 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (python_full_version < '3.11' and extra != 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (python_full_version < '3.11' and extra != 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing') or (python_full_version < '3.11' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (python_full_version < '3.11' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (python_full_version < '3.11' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing')" }, - { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.11' and extra == 'extra-8-narwhals-cudf') or (python_full_version >= '3.11' and extra == 'group-8-narwhals-core') or (python_full_version >= '3.11' and extra == 'group-8-narwhals-core-tests') or (python_full_version >= '3.11' and extra == 'group-8-narwhals-dev-core') or (python_full_version >= '3.11' and extra == 'group-8-narwhals-local-dev') or (python_full_version >= '3.11' and extra == 'group-8-narwhals-min-pyspark-version') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (python_full_version >= '3.11' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing')" }, - { name = "pandas", version = "2.3.3", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.11' and extra == 'group-8-narwhals-core') or (python_full_version < '3.11' and extra == 'group-8-narwhals-core-tests') or (python_full_version < '3.11' and extra == 'group-8-narwhals-dev-core') or (python_full_version < '3.11' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (python_full_version < '3.11' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (python_full_version < '3.11' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing') or extra == 'extra-8-narwhals-cudf' or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core-tests') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-dev-core') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-local-dev') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions')" }, - { name = "pandas", version = "3.0.3", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-core') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-core-tests') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-dev-core') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-local-dev') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-min-pyspark-version') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core-tests') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-dev-core') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-local-dev') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-min-pyspark-version') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing')" }, - { name = "pyarrow", version = "23.0.1", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-8-narwhals-cudf' or extra == 'group-8-narwhals-core' or extra == 'group-8-narwhals-core-tests' or extra == 'group-8-narwhals-dev-core' or extra == 'group-8-narwhals-local-dev' or extra == 'group-8-narwhals-min-pyspark-version' or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing')" }, -] - -[[package]] -name = "pyspark" -version = "3.5.8" -source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version >= '3.11'", - "python_full_version < '3.11'", -] -dependencies = [ - { name = "py4j", version = "0.10.9.9", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'group-8-narwhals-extreme-minimum-versions' or extra == 'group-8-narwhals-extreme-not-so-old-versions' or extra == 'group-8-narwhals-extreme-pretty-old-versions' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing')" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/80/5a/3806f44eb47387e8af803508cdd6bbc0df784febf4dc010700be04a1ff89/pyspark-3.5.8.tar.gz", hash = "sha256:54cca0767b21b40e3953ad1d30f8601c53abf9cbda763653289cdcfcac52313c", size = 317817299, upload-time = "2026-01-15T11:46:14.487Z" } - -[package.optional-dependencies] -connect = [ - { name = "googleapis-common-protos", marker = "extra == 'group-8-narwhals-extreme-minimum-versions' or extra == 'group-8-narwhals-extreme-not-so-old-versions' or extra == 'group-8-narwhals-extreme-pretty-old-versions' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing')" }, - { name = "grpcio", marker = "extra == 'group-8-narwhals-extreme-minimum-versions' or extra == 'group-8-narwhals-extreme-not-so-old-versions' or extra == 'group-8-narwhals-extreme-pretty-old-versions' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing')" }, - { name = "grpcio-status", marker = "extra == 'group-8-narwhals-extreme-minimum-versions' or extra == 'group-8-narwhals-extreme-not-so-old-versions' or extra == 'group-8-narwhals-extreme-pretty-old-versions' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing')" }, + { name = "googleapis-common-protos", marker = "extra == 'extra-8-narwhals-cudf' or extra == 'group-8-narwhals-core' or extra == 'group-8-narwhals-core-tests' or extra == 'group-8-narwhals-dev-core' or extra == 'group-8-narwhals-extreme-minimum-versions' or extra == 'group-8-narwhals-extreme-not-so-old-versions' or extra == 'group-8-narwhals-extreme-pretty-old-versions' or extra == 'group-8-narwhals-local-dev' or extra == 'group-8-narwhals-min-pyspark-version' or extra != 'group-8-narwhals-typing' or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas')" }, + { name = "grpcio", marker = "extra == 'extra-8-narwhals-cudf' or extra == 'group-8-narwhals-core' or extra == 'group-8-narwhals-core-tests' or extra == 'group-8-narwhals-dev-core' or extra == 'group-8-narwhals-extreme-minimum-versions' or extra == 'group-8-narwhals-extreme-not-so-old-versions' or extra == 'group-8-narwhals-extreme-pretty-old-versions' or extra == 'group-8-narwhals-local-dev' or extra == 'group-8-narwhals-min-pyspark-version' or extra != 'group-8-narwhals-typing' or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas')" }, + { name = "grpcio-status", marker = "extra == 'extra-8-narwhals-cudf' or extra == 'group-8-narwhals-core' or extra == 'group-8-narwhals-core-tests' or extra == 'group-8-narwhals-dev-core' or extra == 'group-8-narwhals-extreme-minimum-versions' or extra == 'group-8-narwhals-extreme-not-so-old-versions' or extra == 'group-8-narwhals-extreme-pretty-old-versions' or extra == 'group-8-narwhals-local-dev' or extra == 'group-8-narwhals-min-pyspark-version' or extra != 'group-8-narwhals-typing' or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas')" }, { name = "numpy", version = "1.21.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'group-8-narwhals-extreme-minimum-versions' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing')" }, { name = "numpy", version = "1.22.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'group-8-narwhals-extreme-pretty-old-versions' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing')" }, { name = "numpy", version = "1.24.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'group-8-narwhals-extreme-not-so-old-versions' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.11' and extra == 'extra-8-narwhals-cudf') or (python_full_version < '3.11' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core') or (python_full_version < '3.11' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core-tests') or (python_full_version < '3.11' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-dev-core') or (python_full_version < '3.11' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-core') or (python_full_version < '3.11' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-core-tests') or (python_full_version < '3.11' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra == 'group-8-narwhals-dev-core') or (python_full_version < '3.11' and extra != 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (python_full_version < '3.11' and extra != 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (python_full_version < '3.11' and extra != 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing') or (python_full_version < '3.11' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (python_full_version < '3.11' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (python_full_version < '3.11' and extra != 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin' and extra != 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing')" }, + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.11' and extra == 'extra-8-narwhals-cudf') or (python_full_version >= '3.11' and extra == 'group-8-narwhals-core') or (python_full_version >= '3.11' and extra == 'group-8-narwhals-core-tests') or (python_full_version >= '3.11' and extra == 'group-8-narwhals-dev-core') or (python_full_version >= '3.11' and extra == 'group-8-narwhals-local-dev') or (python_full_version >= '3.11' and extra == 'group-8-narwhals-min-pyspark-version') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (python_full_version >= '3.11' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing')" }, { name = "pandas", version = "1.3.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'group-8-narwhals-extreme-minimum-versions' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing')" }, { name = "pandas", version = "1.4.1", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'group-8-narwhals-extreme-pretty-old-versions' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing')" }, { name = "pandas", version = "2.0.3", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'group-8-narwhals-extreme-not-so-old-versions' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing')" }, + { name = "pandas", version = "2.3.3", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.11' and extra == 'group-8-narwhals-core') or (python_full_version < '3.11' and extra == 'group-8-narwhals-core-tests') or (python_full_version < '3.11' and extra == 'group-8-narwhals-dev-core') or (python_full_version < '3.11' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (python_full_version < '3.11' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (python_full_version < '3.11' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing') or extra == 'extra-8-narwhals-cudf' or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core-tests') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-dev-core') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-local-dev') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions')" }, + { name = "pandas", version = "3.0.3", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-core') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-core-tests') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-dev-core') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-local-dev') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-min-pyspark-version') or (python_full_version >= '3.11' and extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-core-tests') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-dev-core') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-local-dev') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-min-pyspark-version') or (python_full_version >= '3.11' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing')" }, { name = "pyarrow", version = "13.0.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'group-8-narwhals-extreme-minimum-versions' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing')" }, { name = "pyarrow", version = "14.0.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'group-8-narwhals-extreme-pretty-old-versions' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing')" }, { name = "pyarrow", version = "15.0.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'group-8-narwhals-extreme-not-so-old-versions' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-local-dev' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing')" }, + { name = "pyarrow", version = "23.0.1", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-8-narwhals-cudf' or extra == 'group-8-narwhals-core' or extra == 'group-8-narwhals-core-tests' or extra == 'group-8-narwhals-dev-core' or extra == 'group-8-narwhals-local-dev' or extra == 'group-8-narwhals-min-pyspark-version' or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-dask' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (extra == 'extra-8-narwhals-modin' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-typing') or (extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-typing')" }, ] [[package]] name = "pyspark" -version = "4.1.1" +version = "4.1.2" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version >= '3.15' and sys_platform == 'win32' and extra != 'extra-8-narwhals-cudf' and extra != 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas' and extra != 'group-8-narwhals-core' and extra != 'group-8-narwhals-core-tests' and extra != 'group-8-narwhals-dev-core' and extra != 'group-8-narwhals-extreme-minimum-versions' and extra != 'group-8-narwhals-extreme-not-so-old-versions' and extra != 'group-8-narwhals-extreme-pretty-old-versions' and extra != 'group-8-narwhals-local-dev' and extra != 'group-8-narwhals-min-pyspark-version' and extra == 'group-8-narwhals-typing'", @@ -3953,7 +3924,7 @@ resolution-markers = [ dependencies = [ { name = "py4j", version = "0.10.9.9", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'group-8-narwhals-typing' or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-dask') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-cudf' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'extra-8-narwhals-cudf' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'extra-8-narwhals-modin') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-dask' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'extra-8-narwhals-pandas') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'extra-8-narwhals-modin' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-core-tests' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-minimum-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-dev-core' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-not-so-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-minimum-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-extreme-pretty-old-versions') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-not-so-old-versions' and extra == 'group-8-narwhals-min-pyspark-version') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-local-dev') or (extra == 'group-8-narwhals-extreme-pretty-old-versions' and extra == 'group-8-narwhals-min-pyspark-version')" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/19/bf/58ee13add151469c25825b7125bbf62c3bdcec05eec4d458fcb5c5516066/pyspark-4.1.1.tar.gz", hash = "sha256:77f78984aa84fbe865c717dd37b49913b4e5c97d76ef6824f932f1aefa6621ec", size = 455359625, upload-time = "2026-01-09T09:38:38.28Z" } +sdist = { url = "https://files.pythonhosted.org/packages/5e/71/4dd20c69332a2a4bf7ece8a655c9da98e4bd9b6bcea235349c1a00399d57/pyspark-4.1.2.tar.gz", hash = "sha256:fa5d6159f700d0990a07f4f62df1b7449401dccee9cd7d5d6df8957530841602", size = 455428043, upload-time = "2026-05-21T14:49:21.785Z" } [package.optional-dependencies] connect = [ @@ -3986,20 +3957,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" }, ] -[[package]] -name = "pytest-cov" -version = "7.1.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "coverage", extra = ["toml"] }, - { name = "pluggy" }, - { name = "pytest" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/b1/51/a849f96e117386044471c8ec2bd6cfebacda285da9525c9106aeb28da671/pytest_cov-7.1.0.tar.gz", hash = "sha256:30674f2b5f6351aa09702a9c8c364f6a01c27aae0c1366ae8016160d1efc56b2", size = 55592, upload-time = "2026-03-21T20:11:16.284Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/9d/7a/d968e294073affff457b041c2be9868a40c1c71f4a35fcc1e45e5493067b/pytest_cov-7.1.0-py3-none-any.whl", hash = "sha256:a0461110b7865f9a271aa1b51e516c9a95de9d696734a2f71e3e78f46e1d4678", size = 22876, upload-time = "2026-03-21T20:11:14.438Z" }, -] - [[package]] name = "pytest-env" version = "1.6.0" @@ -4251,27 +4208,27 @@ wheels = [ [[package]] name = "ruff" -version = "0.15.13" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/24/21/a7d5c126d5b557715ef81098f3db2fe20f622a039ff2e626af28d674ab80/ruff-0.15.13.tar.gz", hash = "sha256:f9d89f17f7ba7fb2ed42921f0df75da797a9a5d71bc39049e2c687cf2baf44b7", size = 4678180, upload-time = "2026-05-14T13:44:37.869Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c6/61/11d458dc6ac22504fd8e237b29dfd40504c7fbbcc8930402cfe51a8e63ed/ruff-0.15.13-py3-none-linux_armv6l.whl", hash = "sha256:444b580fc72fd6887e650acd3e575e18cdc79dbcf42fb4030b491057921f61f8", size = 10738279, upload-time = "2026-05-14T13:44:18.7Z" }, - { url = "https://files.pythonhosted.org/packages/86/ca/caa871ee7be718c45256fada4e16a218ee3e33f0c4a46b729a60a24912e6/ruff-0.15.13-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:6590d009e7cb7ebf36f83dbdd44a3fa48a0994ff6f1cdc1b08006abe58f98dc7", size = 11124798, upload-time = "2026-05-14T13:44:06.427Z" }, - { url = "https://files.pythonhosted.org/packages/d3/19/43f5f2e568dddde567fc41f8471f9432c09563e19d3e617a48cfa52f8f0a/ruff-0.15.13-py3-none-macosx_11_0_arm64.whl", hash = "sha256:1c26d2f66163deeb6e08d8b39fbbe983ce3c71cea06a6d7591cfd1421793c629", size = 10460761, upload-time = "2026-05-14T13:44:04.375Z" }, - { url = "https://files.pythonhosted.org/packages/99/df/cf938cd6de3003178f03ad7c1ea2a6c099468c03a35037985070b37e76be/ruff-0.15.13-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9dbd6f94b434f896308e4d57fb7bfde0d02b99f7a64b3bdab0fdfa6a864203a5", size = 10804451, upload-time = "2026-05-14T13:44:25.221Z" }, - { url = "https://files.pythonhosted.org/packages/c7/7d/5d0973129b154ded2225729169d7068f26b467760b146493fde138415f23/ruff-0.15.13-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bf3259f3be4d181bda591da5db2571aed6853c6a048157756448020bc6c5cd22", size = 10534285, upload-time = "2026-05-14T13:44:08.888Z" }, - { url = "https://files.pythonhosted.org/packages/1f/e3/6b999bbc66cd51e5f073842bc2a3995e99c5e0e72e16b15e7261f7abf57a/ruff-0.15.13-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ae9c17e5eb4430c154e76abc25d79a318190f5a997f38fb6b114416c5319ffc9", size = 11312063, upload-time = "2026-05-14T13:44:11.274Z" }, - { url = "https://files.pythonhosted.org/packages/af/5a/642639e9f5db04f1e97fbd6e091c6fd20725bdf072fb114d00eefb9e6eb8/ruff-0.15.13-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2e2e39bff6c341f4b577a21b801326fab0b11847f48fcaa83f00a113c9b3cb55", size = 12183079, upload-time = "2026-05-14T13:44:01.634Z" }, - { url = "https://files.pythonhosted.org/packages/19/4c/7585735f6b53b0f12de13618b2f7d250a844f018822efc899df2e7b8295f/ruff-0.15.13-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e8d9a8e08013542e94d3220bc5b62cc3e5ef87c5f74bff367d3fac14fab013e6", size = 11440833, upload-time = "2026-05-14T13:43:59.043Z" }, - { url = "https://files.pythonhosted.org/packages/e8/31/bf1a0803d077e679cfeee5f2f67290a0fa79c7385b5d9a8c17b9db2c48f0/ruff-0.15.13-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc411dfebe5eebe55ce041c6ae080eb7668955e866daa2fbb16692a784f1c4ca", size = 11434486, upload-time = "2026-05-14T13:44:27.761Z" }, - { url = "https://files.pythonhosted.org/packages/e1/4e/62c9b999875d4f14db80f277c030578f5e249c9852d65b7ac7ad0b43c041/ruff-0.15.13-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:768494eb08b9cee54e2fd27969966f74db5a57f6eaa7a90fcb3306af34dfc4bd", size = 11385189, upload-time = "2026-05-14T13:44:13.704Z" }, - { url = "https://files.pythonhosted.org/packages/fc/89/7e959047a104df3eb12863447c110140191fc5b6c4f379ea2e803fcdb0e4/ruff-0.15.13-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:fb75f9a3a7e42ffe117d734494e6c5e5cb3565d66e12612cb63d0e572a41a5b6", size = 10781380, upload-time = "2026-05-14T13:43:56.734Z" }, - { url = "https://files.pythonhosted.org/packages/ff/52/5fd18f3b88cab63e88aa11516b3b4e1e5f720e5c330f8dbe5c26210f41f8/ruff-0.15.13-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:8cb74dd33bb2f6613faf7fc03b660053b5ac4f80e706d5788c6335e2a8048d51", size = 10540605, upload-time = "2026-05-14T13:44:20.748Z" }, - { url = "https://files.pythonhosted.org/packages/e8/e0/9e35f338990d3e41a82875ff7053ffe97541dae81c9d02143177f381d572/ruff-0.15.13-py3-none-musllinux_1_2_i686.whl", hash = "sha256:7ef823f817fcd191dc934e984be9cf4094f808effa16f2542ad8e821ba02bbf2", size = 11036554, upload-time = "2026-05-14T13:44:16.256Z" }, - { url = "https://files.pythonhosted.org/packages/c2/13/070fb048c24080fba188f66371e2a92785be257ad02242066dc7255ac6e9/ruff-0.15.13-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:f345a13937bd7f09f6f5d19fa0721b0c103e00e7f62bc67089a8e5e037719e0b", size = 11528133, upload-time = "2026-05-14T13:44:22.808Z" }, - { url = "https://files.pythonhosted.org/packages/6b/8c/b1e1666aef7fc6555094d73ae6cd981701781ae85b97ceefc0eebd0b4668/ruff-0.15.13-py3-none-win32.whl", hash = "sha256:4044f94208b3b05ba0fc4a4abd0558cf4d6459bd18325eead7fd8cc66f909b41", size = 10721455, upload-time = "2026-05-14T13:44:35.697Z" }, - { url = "https://files.pythonhosted.org/packages/ab/a6/870a3e8a50590bb92be184ad928c2922f088b00d9dc5c5ec7b924ee08c22/ruff-0.15.13-py3-none-win_amd64.whl", hash = "sha256:7064884d442b7d477b4e7473d12da7f08851d2b1982763c5d3f388a19468a1a4", size = 11900409, upload-time = "2026-05-14T13:44:30.389Z" }, - { url = "https://files.pythonhosted.org/packages/9b/36/9c015cd052fca743dae8cb2aeb16b551444787467db42ceab0fc968865af/ruff-0.15.13-py3-none-win_arm64.whl", hash = "sha256:2471da9bd1068c8c064b5fd9c0c4b6dddffd6369cb1cd68b29993b1709ff1b21", size = 11179336, upload-time = "2026-05-14T13:44:33.026Z" }, +version = "0.15.15" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/84/6f/a76f7d96e5c962f5b69cee865e49c15c1116897c01990faa8a57edb62e7f/ruff-0.15.15.tar.gz", hash = "sha256:b8dff018130b46d8e5bf0f926ef6b60cf871d6d5ae45fc9334e09632daa741d6", size = 4706985, upload-time = "2026-05-28T14:16:57.784Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fa/9d/3a45c05b8ab04b4705989de70a79008e27c8003296a0feaee9edc18dd7e9/ruff-0.15.15-py3-none-linux_armv6l.whl", hash = "sha256:cf93e5388f412e1b108b1f8b34a6e036b70fe8aff89393befad96fe48670311b", size = 10710652, upload-time = "2026-05-28T14:16:06.701Z" }, + { url = "https://files.pythonhosted.org/packages/05/66/da974431624bf3b49f6ee1f9543c02d929ff1cba78b0d5a79c38cf21f744/ruff-0.15.15-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:ac5a646d1f6a7dadd5d50842dae2c1f9862ac887ef5d1b1375e02def791fde6e", size = 11096615, upload-time = "2026-05-28T14:16:23.313Z" }, + { url = "https://files.pythonhosted.org/packages/8c/09/7443452e5d290230a712103f2fdceeef7184f3ec99a2bd01c8be78aaceb5/ruff-0.15.15-py3-none-macosx_11_0_arm64.whl", hash = "sha256:77d955a431430c66f72dd94e379ad38a16daea3d25094872ac4edf9e797be530", size = 10436683, upload-time = "2026-05-28T14:16:40.974Z" }, + { url = "https://files.pythonhosted.org/packages/53/01/d330c26a57fa4f3943a14424904027428315b700fe4d14a84bb123a649e5/ruff-0.15.15-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7614ee79c69788cf6cedd568069ade9cecc22a1ad20494efe8d0c9ebb4b622d4", size = 10769064, upload-time = "2026-05-28T14:16:28.905Z" }, + { url = "https://files.pythonhosted.org/packages/1d/85/cc8770f8bdff541b1da8392d1634141fe4a0e3f4ee596605959b7906c27f/ruff-0.15.15-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3cdb1679e06a1f6b47bc384714ae96f6e2fb65ca441eb78c43d2ca554176ce1f", size = 10511987, upload-time = "2026-05-28T14:16:43.732Z" }, + { url = "https://files.pythonhosted.org/packages/7c/29/8c190c1472b63013583ba391f3342036e02010544c1270455ed8e519bdf3/ruff-0.15.15-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2728b93d7b23a603ea2c0ac6eb73d760bd38ec9de35f35fb41e18f7a3fee7622", size = 11275100, upload-time = "2026-05-28T14:16:55.244Z" }, + { url = "https://files.pythonhosted.org/packages/9f/6b/7e145ce2cc8e63d6834eca03d83a0e18d121def5c69f91b4cf4011ed4879/ruff-0.15.15-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:be582fcc0db438902c7792b08d6ddf6c9b9e21addaa10092c2c741cfb09e5a45", size = 12176903, upload-time = "2026-05-28T14:16:14.368Z" }, + { url = "https://files.pythonhosted.org/packages/80/a3/d5974637f68e451f7fadf015cf3101d1cd7d8ba5027cffe0b9e3826ebe6b/ruff-0.15.15-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7aa77465b8ecaf1a27bea098d696f7fed5e1eccbd10b321b682d6de586ae5627", size = 11404550, upload-time = "2026-05-28T14:16:20.138Z" }, + { url = "https://files.pythonhosted.org/packages/fe/1c/e6e5e568f22be4fb05d6244234aba384c06b451252453b821e1a529263cf/ruff-0.15.15-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:48decfa11d740de4889de623be1463308346312f2409a56e24aa280c86162dc4", size = 11382027, upload-time = "2026-05-28T14:16:46.615Z" }, + { url = "https://files.pythonhosted.org/packages/1d/01/170921b49fcd2e8858825593f91cf7146c3e40a5c3e6df763e4bb0484dde/ruff-0.15.15-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:a5015088452ca0081387063649ec67f06d3d1d6b8b936a1f836b5e9657ecd48c", size = 11366041, upload-time = "2026-05-28T14:16:26.247Z" }, + { url = "https://files.pythonhosted.org/packages/87/54/a7bad711d7de93254e15e06a4c375b89a03d18de45d3e5dcc86a4472fb1a/ruff-0.15.15-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:f5294aab6356c81600fcdea3a62bb1b924dfd5e91767c12318d3f68f86af57cd", size = 10741795, upload-time = "2026-05-28T14:16:17.11Z" }, + { url = "https://files.pythonhosted.org/packages/c9/31/38c075963668f8b41c6914ee0f6f318727fbe30ab9145cb29e6df464c5fa/ruff-0.15.15-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:db5bd4d802415cca656dc1616070b725952d6ae95eb5d4831e49fbd94a38f75f", size = 10511117, upload-time = "2026-05-28T14:16:31.767Z" }, + { url = "https://files.pythonhosted.org/packages/9d/96/6ff689e1f7e375d1d97075eca022f74c2bab59554a432fe4d2e6f091986a/ruff-0.15.15-py3-none-musllinux_1_2_i686.whl", hash = "sha256:587a6278ed42059191c1a466e490bd7930fb50bd2e255398bc29616c895a61cb", size = 10994867, upload-time = "2026-05-28T14:16:35.149Z" }, + { url = "https://files.pythonhosted.org/packages/c3/c2/5dce0ab9f92a8d534fa62b9bf9caca3eddb8c1a81b616f5e195ada4f0d6e/ruff-0.15.15-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:df0c1c084f5f4be9812f61518a45c440d3c30d69ce4bf6c5270e66d38338f02a", size = 11482101, upload-time = "2026-05-28T14:16:49.598Z" }, + { url = "https://files.pythonhosted.org/packages/b1/c0/1003b60edd697c649faf61f1a34094b1abb38fb3d1181e3f895781250a08/ruff-0.15.15-py3-none-win32.whl", hash = "sha256:29428ea79694afbe756d45fd59b36f22b6b020dc0443cf7de0173046236964b9", size = 10716774, upload-time = "2026-05-28T14:16:52.337Z" }, + { url = "https://files.pythonhosted.org/packages/02/a8/1269eddd6945a06c23f055ef7848886e37cf9d6a8bebb386a3115f01470c/ruff-0.15.15-py3-none-win_amd64.whl", hash = "sha256:8df0323902e15e24bc4bf246da830573d3cf3352bd0b9a164eab335d111ff4a4", size = 11868463, upload-time = "2026-05-28T14:16:11.333Z" }, + { url = "https://files.pythonhosted.org/packages/4e/b2/920464c907b191e37469d477a1aa8bc048b8f36c4c1610dfa4ab87b39e18/ruff-0.15.15-py3-none-win_arm64.whl", hash = "sha256:3c8ceca6792f38196b8f589bc92eccd03eef286602da92e5dc05cc42ef6441b7", size = 11138498, upload-time = "2026-05-28T14:16:38.425Z" }, ] [[package]]