cudf-polars-cu12 25.2.2__py3-none-any.whl → 25.6.0__py3-none-any.whl

cudf_polars/utils/config.py

@@ -0,0 +1,353 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Config utilities."""
+
+from __future__ import annotations
+
+import dataclasses
+import enum
+import json
+import os
+import warnings
+from typing import TYPE_CHECKING, Literal
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+    import polars as pl
+
+
+__all__ = ["ConfigOptions"]
+
+
+# TODO: Use enum.StrEnum when we drop Python 3.10
+
+
+class StreamingFallbackMode(str, enum.Enum):
+    """
+    How the streaming executor handles operations that don't support multiple partitions.
+
+    Upon encountering an unsupported operation, the streaming executor will fall
+    back to using a single partition, which might use a large amount of memory.
+
+    * ``StreamingFallbackMode.WARN`` : Emit a warning and fall back to a single partition.
+    * ``StreamingFallbackMode.SILENT``: Silently fall back to a single partition.
+    * ``StreamingFallbackMode.RAISE`` : Raise an exception.
+    """
+
+    WARN = "warn"
+    RAISE = "raise"
+    SILENT = "silent"
+
+
+class Scheduler(str, enum.Enum):
+    """
+    The scheduler to use for the streaming executor.
+
+    * ``Scheduler.SYNCHRONOUS`` : Use the synchronous scheduler.
+    * ``Scheduler.DISTRIBUTED`` : Use the distributed scheduler.
+    """
+
+    SYNCHRONOUS = "synchronous"
+    DISTRIBUTED = "distributed"
+
+
+class ShuffleMethod(str, enum.Enum):
+    """
+    The method to use for shuffling data between workers with the streaming executor.
+
+    * ``ShuffleMethod.TASKS`` : Use the task-based shuffler.
+    * ``ShuffleMethod.RAPIDSMPF`` : Use the rapidsmpf scheduler.
+
+    In :class:`StreamingExecutor`, the default of ``None`` will attempt to use
+    ``ShuffleMethod.RAPIDSMPF``, but will fall back to ``ShuffleMethod.TASKS``
+    if rapidsmpf is not installed.
+    """
+
+    TASKS = "tasks"
+    RAPIDSMPF = "rapidsmpf"
+
+
+@dataclasses.dataclass(frozen=True)
+class ParquetOptions:
+    """
+    Configuration for the cudf-polars Parquet engine.
+
+    Parameters
+    ----------
+    chunked
+        Whether to use libcudf's ``ChunkedParquetReader`` to read the parquet
+        dataset in chunks. This is useful when reading very large parquet
+        files.
+    chunk_read_limit
+        Limit on total number of bytes to be returned per read, or 0 if
+        there is no limit.
+    pass_read_limit
+        Limit on the amount of memory used for reading and decompressing data
+        or 0 if there is no limit.
+    """
+
+    chunked: bool = True
+    chunk_read_limit: int = 0
+    pass_read_limit: int = 0
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.chunked, bool):
+            raise TypeError("chunked must be a bool")
+        if not isinstance(self.chunk_read_limit, int):
+            raise TypeError("chunk_read_limit must be an int")
+        if not isinstance(self.pass_read_limit, int):
+            raise TypeError("pass_read_limit must be an int")
+
+
+def default_blocksize(scheduler: str) -> int:
+    """Return the default blocksize."""
+    try:
+        # Use PyNVML to find the worker device size.
+        import pynvml
+
+        pynvml.nvmlInit()
+        index = os.environ.get("CUDA_VISIBLE_DEVICES", "0").split(",")[0]
+        if index and not index.isnumeric():  # pragma: no cover
+            # This means device_index is UUID.
+            # This works for both MIG and non-MIG device UUIDs.
+            handle = pynvml.nvmlDeviceGetHandleByUUID(str.encode(index))
+            if pynvml.nvmlDeviceIsMigDeviceHandle(handle):
+                # Additionally get parent device handle
+                # if the device itself is a MIG instance
+                handle = pynvml.nvmlDeviceGetDeviceHandleFromMigDeviceHandle(handle)
+        else:
+            handle = pynvml.nvmlDeviceGetHandleByIndex(int(index))
+
+        device_size = pynvml.nvmlDeviceGetMemoryInfo(handle).total
+
+    except (ImportError, ValueError, pynvml.NVMLError) as err:  # pragma: no cover
+        # Fall back to a conservative 12GiB default
+        warnings.warn(
+            "Failed to query the device size with NVML. Please "
+            "set 'target_partition_size' to a literal byte size to "
+            f"silence this warning. Original error: {err}",
+            stacklevel=1,
+        )
+        device_size = 12 * 1024**3
+
+    if scheduler == "distributed":
+        # Distributed execution requires a conservative
+        # blocksize for now.
+        blocksize = int(device_size * 0.025)
+    else:
+        # Single-GPU execution can lean on UVM to
+        # support a much larger blocksize.
+        blocksize = int(device_size * 0.0625)
+
+    return max(blocksize, 256_000_000)
+
+
+@dataclasses.dataclass(frozen=True, eq=True)
+class StreamingExecutor:
+    """
+    Configuration for the cudf-polars streaming executor.
+
+    Parameters
+    ----------
+    scheduler
+        The scheduler to use for the streaming executor. ``Scheduler.SYNCHRONOUS``
+        by default.
+
+        Note ``scheduler="distributed"`` requires a Dask cluster to be running.
+    fallback_mode
+        How to handle errors when the GPU engine fails to execute a query.
+        ``StreamingFallbackMode.WARN`` by default.
+    max_rows_per_partition
+        The maximum number of rows to process per partition. 1_000_000 by default.
+        When the number of rows exceeds this value, the query will be split into
+        multiple partitions and executed in parallel.
+    cardinality_factor
+        A dictionary mapping column names to floats between 0 and 1 (inclusive
+        on the right).
+
+        Each factor estimates the fractional number of unique values in the
+        column. By default, ``1.0`` is used for any column not included in
+        ``cardinality_factor``.
+    target_partition_size
+        Target partition size for IO tasks. This configuration currently
+        controls how large parquet files are split into multiple partitions.
+        Files larger than ``target_partition_size`` bytes are split into multiple
+        partitions.
+    groupby_n_ary
+        The factor by which the number of partitions is decreased when performing
+        a groupby on a partitioned column. For example, if a column has 64 partitions,
+        it will first be reduced to ``ceil(64 / 32) = 2`` partitions.
+
+        This is useful when the absolute number of partitions is large.
+    broadcast_join_limit
+        The maximum number of partitions to allow for the smaller table in
+        a broadcast join.
+    shuffle_method
+        The method to use for shuffling data between workers. ``None``
+        by default, which will use 'rapidsmpf' if installed and fall back to
+        'tasks' if not.
+    rapidsmpf_spill
+        Whether to wrap task arguments and output in objects that are
+        spillable by 'rapidsmpf'.
+    """
+
+    name: Literal["streaming"] = dataclasses.field(default="streaming", init=False)
+    scheduler: Scheduler = Scheduler.SYNCHRONOUS
+    fallback_mode: StreamingFallbackMode = StreamingFallbackMode.WARN
+    max_rows_per_partition: int = 1_000_000
+    cardinality_factor: dict[str, float] = dataclasses.field(default_factory=dict)
+    target_partition_size: int = 0
+    groupby_n_ary: int = 32
+    broadcast_join_limit: int = 0
+    shuffle_method: ShuffleMethod | None = None
+    rapidsmpf_spill: bool = False
+
+    def __post_init__(self) -> None:
+        if self.scheduler == "synchronous" and self.shuffle_method == "rapidsmpf":
+            raise ValueError(
+                "rapidsmpf shuffle method is not supported for synchronous scheduler"
+            )
+
+        # frozen dataclass, so use object.__setattr__
+        object.__setattr__(
+            self, "fallback_mode", StreamingFallbackMode(self.fallback_mode)
+        )
+        if self.target_partition_size == 0:
+            object.__setattr__(
+                self, "target_partition_size", default_blocksize(self.scheduler)
+            )
+        if self.broadcast_join_limit == 0:
+            object.__setattr__(
+                self,
+                "broadcast_join_limit",
+                # Usually better to avoid shuffling for single gpu
+                2 if self.scheduler == "distributed" else 32,
+            )
+        object.__setattr__(self, "scheduler", Scheduler(self.scheduler))
+        if self.shuffle_method is not None:
+            object.__setattr__(
+                self, "shuffle_method", ShuffleMethod(self.shuffle_method)
+            )
+
+        # Type / value check everything else
+        if not isinstance(self.max_rows_per_partition, int):
+            raise TypeError("max_rows_per_partition must be an int")
+        if not isinstance(self.cardinality_factor, dict):
+            raise TypeError("cardinality_factor must be a dict of column name to float")
+        if not isinstance(self.target_partition_size, int):
+            raise TypeError("target_partition_size must be an int")
+        if not isinstance(self.groupby_n_ary, int):
+            raise TypeError("groupby_n_ary must be an int")
+        if not isinstance(self.broadcast_join_limit, int):
+            raise TypeError("broadcast_join_limit must be an int")
+        if not isinstance(self.rapidsmpf_spill, bool):
+            raise TypeError("rapidsmpf_spill must be bool")
+
+    def __hash__(self) -> int:
+        # cardinality factory, a dict, isn't natively hashable. We'll dump it
+        # to json and hash that.
+        d = dataclasses.asdict(self)
+        d["cardinality_factor"] = json.dumps(d["cardinality_factor"])
+        return hash(tuple(sorted(d.items())))
+
+
+@dataclasses.dataclass(frozen=True, eq=True)
+class InMemoryExecutor:
+    """
+    Configuration for the cudf-polars in-memory executor.
+
+    Parameters
+    ----------
+    scheduler:
+        The scheduler to use for the in-memory executor. Currently
+        only ``Scheduler.SYNCHRONOUS`` is supported for the in-memory executor.
+    """
+
+    name: Literal["in-memory"] = dataclasses.field(default="in-memory", init=False)
+
+
+@dataclasses.dataclass(frozen=True, eq=True)
+class ConfigOptions:
+    """
+    Configuration for the polars GPUEngine.
+
+    Parameters
+    ----------
+    raise_on_fail
+        Whether to raise an exception when the GPU engine cannot execute a
+        query. ``False`` by default.
+    parquet_options
+        Options controlling parquet file reading and writing. See
+        :class:`ParquetOptions` for more.
+    executor
+        The executor to use for the GPU engine. See :class:`StreamingExecutor`
+        and :class:`InMemoryExecutor` for more.
+    device
+        The GPU used to run the query. If not provided, the
+        query uses the current CUDA device.
+    """
+
+    raise_on_fail: bool = False
+    parquet_options: ParquetOptions = dataclasses.field(default_factory=ParquetOptions)
+    executor: StreamingExecutor | InMemoryExecutor = dataclasses.field(
+        default_factory=InMemoryExecutor
+    )
+    device: int | None = None
+
+    @classmethod
+    def from_polars_engine(cls, engine: pl.GPUEngine) -> Self:
+        """
+        Create a `ConfigOptions` object from a `pl.GPUEngine` object.
+
+        This creates our internal, typed, configuration object from the
+        user-provided `polars.GPUEngine` object.
+        """
+        # these are the valid top-level keys in the engine.config that
+        # the user passes as **kwargs to GPUEngine.
+        valid_options = {
+            "executor",
+            "executor_options",
+            "parquet_options",
+            "raise_on_fail",
+        }
+
+        extra_options = set(engine.config.keys()) - valid_options
+        if extra_options:
+            raise TypeError(f"Unsupported executor_options: {extra_options}")
+
+        user_executor = engine.config.get("executor", "in-memory")
+        if user_executor is None:
+            user_executor = "in-memory"
+        user_executor_options = engine.config.get("executor_options", {})
+        user_parquet_options = engine.config.get("parquet_options", {})
+        user_raise_on_fail = engine.config.get("raise_on_fail", False)
+
+        # These are user-provided options, so we need to actually validate
+        # them.
+
+        if user_executor not in {"in-memory", "streaming"}:
+            raise ValueError(f"Unknown executor '{user_executor}'")
+
+        if not isinstance(user_raise_on_fail, bool):
+            raise TypeError("GPUEngine option 'raise_on_fail' must be a boolean.")
+
+        executor: InMemoryExecutor | StreamingExecutor
+
+        match user_executor:
+            case "in-memory":
+                executor = InMemoryExecutor(**user_executor_options)
+            case "streaming":
+                executor = StreamingExecutor(**user_executor_options)
+                # Update with the streaming defaults, but user options take precedence.
+
+            case _:  # pragma: no cover; Unreachable
+                raise ValueError(f"Unsupported executor: {user_executor}")
+
+        return cls(
+            raise_on_fail=user_raise_on_fail,
+            parquet_options=ParquetOptions(**user_parquet_options),
+            executor=executor,
+            device=engine.device,
+        )

cudf_polars/utils/conversion.py

@@ -0,0 +1,40 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Miscellaneous conversion functions."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from cudf_polars.typing import Slice
+
+
+def from_polars_slice(zlice: Slice, *, num_rows: int) -> list[int]:
+    """
+    Convert a Polar slice into something pylibcudf handles.
+
+    Parameters
+    ----------
+    zlice
+         The slice to convert
+    num_rows
+         The number of rows in the object being sliced.
+
+    Returns
+    -------
+    List of start and end slice bounds.
+    """
+    start, length = zlice
+    if length is None:
+        length = num_rows
+    if start < 0:
+        start += num_rows
+    # Polars implementation wraps negative start by num_rows, then
+    # adds length to start to get the end, then clamps both to
+    # [0, num_rows)
+    end = start + length
+    start = max(min(start, num_rows), 0)
+    end = max(min(end, num_rows), 0)
+    return [start, end]

cudf_polars/utils/dtypes.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES.
 # SPDX-License-Identifier: Apache-2.0
 
 """Datatype utilities."""
@@ -12,6 +12,7 @@ from typing_extensions import assert_never
 
 import polars as pl
 
+import pylibcudf as plc
 from pylibcudf.traits import (
     is_floating_point,
     is_integral_not_bool,
@@ -19,12 +20,18 @@ from pylibcudf.traits import (
 )
 
 __all__ = [
+    "TO_ARROW_COMPAT_LEVEL",
     "can_cast",
     "downcast_arrow_lists",
     "from_polars",
     "is_order_preserving_cast",
 ]
-import pylibcudf as plc
+
+TO_ARROW_COMPAT_LEVEL = (
+    pl.CompatLevel.newest()
+    if hasattr(pa.lib, "Type_STRING_VIEW")
+    else pl.CompatLevel.oldest()
+)
 
 
 def downcast_arrow_lists(typ: pa.DataType) -> pa.DataType:
@@ -71,7 +78,9 @@ def can_cast(from_: plc.DataType, to: plc.DataType) -> bool:
     -------
     True if casting is supported, False otherwise
     """
-    has_empty = from_.id() == plc.TypeId.EMPTY or to.id() == plc.TypeId.EMPTY
+    to_is_empty = to.id() == plc.TypeId.EMPTY
+    from_is_empty = from_.id() == plc.TypeId.EMPTY
+    has_empty = to_is_empty or from_is_empty
     return (
         (
             from_ == to
@@ -84,8 +93,16 @@ def can_cast(from_: plc.DataType, to: plc.DataType) -> bool:
                 )
             )
         )
-        or (from_.id() == plc.TypeId.STRING and is_numeric_not_bool(to))
-        or (to.id() == plc.TypeId.STRING and is_numeric_not_bool(from_))
+        or (
+            from_.id() == plc.TypeId.STRING
+            and not to_is_empty
+            and is_numeric_not_bool(to)
+        )
+        or (
+            to.id() == plc.TypeId.STRING
+            and not from_is_empty
+            and is_numeric_not_bool(from_)
+        )
     )
 
 

cudf_polars/utils/timer.py

@@ -0,0 +1,39 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Timing utilities."""
+
+from __future__ import annotations
+
+__all__: list[str] = ["Timer"]
+
+
+class Timer:
+    """
+    A timer for recording execution times of nodes.
+
+    Parameters
+    ----------
+    query_start
+        Duration in nanoseconds since the query was started on the
+        Polars side
+    """
+
+    def __init__(self, query_start: int):
+        self.query_start = query_start
+        self.timings: list[tuple[int, int, str]] = []
+
+    def store(self, start: int, end: int, name: str) -> None:
+        """
+        Store timing for a node.
+
+        Parameters
+        ----------
+        start
+            Start of the execution for this node (use time.monotonic_ns).
+        end
+            End of the execution for this node.
+        name
+            The name for this node.
+        """
+        self.timings.append((start - self.query_start, end - self.query_start, name))

cudf_polars/utils/versions.py

@@ -12,11 +12,12 @@ from polars import __version__
 
 POLARS_VERSION = parse(__version__)
 
-POLARS_VERSION_LT_120 = POLARS_VERSION < parse("1.20")
+POLARS_VERSION_LT_125 = POLARS_VERSION < parse("1.25")
+POLARS_VERSION_LT_128 = POLARS_VERSION < parse("1.28")
 
 
-def _ensure_polars_version():
-    if POLARS_VERSION_LT_120:
+def _ensure_polars_version() -> None:
+    if POLARS_VERSION_LT_125:
         raise ImportError(
-            "cudf_polars requires py-polars v1.20 or greater."
+            "cudf_polars requires py-polars v1.25 or greater."
         )  # pragma: no cover

{cudf_polars_cu12-25.2.2.dist-info → cudf_polars_cu12-25.6.0.dist-info}/METADATA

@@ -1,9 +1,9 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: cudf-polars-cu12
-Version: 25.2.2
+Version: 25.6.0
 Summary: Executor for polars using cudf
 Author: NVIDIA Corporation
-License: Apache 2.0
+License: Apache-2.0
 Project-URL: Homepage, https://github.com/rapidsai/cudf
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Database
@@ -13,18 +13,21 @@ Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: polars<1.22,>=1.20
-Requires-Dist: pylibcudf-cu12==25.2.*
+Requires-Dist: polars<1.29,>=1.25
+Requires-Dist: pylibcudf-cu12==25.6.*
 Provides-Extra: test
+Requires-Dist: dask-cuda==25.6.*; extra == "test"
 Requires-Dist: numpy<3.0a0,>=1.23; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
 Requires-Dist: pytest-xdist; extra == "test"
 Requires-Dist: pytest<8; extra == "test"
 Provides-Extra: experimental
-Requires-Dist: rapids-dask-dependency==25.2.*; extra == "experimental"
+Requires-Dist: rapids-dask-dependency==25.6.*; extra == "experimental"
+Dynamic: license-file
 
 # <div align="left"><img src="img/rapids_logo.png" width="90px"/>&nbsp;cuDF - GPU DataFrames</div>
 
@@ -111,7 +114,7 @@ cuDF can be installed with conda (via [miniforge](https://github.com/conda-forge
 
 ```bash
 conda install -c rapidsai -c conda-forge -c nvidia \
-    cudf=25.02 python=3.12 cuda-version=12.8
+    cudf=25.06 python=3.13 cuda-version=12.8
 ```
 
 We also provide [nightly Conda packages](https://anaconda.org/rapidsai-nightly) built from the HEAD

cudf_polars_cu12-25.6.0.dist-info/RECORD

@@ -0,0 +1,73 @@
+cudf_polars/VERSION,sha256=mkkPLCPxib-wy79AMMpM4Bq103DbRbHiXhZFFnGa_sk,8
+cudf_polars/__init__.py,sha256=fSTx5nmqajdwp7qvP4PnYL6wZN9-k1fKB43NkcZlHwk,740
+cudf_polars/_version.py,sha256=kj5Ir4dxZRR-k2k8mWUDJHiGpE8_ZcTNzt_kMZxcFRA,528
+cudf_polars/callback.py,sha256=Pq8_oG_C1QCxaoTyqYZEmQnXXkF8RnkdOT4S1sv9wIQ,9702
+cudf_polars/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cudf_polars/containers/__init__.py,sha256=He8qCk9m37k7KOWC6s4QuL8LYF11KhP2vluH9s8EeYI,339
+cudf_polars/containers/column.py,sha256=a-gK48MPqz92b1gkG6EqrSxr3_vK2I3efqaQsbp9FLs,12464
+cudf_polars/containers/dataframe.py,sha256=6f-fVJ3KZT9VWaqd0DH9nO0tZGaT30B0mketsz9iW18,10093
+cudf_polars/dsl/__init__.py,sha256=bYwYnqmqINMgwnkJ22EnXMlHviLolPaMgQ8QqoZL3YE,244
+cudf_polars/dsl/expr.py,sha256=PgzO75CP-n5ZggpT-XqpUdjAwEpGP04G5N_aiX3VEqU,1868
+cudf_polars/dsl/ir.py,sha256=W_qD6K8UMrByU-kTD-3EjEfaELmjB-XNV4RLHpg2Z8w,83936
+cudf_polars/dsl/nodebase.py,sha256=4lE2WAekzCG_ut0lYor8iPI_7hJZsy_lLTEh-54nbUk,4540
+cudf_polars/dsl/to_ast.py,sha256=MUwFANApCSDgayK6hwlIcro2sMpE-nanqGqUsbR9sLk,12426
+cudf_polars/dsl/translate.py,sha256=Ghr3i0f6X2TlMVqc-qZkf4jvfkZ_sF7tSGPhrjhXrFw,29847
+cudf_polars/dsl/traversal.py,sha256=dVH37YoLx-wo61lUofaOM77eji99yIaC62PSb3QYKHM,4610
+cudf_polars/dsl/expressions/__init__.py,sha256=uj1a4BzrDVAjOgP6FKKtnvR5elF4ksUj1RhkLTZoS1k,224
+cudf_polars/dsl/expressions/aggregation.py,sha256=5EmwA_sXAZj4sRnM_YjGuOkxKVNHigzxNTDolVpttqw,7450
+cudf_polars/dsl/expressions/base.py,sha256=Of-J3BgtRUaUAeNUiw0MzZq4jHlCJtfZ6opt8HZkqrQ,7822
+cudf_polars/dsl/expressions/binaryop.py,sha256=sRYXXgIwX9Cn8uJFJuLCWQgKgG2nuMiv9W8JREr3xx0,4170
+cudf_polars/dsl/expressions/boolean.py,sha256=pBEWN8DOSG9V3RISQZTsztnNuNbuW9vKfka0Fj7Szfs,10920
+cudf_polars/dsl/expressions/datetime.py,sha256=bkJ5qAcy43E49Ye6Nrw83YKScdbgvz6HBqQ49QjASDU,10366
+cudf_polars/dsl/expressions/literal.py,sha256=2fiTu0NikVyLRQei2tN3wcgZFD2OweevdN_8_ASJXQY,2755
+cudf_polars/dsl/expressions/rolling.py,sha256=veHY728JI7Qy9UyuUDMsqVw69udQDz0dXHrr_LFGIvA,5106
+cudf_polars/dsl/expressions/selection.py,sha256=QfkV7hRpJWv9GfX45WSyCHct--1EMWRC05aTBsbhvyA,2526
+cudf_polars/dsl/expressions/slicing.py,sha256=I7KcvMOwSDd740wrMUW_gX8Jny5hQVDP8mdfy_dJwDA,1167
+cudf_polars/dsl/expressions/sorting.py,sha256=nnuBBWofgSHjGQY9QONDn_w4eMPMU2fGu9d445zfGmc,2739
+cudf_polars/dsl/expressions/string.py,sha256=oheWLRvd0sOyNF_yr7nKg0v7NVkEy8Z05Ku5xG-dukY,14396
+cudf_polars/dsl/expressions/ternary.py,sha256=PQ4nKRqG7dZggZ9dxGJJRCIAsrSBqS0RzAS61WiVSYw,1356
+cudf_polars/dsl/expressions/unary.py,sha256=cL1y4IjzhW6RLsGlof6bEXGHklFgGjsiISy8Y36DXuo,11542
+cudf_polars/dsl/utils/__init__.py,sha256=JL26nlMAbcdL8ZE4iXRrMOEVSTEZU1P5y9WvxTEDdnY,199
+cudf_polars/dsl/utils/aggregations.py,sha256=pv007Uu9h--Hj2pvU6l5_IpPZmShLpYgibbloXadWOY,10067
+cudf_polars/dsl/utils/groupby.py,sha256=aEnJOpEBw6sus6PXM1qeOzOO2kVYIFmmc21xCS2b7CY,2632
+cudf_polars/dsl/utils/naming.py,sha256=ydp_BYYAt3mG7JHfi9Snp3dDNzdQZD6F2sAMEmT4OYA,737
+cudf_polars/dsl/utils/replace.py,sha256=ZAz6htTBSPkkrnv6faRh9_xPnnzin9kuI9PcrGtaX0Q,1224
+cudf_polars/dsl/utils/rolling.py,sha256=S6Lzs7rpBxFP8exHSrEHDr6tWHdwW3V42jp40ZNauKk,3405
+cudf_polars/dsl/utils/windows.py,sha256=vPEzlwYs1ogri7ly3gQPrLPFsfWhLBygsnIROqgwgAk,5155
+cudf_polars/experimental/__init__.py,sha256=S2oI2K__woyPQAAlFMOo6RTMtdfIZxmzzAO92VtJgP4,256
+cudf_polars/experimental/base.py,sha256=neb7H4uqn5Yt3lL6ZTpFsRB7xQc0-muOE3meq8DLMuE,1158
+cudf_polars/experimental/dask_registers.py,sha256=xJh6wW7rq78fd17gLsOCmQ0cZQVx2yXRnH7z8a54Kvw,7507
+cudf_polars/experimental/dispatch.py,sha256=pw6KyC_irRcQgKb8S0o1KKvRHQPFOikyv8kfMQtgxjc,2094
+cudf_polars/experimental/distinct.py,sha256=6-EkCtgA7Qukjb3f7ERWPs6y9fd0xggbSOK9ZjJOaSY,6351
+cudf_polars/experimental/explain.py,sha256=o2HNzZr1X0P-Q68B7iPgE52WMf_G1XfiZX9xQ1aFeUM,3646
+cudf_polars/experimental/expressions.py,sha256=8ug6lnGj1rz6bkXi3Y9UIdZmXczlRQiErsj1aBqWBhQ,16227
+cudf_polars/experimental/groupby.py,sha256=HHB38kUW4u_QlkIyRqtdPxlvBtryOB_Oi9hlRDYEuas,9811
+cudf_polars/experimental/io.py,sha256=kfNz1kjcskP5ubH-T-adWzizLntGXd10HgtPeRFQvCw,12475
+cudf_polars/experimental/join.py,sha256=HZ-dIzHhvuisBb-zw9BV-dxSPsU-FGKUBOxBY43Vu3E,11644
+cudf_polars/experimental/parallel.py,sha256=6ckDfuw3MSWnTRr7WgqpHEIoUw3RD9QdOlrIX7bXR78,9636
+cudf_polars/experimental/repartition.py,sha256=o1qtstaB_dBaYjkmsmfnveZ6T66A9XGwzFEBUucfyrk,2124
+cudf_polars/experimental/scheduler.py,sha256=ieL7bdxTqlmd8MO37JCaCoqhyDRZNTLnPFUme3hv6SQ,4203
+cudf_polars/experimental/select.py,sha256=Zrdlnw426Ul8DE8WzST7ggLW74yTMXHp-enMTog9tp8,3829
+cudf_polars/experimental/shuffle.py,sha256=lv33GaR0w5h8p7z9NfwNgXw5DazjCohsy_B7ZUEUQIo,8975
+cudf_polars/experimental/sort.py,sha256=OAY_Us0IXfYPy6NRwqH3JsSE00lg63o83uuve6KLFiY,1633
+cudf_polars/experimental/spilling.py,sha256=OVpH9PHYNJcYL-PAB0CvoAil_nJW0VepLvcIrrAUdlc,4255
+cudf_polars/experimental/utils.py,sha256=l6OWbWsdn8AfFiNSXZwvL9Gm9HP_P9cVXLXfIqizinY,3303
+cudf_polars/experimental/benchmarks/__init__.py,sha256=XiT8hL6V9Ns_SSXDXkzoSWlXIo6aFLDXUHLLWch23Ok,149
+cudf_polars/experimental/benchmarks/pdsh.py,sha256=OCQJeek-hz2nsctHO93oDr9BgQc97mdCCtcpAVodomo,45230
+cudf_polars/testing/__init__.py,sha256=0MnlTjkTEqkSpL5GdMhQf4uXOaQwNrzgEJCZKa5FnL4,219
+cudf_polars/testing/asserts.py,sha256=bzzS5ZalRAxDMvGncHvem7xuzljPJxeRFMT5KLCye7Q,11926
+cudf_polars/testing/io.py,sha256=sw9aT4wXLRMKxuH2rCwy7wV3c8pqEdqZdXn2jQSb-jM,2221
+cudf_polars/testing/plugin.py,sha256=AkJRQZhhCSk-vLJr2WAOIZCvR-iQ24ZZQ61IHZuPPY8,25913
+cudf_polars/typing/__init__.py,sha256=cEMEtn5bJTS0mY9U2E7fO15ya8CsOVUE442bqVubWzI,4568
+cudf_polars/utils/__init__.py,sha256=urdV5MUIneU8Dn6pt1db5GkDG0oY4NsFD0Uhl3j98l8,195
+cudf_polars/utils/config.py,sha256=X8yOjJW2lab-FFPma_IEbSKghUiKE_57BTrY3ixj3Do,13017
+cudf_polars/utils/conversion.py,sha256=k_apLbSR-MiYYlQBGrzYOInuvcbfSi-il-o9nkovdXQ,1042
+cudf_polars/utils/dtypes.py,sha256=t5pslaZo320URlKramQDLrTbAbS21RUHvVzuLe1PIhA,6936
+cudf_polars/utils/sorting.py,sha256=Mqb_KLsYnKU8p1dDan2mtlIQl65RqwM78OlUi-_Jj0k,1725
+cudf_polars/utils/timer.py,sha256=KqcXqOcbovsj6KDCwaxl70baQXjuod43rABrpQkE78M,1005
+cudf_polars/utils/versions.py,sha256=wOXN56WwDFeQvzX1-8EXYiGNxq1pYtKPHxGQ1bttZLo,668
+cudf_polars_cu12-25.6.0.dist-info/licenses/LICENSE,sha256=4YCpjWCbYMkMQFW47JXsorZLOaP957HwmP6oHW2_ngM,11348
+cudf_polars_cu12-25.6.0.dist-info/METADATA,sha256=RBlwRQKUIYjoAE7LWZuwtApcvyyxy3ImlXLF_1HqWA8,4668
+cudf_polars_cu12-25.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cudf_polars_cu12-25.6.0.dist-info/top_level.txt,sha256=w2bOa7MpuyapYgZh480Znh4UzX7rSWlFcYR1Yo6QIPs,12
+cudf_polars_cu12-25.6.0.dist-info/RECORD,,

{cudf_polars_cu12-25.2.2.dist-info → cudf_polars_cu12-25.6.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.2)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any