polars-runtime-compat 1.34.0b3__cp39-abi3-manylinux_2_24_aarch64.whl → 1.34.0b4__cp39-abi3-manylinux_2_24_aarch64.whl

polars/functions/len.py

@@ -1,68 +0,0 @@
-"""
-Module containing the `len` function.
-
-Keep this function in its own module to avoid conflicts with Python's built-in `len`.
-"""
-
-from __future__ import annotations
-
-import contextlib
-from typing import TYPE_CHECKING
-
-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 polars import Expr
-
-
-def len() -> Expr:
-    """
-    Return the number of rows in the context.
-
-    This is similar to `COUNT(*)` in SQL.
-
-    Returns
-    -------
-    Expr
-        Expression of data type :class:`UInt32`.
-
-    Examples
-    --------
-    >>> df = pl.DataFrame(
-    ...     {
-    ...         "a": [1, 2, None],
-    ...         "b": [3, None, None],
-    ...         "c": ["foo", "bar", "foo"],
-    ...     }
-    ... )
-    >>> df.select(pl.len())
-    shape: (1, 1)
-    ┌─────┐
-    │ len │
-    │ --- │
-    │ u32 │
-    ╞═════╡
-    │ 3   │
-    └─────┘
-
-    Generate an index column by using `len` in conjunction with :func:`int_range`.
-
-    >>> df.select(
-    ...     pl.int_range(pl.len(), dtype=pl.UInt32).alias("index"),
-    ...     pl.all(),
-    ... )
-    shape: (3, 4)
-    ┌───────┬──────┬──────┬─────┐
-    │ index ┆ a    ┆ b    ┆ c   │
-    │ ---   ┆ ---  ┆ ---  ┆ --- │
-    │ u32   ┆ i64  ┆ i64  ┆ str │
-    ╞═══════╪══════╪══════╪═════╡
-    │ 0     ┆ 1    ┆ 3    ┆ foo │
-    │ 1     ┆ 2    ┆ null ┆ bar │
-    │ 2     ┆ null ┆ null ┆ foo │
-    └───────┴──────┴──────┴─────┘
-    """
-    return wrap_expr(plr.len())

polars/functions/lit.py

@@ -1,210 +0,0 @@
-from __future__ import annotations
-
-import contextlib
-import enum
-from datetime import date, datetime, time, timedelta, timezone
-from typing import TYPE_CHECKING, Any
-from zoneinfo import ZoneInfo
-
-import polars._reexport as pl
-from polars._dependencies import (
-    _check_for_numpy,
-    _check_for_pytz,
-    _check_for_torch,
-    pytz,
-    torch,
-)
-from polars._dependencies import numpy as np
-from polars._utils.wrap import wrap_expr
-from polars.datatypes import Date, Datetime, Duration
-from polars.datatypes.convert import DataTypeMappings
-
-with contextlib.suppress(ImportError):  # Module not available when building docs
-    import polars._plr as plr
-
-
-if TYPE_CHECKING:
-    from polars import Expr
-    from polars._typing import PolarsDataType, TimeUnit
-
-
-def lit(
-    value: Any, dtype: PolarsDataType | None = None, *, allow_object: bool = False
-) -> Expr:
-    """
-    Return an expression representing a literal value.
-
-    Parameters
-    ----------
-    value
-        Value that should be used as a `literal`.
-    dtype
-        The data type of the resulting expression.
-        If set to `None` (default), the data type is inferred from the `value` input.
-    allow_object
-        If type is unknown use an 'object' type.
-        By default, we will raise a `ValueException`
-        if the type is unknown.
-
-    Notes
-    -----
-    Expected datatypes:
-
-    - `pl.lit([])` -> empty List<Null>
-    - `pl.lit([1, 2, 3])` -> List<i64>
-    - `pl.lit(pl.Series([]))`-> empty Series Null
-    - `pl.lit(pl.Series([1, 2, 3]))` -> Series Int64
-    - `pl.lit(None)` -> Null
-
-    Examples
-    --------
-    Literal scalar values:
-
-    >>> pl.lit(1)  # doctest: +IGNORE_RESULT
-    >>> pl.lit(5.5)  # doctest: +IGNORE_RESULT
-    >>> pl.lit(None)  # doctest: +IGNORE_RESULT
-    >>> pl.lit("foo_bar")  # doctest: +IGNORE_RESULT
-    >>> pl.lit(date(2021, 1, 20))  # doctest: +IGNORE_RESULT
-    >>> pl.lit(datetime(2023, 3, 31, 10, 30, 45))  # doctest: +IGNORE_RESULT
-
-    Literal list/Series data (1D):
-
-    >>> pl.lit([1, 2, 3])  # doctest: +SKIP
-    >>> pl.lit(pl.Series("x", [1, 2, 3]))  # doctest: +IGNORE_RESULT
-
-    Literal list/Series data (2D):
-
-    >>> pl.lit([[1, 2], [3, 4]])  # doctest: +SKIP
-    >>> pl.lit(pl.Series("y", [[1, 2], [3, 4]]))  # doctest: +IGNORE_RESULT
-    """
-    time_unit: TimeUnit
-
-    if isinstance(value, datetime):
-        if dtype == Date:
-            return wrap_expr(plr.lit(value.date(), allow_object=False, is_scalar=True))
-
-        # parse time unit
-        if dtype is not None and (tu := getattr(dtype, "time_unit", "us")) is not None:
-            time_unit = tu  # type: ignore[assignment]
-        else:
-            time_unit = "us"
-
-        # parse time zone
-        dtype_tz = getattr(dtype, "time_zone", None)
-        value_tz = value.tzinfo
-        if value_tz is None:
-            tz = dtype_tz
-        else:
-            # value has time zone, but dtype does not: keep value time zone
-            if dtype_tz is None:
-                if isinstance(value_tz, ZoneInfo) or (
-                    _check_for_pytz(value_tz)
-                    and isinstance(value_tz, pytz.tzinfo.BaseTzInfo)
-                    and value_tz.zone is not None
-                ):
-                    # named timezone
-                    tz = str(value_tz)
-                else:
-                    # fixed offset from UTC (eg: +4:00)
-                    value = value.astimezone(timezone.utc)
-                    tz = "UTC"
-
-            # dtype and value both have same time zone
-            elif str(value_tz) == dtype_tz:
-                tz = str(value_tz)
-
-            # given a fixed offset from UTC that matches the dtype tz offset
-            elif hasattr(value_tz, "utcoffset") and getattr(
-                ZoneInfo(dtype_tz).utcoffset(value), "seconds", 0
-            ) == getattr(value_tz.utcoffset(value), "seconds", 1):
-                tz = dtype_tz
-            else:
-                # value has time zone that differs from dtype time zone
-                msg = (
-                    f"time zone of dtype ({dtype_tz!r}) differs from time zone of "
-                    f"value ({value_tz!r})"
-                )
-                raise TypeError(msg)
-
-        dt_utc = value.replace(tzinfo=timezone.utc)
-        expr = wrap_expr(plr.lit(dt_utc, allow_object=False, is_scalar=True)).cast(
-            Datetime(time_unit)
-        )
-        if tz is not None:
-            expr = expr.dt.replace_time_zone(
-                tz, ambiguous="earliest" if value.fold == 0 else "latest"
-            )
-        return expr
-
-    elif isinstance(value, timedelta):
-        expr = wrap_expr(plr.lit(value, allow_object=False, is_scalar=True))
-        if dtype is not None and (tu := getattr(dtype, "time_unit", None)) is not None:
-            expr = expr.cast(Duration(tu))
-        return expr
-
-    elif isinstance(value, time):
-        return wrap_expr(plr.lit(value, allow_object=False, is_scalar=True))
-
-    elif isinstance(value, date):
-        if dtype == Datetime:
-            time_unit = getattr(dtype, "time_unit", "us") or "us"
-            dt_utc = datetime(value.year, value.month, value.day)
-            expr = wrap_expr(plr.lit(dt_utc, allow_object=False, is_scalar=True)).cast(
-                Datetime(time_unit)
-            )
-            if (time_zone := getattr(dtype, "time_zone", None)) is not None:
-                expr = expr.dt.replace_time_zone(str(time_zone))
-            return expr
-        else:
-            return wrap_expr(plr.lit(value, allow_object=False, is_scalar=True))
-
-    elif isinstance(value, pl.Series):
-        value = value._s
-        return wrap_expr(plr.lit(value, allow_object, is_scalar=False))
-
-    elif _check_for_numpy(value) and isinstance(value, np.ndarray):
-        return lit(pl.Series("literal", value, dtype=dtype))
-
-    elif _check_for_torch(value) and isinstance(value, torch.Tensor):
-        return lit(pl.Series("literal", value.numpy(force=False), dtype=dtype))
-
-    elif isinstance(value, (list, tuple)):
-        return wrap_expr(
-            plr.lit(
-                pl.Series("literal", [value], dtype=dtype)._s,
-                allow_object,
-                is_scalar=True,
-            )
-        )
-
-    elif isinstance(value, enum.Enum):
-        return lit(value.value, dtype=dtype)
-
-    if dtype:
-        return wrap_expr(plr.lit(value, allow_object, is_scalar=True)).cast(dtype)
-
-    if _check_for_numpy(value) and isinstance(value, np.generic):
-        # note: the item() is a py-native datetime/timedelta when units < 'ns'
-        if isinstance(item := value.item(), (date, datetime, timedelta)):
-            return lit(item)
-
-        # handle 'ns' units
-        if isinstance(item, int) and hasattr(value, "dtype"):
-            dtype_name = value.dtype.name
-            if dtype_name.startswith("datetime64["):
-                time_unit = dtype_name[len("datetime64[") : -1]  # type: ignore[assignment]
-                return lit(item).cast(Datetime(time_unit))
-            if dtype_name.startswith("timedelta64["):
-                time_unit = dtype_name[len("timedelta64[") : -1]  # type: ignore[assignment]
-                return lit(item).cast(Duration(time_unit))
-
-        # handle known mappable values
-        dtype = DataTypeMappings.NUMPY_KIND_AND_ITEMSIZE_TO_DTYPE.get(
-            (value.dtype.kind, value.dtype.itemsize)
-        )
-        if dtype is not None:
-            return lit(value, dtype=dtype)
-    else:
-        item = value
-
-    return wrap_expr(plr.lit(item, allow_object, is_scalar=True))

polars/functions/random.py

@@ -1,22 +0,0 @@
-from __future__ import annotations
-
-import contextlib
-
-with contextlib.suppress(ImportError):  # Module not available when building docs
-    import polars._plr as plr
-
-
-def set_random_seed(seed: int) -> None:
-    r"""
-    Set the global random seed for Polars.
-
-    This random seed is used to determine things such as shuffle ordering.
-
-
-    Parameters
-    ----------
-    seed
-        A non-negative integer < 2\ :sup:`64` used to seed the internal global
-        random number generator.
-    """
-    plr.set_random_seed(seed)

polars/functions/range/__init__.py

@@ -1,19 +0,0 @@
-from polars.functions.range.date_range import date_range, date_ranges
-from polars.functions.range.datetime_range import datetime_range, datetime_ranges
-from polars.functions.range.int_range import arange, int_range, int_ranges
-from polars.functions.range.linear_space import linear_space, linear_spaces
-from polars.functions.range.time_range import time_range, time_ranges
-
-__all__ = [
-    "arange",
-    "date_range",
-    "date_ranges",
-    "datetime_range",
-    "datetime_ranges",
-    "int_range",
-    "int_ranges",
-    "linear_space",
-    "linear_spaces",
-    "time_range",
-    "time_ranges",
-]

polars/functions/range/_utils.py

@@ -1,15 +0,0 @@
-from __future__ import annotations
-
-from datetime import timedelta
-
-from polars._utils.convert import parse_as_duration_string
-
-
-def parse_interval_argument(interval: str | timedelta) -> str:
-    """Parse the interval argument as a Polars duration string."""
-    if isinstance(interval, timedelta):
-        return parse_as_duration_string(interval)
-
-    if " " in interval:
-        interval = interval.replace(" ", "")
-    return interval.lower()

polars/functions/range/date_range.py

@@ -1,303 +0,0 @@
-from __future__ import annotations
-
-import contextlib
-from typing import TYPE_CHECKING, overload
-
-from polars import functions as F
-from polars._utils.parse import parse_into_expression
-from polars._utils.wrap import wrap_expr
-from polars.functions.range._utils import parse_interval_argument
-
-with contextlib.suppress(ImportError):  # Module not available when building docs
-    import polars._plr as plr
-
-if TYPE_CHECKING:
-    from datetime import date, datetime, timedelta
-    from typing import Literal
-
-    from polars import Expr, Series
-    from polars._typing import ClosedInterval, IntoExprColumn
-
-
-@overload
-def date_range(
-    start: date | datetime | IntoExprColumn,
-    end: date | datetime | IntoExprColumn,
-    interval: str | timedelta = ...,
-    *,
-    closed: ClosedInterval = ...,
-    eager: Literal[False] = ...,
-) -> Expr: ...
-
-
-@overload
-def date_range(
-    start: date | datetime | IntoExprColumn,
-    end: date | datetime | IntoExprColumn,
-    interval: str | timedelta = ...,
-    *,
-    closed: ClosedInterval = ...,
-    eager: Literal[True],
-) -> Series: ...
-
-
-@overload
-def date_range(
-    start: date | datetime | IntoExprColumn,
-    end: date | datetime | IntoExprColumn,
-    interval: str | timedelta = ...,
-    *,
-    closed: ClosedInterval = ...,
-    eager: bool,
-) -> Series | Expr: ...
-
-
-def date_range(
-    start: date | datetime | IntoExprColumn,
-    end: date | datetime | IntoExprColumn,
-    interval: str | timedelta = "1d",
-    *,
-    closed: ClosedInterval = "both",
-    eager: bool = False,
-) -> Series | Expr:
-    """
-    Generate a date range.
-
-    Parameters
-    ----------
-    start
-        Lower bound of the date range.
-    end
-        Upper bound of the date range.
-    interval
-        Interval of the range periods, specified as a Python `timedelta` object
-        or using the Polars duration string language (see "Notes" section below).
-        Must consist of full days.
-    closed : {'both', 'left', 'right', 'none'}
-        Define which sides of the range are closed (inclusive).
-    eager
-        Evaluate immediately and return a `Series`.
-        If set to `False` (default), return an expression instead.
-
-    Returns
-    -------
-    Expr or Series
-        Column of data type :class:`Date`.
-
-    See Also
-    --------
-    date_ranges
-    datetime_range
-
-    Notes
-    -----
-    `interval` is created according to the following string language:
-
-    - 1d    (1 calendar day)
-    - 1w    (1 calendar week)
-    - 1mo   (1 calendar month)
-    - 1q    (1 calendar quarter)
-    - 1y    (1 calendar year)
-
-    Or combine them:
-    "1w2d" # 1 week, 2 days
-
-    By "calendar day", we mean the corresponding time on the next day (which may
-    not be 24 hours, due to daylight savings). Similarly for "calendar week",
-    "calendar month", "calendar quarter", and "calendar year".
-
-    Examples
-    --------
-    Using Polars duration string to specify the interval:
-
-    >>> from datetime import date
-    >>> pl.date_range(date(2022, 1, 1), date(2022, 3, 1), "1mo", eager=True).alias(
-    ...     "date"
-    ... )
-    shape: (3,)
-    Series: 'date' [date]
-    [
-        2022-01-01
-        2022-02-01
-        2022-03-01
-    ]
-
-    Using `timedelta` object to specify the interval:
-
-    >>> from datetime import timedelta
-    >>> pl.date_range(
-    ...     date(1985, 1, 1),
-    ...     date(1985, 1, 10),
-    ...     timedelta(days=2),
-    ...     eager=True,
-    ... ).alias("date")
-    shape: (5,)
-    Series: 'date' [date]
-    [
-        1985-01-01
-        1985-01-03
-        1985-01-05
-        1985-01-07
-        1985-01-09
-    ]
-
-    Omit `eager=True` if you want to use `date_range` as an expression:
-
-    >>> df = pl.DataFrame(
-    ...     {
-    ...         "date": [
-    ...             date(2024, 1, 1),
-    ...             date(2024, 1, 2),
-    ...             date(2024, 1, 1),
-    ...             date(2024, 1, 3),
-    ...         ],
-    ...         "key": ["one", "one", "two", "two"],
-    ...     }
-    ... )
-    >>> result = (
-    ...     df.group_by("key")
-    ...     .agg(pl.date_range(pl.col("date").min(), pl.col("date").max()))
-    ...     .sort("key")
-    ... )
-    >>> with pl.Config(fmt_str_lengths=50):
-    ...     print(result)
-    shape: (2, 2)
-    ┌─────┬──────────────────────────────────────┐
-    │ key ┆ date                                 │
-    │ --- ┆ ---                                  │
-    │ str ┆ list[date]                           │
-    ╞═════╪══════════════════════════════════════╡
-    │ one ┆ [2024-01-01, 2024-01-02]             │
-    │ two ┆ [2024-01-01, 2024-01-02, 2024-01-03] │
-    └─────┴──────────────────────────────────────┘
-    """
-    interval = parse_interval_argument(interval)
-
-    start_pyexpr = parse_into_expression(start)
-    end_pyexpr = parse_into_expression(end)
-    result = wrap_expr(plr.date_range(start_pyexpr, end_pyexpr, interval, closed))
-
-    if eager:
-        return F.select(result).to_series()
-
-    return result
-
-
-@overload
-def date_ranges(
-    start: date | datetime | IntoExprColumn,
-    end: date | datetime | IntoExprColumn,
-    interval: str | timedelta = ...,
-    *,
-    closed: ClosedInterval = ...,
-    eager: Literal[False] = ...,
-) -> Expr: ...
-
-
-@overload
-def date_ranges(
-    start: date | datetime | IntoExprColumn,
-    end: date | datetime | IntoExprColumn,
-    interval: str | timedelta = ...,
-    *,
-    closed: ClosedInterval = ...,
-    eager: Literal[True],
-) -> Series: ...
-
-
-@overload
-def date_ranges(
-    start: date | datetime | IntoExprColumn,
-    end: date | datetime | IntoExprColumn,
-    interval: str | timedelta = ...,
-    *,
-    closed: ClosedInterval = ...,
-    eager: bool,
-) -> Series | Expr: ...
-
-
-def date_ranges(
-    start: date | datetime | IntoExprColumn,
-    end: date | datetime | IntoExprColumn,
-    interval: str | timedelta = "1d",
-    *,
-    closed: ClosedInterval = "both",
-    eager: bool = False,
-) -> Series | Expr:
-    """
-    Create a column of date ranges.
-
-    Parameters
-    ----------
-    start
-        Lower bound of the date range.
-    end
-        Upper bound of the date range.
-    interval
-        Interval of the range periods, specified as a Python `timedelta` object
-        or using the Polars duration string language (see "Notes" section below).
-        Must consist of full days.
-    closed : {'both', 'left', 'right', 'none'}
-        Define which sides of the range are closed (inclusive).
-    eager
-        Evaluate immediately and return a `Series`.
-        If set to `False` (default), return an expression instead.
-
-    Returns
-    -------
-    Expr or Series
-        Column of data type `List(Date)`.
-
-    See Also
-    --------
-    date_range
-    datetime_ranges
-
-    Notes
-    -----
-    `interval` is created according to the following string language:
-
-    - 1d    (1 calendar day)
-    - 1w    (1 calendar week)
-    - 1mo   (1 calendar month)
-    - 1q    (1 calendar quarter)
-    - 1y    (1 calendar year)
-
-    Or combine them:
-    "1w2d" # 1 week, 2 days
-
-    By "calendar day", we mean the corresponding time on the next day (which may
-    not be 24 hours, due to daylight savings). Similarly for "calendar week",
-    "calendar month", "calendar quarter", and "calendar year".
-
-    Examples
-    --------
-    >>> from datetime import date
-    >>> df = pl.DataFrame(
-    ...     {
-    ...         "start": [date(2022, 1, 1), date(2022, 1, 2)],
-    ...         "end": date(2022, 1, 3),
-    ...     }
-    ... )
-    >>> with pl.Config(fmt_str_lengths=50):
-    ...     df.with_columns(date_range=pl.date_ranges("start", "end"))
-    shape: (2, 3)
-    ┌────────────┬────────────┬──────────────────────────────────────┐
-    │ start      ┆ end        ┆ date_range                           │
-    │ ---        ┆ ---        ┆ ---                                  │
-    │ date       ┆ date       ┆ list[date]                           │
-    ╞════════════╪════════════╪══════════════════════════════════════╡
-    │ 2022-01-01 ┆ 2022-01-03 ┆ [2022-01-01, 2022-01-02, 2022-01-03] │
-    │ 2022-01-02 ┆ 2022-01-03 ┆ [2022-01-02, 2022-01-03]             │
-    └────────────┴────────────┴──────────────────────────────────────┘
-    """
-    interval = parse_interval_argument(interval)
-    start_pyexpr = parse_into_expression(start)
-    end_pyexpr = parse_into_expression(end)
-
-    result = wrap_expr(plr.date_ranges(start_pyexpr, end_pyexpr, interval, closed))
-
-    if eager:
-        return F.select(result).to_series()
-
-    return result