cudf-polars-cu13 25.10.0__py3-none-any.whl

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

@@ -0,0 +1,118 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Datatype utilities."""
+
+from __future__ import annotations
+
+import pylibcudf as plc
+from pylibcudf.traits import (
+    is_floating_point,
+    is_integral_not_bool,
+    is_nested,
+    is_numeric_not_bool,
+)
+
+__all__ = [
+    "can_cast",
+    "is_order_preserving_cast",
+]
+
+
+def can_cast(from_: plc.DataType, to: plc.DataType) -> bool:
+    """
+    Determine whether a cast between two datatypes is supported by cudf-polars.
+
+    Parameters
+    ----------
+    from_ : pylibcudf.DataType
+        Source datatype
+
+    to : pylibcudf.DataType
+        Target datatype
+
+    Returns
+    -------
+    bool
+        True if the cast is supported, False otherwise.
+    """
+    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
+    if is_nested(from_) and is_nested(to):
+        return False
+    return (
+        (
+            from_ == to
+            or (
+                not has_empty
+                and (
+                    plc.traits.is_fixed_width(to)
+                    and plc.traits.is_fixed_width(from_)
+                    and plc.unary.is_supported_cast(from_, to)
+                )
+            )
+        )
+        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_)
+        )
+        or (
+            plc.traits.is_integral_not_bool(from_)
+            and from_.id() != plc.TypeId.UINT64  # not overflow safe
+            and not to_is_empty
+            and plc.traits.is_timestamp(to)
+        )
+        or (
+            plc.traits.is_integral_not_bool(to)
+            and not to_is_empty
+            and plc.traits.is_timestamp(from_)
+        )
+    )
+
+
+def is_order_preserving_cast(from_: plc.DataType, to: plc.DataType) -> bool:
+    """
+    Determine if a cast would preserve the order of the source data.
+
+    Parameters
+    ----------
+    from_
+        Source datatype
+    to
+        Target datatype
+
+    Returns
+    -------
+    True if the cast is order-preserving, False otherwise
+    """
+    if from_.id() == to.id():
+        return True
+
+    if is_integral_not_bool(from_) and is_integral_not_bool(to):
+        # True if signedness is the same and the target is larger
+        if plc.traits.is_unsigned(from_) == plc.traits.is_unsigned(to):
+            if plc.types.size_of(to) >= plc.types.size_of(from_):
+                return True
+        elif (plc.traits.is_unsigned(from_) and not plc.traits.is_unsigned(to)) and (
+            plc.types.size_of(to) > plc.types.size_of(from_)
+        ):
+            # Unsigned to signed is order preserving if target is large enough
+            # But signed to unsigned is never order preserving due to negative values
+            return True
+    elif (
+        is_floating_point(from_)
+        and is_floating_point(to)
+        and (plc.types.size_of(to) >= plc.types.size_of(from_))
+    ):
+        # True if the target is larger
+        return True
+    return (is_integral_not_bool(from_) and is_floating_point(to)) or (
+        is_floating_point(from_) and is_integral_not_bool(to)
+    )

cudf_polars/utils/sorting.py

@@ -0,0 +1,53 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Sorting utilities."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import pylibcudf as plc
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+
+def sort_order(
+    descending: Sequence[bool], *, nulls_last: Sequence[bool], num_keys: int
+) -> tuple[list[plc.types.Order], list[plc.types.NullOrder]]:
+    """
+    Produce sort order arguments.
+
+    Parameters
+    ----------
+    descending
+        List indicating order for each column
+    nulls_last
+        Should nulls sort last or first?
+    num_keys
+        Number of sort keys
+
+    Returns
+    -------
+    tuple of column_order and null_precedence
+    suitable for passing to sort routines
+    """
+    # Mimicking polars broadcast handling of descending
+    if num_keys > (n := len(descending)) and n == 1:
+        descending = [descending[0]] * num_keys
+    if num_keys > (n := len(nulls_last)) and n == 1:
+        nulls_last = [nulls_last[0]] * num_keys
+    column_order = [
+        plc.types.Order.DESCENDING if d else plc.types.Order.ASCENDING
+        for d in descending
+    ]
+    null_precedence = []
+    if len(descending) != len(nulls_last) or len(descending) != num_keys:
+        raise ValueError("Mismatching length of arguments in sort_order")
+    for asc, null_last in zip(column_order, nulls_last, strict=True):
+        if (asc == plc.types.Order.ASCENDING) ^ (not null_last):
+            null_precedence.append(plc.types.NullOrder.AFTER)
+        elif (asc == plc.types.Order.ASCENDING) ^ null_last:
+            null_precedence.append(plc.types.NullOrder.BEFORE)
+    return column_order, null_precedence

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

@@ -0,0 +1,27 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Version utilities so that cudf_polars supports a range of polars versions."""
+
+# ruff: noqa: SIM300
+from __future__ import annotations
+
+from packaging.version import parse
+
+from polars import __version__
+
+POLARS_VERSION = parse(__version__)
+POLARS_LOWER_BOUND = parse("1.28")
+POLARS_VERSION_LT_129 = POLARS_VERSION < parse("1.29")
+POLARS_VERSION_LT_130 = POLARS_VERSION < parse("1.30")
+POLARS_VERSION_LT_131 = POLARS_VERSION < parse("1.31")
+POLARS_VERSION_LT_132 = POLARS_VERSION < parse("1.32")
+POLARS_VERSION_LT_1321 = POLARS_VERSION < parse("1.32.1")
+POLARS_VERSION_LT_1323 = POLARS_VERSION < parse("1.32.3")
+
+
+def _ensure_polars_version() -> None:
+    if POLARS_VERSION < POLARS_LOWER_BOUND:
+        raise ImportError(
+            f"cudf_polars requires py-polars v{POLARS_LOWER_BOUND} or greater."
+        )  # pragma: no cover

cudf_polars_cu13-25.10.0.dist-info/METADATA

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: cudf-polars-cu13
+Version: 25.10.0
+Summary: Executor for polars using cudf
+Author: NVIDIA Corporation
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/rapidsai/cudf
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Database
+Classifier: Topic :: Scientific/Engineering
+Classifier: License :: OSI Approved :: Apache Software License
+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: nvidia-ml-py>=12
+Requires-Dist: packaging
+Requires-Dist: polars<1.33,>=1.28
+Requires-Dist: pylibcudf-cu13==25.10.*
+Requires-Dist: typing-extensions; python_version < "3.11"
+Provides-Extra: test
+Requires-Dist: dask-cuda==25.10.*; extra == "test"
+Requires-Dist: numpy<3.0a0,>=1.23; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-httpserver; extra == "test"
+Requires-Dist: pytest-xdist; extra == "test"
+Requires-Dist: rich; extra == "test"
+Provides-Extra: experimental
+Requires-Dist: nvidia-ml-py>=12; extra == "experimental"
+Requires-Dist: rapids-dask-dependency==25.10.*; extra == "experimental"
+Dynamic: license-file
+
+# <div align="left"><img src="img/rapids_logo.png" width="90px"/>&nbsp;cuDF - GPU DataFrames</div>
+
+## 📢 cuDF can now be used as a no-code-change accelerator for pandas! To learn more, see [here](https://rapids.ai/cudf-pandas/)!
+
+cuDF (pronounced "KOO-dee-eff") is a GPU DataFrame library
+for loading, joining, aggregating, filtering, and otherwise
+manipulating data. cuDF leverages
+[libcudf](https://docs.rapids.ai/api/libcudf/stable/), a
+blazing-fast C++/CUDA dataframe library and the [Apache
+Arrow](https://arrow.apache.org/) columnar format to provide a
+GPU-accelerated pandas API.
+
+You can import `cudf` directly and use it like `pandas`:
+
+```python
+import cudf
+
+tips_df = cudf.read_csv("https://github.com/plotly/datasets/raw/master/tips.csv")
+tips_df["tip_percentage"] = tips_df["tip"] / tips_df["total_bill"] * 100
+
+# display average tip by dining party size
+print(tips_df.groupby("size").tip_percentage.mean())
+```
+
+Or, you can use cuDF as a no-code-change accelerator for pandas, using
+[`cudf.pandas`](https://docs.rapids.ai/api/cudf/stable/cudf_pandas).
+`cudf.pandas` supports 100% of the pandas API, utilizing cuDF for
+supported operations and falling back to pandas when needed:
+
+```python
+%load_ext cudf.pandas  # pandas operations now use the GPU!
+
+import pandas as pd
+
+tips_df = pd.read_csv("https://github.com/plotly/datasets/raw/master/tips.csv")
+tips_df["tip_percentage"] = tips_df["tip"] / tips_df["total_bill"] * 100
+
+# display average tip by dining party size
+print(tips_df.groupby("size").tip_percentage.mean())
+```
+
+## Resources
+
+- [Try cudf.pandas now](https://nvda.ws/rapids-cudf): Explore `cudf.pandas` on a free GPU enabled instance on Google Colab!
+- [Install](https://docs.rapids.ai/install): Instructions for installing cuDF and other [RAPIDS](https://rapids.ai) libraries.
+- [cudf (Python) documentation](https://docs.rapids.ai/api/cudf/stable/)
+- [libcudf (C++/CUDA) documentation](https://docs.rapids.ai/api/libcudf/stable/)
+- [RAPIDS Community](https://rapids.ai/learn-more/#get-involved): Get help, contribute, and collaborate.
+
+See the [RAPIDS install page](https://docs.rapids.ai/install) for
+the most up-to-date information and commands for installing cuDF
+and other RAPIDS packages.
+
+## Installation
+
+### CUDA/GPU requirements
+
+* CUDA 12.0+ with a compatible NVIDIA driver
+* Volta architecture or better (Compute Capability >=7.0)
+
+### Pip
+
+cuDF can be installed via `pip` from the NVIDIA Python Package Index.
+Be sure to select the appropriate cuDF package depending
+on the major version of CUDA available in your environment:
+
+```bash
+# CUDA 13
+pip install cudf-cu13
+
+# CUDA 12
+pip install cudf-cu12
+```
+
+### Conda
+
+cuDF can be installed with conda (via [miniforge](https://github.com/conda-forge/miniforge)) from the `rapidsai` channel:
+
+```bash
+# CUDA 13
+conda install -c rapidsai -c conda-forge cudf=25.10 cuda-version=13.0
+
+# CUDA 12
+conda install -c rapidsai -c conda-forge cudf=25.10 cuda-version=12.9
+```
+
+We also provide [nightly Conda packages](https://anaconda.org/rapidsai-nightly) built from the HEAD
+of our latest development branch.
+
+Note: cuDF is supported only on Linux, and with Python versions 3.10 and later.
+
+See the [RAPIDS installation guide](https://docs.rapids.ai/install) for more OS and version info.
+
+## Build/Install from Source
+See build [instructions](CONTRIBUTING.md#setting-up-your-build-environment).
+
+## Contributing
+
+Please see our [guide for contributing to cuDF](CONTRIBUTING.md).

cudf_polars_cu13-25.10.0.dist-info/RECORD

@@ -0,0 +1,92 @@
+cudf_polars/GIT_COMMIT,sha256=dSIC7QF9D2u7uNLtZDtGWJYqrCMXIqV9uYhOHjtkmLU,41
+cudf_polars/VERSION,sha256=qFUmAhDerTzlTeG7G1N8kkXh-gyZzDU9R0ARLQtoP_Y,8
+cudf_polars/__init__.py,sha256=fSTx5nmqajdwp7qvP4PnYL6wZN9-k1fKB43NkcZlHwk,740
+cudf_polars/_version.py,sha256=kj5Ir4dxZRR-k2k8mWUDJHiGpE8_ZcTNzt_kMZxcFRA,528
+cudf_polars/callback.py,sha256=r8hf3BbpXaKtBjQkxIt_XMP9IVj6UjtdSIvJXR3r_NA,9994
+cudf_polars/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cudf_polars/containers/__init__.py,sha256=EIiTQKXBTwCmbsUNotYImSi3wq31pX55hYFwojygcyI,518
+cudf_polars/containers/column.py,sha256=jklTNU2gMazs84wybZIlojY0XXVdRZYNT4X4rPL31nM,15233
+cudf_polars/containers/dataframe.py,sha256=geASmznODV_7pFcxqcQqEzdDpN5dLDR1_vmdXHFI1og,11665
+cudf_polars/containers/datatype.py,sha256=uNsVCieVWR7fgpiSmXu25Z5mfECSIxBGrweZf9EQu7E,4680
+cudf_polars/dsl/__init__.py,sha256=bYwYnqmqINMgwnkJ22EnXMlHviLolPaMgQ8QqoZL3YE,244
+cudf_polars/dsl/expr.py,sha256=fLimKmIxdEkVwie90QR3ajjxA7le5zI-iu1VZW1ZN8c,1952
+cudf_polars/dsl/ir.py,sha256=vfPHOOPYaz7KTJfkshN-5mVMkrVqYKFGle5IfQhxFLw,93272
+cudf_polars/dsl/nodebase.py,sha256=QbZHK9aUbdiE-Mp_NkkiuNvCnD8E3xzd9-GYKR8UqcM,4777
+cudf_polars/dsl/to_ast.py,sha256=We0idh-0ckSz9nIZrGkeMg75XbnijRW2_DHVXZ9-a34,13595
+cudf_polars/dsl/tracing.py,sha256=xPTyXNQ64PSuV4_t5z6_GGJ1V_m4sFxxHiYEDp64Ofk,383
+cudf_polars/dsl/translate.py,sha256=t_bHoIS6Ny3gQcMqWAgBUT0AmWTM0LSCQnhYG36Km2s,31687
+cudf_polars/dsl/traversal.py,sha256=dzOHVaRj0wTYQd5h-JnjQrj4DffEfq1gdENYcDk5Eis,5729
+cudf_polars/dsl/expressions/__init__.py,sha256=uj1a4BzrDVAjOgP6FKKtnvR5elF4ksUj1RhkLTZoS1k,224
+cudf_polars/dsl/expressions/aggregation.py,sha256=XxC1d4cbQIvL6o6REQ2FlyxcdUbVyMl-gN4RDFHnLSQ,7950
+cudf_polars/dsl/expressions/base.py,sha256=Fq_MCz2LOMm6eekLJQ1jwEsAvYuouFXzrhIpxIRs4ak,7976
+cudf_polars/dsl/expressions/binaryop.py,sha256=7Psj8BKnotNGopQw5W9hM6cP8fbng-OllxrkgYrvLzs,5070
+cudf_polars/dsl/expressions/boolean.py,sha256=Gpx0cn2L1Wr4q5OqGT2s7lYsN_VlG_IYPtKD-BE6Cc8,12550
+cudf_polars/dsl/expressions/datetime.py,sha256=MEGtYOYl2ftbNzVd9NBv9DMJ2dUxZwGg5z69xzjZP18,10102
+cudf_polars/dsl/expressions/literal.py,sha256=CpfWj5XFqBNKqu3jaWgP13_HfSg6maXiKDjmY6pdoUE,3192
+cudf_polars/dsl/expressions/rolling.py,sha256=NiR8FfUwQMdmqFIrMM-hBcZ_JEKn9a1X9UZF4DPKM0E,23037
+cudf_polars/dsl/expressions/selection.py,sha256=RfGj0RbKairCNibfQCUtwbFiS4xv9fRoznycEKxE3ww,2520
+cudf_polars/dsl/expressions/slicing.py,sha256=xaI-XzZvPzyLDwG0yZcIPII56OMEJDxem2piV4LBGI0,1185
+cudf_polars/dsl/expressions/sorting.py,sha256=6XO0JktGGUJujADXrZoSBeJGDk80vSOCzboB7jOlL5Q,2789
+cudf_polars/dsl/expressions/string.py,sha256=LXUd0IYiblmlNHQ9zTpV5i0m770TY0k9vBcLyPI9c0k,38164
+cudf_polars/dsl/expressions/struct.py,sha256=DC426pMVQrebvAEi9NCzKhzFxPFhUglvUlvOb866TLQ,4658
+cudf_polars/dsl/expressions/ternary.py,sha256=J_85frSq5Hh2ERSXOIZlwiwFTEp9WASh2hPiCkbkbqM,1415
+cudf_polars/dsl/expressions/unary.py,sha256=sW4t9pSbRMMUlD6wJ9Vq4khi4qhBelVfqmtj_gl1Oj8,20283
+cudf_polars/dsl/utils/__init__.py,sha256=JL26nlMAbcdL8ZE4iXRrMOEVSTEZU1P5y9WvxTEDdnY,199
+cudf_polars/dsl/utils/aggregations.py,sha256=Vozij-WaR8UwOq28WSEMNmigokduydXSknL0krKj-6Y,17522
+cudf_polars/dsl/utils/groupby.py,sha256=PhkzM62N8b9qjJs8910IewnTbn_Qx2OiMPXgqMo1yDI,2621
+cudf_polars/dsl/utils/naming.py,sha256=ydp_BYYAt3mG7JHfi9Snp3dDNzdQZD6F2sAMEmT4OYA,737
+cudf_polars/dsl/utils/replace.py,sha256=8ns_TpbG1Hh8ZJejRyGA6KCu5t-TvUaM009AO8J98vc,1612
+cudf_polars/dsl/utils/reshape.py,sha256=Q13_0tIjgtMocGRFciPa1GcMxc2ClqqZf1mujl7w1kw,2397
+cudf_polars/dsl/utils/rolling.py,sha256=ioqNHIzEip9vd7XHHZvUmHL3RYPwOD6qYsPHUDmlhM8,3618
+cudf_polars/dsl/utils/windows.py,sha256=ysRZfl9wm2z-QXTRO09tT5gy1vwvoV_8_8iBsE9FZeA,5388
+cudf_polars/experimental/__init__.py,sha256=S2oI2K__woyPQAAlFMOo6RTMtdfIZxmzzAO92VtJgP4,256
+cudf_polars/experimental/base.py,sha256=9_bEWrbizmR9n4I55oqlORrGxBwc4kaGtn4EXSo_uu0,11582
+cudf_polars/experimental/dask_registers.py,sha256=bGU6nEh-rQd6lMPaEhJUdkVrkCFSjknb8IwB0EeMnrs,7780
+cudf_polars/experimental/dispatch.py,sha256=i1Q0J5M9rLMi1lp_MxjGmvAfjKEGda0B3c5kvTtz3uM,3942
+cudf_polars/experimental/distinct.py,sha256=ZyQ2SEVftdRAbtVOdJ89TvbK8uDPpam1FG6VKj86kAY,6978
+cudf_polars/experimental/explain.py,sha256=-NPFj7jplbobu7jGTOnv8e9VDOs9BHuPxjilvZ19ryI,4803
+cudf_polars/experimental/expressions.py,sha256=3NXUUepYLdqzrhaFuhu_Ya5nc89Dxhsmv0liIxAyQlQ,18412
+cudf_polars/experimental/groupby.py,sha256=uoN759pB3yrvNRFwc_jq4bNtsTmDrtPjifMABhfutwY,11222
+cudf_polars/experimental/io.py,sha256=RMH5dDrO3TsPK9QXkq5ibcHT_pRh64_m9RmIxiYtawE,31667
+cudf_polars/experimental/join.py,sha256=bfxbAl34Ql-FcMYCbn8oYAW9bROhFpf3d8yIjEVtcIY,12790
+cudf_polars/experimental/parallel.py,sha256=NsI_X-LKUNgpjoD9EFjWHXRiDvIy_onUJvzDCZAtr5U,12803
+cudf_polars/experimental/repartition.py,sha256=o1qtstaB_dBaYjkmsmfnveZ6T66A9XGwzFEBUucfyrk,2124
+cudf_polars/experimental/scheduler.py,sha256=ieL7bdxTqlmd8MO37JCaCoqhyDRZNTLnPFUme3hv6SQ,4203
+cudf_polars/experimental/select.py,sha256=5r4zAa2iupN_VJDLQ-PKWLyfzcgeJkTpVI5HXlTtULs,6106
+cudf_polars/experimental/shuffle.py,sha256=pfMxjVufnYf_1GXApBRSng-_O1Gl33NP0KQAZhKpu1E,11077
+cudf_polars/experimental/sort.py,sha256=6EGk1rAzw58Jtd5CZ9pHvesK-yA1h-SmDnE8ZFUlGcw,20830
+cudf_polars/experimental/spilling.py,sha256=OVpH9PHYNJcYL-PAB0CvoAil_nJW0VepLvcIrrAUdlc,4255
+cudf_polars/experimental/statistics.py,sha256=GMurzuADNEyWaKh43BHTzb30inTKkdALJrNx3GfMa3o,29147
+cudf_polars/experimental/utils.py,sha256=e17n8NojqVQ33UhKXkXS1MgFopyINgCFDjRSIMBV9Mw,5632
+cudf_polars/experimental/benchmarks/__init__.py,sha256=XiT8hL6V9Ns_SSXDXkzoSWlXIo6aFLDXUHLLWch23Ok,149
+cudf_polars/experimental/benchmarks/pdsds.py,sha256=e565fV2a6tzhKfQ4pCqTMoxJboDx3O8hV2_NHjkRaow,6889
+cudf_polars/experimental/benchmarks/pdsh.py,sha256=2KTQvP4ordyo0qy1WDgagpHoYYRrQz1PkDHnhNpo-_s,31151
+cudf_polars/experimental/benchmarks/utils.py,sha256=eC8mcqUEh1fu07SCIvr9ZVbiHkzt6aqBZBKWL8y7Wc4,28196
+cudf_polars/experimental/benchmarks/pdsds_queries/__init__.py,sha256=pkjkRg2qJCMbhBpD9cIxcjsgMOZXXliWJPZIgZpcUQA,151
+cudf_polars/experimental/benchmarks/pdsds_queries/q1.py,sha256=NTvgxMJUB9xH2llo6_SWO7JQNwxEoK9nQ-mnRCsYf9Y,3100
+cudf_polars/experimental/benchmarks/pdsds_queries/q10.py,sha256=SBDDIf-BfoPTqHCi4jIpgLJXkA99UcZ-NhAPhE1D2hA,7797
+cudf_polars/experimental/benchmarks/pdsds_queries/q2.py,sha256=hns2Hz1Eu8YBl4YDweINv__BME3HTt5A_TDppjXP0aw,9088
+cudf_polars/experimental/benchmarks/pdsds_queries/q3.py,sha256=GhdN9WbYVv97aIc29i3w_tl1T7rtotwY5SZBhZK6gf4,2150
+cudf_polars/experimental/benchmarks/pdsds_queries/q4.py,sha256=6E8lOk5lS_R4VeN81Dof1ijzKbMsQ3zuqinU0nQZVWg,13475
+cudf_polars/experimental/benchmarks/pdsds_queries/q5.py,sha256=neKCu04M9SRDQHa6Nc51NbJ3gFY3yJkM05qE1YHUevU,19800
+cudf_polars/experimental/benchmarks/pdsds_queries/q6.py,sha256=7zdkXHpnY3xwa8oj2c3dtPgW_pAmr4kfhATdFQiq9vk,3226
+cudf_polars/experimental/benchmarks/pdsds_queries/q7.py,sha256=gWAuGaDQbdCn6CofbqPAah3X4uVBVYdsfIIqRpZppFc,2789
+cudf_polars/experimental/benchmarks/pdsds_queries/q8.py,sha256=62qZn1RFhS3T-GL9bBY2cIR3kbVxgoYdY9n4en309EU,9546
+cudf_polars/experimental/benchmarks/pdsds_queries/q9.py,sha256=_MyLgknIVUK1U1x12bsM9Lrhs-ZMKuSOwMc9yu0ddYY,4723
+cudf_polars/testing/__init__.py,sha256=0MnlTjkTEqkSpL5GdMhQf4uXOaQwNrzgEJCZKa5FnL4,219
+cudf_polars/testing/asserts.py,sha256=he6BcpNuPyHOBVNiXAAcr-7HdjKl7n0PQfCjdyPxWoA,15250
+cudf_polars/testing/io.py,sha256=mNHsddu-c0Gs0SVVmBOYpXIDFjMiuVrmArllqIEu-2w,3832
+cudf_polars/testing/plugin.py,sha256=aAut5jHckE2JhxBfVmtEBfGsfxcNtFMBph12pYSfpw0,23343
+cudf_polars/typing/__init__.py,sha256=Q1iVabv-7etFo01UxT6cz-zgZa_9_WYA8D8QHnjZuTg,5022
+cudf_polars/utils/__init__.py,sha256=urdV5MUIneU8Dn6pt1db5GkDG0oY4NsFD0Uhl3j98l8,195
+cudf_polars/utils/config.py,sha256=LTS-gc90wWVFuDFOYqhZZ6mK68W8z6L0G4YVOZRGCIs,28814
+cudf_polars/utils/conversion.py,sha256=k_apLbSR-MiYYlQBGrzYOInuvcbfSi-il-o9nkovdXQ,1042
+cudf_polars/utils/dtypes.py,sha256=yktzqBLfbv-zve1-iS_XsGZD1R6GXgXV_grZ8m7KidM,3358
+cudf_polars/utils/sorting.py,sha256=Mqb_KLsYnKU8p1dDan2mtlIQl65RqwM78OlUi-_Jj0k,1725
+cudf_polars/utils/timer.py,sha256=KqcXqOcbovsj6KDCwaxl70baQXjuod43rABrpQkE78M,1005
+cudf_polars/utils/versions.py,sha256=UxJc6S0Sss8hIUs2ZqviKH-2FXwEBmoRKQW3BZlpydY,959
+cudf_polars_cu13-25.10.0.dist-info/licenses/LICENSE,sha256=4YCpjWCbYMkMQFW47JXsorZLOaP957HwmP6oHW2_ngM,11348
+cudf_polars_cu13-25.10.0.dist-info/METADATA,sha256=CHrSC8yWGA3bG70IlulJshqH90qpQW6-OzlRW_sH83g,4889
+cudf_polars_cu13-25.10.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cudf_polars_cu13-25.10.0.dist-info/top_level.txt,sha256=w2bOa7MpuyapYgZh480Znh4UzX7rSWlFcYR1Yo6QIPs,12
+cudf_polars_cu13-25.10.0.dist-info/RECORD,,

cudf_polars_cu13-25.10.0.dist-info/WHEEL

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