polars-runtime-compat 1.34.0b3__cp39-abi3-win_amd64.whl → 1.34.0b5__cp39-abi3-win_amd64.whl

polars/interchange/buffer.py

@@ -1,77 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from polars.interchange.protocol import (
-    Buffer,
-    CopyNotAllowedError,
-    DlpackDeviceType,
-    DtypeKind,
-)
-from polars.interchange.utils import polars_dtype_to_dtype
-
-if TYPE_CHECKING:
-    from typing import NoReturn
-
-    from polars import Series
-
-
-class PolarsBuffer(Buffer):
-    """
-    A buffer object backed by a Polars Series consisting of a single chunk.
-
-    Parameters
-    ----------
-    data
-        The Polars Series backing the buffer object.
-    allow_copy
-        Allow data to be copied during operations on this column. If set to `False`,
-        a RuntimeError will be raised if data would be copied.
-    """
-
-    def __init__(self, data: Series, *, allow_copy: bool = True) -> None:
-        if data.n_chunks() > 1:
-            if not allow_copy:
-                msg = "non-contiguous buffer must be made contiguous"
-                raise CopyNotAllowedError(msg)
-            data = data.rechunk()
-
-        self._data = data
-
-    @property
-    def bufsize(self) -> int:
-        """Buffer size in bytes."""
-        dtype = polars_dtype_to_dtype(self._data.dtype)
-
-        if dtype[0] == DtypeKind.BOOL:
-            _, offset, length = self._data._get_buffer_info()
-            n_bits = offset + length
-            n_bytes, rest = divmod(n_bits, 8)
-            # Round up to the nearest byte
-            if rest == 0:
-                return n_bytes
-            else:
-                return n_bytes + 1
-
-        return self._data.len() * (dtype[1] // 8)
-
-    @property
-    def ptr(self) -> int:
-        """Pointer to start of the buffer as an integer."""
-        pointer, _, _ = self._data._get_buffer_info()
-        return pointer
-
-    def __dlpack__(self) -> NoReturn:
-        """Represent this structure as DLPack interface."""
-        msg = "__dlpack__"
-        raise NotImplementedError(msg)
-
-    def __dlpack_device__(self) -> tuple[DlpackDeviceType, None]:
-        """Device type and device ID for where the data in the buffer resides."""
-        return (DlpackDeviceType.CPU, None)
-
-    def __repr__(self) -> str:
-        bufsize = self.bufsize
-        ptr = self.ptr
-        device = self.__dlpack_device__()[0].name
-        return f"PolarsBuffer(bufsize={bufsize}, ptr={ptr}, device={device!r})"

polars/interchange/column.py

@@ -1,190 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from polars.datatypes import Boolean, Categorical, Enum, String
-from polars.interchange.buffer import PolarsBuffer
-from polars.interchange.protocol import (
-    Column,
-    ColumnNullType,
-    CopyNotAllowedError,
-    DtypeKind,
-    Endianness,
-)
-from polars.interchange.utils import polars_dtype_to_dtype
-
-if TYPE_CHECKING:
-    from collections.abc import Iterator
-    from typing import Any
-
-    from polars import Series
-    from polars.interchange.protocol import CategoricalDescription, ColumnBuffers, Dtype
-
-
-class PolarsColumn(Column):
-    """
-    A column object backed by a Polars Series.
-
-    Parameters
-    ----------
-    column
-        The Polars Series backing the column object.
-    allow_copy
-        Allow data to be copied during operations on this column. If set to `False`,
-        a RuntimeError will be raised if data would be copied.
-    """
-
-    def __init__(self, column: Series, *, allow_copy: bool = True) -> None:
-        self._col = column
-        self._allow_copy = allow_copy
-
-    def size(self) -> int:
-        """Size of the column in elements."""
-        return self._col.len()
-
-    @property
-    def offset(self) -> int:
-        """Offset of the first element with respect to the start of the underlying buffer."""  # noqa: W505
-        if self._col.dtype == Boolean:
-            return self._col._get_buffer_info()[1]
-        else:
-            return 0
-
-    @property
-    def dtype(self) -> Dtype:
-        """Data type of the column."""
-        pl_dtype = self._col.dtype
-        return polars_dtype_to_dtype(pl_dtype)
-
-    @property
-    def describe_categorical(self) -> CategoricalDescription:
-        """
-        Description of the categorical data type of the column.
-
-        Raises
-        ------
-        TypeError
-            If the data type of the column is not categorical.
-        """
-        dtype = self._col.dtype
-        if dtype == Categorical:
-            categories = self._col.cat.get_categories()
-            is_ordered = False
-        elif dtype == Enum:
-            categories = dtype.categories  # type: ignore[attr-defined]
-            is_ordered = True
-        else:
-            msg = "`describe_categorical` only works on categorical columns"
-            raise TypeError(msg)
-
-        return {
-            "is_ordered": is_ordered,
-            "is_dictionary": True,
-            "categories": PolarsColumn(categories, allow_copy=self._allow_copy),
-        }
-
-    @property
-    def describe_null(self) -> tuple[ColumnNullType, int | None]:
-        """Description of the null representation the column uses."""
-        if self.null_count == 0:
-            return ColumnNullType.NON_NULLABLE, None
-        else:
-            return ColumnNullType.USE_BITMASK, 0
-
-    @property
-    def null_count(self) -> int:
-        """The number of null elements."""
-        return self._col.null_count()
-
-    @property
-    def metadata(self) -> dict[str, Any]:
-        """The metadata for the column."""
-        return {}
-
-    def num_chunks(self) -> int:
-        """Return the number of chunks the column consists of."""
-        return self._col.n_chunks()
-
-    def get_chunks(self, n_chunks: int | None = None) -> Iterator[PolarsColumn]:
-        """
-        Return an iterator yielding the column chunks.
-
-        Parameters
-        ----------
-        n_chunks
-            The number of chunks to return. Must be a multiple of the number of chunks
-            in the column.
-
-        Notes
-        -----
-        When `n_chunks` is higher than the number of chunks in the column, a slice
-        must be performed that is not on the chunk boundary. This will trigger some
-        compute if the column contains null values or if the column is of data type
-        boolean.
-        """
-        total_n_chunks = self.num_chunks()
-        chunks = self._col.get_chunks()
-
-        if (n_chunks is None) or (n_chunks == total_n_chunks):
-            for chunk in chunks:
-                yield PolarsColumn(chunk, allow_copy=self._allow_copy)
-
-        elif (n_chunks <= 0) or (n_chunks % total_n_chunks != 0):
-            msg = (
-                "`n_chunks` must be a multiple of the number of chunks of this column"
-                f" ({total_n_chunks})"
-            )
-            raise ValueError(msg)
-
-        else:
-            subchunks_per_chunk = n_chunks // total_n_chunks
-            for chunk in chunks:
-                size = len(chunk)
-                step = size // subchunks_per_chunk
-                if size % subchunks_per_chunk != 0:
-                    step += 1
-                for start in range(0, step * subchunks_per_chunk, step):
-                    yield PolarsColumn(
-                        chunk[start : start + step], allow_copy=self._allow_copy
-                    )
-
-    def get_buffers(self) -> ColumnBuffers:
-        """Return a dictionary containing the underlying buffers."""
-        dtype = self._col.dtype
-
-        if dtype == String and not self._allow_copy:
-            msg = "string buffers must be converted"
-            raise CopyNotAllowedError(msg)
-
-        buffers = self._col._get_buffers()
-
-        return {
-            "data": self._wrap_data_buffer(buffers["values"]),
-            "validity": self._wrap_validity_buffer(buffers["validity"]),
-            "offsets": self._wrap_offsets_buffer(buffers["offsets"]),
-        }
-
-    def _wrap_data_buffer(self, buffer: Series) -> tuple[PolarsBuffer, Dtype]:
-        interchange_buffer = PolarsBuffer(buffer, allow_copy=self._allow_copy)
-        dtype = polars_dtype_to_dtype(buffer.dtype)
-        return interchange_buffer, dtype
-
-    def _wrap_validity_buffer(
-        self, buffer: Series | None
-    ) -> tuple[PolarsBuffer, Dtype] | None:
-        if buffer is None:
-            return None
-
-        interchange_buffer = PolarsBuffer(buffer, allow_copy=self._allow_copy)
-        dtype = (DtypeKind.BOOL, 1, "b", Endianness.NATIVE)
-        return interchange_buffer, dtype
-
-    def _wrap_offsets_buffer(
-        self, buffer: Series | None
-    ) -> tuple[PolarsBuffer, Dtype] | None:
-        if buffer is None:
-            return None
-
-        interchange_buffer = PolarsBuffer(buffer, allow_copy=self._allow_copy)
-        dtype = (DtypeKind.INT, 64, "l", Endianness.NATIVE)
-        return interchange_buffer, dtype

polars/interchange/dataframe.py

@@ -1,230 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Sequence
-from itertools import accumulate
-from typing import TYPE_CHECKING
-
-from polars.interchange.column import PolarsColumn
-from polars.interchange.protocol import CopyNotAllowedError
-from polars.interchange.protocol import DataFrame as InterchangeDataFrame
-
-if TYPE_CHECKING:
-    from collections.abc import Iterator
-    from typing import Any
-
-    from polars import DataFrame
-
-
-class PolarsDataFrame(InterchangeDataFrame):
-    """
-    A dataframe object backed by a Polars DataFrame.
-
-    Parameters
-    ----------
-    df
-        The Polars DataFrame backing the dataframe object.
-    allow_copy
-        Allow data to be copied during operations on this column. If set to `False`,
-        a RuntimeError is raised if data would be copied.
-    """
-
-    version = 0
-
-    def __init__(self, df: DataFrame, *, allow_copy: bool = True) -> None:
-        self._df = df
-        self._allow_copy = allow_copy
-
-    def __dataframe__(
-        self,
-        nan_as_null: bool = False,  # noqa: FBT001
-        allow_copy: bool = True,  # noqa: FBT001
-    ) -> PolarsDataFrame:
-        """
-        Construct a new dataframe object, potentially changing the parameters.
-
-        Parameters
-        ----------
-        nan_as_null
-            Overwrite null values in the data with `NaN`.
-
-            .. warning::
-                This functionality has not been implemented and the parameter will be
-                removed in a future version.
-                Setting this to `True` will raise a `NotImplementedError`.
-        allow_copy
-            Allow memory to be copied to perform the conversion. If set to `False`,
-            causes conversions that are not zero-copy to fail.
-        """
-        if nan_as_null:
-            msg = (
-                "functionality for `nan_as_null` has not been implemented and the"
-                " parameter will be removed in a future version"
-                "\n\nUse the default `nan_as_null=False`."
-            )
-            raise NotImplementedError(msg)
-        return PolarsDataFrame(self._df, allow_copy=allow_copy)
-
-    @property
-    def metadata(self) -> dict[str, Any]:
-        """The metadata for the dataframe."""
-        return {}
-
-    def num_columns(self) -> int:
-        """Return the number of columns in the dataframe."""
-        return self._df.width
-
-    def num_rows(self) -> int:
-        """Return the number of rows in the dataframe."""
-        return self._df.height
-
-    def num_chunks(self) -> int:
-        """
-        Return the number of chunks the dataframe consists of.
-
-        It is possible for a Polars DataFrame to consist of columns with a varying
-        number of chunks. This method returns the number of chunks of the first
-        column.
-
-        See Also
-        --------
-        polars.dataframe.frame.DataFrame.n_chunks
-        """
-        return self._df.n_chunks("first")
-
-    def column_names(self) -> list[str]:
-        """Return the column names."""
-        return self._df.columns
-
-    def get_column(self, i: int) -> PolarsColumn:
-        """
-        Return the column at the indicated position.
-
-        Parameters
-        ----------
-        i
-            Index of the column.
-        """
-        s = self._df.to_series(i)
-        return PolarsColumn(s, allow_copy=self._allow_copy)
-
-    def get_column_by_name(self, name: str) -> PolarsColumn:
-        """
-        Return the column with the given name.
-
-        Parameters
-        ----------
-        name
-            Name of the column.
-        """
-        s = self._df.get_column(name)
-        return PolarsColumn(s, allow_copy=self._allow_copy)
-
-    def get_columns(self) -> Iterator[PolarsColumn]:
-        """Return an iterator yielding the columns."""
-        for column in self._df.get_columns():
-            yield PolarsColumn(column, allow_copy=self._allow_copy)
-
-    def select_columns(self, indices: Sequence[int]) -> PolarsDataFrame:
-        """
-        Create a new dataframe by selecting a subset of columns by index.
-
-        Parameters
-        ----------
-        indices
-            Column indices
-        """
-        if not isinstance(indices, Sequence):
-            msg = "`indices` is not a sequence"
-            raise TypeError(msg)
-        if not isinstance(indices, list):
-            indices = list(indices)
-
-        return PolarsDataFrame(
-            self._df[:, indices],
-            allow_copy=self._allow_copy,
-        )
-
-    def select_columns_by_name(self, names: Sequence[str]) -> PolarsDataFrame:
-        """
-        Create a new dataframe by selecting a subset of columns by name.
-
-        Parameters
-        ----------
-        names
-            Column names.
-        """
-        if not isinstance(names, Sequence):
-            msg = "`names` is not a sequence"
-            raise TypeError(msg)
-
-        return PolarsDataFrame(
-            self._df.select(names),
-            allow_copy=self._allow_copy,
-        )
-
-    def get_chunks(self, n_chunks: int | None = None) -> Iterator[PolarsDataFrame]:
-        """
-        Return an iterator yielding the chunks of the dataframe.
-
-        Parameters
-        ----------
-        n_chunks
-            The number of chunks to return. Must be a multiple of the number of chunks
-            in the dataframe. If set to `None` (default), returns all chunks.
-
-        Notes
-        -----
-        When the columns in the dataframe are chunked unevenly, or when `n_chunks` is
-        higher than the number of chunks in the dataframe, a slice must be performed
-        that is not on the chunk boundary. This will trigger some compute for columns
-        that contain null values and boolean columns.
-        """
-        total_n_chunks = self.num_chunks()
-        chunks = self._get_chunks_from_col_chunks()
-
-        if (n_chunks is None) or (n_chunks == total_n_chunks):
-            for chunk in chunks:
-                yield PolarsDataFrame(chunk, allow_copy=self._allow_copy)
-
-        elif (n_chunks <= 0) or (n_chunks % total_n_chunks != 0):
-            msg = (
-                "`n_chunks` must be a multiple of the number of chunks of this"
-                f" dataframe ({total_n_chunks})"
-            )
-            raise ValueError(msg)
-
-        else:
-            subchunks_per_chunk = n_chunks // total_n_chunks
-            for chunk in chunks:
-                size = len(chunk)
-                step = size // subchunks_per_chunk
-                if size % subchunks_per_chunk != 0:
-                    step += 1
-                for start in range(0, step * subchunks_per_chunk, step):
-                    yield PolarsDataFrame(
-                        chunk[start : start + step, :],
-                        allow_copy=self._allow_copy,
-                    )
-
-    def _get_chunks_from_col_chunks(self) -> Iterator[DataFrame]:
-        """
-        Return chunks of this dataframe according to the chunks of the first column.
-
-        If columns are not all chunked identically, they will be rechunked like the
-        first column. If copy is not allowed, this raises a RuntimeError.
-        """
-        col_chunks = self.get_column(0).get_chunks()
-        chunk_sizes = [chunk.size() for chunk in col_chunks]
-        starts = [0] + list(accumulate(chunk_sizes))
-
-        for i in range(len(starts) - 1):
-            start, end = starts[i : i + 2]
-            chunk = self._df[start:end, :]
-
-            if not all(x == 1 for x in chunk.n_chunks("all")):
-                if not self._allow_copy:
-                    msg = "unevenly chunked columns must be rechunked"
-                    raise CopyNotAllowedError(msg)
-                chunk = chunk.rechunk()
-
-            yield chunk