polars-runtime-compat 1.34.0b2__cp39-abi3-win_amd64.whl → 1.34.0b4__cp39-abi3-win_amd64.whl

polars/functions/business.py

@@ -1,138 +0,0 @@
-from __future__ import annotations
-
-import contextlib
-from datetime import date
-from typing import TYPE_CHECKING
-
-from polars._utils.deprecation import deprecate_nonkeyword_arguments
-from polars._utils.parse import parse_into_expression
-from polars._utils.unstable import unstable
-from polars._utils.wrap import wrap_expr
-
-with contextlib.suppress(ImportError):  # Module not available when building docs
-    import polars._plr as plr
-
-if TYPE_CHECKING:
-    from collections.abc import Iterable
-
-    from polars import Expr
-    from polars._typing import IntoExprColumn
-
-
-@unstable()
-@deprecate_nonkeyword_arguments(allowed_args=["start", "end"], version="1.27.0")
-def business_day_count(
-    start: date | IntoExprColumn,
-    end: date | IntoExprColumn,
-    week_mask: Iterable[bool] = (True, True, True, True, True, False, False),
-    holidays: Iterable[date] = (),
-) -> Expr:
-    """
-    Count the number of business days between `start` and `end` (not including `end`).
-
-    .. warning::
-        This functionality is considered **unstable**. It may be changed
-        at any point without it being considered a breaking change.
-
-    .. versionchanged:: 1.27.0
-        Parameters after `start` and `end` should now be passed as keyword arguments.
-
-    Parameters
-    ----------
-    start
-        Start dates.
-    end
-        End dates.
-    week_mask
-        Which days of the week to count. The default is Monday to Friday.
-        If you wanted to count only Monday to Thursday, you would pass
-        `(True, True, True, True, False, False, False)`.
-    holidays
-        Holidays to exclude from the count. The Python package
-        `python-holidays <https://github.com/vacanza/python-holidays>`_
-        may come in handy here. You can install it with ``pip install holidays``,
-        and then, to get all Dutch holidays for years 2020-2024:
-
-        .. code-block:: python
-
-            import holidays
-
-            my_holidays = holidays.country_holidays("NL", years=range(2020, 2025))
-
-        and pass `holidays=my_holidays` when you call `business_day_count`.
-
-    Returns
-    -------
-    Expr
-
-    Examples
-    --------
-    >>> from datetime import date
-    >>> df = pl.DataFrame(
-    ...     {
-    ...         "start": [date(2020, 1, 1), date(2020, 1, 2)],
-    ...         "end": [date(2020, 1, 2), date(2020, 1, 10)],
-    ...     }
-    ... )
-    >>> df.with_columns(
-    ...     business_day_count=pl.business_day_count("start", "end"),
-    ... )
-    shape: (2, 3)
-    ┌────────────┬────────────┬────────────────────┐
-    │ start      ┆ end        ┆ business_day_count │
-    │ ---        ┆ ---        ┆ ---                │
-    │ date       ┆ date       ┆ i32                │
-    ╞════════════╪════════════╪════════════════════╡
-    │ 2020-01-01 ┆ 2020-01-02 ┆ 1                  │
-    │ 2020-01-02 ┆ 2020-01-10 ┆ 6                  │
-    └────────────┴────────────┴────────────────────┘
-
-    Note how the business day count is 6 (as opposed a regular day count of 8)
-    due to the weekend (2020-01-04 - 2020-01-05) not being counted.
-
-    You can pass a custom weekend - for example, if you only take Sunday off:
-
-    >>> week_mask = (True, True, True, True, True, True, False)
-    >>> df.with_columns(
-    ...     business_day_count=pl.business_day_count(
-    ...         "start", "end", week_mask=week_mask
-    ...     ),
-    ... )
-    shape: (2, 3)
-    ┌────────────┬────────────┬────────────────────┐
-    │ start      ┆ end        ┆ business_day_count │
-    │ ---        ┆ ---        ┆ ---                │
-    │ date       ┆ date       ┆ i32                │
-    ╞════════════╪════════════╪════════════════════╡
-    │ 2020-01-01 ┆ 2020-01-02 ┆ 1                  │
-    │ 2020-01-02 ┆ 2020-01-10 ┆ 7                  │
-    └────────────┴────────────┴────────────────────┘
-
-    You can also pass a list of holidays to exclude from the count:
-
-    >>> from datetime import date
-    >>> holidays = [date(2020, 1, 1), date(2020, 1, 2)]
-    >>> df.with_columns(
-    ...     business_day_count=pl.business_day_count("start", "end", holidays=holidays)
-    ... )
-    shape: (2, 3)
-    ┌────────────┬────────────┬────────────────────┐
-    │ start      ┆ end        ┆ business_day_count │
-    │ ---        ┆ ---        ┆ ---                │
-    │ date       ┆ date       ┆ i32                │
-    ╞════════════╪════════════╪════════════════════╡
-    │ 2020-01-01 ┆ 2020-01-02 ┆ 0                  │
-    │ 2020-01-02 ┆ 2020-01-10 ┆ 5                  │
-    └────────────┴────────────┴────────────────────┘
-    """
-    start_pyexpr = parse_into_expression(start)
-    end_pyexpr = parse_into_expression(end)
-    unix_epoch = date(1970, 1, 1)
-    return wrap_expr(
-        plr.business_day_count(
-            start_pyexpr,
-            end_pyexpr,
-            list(week_mask),
-            [(holiday - unix_epoch).days for holiday in holidays],
-        )
-    )

polars/functions/col.py

@@ -1,384 +0,0 @@
-from __future__ import annotations
-
-import contextlib
-import sys
-from collections.abc import Iterable
-from datetime import datetime, timedelta
-from typing import TYPE_CHECKING
-
-import polars._reexport as pl
-from polars._utils.wrap import wrap_expr
-from polars.datatypes import (
-    Datetime,
-    Duration,
-    is_polars_dtype,
-    parse_into_dtype,
-)
-from polars.datatypes.group import (
-    DATETIME_DTYPES,
-    DURATION_DTYPES,
-    FLOAT_DTYPES,
-    INTEGER_DTYPES,
-)
-
-with contextlib.suppress(ImportError):  # Module not available when building docs
-    import polars._plr as plr
-
-if TYPE_CHECKING:
-    from polars._typing import PolarsDataType, PythonDataType
-    from polars.expr.expr import Expr
-
-    if not sys.version_info >= (3, 11):
-        from typing import Any
-
-__all__ = ["col"]
-
-
-def _create_col(
-    name: (
-        str
-        | PolarsDataType
-        | PythonDataType
-        | Iterable[str]
-        | Iterable[PolarsDataType | PythonDataType]
-    ),
-    *more_names: str | PolarsDataType | PythonDataType,
-) -> Expr:
-    """Create one or more column expressions representing column(s) in a DataFrame."""
-    dtypes: list[PolarsDataType]
-    if more_names:
-        if isinstance(name, str):
-            names_str = [name]
-            names_str.extend(more_names)  # type: ignore[arg-type]
-            return pl.Selector._by_name(names_str, strict=True).as_expr()
-        elif is_polars_dtype(name):
-            dtypes = [name]
-            dtypes.extend(more_names)  # type: ignore[arg-type]
-            return pl.Selector._by_dtype(dtypes).as_expr()  # type: ignore[arg-type]
-        else:
-            msg = (
-                "invalid input for `col`"
-                f"\n\nExpected `str` or `DataType`, got {type(name).__name__!r}."
-            )
-            raise TypeError(msg)
-
-    if isinstance(name, str):
-        return wrap_expr(plr.col(name))
-    elif is_polars_dtype(name):
-        dtypes = _polars_dtype_match(name)
-        return pl.Selector._by_dtype(dtypes).as_expr()  # type: ignore[arg-type]
-    elif isinstance(name, type):
-        dtypes = _python_dtype_match(name)
-        return pl.Selector._by_dtype(dtypes).as_expr()  # type: ignore[arg-type]
-    elif isinstance(name, Iterable):
-        names = list(name)
-        if not names:
-            return pl.Selector._by_name(names, strict=True).as_expr()  # type: ignore[arg-type]
-
-        item = names[0]
-        if isinstance(item, str):
-            return pl.Selector._by_name(names, strict=True).as_expr()  # type: ignore[arg-type]
-        elif is_polars_dtype(item):
-            dtypes = []
-            for nm in names:
-                dtypes.extend(_polars_dtype_match(nm))  # type: ignore[arg-type]
-            return pl.Selector._by_dtype(dtypes).as_expr()  # type: ignore[arg-type]
-        elif isinstance(item, type):
-            dtypes = []
-            for nm in names:
-                dtypes.extend(_python_dtype_match(nm))  # type: ignore[arg-type]
-            return pl.Selector._by_dtype(dtypes).as_expr()  # type: ignore[arg-type]
-        else:
-            msg = (
-                "invalid input for `col`"
-                "\n\nExpected iterable of type `str` or `DataType`,"
-                f" got iterable of type {type(item).__name__!r}."
-            )
-            raise TypeError(msg)
-    else:
-        msg = (
-            "invalid input for `col`"
-            f"\n\nExpected `str` or `DataType`, got {type(name).__name__!r}."
-        )
-        raise TypeError(msg)
-
-
-def _python_dtype_match(tp: PythonDataType) -> list[PolarsDataType]:
-    if tp is int:
-        return list(INTEGER_DTYPES)
-    elif tp is float:
-        return list(FLOAT_DTYPES)
-    elif tp is datetime:
-        return list(DATETIME_DTYPES)
-    elif tp is timedelta:
-        return list(DURATION_DTYPES)
-    return [parse_into_dtype(tp)]
-
-
-def _polars_dtype_match(tp: PolarsDataType) -> list[PolarsDataType]:
-    if Datetime.is_(tp):
-        return list(DATETIME_DTYPES)
-    elif Duration.is_(tp):
-        return list(DURATION_DTYPES)
-    return [tp]
-
-
-class Col:
-    """
-    Create Polars column expressions.
-
-    Notes
-    -----
-    An instance of this class is exported under the name `col`. It can be used as
-    though it were a function by calling, for example, `pl.col("foo")`.
-    See the :func:`__call__` method for further documentation.
-
-    This helper class enables an alternative syntax for creating a column expression
-    through attribute lookup. For example `col.foo` creates an expression equal to
-    `col("foo")`. See the :func:`__getattr__` method for further documentation.
-
-    The function call syntax is considered the idiomatic way of constructing a column
-    expression. The alternative attribute syntax can be useful for quick prototyping as
-    it can save some keystrokes, but has drawbacks in both expressiveness and
-    readability.
-
-    Examples
-    --------
-    >>> from polars import col
-    >>> df = pl.DataFrame(
-    ...     {
-    ...         "foo": [1, 2],
-    ...         "bar": [3, 4],
-    ...     }
-    ... )
-
-    Create a new column expression using the standard syntax:
-
-    >>> df.with_columns(baz=(col("foo") * col("bar")) / 2)
-    shape: (2, 3)
-    ┌─────┬─────┬─────┐
-    │ foo ┆ bar ┆ baz │
-    │ --- ┆ --- ┆ --- │
-    │ i64 ┆ i64 ┆ f64 │
-    ╞═════╪═════╪═════╡
-    │ 1   ┆ 3   ┆ 1.5 │
-    │ 2   ┆ 4   ┆ 4.0 │
-    └─────┴─────┴─────┘
-
-    Use attribute lookup to create a new column expression:
-
-    >>> df.with_columns(baz=(col.foo + col.bar))
-    shape: (2, 3)
-    ┌─────┬─────┬─────┐
-    │ foo ┆ bar ┆ baz │
-    │ --- ┆ --- ┆ --- │
-    │ i64 ┆ i64 ┆ i64 │
-    ╞═════╪═════╪═════╡
-    │ 1   ┆ 3   ┆ 4   │
-    │ 2   ┆ 4   ┆ 6   │
-    └─────┴─────┴─────┘
-    """
-
-    def __call__(
-        self,
-        name: (
-            str
-            | PolarsDataType
-            | PythonDataType
-            | Iterable[str]
-            | Iterable[PolarsDataType | PythonDataType]
-        ),
-        *more_names: str | PolarsDataType | PythonDataType,
-    ) -> Expr:
-        """
-        Create one or more expressions representing columns in a DataFrame.
-
-        Parameters
-        ----------
-        name
-            The name or datatype of the column(s) to represent.
-            Accepts regular expression input; regular expressions
-            should start with `^` and end with `$`.
-        *more_names
-            Additional names or datatypes of columns to represent,
-            specified as positional arguments.
-
-        See Also
-        --------
-        first
-        last
-        nth
-
-        Examples
-        --------
-        Pass a single column name to represent that column.
-
-        >>> df = pl.DataFrame(
-        ...     {
-        ...         "ham": [1, 2],
-        ...         "hamburger": [11, 22],
-        ...         "foo": [2, 1],
-        ...         "bar": ["a", "b"],
-        ...     }
-        ... )
-        >>> df.select(pl.col("foo"))
-        shape: (2, 1)
-        ┌─────┐
-        │ foo │
-        │ --- │
-        │ i64 │
-        ╞═════╡
-        │ 2   │
-        │ 1   │
-        └─────┘
-
-        Use dot syntax to save keystrokes for quick prototyping.
-
-        >>> from polars import col as c
-        >>> df.select(c.foo + c.ham)
-        shape: (2, 1)
-        ┌─────┐
-        │ foo │
-        │ --- │
-        │ i64 │
-        ╞═════╡
-        │ 3   │
-        │ 3   │
-        └─────┘
-
-        Use the wildcard `*` to represent all columns.
-
-        >>> df.select(pl.col("*"))
-        shape: (2, 4)
-        ┌─────┬───────────┬─────┬─────┐
-        │ ham ┆ hamburger ┆ foo ┆ bar │
-        │ --- ┆ ---       ┆ --- ┆ --- │
-        │ i64 ┆ i64       ┆ i64 ┆ str │
-        ╞═════╪═══════════╪═════╪═════╡
-        │ 1   ┆ 11        ┆ 2   ┆ a   │
-        │ 2   ┆ 22        ┆ 1   ┆ b   │
-        └─────┴───────────┴─────┴─────┘
-        >>> df.select(pl.col("*").exclude("ham"))
-        shape: (2, 3)
-        ┌───────────┬─────┬─────┐
-        │ hamburger ┆ foo ┆ bar │
-        │ ---       ┆ --- ┆ --- │
-        │ i64       ┆ i64 ┆ str │
-        ╞═══════════╪═════╪═════╡
-        │ 11        ┆ 2   ┆ a   │
-        │ 22        ┆ 1   ┆ b   │
-        └───────────┴─────┴─────┘
-
-        Regular expression input is supported.
-
-        >>> df.select(pl.col("^ham.*$"))
-        shape: (2, 2)
-        ┌─────┬───────────┐
-        │ ham ┆ hamburger │
-        │ --- ┆ ---       │
-        │ i64 ┆ i64       │
-        ╞═════╪═══════════╡
-        │ 1   ┆ 11        │
-        │ 2   ┆ 22        │
-        └─────┴───────────┘
-
-        Multiple columns can be represented by passing a list of names.
-
-        >>> df.select(pl.col(["hamburger", "foo"]))
-        shape: (2, 2)
-        ┌───────────┬─────┐
-        │ hamburger ┆ foo │
-        │ ---       ┆ --- │
-        │ i64       ┆ i64 │
-        ╞═══════════╪═════╡
-        │ 11        ┆ 2   │
-        │ 22        ┆ 1   │
-        └───────────┴─────┘
-
-        Or use positional arguments to represent multiple columns in the same way.
-
-        >>> df.select(pl.col("hamburger", "foo"))
-        shape: (2, 2)
-        ┌───────────┬─────┐
-        │ hamburger ┆ foo │
-        │ ---       ┆ --- │
-        │ i64       ┆ i64 │
-        ╞═══════════╪═════╡
-        │ 11        ┆ 2   │
-        │ 22        ┆ 1   │
-        └───────────┴─────┘
-
-        Easily select all columns that match a certain data type by passing that
-        datatype.
-
-        >>> df.select(pl.col(pl.String))
-        shape: (2, 1)
-        ┌─────┐
-        │ bar │
-        │ --- │
-        │ str │
-        ╞═════╡
-        │ a   │
-        │ b   │
-        └─────┘
-        >>> df.select(pl.col(pl.Int64, pl.Float64))
-        shape: (2, 3)
-        ┌─────┬───────────┬─────┐
-        │ ham ┆ hamburger ┆ foo │
-        │ --- ┆ ---       ┆ --- │
-        │ i64 ┆ i64       ┆ i64 │
-        ╞═════╪═══════════╪═════╡
-        │ 1   ┆ 11        ┆ 2   │
-        │ 2   ┆ 22        ┆ 1   │
-        └─────┴───────────┴─────┘
-        """
-        return _create_col(name, *more_names)
-
-    def __getattr__(self, name: str) -> Expr:
-        """
-        Create a column expression using attribute syntax.
-
-        Note that this syntax does not support passing data
-        types or multiple column names.
-
-        Parameters
-        ----------
-        name
-            The name of the column to represent.
-
-        Examples
-        --------
-        >>> from polars import col as c
-        >>> df = pl.DataFrame(
-        ...     {
-        ...         "foo": [1, 2],
-        ...         "bar": [3, 4],
-        ...     }
-        ... )
-        >>> df.select(c.foo + c.bar)
-        shape: (2, 1)
-        ┌─────┐
-        │ foo │
-        │ --- │
-        │ i64 │
-        ╞═════╡
-        │ 4   │
-        │ 6   │
-        └─────┘
-        """
-        # For autocomplete to work with IPython
-        if name.startswith("__wrapped__"):
-            return getattr(type(self), name)
-
-        return _create_col(name)
-
-    if not sys.version_info >= (3, 11):
-
-        def __getstate__(self) -> Any:
-            return self.__dict__
-
-        def __setstate__(self, state: Any) -> None:
-            self.__dict__ = state
-
-
-col: Col = Col()

polars/functions/datatype.py

@@ -1,121 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-import polars._reexport as pl
-from polars import functions as F
-from polars._utils.unstable import unstable
-from polars._utils.various import qualified_type_name
-
-if TYPE_CHECKING:
-    from collections.abc import Mapping
-
-    from polars import Expr
-    from polars._typing import PolarsDataType
-
-
-@unstable()
-def dtype_of(col_or_expr: str | Expr) -> pl.DataTypeExpr:
-    """
-    Get a lazily evaluated :class:`DataType` of a column or expression.
-
-    .. warning::
-        This functionality is considered **unstable**. It may be changed
-        at any point without it being considered a breaking change.
-
-    Examples
-    --------
-    >>> def inspect(expr: pl.Expr) -> pl.Expr:
-    ...     def print_and_return(s: pl.Series) -> pl.Series:
-    ...         print(s)
-    ...         return s
-    ...
-    ...     return expr.map_batches(
-    ...         print_and_return,
-    ...         # Clarify that the expression returns the same datatype as the input
-    ...         # datatype.
-    ...         return_dtype=pl.dtype_of(expr),
-    ...     )
-    >>> df = pl.DataFrame(
-    ...     {
-    ...         "UserID": [1, 2, 3, 4, 5],
-    ...         "Name": ["Alice", "Bob", "Charlie", "Diana", "Ethan"],
-    ...     }
-    ... )
-    >>> df.select(inspect(pl.col("Name")))
-    shape: (5,)
-    Series: 'Name' [str]
-    [
-        "Alice"
-        "Bob"
-        "Charlie"
-        "Diana"
-        "Ethan"
-    ]
-    shape: (5, 1)
-    ┌─────────┐
-    │ Name    │
-    │ ---     │
-    │ str     │
-    ╞═════════╡
-    │ Alice   │
-    │ Bob     │
-    │ Charlie │
-    │ Diana   │
-    │ Ethan   │
-    └─────────┘
-    """
-    from polars._plr import PyDataTypeExpr
-
-    e: Expr
-    if isinstance(col_or_expr, str):
-        e = F.col(col_or_expr)
-    else:
-        e = col_or_expr
-
-    return pl.DataTypeExpr._from_pydatatype_expr(PyDataTypeExpr.of_expr(e._pyexpr))
-
-
-@unstable()
-def self_dtype() -> pl.DataTypeExpr:
-    """
-    Get the dtype of `self` in `map_elements` and `map_batches`.
-
-    .. warning::
-        This functionality is considered **unstable**. It may be changed
-        at any point without it being considered a breaking change.
-    """
-    from polars._plr import PyDataTypeExpr
-
-    return pl.DataTypeExpr._from_pydatatype_expr(PyDataTypeExpr.self_dtype())
-
-
-@unstable()
-def struct_with_fields(
-    mapping: Mapping[str, PolarsDataType | pl.DataTypeExpr],
-) -> pl.DataTypeExpr:
-    """
-    Create a new datatype expression that represents a Struct datatype.
-
-    .. warning::
-        This functionality is considered **unstable**. It may be changed
-        at any point without it being considered a breaking change.
-    """
-    from polars._plr import PyDataTypeExpr
-
-    def preprocess(dtype_expr: PolarsDataType | pl.DataTypeExpr) -> PyDataTypeExpr:
-        if isinstance(dtype_expr, pl.DataType):
-            return dtype_expr.to_dtype_expr()._pydatatype_expr
-        if isinstance(dtype_expr, pl.DataTypeClass):
-            return dtype_expr.to_dtype_expr()._pydatatype_expr
-        elif isinstance(dtype_expr, pl.DataTypeExpr):
-            return dtype_expr._pydatatype_expr
-        else:
-            msg = f"mapping item must be a datatype or datatype expression; found {qualified_type_name(dtype_expr)!r}"
-            raise TypeError(msg)
-
-    fields = [(name, preprocess(dtype_expr)) for (name, dtype_expr) in mapping.items()]
-
-    return pl.DataTypeExpr._from_pydatatype_expr(
-        PyDataTypeExpr.struct_with_fields(fields)
-    )