Add files using upload-large-folder tool

videollama2/lib/python3.10/site-packages/pandas/core/accessor.py

@@ -0,0 +1,340 @@
+"""
+
+accessor.py contains base classes for implementing accessor properties
+that can be mixed into or pinned onto other pandas classes.
+
+"""
+from __future__ import annotations
+
+from typing import (
+    Callable,
+    final,
+)
+import warnings
+
+from pandas.util._decorators import doc
+from pandas.util._exceptions import find_stack_level
+
+
+class DirNamesMixin:
+    _accessors: set[str] = set()
+    _hidden_attrs: frozenset[str] = frozenset()
+
+    @final
+    def _dir_deletions(self) -> set[str]:
+        """
+        Delete unwanted __dir__ for this object.
+        """
+        return self._accessors | self._hidden_attrs
+
+    def _dir_additions(self) -> set[str]:
+        """
+        Add additional __dir__ for this object.
+        """
+        return {accessor for accessor in self._accessors if hasattr(self, accessor)}
+
+    def __dir__(self) -> list[str]:
+        """
+        Provide method name lookup and completion.
+
+        Notes
+        -----
+        Only provide 'public' methods.
+        """
+        rv = set(super().__dir__())
+        rv = (rv - self._dir_deletions()) | self._dir_additions()
+        return sorted(rv)
+
+
+class PandasDelegate:
+    """
+    Abstract base class for delegating methods/properties.
+    """
+
+    def _delegate_property_get(self, name: str, *args, **kwargs):
+        raise TypeError(f"You cannot access the property {name}")
+
+    def _delegate_property_set(self, name: str, value, *args, **kwargs):
+        raise TypeError(f"The property {name} cannot be set")
+
+    def _delegate_method(self, name: str, *args, **kwargs):
+        raise TypeError(f"You cannot call method {name}")
+
+    @classmethod
+    def _add_delegate_accessors(
+        cls,
+        delegate,
+        accessors: list[str],
+        typ: str,
+        overwrite: bool = False,
+        accessor_mapping: Callable[[str], str] = lambda x: x,
+        raise_on_missing: bool = True,
+    ) -> None:
+        """
+        Add accessors to cls from the delegate class.
+
+        Parameters
+        ----------
+        cls
+            Class to add the methods/properties to.
+        delegate
+            Class to get methods/properties and doc-strings.
+        accessors : list of str
+            List of accessors to add.
+        typ : {'property', 'method'}
+        overwrite : bool, default False
+            Overwrite the method/property in the target class if it exists.
+        accessor_mapping: Callable, default lambda x: x
+            Callable to map the delegate's function to the cls' function.
+        raise_on_missing: bool, default True
+            Raise if an accessor does not exist on delegate.
+            False skips the missing accessor.
+        """
+
+        def _create_delegator_property(name: str):
+            def _getter(self):
+                return self._delegate_property_get(name)
+
+            def _setter(self, new_values):
+                return self._delegate_property_set(name, new_values)
+
+            _getter.__name__ = name
+            _setter.__name__ = name
+
+            return property(
+                fget=_getter,
+                fset=_setter,
+                doc=getattr(delegate, accessor_mapping(name)).__doc__,
+            )
+
+        def _create_delegator_method(name: str):
+            def f(self, *args, **kwargs):
+                return self._delegate_method(name, *args, **kwargs)
+
+            f.__name__ = name
+            f.__doc__ = getattr(delegate, accessor_mapping(name)).__doc__
+
+            return f
+
+        for name in accessors:
+            if (
+                not raise_on_missing
+                and getattr(delegate, accessor_mapping(name), None) is None
+            ):
+                continue
+
+            if typ == "property":
+                f = _create_delegator_property(name)
+            else:
+                f = _create_delegator_method(name)
+
+            # don't overwrite existing methods/properties
+            if overwrite or not hasattr(cls, name):
+                setattr(cls, name, f)
+
+
+def delegate_names(
+    delegate,
+    accessors: list[str],
+    typ: str,
+    overwrite: bool = False,
+    accessor_mapping: Callable[[str], str] = lambda x: x,
+    raise_on_missing: bool = True,
+):
+    """
+    Add delegated names to a class using a class decorator.  This provides
+    an alternative usage to directly calling `_add_delegate_accessors`
+    below a class definition.
+
+    Parameters
+    ----------
+    delegate : object
+        The class to get methods/properties & doc-strings.
+    accessors : Sequence[str]
+        List of accessor to add.
+    typ : {'property', 'method'}
+    overwrite : bool, default False
+       Overwrite the method/property in the target class if it exists.
+    accessor_mapping: Callable, default lambda x: x
+        Callable to map the delegate's function to the cls' function.
+    raise_on_missing: bool, default True
+        Raise if an accessor does not exist on delegate.
+        False skips the missing accessor.
+
+    Returns
+    -------
+    callable
+        A class decorator.
+
+    Examples
+    --------
+    @delegate_names(Categorical, ["categories", "ordered"], "property")
+    class CategoricalAccessor(PandasDelegate):
+        [...]
+    """
+
+    def add_delegate_accessors(cls):
+        cls._add_delegate_accessors(
+            delegate,
+            accessors,
+            typ,
+            overwrite=overwrite,
+            accessor_mapping=accessor_mapping,
+            raise_on_missing=raise_on_missing,
+        )
+        return cls
+
+    return add_delegate_accessors
+
+
+# Ported with modifications from xarray; licence at LICENSES/XARRAY_LICENSE
+# https://github.com/pydata/xarray/blob/master/xarray/core/extensions.py
+# 1. We don't need to catch and re-raise AttributeErrors as RuntimeErrors
+# 2. We use a UserWarning instead of a custom Warning
+
+
+class CachedAccessor:
+    """
+    Custom property-like object.
+
+    A descriptor for caching accessors.
+
+    Parameters
+    ----------
+    name : str
+        Namespace that will be accessed under, e.g. ``df.foo``.
+    accessor : cls
+        Class with the extension methods.
+
+    Notes
+    -----
+    For accessor, The class's __init__ method assumes that one of
+    ``Series``, ``DataFrame`` or ``Index`` as the
+    single argument ``data``.
+    """
+
+    def __init__(self, name: str, accessor) -> None:
+        self._name = name
+        self._accessor = accessor
+
+    def __get__(self, obj, cls):
+        if obj is None:
+            # we're accessing the attribute of the class, i.e., Dataset.geo
+            return self._accessor
+        accessor_obj = self._accessor(obj)
+        # Replace the property with the accessor object. Inspired by:
+        # https://www.pydanny.com/cached-property.html
+        # We need to use object.__setattr__ because we overwrite __setattr__ on
+        # NDFrame
+        object.__setattr__(obj, self._name, accessor_obj)
+        return accessor_obj
+
+
+@doc(klass="", others="")
+def _register_accessor(name: str, cls):
+    """
+    Register a custom accessor on {klass} objects.
+
+    Parameters
+    ----------
+    name : str
+        Name under which the accessor should be registered. A warning is issued
+        if this name conflicts with a preexisting attribute.
+
+    Returns
+    -------
+    callable
+        A class decorator.
+
+    See Also
+    --------
+    register_dataframe_accessor : Register a custom accessor on DataFrame objects.
+    register_series_accessor : Register a custom accessor on Series objects.
+    register_index_accessor : Register a custom accessor on Index objects.
+
+    Notes
+    -----
+    When accessed, your accessor will be initialized with the pandas object
+    the user is interacting with. So the signature must be
+
+    .. code-block:: python
+
+        def __init__(self, pandas_object):  # noqa: E999
+            ...
+
+    For consistency with pandas methods, you should raise an ``AttributeError``
+    if the data passed to your accessor has an incorrect dtype.
+
+    >>> pd.Series(['a', 'b']).dt
+    Traceback (most recent call last):
+    ...
+    AttributeError: Can only use .dt accessor with datetimelike values
+
+    Examples
+    --------
+    In your library code::
+
+        import pandas as pd
+
+        @pd.api.extensions.register_dataframe_accessor("geo")
+        class GeoAccessor:
+            def __init__(self, pandas_obj):
+                self._obj = pandas_obj
+
+            @property
+            def center(self):
+                # return the geographic center point of this DataFrame
+                lat = self._obj.latitude
+                lon = self._obj.longitude
+                return (float(lon.mean()), float(lat.mean()))
+
+            def plot(self):
+                # plot this array's data on a map, e.g., using Cartopy
+                pass
+
+    Back in an interactive IPython session:
+
+        .. code-block:: ipython
+
+            In [1]: ds = pd.DataFrame({{"longitude": np.linspace(0, 10),
+               ...:                    "latitude": np.linspace(0, 20)}})
+            In [2]: ds.geo.center
+            Out[2]: (5.0, 10.0)
+            In [3]: ds.geo.plot()  # plots data on a map
+    """
+
+    def decorator(accessor):
+        if hasattr(cls, name):
+            warnings.warn(
+                f"registration of accessor {repr(accessor)} under name "
+                f"{repr(name)} for type {repr(cls)} is overriding a preexisting "
+                f"attribute with the same name.",
+                UserWarning,
+                stacklevel=find_stack_level(),
+            )
+        setattr(cls, name, CachedAccessor(name, accessor))
+        cls._accessors.add(name)
+        return accessor
+
+    return decorator
+
+
+@doc(_register_accessor, klass="DataFrame")
+def register_dataframe_accessor(name: str):
+    from pandas import DataFrame
+
+    return _register_accessor(name, DataFrame)
+
+
+@doc(_register_accessor, klass="Series")
+def register_series_accessor(name: str):
+    from pandas import Series
+
+    return _register_accessor(name, Series)
+
+
+@doc(_register_accessor, klass="Index")
+def register_index_accessor(name: str):
+    from pandas import Index
+
+    return _register_accessor(name, Index)

videollama2/lib/python3.10/site-packages/pandas/core/algorithms.py

@@ -0,0 +1,1747 @@
+"""
+Generic data algorithms. This module is experimental at the moment and not
+intended for public consumption
+"""
+from __future__ import annotations
+
+import decimal
+import operator
+from textwrap import dedent
+from typing import (
+    TYPE_CHECKING,
+    Literal,
+    cast,
+)
+import warnings
+
+import numpy as np
+
+from pandas._libs import (
+    algos,
+    hashtable as htable,
+    iNaT,
+    lib,
+)
+from pandas._typing import (
+    AnyArrayLike,
+    ArrayLike,
+    AxisInt,
+    DtypeObj,
+    TakeIndexer,
+    npt,
+)
+from pandas.util._decorators import doc
+from pandas.util._exceptions import find_stack_level
+
+from pandas.core.dtypes.cast import (
+    construct_1d_object_array_from_listlike,
+    np_find_common_type,
+)
+from pandas.core.dtypes.common import (
+    ensure_float64,
+    ensure_object,
+    ensure_platform_int,
+    is_array_like,
+    is_bool_dtype,
+    is_complex_dtype,
+    is_dict_like,
+    is_extension_array_dtype,
+    is_float_dtype,
+    is_integer,
+    is_integer_dtype,
+    is_list_like,
+    is_object_dtype,
+    is_signed_integer_dtype,
+    needs_i8_conversion,
+)
+from pandas.core.dtypes.concat import concat_compat
+from pandas.core.dtypes.dtypes import (
+    BaseMaskedDtype,
+    CategoricalDtype,
+    ExtensionDtype,
+    NumpyEADtype,
+)
+from pandas.core.dtypes.generic import (
+    ABCDatetimeArray,
+    ABCExtensionArray,
+    ABCIndex,
+    ABCMultiIndex,
+    ABCSeries,
+    ABCTimedeltaArray,
+)
+from pandas.core.dtypes.missing import (
+    isna,
+    na_value_for_dtype,
+)
+
+from pandas.core.array_algos.take import take_nd
+from pandas.core.construction import (
+    array as pd_array,
+    ensure_wrapped_if_datetimelike,
+    extract_array,
+)
+from pandas.core.indexers import validate_indices
+
+if TYPE_CHECKING:
+    from pandas._typing import (
+        ListLike,
+        NumpySorter,
+        NumpyValueArrayLike,
+    )
+
+    from pandas import (
+        Categorical,
+        Index,
+        Series,
+    )
+    from pandas.core.arrays import (
+        BaseMaskedArray,
+        ExtensionArray,
+    )
+
+
+# --------------- #
+# dtype access    #
+# --------------- #
+def _ensure_data(values: ArrayLike) -> np.ndarray:
+    """
+    routine to ensure that our data is of the correct
+    input dtype for lower-level routines
+
+    This will coerce:
+    - ints -> int64
+    - uint -> uint64
+    - bool -> uint8
+    - datetimelike -> i8
+    - datetime64tz -> i8 (in local tz)
+    - categorical -> codes
+
+    Parameters
+    ----------
+    values : np.ndarray or ExtensionArray
+
+    Returns
+    -------
+    np.ndarray
+    """
+
+    if not isinstance(values, ABCMultiIndex):
+        # extract_array would raise
+        values = extract_array(values, extract_numpy=True)
+
+    if is_object_dtype(values.dtype):
+        return ensure_object(np.asarray(values))
+
+    elif isinstance(values.dtype, BaseMaskedDtype):
+        # i.e. BooleanArray, FloatingArray, IntegerArray
+        values = cast("BaseMaskedArray", values)
+        if not values._hasna:
+            # No pd.NAs -> We can avoid an object-dtype cast (and copy) GH#41816
+            #  recurse to avoid re-implementing logic for eg bool->uint8
+            return _ensure_data(values._data)
+        return np.asarray(values)
+
+    elif isinstance(values.dtype, CategoricalDtype):
+        # NB: cases that go through here should NOT be using _reconstruct_data
+        #  on the back-end.
+        values = cast("Categorical", values)
+        return values.codes
+
+    elif is_bool_dtype(values.dtype):
+        if isinstance(values, np.ndarray):
+            # i.e. actually dtype == np.dtype("bool")
+            return np.asarray(values).view("uint8")
+        else:
+            # e.g. Sparse[bool, False]  # TODO: no test cases get here
+            return np.asarray(values).astype("uint8", copy=False)
+
+    elif is_integer_dtype(values.dtype):
+        return np.asarray(values)
+
+    elif is_float_dtype(values.dtype):
+        # Note: checking `values.dtype == "float128"` raises on Windows and 32bit
+        # error: Item "ExtensionDtype" of "Union[Any, ExtensionDtype, dtype[Any]]"
+        # has no attribute "itemsize"
+        if values.dtype.itemsize in [2, 12, 16]:  # type: ignore[union-attr]
+            # we dont (yet) have float128 hashtable support
+            return ensure_float64(values)
+        return np.asarray(values)
+
+    elif is_complex_dtype(values.dtype):
+        return cast(np.ndarray, values)
+
+    # datetimelike
+    elif needs_i8_conversion(values.dtype):
+        npvalues = values.view("i8")
+        npvalues = cast(np.ndarray, npvalues)
+        return npvalues
+
+    # we have failed, return object
+    values = np.asarray(values, dtype=object)
+    return ensure_object(values)
+
+
+def _reconstruct_data(
+    values: ArrayLike, dtype: DtypeObj, original: AnyArrayLike
+) -> ArrayLike:
+    """
+    reverse of _ensure_data
+
+    Parameters
+    ----------
+    values : np.ndarray or ExtensionArray
+    dtype : np.dtype or ExtensionDtype
+    original : AnyArrayLike
+
+    Returns
+    -------
+    ExtensionArray or np.ndarray
+    """
+    if isinstance(values, ABCExtensionArray) and values.dtype == dtype:
+        # Catch DatetimeArray/TimedeltaArray
+        return values
+
+    if not isinstance(dtype, np.dtype):
+        # i.e. ExtensionDtype; note we have ruled out above the possibility
+        #  that values.dtype == dtype
+        cls = dtype.construct_array_type()
+
+        values = cls._from_sequence(values, dtype=dtype)
+
+    else:
+        values = values.astype(dtype, copy=False)
+
+    return values
+
+
+def _ensure_arraylike(values, func_name: str) -> ArrayLike:
+    """
+    ensure that we are arraylike if not already
+    """
+    if not isinstance(values, (ABCIndex, ABCSeries, ABCExtensionArray, np.ndarray)):
+        # GH#52986
+        if func_name != "isin-targets":
+            # Make an exception for the comps argument in isin.
+            warnings.warn(
+                f"{func_name} with argument that is not not a Series, Index, "
+                "ExtensionArray, or np.ndarray is deprecated and will raise in a "
+                "future version.",
+                FutureWarning,
+                stacklevel=find_stack_level(),
+            )
+
+        inferred = lib.infer_dtype(values, skipna=False)
+        if inferred in ["mixed", "string", "mixed-integer"]:
+            # "mixed-integer" to ensure we do not cast ["ss", 42] to str GH#22160
+            if isinstance(values, tuple):
+                values = list(values)
+            values = construct_1d_object_array_from_listlike(values)
+        else:
+            values = np.asarray(values)
+    return values
+
+
+_hashtables = {
+    "complex128": htable.Complex128HashTable,
+    "complex64": htable.Complex64HashTable,
+    "float64": htable.Float64HashTable,
+    "float32": htable.Float32HashTable,
+    "uint64": htable.UInt64HashTable,
+    "uint32": htable.UInt32HashTable,
+    "uint16": htable.UInt16HashTable,
+    "uint8": htable.UInt8HashTable,
+    "int64": htable.Int64HashTable,
+    "int32": htable.Int32HashTable,
+    "int16": htable.Int16HashTable,
+    "int8": htable.Int8HashTable,
+    "string": htable.StringHashTable,
+    "object": htable.PyObjectHashTable,
+}
+
+
+def _get_hashtable_algo(values: np.ndarray):
+    """
+    Parameters
+    ----------
+    values : np.ndarray
+
+    Returns
+    -------
+    htable : HashTable subclass
+    values : ndarray
+    """
+    values = _ensure_data(values)
+
+    ndtype = _check_object_for_strings(values)
+    hashtable = _hashtables[ndtype]
+    return hashtable, values
+
+
+def _check_object_for_strings(values: np.ndarray) -> str:
+    """
+    Check if we can use string hashtable instead of object hashtable.
+
+    Parameters
+    ----------
+    values : ndarray
+
+    Returns
+    -------
+    str
+    """
+    ndtype = values.dtype.name
+    if ndtype == "object":
+        # it's cheaper to use a String Hash Table than Object; we infer
+        # including nulls because that is the only difference between
+        # StringHashTable and ObjectHashtable
+        if lib.is_string_array(values, skipna=False):
+            ndtype = "string"
+    return ndtype
+
+
+# --------------- #
+# top-level algos #
+# --------------- #
+
+
+def unique(values):
+    """
+    Return unique values based on a hash table.
+
+    Uniques are returned in order of appearance. This does NOT sort.
+
+    Significantly faster than numpy.unique for long enough sequences.
+    Includes NA values.
+
+    Parameters
+    ----------
+    values : 1d array-like
+
+    Returns
+    -------
+    numpy.ndarray or ExtensionArray
+
+        The return can be:
+
+        * Index : when the input is an Index
+        * Categorical : when the input is a Categorical dtype
+        * ndarray : when the input is a Series/ndarray
+
+        Return numpy.ndarray or ExtensionArray.
+
+    See Also
+    --------
+    Index.unique : Return unique values from an Index.
+    Series.unique : Return unique values of Series object.
+
+    Examples
+    --------
+    >>> pd.unique(pd.Series([2, 1, 3, 3]))
+    array([2, 1, 3])
+
+    >>> pd.unique(pd.Series([2] + [1] * 5))
+    array([2, 1])
+
+    >>> pd.unique(pd.Series([pd.Timestamp("20160101"), pd.Timestamp("20160101")]))
+    array(['2016-01-01T00:00:00.000000000'], dtype='datetime64[ns]')
+
+    >>> pd.unique(
+    ...     pd.Series(
+    ...         [
+    ...             pd.Timestamp("20160101", tz="US/Eastern"),
+    ...             pd.Timestamp("20160101", tz="US/Eastern"),
+    ...         ]
+    ...     )
+    ... )
+    <DatetimeArray>
+    ['2016-01-01 00:00:00-05:00']
+    Length: 1, dtype: datetime64[ns, US/Eastern]
+
+    >>> pd.unique(
+    ...     pd.Index(
+    ...         [
+    ...             pd.Timestamp("20160101", tz="US/Eastern"),
+    ...             pd.Timestamp("20160101", tz="US/Eastern"),
+    ...         ]
+    ...     )
+    ... )
+    DatetimeIndex(['2016-01-01 00:00:00-05:00'],
+            dtype='datetime64[ns, US/Eastern]',
+            freq=None)
+
+    >>> pd.unique(np.array(list("baabc"), dtype="O"))
+    array(['b', 'a', 'c'], dtype=object)
+
+    An unordered Categorical will return categories in the
+    order of appearance.
+
+    >>> pd.unique(pd.Series(pd.Categorical(list("baabc"))))
+    ['b', 'a', 'c']
+    Categories (3, object): ['a', 'b', 'c']
+
+    >>> pd.unique(pd.Series(pd.Categorical(list("baabc"), categories=list("abc"))))
+    ['b', 'a', 'c']
+    Categories (3, object): ['a', 'b', 'c']
+
+    An ordered Categorical preserves the category ordering.
+
+    >>> pd.unique(
+    ...     pd.Series(
+    ...         pd.Categorical(list("baabc"), categories=list("abc"), ordered=True)
+    ...     )
+    ... )
+    ['b', 'a', 'c']
+    Categories (3, object): ['a' < 'b' < 'c']
+
+    An array of tuples
+
+    >>> pd.unique(pd.Series([("a", "b"), ("b", "a"), ("a", "c"), ("b", "a")]).values)
+    array([('a', 'b'), ('b', 'a'), ('a', 'c')], dtype=object)
+    """
+    return unique_with_mask(values)
+
+
+def nunique_ints(values: ArrayLike) -> int:
+    """
+    Return the number of unique values for integer array-likes.
+
+    Significantly faster than pandas.unique for long enough sequences.
+    No checks are done to ensure input is integral.
+
+    Parameters
+    ----------
+    values : 1d array-like
+
+    Returns
+    -------
+    int : The number of unique values in ``values``
+    """
+    if len(values) == 0:
+        return 0
+    values = _ensure_data(values)
+    # bincount requires intp
+    result = (np.bincount(values.ravel().astype("intp")) != 0).sum()
+    return result
+
+
+def unique_with_mask(values, mask: npt.NDArray[np.bool_] | None = None):
+    """See algorithms.unique for docs. Takes a mask for masked arrays."""
+    values = _ensure_arraylike(values, func_name="unique")
+
+    if isinstance(values.dtype, ExtensionDtype):
+        # Dispatch to extension dtype's unique.
+        return values.unique()
+
+    original = values
+    hashtable, values = _get_hashtable_algo(values)
+
+    table = hashtable(len(values))
+    if mask is None:
+        uniques = table.unique(values)
+        uniques = _reconstruct_data(uniques, original.dtype, original)
+        return uniques
+
+    else:
+        uniques, mask = table.unique(values, mask=mask)
+        uniques = _reconstruct_data(uniques, original.dtype, original)
+        assert mask is not None  # for mypy
+        return uniques, mask.astype("bool")
+
+
+unique1d = unique
+
+
+_MINIMUM_COMP_ARR_LEN = 1_000_000
+
+
+def isin(comps: ListLike, values: ListLike) -> npt.NDArray[np.bool_]:
+    """
+    Compute the isin boolean array.
+
+    Parameters
+    ----------
+    comps : list-like
+    values : list-like
+
+    Returns
+    -------
+    ndarray[bool]
+        Same length as `comps`.
+    """
+    if not is_list_like(comps):
+        raise TypeError(
+            "only list-like objects are allowed to be passed "
+            f"to isin(), you passed a `{type(comps).__name__}`"
+        )
+    if not is_list_like(values):
+        raise TypeError(
+            "only list-like objects are allowed to be passed "
+            f"to isin(), you passed a `{type(values).__name__}`"
+        )
+
+    if not isinstance(values, (ABCIndex, ABCSeries, ABCExtensionArray, np.ndarray)):
+        orig_values = list(values)
+        values = _ensure_arraylike(orig_values, func_name="isin-targets")
+
+        if (
+            len(values) > 0
+            and values.dtype.kind in "iufcb"
+            and not is_signed_integer_dtype(comps)
+        ):
+            # GH#46485 Use object to avoid upcast to float64 later
+            # TODO: Share with _find_common_type_compat
+            values = construct_1d_object_array_from_listlike(orig_values)
+
+    elif isinstance(values, ABCMultiIndex):
+        # Avoid raising in extract_array
+        values = np.array(values)
+    else:
+        values = extract_array(values, extract_numpy=True, extract_range=True)
+
+    comps_array = _ensure_arraylike(comps, func_name="isin")
+    comps_array = extract_array(comps_array, extract_numpy=True)
+    if not isinstance(comps_array, np.ndarray):
+        # i.e. Extension Array
+        return comps_array.isin(values)
+
+    elif needs_i8_conversion(comps_array.dtype):
+        # Dispatch to DatetimeLikeArrayMixin.isin
+        return pd_array(comps_array).isin(values)
+    elif needs_i8_conversion(values.dtype) and not is_object_dtype(comps_array.dtype):
+        # e.g. comps_array are integers and values are datetime64s
+        return np.zeros(comps_array.shape, dtype=bool)
+        # TODO: not quite right ... Sparse/Categorical
+    elif needs_i8_conversion(values.dtype):
+        return isin(comps_array, values.astype(object))
+
+    elif isinstance(values.dtype, ExtensionDtype):
+        return isin(np.asarray(comps_array), np.asarray(values))
+
+    # GH16012
+    # Ensure np.isin doesn't get object types or it *may* throw an exception
+    # Albeit hashmap has O(1) look-up (vs. O(logn) in sorted array),
+    # isin is faster for small sizes
+    if (
+        len(comps_array) > _MINIMUM_COMP_ARR_LEN
+        and len(values) <= 26
+        and comps_array.dtype != object
+    ):
+        # If the values include nan we need to check for nan explicitly
+        # since np.nan it not equal to np.nan
+        if isna(values).any():
+
+            def f(c, v):
+                return np.logical_or(np.isin(c, v).ravel(), np.isnan(c))
+
+        else:
+            f = lambda a, b: np.isin(a, b).ravel()
+
+    else:
+        common = np_find_common_type(values.dtype, comps_array.dtype)
+        values = values.astype(common, copy=False)
+        comps_array = comps_array.astype(common, copy=False)
+        f = htable.ismember
+
+    return f(comps_array, values)
+
+
+def factorize_array(
+    values: np.ndarray,
+    use_na_sentinel: bool = True,
+    size_hint: int | None = None,
+    na_value: object = None,
+    mask: npt.NDArray[np.bool_] | None = None,
+) -> tuple[npt.NDArray[np.intp], np.ndarray]:
+    """
+    Factorize a numpy array to codes and uniques.
+
+    This doesn't do any coercion of types or unboxing before factorization.
+
+    Parameters
+    ----------
+    values : ndarray
+    use_na_sentinel : bool, default True
+        If True, the sentinel -1 will be used for NaN values. If False,
+        NaN values will be encoded as non-negative integers and will not drop the
+        NaN from the uniques of the values.
+    size_hint : int, optional
+        Passed through to the hashtable's 'get_labels' method
+    na_value : object, optional
+        A value in `values` to consider missing. Note: only use this
+        parameter when you know that you don't have any values pandas would
+        consider missing in the array (NaN for float data, iNaT for
+        datetimes, etc.).
+    mask : ndarray[bool], optional
+        If not None, the mask is used as indicator for missing values
+        (True = missing, False = valid) instead of `na_value` or
+        condition "val != val".
+
+    Returns
+    -------
+    codes : ndarray[np.intp]
+    uniques : ndarray
+    """
+    original = values
+    if values.dtype.kind in "mM":
+        # _get_hashtable_algo will cast dt64/td64 to i8 via _ensure_data, so we
+        #  need to do the same to na_value. We are assuming here that the passed
+        #  na_value is an appropriately-typed NaT.
+        # e.g. test_where_datetimelike_categorical
+        na_value = iNaT
+
+    hash_klass, values = _get_hashtable_algo(values)
+
+    table = hash_klass(size_hint or len(values))
+    uniques, codes = table.factorize(
+        values,
+        na_sentinel=-1,
+        na_value=na_value,
+        mask=mask,
+        ignore_na=use_na_sentinel,
+    )
+
+    # re-cast e.g. i8->dt64/td64, uint8->bool
+    uniques = _reconstruct_data(uniques, original.dtype, original)
+
+    codes = ensure_platform_int(codes)
+    return codes, uniques
+
+
+@doc(
+    values=dedent(
+        """\
+    values : sequence
+        A 1-D sequence. Sequences that aren't pandas objects are
+        coerced to ndarrays before factorization.
+    """
+    ),
+    sort=dedent(
+        """\
+    sort : bool, default False
+        Sort `uniques` and shuffle `codes` to maintain the
+        relationship.
+    """
+    ),
+    size_hint=dedent(
+        """\
+    size_hint : int, optional
+        Hint to the hashtable sizer.
+    """
+    ),
+)
+def factorize(
+    values,
+    sort: bool = False,
+    use_na_sentinel: bool = True,
+    size_hint: int | None = None,
+) -> tuple[np.ndarray, np.ndarray | Index]:
+    """
+    Encode the object as an enumerated type or categorical variable.
+
+    This method is useful for obtaining a numeric representation of an
+    array when all that matters is identifying distinct values. `factorize`
+    is available as both a top-level function :func:`pandas.factorize`,
+    and as a method :meth:`Series.factorize` and :meth:`Index.factorize`.
+
+    Parameters
+    ----------
+    {values}{sort}
+    use_na_sentinel : bool, default True
+        If True, the sentinel -1 will be used for NaN values. If False,
+        NaN values will be encoded as non-negative integers and will not drop the
+        NaN from the uniques of the values.
+
+        .. versionadded:: 1.5.0
+    {size_hint}\
+
+    Returns
+    -------
+    codes : ndarray
+        An integer ndarray that's an indexer into `uniques`.
+        ``uniques.take(codes)`` will have the same values as `values`.
+    uniques : ndarray, Index, or Categorical
+        The unique valid values. When `values` is Categorical, `uniques`
+        is a Categorical. When `values` is some other pandas object, an
+        `Index` is returned. Otherwise, a 1-D ndarray is returned.
+
+        .. note::
+
+           Even if there's a missing value in `values`, `uniques` will
+           *not* contain an entry for it.
+
+    See Also
+    --------
+    cut : Discretize continuous-valued array.
+    unique : Find the unique value in an array.
+
+    Notes
+    -----
+    Reference :ref:`the user guide <reshaping.factorize>` for more examples.
+
+    Examples
+    --------
+    These examples all show factorize as a top-level method like
+    ``pd.factorize(values)``. The results are identical for methods like
+    :meth:`Series.factorize`.
+
+    >>> codes, uniques = pd.factorize(np.array(['b', 'b', 'a', 'c', 'b'], dtype="O"))
+    >>> codes
+    array([0, 0, 1, 2, 0])
+    >>> uniques
+    array(['b', 'a', 'c'], dtype=object)
+
+    With ``sort=True``, the `uniques` will be sorted, and `codes` will be
+    shuffled so that the relationship is the maintained.
+
+    >>> codes, uniques = pd.factorize(np.array(['b', 'b', 'a', 'c', 'b'], dtype="O"),
+    ...                               sort=True)
+    >>> codes
+    array([1, 1, 0, 2, 1])
+    >>> uniques
+    array(['a', 'b', 'c'], dtype=object)
+
+    When ``use_na_sentinel=True`` (the default), missing values are indicated in
+    the `codes` with the sentinel value ``-1`` and missing values are not
+    included in `uniques`.
+
+    >>> codes, uniques = pd.factorize(np.array(['b', None, 'a', 'c', 'b'], dtype="O"))
+    >>> codes
+    array([ 0, -1,  1,  2,  0])
+    >>> uniques
+    array(['b', 'a', 'c'], dtype=object)
+
+    Thus far, we've only factorized lists (which are internally coerced to
+    NumPy arrays). When factorizing pandas objects, the type of `uniques`
+    will differ. For Categoricals, a `Categorical` is returned.
+
+    >>> cat = pd.Categorical(['a', 'a', 'c'], categories=['a', 'b', 'c'])
+    >>> codes, uniques = pd.factorize(cat)
+    >>> codes
+    array([0, 0, 1])
+    >>> uniques
+    ['a', 'c']
+    Categories (3, object): ['a', 'b', 'c']
+
+    Notice that ``'b'`` is in ``uniques.categories``, despite not being
+    present in ``cat.values``.
+
+    For all other pandas objects, an Index of the appropriate type is
+    returned.
+
+    >>> cat = pd.Series(['a', 'a', 'c'])
+    >>> codes, uniques = pd.factorize(cat)
+    >>> codes
+    array([0, 0, 1])
+    >>> uniques
+    Index(['a', 'c'], dtype='object')
+
+    If NaN is in the values, and we want to include NaN in the uniques of the
+    values, it can be achieved by setting ``use_na_sentinel=False``.
+
+    >>> values = np.array([1, 2, 1, np.nan])
+    >>> codes, uniques = pd.factorize(values)  # default: use_na_sentinel=True
+    >>> codes
+    array([ 0,  1,  0, -1])
+    >>> uniques
+    array([1., 2.])
+
+    >>> codes, uniques = pd.factorize(values, use_na_sentinel=False)
+    >>> codes
+    array([0, 1, 0, 2])
+    >>> uniques
+    array([ 1.,  2., nan])
+    """
+    # Implementation notes: This method is responsible for 3 things
+    # 1.) coercing data to array-like (ndarray, Index, extension array)
+    # 2.) factorizing codes and uniques
+    # 3.) Maybe boxing the uniques in an Index
+    #
+    # Step 2 is dispatched to extension types (like Categorical). They are
+    # responsible only for factorization. All data coercion, sorting and boxing
+    # should happen here.
+    if isinstance(values, (ABCIndex, ABCSeries)):
+        return values.factorize(sort=sort, use_na_sentinel=use_na_sentinel)
+
+    values = _ensure_arraylike(values, func_name="factorize")
+    original = values
+
+    if (
+        isinstance(values, (ABCDatetimeArray, ABCTimedeltaArray))
+        and values.freq is not None
+    ):
+        # The presence of 'freq' means we can fast-path sorting and know there
+        #  aren't NAs
+        codes, uniques = values.factorize(sort=sort)
+        return codes, uniques
+
+    elif not isinstance(values, np.ndarray):
+        # i.e. ExtensionArray
+        codes, uniques = values.factorize(use_na_sentinel=use_na_sentinel)
+
+    else:
+        values = np.asarray(values)  # convert DTA/TDA/MultiIndex
+
+        if not use_na_sentinel and values.dtype == object:
+            # factorize can now handle differentiating various types of null values.
+            # These can only occur when the array has object dtype.
+            # However, for backwards compatibility we only use the null for the
+            # provided dtype. This may be revisited in the future, see GH#48476.
+            null_mask = isna(values)
+            if null_mask.any():
+                na_value = na_value_for_dtype(values.dtype, compat=False)
+                # Don't modify (potentially user-provided) array
+                values = np.where(null_mask, na_value, values)
+
+        codes, uniques = factorize_array(
+            values,
+            use_na_sentinel=use_na_sentinel,
+            size_hint=size_hint,
+        )
+
+    if sort and len(uniques) > 0:
+        uniques, codes = safe_sort(
+            uniques,
+            codes,
+            use_na_sentinel=use_na_sentinel,
+            assume_unique=True,
+            verify=False,
+        )
+
+    uniques = _reconstruct_data(uniques, original.dtype, original)
+
+    return codes, uniques
+
+
+def value_counts(
+    values,
+    sort: bool = True,
+    ascending: bool = False,
+    normalize: bool = False,
+    bins=None,
+    dropna: bool = True,
+) -> Series:
+    """
+    Compute a histogram of the counts of non-null values.
+
+    Parameters
+    ----------
+    values : ndarray (1-d)
+    sort : bool, default True
+        Sort by values
+    ascending : bool, default False
+        Sort in ascending order
+    normalize: bool, default False
+        If True then compute a relative histogram
+    bins : integer, optional
+        Rather than count values, group them into half-open bins,
+        convenience for pd.cut, only works with numeric data
+    dropna : bool, default True
+        Don't include counts of NaN
+
+    Returns
+    -------
+    Series
+    """
+    warnings.warn(
+        # GH#53493
+        "pandas.value_counts is deprecated and will be removed in a "
+        "future version. Use pd.Series(obj).value_counts() instead.",
+        FutureWarning,
+        stacklevel=find_stack_level(),
+    )
+    return value_counts_internal(
+        values,
+        sort=sort,
+        ascending=ascending,
+        normalize=normalize,
+        bins=bins,
+        dropna=dropna,
+    )
+
+
+def value_counts_internal(
+    values,
+    sort: bool = True,
+    ascending: bool = False,
+    normalize: bool = False,
+    bins=None,
+    dropna: bool = True,
+) -> Series:
+    from pandas import (
+        Index,
+        Series,
+    )
+
+    index_name = getattr(values, "name", None)
+    name = "proportion" if normalize else "count"
+
+    if bins is not None:
+        from pandas.core.reshape.tile import cut
+
+        if isinstance(values, Series):
+            values = values._values
+
+        try:
+            ii = cut(values, bins, include_lowest=True)
+        except TypeError as err:
+            raise TypeError("bins argument only works with numeric data.") from err
+
+        # count, remove nulls (from the index), and but the bins
+        result = ii.value_counts(dropna=dropna)
+        result.name = name
+        result = result[result.index.notna()]
+        result.index = result.index.astype("interval")
+        result = result.sort_index()
+
+        # if we are dropna and we have NO values
+        if dropna and (result._values == 0).all():
+            result = result.iloc[0:0]
+
+        # normalizing is by len of all (regardless of dropna)
+        counts = np.array([len(ii)])
+
+    else:
+        if is_extension_array_dtype(values):
+            # handle Categorical and sparse,
+            result = Series(values, copy=False)._values.value_counts(dropna=dropna)
+            result.name = name
+            result.index.name = index_name
+            counts = result._values
+            if not isinstance(counts, np.ndarray):
+                # e.g. ArrowExtensionArray
+                counts = np.asarray(counts)
+
+        elif isinstance(values, ABCMultiIndex):
+            # GH49558
+            levels = list(range(values.nlevels))
+            result = (
+                Series(index=values, name=name)
+                .groupby(level=levels, dropna=dropna)
+                .size()
+            )
+            result.index.names = values.names
+            counts = result._values
+
+        else:
+            values = _ensure_arraylike(values, func_name="value_counts")
+            keys, counts, _ = value_counts_arraylike(values, dropna)
+            if keys.dtype == np.float16:
+                keys = keys.astype(np.float32)
+
+            # For backwards compatibility, we let Index do its normal type
+            #  inference, _except_ for if if infers from object to bool.
+            idx = Index(keys)
+            if idx.dtype == bool and keys.dtype == object:
+                idx = idx.astype(object)
+            elif (
+                idx.dtype != keys.dtype  # noqa: PLR1714  # # pylint: disable=R1714
+                and idx.dtype != "string[pyarrow_numpy]"
+            ):
+                warnings.warn(
+                    # GH#56161
+                    "The behavior of value_counts with object-dtype is deprecated. "
+                    "In a future version, this will *not* perform dtype inference "
+                    "on the resulting index. To retain the old behavior, use "
+                    "`result.index = result.index.infer_objects()`",
+                    FutureWarning,
+                    stacklevel=find_stack_level(),
+                )
+            idx.name = index_name
+
+            result = Series(counts, index=idx, name=name, copy=False)
+
+    if sort:
+        result = result.sort_values(ascending=ascending)
+
+    if normalize:
+        result = result / counts.sum()
+
+    return result
+
+
+# Called once from SparseArray, otherwise could be private
+def value_counts_arraylike(
+    values: np.ndarray, dropna: bool, mask: npt.NDArray[np.bool_] | None = None
+) -> tuple[ArrayLike, npt.NDArray[np.int64], int]:
+    """
+    Parameters
+    ----------
+    values : np.ndarray
+    dropna : bool
+    mask : np.ndarray[bool] or None, default None
+
+    Returns
+    -------
+    uniques : np.ndarray
+    counts : np.ndarray[np.int64]
+    """
+    original = values
+    values = _ensure_data(values)
+
+    keys, counts, na_counter = htable.value_count(values, dropna, mask=mask)
+
+    if needs_i8_conversion(original.dtype):
+        # datetime, timedelta, or period
+
+        if dropna:
+            mask = keys != iNaT
+            keys, counts = keys[mask], counts[mask]
+
+    res_keys = _reconstruct_data(keys, original.dtype, original)
+    return res_keys, counts, na_counter
+
+
+def duplicated(
+    values: ArrayLike,
+    keep: Literal["first", "last", False] = "first",
+    mask: npt.NDArray[np.bool_] | None = None,
+) -> npt.NDArray[np.bool_]:
+    """
+    Return boolean ndarray denoting duplicate values.
+
+    Parameters
+    ----------
+    values : np.ndarray or ExtensionArray
+        Array over which to check for duplicate values.
+    keep : {'first', 'last', False}, default 'first'
+        - ``first`` : Mark duplicates as ``True`` except for the first
+          occurrence.
+        - ``last`` : Mark duplicates as ``True`` except for the last
+          occurrence.
+        - False : Mark all duplicates as ``True``.
+    mask : ndarray[bool], optional
+        array indicating which elements to exclude from checking
+
+    Returns
+    -------
+    duplicated : ndarray[bool]
+    """
+    values = _ensure_data(values)
+    return htable.duplicated(values, keep=keep, mask=mask)
+
+
+def mode(
+    values: ArrayLike, dropna: bool = True, mask: npt.NDArray[np.bool_] | None = None
+) -> ArrayLike:
+    """
+    Returns the mode(s) of an array.
+
+    Parameters
+    ----------
+    values : array-like
+        Array over which to check for duplicate values.
+    dropna : bool, default True
+        Don't consider counts of NaN/NaT.
+
+    Returns
+    -------
+    np.ndarray or ExtensionArray
+    """
+    values = _ensure_arraylike(values, func_name="mode")
+    original = values
+
+    if needs_i8_conversion(values.dtype):
+        # Got here with ndarray; dispatch to DatetimeArray/TimedeltaArray.
+        values = ensure_wrapped_if_datetimelike(values)
+        values = cast("ExtensionArray", values)
+        return values._mode(dropna=dropna)
+
+    values = _ensure_data(values)
+
+    npresult, res_mask = htable.mode(values, dropna=dropna, mask=mask)
+    if res_mask is not None:
+        return npresult, res_mask  # type: ignore[return-value]
+
+    try:
+        npresult = np.sort(npresult)
+    except TypeError as err:
+        warnings.warn(
+            f"Unable to sort modes: {err}",
+            stacklevel=find_stack_level(),
+        )
+
+    result = _reconstruct_data(npresult, original.dtype, original)
+    return result
+
+
+def rank(
+    values: ArrayLike,
+    axis: AxisInt = 0,
+    method: str = "average",
+    na_option: str = "keep",
+    ascending: bool = True,
+    pct: bool = False,
+) -> npt.NDArray[np.float64]:
+    """
+    Rank the values along a given axis.
+
+    Parameters
+    ----------
+    values : np.ndarray or ExtensionArray
+        Array whose values will be ranked. The number of dimensions in this
+        array must not exceed 2.
+    axis : int, default 0
+        Axis over which to perform rankings.
+    method : {'average', 'min', 'max', 'first', 'dense'}, default 'average'
+        The method by which tiebreaks are broken during the ranking.
+    na_option : {'keep', 'top'}, default 'keep'
+        The method by which NaNs are placed in the ranking.
+        - ``keep``: rank each NaN value with a NaN ranking
+        - ``top``: replace each NaN with either +/- inf so that they
+                   there are ranked at the top
+    ascending : bool, default True
+        Whether or not the elements should be ranked in ascending order.
+    pct : bool, default False
+        Whether or not to the display the returned rankings in integer form
+        (e.g. 1, 2, 3) or in percentile form (e.g. 0.333..., 0.666..., 1).
+    """
+    is_datetimelike = needs_i8_conversion(values.dtype)
+    values = _ensure_data(values)
+
+    if values.ndim == 1:
+        ranks = algos.rank_1d(
+            values,
+            is_datetimelike=is_datetimelike,
+            ties_method=method,
+            ascending=ascending,
+            na_option=na_option,
+            pct=pct,
+        )
+    elif values.ndim == 2:
+        ranks = algos.rank_2d(
+            values,
+            axis=axis,
+            is_datetimelike=is_datetimelike,
+            ties_method=method,
+            ascending=ascending,
+            na_option=na_option,
+            pct=pct,
+        )
+    else:
+        raise TypeError("Array with ndim > 2 are not supported.")
+
+    return ranks
+
+
+# ---- #
+# take #
+# ---- #
+
+
+def take(
+    arr,
+    indices: TakeIndexer,
+    axis: AxisInt = 0,
+    allow_fill: bool = False,
+    fill_value=None,
+):
+    """
+    Take elements from an array.
+
+    Parameters
+    ----------
+    arr : array-like or scalar value
+        Non array-likes (sequences/scalars without a dtype) are coerced
+        to an ndarray.
+
+        .. deprecated:: 2.1.0
+            Passing an argument other than a numpy.ndarray, ExtensionArray,
+            Index, or Series is deprecated.
+
+    indices : sequence of int or one-dimensional np.ndarray of int
+        Indices to be taken.
+    axis : int, default 0
+        The axis over which to select values.
+    allow_fill : bool, default False
+        How to handle negative values in `indices`.
+
+        * False: negative values in `indices` indicate positional indices
+          from the right (the default). This is similar to :func:`numpy.take`.
+
+        * True: negative values in `indices` indicate
+          missing values. These values are set to `fill_value`. Any other
+          negative values raise a ``ValueError``.
+
+    fill_value : any, optional
+        Fill value to use for NA-indices when `allow_fill` is True.
+        This may be ``None``, in which case the default NA value for
+        the type (``self.dtype.na_value``) is used.
+
+        For multi-dimensional `arr`, each *element* is filled with
+        `fill_value`.
+
+    Returns
+    -------
+    ndarray or ExtensionArray
+        Same type as the input.
+
+    Raises
+    ------
+    IndexError
+        When `indices` is out of bounds for the array.
+    ValueError
+        When the indexer contains negative values other than ``-1``
+        and `allow_fill` is True.
+
+    Notes
+    -----
+    When `allow_fill` is False, `indices` may be whatever dimensionality
+    is accepted by NumPy for `arr`.
+
+    When `allow_fill` is True, `indices` should be 1-D.
+
+    See Also
+    --------
+    numpy.take : Take elements from an array along an axis.
+
+    Examples
+    --------
+    >>> import pandas as pd
+
+    With the default ``allow_fill=False``, negative numbers indicate
+    positional indices from the right.
+
+    >>> pd.api.extensions.take(np.array([10, 20, 30]), [0, 0, -1])
+    array([10, 10, 30])
+
+    Setting ``allow_fill=True`` will place `fill_value` in those positions.
+
+    >>> pd.api.extensions.take(np.array([10, 20, 30]), [0, 0, -1], allow_fill=True)
+    array([10., 10., nan])
+
+    >>> pd.api.extensions.take(np.array([10, 20, 30]), [0, 0, -1], allow_fill=True,
+    ...      fill_value=-10)
+    array([ 10,  10, -10])
+    """
+    if not isinstance(arr, (np.ndarray, ABCExtensionArray, ABCIndex, ABCSeries)):
+        # GH#52981
+        warnings.warn(
+            "pd.api.extensions.take accepting non-standard inputs is deprecated "
+            "and will raise in a future version. Pass either a numpy.ndarray, "
+            "ExtensionArray, Index, or Series instead.",
+            FutureWarning,
+            stacklevel=find_stack_level(),
+        )
+
+    if not is_array_like(arr):
+        arr = np.asarray(arr)
+
+    indices = ensure_platform_int(indices)
+
+    if allow_fill:
+        # Pandas style, -1 means NA
+        validate_indices(indices, arr.shape[axis])
+        result = take_nd(
+            arr, indices, axis=axis, allow_fill=True, fill_value=fill_value
+        )
+    else:
+        # NumPy style
+        result = arr.take(indices, axis=axis)
+    return result
+
+
+# ------------ #
+# searchsorted #
+# ------------ #
+
+
+def searchsorted(
+    arr: ArrayLike,
+    value: NumpyValueArrayLike | ExtensionArray,
+    side: Literal["left", "right"] = "left",
+    sorter: NumpySorter | None = None,
+) -> npt.NDArray[np.intp] | np.intp:
+    """
+    Find indices where elements should be inserted to maintain order.
+
+    Find the indices into a sorted array `arr` (a) such that, if the
+    corresponding elements in `value` were inserted before the indices,
+    the order of `arr` would be preserved.
+
+    Assuming that `arr` is sorted:
+
+    ======  ================================
+    `side`  returned index `i` satisfies
+    ======  ================================
+    left    ``arr[i-1] < value <= self[i]``
+    right   ``arr[i-1] <= value < self[i]``
+    ======  ================================
+
+    Parameters
+    ----------
+    arr: np.ndarray, ExtensionArray, Series
+        Input array. If `sorter` is None, then it must be sorted in
+        ascending order, otherwise `sorter` must be an array of indices
+        that sort it.
+    value : array-like or scalar
+        Values to insert into `arr`.
+    side : {'left', 'right'}, optional
+        If 'left', the index of the first suitable location found is given.
+        If 'right', return the last such index.  If there is no suitable
+        index, return either 0 or N (where N is the length of `self`).
+    sorter : 1-D array-like, optional
+        Optional array of integer indices that sort array a into ascending
+        order. They are typically the result of argsort.
+
+    Returns
+    -------
+    array of ints or int
+        If value is array-like, array of insertion points.
+        If value is scalar, a single integer.
+
+    See Also
+    --------
+    numpy.searchsorted : Similar method from NumPy.
+    """
+    if sorter is not None:
+        sorter = ensure_platform_int(sorter)
+
+    if (
+        isinstance(arr, np.ndarray)
+        and arr.dtype.kind in "iu"
+        and (is_integer(value) or is_integer_dtype(value))
+    ):
+        # if `arr` and `value` have different dtypes, `arr` would be
+        # recast by numpy, causing a slow search.
+        # Before searching below, we therefore try to give `value` the
+        # same dtype as `arr`, while guarding against integer overflows.
+        iinfo = np.iinfo(arr.dtype.type)
+        value_arr = np.array([value]) if is_integer(value) else np.array(value)
+        if (value_arr >= iinfo.min).all() and (value_arr <= iinfo.max).all():
+            # value within bounds, so no overflow, so can convert value dtype
+            # to dtype of arr
+            dtype = arr.dtype
+        else:
+            dtype = value_arr.dtype
+
+        if is_integer(value):
+            # We know that value is int
+            value = cast(int, dtype.type(value))
+        else:
+            value = pd_array(cast(ArrayLike, value), dtype=dtype)
+    else:
+        # E.g. if `arr` is an array with dtype='datetime64[ns]'
+        # and `value` is a pd.Timestamp, we may need to convert value
+        arr = ensure_wrapped_if_datetimelike(arr)
+
+    # Argument 1 to "searchsorted" of "ndarray" has incompatible type
+    # "Union[NumpyValueArrayLike, ExtensionArray]"; expected "NumpyValueArrayLike"
+    return arr.searchsorted(value, side=side, sorter=sorter)  # type: ignore[arg-type]
+
+
+# ---- #
+# diff #
+# ---- #
+
+_diff_special = {"float64", "float32", "int64", "int32", "int16", "int8"}
+
+
+def diff(arr, n: int, axis: AxisInt = 0):
+    """
+    difference of n between self,
+    analogous to s-s.shift(n)
+
+    Parameters
+    ----------
+    arr : ndarray or ExtensionArray
+    n : int
+        number of periods
+    axis : {0, 1}
+        axis to shift on
+    stacklevel : int, default 3
+        The stacklevel for the lost dtype warning.
+
+    Returns
+    -------
+    shifted
+    """
+
+    n = int(n)
+    na = np.nan
+    dtype = arr.dtype
+
+    is_bool = is_bool_dtype(dtype)
+    if is_bool:
+        op = operator.xor
+    else:
+        op = operator.sub
+
+    if isinstance(dtype, NumpyEADtype):
+        # NumpyExtensionArray cannot necessarily hold shifted versions of itself.
+        arr = arr.to_numpy()
+        dtype = arr.dtype
+
+    if not isinstance(arr, np.ndarray):
+        # i.e ExtensionArray
+        if hasattr(arr, f"__{op.__name__}__"):
+            if axis != 0:
+                raise ValueError(f"cannot diff {type(arr).__name__} on axis={axis}")
+            return op(arr, arr.shift(n))
+        else:
+            raise TypeError(
+                f"{type(arr).__name__} has no 'diff' method. "
+                "Convert to a suitable dtype prior to calling 'diff'."
+            )
+
+    is_timedelta = False
+    if arr.dtype.kind in "mM":
+        dtype = np.int64
+        arr = arr.view("i8")
+        na = iNaT
+        is_timedelta = True
+
+    elif is_bool:
+        # We have to cast in order to be able to hold np.nan
+        dtype = np.object_
+
+    elif dtype.kind in "iu":
+        # We have to cast in order to be able to hold np.nan
+
+        # int8, int16 are incompatible with float64,
+        # see https://github.com/cython/cython/issues/2646
+        if arr.dtype.name in ["int8", "int16"]:
+            dtype = np.float32
+        else:
+            dtype = np.float64
+
+    orig_ndim = arr.ndim
+    if orig_ndim == 1:
+        # reshape so we can always use algos.diff_2d
+        arr = arr.reshape(-1, 1)
+        # TODO: require axis == 0
+
+    dtype = np.dtype(dtype)
+    out_arr = np.empty(arr.shape, dtype=dtype)
+
+    na_indexer = [slice(None)] * 2
+    na_indexer[axis] = slice(None, n) if n >= 0 else slice(n, None)
+    out_arr[tuple(na_indexer)] = na
+
+    if arr.dtype.name in _diff_special:
+        # TODO: can diff_2d dtype specialization troubles be fixed by defining
+        #  out_arr inside diff_2d?
+        algos.diff_2d(arr, out_arr, n, axis, datetimelike=is_timedelta)
+    else:
+        # To keep mypy happy, _res_indexer is a list while res_indexer is
+        #  a tuple, ditto for lag_indexer.
+        _res_indexer = [slice(None)] * 2
+        _res_indexer[axis] = slice(n, None) if n >= 0 else slice(None, n)
+        res_indexer = tuple(_res_indexer)
+
+        _lag_indexer = [slice(None)] * 2
+        _lag_indexer[axis] = slice(None, -n) if n > 0 else slice(-n, None)
+        lag_indexer = tuple(_lag_indexer)
+
+        out_arr[res_indexer] = op(arr[res_indexer], arr[lag_indexer])
+
+    if is_timedelta:
+        out_arr = out_arr.view("timedelta64[ns]")
+
+    if orig_ndim == 1:
+        out_arr = out_arr[:, 0]
+    return out_arr
+
+
+# --------------------------------------------------------------------
+# Helper functions
+
+
+# Note: safe_sort is in algorithms.py instead of sorting.py because it is
+#  low-dependency, is used in this module, and used private methods from
+#  this module.
+def safe_sort(
+    values: Index | ArrayLike,
+    codes: npt.NDArray[np.intp] | None = None,
+    use_na_sentinel: bool = True,
+    assume_unique: bool = False,
+    verify: bool = True,
+) -> AnyArrayLike | tuple[AnyArrayLike, np.ndarray]:
+    """
+    Sort ``values`` and reorder corresponding ``codes``.
+
+    ``values`` should be unique if ``codes`` is not None.
+    Safe for use with mixed types (int, str), orders ints before strs.
+
+    Parameters
+    ----------
+    values : list-like
+        Sequence; must be unique if ``codes`` is not None.
+    codes : np.ndarray[intp] or None, default None
+        Indices to ``values``. All out of bound indices are treated as
+        "not found" and will be masked with ``-1``.
+    use_na_sentinel : bool, default True
+        If True, the sentinel -1 will be used for NaN values. If False,
+        NaN values will be encoded as non-negative integers and will not drop the
+        NaN from the uniques of the values.
+    assume_unique : bool, default False
+        When True, ``values`` are assumed to be unique, which can speed up
+        the calculation. Ignored when ``codes`` is None.
+    verify : bool, default True
+        Check if codes are out of bound for the values and put out of bound
+        codes equal to ``-1``. If ``verify=False``, it is assumed there
+        are no out of bound codes. Ignored when ``codes`` is None.
+
+    Returns
+    -------
+    ordered : AnyArrayLike
+        Sorted ``values``
+    new_codes : ndarray
+        Reordered ``codes``; returned when ``codes`` is not None.
+
+    Raises
+    ------
+    TypeError
+        * If ``values`` is not list-like or if ``codes`` is neither None
+        nor list-like
+        * If ``values`` cannot be sorted
+    ValueError
+        * If ``codes`` is not None and ``values`` contain duplicates.
+    """
+    if not isinstance(values, (np.ndarray, ABCExtensionArray, ABCIndex)):
+        raise TypeError(
+            "Only np.ndarray, ExtensionArray, and Index objects are allowed to "
+            "be passed to safe_sort as values"
+        )
+
+    sorter = None
+    ordered: AnyArrayLike
+
+    if (
+        not isinstance(values.dtype, ExtensionDtype)
+        and lib.infer_dtype(values, skipna=False) == "mixed-integer"
+    ):
+        ordered = _sort_mixed(values)
+    else:
+        try:
+            sorter = values.argsort()
+            ordered = values.take(sorter)
+        except (TypeError, decimal.InvalidOperation):
+            # Previous sorters failed or were not applicable, try `_sort_mixed`
+            # which would work, but which fails for special case of 1d arrays
+            # with tuples.
+            if values.size and isinstance(values[0], tuple):
+                # error: Argument 1 to "_sort_tuples" has incompatible type
+                # "Union[Index, ExtensionArray, ndarray[Any, Any]]"; expected
+                # "ndarray[Any, Any]"
+                ordered = _sort_tuples(values)  # type: ignore[arg-type]
+            else:
+                ordered = _sort_mixed(values)
+
+    # codes:
+
+    if codes is None:
+        return ordered
+
+    if not is_list_like(codes):
+        raise TypeError(
+            "Only list-like objects or None are allowed to "
+            "be passed to safe_sort as codes"
+        )
+    codes = ensure_platform_int(np.asarray(codes))
+
+    if not assume_unique and not len(unique(values)) == len(values):
+        raise ValueError("values should be unique if codes is not None")
+
+    if sorter is None:
+        # mixed types
+        # error: Argument 1 to "_get_hashtable_algo" has incompatible type
+        # "Union[Index, ExtensionArray, ndarray[Any, Any]]"; expected
+        # "ndarray[Any, Any]"
+        hash_klass, values = _get_hashtable_algo(values)  # type: ignore[arg-type]
+        t = hash_klass(len(values))
+        t.map_locations(values)
+        sorter = ensure_platform_int(t.lookup(ordered))
+
+    if use_na_sentinel:
+        # take_nd is faster, but only works for na_sentinels of -1
+        order2 = sorter.argsort()
+        if verify:
+            mask = (codes < -len(values)) | (codes >= len(values))
+            codes[mask] = 0
+        else:
+            mask = None
+        new_codes = take_nd(order2, codes, fill_value=-1)
+    else:
+        reverse_indexer = np.empty(len(sorter), dtype=int)
+        reverse_indexer.put(sorter, np.arange(len(sorter)))
+        # Out of bound indices will be masked with `-1` next, so we
+        # may deal with them here without performance loss using `mode='wrap'`
+        new_codes = reverse_indexer.take(codes, mode="wrap")
+
+        if use_na_sentinel:
+            mask = codes == -1
+            if verify:
+                mask = mask | (codes < -len(values)) | (codes >= len(values))
+
+    if use_na_sentinel and mask is not None:
+        np.putmask(new_codes, mask, -1)
+
+    return ordered, ensure_platform_int(new_codes)
+
+
+def _sort_mixed(values) -> AnyArrayLike:
+    """order ints before strings before nulls in 1d arrays"""
+    str_pos = np.array([isinstance(x, str) for x in values], dtype=bool)
+    null_pos = np.array([isna(x) for x in values], dtype=bool)
+    num_pos = ~str_pos & ~null_pos
+    str_argsort = np.argsort(values[str_pos])
+    num_argsort = np.argsort(values[num_pos])
+    # convert boolean arrays to positional indices, then order by underlying values
+    str_locs = str_pos.nonzero()[0].take(str_argsort)
+    num_locs = num_pos.nonzero()[0].take(num_argsort)
+    null_locs = null_pos.nonzero()[0]
+    locs = np.concatenate([num_locs, str_locs, null_locs])
+    return values.take(locs)
+
+
+def _sort_tuples(values: np.ndarray) -> np.ndarray:
+    """
+    Convert array of tuples (1d) to array of arrays (2d).
+    We need to keep the columns separately as they contain different types and
+    nans (can't use `np.sort` as it may fail when str and nan are mixed in a
+    column as types cannot be compared).
+    """
+    from pandas.core.internals.construction import to_arrays
+    from pandas.core.sorting import lexsort_indexer
+
+    arrays, _ = to_arrays(values, None)
+    indexer = lexsort_indexer(arrays, orders=True)
+    return values[indexer]
+
+
+def union_with_duplicates(
+    lvals: ArrayLike | Index, rvals: ArrayLike | Index
+) -> ArrayLike | Index:
+    """
+    Extracts the union from lvals and rvals with respect to duplicates and nans in
+    both arrays.
+
+    Parameters
+    ----------
+    lvals: np.ndarray or ExtensionArray
+        left values which is ordered in front.
+    rvals: np.ndarray or ExtensionArray
+        right values ordered after lvals.
+
+    Returns
+    -------
+    np.ndarray or ExtensionArray
+        Containing the unsorted union of both arrays.
+
+    Notes
+    -----
+    Caller is responsible for ensuring lvals.dtype == rvals.dtype.
+    """
+    from pandas import Series
+
+    with warnings.catch_warnings():
+        # filter warning from object dtype inference; we will end up discarding
+        # the index here, so the deprecation does not affect the end result here.
+        warnings.filterwarnings(
+            "ignore",
+            "The behavior of value_counts with object-dtype is deprecated",
+            category=FutureWarning,
+        )
+        l_count = value_counts_internal(lvals, dropna=False)
+        r_count = value_counts_internal(rvals, dropna=False)
+    l_count, r_count = l_count.align(r_count, fill_value=0)
+    final_count = np.maximum(l_count.values, r_count.values)
+    final_count = Series(final_count, index=l_count.index, dtype="int", copy=False)
+    if isinstance(lvals, ABCMultiIndex) and isinstance(rvals, ABCMultiIndex):
+        unique_vals = lvals.append(rvals).unique()
+    else:
+        if isinstance(lvals, ABCIndex):
+            lvals = lvals._values
+        if isinstance(rvals, ABCIndex):
+            rvals = rvals._values
+        # error: List item 0 has incompatible type "Union[ExtensionArray,
+        # ndarray[Any, Any], Index]"; expected "Union[ExtensionArray,
+        # ndarray[Any, Any]]"
+        combined = concat_compat([lvals, rvals])  # type: ignore[list-item]
+        unique_vals = unique(combined)
+        unique_vals = ensure_wrapped_if_datetimelike(unique_vals)
+    repeats = final_count.reindex(unique_vals).values
+    return np.repeat(unique_vals, repeats)
+
+
+def map_array(
+    arr: ArrayLike,
+    mapper,
+    na_action: Literal["ignore"] | None = None,
+    convert: bool = True,
+) -> np.ndarray | ExtensionArray | Index:
+    """
+    Map values using an input mapping or function.
+
+    Parameters
+    ----------
+    mapper : function, dict, or Series
+        Mapping correspondence.
+    na_action : {None, 'ignore'}, default None
+        If 'ignore', propagate NA values, without passing them to the
+        mapping correspondence.
+    convert : bool, default True
+        Try to find better dtype for elementwise function results. If
+        False, leave as dtype=object.
+
+    Returns
+    -------
+    Union[ndarray, Index, ExtensionArray]
+        The output of the mapping function applied to the array.
+        If the function returns a tuple with more than one element
+        a MultiIndex will be returned.
+    """
+    if na_action not in (None, "ignore"):
+        msg = f"na_action must either be 'ignore' or None, {na_action} was passed"
+        raise ValueError(msg)
+
+    # we can fastpath dict/Series to an efficient map
+    # as we know that we are not going to have to yield
+    # python types
+    if is_dict_like(mapper):
+        if isinstance(mapper, dict) and hasattr(mapper, "__missing__"):
+            # If a dictionary subclass defines a default value method,
+            # convert mapper to a lookup function (GH #15999).
+            dict_with_default = mapper
+            mapper = lambda x: dict_with_default[
+                np.nan if isinstance(x, float) and np.isnan(x) else x
+            ]
+        else:
+            # Dictionary does not have a default. Thus it's safe to
+            # convert to an Series for efficiency.
+            # we specify the keys here to handle the
+            # possibility that they are tuples
+
+            # The return value of mapping with an empty mapper is
+            # expected to be pd.Series(np.nan, ...). As np.nan is
+            # of dtype float64 the return value of this method should
+            # be float64 as well
+            from pandas import Series
+
+            if len(mapper) == 0:
+                mapper = Series(mapper, dtype=np.float64)
+            else:
+                mapper = Series(mapper)
+
+    if isinstance(mapper, ABCSeries):
+        if na_action == "ignore":
+            mapper = mapper[mapper.index.notna()]
+
+        # Since values were input this means we came from either
+        # a dict or a series and mapper should be an index
+        indexer = mapper.index.get_indexer(arr)
+        new_values = take_nd(mapper._values, indexer)
+
+        return new_values
+
+    if not len(arr):
+        return arr.copy()
+
+    # we must convert to python types
+    values = arr.astype(object, copy=False)
+    if na_action is None:
+        return lib.map_infer(values, mapper, convert=convert)
+    else:
+        return lib.map_infer_mask(
+            values, mapper, mask=isna(values).view(np.uint8), convert=convert
+        )

videollama2/lib/python3.10/site-packages/pandas/core/api.py

@@ -0,0 +1,140 @@
+from pandas._libs import (
+    NaT,
+    Period,
+    Timedelta,
+    Timestamp,
+)
+from pandas._libs.missing import NA
+
+from pandas.core.dtypes.dtypes import (
+    ArrowDtype,
+    CategoricalDtype,
+    DatetimeTZDtype,
+    IntervalDtype,
+    PeriodDtype,
+)
+from pandas.core.dtypes.missing import (
+    isna,
+    isnull,
+    notna,
+    notnull,
+)
+
+from pandas.core.algorithms import (
+    factorize,
+    unique,
+    value_counts,
+)
+from pandas.core.arrays import Categorical
+from pandas.core.arrays.boolean import BooleanDtype
+from pandas.core.arrays.floating import (
+    Float32Dtype,
+    Float64Dtype,
+)
+from pandas.core.arrays.integer import (
+    Int8Dtype,
+    Int16Dtype,
+    Int32Dtype,
+    Int64Dtype,
+    UInt8Dtype,
+    UInt16Dtype,
+    UInt32Dtype,
+    UInt64Dtype,
+)
+from pandas.core.arrays.string_ import StringDtype
+from pandas.core.construction import array
+from pandas.core.flags import Flags
+from pandas.core.groupby import (
+    Grouper,
+    NamedAgg,
+)
+from pandas.core.indexes.api import (
+    CategoricalIndex,
+    DatetimeIndex,
+    Index,
+    IntervalIndex,
+    MultiIndex,
+    PeriodIndex,
+    RangeIndex,
+    TimedeltaIndex,
+)
+from pandas.core.indexes.datetimes import (
+    bdate_range,
+    date_range,
+)
+from pandas.core.indexes.interval import (
+    Interval,
+    interval_range,
+)
+from pandas.core.indexes.period import period_range
+from pandas.core.indexes.timedeltas import timedelta_range
+from pandas.core.indexing import IndexSlice
+from pandas.core.series import Series
+from pandas.core.tools.datetimes import to_datetime
+from pandas.core.tools.numeric import to_numeric
+from pandas.core.tools.timedeltas import to_timedelta
+
+from pandas.io.formats.format import set_eng_float_format
+from pandas.tseries.offsets import DateOffset
+
+# DataFrame needs to be imported after NamedAgg to avoid a circular import
+from pandas.core.frame import DataFrame  # isort:skip
+
+__all__ = [
+    "array",
+    "ArrowDtype",
+    "bdate_range",
+    "BooleanDtype",
+    "Categorical",
+    "CategoricalDtype",
+    "CategoricalIndex",
+    "DataFrame",
+    "DateOffset",
+    "date_range",
+    "DatetimeIndex",
+    "DatetimeTZDtype",
+    "factorize",
+    "Flags",
+    "Float32Dtype",
+    "Float64Dtype",
+    "Grouper",
+    "Index",
+    "IndexSlice",
+    "Int16Dtype",
+    "Int32Dtype",
+    "Int64Dtype",
+    "Int8Dtype",
+    "Interval",
+    "IntervalDtype",
+    "IntervalIndex",
+    "interval_range",
+    "isna",
+    "isnull",
+    "MultiIndex",
+    "NA",
+    "NamedAgg",
+    "NaT",
+    "notna",
+    "notnull",
+    "Period",
+    "PeriodDtype",
+    "PeriodIndex",
+    "period_range",
+    "RangeIndex",
+    "Series",
+    "set_eng_float_format",
+    "StringDtype",
+    "Timedelta",
+    "TimedeltaIndex",
+    "timedelta_range",
+    "Timestamp",
+    "to_datetime",
+    "to_numeric",
+    "to_timedelta",
+    "UInt16Dtype",
+    "UInt32Dtype",
+    "UInt64Dtype",
+    "UInt8Dtype",
+    "unique",
+    "value_counts",
+]

videollama2/lib/python3.10/site-packages/pandas/core/missing.py

@@ -0,0 +1,1158 @@
+"""
+Routines for filling missing data.
+"""
+from __future__ import annotations
+
+from functools import wraps
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Literal,
+    cast,
+    overload,
+)
+
+import numpy as np
+
+from pandas._libs import (
+    NaT,
+    algos,
+    lib,
+)
+from pandas._typing import (
+    ArrayLike,
+    AxisInt,
+    F,
+    ReindexMethod,
+    npt,
+)
+from pandas.compat._optional import import_optional_dependency
+
+from pandas.core.dtypes.cast import infer_dtype_from
+from pandas.core.dtypes.common import (
+    is_array_like,
+    is_bool_dtype,
+    is_numeric_dtype,
+    is_numeric_v_string_like,
+    is_object_dtype,
+    needs_i8_conversion,
+)
+from pandas.core.dtypes.dtypes import DatetimeTZDtype
+from pandas.core.dtypes.missing import (
+    is_valid_na_for_dtype,
+    isna,
+    na_value_for_dtype,
+)
+
+if TYPE_CHECKING:
+    from pandas import Index
+
+
+def check_value_size(value, mask: npt.NDArray[np.bool_], length: int):
+    """
+    Validate the size of the values passed to ExtensionArray.fillna.
+    """
+    if is_array_like(value):
+        if len(value) != length:
+            raise ValueError(
+                f"Length of 'value' does not match. Got ({len(value)}) "
+                f" expected {length}"
+            )
+        value = value[mask]
+
+    return value
+
+
+def mask_missing(arr: ArrayLike, values_to_mask) -> npt.NDArray[np.bool_]:
+    """
+    Return a masking array of same size/shape as arr
+    with entries equaling any member of values_to_mask set to True
+
+    Parameters
+    ----------
+    arr : ArrayLike
+    values_to_mask: list, tuple, or scalar
+
+    Returns
+    -------
+    np.ndarray[bool]
+    """
+    # When called from Block.replace/replace_list, values_to_mask is a scalar
+    #  known to be holdable by arr.
+    # When called from Series._single_replace, values_to_mask is tuple or list
+    dtype, values_to_mask = infer_dtype_from(values_to_mask)
+
+    if isinstance(dtype, np.dtype):
+        values_to_mask = np.array(values_to_mask, dtype=dtype)
+    else:
+        cls = dtype.construct_array_type()
+        if not lib.is_list_like(values_to_mask):
+            values_to_mask = [values_to_mask]
+        values_to_mask = cls._from_sequence(values_to_mask, dtype=dtype, copy=False)
+
+    potential_na = False
+    if is_object_dtype(arr.dtype):
+        # pre-compute mask to avoid comparison to NA
+        potential_na = True
+        arr_mask = ~isna(arr)
+
+    na_mask = isna(values_to_mask)
+    nonna = values_to_mask[~na_mask]
+
+    # GH 21977
+    mask = np.zeros(arr.shape, dtype=bool)
+    if (
+        is_numeric_dtype(arr.dtype)
+        and not is_bool_dtype(arr.dtype)
+        and is_bool_dtype(nonna.dtype)
+    ):
+        pass
+    elif (
+        is_bool_dtype(arr.dtype)
+        and is_numeric_dtype(nonna.dtype)
+        and not is_bool_dtype(nonna.dtype)
+    ):
+        pass
+    else:
+        for x in nonna:
+            if is_numeric_v_string_like(arr, x):
+                # GH#29553 prevent numpy deprecation warnings
+                pass
+            else:
+                if potential_na:
+                    new_mask = np.zeros(arr.shape, dtype=np.bool_)
+                    new_mask[arr_mask] = arr[arr_mask] == x
+                else:
+                    new_mask = arr == x
+
+                    if not isinstance(new_mask, np.ndarray):
+                        # usually BooleanArray
+                        new_mask = new_mask.to_numpy(dtype=bool, na_value=False)
+                mask |= new_mask
+
+    if na_mask.any():
+        mask |= isna(arr)
+
+    return mask
+
+
+@overload
+def clean_fill_method(
+    method: Literal["ffill", "pad", "bfill", "backfill"],
+    *,
+    allow_nearest: Literal[False] = ...,
+) -> Literal["pad", "backfill"]:
+    ...
+
+
+@overload
+def clean_fill_method(
+    method: Literal["ffill", "pad", "bfill", "backfill", "nearest"],
+    *,
+    allow_nearest: Literal[True],
+) -> Literal["pad", "backfill", "nearest"]:
+    ...
+
+
+def clean_fill_method(
+    method: Literal["ffill", "pad", "bfill", "backfill", "nearest"],
+    *,
+    allow_nearest: bool = False,
+) -> Literal["pad", "backfill", "nearest"]:
+    if isinstance(method, str):
+        # error: Incompatible types in assignment (expression has type "str", variable
+        # has type "Literal['ffill', 'pad', 'bfill', 'backfill', 'nearest']")
+        method = method.lower()  # type: ignore[assignment]
+        if method == "ffill":
+            method = "pad"
+        elif method == "bfill":
+            method = "backfill"
+
+    valid_methods = ["pad", "backfill"]
+    expecting = "pad (ffill) or backfill (bfill)"
+    if allow_nearest:
+        valid_methods.append("nearest")
+        expecting = "pad (ffill), backfill (bfill) or nearest"
+    if method not in valid_methods:
+        raise ValueError(f"Invalid fill method. Expecting {expecting}. Got {method}")
+    return method
+
+
+# interpolation methods that dispatch to np.interp
+
+NP_METHODS = ["linear", "time", "index", "values"]
+
+# interpolation methods that dispatch to _interpolate_scipy_wrapper
+
+SP_METHODS = [
+    "nearest",
+    "zero",
+    "slinear",
+    "quadratic",
+    "cubic",
+    "barycentric",
+    "krogh",
+    "spline",
+    "polynomial",
+    "from_derivatives",
+    "piecewise_polynomial",
+    "pchip",
+    "akima",
+    "cubicspline",
+]
+
+
+def clean_interp_method(method: str, index: Index, **kwargs) -> str:
+    order = kwargs.get("order")
+
+    if method in ("spline", "polynomial") and order is None:
+        raise ValueError("You must specify the order of the spline or polynomial.")
+
+    valid = NP_METHODS + SP_METHODS
+    if method not in valid:
+        raise ValueError(f"method must be one of {valid}. Got '{method}' instead.")
+
+    if method in ("krogh", "piecewise_polynomial", "pchip"):
+        if not index.is_monotonic_increasing:
+            raise ValueError(
+                f"{method} interpolation requires that the index be monotonic."
+            )
+
+    return method
+
+
+def find_valid_index(how: str, is_valid: npt.NDArray[np.bool_]) -> int | None:
+    """
+    Retrieves the positional index of the first valid value.
+
+    Parameters
+    ----------
+    how : {'first', 'last'}
+        Use this parameter to change between the first or last valid index.
+    is_valid: np.ndarray
+        Mask to find na_values.
+
+    Returns
+    -------
+    int or None
+    """
+    assert how in ["first", "last"]
+
+    if len(is_valid) == 0:  # early stop
+        return None
+
+    if is_valid.ndim == 2:
+        is_valid = is_valid.any(axis=1)  # reduce axis 1
+
+    if how == "first":
+        idxpos = is_valid[::].argmax()
+
+    elif how == "last":
+        idxpos = len(is_valid) - 1 - is_valid[::-1].argmax()
+
+    chk_notna = is_valid[idxpos]
+
+    if not chk_notna:
+        return None
+    # Incompatible return value type (got "signedinteger[Any]",
+    # expected "Optional[int]")
+    return idxpos  # type: ignore[return-value]
+
+
+def validate_limit_direction(
+    limit_direction: str,
+) -> Literal["forward", "backward", "both"]:
+    valid_limit_directions = ["forward", "backward", "both"]
+    limit_direction = limit_direction.lower()
+    if limit_direction not in valid_limit_directions:
+        raise ValueError(
+            "Invalid limit_direction: expecting one of "
+            f"{valid_limit_directions}, got '{limit_direction}'."
+        )
+    # error: Incompatible return value type (got "str", expected
+    # "Literal['forward', 'backward', 'both']")
+    return limit_direction  # type: ignore[return-value]
+
+
+def validate_limit_area(limit_area: str | None) -> Literal["inside", "outside"] | None:
+    if limit_area is not None:
+        valid_limit_areas = ["inside", "outside"]
+        limit_area = limit_area.lower()
+        if limit_area not in valid_limit_areas:
+            raise ValueError(
+                f"Invalid limit_area: expecting one of {valid_limit_areas}, got "
+                f"{limit_area}."
+            )
+    # error: Incompatible return value type (got "Optional[str]", expected
+    # "Optional[Literal['inside', 'outside']]")
+    return limit_area  # type: ignore[return-value]
+
+
+def infer_limit_direction(
+    limit_direction: Literal["backward", "forward", "both"] | None, method: str
+) -> Literal["backward", "forward", "both"]:
+    # Set `limit_direction` depending on `method`
+    if limit_direction is None:
+        if method in ("backfill", "bfill"):
+            limit_direction = "backward"
+        else:
+            limit_direction = "forward"
+    else:
+        if method in ("pad", "ffill") and limit_direction != "forward":
+            raise ValueError(
+                f"`limit_direction` must be 'forward' for method `{method}`"
+            )
+        if method in ("backfill", "bfill") and limit_direction != "backward":
+            raise ValueError(
+                f"`limit_direction` must be 'backward' for method `{method}`"
+            )
+    return limit_direction
+
+
+def get_interp_index(method, index: Index) -> Index:
+    # create/use the index
+    if method == "linear":
+        # prior default
+        from pandas import Index
+
+        index = Index(np.arange(len(index)))
+    else:
+        methods = {"index", "values", "nearest", "time"}
+        is_numeric_or_datetime = (
+            is_numeric_dtype(index.dtype)
+            or isinstance(index.dtype, DatetimeTZDtype)
+            or lib.is_np_dtype(index.dtype, "mM")
+        )
+        if method not in methods and not is_numeric_or_datetime:
+            raise ValueError(
+                "Index column must be numeric or datetime type when "
+                f"using {method} method other than linear. "
+                "Try setting a numeric or datetime index column before "
+                "interpolating."
+            )
+
+    if isna(index).any():
+        raise NotImplementedError(
+            "Interpolation with NaNs in the index "
+            "has not been implemented. Try filling "
+            "those NaNs before interpolating."
+        )
+    return index
+
+
+def interpolate_2d_inplace(
+    data: np.ndarray,  # floating dtype
+    index: Index,
+    axis: AxisInt,
+    method: str = "linear",
+    limit: int | None = None,
+    limit_direction: str = "forward",
+    limit_area: str | None = None,
+    fill_value: Any | None = None,
+    mask=None,
+    **kwargs,
+) -> None:
+    """
+    Column-wise application of _interpolate_1d.
+
+    Notes
+    -----
+    Alters 'data' in-place.
+
+    The signature does differ from _interpolate_1d because it only
+    includes what is needed for Block.interpolate.
+    """
+    # validate the interp method
+    clean_interp_method(method, index, **kwargs)
+
+    if is_valid_na_for_dtype(fill_value, data.dtype):
+        fill_value = na_value_for_dtype(data.dtype, compat=False)
+
+    if method == "time":
+        if not needs_i8_conversion(index.dtype):
+            raise ValueError(
+                "time-weighted interpolation only works "
+                "on Series or DataFrames with a "
+                "DatetimeIndex"
+            )
+        method = "values"
+
+    limit_direction = validate_limit_direction(limit_direction)
+    limit_area_validated = validate_limit_area(limit_area)
+
+    # default limit is unlimited GH #16282
+    limit = algos.validate_limit(nobs=None, limit=limit)
+
+    indices = _index_to_interp_indices(index, method)
+
+    def func(yvalues: np.ndarray) -> None:
+        # process 1-d slices in the axis direction
+
+        _interpolate_1d(
+            indices=indices,
+            yvalues=yvalues,
+            method=method,
+            limit=limit,
+            limit_direction=limit_direction,
+            limit_area=limit_area_validated,
+            fill_value=fill_value,
+            bounds_error=False,
+            mask=mask,
+            **kwargs,
+        )
+
+    # error: Argument 1 to "apply_along_axis" has incompatible type
+    # "Callable[[ndarray[Any, Any]], None]"; expected "Callable[...,
+    # Union[_SupportsArray[dtype[<nothing>]], Sequence[_SupportsArray
+    # [dtype[<nothing>]]], Sequence[Sequence[_SupportsArray[dtype[<nothing>]]]],
+    # Sequence[Sequence[Sequence[_SupportsArray[dtype[<nothing>]]]]],
+    # Sequence[Sequence[Sequence[Sequence[_SupportsArray[dtype[<nothing>]]]]]]]]"
+    np.apply_along_axis(func, axis, data)  # type: ignore[arg-type]
+
+
+def _index_to_interp_indices(index: Index, method: str) -> np.ndarray:
+    """
+    Convert Index to ndarray of indices to pass to NumPy/SciPy.
+    """
+    xarr = index._values
+    if needs_i8_conversion(xarr.dtype):
+        # GH#1646 for dt64tz
+        xarr = xarr.view("i8")
+
+    if method == "linear":
+        inds = xarr
+        inds = cast(np.ndarray, inds)
+    else:
+        inds = np.asarray(xarr)
+
+        if method in ("values", "index"):
+            if inds.dtype == np.object_:
+                inds = lib.maybe_convert_objects(inds)
+
+    return inds
+
+
+def _interpolate_1d(
+    indices: np.ndarray,
+    yvalues: np.ndarray,
+    method: str = "linear",
+    limit: int | None = None,
+    limit_direction: str = "forward",
+    limit_area: Literal["inside", "outside"] | None = None,
+    fill_value: Any | None = None,
+    bounds_error: bool = False,
+    order: int | None = None,
+    mask=None,
+    **kwargs,
+) -> None:
+    """
+    Logic for the 1-d interpolation.  The input
+    indices and yvalues will each be 1-d arrays of the same length.
+
+    Bounds_error is currently hardcoded to False since non-scipy ones don't
+    take it as an argument.
+
+    Notes
+    -----
+    Fills 'yvalues' in-place.
+    """
+    if mask is not None:
+        invalid = mask
+    else:
+        invalid = isna(yvalues)
+    valid = ~invalid
+
+    if not valid.any():
+        return
+
+    if valid.all():
+        return
+
+    # These are sets of index pointers to invalid values... i.e. {0, 1, etc...
+    all_nans = set(np.flatnonzero(invalid))
+
+    first_valid_index = find_valid_index(how="first", is_valid=valid)
+    if first_valid_index is None:  # no nan found in start
+        first_valid_index = 0
+    start_nans = set(range(first_valid_index))
+
+    last_valid_index = find_valid_index(how="last", is_valid=valid)
+    if last_valid_index is None:  # no nan found in end
+        last_valid_index = len(yvalues)
+    end_nans = set(range(1 + last_valid_index, len(valid)))
+
+    # Like the sets above, preserve_nans contains indices of invalid values,
+    # but in this case, it is the final set of indices that need to be
+    # preserved as NaN after the interpolation.
+
+    # For example if limit_direction='forward' then preserve_nans will
+    # contain indices of NaNs at the beginning of the series, and NaNs that
+    # are more than 'limit' away from the prior non-NaN.
+
+    # set preserve_nans based on direction using _interp_limit
+    preserve_nans: list | set
+    if limit_direction == "forward":
+        preserve_nans = start_nans | set(_interp_limit(invalid, limit, 0))
+    elif limit_direction == "backward":
+        preserve_nans = end_nans | set(_interp_limit(invalid, 0, limit))
+    else:
+        # both directions... just use _interp_limit
+        preserve_nans = set(_interp_limit(invalid, limit, limit))
+
+    # if limit_area is set, add either mid or outside indices
+    # to preserve_nans GH #16284
+    if limit_area == "inside":
+        # preserve NaNs on the outside
+        preserve_nans |= start_nans | end_nans
+    elif limit_area == "outside":
+        # preserve NaNs on the inside
+        mid_nans = all_nans - start_nans - end_nans
+        preserve_nans |= mid_nans
+
+    # sort preserve_nans and convert to list
+    preserve_nans = sorted(preserve_nans)
+
+    is_datetimelike = yvalues.dtype.kind in "mM"
+
+    if is_datetimelike:
+        yvalues = yvalues.view("i8")
+
+    if method in NP_METHODS:
+        # np.interp requires sorted X values, #21037
+
+        indexer = np.argsort(indices[valid])
+        yvalues[invalid] = np.interp(
+            indices[invalid], indices[valid][indexer], yvalues[valid][indexer]
+        )
+    else:
+        yvalues[invalid] = _interpolate_scipy_wrapper(
+            indices[valid],
+            yvalues[valid],
+            indices[invalid],
+            method=method,
+            fill_value=fill_value,
+            bounds_error=bounds_error,
+            order=order,
+            **kwargs,
+        )
+
+    if mask is not None:
+        mask[:] = False
+        mask[preserve_nans] = True
+    elif is_datetimelike:
+        yvalues[preserve_nans] = NaT.value
+    else:
+        yvalues[preserve_nans] = np.nan
+    return
+
+
+def _interpolate_scipy_wrapper(
+    x: np.ndarray,
+    y: np.ndarray,
+    new_x: np.ndarray,
+    method: str,
+    fill_value=None,
+    bounds_error: bool = False,
+    order=None,
+    **kwargs,
+):
+    """
+    Passed off to scipy.interpolate.interp1d. method is scipy's kind.
+    Returns an array interpolated at new_x.  Add any new methods to
+    the list in _clean_interp_method.
+    """
+    extra = f"{method} interpolation requires SciPy."
+    import_optional_dependency("scipy", extra=extra)
+    from scipy import interpolate
+
+    new_x = np.asarray(new_x)
+
+    # ignores some kwargs that could be passed along.
+    alt_methods = {
+        "barycentric": interpolate.barycentric_interpolate,
+        "krogh": interpolate.krogh_interpolate,
+        "from_derivatives": _from_derivatives,
+        "piecewise_polynomial": _from_derivatives,
+        "cubicspline": _cubicspline_interpolate,
+        "akima": _akima_interpolate,
+        "pchip": interpolate.pchip_interpolate,
+    }
+
+    interp1d_methods = [
+        "nearest",
+        "zero",
+        "slinear",
+        "quadratic",
+        "cubic",
+        "polynomial",
+    ]
+    if method in interp1d_methods:
+        if method == "polynomial":
+            kind = order
+        else:
+            kind = method
+        terp = interpolate.interp1d(
+            x, y, kind=kind, fill_value=fill_value, bounds_error=bounds_error
+        )
+        new_y = terp(new_x)
+    elif method == "spline":
+        # GH #10633, #24014
+        if isna(order) or (order <= 0):
+            raise ValueError(
+                f"order needs to be specified and greater than 0; got order: {order}"
+            )
+        terp = interpolate.UnivariateSpline(x, y, k=order, **kwargs)
+        new_y = terp(new_x)
+    else:
+        # GH 7295: need to be able to write for some reason
+        # in some circumstances: check all three
+        if not x.flags.writeable:
+            x = x.copy()
+        if not y.flags.writeable:
+            y = y.copy()
+        if not new_x.flags.writeable:
+            new_x = new_x.copy()
+        terp = alt_methods[method]
+        new_y = terp(x, y, new_x, **kwargs)
+    return new_y
+
+
+def _from_derivatives(
+    xi: np.ndarray,
+    yi: np.ndarray,
+    x: np.ndarray,
+    order=None,
+    der: int | list[int] | None = 0,
+    extrapolate: bool = False,
+):
+    """
+    Convenience function for interpolate.BPoly.from_derivatives.
+
+    Construct a piecewise polynomial in the Bernstein basis, compatible
+    with the specified values and derivatives at breakpoints.
+
+    Parameters
+    ----------
+    xi : array-like
+        sorted 1D array of x-coordinates
+    yi : array-like or list of array-likes
+        yi[i][j] is the j-th derivative known at xi[i]
+    order: None or int or array-like of ints. Default: None.
+        Specifies the degree of local polynomials. If not None, some
+        derivatives are ignored.
+    der : int or list
+        How many derivatives to extract; None for all potentially nonzero
+        derivatives (that is a number equal to the number of points), or a
+        list of derivatives to extract. This number includes the function
+        value as 0th derivative.
+     extrapolate : bool, optional
+        Whether to extrapolate to ouf-of-bounds points based on first and last
+        intervals, or to return NaNs. Default: True.
+
+    See Also
+    --------
+    scipy.interpolate.BPoly.from_derivatives
+
+    Returns
+    -------
+    y : scalar or array-like
+        The result, of length R or length M or M by R.
+    """
+    from scipy import interpolate
+
+    # return the method for compat with scipy version & backwards compat
+    method = interpolate.BPoly.from_derivatives
+    m = method(xi, yi.reshape(-1, 1), orders=order, extrapolate=extrapolate)
+
+    return m(x)
+
+
+def _akima_interpolate(
+    xi: np.ndarray,
+    yi: np.ndarray,
+    x: np.ndarray,
+    der: int | list[int] | None = 0,
+    axis: AxisInt = 0,
+):
+    """
+    Convenience function for akima interpolation.
+    xi and yi are arrays of values used to approximate some function f,
+    with ``yi = f(xi)``.
+
+    See `Akima1DInterpolator` for details.
+
+    Parameters
+    ----------
+    xi : np.ndarray
+        A sorted list of x-coordinates, of length N.
+    yi : np.ndarray
+        A 1-D array of real values.  `yi`'s length along the interpolation
+        axis must be equal to the length of `xi`. If N-D array, use axis
+        parameter to select correct axis.
+    x : np.ndarray
+        Of length M.
+    der : int, optional
+        How many derivatives to extract; None for all potentially
+        nonzero derivatives (that is a number equal to the number
+        of points), or a list of derivatives to extract. This number
+        includes the function value as 0th derivative.
+    axis : int, optional
+        Axis in the yi array corresponding to the x-coordinate values.
+
+    See Also
+    --------
+    scipy.interpolate.Akima1DInterpolator
+
+    Returns
+    -------
+    y : scalar or array-like
+        The result, of length R or length M or M by R,
+
+    """
+    from scipy import interpolate
+
+    P = interpolate.Akima1DInterpolator(xi, yi, axis=axis)
+
+    return P(x, nu=der)
+
+
+def _cubicspline_interpolate(
+    xi: np.ndarray,
+    yi: np.ndarray,
+    x: np.ndarray,
+    axis: AxisInt = 0,
+    bc_type: str | tuple[Any, Any] = "not-a-knot",
+    extrapolate=None,
+):
+    """
+    Convenience function for cubic spline data interpolator.
+
+    See `scipy.interpolate.CubicSpline` for details.
+
+    Parameters
+    ----------
+    xi : np.ndarray, shape (n,)
+        1-d array containing values of the independent variable.
+        Values must be real, finite and in strictly increasing order.
+    yi : np.ndarray
+        Array containing values of the dependent variable. It can have
+        arbitrary number of dimensions, but the length along ``axis``
+        (see below) must match the length of ``x``. Values must be finite.
+    x : np.ndarray, shape (m,)
+    axis : int, optional
+        Axis along which `y` is assumed to be varying. Meaning that for
+        ``x[i]`` the corresponding values are ``np.take(y, i, axis=axis)``.
+        Default is 0.
+    bc_type : string or 2-tuple, optional
+        Boundary condition type. Two additional equations, given by the
+        boundary conditions, are required to determine all coefficients of
+        polynomials on each segment [2]_.
+        If `bc_type` is a string, then the specified condition will be applied
+        at both ends of a spline. Available conditions are:
+        * 'not-a-knot' (default): The first and second segment at a curve end
+          are the same polynomial. It is a good default when there is no
+          information on boundary conditions.
+        * 'periodic': The interpolated functions is assumed to be periodic
+          of period ``x[-1] - x[0]``. The first and last value of `y` must be
+          identical: ``y[0] == y[-1]``. This boundary condition will result in
+          ``y'[0] == y'[-1]`` and ``y''[0] == y''[-1]``.
+        * 'clamped': The first derivative at curves ends are zero. Assuming
+          a 1D `y`, ``bc_type=((1, 0.0), (1, 0.0))`` is the same condition.
+        * 'natural': The second derivative at curve ends are zero. Assuming
+          a 1D `y`, ``bc_type=((2, 0.0), (2, 0.0))`` is the same condition.
+        If `bc_type` is a 2-tuple, the first and the second value will be
+        applied at the curve start and end respectively. The tuple values can
+        be one of the previously mentioned strings (except 'periodic') or a
+        tuple `(order, deriv_values)` allowing to specify arbitrary
+        derivatives at curve ends:
+        * `order`: the derivative order, 1 or 2.
+        * `deriv_value`: array-like containing derivative values, shape must
+          be the same as `y`, excluding ``axis`` dimension. For example, if
+          `y` is 1D, then `deriv_value` must be a scalar. If `y` is 3D with
+          the shape (n0, n1, n2) and axis=2, then `deriv_value` must be 2D
+          and have the shape (n0, n1).
+    extrapolate : {bool, 'periodic', None}, optional
+        If bool, determines whether to extrapolate to out-of-bounds points
+        based on first and last intervals, or to return NaNs. If 'periodic',
+        periodic extrapolation is used. If None (default), ``extrapolate`` is
+        set to 'periodic' for ``bc_type='periodic'`` and to True otherwise.
+
+    See Also
+    --------
+    scipy.interpolate.CubicHermiteSpline
+
+    Returns
+    -------
+    y : scalar or array-like
+        The result, of shape (m,)
+
+    References
+    ----------
+    .. [1] `Cubic Spline Interpolation
+            <https://en.wikiversity.org/wiki/Cubic_Spline_Interpolation>`_
+            on Wikiversity.
+    .. [2] Carl de Boor, "A Practical Guide to Splines", Springer-Verlag, 1978.
+    """
+    from scipy import interpolate
+
+    P = interpolate.CubicSpline(
+        xi, yi, axis=axis, bc_type=bc_type, extrapolate=extrapolate
+    )
+
+    return P(x)
+
+
+def _interpolate_with_limit_area(
+    values: np.ndarray,
+    method: Literal["pad", "backfill"],
+    limit: int | None,
+    limit_area: Literal["inside", "outside"],
+) -> None:
+    """
+    Apply interpolation and limit_area logic to values along a to-be-specified axis.
+
+    Parameters
+    ----------
+    values: np.ndarray
+        Input array.
+    method: str
+        Interpolation method. Could be "bfill" or "pad"
+    limit: int, optional
+        Index limit on interpolation.
+    limit_area: {'inside', 'outside'}
+        Limit area for interpolation.
+
+    Notes
+    -----
+    Modifies values in-place.
+    """
+
+    invalid = isna(values)
+    is_valid = ~invalid
+
+    if not invalid.all():
+        first = find_valid_index(how="first", is_valid=is_valid)
+        if first is None:
+            first = 0
+        last = find_valid_index(how="last", is_valid=is_valid)
+        if last is None:
+            last = len(values)
+
+        pad_or_backfill_inplace(
+            values,
+            method=method,
+            limit=limit,
+            limit_area=limit_area,
+        )
+
+        if limit_area == "inside":
+            invalid[first : last + 1] = False
+        elif limit_area == "outside":
+            invalid[:first] = invalid[last + 1 :] = False
+        else:
+            raise ValueError("limit_area should be 'inside' or 'outside'")
+
+        values[invalid] = np.nan
+
+
+def pad_or_backfill_inplace(
+    values: np.ndarray,
+    method: Literal["pad", "backfill"] = "pad",
+    axis: AxisInt = 0,
+    limit: int | None = None,
+    limit_area: Literal["inside", "outside"] | None = None,
+) -> None:
+    """
+    Perform an actual interpolation of values, values will be make 2-d if
+    needed fills inplace, returns the result.
+
+    Parameters
+    ----------
+    values: np.ndarray
+        Input array.
+    method: str, default "pad"
+        Interpolation method. Could be "bfill" or "pad"
+    axis: 0 or 1
+        Interpolation axis
+    limit: int, optional
+        Index limit on interpolation.
+    limit_area: str, optional
+        Limit area for interpolation. Can be "inside" or "outside"
+
+    Notes
+    -----
+    Modifies values in-place.
+    """
+    transf = (lambda x: x) if axis == 0 else (lambda x: x.T)
+
+    # reshape a 1 dim if needed
+    if values.ndim == 1:
+        if axis != 0:  # pragma: no cover
+            raise AssertionError("cannot interpolate on a ndim == 1 with axis != 0")
+        values = values.reshape(tuple((1,) + values.shape))
+
+    method = clean_fill_method(method)
+    tvalues = transf(values)
+
+    func = get_fill_func(method, ndim=2)
+    # _pad_2d and _backfill_2d both modify tvalues inplace
+    func(tvalues, limit=limit, limit_area=limit_area)
+
+
+def _fillna_prep(
+    values, mask: npt.NDArray[np.bool_] | None = None
+) -> npt.NDArray[np.bool_]:
+    # boilerplate for _pad_1d, _backfill_1d, _pad_2d, _backfill_2d
+
+    if mask is None:
+        mask = isna(values)
+
+    return mask
+
+
+def _datetimelike_compat(func: F) -> F:
+    """
+    Wrapper to handle datetime64 and timedelta64 dtypes.
+    """
+
+    @wraps(func)
+    def new_func(
+        values,
+        limit: int | None = None,
+        limit_area: Literal["inside", "outside"] | None = None,
+        mask=None,
+    ):
+        if needs_i8_conversion(values.dtype):
+            if mask is None:
+                # This needs to occur before casting to int64
+                mask = isna(values)
+
+            result, mask = func(
+                values.view("i8"), limit=limit, limit_area=limit_area, mask=mask
+            )
+            return result.view(values.dtype), mask
+
+        return func(values, limit=limit, limit_area=limit_area, mask=mask)
+
+    return cast(F, new_func)
+
+
+@_datetimelike_compat
+def _pad_1d(
+    values: np.ndarray,
+    limit: int | None = None,
+    limit_area: Literal["inside", "outside"] | None = None,
+    mask: npt.NDArray[np.bool_] | None = None,
+) -> tuple[np.ndarray, npt.NDArray[np.bool_]]:
+    mask = _fillna_prep(values, mask)
+    if limit_area is not None and not mask.all():
+        _fill_limit_area_1d(mask, limit_area)
+    algos.pad_inplace(values, mask, limit=limit)
+    return values, mask
+
+
+@_datetimelike_compat
+def _backfill_1d(
+    values: np.ndarray,
+    limit: int | None = None,
+    limit_area: Literal["inside", "outside"] | None = None,
+    mask: npt.NDArray[np.bool_] | None = None,
+) -> tuple[np.ndarray, npt.NDArray[np.bool_]]:
+    mask = _fillna_prep(values, mask)
+    if limit_area is not None and not mask.all():
+        _fill_limit_area_1d(mask, limit_area)
+    algos.backfill_inplace(values, mask, limit=limit)
+    return values, mask
+
+
+@_datetimelike_compat
+def _pad_2d(
+    values: np.ndarray,
+    limit: int | None = None,
+    limit_area: Literal["inside", "outside"] | None = None,
+    mask: npt.NDArray[np.bool_] | None = None,
+):
+    mask = _fillna_prep(values, mask)
+    if limit_area is not None:
+        _fill_limit_area_2d(mask, limit_area)
+
+    if values.size:
+        algos.pad_2d_inplace(values, mask, limit=limit)
+    else:
+        # for test coverage
+        pass
+    return values, mask
+
+
+@_datetimelike_compat
+def _backfill_2d(
+    values,
+    limit: int | None = None,
+    limit_area: Literal["inside", "outside"] | None = None,
+    mask: npt.NDArray[np.bool_] | None = None,
+):
+    mask = _fillna_prep(values, mask)
+    if limit_area is not None:
+        _fill_limit_area_2d(mask, limit_area)
+
+    if values.size:
+        algos.backfill_2d_inplace(values, mask, limit=limit)
+    else:
+        # for test coverage
+        pass
+    return values, mask
+
+
+def _fill_limit_area_1d(
+    mask: npt.NDArray[np.bool_], limit_area: Literal["outside", "inside"]
+) -> None:
+    """Prepare 1d mask for ffill/bfill with limit_area.
+
+    Caller is responsible for checking at least one value of mask is False.
+    When called, mask will no longer faithfully represent when
+    the corresponding are NA or not.
+
+    Parameters
+    ----------
+    mask : np.ndarray[bool, ndim=1]
+        Mask representing NA values when filling.
+    limit_area : { "outside", "inside" }
+        Whether to limit filling to outside or inside the outer most non-NA value.
+    """
+    neg_mask = ~mask
+    first = neg_mask.argmax()
+    last = len(neg_mask) - neg_mask[::-1].argmax() - 1
+    if limit_area == "inside":
+        mask[:first] = False
+        mask[last + 1 :] = False
+    elif limit_area == "outside":
+        mask[first + 1 : last] = False
+
+
+def _fill_limit_area_2d(
+    mask: npt.NDArray[np.bool_], limit_area: Literal["outside", "inside"]
+) -> None:
+    """Prepare 2d mask for ffill/bfill with limit_area.
+
+    When called, mask will no longer faithfully represent when
+    the corresponding are NA or not.
+
+    Parameters
+    ----------
+    mask : np.ndarray[bool, ndim=1]
+        Mask representing NA values when filling.
+    limit_area : { "outside", "inside" }
+        Whether to limit filling to outside or inside the outer most non-NA value.
+    """
+    neg_mask = ~mask.T
+    if limit_area == "outside":
+        # Identify inside
+        la_mask = (
+            np.maximum.accumulate(neg_mask, axis=0)
+            & np.maximum.accumulate(neg_mask[::-1], axis=0)[::-1]
+        )
+    else:
+        # Identify outside
+        la_mask = (
+            ~np.maximum.accumulate(neg_mask, axis=0)
+            | ~np.maximum.accumulate(neg_mask[::-1], axis=0)[::-1]
+        )
+    mask[la_mask.T] = False
+
+
+_fill_methods = {"pad": _pad_1d, "backfill": _backfill_1d}
+
+
+def get_fill_func(method, ndim: int = 1):
+    method = clean_fill_method(method)
+    if ndim == 1:
+        return _fill_methods[method]
+    return {"pad": _pad_2d, "backfill": _backfill_2d}[method]
+
+
+def clean_reindex_fill_method(method) -> ReindexMethod | None:
+    if method is None:
+        return None
+    return clean_fill_method(method, allow_nearest=True)
+
+
+def _interp_limit(
+    invalid: npt.NDArray[np.bool_], fw_limit: int | None, bw_limit: int | None
+):
+    """
+    Get indexers of values that won't be filled
+    because they exceed the limits.
+
+    Parameters
+    ----------
+    invalid : np.ndarray[bool]
+    fw_limit : int or None
+        forward limit to index
+    bw_limit : int or None
+        backward limit to index
+
+    Returns
+    -------
+    set of indexers
+
+    Notes
+    -----
+    This is equivalent to the more readable, but slower
+
+    .. code-block:: python
+
+        def _interp_limit(invalid, fw_limit, bw_limit):
+            for x in np.where(invalid)[0]:
+                if invalid[max(0, x - fw_limit):x + bw_limit + 1].all():
+                    yield x
+    """
+    # handle forward first; the backward direction is the same except
+    # 1. operate on the reversed array
+    # 2. subtract the returned indices from N - 1
+    N = len(invalid)
+    f_idx = set()
+    b_idx = set()
+
+    def inner(invalid, limit: int):
+        limit = min(limit, N)
+        windowed = _rolling_window(invalid, limit + 1).all(1)
+        idx = set(np.where(windowed)[0] + limit) | set(
+            np.where((~invalid[: limit + 1]).cumsum() == 0)[0]
+        )
+        return idx
+
+    if fw_limit is not None:
+        if fw_limit == 0:
+            f_idx = set(np.where(invalid)[0])
+        else:
+            f_idx = inner(invalid, fw_limit)
+
+    if bw_limit is not None:
+        if bw_limit == 0:
+            # then we don't even need to care about backwards
+            # just use forwards
+            return f_idx
+        else:
+            b_idx_inv = list(inner(invalid[::-1], bw_limit))
+            b_idx = set(N - 1 - np.asarray(b_idx_inv))
+            if fw_limit == 0:
+                return b_idx
+
+    return f_idx & b_idx
+
+
+def _rolling_window(a: npt.NDArray[np.bool_], window: int) -> npt.NDArray[np.bool_]:
+    """
+    [True, True, False, True, False], 2 ->
+
+    [
+        [True,  True],
+        [True, False],
+        [False, True],
+        [True, False],
+    ]
+    """
+    # https://stackoverflow.com/a/6811241
+    shape = a.shape[:-1] + (a.shape[-1] - window + 1, window)
+    strides = a.strides + (a.strides[-1],)
+    return np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides)

videollama2/lib/python3.10/site-packages/pandas/core/nanops.py

@@ -0,0 +1,1748 @@
+from __future__ import annotations
+
+import functools
+import itertools
+from typing import (
+    Any,
+    Callable,
+    cast,
+)
+import warnings
+
+import numpy as np
+
+from pandas._config import get_option
+
+from pandas._libs import (
+    NaT,
+    NaTType,
+    iNaT,
+    lib,
+)
+from pandas._typing import (
+    ArrayLike,
+    AxisInt,
+    CorrelationMethod,
+    Dtype,
+    DtypeObj,
+    F,
+    Scalar,
+    Shape,
+    npt,
+)
+from pandas.compat._optional import import_optional_dependency
+from pandas.util._exceptions import find_stack_level
+
+from pandas.core.dtypes.common import (
+    is_complex,
+    is_float,
+    is_float_dtype,
+    is_integer,
+    is_numeric_dtype,
+    is_object_dtype,
+    needs_i8_conversion,
+    pandas_dtype,
+)
+from pandas.core.dtypes.missing import (
+    isna,
+    na_value_for_dtype,
+    notna,
+)
+
+bn = import_optional_dependency("bottleneck", errors="warn")
+_BOTTLENECK_INSTALLED = bn is not None
+_USE_BOTTLENECK = False
+
+
+def set_use_bottleneck(v: bool = True) -> None:
+    # set/unset to use bottleneck
+    global _USE_BOTTLENECK
+    if _BOTTLENECK_INSTALLED:
+        _USE_BOTTLENECK = v
+
+
+set_use_bottleneck(get_option("compute.use_bottleneck"))
+
+
+class disallow:
+    def __init__(self, *dtypes: Dtype) -> None:
+        super().__init__()
+        self.dtypes = tuple(pandas_dtype(dtype).type for dtype in dtypes)
+
+    def check(self, obj) -> bool:
+        return hasattr(obj, "dtype") and issubclass(obj.dtype.type, self.dtypes)
+
+    def __call__(self, f: F) -> F:
+        @functools.wraps(f)
+        def _f(*args, **kwargs):
+            obj_iter = itertools.chain(args, kwargs.values())
+            if any(self.check(obj) for obj in obj_iter):
+                f_name = f.__name__.replace("nan", "")
+                raise TypeError(
+                    f"reduction operation '{f_name}' not allowed for this dtype"
+                )
+            try:
+                return f(*args, **kwargs)
+            except ValueError as e:
+                # we want to transform an object array
+                # ValueError message to the more typical TypeError
+                # e.g. this is normally a disallowed function on
+                # object arrays that contain strings
+                if is_object_dtype(args[0]):
+                    raise TypeError(e) from e
+                raise
+
+        return cast(F, _f)
+
+
+class bottleneck_switch:
+    def __init__(self, name=None, **kwargs) -> None:
+        self.name = name
+        self.kwargs = kwargs
+
+    def __call__(self, alt: F) -> F:
+        bn_name = self.name or alt.__name__
+
+        try:
+            bn_func = getattr(bn, bn_name)
+        except (AttributeError, NameError):  # pragma: no cover
+            bn_func = None
+
+        @functools.wraps(alt)
+        def f(
+            values: np.ndarray,
+            *,
+            axis: AxisInt | None = None,
+            skipna: bool = True,
+            **kwds,
+        ):
+            if len(self.kwargs) > 0:
+                for k, v in self.kwargs.items():
+                    if k not in kwds:
+                        kwds[k] = v
+
+            if values.size == 0 and kwds.get("min_count") is None:
+                # We are empty, returning NA for our type
+                # Only applies for the default `min_count` of None
+                # since that affects how empty arrays are handled.
+                # TODO(GH-18976) update all the nanops methods to
+                # correctly handle empty inputs and remove this check.
+                # It *may* just be `var`
+                return _na_for_min_count(values, axis)
+
+            if _USE_BOTTLENECK and skipna and _bn_ok_dtype(values.dtype, bn_name):
+                if kwds.get("mask", None) is None:
+                    # `mask` is not recognised by bottleneck, would raise
+                    #  TypeError if called
+                    kwds.pop("mask", None)
+                    result = bn_func(values, axis=axis, **kwds)
+
+                    # prefer to treat inf/-inf as NA, but must compute the func
+                    # twice :(
+                    if _has_infs(result):
+                        result = alt(values, axis=axis, skipna=skipna, **kwds)
+                else:
+                    result = alt(values, axis=axis, skipna=skipna, **kwds)
+            else:
+                result = alt(values, axis=axis, skipna=skipna, **kwds)
+
+            return result
+
+        return cast(F, f)
+
+
+def _bn_ok_dtype(dtype: DtypeObj, name: str) -> bool:
+    # Bottleneck chokes on datetime64, PeriodDtype (or and EA)
+    if dtype != object and not needs_i8_conversion(dtype):
+        # GH 42878
+        # Bottleneck uses naive summation leading to O(n) loss of precision
+        # unlike numpy which implements pairwise summation, which has O(log(n)) loss
+        # crossref: https://github.com/pydata/bottleneck/issues/379
+
+        # GH 15507
+        # bottleneck does not properly upcast during the sum
+        # so can overflow
+
+        # GH 9422
+        # further we also want to preserve NaN when all elements
+        # are NaN, unlike bottleneck/numpy which consider this
+        # to be 0
+        return name not in ["nansum", "nanprod", "nanmean"]
+    return False
+
+
+def _has_infs(result) -> bool:
+    if isinstance(result, np.ndarray):
+        if result.dtype in ("f8", "f4"):
+            # Note: outside of an nanops-specific test, we always have
+            #  result.ndim == 1, so there is no risk of this ravel making a copy.
+            return lib.has_infs(result.ravel("K"))
+    try:
+        return np.isinf(result).any()
+    except (TypeError, NotImplementedError):
+        # if it doesn't support infs, then it can't have infs
+        return False
+
+
+def _get_fill_value(
+    dtype: DtypeObj, fill_value: Scalar | None = None, fill_value_typ=None
+):
+    """return the correct fill value for the dtype of the values"""
+    if fill_value is not None:
+        return fill_value
+    if _na_ok_dtype(dtype):
+        if fill_value_typ is None:
+            return np.nan
+        else:
+            if fill_value_typ == "+inf":
+                return np.inf
+            else:
+                return -np.inf
+    else:
+        if fill_value_typ == "+inf":
+            # need the max int here
+            return lib.i8max
+        else:
+            return iNaT
+
+
+def _maybe_get_mask(
+    values: np.ndarray, skipna: bool, mask: npt.NDArray[np.bool_] | None
+) -> npt.NDArray[np.bool_] | None:
+    """
+    Compute a mask if and only if necessary.
+
+    This function will compute a mask iff it is necessary. Otherwise,
+    return the provided mask (potentially None) when a mask does not need to be
+    computed.
+
+    A mask is never necessary if the values array is of boolean or integer
+    dtypes, as these are incapable of storing NaNs. If passing a NaN-capable
+    dtype that is interpretable as either boolean or integer data (eg,
+    timedelta64), a mask must be provided.
+
+    If the skipna parameter is False, a new mask will not be computed.
+
+    The mask is computed using isna() by default. Setting invert=True selects
+    notna() as the masking function.
+
+    Parameters
+    ----------
+    values : ndarray
+        input array to potentially compute mask for
+    skipna : bool
+        boolean for whether NaNs should be skipped
+    mask : Optional[ndarray]
+        nan-mask if known
+
+    Returns
+    -------
+    Optional[np.ndarray[bool]]
+    """
+    if mask is None:
+        if values.dtype.kind in "biu":
+            # Boolean data cannot contain nulls, so signal via mask being None
+            return None
+
+        if skipna or values.dtype.kind in "mM":
+            mask = isna(values)
+
+    return mask
+
+
+def _get_values(
+    values: np.ndarray,
+    skipna: bool,
+    fill_value: Any = None,
+    fill_value_typ: str | None = None,
+    mask: npt.NDArray[np.bool_] | None = None,
+) -> tuple[np.ndarray, npt.NDArray[np.bool_] | None]:
+    """
+    Utility to get the values view, mask, dtype, dtype_max, and fill_value.
+
+    If both mask and fill_value/fill_value_typ are not None and skipna is True,
+    the values array will be copied.
+
+    For input arrays of boolean or integer dtypes, copies will only occur if a
+    precomputed mask, a fill_value/fill_value_typ, and skipna=True are
+    provided.
+
+    Parameters
+    ----------
+    values : ndarray
+        input array to potentially compute mask for
+    skipna : bool
+        boolean for whether NaNs should be skipped
+    fill_value : Any
+        value to fill NaNs with
+    fill_value_typ : str
+        Set to '+inf' or '-inf' to handle dtype-specific infinities
+    mask : Optional[np.ndarray[bool]]
+        nan-mask if known
+
+    Returns
+    -------
+    values : ndarray
+        Potential copy of input value array
+    mask : Optional[ndarray[bool]]
+        Mask for values, if deemed necessary to compute
+    """
+    # In _get_values is only called from within nanops, and in all cases
+    #  with scalar fill_value.  This guarantee is important for the
+    #  np.where call below
+
+    mask = _maybe_get_mask(values, skipna, mask)
+
+    dtype = values.dtype
+
+    datetimelike = False
+    if values.dtype.kind in "mM":
+        # changing timedelta64/datetime64 to int64 needs to happen after
+        #  finding `mask` above
+        values = np.asarray(values.view("i8"))
+        datetimelike = True
+
+    if skipna and (mask is not None):
+        # get our fill value (in case we need to provide an alternative
+        # dtype for it)
+        fill_value = _get_fill_value(
+            dtype, fill_value=fill_value, fill_value_typ=fill_value_typ
+        )
+
+        if fill_value is not None:
+            if mask.any():
+                if datetimelike or _na_ok_dtype(dtype):
+                    values = values.copy()
+                    np.putmask(values, mask, fill_value)
+                else:
+                    # np.where will promote if needed
+                    values = np.where(~mask, values, fill_value)
+
+    return values, mask
+
+
+def _get_dtype_max(dtype: np.dtype) -> np.dtype:
+    # return a platform independent precision dtype
+    dtype_max = dtype
+    if dtype.kind in "bi":
+        dtype_max = np.dtype(np.int64)
+    elif dtype.kind == "u":
+        dtype_max = np.dtype(np.uint64)
+    elif dtype.kind == "f":
+        dtype_max = np.dtype(np.float64)
+    return dtype_max
+
+
+def _na_ok_dtype(dtype: DtypeObj) -> bool:
+    if needs_i8_conversion(dtype):
+        return False
+    return not issubclass(dtype.type, np.integer)
+
+
+def _wrap_results(result, dtype: np.dtype, fill_value=None):
+    """wrap our results if needed"""
+    if result is NaT:
+        pass
+
+    elif dtype.kind == "M":
+        if fill_value is None:
+            # GH#24293
+            fill_value = iNaT
+        if not isinstance(result, np.ndarray):
+            assert not isna(fill_value), "Expected non-null fill_value"
+            if result == fill_value:
+                result = np.nan
+
+            if isna(result):
+                result = np.datetime64("NaT", "ns").astype(dtype)
+            else:
+                result = np.int64(result).view(dtype)
+            # retain original unit
+            result = result.astype(dtype, copy=False)
+        else:
+            # If we have float dtype, taking a view will give the wrong result
+            result = result.astype(dtype)
+    elif dtype.kind == "m":
+        if not isinstance(result, np.ndarray):
+            if result == fill_value or np.isnan(result):
+                result = np.timedelta64("NaT").astype(dtype)
+
+            elif np.fabs(result) > lib.i8max:
+                # raise if we have a timedelta64[ns] which is too large
+                raise ValueError("overflow in timedelta operation")
+            else:
+                # return a timedelta64 with the original unit
+                result = np.int64(result).astype(dtype, copy=False)
+
+        else:
+            result = result.astype("m8[ns]").view(dtype)
+
+    return result
+
+
+def _datetimelike_compat(func: F) -> F:
+    """
+    If we have datetime64 or timedelta64 values, ensure we have a correct
+    mask before calling the wrapped function, then cast back afterwards.
+    """
+
+    @functools.wraps(func)
+    def new_func(
+        values: np.ndarray,
+        *,
+        axis: AxisInt | None = None,
+        skipna: bool = True,
+        mask: npt.NDArray[np.bool_] | None = None,
+        **kwargs,
+    ):
+        orig_values = values
+
+        datetimelike = values.dtype.kind in "mM"
+        if datetimelike and mask is None:
+            mask = isna(values)
+
+        result = func(values, axis=axis, skipna=skipna, mask=mask, **kwargs)
+
+        if datetimelike:
+            result = _wrap_results(result, orig_values.dtype, fill_value=iNaT)
+            if not skipna:
+                assert mask is not None  # checked above
+                result = _mask_datetimelike_result(result, axis, mask, orig_values)
+
+        return result
+
+    return cast(F, new_func)
+
+
+def _na_for_min_count(values: np.ndarray, axis: AxisInt | None) -> Scalar | np.ndarray:
+    """
+    Return the missing value for `values`.
+
+    Parameters
+    ----------
+    values : ndarray
+    axis : int or None
+        axis for the reduction, required if values.ndim > 1.
+
+    Returns
+    -------
+    result : scalar or ndarray
+        For 1-D values, returns a scalar of the correct missing type.
+        For 2-D values, returns a 1-D array where each element is missing.
+    """
+    # we either return np.nan or pd.NaT
+    if values.dtype.kind in "iufcb":
+        values = values.astype("float64")
+    fill_value = na_value_for_dtype(values.dtype)
+
+    if values.ndim == 1:
+        return fill_value
+    elif axis is None:
+        return fill_value
+    else:
+        result_shape = values.shape[:axis] + values.shape[axis + 1 :]
+
+        return np.full(result_shape, fill_value, dtype=values.dtype)
+
+
+def maybe_operate_rowwise(func: F) -> F:
+    """
+    NumPy operations on C-contiguous ndarrays with axis=1 can be
+    very slow if axis 1 >> axis 0.
+    Operate row-by-row and concatenate the results.
+    """
+
+    @functools.wraps(func)
+    def newfunc(values: np.ndarray, *, axis: AxisInt | None = None, **kwargs):
+        if (
+            axis == 1
+            and values.ndim == 2
+            and values.flags["C_CONTIGUOUS"]
+            # only takes this path for wide arrays (long dataframes), for threshold see
+            # https://github.com/pandas-dev/pandas/pull/43311#issuecomment-974891737
+            and (values.shape[1] / 1000) > values.shape[0]
+            and values.dtype != object
+            and values.dtype != bool
+        ):
+            arrs = list(values)
+            if kwargs.get("mask") is not None:
+                mask = kwargs.pop("mask")
+                results = [
+                    func(arrs[i], mask=mask[i], **kwargs) for i in range(len(arrs))
+                ]
+            else:
+                results = [func(x, **kwargs) for x in arrs]
+            return np.array(results)
+
+        return func(values, axis=axis, **kwargs)
+
+    return cast(F, newfunc)
+
+
+def nanany(
+    values: np.ndarray,
+    *,
+    axis: AxisInt | None = None,
+    skipna: bool = True,
+    mask: npt.NDArray[np.bool_] | None = None,
+) -> bool:
+    """
+    Check if any elements along an axis evaluate to True.
+
+    Parameters
+    ----------
+    values : ndarray
+    axis : int, optional
+    skipna : bool, default True
+    mask : ndarray[bool], optional
+        nan-mask if known
+
+    Returns
+    -------
+    result : bool
+
+    Examples
+    --------
+    >>> from pandas.core import nanops
+    >>> s = pd.Series([1, 2])
+    >>> nanops.nanany(s.values)
+    True
+
+    >>> from pandas.core import nanops
+    >>> s = pd.Series([np.nan])
+    >>> nanops.nanany(s.values)
+    False
+    """
+    if values.dtype.kind in "iub" and mask is None:
+        # GH#26032 fastpath
+        # error: Incompatible return value type (got "Union[bool_, ndarray]",
+        # expected "bool")
+        return values.any(axis)  # type: ignore[return-value]
+
+    if values.dtype.kind == "M":
+        # GH#34479
+        warnings.warn(
+            "'any' with datetime64 dtypes is deprecated and will raise in a "
+            "future version. Use (obj != pd.Timestamp(0)).any() instead.",
+            FutureWarning,
+            stacklevel=find_stack_level(),
+        )
+
+    values, _ = _get_values(values, skipna, fill_value=False, mask=mask)
+
+    # For object type, any won't necessarily return
+    # boolean values (numpy/numpy#4352)
+    if values.dtype == object:
+        values = values.astype(bool)
+
+    # error: Incompatible return value type (got "Union[bool_, ndarray]", expected
+    # "bool")
+    return values.any(axis)  # type: ignore[return-value]
+
+
+def nanall(
+    values: np.ndarray,
+    *,
+    axis: AxisInt | None = None,
+    skipna: bool = True,
+    mask: npt.NDArray[np.bool_] | None = None,
+) -> bool:
+    """
+    Check if all elements along an axis evaluate to True.
+
+    Parameters
+    ----------
+    values : ndarray
+    axis : int, optional
+    skipna : bool, default True
+    mask : ndarray[bool], optional
+        nan-mask if known
+
+    Returns
+    -------
+    result : bool
+
+    Examples
+    --------
+    >>> from pandas.core import nanops
+    >>> s = pd.Series([1, 2, np.nan])
+    >>> nanops.nanall(s.values)
+    True
+
+    >>> from pandas.core import nanops
+    >>> s = pd.Series([1, 0])
+    >>> nanops.nanall(s.values)
+    False
+    """
+    if values.dtype.kind in "iub" and mask is None:
+        # GH#26032 fastpath
+        # error: Incompatible return value type (got "Union[bool_, ndarray]",
+        # expected "bool")
+        return values.all(axis)  # type: ignore[return-value]
+
+    if values.dtype.kind == "M":
+        # GH#34479
+        warnings.warn(
+            "'all' with datetime64 dtypes is deprecated and will raise in a "
+            "future version. Use (obj != pd.Timestamp(0)).all() instead.",
+            FutureWarning,
+            stacklevel=find_stack_level(),
+        )
+
+    values, _ = _get_values(values, skipna, fill_value=True, mask=mask)
+
+    # For object type, all won't necessarily return
+    # boolean values (numpy/numpy#4352)
+    if values.dtype == object:
+        values = values.astype(bool)
+
+    # error: Incompatible return value type (got "Union[bool_, ndarray]", expected
+    # "bool")
+    return values.all(axis)  # type: ignore[return-value]
+
+
+@disallow("M8")
+@_datetimelike_compat
+@maybe_operate_rowwise
+def nansum(
+    values: np.ndarray,
+    *,
+    axis: AxisInt | None = None,
+    skipna: bool = True,
+    min_count: int = 0,
+    mask: npt.NDArray[np.bool_] | None = None,
+) -> float:
+    """
+    Sum the elements along an axis ignoring NaNs
+
+    Parameters
+    ----------
+    values : ndarray[dtype]
+    axis : int, optional
+    skipna : bool, default True
+    min_count: int, default 0
+    mask : ndarray[bool], optional
+        nan-mask if known
+
+    Returns
+    -------
+    result : dtype
+
+    Examples
+    --------
+    >>> from pandas.core import nanops
+    >>> s = pd.Series([1, 2, np.nan])
+    >>> nanops.nansum(s.values)
+    3.0
+    """
+    dtype = values.dtype
+    values, mask = _get_values(values, skipna, fill_value=0, mask=mask)
+    dtype_sum = _get_dtype_max(dtype)
+    if dtype.kind == "f":
+        dtype_sum = dtype
+    elif dtype.kind == "m":
+        dtype_sum = np.dtype(np.float64)
+
+    the_sum = values.sum(axis, dtype=dtype_sum)
+    the_sum = _maybe_null_out(the_sum, axis, mask, values.shape, min_count=min_count)
+
+    return the_sum
+
+
+def _mask_datetimelike_result(
+    result: np.ndarray | np.datetime64 | np.timedelta64,
+    axis: AxisInt | None,
+    mask: npt.NDArray[np.bool_],
+    orig_values: np.ndarray,
+) -> np.ndarray | np.datetime64 | np.timedelta64 | NaTType:
+    if isinstance(result, np.ndarray):
+        # we need to apply the mask
+        result = result.astype("i8").view(orig_values.dtype)
+        axis_mask = mask.any(axis=axis)
+        # error: Unsupported target for indexed assignment ("Union[ndarray[Any, Any],
+        # datetime64, timedelta64]")
+        result[axis_mask] = iNaT  # type: ignore[index]
+    else:
+        if mask.any():
+            return np.int64(iNaT).view(orig_values.dtype)
+    return result
+
+
+@bottleneck_switch()
+@_datetimelike_compat
+def nanmean(
+    values: np.ndarray,
+    *,
+    axis: AxisInt | None = None,
+    skipna: bool = True,
+    mask: npt.NDArray[np.bool_] | None = None,
+) -> float:
+    """
+    Compute the mean of the element along an axis ignoring NaNs
+
+    Parameters
+    ----------
+    values : ndarray
+    axis : int, optional
+    skipna : bool, default True
+    mask : ndarray[bool], optional
+        nan-mask if known
+
+    Returns
+    -------
+    float
+        Unless input is a float array, in which case use the same
+        precision as the input array.
+
+    Examples
+    --------
+    >>> from pandas.core import nanops
+    >>> s = pd.Series([1, 2, np.nan])
+    >>> nanops.nanmean(s.values)
+    1.5
+    """
+    dtype = values.dtype
+    values, mask = _get_values(values, skipna, fill_value=0, mask=mask)
+    dtype_sum = _get_dtype_max(dtype)
+    dtype_count = np.dtype(np.float64)
+
+    # not using needs_i8_conversion because that includes period
+    if dtype.kind in "mM":
+        dtype_sum = np.dtype(np.float64)
+    elif dtype.kind in "iu":
+        dtype_sum = np.dtype(np.float64)
+    elif dtype.kind == "f":
+        dtype_sum = dtype
+        dtype_count = dtype
+
+    count = _get_counts(values.shape, mask, axis, dtype=dtype_count)
+    the_sum = values.sum(axis, dtype=dtype_sum)
+    the_sum = _ensure_numeric(the_sum)
+
+    if axis is not None and getattr(the_sum, "ndim", False):
+        count = cast(np.ndarray, count)
+        with np.errstate(all="ignore"):
+            # suppress division by zero warnings
+            the_mean = the_sum / count
+        ct_mask = count == 0
+        if ct_mask.any():
+            the_mean[ct_mask] = np.nan
+    else:
+        the_mean = the_sum / count if count > 0 else np.nan
+
+    return the_mean
+
+
+@bottleneck_switch()
+def nanmedian(values, *, axis: AxisInt | None = None, skipna: bool = True, mask=None):
+    """
+    Parameters
+    ----------
+    values : ndarray
+    axis : int, optional
+    skipna : bool, default True
+    mask : ndarray[bool], optional
+        nan-mask if known
+
+    Returns
+    -------
+    result : float
+        Unless input is a float array, in which case use the same
+        precision as the input array.
+
+    Examples
+    --------
+    >>> from pandas.core import nanops
+    >>> s = pd.Series([1, np.nan, 2, 2])
+    >>> nanops.nanmedian(s.values)
+    2.0
+    """
+    # for floats without mask, the data already uses NaN as missing value
+    # indicator, and `mask` will be calculated from that below -> in those
+    # cases we never need to set NaN to the masked values
+    using_nan_sentinel = values.dtype.kind == "f" and mask is None
+
+    def get_median(x, _mask=None):
+        if _mask is None:
+            _mask = notna(x)
+        else:
+            _mask = ~_mask
+        if not skipna and not _mask.all():
+            return np.nan
+        with warnings.catch_warnings():
+            # Suppress RuntimeWarning about All-NaN slice
+            warnings.filterwarnings(
+                "ignore", "All-NaN slice encountered", RuntimeWarning
+            )
+            res = np.nanmedian(x[_mask])
+        return res
+
+    dtype = values.dtype
+    values, mask = _get_values(values, skipna, mask=mask, fill_value=None)
+    if values.dtype.kind != "f":
+        if values.dtype == object:
+            # GH#34671 avoid casting strings to numeric
+            inferred = lib.infer_dtype(values)
+            if inferred in ["string", "mixed"]:
+                raise TypeError(f"Cannot convert {values} to numeric")
+        try:
+            values = values.astype("f8")
+        except ValueError as err:
+            # e.g. "could not convert string to float: 'a'"
+            raise TypeError(str(err)) from err
+    if not using_nan_sentinel and mask is not None:
+        if not values.flags.writeable:
+            values = values.copy()
+        values[mask] = np.nan
+
+    notempty = values.size
+
+    # an array from a frame
+    if values.ndim > 1 and axis is not None:
+        # there's a non-empty array to apply over otherwise numpy raises
+        if notempty:
+            if not skipna:
+                res = np.apply_along_axis(get_median, axis, values)
+
+            else:
+                # fastpath for the skipna case
+                with warnings.catch_warnings():
+                    # Suppress RuntimeWarning about All-NaN slice
+                    warnings.filterwarnings(
+                        "ignore", "All-NaN slice encountered", RuntimeWarning
+                    )
+                    if (values.shape[1] == 1 and axis == 0) or (
+                        values.shape[0] == 1 and axis == 1
+                    ):
+                        # GH52788: fastpath when squeezable, nanmedian for 2D array slow
+                        res = np.nanmedian(np.squeeze(values), keepdims=True)
+                    else:
+                        res = np.nanmedian(values, axis=axis)
+
+        else:
+            # must return the correct shape, but median is not defined for the
+            # empty set so return nans of shape "everything but the passed axis"
+            # since "axis" is where the reduction would occur if we had a nonempty
+            # array
+            res = _get_empty_reduction_result(values.shape, axis)
+
+    else:
+        # otherwise return a scalar value
+        res = get_median(values, mask) if notempty else np.nan
+    return _wrap_results(res, dtype)
+
+
+def _get_empty_reduction_result(
+    shape: Shape,
+    axis: AxisInt,
+) -> np.ndarray:
+    """
+    The result from a reduction on an empty ndarray.
+
+    Parameters
+    ----------
+    shape : Tuple[int, ...]
+    axis : int
+
+    Returns
+    -------
+    np.ndarray
+    """
+    shp = np.array(shape)
+    dims = np.arange(len(shape))
+    ret = np.empty(shp[dims != axis], dtype=np.float64)
+    ret.fill(np.nan)
+    return ret
+
+
+def _get_counts_nanvar(
+    values_shape: Shape,
+    mask: npt.NDArray[np.bool_] | None,
+    axis: AxisInt | None,
+    ddof: int,
+    dtype: np.dtype = np.dtype(np.float64),
+) -> tuple[float | np.ndarray, float | np.ndarray]:
+    """
+    Get the count of non-null values along an axis, accounting
+    for degrees of freedom.
+
+    Parameters
+    ----------
+    values_shape : Tuple[int, ...]
+        shape tuple from values ndarray, used if mask is None
+    mask : Optional[ndarray[bool]]
+        locations in values that should be considered missing
+    axis : Optional[int]
+        axis to count along
+    ddof : int
+        degrees of freedom
+    dtype : type, optional
+        type to use for count
+
+    Returns
+    -------
+    count : int, np.nan or np.ndarray
+    d : int, np.nan or np.ndarray
+    """
+    count = _get_counts(values_shape, mask, axis, dtype=dtype)
+    d = count - dtype.type(ddof)
+
+    # always return NaN, never inf
+    if is_float(count):
+        if count <= ddof:
+            # error: Incompatible types in assignment (expression has type
+            # "float", variable has type "Union[floating[Any], ndarray[Any,
+            # dtype[floating[Any]]]]")
+            count = np.nan  # type: ignore[assignment]
+            d = np.nan
+    else:
+        # count is not narrowed by is_float check
+        count = cast(np.ndarray, count)
+        mask = count <= ddof
+        if mask.any():
+            np.putmask(d, mask, np.nan)
+            np.putmask(count, mask, np.nan)
+    return count, d
+
+
+@bottleneck_switch(ddof=1)
+def nanstd(
+    values,
+    *,
+    axis: AxisInt | None = None,
+    skipna: bool = True,
+    ddof: int = 1,
+    mask=None,
+):
+    """
+    Compute the standard deviation along given axis while ignoring NaNs
+
+    Parameters
+    ----------
+    values : ndarray
+    axis : int, optional
+    skipna : bool, default True
+    ddof : int, default 1
+        Delta Degrees of Freedom. The divisor used in calculations is N - ddof,
+        where N represents the number of elements.
+    mask : ndarray[bool], optional
+        nan-mask if known
+
+    Returns
+    -------
+    result : float
+        Unless input is a float array, in which case use the same
+        precision as the input array.
+
+    Examples
+    --------
+    >>> from pandas.core import nanops
+    >>> s = pd.Series([1, np.nan, 2, 3])
+    >>> nanops.nanstd(s.values)
+    1.0
+    """
+    if values.dtype == "M8[ns]":
+        values = values.view("m8[ns]")
+
+    orig_dtype = values.dtype
+    values, mask = _get_values(values, skipna, mask=mask)
+
+    result = np.sqrt(nanvar(values, axis=axis, skipna=skipna, ddof=ddof, mask=mask))
+    return _wrap_results(result, orig_dtype)
+
+
+@disallow("M8", "m8")
+@bottleneck_switch(ddof=1)
+def nanvar(
+    values: np.ndarray,
+    *,
+    axis: AxisInt | None = None,
+    skipna: bool = True,
+    ddof: int = 1,
+    mask=None,
+):
+    """
+    Compute the variance along given axis while ignoring NaNs
+
+    Parameters
+    ----------
+    values : ndarray
+    axis : int, optional
+    skipna : bool, default True
+    ddof : int, default 1
+        Delta Degrees of Freedom. The divisor used in calculations is N - ddof,
+        where N represents the number of elements.
+    mask : ndarray[bool], optional
+        nan-mask if known
+
+    Returns
+    -------
+    result : float
+        Unless input is a float array, in which case use the same
+        precision as the input array.
+
+    Examples
+    --------
+    >>> from pandas.core import nanops
+    >>> s = pd.Series([1, np.nan, 2, 3])
+    >>> nanops.nanvar(s.values)
+    1.0
+    """
+    dtype = values.dtype
+    mask = _maybe_get_mask(values, skipna, mask)
+    if dtype.kind in "iu":
+        values = values.astype("f8")
+        if mask is not None:
+            values[mask] = np.nan
+
+    if values.dtype.kind == "f":
+        count, d = _get_counts_nanvar(values.shape, mask, axis, ddof, values.dtype)
+    else:
+        count, d = _get_counts_nanvar(values.shape, mask, axis, ddof)
+
+    if skipna and mask is not None:
+        values = values.copy()
+        np.putmask(values, mask, 0)
+
+    # xref GH10242
+    # Compute variance via two-pass algorithm, which is stable against
+    # cancellation errors and relatively accurate for small numbers of
+    # observations.
+    #
+    # See https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
+    avg = _ensure_numeric(values.sum(axis=axis, dtype=np.float64)) / count
+    if axis is not None:
+        avg = np.expand_dims(avg, axis)
+    sqr = _ensure_numeric((avg - values) ** 2)
+    if mask is not None:
+        np.putmask(sqr, mask, 0)
+    result = sqr.sum(axis=axis, dtype=np.float64) / d
+
+    # Return variance as np.float64 (the datatype used in the accumulator),
+    # unless we were dealing with a float array, in which case use the same
+    # precision as the original values array.
+    if dtype.kind == "f":
+        result = result.astype(dtype, copy=False)
+    return result
+
+
+@disallow("M8", "m8")
+def nansem(
+    values: np.ndarray,
+    *,
+    axis: AxisInt | None = None,
+    skipna: bool = True,
+    ddof: int = 1,
+    mask: npt.NDArray[np.bool_] | None = None,
+) -> float:
+    """
+    Compute the standard error in the mean along given axis while ignoring NaNs
+
+    Parameters
+    ----------
+    values : ndarray
+    axis : int, optional
+    skipna : bool, default True
+    ddof : int, default 1
+        Delta Degrees of Freedom. The divisor used in calculations is N - ddof,
+        where N represents the number of elements.
+    mask : ndarray[bool], optional
+        nan-mask if known
+
+    Returns
+    -------
+    result : float64
+        Unless input is a float array, in which case use the same
+        precision as the input array.
+
+    Examples
+    --------
+    >>> from pandas.core import nanops
+    >>> s = pd.Series([1, np.nan, 2, 3])
+    >>> nanops.nansem(s.values)
+     0.5773502691896258
+    """
+    # This checks if non-numeric-like data is passed with numeric_only=False
+    # and raises a TypeError otherwise
+    nanvar(values, axis=axis, skipna=skipna, ddof=ddof, mask=mask)
+
+    mask = _maybe_get_mask(values, skipna, mask)
+    if values.dtype.kind != "f":
+        values = values.astype("f8")
+
+    if not skipna and mask is not None and mask.any():
+        return np.nan
+
+    count, _ = _get_counts_nanvar(values.shape, mask, axis, ddof, values.dtype)
+    var = nanvar(values, axis=axis, skipna=skipna, ddof=ddof, mask=mask)
+
+    return np.sqrt(var) / np.sqrt(count)
+
+
+def _nanminmax(meth, fill_value_typ):
+    @bottleneck_switch(name=f"nan{meth}")
+    @_datetimelike_compat
+    def reduction(
+        values: np.ndarray,
+        *,
+        axis: AxisInt | None = None,
+        skipna: bool = True,
+        mask: npt.NDArray[np.bool_] | None = None,
+    ):
+        if values.size == 0:
+            return _na_for_min_count(values, axis)
+
+        values, mask = _get_values(
+            values, skipna, fill_value_typ=fill_value_typ, mask=mask
+        )
+        result = getattr(values, meth)(axis)
+        result = _maybe_null_out(result, axis, mask, values.shape)
+        return result
+
+    return reduction
+
+
+nanmin = _nanminmax("min", fill_value_typ="+inf")
+nanmax = _nanminmax("max", fill_value_typ="-inf")
+
+
+def nanargmax(
+    values: np.ndarray,
+    *,
+    axis: AxisInt | None = None,
+    skipna: bool = True,
+    mask: npt.NDArray[np.bool_] | None = None,
+) -> int | np.ndarray:
+    """
+    Parameters
+    ----------
+    values : ndarray
+    axis : int, optional
+    skipna : bool, default True
+    mask : ndarray[bool], optional
+        nan-mask if known
+
+    Returns
+    -------
+    result : int or ndarray[int]
+        The index/indices  of max value in specified axis or -1 in the NA case
+
+    Examples
+    --------
+    >>> from pandas.core import nanops
+    >>> arr = np.array([1, 2, 3, np.nan, 4])
+    >>> nanops.nanargmax(arr)
+    4
+
+    >>> arr = np.array(range(12), dtype=np.float64).reshape(4, 3)
+    >>> arr[2:, 2] = np.nan
+    >>> arr
+    array([[ 0.,  1.,  2.],
+           [ 3.,  4.,  5.],
+           [ 6.,  7., nan],
+           [ 9., 10., nan]])
+    >>> nanops.nanargmax(arr, axis=1)
+    array([2, 2, 1, 1])
+    """
+    values, mask = _get_values(values, True, fill_value_typ="-inf", mask=mask)
+    result = values.argmax(axis)
+    # error: Argument 1 to "_maybe_arg_null_out" has incompatible type "Any |
+    # signedinteger[Any]"; expected "ndarray[Any, Any]"
+    result = _maybe_arg_null_out(result, axis, mask, skipna)  # type: ignore[arg-type]
+    return result
+
+
+def nanargmin(
+    values: np.ndarray,
+    *,
+    axis: AxisInt | None = None,
+    skipna: bool = True,
+    mask: npt.NDArray[np.bool_] | None = None,
+) -> int | np.ndarray:
+    """
+    Parameters
+    ----------
+    values : ndarray
+    axis : int, optional
+    skipna : bool, default True
+    mask : ndarray[bool], optional
+        nan-mask if known
+
+    Returns
+    -------
+    result : int or ndarray[int]
+        The index/indices of min value in specified axis or -1 in the NA case
+
+    Examples
+    --------
+    >>> from pandas.core import nanops
+    >>> arr = np.array([1, 2, 3, np.nan, 4])
+    >>> nanops.nanargmin(arr)
+    0
+
+    >>> arr = np.array(range(12), dtype=np.float64).reshape(4, 3)
+    >>> arr[2:, 0] = np.nan
+    >>> arr
+    array([[ 0.,  1.,  2.],
+           [ 3.,  4.,  5.],
+           [nan,  7.,  8.],
+           [nan, 10., 11.]])
+    >>> nanops.nanargmin(arr, axis=1)
+    array([0, 0, 1, 1])
+    """
+    values, mask = _get_values(values, True, fill_value_typ="+inf", mask=mask)
+    result = values.argmin(axis)
+    # error: Argument 1 to "_maybe_arg_null_out" has incompatible type "Any |
+    # signedinteger[Any]"; expected "ndarray[Any, Any]"
+    result = _maybe_arg_null_out(result, axis, mask, skipna)  # type: ignore[arg-type]
+    return result
+
+
+@disallow("M8", "m8")
+@maybe_operate_rowwise
+def nanskew(
+    values: np.ndarray,
+    *,
+    axis: AxisInt | None = None,
+    skipna: bool = True,
+    mask: npt.NDArray[np.bool_] | None = None,
+) -> float:
+    """
+    Compute the sample skewness.
+
+    The statistic computed here is the adjusted Fisher-Pearson standardized
+    moment coefficient G1. The algorithm computes this coefficient directly
+    from the second and third central moment.
+
+    Parameters
+    ----------
+    values : ndarray
+    axis : int, optional
+    skipna : bool, default True
+    mask : ndarray[bool], optional
+        nan-mask if known
+
+    Returns
+    -------
+    result : float64
+        Unless input is a float array, in which case use the same
+        precision as the input array.
+
+    Examples
+    --------
+    >>> from pandas.core import nanops
+    >>> s = pd.Series([1, np.nan, 1, 2])
+    >>> nanops.nanskew(s.values)
+    1.7320508075688787
+    """
+    mask = _maybe_get_mask(values, skipna, mask)
+    if values.dtype.kind != "f":
+        values = values.astype("f8")
+        count = _get_counts(values.shape, mask, axis)
+    else:
+        count = _get_counts(values.shape, mask, axis, dtype=values.dtype)
+
+    if skipna and mask is not None:
+        values = values.copy()
+        np.putmask(values, mask, 0)
+    elif not skipna and mask is not None and mask.any():
+        return np.nan
+
+    with np.errstate(invalid="ignore", divide="ignore"):
+        mean = values.sum(axis, dtype=np.float64) / count
+    if axis is not None:
+        mean = np.expand_dims(mean, axis)
+
+    adjusted = values - mean
+    if skipna and mask is not None:
+        np.putmask(adjusted, mask, 0)
+    adjusted2 = adjusted**2
+    adjusted3 = adjusted2 * adjusted
+    m2 = adjusted2.sum(axis, dtype=np.float64)
+    m3 = adjusted3.sum(axis, dtype=np.float64)
+
+    # floating point error
+    #
+    # #18044 in _libs/windows.pyx calc_skew follow this behavior
+    # to fix the fperr to treat m2 <1e-14 as zero
+    m2 = _zero_out_fperr(m2)
+    m3 = _zero_out_fperr(m3)
+
+    with np.errstate(invalid="ignore", divide="ignore"):
+        result = (count * (count - 1) ** 0.5 / (count - 2)) * (m3 / m2**1.5)
+
+    dtype = values.dtype
+    if dtype.kind == "f":
+        result = result.astype(dtype, copy=False)
+
+    if isinstance(result, np.ndarray):
+        result = np.where(m2 == 0, 0, result)
+        result[count < 3] = np.nan
+    else:
+        result = dtype.type(0) if m2 == 0 else result
+        if count < 3:
+            return np.nan
+
+    return result
+
+
+@disallow("M8", "m8")
+@maybe_operate_rowwise
+def nankurt(
+    values: np.ndarray,
+    *,
+    axis: AxisInt | None = None,
+    skipna: bool = True,
+    mask: npt.NDArray[np.bool_] | None = None,
+) -> float:
+    """
+    Compute the sample excess kurtosis
+
+    The statistic computed here is the adjusted Fisher-Pearson standardized
+    moment coefficient G2, computed directly from the second and fourth
+    central moment.
+
+    Parameters
+    ----------
+    values : ndarray
+    axis : int, optional
+    skipna : bool, default True
+    mask : ndarray[bool], optional
+        nan-mask if known
+
+    Returns
+    -------
+    result : float64
+        Unless input is a float array, in which case use the same
+        precision as the input array.
+
+    Examples
+    --------
+    >>> from pandas.core import nanops
+    >>> s = pd.Series([1, np.nan, 1, 3, 2])
+    >>> nanops.nankurt(s.values)
+    -1.2892561983471076
+    """
+    mask = _maybe_get_mask(values, skipna, mask)
+    if values.dtype.kind != "f":
+        values = values.astype("f8")
+        count = _get_counts(values.shape, mask, axis)
+    else:
+        count = _get_counts(values.shape, mask, axis, dtype=values.dtype)
+
+    if skipna and mask is not None:
+        values = values.copy()
+        np.putmask(values, mask, 0)
+    elif not skipna and mask is not None and mask.any():
+        return np.nan
+
+    with np.errstate(invalid="ignore", divide="ignore"):
+        mean = values.sum(axis, dtype=np.float64) / count
+    if axis is not None:
+        mean = np.expand_dims(mean, axis)
+
+    adjusted = values - mean
+    if skipna and mask is not None:
+        np.putmask(adjusted, mask, 0)
+    adjusted2 = adjusted**2
+    adjusted4 = adjusted2**2
+    m2 = adjusted2.sum(axis, dtype=np.float64)
+    m4 = adjusted4.sum(axis, dtype=np.float64)
+
+    with np.errstate(invalid="ignore", divide="ignore"):
+        adj = 3 * (count - 1) ** 2 / ((count - 2) * (count - 3))
+        numerator = count * (count + 1) * (count - 1) * m4
+        denominator = (count - 2) * (count - 3) * m2**2
+
+    # floating point error
+    #
+    # #18044 in _libs/windows.pyx calc_kurt follow this behavior
+    # to fix the fperr to treat denom <1e-14 as zero
+    numerator = _zero_out_fperr(numerator)
+    denominator = _zero_out_fperr(denominator)
+
+    if not isinstance(denominator, np.ndarray):
+        # if ``denom`` is a scalar, check these corner cases first before
+        # doing division
+        if count < 4:
+            return np.nan
+        if denominator == 0:
+            return values.dtype.type(0)
+
+    with np.errstate(invalid="ignore", divide="ignore"):
+        result = numerator / denominator - adj
+
+    dtype = values.dtype
+    if dtype.kind == "f":
+        result = result.astype(dtype, copy=False)
+
+    if isinstance(result, np.ndarray):
+        result = np.where(denominator == 0, 0, result)
+        result[count < 4] = np.nan
+
+    return result
+
+
+@disallow("M8", "m8")
+@maybe_operate_rowwise
+def nanprod(
+    values: np.ndarray,
+    *,
+    axis: AxisInt | None = None,
+    skipna: bool = True,
+    min_count: int = 0,
+    mask: npt.NDArray[np.bool_] | None = None,
+) -> float:
+    """
+    Parameters
+    ----------
+    values : ndarray[dtype]
+    axis : int, optional
+    skipna : bool, default True
+    min_count: int, default 0
+    mask : ndarray[bool], optional
+        nan-mask if known
+
+    Returns
+    -------
+    Dtype
+        The product of all elements on a given axis. ( NaNs are treated as 1)
+
+    Examples
+    --------
+    >>> from pandas.core import nanops
+    >>> s = pd.Series([1, 2, 3, np.nan])
+    >>> nanops.nanprod(s.values)
+    6.0
+    """
+    mask = _maybe_get_mask(values, skipna, mask)
+
+    if skipna and mask is not None:
+        values = values.copy()
+        values[mask] = 1
+    result = values.prod(axis)
+    # error: Incompatible return value type (got "Union[ndarray, float]", expected
+    # "float")
+    return _maybe_null_out(  # type: ignore[return-value]
+        result, axis, mask, values.shape, min_count=min_count
+    )
+
+
+def _maybe_arg_null_out(
+    result: np.ndarray,
+    axis: AxisInt | None,
+    mask: npt.NDArray[np.bool_] | None,
+    skipna: bool,
+) -> np.ndarray | int:
+    # helper function for nanargmin/nanargmax
+    if mask is None:
+        return result
+
+    if axis is None or not getattr(result, "ndim", False):
+        if skipna:
+            if mask.all():
+                return -1
+        else:
+            if mask.any():
+                return -1
+    else:
+        if skipna:
+            na_mask = mask.all(axis)
+        else:
+            na_mask = mask.any(axis)
+        if na_mask.any():
+            result[na_mask] = -1
+    return result
+
+
+def _get_counts(
+    values_shape: Shape,
+    mask: npt.NDArray[np.bool_] | None,
+    axis: AxisInt | None,
+    dtype: np.dtype[np.floating] = np.dtype(np.float64),
+) -> np.floating | npt.NDArray[np.floating]:
+    """
+    Get the count of non-null values along an axis
+
+    Parameters
+    ----------
+    values_shape : tuple of int
+        shape tuple from values ndarray, used if mask is None
+    mask : Optional[ndarray[bool]]
+        locations in values that should be considered missing
+    axis : Optional[int]
+        axis to count along
+    dtype : type, optional
+        type to use for count
+
+    Returns
+    -------
+    count : scalar or array
+    """
+    if axis is None:
+        if mask is not None:
+            n = mask.size - mask.sum()
+        else:
+            n = np.prod(values_shape)
+        return dtype.type(n)
+
+    if mask is not None:
+        count = mask.shape[axis] - mask.sum(axis)
+    else:
+        count = values_shape[axis]
+
+    if is_integer(count):
+        return dtype.type(count)
+    return count.astype(dtype, copy=False)
+
+
+def _maybe_null_out(
+    result: np.ndarray | float | NaTType,
+    axis: AxisInt | None,
+    mask: npt.NDArray[np.bool_] | None,
+    shape: tuple[int, ...],
+    min_count: int = 1,
+) -> np.ndarray | float | NaTType:
+    """
+    Returns
+    -------
+    Dtype
+        The product of all elements on a given axis. ( NaNs are treated as 1)
+    """
+    if mask is None and min_count == 0:
+        # nothing to check; short-circuit
+        return result
+
+    if axis is not None and isinstance(result, np.ndarray):
+        if mask is not None:
+            null_mask = (mask.shape[axis] - mask.sum(axis) - min_count) < 0
+        else:
+            # we have no nulls, kept mask=None in _maybe_get_mask
+            below_count = shape[axis] - min_count < 0
+            new_shape = shape[:axis] + shape[axis + 1 :]
+            null_mask = np.broadcast_to(below_count, new_shape)
+
+        if np.any(null_mask):
+            if is_numeric_dtype(result):
+                if np.iscomplexobj(result):
+                    result = result.astype("c16")
+                elif not is_float_dtype(result):
+                    result = result.astype("f8", copy=False)
+                result[null_mask] = np.nan
+            else:
+                # GH12941, use None to auto cast null
+                result[null_mask] = None
+    elif result is not NaT:
+        if check_below_min_count(shape, mask, min_count):
+            result_dtype = getattr(result, "dtype", None)
+            if is_float_dtype(result_dtype):
+                # error: Item "None" of "Optional[Any]" has no attribute "type"
+                result = result_dtype.type("nan")  # type: ignore[union-attr]
+            else:
+                result = np.nan
+
+    return result
+
+
+def check_below_min_count(
+    shape: tuple[int, ...], mask: npt.NDArray[np.bool_] | None, min_count: int
+) -> bool:
+    """
+    Check for the `min_count` keyword. Returns True if below `min_count` (when
+    missing value should be returned from the reduction).
+
+    Parameters
+    ----------
+    shape : tuple
+        The shape of the values (`values.shape`).
+    mask : ndarray[bool] or None
+        Boolean numpy array (typically of same shape as `shape`) or None.
+    min_count : int
+        Keyword passed through from sum/prod call.
+
+    Returns
+    -------
+    bool
+    """
+    if min_count > 0:
+        if mask is None:
+            # no missing values, only check size
+            non_nulls = np.prod(shape)
+        else:
+            non_nulls = mask.size - mask.sum()
+        if non_nulls < min_count:
+            return True
+    return False
+
+
+def _zero_out_fperr(arg):
+    # #18044 reference this behavior to fix rolling skew/kurt issue
+    if isinstance(arg, np.ndarray):
+        return np.where(np.abs(arg) < 1e-14, 0, arg)
+    else:
+        return arg.dtype.type(0) if np.abs(arg) < 1e-14 else arg
+
+
+@disallow("M8", "m8")
+def nancorr(
+    a: np.ndarray,
+    b: np.ndarray,
+    *,
+    method: CorrelationMethod = "pearson",
+    min_periods: int | None = None,
+) -> float:
+    """
+    a, b: ndarrays
+    """
+    if len(a) != len(b):
+        raise AssertionError("Operands to nancorr must have same size")
+
+    if min_periods is None:
+        min_periods = 1
+
+    valid = notna(a) & notna(b)
+    if not valid.all():
+        a = a[valid]
+        b = b[valid]
+
+    if len(a) < min_periods:
+        return np.nan
+
+    a = _ensure_numeric(a)
+    b = _ensure_numeric(b)
+
+    f = get_corr_func(method)
+    return f(a, b)
+
+
+def get_corr_func(
+    method: CorrelationMethod,
+) -> Callable[[np.ndarray, np.ndarray], float]:
+    if method == "kendall":
+        from scipy.stats import kendalltau
+
+        def func(a, b):
+            return kendalltau(a, b)[0]
+
+        return func
+    elif method == "spearman":
+        from scipy.stats import spearmanr
+
+        def func(a, b):
+            return spearmanr(a, b)[0]
+
+        return func
+    elif method == "pearson":
+
+        def func(a, b):
+            return np.corrcoef(a, b)[0, 1]
+
+        return func
+    elif callable(method):
+        return method
+
+    raise ValueError(
+        f"Unknown method '{method}', expected one of "
+        "'kendall', 'spearman', 'pearson', or callable"
+    )
+
+
+@disallow("M8", "m8")
+def nancov(
+    a: np.ndarray,
+    b: np.ndarray,
+    *,
+    min_periods: int | None = None,
+    ddof: int | None = 1,
+) -> float:
+    if len(a) != len(b):
+        raise AssertionError("Operands to nancov must have same size")
+
+    if min_periods is None:
+        min_periods = 1
+
+    valid = notna(a) & notna(b)
+    if not valid.all():
+        a = a[valid]
+        b = b[valid]
+
+    if len(a) < min_periods:
+        return np.nan
+
+    a = _ensure_numeric(a)
+    b = _ensure_numeric(b)
+
+    return np.cov(a, b, ddof=ddof)[0, 1]
+
+
+def _ensure_numeric(x):
+    if isinstance(x, np.ndarray):
+        if x.dtype.kind in "biu":
+            x = x.astype(np.float64)
+        elif x.dtype == object:
+            inferred = lib.infer_dtype(x)
+            if inferred in ["string", "mixed"]:
+                # GH#44008, GH#36703 avoid casting e.g. strings to numeric
+                raise TypeError(f"Could not convert {x} to numeric")
+            try:
+                x = x.astype(np.complex128)
+            except (TypeError, ValueError):
+                try:
+                    x = x.astype(np.float64)
+                except ValueError as err:
+                    # GH#29941 we get here with object arrays containing strs
+                    raise TypeError(f"Could not convert {x} to numeric") from err
+            else:
+                if not np.any(np.imag(x)):
+                    x = x.real
+    elif not (is_float(x) or is_integer(x) or is_complex(x)):
+        if isinstance(x, str):
+            # GH#44008, GH#36703 avoid casting e.g. strings to numeric
+            raise TypeError(f"Could not convert string '{x}' to numeric")
+        try:
+            x = float(x)
+        except (TypeError, ValueError):
+            # e.g. "1+1j" or "foo"
+            try:
+                x = complex(x)
+            except ValueError as err:
+                # e.g. "foo"
+                raise TypeError(f"Could not convert {x} to numeric") from err
+    return x
+
+
+def na_accum_func(values: ArrayLike, accum_func, *, skipna: bool) -> ArrayLike:
+    """
+    Cumulative function with skipna support.
+
+    Parameters
+    ----------
+    values : np.ndarray or ExtensionArray
+    accum_func : {np.cumprod, np.maximum.accumulate, np.cumsum, np.minimum.accumulate}
+    skipna : bool
+
+    Returns
+    -------
+    np.ndarray or ExtensionArray
+    """
+    mask_a, mask_b = {
+        np.cumprod: (1.0, np.nan),
+        np.maximum.accumulate: (-np.inf, np.nan),
+        np.cumsum: (0.0, np.nan),
+        np.minimum.accumulate: (np.inf, np.nan),
+    }[accum_func]
+
+    # This should go through ea interface
+    assert values.dtype.kind not in "mM"
+
+    # We will be applying this function to block values
+    if skipna and not issubclass(values.dtype.type, (np.integer, np.bool_)):
+        vals = values.copy()
+        mask = isna(vals)
+        vals[mask] = mask_a
+        result = accum_func(vals, axis=0)
+        result[mask] = mask_b
+    else:
+        result = accum_func(values, axis=0)
+
+    return result

videollama2/lib/python3.10/site-packages/pandas/core/resample.py

@@ -0,0 +1,2920 @@
+from __future__ import annotations
+
+import copy
+from textwrap import dedent
+from typing import (
+    TYPE_CHECKING,
+    Callable,
+    Literal,
+    cast,
+    final,
+    no_type_check,
+)
+import warnings
+
+import numpy as np
+
+from pandas._libs import lib
+from pandas._libs.tslibs import (
+    BaseOffset,
+    IncompatibleFrequency,
+    NaT,
+    Period,
+    Timedelta,
+    Timestamp,
+    to_offset,
+)
+from pandas._libs.tslibs.dtypes import freq_to_period_freqstr
+from pandas._typing import NDFrameT
+from pandas.compat.numpy import function as nv
+from pandas.errors import AbstractMethodError
+from pandas.util._decorators import (
+    Appender,
+    Substitution,
+    doc,
+)
+from pandas.util._exceptions import (
+    find_stack_level,
+    rewrite_warning,
+)
+
+from pandas.core.dtypes.dtypes import ArrowDtype
+from pandas.core.dtypes.generic import (
+    ABCDataFrame,
+    ABCSeries,
+)
+
+import pandas.core.algorithms as algos
+from pandas.core.apply import (
+    ResamplerWindowApply,
+    warn_alias_replacement,
+)
+from pandas.core.arrays import ArrowExtensionArray
+from pandas.core.base import (
+    PandasObject,
+    SelectionMixin,
+)
+import pandas.core.common as com
+from pandas.core.generic import (
+    NDFrame,
+    _shared_docs,
+)
+from pandas.core.groupby.generic import SeriesGroupBy
+from pandas.core.groupby.groupby import (
+    BaseGroupBy,
+    GroupBy,
+    _apply_groupings_depr,
+    _pipe_template,
+    get_groupby,
+)
+from pandas.core.groupby.grouper import Grouper
+from pandas.core.groupby.ops import BinGrouper
+from pandas.core.indexes.api import MultiIndex
+from pandas.core.indexes.base import Index
+from pandas.core.indexes.datetimes import (
+    DatetimeIndex,
+    date_range,
+)
+from pandas.core.indexes.period import (
+    PeriodIndex,
+    period_range,
+)
+from pandas.core.indexes.timedeltas import (
+    TimedeltaIndex,
+    timedelta_range,
+)
+
+from pandas.tseries.frequencies import (
+    is_subperiod,
+    is_superperiod,
+)
+from pandas.tseries.offsets import (
+    Day,
+    Tick,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Hashable
+
+    from pandas._typing import (
+        AnyArrayLike,
+        Axis,
+        AxisInt,
+        Frequency,
+        IndexLabel,
+        InterpolateOptions,
+        T,
+        TimedeltaConvertibleTypes,
+        TimeGrouperOrigin,
+        TimestampConvertibleTypes,
+        npt,
+    )
+
+    from pandas import (
+        DataFrame,
+        Series,
+    )
+
+_shared_docs_kwargs: dict[str, str] = {}
+
+
+class Resampler(BaseGroupBy, PandasObject):
+    """
+    Class for resampling datetimelike data, a groupby-like operation.
+    See aggregate, transform, and apply functions on this object.
+
+    It's easiest to use obj.resample(...) to use Resampler.
+
+    Parameters
+    ----------
+    obj : Series or DataFrame
+    groupby : TimeGrouper
+    axis : int, default 0
+    kind : str or None
+        'period', 'timestamp' to override default index treatment
+
+    Returns
+    -------
+    a Resampler of the appropriate type
+
+    Notes
+    -----
+    After resampling, see aggregate, apply, and transform functions.
+    """
+
+    _grouper: BinGrouper
+    _timegrouper: TimeGrouper
+    binner: DatetimeIndex | TimedeltaIndex | PeriodIndex  # depends on subclass
+    exclusions: frozenset[Hashable] = frozenset()  # for SelectionMixin compat
+    _internal_names_set = set({"obj", "ax", "_indexer"})
+
+    # to the groupby descriptor
+    _attributes = [
+        "freq",
+        "axis",
+        "closed",
+        "label",
+        "convention",
+        "kind",
+        "origin",
+        "offset",
+    ]
+
+    def __init__(
+        self,
+        obj: NDFrame,
+        timegrouper: TimeGrouper,
+        axis: Axis = 0,
+        kind=None,
+        *,
+        gpr_index: Index,
+        group_keys: bool = False,
+        selection=None,
+        include_groups: bool = True,
+    ) -> None:
+        self._timegrouper = timegrouper
+        self.keys = None
+        self.sort = True
+        self.axis = obj._get_axis_number(axis)
+        self.kind = kind
+        self.group_keys = group_keys
+        self.as_index = True
+        self.include_groups = include_groups
+
+        self.obj, self.ax, self._indexer = self._timegrouper._set_grouper(
+            self._convert_obj(obj), sort=True, gpr_index=gpr_index
+        )
+        self.binner, self._grouper = self._get_binner()
+        self._selection = selection
+        if self._timegrouper.key is not None:
+            self.exclusions = frozenset([self._timegrouper.key])
+        else:
+            self.exclusions = frozenset()
+
+    @final
+    def __str__(self) -> str:
+        """
+        Provide a nice str repr of our rolling object.
+        """
+        attrs = (
+            f"{k}={getattr(self._timegrouper, k)}"
+            for k in self._attributes
+            if getattr(self._timegrouper, k, None) is not None
+        )
+        return f"{type(self).__name__} [{', '.join(attrs)}]"
+
+    @final
+    def __getattr__(self, attr: str):
+        if attr in self._internal_names_set:
+            return object.__getattribute__(self, attr)
+        if attr in self._attributes:
+            return getattr(self._timegrouper, attr)
+        if attr in self.obj:
+            return self[attr]
+
+        return object.__getattribute__(self, attr)
+
+    @final
+    @property
+    def _from_selection(self) -> bool:
+        """
+        Is the resampling from a DataFrame column or MultiIndex level.
+        """
+        # upsampling and PeriodIndex resampling do not work
+        # with selection, this state used to catch and raise an error
+        return self._timegrouper is not None and (
+            self._timegrouper.key is not None or self._timegrouper.level is not None
+        )
+
+    def _convert_obj(self, obj: NDFrameT) -> NDFrameT:
+        """
+        Provide any conversions for the object in order to correctly handle.
+
+        Parameters
+        ----------
+        obj : Series or DataFrame
+
+        Returns
+        -------
+        Series or DataFrame
+        """
+        return obj._consolidate()
+
+    def _get_binner_for_time(self):
+        raise AbstractMethodError(self)
+
+    @final
+    def _get_binner(self):
+        """
+        Create the BinGrouper, assume that self.set_grouper(obj)
+        has already been called.
+        """
+        binner, bins, binlabels = self._get_binner_for_time()
+        assert len(bins) == len(binlabels)
+        bin_grouper = BinGrouper(bins, binlabels, indexer=self._indexer)
+        return binner, bin_grouper
+
+    @final
+    @Substitution(
+        klass="Resampler",
+        examples="""
+    >>> df = pd.DataFrame({'A': [1, 2, 3, 4]},
+    ...                   index=pd.date_range('2012-08-02', periods=4))
+    >>> df
+                A
+    2012-08-02  1
+    2012-08-03  2
+    2012-08-04  3
+    2012-08-05  4
+
+    To get the difference between each 2-day period's maximum and minimum
+    value in one pass, you can do
+
+    >>> df.resample('2D').pipe(lambda x: x.max() - x.min())
+                A
+    2012-08-02  1
+    2012-08-04  1""",
+    )
+    @Appender(_pipe_template)
+    def pipe(
+        self,
+        func: Callable[..., T] | tuple[Callable[..., T], str],
+        *args,
+        **kwargs,
+    ) -> T:
+        return super().pipe(func, *args, **kwargs)
+
+    _agg_see_also_doc = dedent(
+        """
+    See Also
+    --------
+    DataFrame.groupby.aggregate : Aggregate using callable, string, dict,
+        or list of string/callables.
+    DataFrame.resample.transform : Transforms the Series on each group
+        based on the given function.
+    DataFrame.aggregate: Aggregate using one or more
+        operations over the specified axis.
+    """
+    )
+
+    _agg_examples_doc = dedent(
+        """
+    Examples
+    --------
+    >>> s = pd.Series([1, 2, 3, 4, 5],
+    ...               index=pd.date_range('20130101', periods=5, freq='s'))
+    >>> s
+    2013-01-01 00:00:00    1
+    2013-01-01 00:00:01    2
+    2013-01-01 00:00:02    3
+    2013-01-01 00:00:03    4
+    2013-01-01 00:00:04    5
+    Freq: s, dtype: int64
+
+    >>> r = s.resample('2s')
+
+    >>> r.agg("sum")
+    2013-01-01 00:00:00    3
+    2013-01-01 00:00:02    7
+    2013-01-01 00:00:04    5
+    Freq: 2s, dtype: int64
+
+    >>> r.agg(['sum', 'mean', 'max'])
+                         sum  mean  max
+    2013-01-01 00:00:00    3   1.5    2
+    2013-01-01 00:00:02    7   3.5    4
+    2013-01-01 00:00:04    5   5.0    5
+
+    >>> r.agg({'result': lambda x: x.mean() / x.std(),
+    ...        'total': "sum"})
+                           result  total
+    2013-01-01 00:00:00  2.121320      3
+    2013-01-01 00:00:02  4.949747      7
+    2013-01-01 00:00:04       NaN      5
+
+    >>> r.agg(average="mean", total="sum")
+                             average  total
+    2013-01-01 00:00:00      1.5      3
+    2013-01-01 00:00:02      3.5      7
+    2013-01-01 00:00:04      5.0      5
+    """
+    )
+
+    @final
+    @doc(
+        _shared_docs["aggregate"],
+        see_also=_agg_see_also_doc,
+        examples=_agg_examples_doc,
+        klass="DataFrame",
+        axis="",
+    )
+    def aggregate(self, func=None, *args, **kwargs):
+        result = ResamplerWindowApply(self, func, args=args, kwargs=kwargs).agg()
+        if result is None:
+            how = func
+            result = self._groupby_and_aggregate(how, *args, **kwargs)
+
+        return result
+
+    agg = aggregate
+    apply = aggregate
+
+    @final
+    def transform(self, arg, *args, **kwargs):
+        """
+        Call function producing a like-indexed Series on each group.
+
+        Return a Series with the transformed values.
+
+        Parameters
+        ----------
+        arg : function
+            To apply to each group. Should return a Series with the same index.
+
+        Returns
+        -------
+        Series
+
+        Examples
+        --------
+        >>> s = pd.Series([1, 2],
+        ...               index=pd.date_range('20180101',
+        ...                                   periods=2,
+        ...                                   freq='1h'))
+        >>> s
+        2018-01-01 00:00:00    1
+        2018-01-01 01:00:00    2
+        Freq: h, dtype: int64
+
+        >>> resampled = s.resample('15min')
+        >>> resampled.transform(lambda x: (x - x.mean()) / x.std())
+        2018-01-01 00:00:00   NaN
+        2018-01-01 01:00:00   NaN
+        Freq: h, dtype: float64
+        """
+        return self._selected_obj.groupby(self._timegrouper).transform(
+            arg, *args, **kwargs
+        )
+
+    def _downsample(self, f, **kwargs):
+        raise AbstractMethodError(self)
+
+    def _upsample(self, f, limit: int | None = None, fill_value=None):
+        raise AbstractMethodError(self)
+
+    def _gotitem(self, key, ndim: int, subset=None):
+        """
+        Sub-classes to define. Return a sliced object.
+
+        Parameters
+        ----------
+        key : string / list of selections
+        ndim : {1, 2}
+            requested ndim of result
+        subset : object, default None
+            subset to act on
+        """
+        grouper = self._grouper
+        if subset is None:
+            subset = self.obj
+            if key is not None:
+                subset = subset[key]
+            else:
+                # reached via Apply.agg_dict_like with selection=None and ndim=1
+                assert subset.ndim == 1
+        if ndim == 1:
+            assert subset.ndim == 1
+
+        grouped = get_groupby(
+            subset, by=None, grouper=grouper, axis=self.axis, group_keys=self.group_keys
+        )
+        return grouped
+
+    def _groupby_and_aggregate(self, how, *args, **kwargs):
+        """
+        Re-evaluate the obj with a groupby aggregation.
+        """
+        grouper = self._grouper
+
+        # Excludes `on` column when provided
+        obj = self._obj_with_exclusions
+
+        grouped = get_groupby(
+            obj, by=None, grouper=grouper, axis=self.axis, group_keys=self.group_keys
+        )
+
+        try:
+            if callable(how):
+                # TODO: test_resample_apply_with_additional_args fails if we go
+                #  through the non-lambda path, not clear that it should.
+                func = lambda x: how(x, *args, **kwargs)
+                result = grouped.aggregate(func)
+            else:
+                result = grouped.aggregate(how, *args, **kwargs)
+        except (AttributeError, KeyError):
+            # we have a non-reducing function; try to evaluate
+            # alternatively we want to evaluate only a column of the input
+
+            # test_apply_to_one_column_of_df the function being applied references
+            #  a DataFrame column, but aggregate_item_by_item operates column-wise
+            #  on Series, raising AttributeError or KeyError
+            #  (depending on whether the column lookup uses getattr/__getitem__)
+            result = _apply(
+                grouped, how, *args, include_groups=self.include_groups, **kwargs
+            )
+
+        except ValueError as err:
+            if "Must produce aggregated value" in str(err):
+                # raised in _aggregate_named
+                # see test_apply_without_aggregation, test_apply_with_mutated_index
+                pass
+            else:
+                raise
+
+            # we have a non-reducing function
+            # try to evaluate
+            result = _apply(
+                grouped, how, *args, include_groups=self.include_groups, **kwargs
+            )
+
+        return self._wrap_result(result)
+
+    @final
+    def _get_resampler_for_grouping(
+        self, groupby: GroupBy, key, include_groups: bool = True
+    ):
+        """
+        Return the correct class for resampling with groupby.
+        """
+        return self._resampler_for_grouping(
+            groupby=groupby, key=key, parent=self, include_groups=include_groups
+        )
+
+    def _wrap_result(self, result):
+        """
+        Potentially wrap any results.
+        """
+        # GH 47705
+        obj = self.obj
+        if (
+            isinstance(result, ABCDataFrame)
+            and len(result) == 0
+            and not isinstance(result.index, PeriodIndex)
+        ):
+            result = result.set_index(
+                _asfreq_compat(obj.index[:0], freq=self.freq), append=True
+            )
+
+        if isinstance(result, ABCSeries) and self._selection is not None:
+            result.name = self._selection
+
+        if isinstance(result, ABCSeries) and result.empty:
+            # When index is all NaT, result is empty but index is not
+            result.index = _asfreq_compat(obj.index[:0], freq=self.freq)
+            result.name = getattr(obj, "name", None)
+
+        if self._timegrouper._arrow_dtype is not None:
+            result.index = result.index.astype(self._timegrouper._arrow_dtype)
+
+        return result
+
+    @final
+    def ffill(self, limit: int | None = None):
+        """
+        Forward fill the values.
+
+        Parameters
+        ----------
+        limit : int, optional
+            Limit of how many values to fill.
+
+        Returns
+        -------
+        An upsampled Series.
+
+        See Also
+        --------
+        Series.fillna: Fill NA/NaN values using the specified method.
+        DataFrame.fillna: Fill NA/NaN values using the specified method.
+
+        Examples
+        --------
+        Here we only create a ``Series``.
+
+        >>> ser = pd.Series([1, 2, 3, 4], index=pd.DatetimeIndex(
+        ...                 ['2023-01-01', '2023-01-15', '2023-02-01', '2023-02-15']))
+        >>> ser
+        2023-01-01    1
+        2023-01-15    2
+        2023-02-01    3
+        2023-02-15    4
+        dtype: int64
+
+        Example for ``ffill`` with downsampling (we have fewer dates after resampling):
+
+        >>> ser.resample('MS').ffill()
+        2023-01-01    1
+        2023-02-01    3
+        Freq: MS, dtype: int64
+
+        Example for ``ffill`` with upsampling (fill the new dates with
+        the previous value):
+
+        >>> ser.resample('W').ffill()
+        2023-01-01    1
+        2023-01-08    1
+        2023-01-15    2
+        2023-01-22    2
+        2023-01-29    2
+        2023-02-05    3
+        2023-02-12    3
+        2023-02-19    4
+        Freq: W-SUN, dtype: int64
+
+        With upsampling and limiting (only fill the first new date with the
+        previous value):
+
+        >>> ser.resample('W').ffill(limit=1)
+        2023-01-01    1.0
+        2023-01-08    1.0
+        2023-01-15    2.0
+        2023-01-22    2.0
+        2023-01-29    NaN
+        2023-02-05    3.0
+        2023-02-12    NaN
+        2023-02-19    4.0
+        Freq: W-SUN, dtype: float64
+        """
+        return self._upsample("ffill", limit=limit)
+
+    @final
+    def nearest(self, limit: int | None = None):
+        """
+        Resample by using the nearest value.
+
+        When resampling data, missing values may appear (e.g., when the
+        resampling frequency is higher than the original frequency).
+        The `nearest` method will replace ``NaN`` values that appeared in
+        the resampled data with the value from the nearest member of the
+        sequence, based on the index value.
+        Missing values that existed in the original data will not be modified.
+        If `limit` is given, fill only this many values in each direction for
+        each of the original values.
+
+        Parameters
+        ----------
+        limit : int, optional
+            Limit of how many values to fill.
+
+        Returns
+        -------
+        Series or DataFrame
+            An upsampled Series or DataFrame with ``NaN`` values filled with
+            their nearest value.
+
+        See Also
+        --------
+        backfill : Backward fill the new missing values in the resampled data.
+        pad : Forward fill ``NaN`` values.
+
+        Examples
+        --------
+        >>> s = pd.Series([1, 2],
+        ...               index=pd.date_range('20180101',
+        ...                                   periods=2,
+        ...                                   freq='1h'))
+        >>> s
+        2018-01-01 00:00:00    1
+        2018-01-01 01:00:00    2
+        Freq: h, dtype: int64
+
+        >>> s.resample('15min').nearest()
+        2018-01-01 00:00:00    1
+        2018-01-01 00:15:00    1
+        2018-01-01 00:30:00    2
+        2018-01-01 00:45:00    2
+        2018-01-01 01:00:00    2
+        Freq: 15min, dtype: int64
+
+        Limit the number of upsampled values imputed by the nearest:
+
+        >>> s.resample('15min').nearest(limit=1)
+        2018-01-01 00:00:00    1.0
+        2018-01-01 00:15:00    1.0
+        2018-01-01 00:30:00    NaN
+        2018-01-01 00:45:00    2.0
+        2018-01-01 01:00:00    2.0
+        Freq: 15min, dtype: float64
+        """
+        return self._upsample("nearest", limit=limit)
+
+    @final
+    def bfill(self, limit: int | None = None):
+        """
+        Backward fill the new missing values in the resampled data.
+
+        In statistics, imputation is the process of replacing missing data with
+        substituted values [1]_. When resampling data, missing values may
+        appear (e.g., when the resampling frequency is higher than the original
+        frequency). The backward fill will replace NaN values that appeared in
+        the resampled data with the next value in the original sequence.
+        Missing values that existed in the original data will not be modified.
+
+        Parameters
+        ----------
+        limit : int, optional
+            Limit of how many values to fill.
+
+        Returns
+        -------
+        Series, DataFrame
+            An upsampled Series or DataFrame with backward filled NaN values.
+
+        See Also
+        --------
+        bfill : Alias of backfill.
+        fillna : Fill NaN values using the specified method, which can be
+            'backfill'.
+        nearest : Fill NaN values with nearest neighbor starting from center.
+        ffill : Forward fill NaN values.
+        Series.fillna : Fill NaN values in the Series using the
+            specified method, which can be 'backfill'.
+        DataFrame.fillna : Fill NaN values in the DataFrame using the
+            specified method, which can be 'backfill'.
+
+        References
+        ----------
+        .. [1] https://en.wikipedia.org/wiki/Imputation_(statistics)
+
+        Examples
+        --------
+        Resampling a Series:
+
+        >>> s = pd.Series([1, 2, 3],
+        ...               index=pd.date_range('20180101', periods=3, freq='h'))
+        >>> s
+        2018-01-01 00:00:00    1
+        2018-01-01 01:00:00    2
+        2018-01-01 02:00:00    3
+        Freq: h, dtype: int64
+
+        >>> s.resample('30min').bfill()
+        2018-01-01 00:00:00    1
+        2018-01-01 00:30:00    2
+        2018-01-01 01:00:00    2
+        2018-01-01 01:30:00    3
+        2018-01-01 02:00:00    3
+        Freq: 30min, dtype: int64
+
+        >>> s.resample('15min').bfill(limit=2)
+        2018-01-01 00:00:00    1.0
+        2018-01-01 00:15:00    NaN
+        2018-01-01 00:30:00    2.0
+        2018-01-01 00:45:00    2.0
+        2018-01-01 01:00:00    2.0
+        2018-01-01 01:15:00    NaN
+        2018-01-01 01:30:00    3.0
+        2018-01-01 01:45:00    3.0
+        2018-01-01 02:00:00    3.0
+        Freq: 15min, dtype: float64
+
+        Resampling a DataFrame that has missing values:
+
+        >>> df = pd.DataFrame({'a': [2, np.nan, 6], 'b': [1, 3, 5]},
+        ...                   index=pd.date_range('20180101', periods=3,
+        ...                                       freq='h'))
+        >>> df
+                               a  b
+        2018-01-01 00:00:00  2.0  1
+        2018-01-01 01:00:00  NaN  3
+        2018-01-01 02:00:00  6.0  5
+
+        >>> df.resample('30min').bfill()
+                               a  b
+        2018-01-01 00:00:00  2.0  1
+        2018-01-01 00:30:00  NaN  3
+        2018-01-01 01:00:00  NaN  3
+        2018-01-01 01:30:00  6.0  5
+        2018-01-01 02:00:00  6.0  5
+
+        >>> df.resample('15min').bfill(limit=2)
+                               a    b
+        2018-01-01 00:00:00  2.0  1.0
+        2018-01-01 00:15:00  NaN  NaN
+        2018-01-01 00:30:00  NaN  3.0
+        2018-01-01 00:45:00  NaN  3.0
+        2018-01-01 01:00:00  NaN  3.0
+        2018-01-01 01:15:00  NaN  NaN
+        2018-01-01 01:30:00  6.0  5.0
+        2018-01-01 01:45:00  6.0  5.0
+        2018-01-01 02:00:00  6.0  5.0
+        """
+        return self._upsample("bfill", limit=limit)
+
+    @final
+    def fillna(self, method, limit: int | None = None):
+        """
+        Fill missing values introduced by upsampling.
+
+        In statistics, imputation is the process of replacing missing data with
+        substituted values [1]_. When resampling data, missing values may
+        appear (e.g., when the resampling frequency is higher than the original
+        frequency).
+
+        Missing values that existed in the original data will
+        not be modified.
+
+        Parameters
+        ----------
+        method : {'pad', 'backfill', 'ffill', 'bfill', 'nearest'}
+            Method to use for filling holes in resampled data
+
+            * 'pad' or 'ffill': use previous valid observation to fill gap
+              (forward fill).
+            * 'backfill' or 'bfill': use next valid observation to fill gap.
+            * 'nearest': use nearest valid observation to fill gap.
+
+        limit : int, optional
+            Limit of how many consecutive missing values to fill.
+
+        Returns
+        -------
+        Series or DataFrame
+            An upsampled Series or DataFrame with missing values filled.
+
+        See Also
+        --------
+        bfill : Backward fill NaN values in the resampled data.
+        ffill : Forward fill NaN values in the resampled data.
+        nearest : Fill NaN values in the resampled data
+            with nearest neighbor starting from center.
+        interpolate : Fill NaN values using interpolation.
+        Series.fillna : Fill NaN values in the Series using the
+            specified method, which can be 'bfill' and 'ffill'.
+        DataFrame.fillna : Fill NaN values in the DataFrame using the
+            specified method, which can be 'bfill' and 'ffill'.
+
+        References
+        ----------
+        .. [1] https://en.wikipedia.org/wiki/Imputation_(statistics)
+
+        Examples
+        --------
+        Resampling a Series:
+
+        >>> s = pd.Series([1, 2, 3],
+        ...               index=pd.date_range('20180101', periods=3, freq='h'))
+        >>> s
+        2018-01-01 00:00:00    1
+        2018-01-01 01:00:00    2
+        2018-01-01 02:00:00    3
+        Freq: h, dtype: int64
+
+        Without filling the missing values you get:
+
+        >>> s.resample("30min").asfreq()
+        2018-01-01 00:00:00    1.0
+        2018-01-01 00:30:00    NaN
+        2018-01-01 01:00:00    2.0
+        2018-01-01 01:30:00    NaN
+        2018-01-01 02:00:00    3.0
+        Freq: 30min, dtype: float64
+
+        >>> s.resample('30min').fillna("backfill")
+        2018-01-01 00:00:00    1
+        2018-01-01 00:30:00    2
+        2018-01-01 01:00:00    2
+        2018-01-01 01:30:00    3
+        2018-01-01 02:00:00    3
+        Freq: 30min, dtype: int64
+
+        >>> s.resample('15min').fillna("backfill", limit=2)
+        2018-01-01 00:00:00    1.0
+        2018-01-01 00:15:00    NaN
+        2018-01-01 00:30:00    2.0
+        2018-01-01 00:45:00    2.0
+        2018-01-01 01:00:00    2.0
+        2018-01-01 01:15:00    NaN
+        2018-01-01 01:30:00    3.0
+        2018-01-01 01:45:00    3.0
+        2018-01-01 02:00:00    3.0
+        Freq: 15min, dtype: float64
+
+        >>> s.resample('30min').fillna("pad")
+        2018-01-01 00:00:00    1
+        2018-01-01 00:30:00    1
+        2018-01-01 01:00:00    2
+        2018-01-01 01:30:00    2
+        2018-01-01 02:00:00    3
+        Freq: 30min, dtype: int64
+
+        >>> s.resample('30min').fillna("nearest")
+        2018-01-01 00:00:00    1
+        2018-01-01 00:30:00    2
+        2018-01-01 01:00:00    2
+        2018-01-01 01:30:00    3
+        2018-01-01 02:00:00    3
+        Freq: 30min, dtype: int64
+
+        Missing values present before the upsampling are not affected.
+
+        >>> sm = pd.Series([1, None, 3],
+        ...                index=pd.date_range('20180101', periods=3, freq='h'))
+        >>> sm
+        2018-01-01 00:00:00    1.0
+        2018-01-01 01:00:00    NaN
+        2018-01-01 02:00:00    3.0
+        Freq: h, dtype: float64
+
+        >>> sm.resample('30min').fillna('backfill')
+        2018-01-01 00:00:00    1.0
+        2018-01-01 00:30:00    NaN
+        2018-01-01 01:00:00    NaN
+        2018-01-01 01:30:00    3.0
+        2018-01-01 02:00:00    3.0
+        Freq: 30min, dtype: float64
+
+        >>> sm.resample('30min').fillna('pad')
+        2018-01-01 00:00:00    1.0
+        2018-01-01 00:30:00    1.0
+        2018-01-01 01:00:00    NaN
+        2018-01-01 01:30:00    NaN
+        2018-01-01 02:00:00    3.0
+        Freq: 30min, dtype: float64
+
+        >>> sm.resample('30min').fillna('nearest')
+        2018-01-01 00:00:00    1.0
+        2018-01-01 00:30:00    NaN
+        2018-01-01 01:00:00    NaN
+        2018-01-01 01:30:00    3.0
+        2018-01-01 02:00:00    3.0
+        Freq: 30min, dtype: float64
+
+        DataFrame resampling is done column-wise. All the same options are
+        available.
+
+        >>> df = pd.DataFrame({'a': [2, np.nan, 6], 'b': [1, 3, 5]},
+        ...                   index=pd.date_range('20180101', periods=3,
+        ...                                       freq='h'))
+        >>> df
+                               a  b
+        2018-01-01 00:00:00  2.0  1
+        2018-01-01 01:00:00  NaN  3
+        2018-01-01 02:00:00  6.0  5
+
+        >>> df.resample('30min').fillna("bfill")
+                               a  b
+        2018-01-01 00:00:00  2.0  1
+        2018-01-01 00:30:00  NaN  3
+        2018-01-01 01:00:00  NaN  3
+        2018-01-01 01:30:00  6.0  5
+        2018-01-01 02:00:00  6.0  5
+        """
+        warnings.warn(
+            f"{type(self).__name__}.fillna is deprecated and will be removed "
+            "in a future version. Use obj.ffill(), obj.bfill(), "
+            "or obj.nearest() instead.",
+            FutureWarning,
+            stacklevel=find_stack_level(),
+        )
+        return self._upsample(method, limit=limit)
+
+    @final
+    def interpolate(
+        self,
+        method: InterpolateOptions = "linear",
+        *,
+        axis: Axis = 0,
+        limit: int | None = None,
+        inplace: bool = False,
+        limit_direction: Literal["forward", "backward", "both"] = "forward",
+        limit_area=None,
+        downcast=lib.no_default,
+        **kwargs,
+    ):
+        """
+        Interpolate values between target timestamps according to different methods.
+
+        The original index is first reindexed to target timestamps
+        (see :meth:`core.resample.Resampler.asfreq`),
+        then the interpolation of ``NaN`` values via :meth:`DataFrame.interpolate`
+        happens.
+
+        Parameters
+        ----------
+        method : str, default 'linear'
+            Interpolation technique to use. One of:
+
+            * 'linear': Ignore the index and treat the values as equally
+              spaced. This is the only method supported on MultiIndexes.
+            * 'time': Works on daily and higher resolution data to interpolate
+              given length of interval.
+            * 'index', 'values': use the actual numerical values of the index.
+            * 'pad': Fill in NaNs using existing values.
+            * 'nearest', 'zero', 'slinear', 'quadratic', 'cubic',
+              'barycentric', 'polynomial': Passed to
+              `scipy.interpolate.interp1d`, whereas 'spline' is passed to
+              `scipy.interpolate.UnivariateSpline`. These methods use the numerical
+              values of the index.  Both 'polynomial' and 'spline' require that
+              you also specify an `order` (int), e.g.
+              ``df.interpolate(method='polynomial', order=5)``. Note that,
+              `slinear` method in Pandas refers to the Scipy first order `spline`
+              instead of Pandas first order `spline`.
+            * 'krogh', 'piecewise_polynomial', 'spline', 'pchip', 'akima',
+              'cubicspline': Wrappers around the SciPy interpolation methods of
+              similar names. See `Notes`.
+            * 'from_derivatives': Refers to
+              `scipy.interpolate.BPoly.from_derivatives`.
+
+        axis : {{0 or 'index', 1 or 'columns', None}}, default None
+            Axis to interpolate along. For `Series` this parameter is unused
+            and defaults to 0.
+        limit : int, optional
+            Maximum number of consecutive NaNs to fill. Must be greater than
+            0.
+        inplace : bool, default False
+            Update the data in place if possible.
+        limit_direction : {{'forward', 'backward', 'both'}}, Optional
+            Consecutive NaNs will be filled in this direction.
+
+            If limit is specified:
+                * If 'method' is 'pad' or 'ffill', 'limit_direction' must be 'forward'.
+                * If 'method' is 'backfill' or 'bfill', 'limit_direction' must be
+                  'backwards'.
+
+            If 'limit' is not specified:
+                * If 'method' is 'backfill' or 'bfill', the default is 'backward'
+                * else the default is 'forward'
+
+                raises ValueError if `limit_direction` is 'forward' or 'both' and
+                    method is 'backfill' or 'bfill'.
+                raises ValueError if `limit_direction` is 'backward' or 'both' and
+                    method is 'pad' or 'ffill'.
+
+        limit_area : {{`None`, 'inside', 'outside'}}, default None
+            If limit is specified, consecutive NaNs will be filled with this
+            restriction.
+
+            * ``None``: No fill restriction.
+            * 'inside': Only fill NaNs surrounded by valid values
+              (interpolate).
+            * 'outside': Only fill NaNs outside valid values (extrapolate).
+
+        downcast : optional, 'infer' or None, defaults to None
+            Downcast dtypes if possible.
+
+            .. deprecated:: 2.1.0
+
+        ``**kwargs`` : optional
+            Keyword arguments to pass on to the interpolating function.
+
+        Returns
+        -------
+        DataFrame or Series
+            Interpolated values at the specified freq.
+
+        See Also
+        --------
+        core.resample.Resampler.asfreq: Return the values at the new freq,
+            essentially a reindex.
+        DataFrame.interpolate: Fill NaN values using an interpolation method.
+
+        Notes
+        -----
+        For high-frequent or non-equidistant time-series with timestamps
+        the reindexing followed by interpolation may lead to information loss
+        as shown in the last example.
+
+        Examples
+        --------
+
+        >>> start = "2023-03-01T07:00:00"
+        >>> timesteps = pd.date_range(start, periods=5, freq="s")
+        >>> series = pd.Series(data=[1, -1, 2, 1, 3], index=timesteps)
+        >>> series
+        2023-03-01 07:00:00    1
+        2023-03-01 07:00:01   -1
+        2023-03-01 07:00:02    2
+        2023-03-01 07:00:03    1
+        2023-03-01 07:00:04    3
+        Freq: s, dtype: int64
+
+        Upsample the dataframe to 0.5Hz by providing the period time of 2s.
+
+        >>> series.resample("2s").interpolate("linear")
+        2023-03-01 07:00:00    1
+        2023-03-01 07:00:02    2
+        2023-03-01 07:00:04    3
+        Freq: 2s, dtype: int64
+
+        Downsample the dataframe to 2Hz by providing the period time of 500ms.
+
+        >>> series.resample("500ms").interpolate("linear")
+        2023-03-01 07:00:00.000    1.0
+        2023-03-01 07:00:00.500    0.0
+        2023-03-01 07:00:01.000   -1.0
+        2023-03-01 07:00:01.500    0.5
+        2023-03-01 07:00:02.000    2.0
+        2023-03-01 07:00:02.500    1.5
+        2023-03-01 07:00:03.000    1.0
+        2023-03-01 07:00:03.500    2.0
+        2023-03-01 07:00:04.000    3.0
+        Freq: 500ms, dtype: float64
+
+        Internal reindexing with ``asfreq()`` prior to interpolation leads to
+        an interpolated timeseries on the basis the reindexed timestamps (anchors).
+        Since not all datapoints from original series become anchors,
+        it can lead to misleading interpolation results as in the following example:
+
+        >>> series.resample("400ms").interpolate("linear")
+        2023-03-01 07:00:00.000    1.0
+        2023-03-01 07:00:00.400    1.2
+        2023-03-01 07:00:00.800    1.4
+        2023-03-01 07:00:01.200    1.6
+        2023-03-01 07:00:01.600    1.8
+        2023-03-01 07:00:02.000    2.0
+        2023-03-01 07:00:02.400    2.2
+        2023-03-01 07:00:02.800    2.4
+        2023-03-01 07:00:03.200    2.6
+        2023-03-01 07:00:03.600    2.8
+        2023-03-01 07:00:04.000    3.0
+        Freq: 400ms, dtype: float64
+
+        Note that the series erroneously increases between two anchors
+        ``07:00:00`` and ``07:00:02``.
+        """
+        assert downcast is lib.no_default  # just checking coverage
+        result = self._upsample("asfreq")
+        return result.interpolate(
+            method=method,
+            axis=axis,
+            limit=limit,
+            inplace=inplace,
+            limit_direction=limit_direction,
+            limit_area=limit_area,
+            downcast=downcast,
+            **kwargs,
+        )
+
+    @final
+    def asfreq(self, fill_value=None):
+        """
+        Return the values at the new freq, essentially a reindex.
+
+        Parameters
+        ----------
+        fill_value : scalar, optional
+            Value to use for missing values, applied during upsampling (note
+            this does not fill NaNs that already were present).
+
+        Returns
+        -------
+        DataFrame or Series
+            Values at the specified freq.
+
+        See Also
+        --------
+        Series.asfreq: Convert TimeSeries to specified frequency.
+        DataFrame.asfreq: Convert TimeSeries to specified frequency.
+
+        Examples
+        --------
+
+        >>> ser = pd.Series([1, 2, 3, 4], index=pd.DatetimeIndex(
+        ...                 ['2023-01-01', '2023-01-31', '2023-02-01', '2023-02-28']))
+        >>> ser
+        2023-01-01    1
+        2023-01-31    2
+        2023-02-01    3
+        2023-02-28    4
+        dtype: int64
+        >>> ser.resample('MS').asfreq()
+        2023-01-01    1
+        2023-02-01    3
+        Freq: MS, dtype: int64
+        """
+        return self._upsample("asfreq", fill_value=fill_value)
+
+    @final
+    def sum(
+        self,
+        numeric_only: bool = False,
+        min_count: int = 0,
+        *args,
+        **kwargs,
+    ):
+        """
+        Compute sum of group values.
+
+        Parameters
+        ----------
+        numeric_only : bool, default False
+            Include only float, int, boolean columns.
+
+            .. versionchanged:: 2.0.0
+
+                numeric_only no longer accepts ``None``.
+
+        min_count : int, default 0
+            The required number of valid values to perform the operation. If fewer
+            than ``min_count`` non-NA values are present the result will be NA.
+
+        Returns
+        -------
+        Series or DataFrame
+            Computed sum of values within each group.
+
+        Examples
+        --------
+        >>> ser = pd.Series([1, 2, 3, 4], index=pd.DatetimeIndex(
+        ...                 ['2023-01-01', '2023-01-15', '2023-02-01', '2023-02-15']))
+        >>> ser
+        2023-01-01    1
+        2023-01-15    2
+        2023-02-01    3
+        2023-02-15    4
+        dtype: int64
+        >>> ser.resample('MS').sum()
+        2023-01-01    3
+        2023-02-01    7
+        Freq: MS, dtype: int64
+        """
+        maybe_warn_args_and_kwargs(type(self), "sum", args, kwargs)
+        nv.validate_resampler_func("sum", args, kwargs)
+        return self._downsample("sum", numeric_only=numeric_only, min_count=min_count)
+
+    @final
+    def prod(
+        self,
+        numeric_only: bool = False,
+        min_count: int = 0,
+        *args,
+        **kwargs,
+    ):
+        """
+        Compute prod of group values.
+
+        Parameters
+        ----------
+        numeric_only : bool, default False
+            Include only float, int, boolean columns.
+
+            .. versionchanged:: 2.0.0
+
+                numeric_only no longer accepts ``None``.
+
+        min_count : int, default 0
+            The required number of valid values to perform the operation. If fewer
+            than ``min_count`` non-NA values are present the result will be NA.
+
+        Returns
+        -------
+        Series or DataFrame
+            Computed prod of values within each group.
+
+        Examples
+        --------
+        >>> ser = pd.Series([1, 2, 3, 4], index=pd.DatetimeIndex(
+        ...                 ['2023-01-01', '2023-01-15', '2023-02-01', '2023-02-15']))
+        >>> ser
+        2023-01-01    1
+        2023-01-15    2
+        2023-02-01    3
+        2023-02-15    4
+        dtype: int64
+        >>> ser.resample('MS').prod()
+        2023-01-01    2
+        2023-02-01   12
+        Freq: MS, dtype: int64
+        """
+        maybe_warn_args_and_kwargs(type(self), "prod", args, kwargs)
+        nv.validate_resampler_func("prod", args, kwargs)
+        return self._downsample("prod", numeric_only=numeric_only, min_count=min_count)
+
+    @final
+    def min(
+        self,
+        numeric_only: bool = False,
+        min_count: int = 0,
+        *args,
+        **kwargs,
+    ):
+        """
+        Compute min value of group.
+
+        Returns
+        -------
+        Series or DataFrame
+
+        Examples
+        --------
+        >>> ser = pd.Series([1, 2, 3, 4], index=pd.DatetimeIndex(
+        ...                 ['2023-01-01', '2023-01-15', '2023-02-01', '2023-02-15']))
+        >>> ser
+        2023-01-01    1
+        2023-01-15    2
+        2023-02-01    3
+        2023-02-15    4
+        dtype: int64
+        >>> ser.resample('MS').min()
+        2023-01-01    1
+        2023-02-01    3
+        Freq: MS, dtype: int64
+        """
+
+        maybe_warn_args_and_kwargs(type(self), "min", args, kwargs)
+        nv.validate_resampler_func("min", args, kwargs)
+        return self._downsample("min", numeric_only=numeric_only, min_count=min_count)
+
+    @final
+    def max(
+        self,
+        numeric_only: bool = False,
+        min_count: int = 0,
+        *args,
+        **kwargs,
+    ):
+        """
+        Compute max value of group.
+
+        Returns
+        -------
+        Series or DataFrame
+
+        Examples
+        --------
+        >>> ser = pd.Series([1, 2, 3, 4], index=pd.DatetimeIndex(
+        ...                 ['2023-01-01', '2023-01-15', '2023-02-01', '2023-02-15']))
+        >>> ser
+        2023-01-01    1
+        2023-01-15    2
+        2023-02-01    3
+        2023-02-15    4
+        dtype: int64
+        >>> ser.resample('MS').max()
+        2023-01-01    2
+        2023-02-01    4
+        Freq: MS, dtype: int64
+        """
+        maybe_warn_args_and_kwargs(type(self), "max", args, kwargs)
+        nv.validate_resampler_func("max", args, kwargs)
+        return self._downsample("max", numeric_only=numeric_only, min_count=min_count)
+
+    @final
+    @doc(GroupBy.first)
+    def first(
+        self,
+        numeric_only: bool = False,
+        min_count: int = 0,
+        skipna: bool = True,
+        *args,
+        **kwargs,
+    ):
+        maybe_warn_args_and_kwargs(type(self), "first", args, kwargs)
+        nv.validate_resampler_func("first", args, kwargs)
+        return self._downsample(
+            "first", numeric_only=numeric_only, min_count=min_count, skipna=skipna
+        )
+
+    @final
+    @doc(GroupBy.last)
+    def last(
+        self,
+        numeric_only: bool = False,
+        min_count: int = 0,
+        skipna: bool = True,
+        *args,
+        **kwargs,
+    ):
+        maybe_warn_args_and_kwargs(type(self), "last", args, kwargs)
+        nv.validate_resampler_func("last", args, kwargs)
+        return self._downsample(
+            "last", numeric_only=numeric_only, min_count=min_count, skipna=skipna
+        )
+
+    @final
+    @doc(GroupBy.median)
+    def median(self, numeric_only: bool = False, *args, **kwargs):
+        maybe_warn_args_and_kwargs(type(self), "median", args, kwargs)
+        nv.validate_resampler_func("median", args, kwargs)
+        return self._downsample("median", numeric_only=numeric_only)
+
+    @final
+    def mean(
+        self,
+        numeric_only: bool = False,
+        *args,
+        **kwargs,
+    ):
+        """
+        Compute mean of groups, excluding missing values.
+
+        Parameters
+        ----------
+        numeric_only : bool, default False
+            Include only `float`, `int` or `boolean` data.
+
+            .. versionchanged:: 2.0.0
+
+                numeric_only now defaults to ``False``.
+
+        Returns
+        -------
+        DataFrame or Series
+            Mean of values within each group.
+
+        Examples
+        --------
+
+        >>> ser = pd.Series([1, 2, 3, 4], index=pd.DatetimeIndex(
+        ...                 ['2023-01-01', '2023-01-15', '2023-02-01', '2023-02-15']))
+        >>> ser
+        2023-01-01    1
+        2023-01-15    2
+        2023-02-01    3
+        2023-02-15    4
+        dtype: int64
+        >>> ser.resample('MS').mean()
+        2023-01-01    1.5
+        2023-02-01    3.5
+        Freq: MS, dtype: float64
+        """
+        maybe_warn_args_and_kwargs(type(self), "mean", args, kwargs)
+        nv.validate_resampler_func("mean", args, kwargs)
+        return self._downsample("mean", numeric_only=numeric_only)
+
+    @final
+    def std(
+        self,
+        ddof: int = 1,
+        numeric_only: bool = False,
+        *args,
+        **kwargs,
+    ):
+        """
+        Compute standard deviation of groups, excluding missing values.
+
+        Parameters
+        ----------
+        ddof : int, default 1
+            Degrees of freedom.
+        numeric_only : bool, default False
+            Include only `float`, `int` or `boolean` data.
+
+            .. versionadded:: 1.5.0
+
+            .. versionchanged:: 2.0.0
+
+                numeric_only now defaults to ``False``.
+
+        Returns
+        -------
+        DataFrame or Series
+            Standard deviation of values within each group.
+
+        Examples
+        --------
+
+        >>> ser = pd.Series([1, 3, 2, 4, 3, 8],
+        ...                 index=pd.DatetimeIndex(['2023-01-01',
+        ...                                         '2023-01-10',
+        ...                                         '2023-01-15',
+        ...                                         '2023-02-01',
+        ...                                         '2023-02-10',
+        ...                                         '2023-02-15']))
+        >>> ser.resample('MS').std()
+        2023-01-01    1.000000
+        2023-02-01    2.645751
+        Freq: MS, dtype: float64
+        """
+        maybe_warn_args_and_kwargs(type(self), "std", args, kwargs)
+        nv.validate_resampler_func("std", args, kwargs)
+        return self._downsample("std", ddof=ddof, numeric_only=numeric_only)
+
+    @final
+    def var(
+        self,
+        ddof: int = 1,
+        numeric_only: bool = False,
+        *args,
+        **kwargs,
+    ):
+        """
+        Compute variance of groups, excluding missing values.
+
+        Parameters
+        ----------
+        ddof : int, default 1
+            Degrees of freedom.
+
+        numeric_only : bool, default False
+            Include only `float`, `int` or `boolean` data.
+
+            .. versionadded:: 1.5.0
+
+            .. versionchanged:: 2.0.0
+
+                numeric_only now defaults to ``False``.
+
+        Returns
+        -------
+        DataFrame or Series
+            Variance of values within each group.
+
+        Examples
+        --------
+
+        >>> ser = pd.Series([1, 3, 2, 4, 3, 8],
+        ...                 index=pd.DatetimeIndex(['2023-01-01',
+        ...                                         '2023-01-10',
+        ...                                         '2023-01-15',
+        ...                                         '2023-02-01',
+        ...                                         '2023-02-10',
+        ...                                         '2023-02-15']))
+        >>> ser.resample('MS').var()
+        2023-01-01    1.0
+        2023-02-01    7.0
+        Freq: MS, dtype: float64
+
+        >>> ser.resample('MS').var(ddof=0)
+        2023-01-01    0.666667
+        2023-02-01    4.666667
+        Freq: MS, dtype: float64
+        """
+        maybe_warn_args_and_kwargs(type(self), "var", args, kwargs)
+        nv.validate_resampler_func("var", args, kwargs)
+        return self._downsample("var", ddof=ddof, numeric_only=numeric_only)
+
+    @final
+    @doc(GroupBy.sem)
+    def sem(
+        self,
+        ddof: int = 1,
+        numeric_only: bool = False,
+        *args,
+        **kwargs,
+    ):
+        maybe_warn_args_and_kwargs(type(self), "sem", args, kwargs)
+        nv.validate_resampler_func("sem", args, kwargs)
+        return self._downsample("sem", ddof=ddof, numeric_only=numeric_only)
+
+    @final
+    @doc(GroupBy.ohlc)
+    def ohlc(
+        self,
+        *args,
+        **kwargs,
+    ):
+        maybe_warn_args_and_kwargs(type(self), "ohlc", args, kwargs)
+        nv.validate_resampler_func("ohlc", args, kwargs)
+
+        ax = self.ax
+        obj = self._obj_with_exclusions
+        if len(ax) == 0:
+            # GH#42902
+            obj = obj.copy()
+            obj.index = _asfreq_compat(obj.index, self.freq)
+            if obj.ndim == 1:
+                obj = obj.to_frame()
+                obj = obj.reindex(["open", "high", "low", "close"], axis=1)
+            else:
+                mi = MultiIndex.from_product(
+                    [obj.columns, ["open", "high", "low", "close"]]
+                )
+                obj = obj.reindex(mi, axis=1)
+            return obj
+
+        return self._downsample("ohlc")
+
+    @final
+    @doc(SeriesGroupBy.nunique)
+    def nunique(
+        self,
+        *args,
+        **kwargs,
+    ):
+        maybe_warn_args_and_kwargs(type(self), "nunique", args, kwargs)
+        nv.validate_resampler_func("nunique", args, kwargs)
+        return self._downsample("nunique")
+
+    @final
+    @doc(GroupBy.size)
+    def size(self):
+        result = self._downsample("size")
+
+        # If the result is a non-empty DataFrame we stack to get a Series
+        # GH 46826
+        if isinstance(result, ABCDataFrame) and not result.empty:
+            result = result.stack(future_stack=True)
+
+        if not len(self.ax):
+            from pandas import Series
+
+            if self._selected_obj.ndim == 1:
+                name = self._selected_obj.name
+            else:
+                name = None
+            result = Series([], index=result.index, dtype="int64", name=name)
+        return result
+
+    @final
+    @doc(GroupBy.count)
+    def count(self):
+        result = self._downsample("count")
+        if not len(self.ax):
+            if self._selected_obj.ndim == 1:
+                result = type(self._selected_obj)(
+                    [], index=result.index, dtype="int64", name=self._selected_obj.name
+                )
+            else:
+                from pandas import DataFrame
+
+                result = DataFrame(
+                    [], index=result.index, columns=result.columns, dtype="int64"
+                )
+
+        return result
+
+    @final
+    def quantile(self, q: float | list[float] | AnyArrayLike = 0.5, **kwargs):
+        """
+        Return value at the given quantile.
+
+        Parameters
+        ----------
+        q : float or array-like, default 0.5 (50% quantile)
+
+        Returns
+        -------
+        DataFrame or Series
+            Quantile of values within each group.
+
+        See Also
+        --------
+        Series.quantile
+            Return a series, where the index is q and the values are the quantiles.
+        DataFrame.quantile
+            Return a DataFrame, where the columns are the columns of self,
+            and the values are the quantiles.
+        DataFrameGroupBy.quantile
+            Return a DataFrame, where the columns are groupby columns,
+            and the values are its quantiles.
+
+        Examples
+        --------
+
+        >>> ser = pd.Series([1, 3, 2, 4, 3, 8],
+        ...                 index=pd.DatetimeIndex(['2023-01-01',
+        ...                                         '2023-01-10',
+        ...                                         '2023-01-15',
+        ...                                         '2023-02-01',
+        ...                                         '2023-02-10',
+        ...                                         '2023-02-15']))
+        >>> ser.resample('MS').quantile()
+        2023-01-01    2.0
+        2023-02-01    4.0
+        Freq: MS, dtype: float64
+
+        >>> ser.resample('MS').quantile(.25)
+        2023-01-01    1.5
+        2023-02-01    3.5
+        Freq: MS, dtype: float64
+        """
+        return self._downsample("quantile", q=q, **kwargs)
+
+
+class _GroupByMixin(PandasObject, SelectionMixin):
+    """
+    Provide the groupby facilities.
+    """
+
+    _attributes: list[str]  # in practice the same as Resampler._attributes
+    _selection: IndexLabel | None = None
+    _groupby: GroupBy
+    _timegrouper: TimeGrouper
+
+    def __init__(
+        self,
+        *,
+        parent: Resampler,
+        groupby: GroupBy,
+        key=None,
+        selection: IndexLabel | None = None,
+        include_groups: bool = False,
+    ) -> None:
+        # reached via ._gotitem and _get_resampler_for_grouping
+
+        assert isinstance(groupby, GroupBy), type(groupby)
+
+        # parent is always a Resampler, sometimes a _GroupByMixin
+        assert isinstance(parent, Resampler), type(parent)
+
+        # initialize our GroupByMixin object with
+        # the resampler attributes
+        for attr in self._attributes:
+            setattr(self, attr, getattr(parent, attr))
+        self._selection = selection
+
+        self.binner = parent.binner
+        self.key = key
+
+        self._groupby = groupby
+        self._timegrouper = copy.copy(parent._timegrouper)
+
+        self.ax = parent.ax
+        self.obj = parent.obj
+        self.include_groups = include_groups
+
+    @no_type_check
+    def _apply(self, f, *args, **kwargs):
+        """
+        Dispatch to _upsample; we are stripping all of the _upsample kwargs and
+        performing the original function call on the grouped object.
+        """
+
+        def func(x):
+            x = self._resampler_cls(x, timegrouper=self._timegrouper, gpr_index=self.ax)
+
+            if isinstance(f, str):
+                return getattr(x, f)(**kwargs)
+
+            return x.apply(f, *args, **kwargs)
+
+        result = _apply(self._groupby, func, include_groups=self.include_groups)
+        return self._wrap_result(result)
+
+    _upsample = _apply
+    _downsample = _apply
+    _groupby_and_aggregate = _apply
+
+    @final
+    def _gotitem(self, key, ndim, subset=None):
+        """
+        Sub-classes to define. Return a sliced object.
+
+        Parameters
+        ----------
+        key : string / list of selections
+        ndim : {1, 2}
+            requested ndim of result
+        subset : object, default None
+            subset to act on
+        """
+        # create a new object to prevent aliasing
+        if subset is None:
+            subset = self.obj
+            if key is not None:
+                subset = subset[key]
+            else:
+                # reached via Apply.agg_dict_like with selection=None, ndim=1
+                assert subset.ndim == 1
+
+        # Try to select from a DataFrame, falling back to a Series
+        try:
+            if isinstance(key, list) and self.key not in key and self.key is not None:
+                key.append(self.key)
+            groupby = self._groupby[key]
+        except IndexError:
+            groupby = self._groupby
+
+        selection = self._infer_selection(key, subset)
+
+        new_rs = type(self)(
+            groupby=groupby,
+            parent=cast(Resampler, self),
+            selection=selection,
+        )
+        return new_rs
+
+
+class DatetimeIndexResampler(Resampler):
+    ax: DatetimeIndex
+
+    @property
+    def _resampler_for_grouping(self):
+        return DatetimeIndexResamplerGroupby
+
+    def _get_binner_for_time(self):
+        # this is how we are actually creating the bins
+        if self.kind == "period":
+            return self._timegrouper._get_time_period_bins(self.ax)
+        return self._timegrouper._get_time_bins(self.ax)
+
+    def _downsample(self, how, **kwargs):
+        """
+        Downsample the cython defined function.
+
+        Parameters
+        ----------
+        how : string / cython mapped function
+        **kwargs : kw args passed to how function
+        """
+        orig_how = how
+        how = com.get_cython_func(how) or how
+        if orig_how != how:
+            warn_alias_replacement(self, orig_how, how)
+        ax = self.ax
+
+        # Excludes `on` column when provided
+        obj = self._obj_with_exclusions
+
+        if not len(ax):
+            # reset to the new freq
+            obj = obj.copy()
+            obj.index = obj.index._with_freq(self.freq)
+            assert obj.index.freq == self.freq, (obj.index.freq, self.freq)
+            return obj
+
+        # do we have a regular frequency
+
+        # error: Item "None" of "Optional[Any]" has no attribute "binlabels"
+        if (
+            (ax.freq is not None or ax.inferred_freq is not None)
+            and len(self._grouper.binlabels) > len(ax)
+            and how is None
+        ):
+            # let's do an asfreq
+            return self.asfreq()
+
+        # we are downsampling
+        # we want to call the actual grouper method here
+        if self.axis == 0:
+            result = obj.groupby(self._grouper).aggregate(how, **kwargs)
+        else:
+            # test_resample_axis1
+            result = obj.T.groupby(self._grouper).aggregate(how, **kwargs).T
+
+        return self._wrap_result(result)
+
+    def _adjust_binner_for_upsample(self, binner):
+        """
+        Adjust our binner when upsampling.
+
+        The range of a new index should not be outside specified range
+        """
+        if self.closed == "right":
+            binner = binner[1:]
+        else:
+            binner = binner[:-1]
+        return binner
+
+    def _upsample(self, method, limit: int | None = None, fill_value=None):
+        """
+        Parameters
+        ----------
+        method : string {'backfill', 'bfill', 'pad',
+            'ffill', 'asfreq'} method for upsampling
+        limit : int, default None
+            Maximum size gap to fill when reindexing
+        fill_value : scalar, default None
+            Value to use for missing values
+
+        See Also
+        --------
+        .fillna: Fill NA/NaN values using the specified method.
+
+        """
+        if self.axis:
+            raise AssertionError("axis must be 0")
+        if self._from_selection:
+            raise ValueError(
+                "Upsampling from level= or on= selection "
+                "is not supported, use .set_index(...) "
+                "to explicitly set index to datetime-like"
+            )
+
+        ax = self.ax
+        obj = self._selected_obj
+        binner = self.binner
+        res_index = self._adjust_binner_for_upsample(binner)
+
+        # if we have the same frequency as our axis, then we are equal sampling
+        if (
+            limit is None
+            and to_offset(ax.inferred_freq) == self.freq
+            and len(obj) == len(res_index)
+        ):
+            result = obj.copy()
+            result.index = res_index
+        else:
+            if method == "asfreq":
+                method = None
+            result = obj.reindex(
+                res_index, method=method, limit=limit, fill_value=fill_value
+            )
+
+        return self._wrap_result(result)
+
+    def _wrap_result(self, result):
+        result = super()._wrap_result(result)
+
+        # we may have a different kind that we were asked originally
+        # convert if needed
+        if self.kind == "period" and not isinstance(result.index, PeriodIndex):
+            if isinstance(result.index, MultiIndex):
+                # GH 24103 - e.g. groupby resample
+                if not isinstance(result.index.levels[-1], PeriodIndex):
+                    new_level = result.index.levels[-1].to_period(self.freq)
+                    result.index = result.index.set_levels(new_level, level=-1)
+            else:
+                result.index = result.index.to_period(self.freq)
+        return result
+
+
+# error: Definition of "ax" in base class "_GroupByMixin" is incompatible
+# with definition in base class "DatetimeIndexResampler"
+class DatetimeIndexResamplerGroupby(  # type: ignore[misc]
+    _GroupByMixin, DatetimeIndexResampler
+):
+    """
+    Provides a resample of a groupby implementation
+    """
+
+    @property
+    def _resampler_cls(self):
+        return DatetimeIndexResampler
+
+
+class PeriodIndexResampler(DatetimeIndexResampler):
+    # error: Incompatible types in assignment (expression has type "PeriodIndex", base
+    # class "DatetimeIndexResampler" defined the type as "DatetimeIndex")
+    ax: PeriodIndex  # type: ignore[assignment]
+
+    @property
+    def _resampler_for_grouping(self):
+        warnings.warn(
+            "Resampling a groupby with a PeriodIndex is deprecated. "
+            "Cast to DatetimeIndex before resampling instead.",
+            FutureWarning,
+            stacklevel=find_stack_level(),
+        )
+        return PeriodIndexResamplerGroupby
+
+    def _get_binner_for_time(self):
+        if self.kind == "timestamp":
+            return super()._get_binner_for_time()
+        return self._timegrouper._get_period_bins(self.ax)
+
+    def _convert_obj(self, obj: NDFrameT) -> NDFrameT:
+        obj = super()._convert_obj(obj)
+
+        if self._from_selection:
+            # see GH 14008, GH 12871
+            msg = (
+                "Resampling from level= or on= selection "
+                "with a PeriodIndex is not currently supported, "
+                "use .set_index(...) to explicitly set index"
+            )
+            raise NotImplementedError(msg)
+
+        # convert to timestamp
+        if self.kind == "timestamp":
+            obj = obj.to_timestamp(how=self.convention)
+
+        return obj
+
+    def _downsample(self, how, **kwargs):
+        """
+        Downsample the cython defined function.
+
+        Parameters
+        ----------
+        how : string / cython mapped function
+        **kwargs : kw args passed to how function
+        """
+        # we may need to actually resample as if we are timestamps
+        if self.kind == "timestamp":
+            return super()._downsample(how, **kwargs)
+
+        orig_how = how
+        how = com.get_cython_func(how) or how
+        if orig_how != how:
+            warn_alias_replacement(self, orig_how, how)
+        ax = self.ax
+
+        if is_subperiod(ax.freq, self.freq):
+            # Downsampling
+            return self._groupby_and_aggregate(how, **kwargs)
+        elif is_superperiod(ax.freq, self.freq):
+            if how == "ohlc":
+                # GH #13083
+                # upsampling to subperiods is handled as an asfreq, which works
+                # for pure aggregating/reducing methods
+                # OHLC reduces along the time dimension, but creates multiple
+                # values for each period -> handle by _groupby_and_aggregate()
+                return self._groupby_and_aggregate(how)
+            return self.asfreq()
+        elif ax.freq == self.freq:
+            return self.asfreq()
+
+        raise IncompatibleFrequency(
+            f"Frequency {ax.freq} cannot be resampled to {self.freq}, "
+            "as they are not sub or super periods"
+        )
+
+    def _upsample(self, method, limit: int | None = None, fill_value=None):
+        """
+        Parameters
+        ----------
+        method : {'backfill', 'bfill', 'pad', 'ffill'}
+            Method for upsampling.
+        limit : int, default None
+            Maximum size gap to fill when reindexing.
+        fill_value : scalar, default None
+            Value to use for missing values.
+
+        See Also
+        --------
+        .fillna: Fill NA/NaN values using the specified method.
+
+        """
+        # we may need to actually resample as if we are timestamps
+        if self.kind == "timestamp":
+            return super()._upsample(method, limit=limit, fill_value=fill_value)
+
+        ax = self.ax
+        obj = self.obj
+        new_index = self.binner
+
+        # Start vs. end of period
+        memb = ax.asfreq(self.freq, how=self.convention)
+
+        # Get the fill indexer
+        if method == "asfreq":
+            method = None
+        indexer = memb.get_indexer(new_index, method=method, limit=limit)
+        new_obj = _take_new_index(
+            obj,
+            indexer,
+            new_index,
+            axis=self.axis,
+        )
+        return self._wrap_result(new_obj)
+
+
+# error: Definition of "ax" in base class "_GroupByMixin" is incompatible with
+# definition in base class "PeriodIndexResampler"
+class PeriodIndexResamplerGroupby(  # type: ignore[misc]
+    _GroupByMixin, PeriodIndexResampler
+):
+    """
+    Provides a resample of a groupby implementation.
+    """
+
+    @property
+    def _resampler_cls(self):
+        return PeriodIndexResampler
+
+
+class TimedeltaIndexResampler(DatetimeIndexResampler):
+    # error: Incompatible types in assignment (expression has type "TimedeltaIndex",
+    # base class "DatetimeIndexResampler" defined the type as "DatetimeIndex")
+    ax: TimedeltaIndex  # type: ignore[assignment]
+
+    @property
+    def _resampler_for_grouping(self):
+        return TimedeltaIndexResamplerGroupby
+
+    def _get_binner_for_time(self):
+        return self._timegrouper._get_time_delta_bins(self.ax)
+
+    def _adjust_binner_for_upsample(self, binner):
+        """
+        Adjust our binner when upsampling.
+
+        The range of a new index is allowed to be greater than original range
+        so we don't need to change the length of a binner, GH 13022
+        """
+        return binner
+
+
+# error: Definition of "ax" in base class "_GroupByMixin" is incompatible with
+# definition in base class "DatetimeIndexResampler"
+class TimedeltaIndexResamplerGroupby(  # type: ignore[misc]
+    _GroupByMixin, TimedeltaIndexResampler
+):
+    """
+    Provides a resample of a groupby implementation.
+    """
+
+    @property
+    def _resampler_cls(self):
+        return TimedeltaIndexResampler
+
+
+def get_resampler(obj: Series | DataFrame, kind=None, **kwds) -> Resampler:
+    """
+    Create a TimeGrouper and return our resampler.
+    """
+    tg = TimeGrouper(obj, **kwds)  # type: ignore[arg-type]
+    return tg._get_resampler(obj, kind=kind)
+
+
+get_resampler.__doc__ = Resampler.__doc__
+
+
+def get_resampler_for_grouping(
+    groupby: GroupBy,
+    rule,
+    how=None,
+    fill_method=None,
+    limit: int | None = None,
+    kind=None,
+    on=None,
+    include_groups: bool = True,
+    **kwargs,
+) -> Resampler:
+    """
+    Return our appropriate resampler when grouping as well.
+    """
+    # .resample uses 'on' similar to how .groupby uses 'key'
+    tg = TimeGrouper(freq=rule, key=on, **kwargs)
+    resampler = tg._get_resampler(groupby.obj, kind=kind)
+    return resampler._get_resampler_for_grouping(
+        groupby=groupby, include_groups=include_groups, key=tg.key
+    )
+
+
+class TimeGrouper(Grouper):
+    """
+    Custom groupby class for time-interval grouping.
+
+    Parameters
+    ----------
+    freq : pandas date offset or offset alias for identifying bin edges
+    closed : closed end of interval; 'left' or 'right'
+    label : interval boundary to use for labeling; 'left' or 'right'
+    convention : {'start', 'end', 'e', 's'}
+        If axis is PeriodIndex
+    """
+
+    _attributes = Grouper._attributes + (
+        "closed",
+        "label",
+        "how",
+        "kind",
+        "convention",
+        "origin",
+        "offset",
+    )
+
+    origin: TimeGrouperOrigin
+
+    def __init__(
+        self,
+        obj: Grouper | None = None,
+        freq: Frequency = "Min",
+        key: str | None = None,
+        closed: Literal["left", "right"] | None = None,
+        label: Literal["left", "right"] | None = None,
+        how: str = "mean",
+        axis: Axis = 0,
+        fill_method=None,
+        limit: int | None = None,
+        kind: str | None = None,
+        convention: Literal["start", "end", "e", "s"] | None = None,
+        origin: Literal["epoch", "start", "start_day", "end", "end_day"]
+        | TimestampConvertibleTypes = "start_day",
+        offset: TimedeltaConvertibleTypes | None = None,
+        group_keys: bool = False,
+        **kwargs,
+    ) -> None:
+        # Check for correctness of the keyword arguments which would
+        # otherwise silently use the default if misspelled
+        if label not in {None, "left", "right"}:
+            raise ValueError(f"Unsupported value {label} for `label`")
+        if closed not in {None, "left", "right"}:
+            raise ValueError(f"Unsupported value {closed} for `closed`")
+        if convention not in {None, "start", "end", "e", "s"}:
+            raise ValueError(f"Unsupported value {convention} for `convention`")
+
+        if (
+            key is None
+            and obj is not None
+            and isinstance(obj.index, PeriodIndex)  # type: ignore[attr-defined]
+            or (
+                key is not None
+                and obj is not None
+                and getattr(obj[key], "dtype", None) == "period"  # type: ignore[index]
+            )
+        ):
+            freq = to_offset(freq, is_period=True)
+        else:
+            freq = to_offset(freq)
+
+        end_types = {"ME", "YE", "QE", "BME", "BYE", "BQE", "W"}
+        rule = freq.rule_code
+        if rule in end_types or ("-" in rule and rule[: rule.find("-")] in end_types):
+            if closed is None:
+                closed = "right"
+            if label is None:
+                label = "right"
+        else:
+            # The backward resample sets ``closed`` to ``'right'`` by default
+            # since the last value should be considered as the edge point for
+            # the last bin. When origin in "end" or "end_day", the value for a
+            # specific ``Timestamp`` index stands for the resample result from
+            # the current ``Timestamp`` minus ``freq`` to the current
+            # ``Timestamp`` with a right close.
+            if origin in ["end", "end_day"]:
+                if closed is None:
+                    closed = "right"
+                if label is None:
+                    label = "right"
+            else:
+                if closed is None:
+                    closed = "left"
+                if label is None:
+                    label = "left"
+
+        self.closed = closed
+        self.label = label
+        self.kind = kind
+        self.convention = convention if convention is not None else "e"
+        self.how = how
+        self.fill_method = fill_method
+        self.limit = limit
+        self.group_keys = group_keys
+        self._arrow_dtype: ArrowDtype | None = None
+
+        if origin in ("epoch", "start", "start_day", "end", "end_day"):
+            # error: Incompatible types in assignment (expression has type "Union[Union[
+            # Timestamp, datetime, datetime64, signedinteger[_64Bit], float, str],
+            # Literal['epoch', 'start', 'start_day', 'end', 'end_day']]", variable has
+            # type "Union[Timestamp, Literal['epoch', 'start', 'start_day', 'end',
+            # 'end_day']]")
+            self.origin = origin  # type: ignore[assignment]
+        else:
+            try:
+                self.origin = Timestamp(origin)
+            except (ValueError, TypeError) as err:
+                raise ValueError(
+                    "'origin' should be equal to 'epoch', 'start', 'start_day', "
+                    "'end', 'end_day' or "
+                    f"should be a Timestamp convertible type. Got '{origin}' instead."
+                ) from err
+
+        try:
+            self.offset = Timedelta(offset) if offset is not None else None
+        except (ValueError, TypeError) as err:
+            raise ValueError(
+                "'offset' should be a Timedelta convertible type. "
+                f"Got '{offset}' instead."
+            ) from err
+
+        # always sort time groupers
+        kwargs["sort"] = True
+
+        super().__init__(freq=freq, key=key, axis=axis, **kwargs)
+
+    def _get_resampler(self, obj: NDFrame, kind=None) -> Resampler:
+        """
+        Return my resampler or raise if we have an invalid axis.
+
+        Parameters
+        ----------
+        obj : Series or DataFrame
+        kind : string, optional
+            'period','timestamp','timedelta' are valid
+
+        Returns
+        -------
+        Resampler
+
+        Raises
+        ------
+        TypeError if incompatible axis
+
+        """
+        _, ax, _ = self._set_grouper(obj, gpr_index=None)
+        if isinstance(ax, DatetimeIndex):
+            return DatetimeIndexResampler(
+                obj,
+                timegrouper=self,
+                kind=kind,
+                axis=self.axis,
+                group_keys=self.group_keys,
+                gpr_index=ax,
+            )
+        elif isinstance(ax, PeriodIndex) or kind == "period":
+            if isinstance(ax, PeriodIndex):
+                # GH#53481
+                warnings.warn(
+                    "Resampling with a PeriodIndex is deprecated. "
+                    "Cast index to DatetimeIndex before resampling instead.",
+                    FutureWarning,
+                    stacklevel=find_stack_level(),
+                )
+            else:
+                warnings.warn(
+                    "Resampling with kind='period' is deprecated.  "
+                    "Use datetime paths instead.",
+                    FutureWarning,
+                    stacklevel=find_stack_level(),
+                )
+            return PeriodIndexResampler(
+                obj,
+                timegrouper=self,
+                kind=kind,
+                axis=self.axis,
+                group_keys=self.group_keys,
+                gpr_index=ax,
+            )
+        elif isinstance(ax, TimedeltaIndex):
+            return TimedeltaIndexResampler(
+                obj,
+                timegrouper=self,
+                axis=self.axis,
+                group_keys=self.group_keys,
+                gpr_index=ax,
+            )
+
+        raise TypeError(
+            "Only valid with DatetimeIndex, "
+            "TimedeltaIndex or PeriodIndex, "
+            f"but got an instance of '{type(ax).__name__}'"
+        )
+
+    def _get_grouper(
+        self, obj: NDFrameT, validate: bool = True
+    ) -> tuple[BinGrouper, NDFrameT]:
+        # create the resampler and return our binner
+        r = self._get_resampler(obj)
+        return r._grouper, cast(NDFrameT, r.obj)
+
+    def _get_time_bins(self, ax: DatetimeIndex):
+        if not isinstance(ax, DatetimeIndex):
+            raise TypeError(
+                "axis must be a DatetimeIndex, but got "
+                f"an instance of {type(ax).__name__}"
+            )
+
+        if len(ax) == 0:
+            binner = labels = DatetimeIndex(
+                data=[], freq=self.freq, name=ax.name, dtype=ax.dtype
+            )
+            return binner, [], labels
+
+        first, last = _get_timestamp_range_edges(
+            ax.min(),
+            ax.max(),
+            self.freq,
+            unit=ax.unit,
+            closed=self.closed,
+            origin=self.origin,
+            offset=self.offset,
+        )
+        # GH #12037
+        # use first/last directly instead of call replace() on them
+        # because replace() will swallow the nanosecond part
+        # thus last bin maybe slightly before the end if the end contains
+        # nanosecond part and lead to `Values falls after last bin` error
+        # GH 25758: If DST lands at midnight (e.g. 'America/Havana'), user feedback
+        # has noted that ambiguous=True provides the most sensible result
+        binner = labels = date_range(
+            freq=self.freq,
+            start=first,
+            end=last,
+            tz=ax.tz,
+            name=ax.name,
+            ambiguous=True,
+            nonexistent="shift_forward",
+            unit=ax.unit,
+        )
+
+        ax_values = ax.asi8
+        binner, bin_edges = self._adjust_bin_edges(binner, ax_values)
+
+        # general version, knowing nothing about relative frequencies
+        bins = lib.generate_bins_dt64(
+            ax_values, bin_edges, self.closed, hasnans=ax.hasnans
+        )
+
+        if self.closed == "right":
+            labels = binner
+            if self.label == "right":
+                labels = labels[1:]
+        elif self.label == "right":
+            labels = labels[1:]
+
+        if ax.hasnans:
+            binner = binner.insert(0, NaT)
+            labels = labels.insert(0, NaT)
+
+        # if we end up with more labels than bins
+        # adjust the labels
+        # GH4076
+        if len(bins) < len(labels):
+            labels = labels[: len(bins)]
+
+        return binner, bins, labels
+
+    def _adjust_bin_edges(
+        self, binner: DatetimeIndex, ax_values: npt.NDArray[np.int64]
+    ) -> tuple[DatetimeIndex, npt.NDArray[np.int64]]:
+        # Some hacks for > daily data, see #1471, #1458, #1483
+
+        if self.freq.name in ("BME", "ME", "W") or self.freq.name.split("-")[0] in (
+            "BQE",
+            "BYE",
+            "QE",
+            "YE",
+            "W",
+        ):
+            # If the right end-point is on the last day of the month, roll forwards
+            # until the last moment of that day. Note that we only do this for offsets
+            # which correspond to the end of a super-daily period - "month start", for
+            # example, is excluded.
+            if self.closed == "right":
+                # GH 21459, GH 9119: Adjust the bins relative to the wall time
+                edges_dti = binner.tz_localize(None)
+                edges_dti = (
+                    edges_dti
+                    + Timedelta(days=1, unit=edges_dti.unit).as_unit(edges_dti.unit)
+                    - Timedelta(1, unit=edges_dti.unit).as_unit(edges_dti.unit)
+                )
+                bin_edges = edges_dti.tz_localize(binner.tz).asi8
+            else:
+                bin_edges = binner.asi8
+
+            # intraday values on last day
+            if bin_edges[-2] > ax_values.max():
+                bin_edges = bin_edges[:-1]
+                binner = binner[:-1]
+        else:
+            bin_edges = binner.asi8
+        return binner, bin_edges
+
+    def _get_time_delta_bins(self, ax: TimedeltaIndex):
+        if not isinstance(ax, TimedeltaIndex):
+            raise TypeError(
+                "axis must be a TimedeltaIndex, but got "
+                f"an instance of {type(ax).__name__}"
+            )
+
+        if not isinstance(self.freq, Tick):
+            # GH#51896
+            raise ValueError(
+                "Resampling on a TimedeltaIndex requires fixed-duration `freq`, "
+                f"e.g. '24h' or '3D', not {self.freq}"
+            )
+
+        if not len(ax):
+            binner = labels = TimedeltaIndex(data=[], freq=self.freq, name=ax.name)
+            return binner, [], labels
+
+        start, end = ax.min(), ax.max()
+
+        if self.closed == "right":
+            end += self.freq
+
+        labels = binner = timedelta_range(
+            start=start, end=end, freq=self.freq, name=ax.name
+        )
+
+        end_stamps = labels
+        if self.closed == "left":
+            end_stamps += self.freq
+
+        bins = ax.searchsorted(end_stamps, side=self.closed)
+
+        if self.offset:
+            # GH 10530 & 31809
+            labels += self.offset
+
+        return binner, bins, labels
+
+    def _get_time_period_bins(self, ax: DatetimeIndex):
+        if not isinstance(ax, DatetimeIndex):
+            raise TypeError(
+                "axis must be a DatetimeIndex, but got "
+                f"an instance of {type(ax).__name__}"
+            )
+
+        freq = self.freq
+
+        if len(ax) == 0:
+            binner = labels = PeriodIndex(
+                data=[], freq=freq, name=ax.name, dtype=ax.dtype
+            )
+            return binner, [], labels
+
+        labels = binner = period_range(start=ax[0], end=ax[-1], freq=freq, name=ax.name)
+
+        end_stamps = (labels + freq).asfreq(freq, "s").to_timestamp()
+        if ax.tz:
+            end_stamps = end_stamps.tz_localize(ax.tz)
+        bins = ax.searchsorted(end_stamps, side="left")
+
+        return binner, bins, labels
+
+    def _get_period_bins(self, ax: PeriodIndex):
+        if not isinstance(ax, PeriodIndex):
+            raise TypeError(
+                "axis must be a PeriodIndex, but got "
+                f"an instance of {type(ax).__name__}"
+            )
+
+        memb = ax.asfreq(self.freq, how=self.convention)
+
+        # NaT handling as in pandas._lib.lib.generate_bins_dt64()
+        nat_count = 0
+        if memb.hasnans:
+            # error: Incompatible types in assignment (expression has type
+            # "bool_", variable has type "int")  [assignment]
+            nat_count = np.sum(memb._isnan)  # type: ignore[assignment]
+            memb = memb[~memb._isnan]
+
+        if not len(memb):
+            # index contains no valid (non-NaT) values
+            bins = np.array([], dtype=np.int64)
+            binner = labels = PeriodIndex(data=[], freq=self.freq, name=ax.name)
+            if len(ax) > 0:
+                # index is all NaT
+                binner, bins, labels = _insert_nat_bin(binner, bins, labels, len(ax))
+            return binner, bins, labels
+
+        freq_mult = self.freq.n
+
+        start = ax.min().asfreq(self.freq, how=self.convention)
+        end = ax.max().asfreq(self.freq, how="end")
+        bin_shift = 0
+
+        if isinstance(self.freq, Tick):
+            # GH 23882 & 31809: get adjusted bin edge labels with 'origin'
+            # and 'origin' support. This call only makes sense if the freq is a
+            # Tick since offset and origin are only used in those cases.
+            # Not doing this check could create an extra empty bin.
+            p_start, end = _get_period_range_edges(
+                start,
+                end,
+                self.freq,
+                closed=self.closed,
+                origin=self.origin,
+                offset=self.offset,
+            )
+
+            # Get offset for bin edge (not label edge) adjustment
+            start_offset = Period(start, self.freq) - Period(p_start, self.freq)
+            # error: Item "Period" of "Union[Period, Any]" has no attribute "n"
+            bin_shift = start_offset.n % freq_mult  # type: ignore[union-attr]
+            start = p_start
+
+        labels = binner = period_range(
+            start=start, end=end, freq=self.freq, name=ax.name
+        )
+
+        i8 = memb.asi8
+
+        # when upsampling to subperiods, we need to generate enough bins
+        expected_bins_count = len(binner) * freq_mult
+        i8_extend = expected_bins_count - (i8[-1] - i8[0])
+        rng = np.arange(i8[0], i8[-1] + i8_extend, freq_mult)
+        rng += freq_mult
+        # adjust bin edge indexes to account for base
+        rng -= bin_shift
+
+        # Wrap in PeriodArray for PeriodArray.searchsorted
+        prng = type(memb._data)(rng, dtype=memb.dtype)
+        bins = memb.searchsorted(prng, side="left")
+
+        if nat_count > 0:
+            binner, bins, labels = _insert_nat_bin(binner, bins, labels, nat_count)
+
+        return binner, bins, labels
+
+    def _set_grouper(
+        self, obj: NDFrameT, sort: bool = False, *, gpr_index: Index | None = None
+    ) -> tuple[NDFrameT, Index, npt.NDArray[np.intp] | None]:
+        obj, ax, indexer = super()._set_grouper(obj, sort, gpr_index=gpr_index)
+        if isinstance(ax.dtype, ArrowDtype) and ax.dtype.kind in "Mm":
+            self._arrow_dtype = ax.dtype
+            ax = Index(
+                cast(ArrowExtensionArray, ax.array)._maybe_convert_datelike_array()
+            )
+        return obj, ax, indexer
+
+
+def _take_new_index(
+    obj: NDFrameT, indexer: npt.NDArray[np.intp], new_index: Index, axis: AxisInt = 0
+) -> NDFrameT:
+    if isinstance(obj, ABCSeries):
+        new_values = algos.take_nd(obj._values, indexer)
+        # error: Incompatible return value type (got "Series", expected "NDFrameT")
+        return obj._constructor(  # type: ignore[return-value]
+            new_values, index=new_index, name=obj.name
+        )
+    elif isinstance(obj, ABCDataFrame):
+        if axis == 1:
+            raise NotImplementedError("axis 1 is not supported")
+        new_mgr = obj._mgr.reindex_indexer(new_axis=new_index, indexer=indexer, axis=1)
+        # error: Incompatible return value type (got "DataFrame", expected "NDFrameT")
+        return obj._constructor_from_mgr(new_mgr, axes=new_mgr.axes)  # type: ignore[return-value]
+    else:
+        raise ValueError("'obj' should be either a Series or a DataFrame")
+
+
+def _get_timestamp_range_edges(
+    first: Timestamp,
+    last: Timestamp,
+    freq: BaseOffset,
+    unit: str,
+    closed: Literal["right", "left"] = "left",
+    origin: TimeGrouperOrigin = "start_day",
+    offset: Timedelta | None = None,
+) -> tuple[Timestamp, Timestamp]:
+    """
+    Adjust the `first` Timestamp to the preceding Timestamp that resides on
+    the provided offset. Adjust the `last` Timestamp to the following
+    Timestamp that resides on the provided offset. Input Timestamps that
+    already reside on the offset will be adjusted depending on the type of
+    offset and the `closed` parameter.
+
+    Parameters
+    ----------
+    first : pd.Timestamp
+        The beginning Timestamp of the range to be adjusted.
+    last : pd.Timestamp
+        The ending Timestamp of the range to be adjusted.
+    freq : pd.DateOffset
+        The dateoffset to which the Timestamps will be adjusted.
+    closed : {'right', 'left'}, default "left"
+        Which side of bin interval is closed.
+    origin : {'epoch', 'start', 'start_day'} or Timestamp, default 'start_day'
+        The timestamp on which to adjust the grouping. The timezone of origin must
+        match the timezone of the index.
+        If a timestamp is not used, these values are also supported:
+
+        - 'epoch': `origin` is 1970-01-01
+        - 'start': `origin` is the first value of the timeseries
+        - 'start_day': `origin` is the first day at midnight of the timeseries
+    offset : pd.Timedelta, default is None
+        An offset timedelta added to the origin.
+
+    Returns
+    -------
+    A tuple of length 2, containing the adjusted pd.Timestamp objects.
+    """
+    if isinstance(freq, Tick):
+        index_tz = first.tz
+        if isinstance(origin, Timestamp) and (origin.tz is None) != (index_tz is None):
+            raise ValueError("The origin must have the same timezone as the index.")
+        if origin == "epoch":
+            # set the epoch based on the timezone to have similar bins results when
+            # resampling on the same kind of indexes on different timezones
+            origin = Timestamp("1970-01-01", tz=index_tz)
+
+        if isinstance(freq, Day):
+            # _adjust_dates_anchored assumes 'D' means 24h, but first/last
+            # might contain a DST transition (23h, 24h, or 25h).
+            # So "pretend" the dates are naive when adjusting the endpoints
+            first = first.tz_localize(None)
+            last = last.tz_localize(None)
+            if isinstance(origin, Timestamp):
+                origin = origin.tz_localize(None)
+
+        first, last = _adjust_dates_anchored(
+            first, last, freq, closed=closed, origin=origin, offset=offset, unit=unit
+        )
+        if isinstance(freq, Day):
+            first = first.tz_localize(index_tz)
+            last = last.tz_localize(index_tz)
+    else:
+        first = first.normalize()
+        last = last.normalize()
+
+        if closed == "left":
+            first = Timestamp(freq.rollback(first))
+        else:
+            first = Timestamp(first - freq)
+
+        last = Timestamp(last + freq)
+
+    return first, last
+
+
+def _get_period_range_edges(
+    first: Period,
+    last: Period,
+    freq: BaseOffset,
+    closed: Literal["right", "left"] = "left",
+    origin: TimeGrouperOrigin = "start_day",
+    offset: Timedelta | None = None,
+) -> tuple[Period, Period]:
+    """
+    Adjust the provided `first` and `last` Periods to the respective Period of
+    the given offset that encompasses them.
+
+    Parameters
+    ----------
+    first : pd.Period
+        The beginning Period of the range to be adjusted.
+    last : pd.Period
+        The ending Period of the range to be adjusted.
+    freq : pd.DateOffset
+        The freq to which the Periods will be adjusted.
+    closed : {'right', 'left'}, default "left"
+        Which side of bin interval is closed.
+    origin : {'epoch', 'start', 'start_day'}, Timestamp, default 'start_day'
+        The timestamp on which to adjust the grouping. The timezone of origin must
+        match the timezone of the index.
+
+        If a timestamp is not used, these values are also supported:
+
+        - 'epoch': `origin` is 1970-01-01
+        - 'start': `origin` is the first value of the timeseries
+        - 'start_day': `origin` is the first day at midnight of the timeseries
+    offset : pd.Timedelta, default is None
+        An offset timedelta added to the origin.
+
+    Returns
+    -------
+    A tuple of length 2, containing the adjusted pd.Period objects.
+    """
+    if not all(isinstance(obj, Period) for obj in [first, last]):
+        raise TypeError("'first' and 'last' must be instances of type Period")
+
+    # GH 23882
+    first_ts = first.to_timestamp()
+    last_ts = last.to_timestamp()
+    adjust_first = not freq.is_on_offset(first_ts)
+    adjust_last = freq.is_on_offset(last_ts)
+
+    first_ts, last_ts = _get_timestamp_range_edges(
+        first_ts, last_ts, freq, unit="ns", closed=closed, origin=origin, offset=offset
+    )
+
+    first = (first_ts + int(adjust_first) * freq).to_period(freq)
+    last = (last_ts - int(adjust_last) * freq).to_period(freq)
+    return first, last
+
+
+def _insert_nat_bin(
+    binner: PeriodIndex, bins: np.ndarray, labels: PeriodIndex, nat_count: int
+) -> tuple[PeriodIndex, np.ndarray, PeriodIndex]:
+    # NaT handling as in pandas._lib.lib.generate_bins_dt64()
+    # shift bins by the number of NaT
+    assert nat_count > 0
+    bins += nat_count
+    bins = np.insert(bins, 0, nat_count)
+
+    # Incompatible types in assignment (expression has type "Index", variable
+    # has type "PeriodIndex")
+    binner = binner.insert(0, NaT)  # type: ignore[assignment]
+    # Incompatible types in assignment (expression has type "Index", variable
+    # has type "PeriodIndex")
+    labels = labels.insert(0, NaT)  # type: ignore[assignment]
+    return binner, bins, labels
+
+
+def _adjust_dates_anchored(
+    first: Timestamp,
+    last: Timestamp,
+    freq: Tick,
+    closed: Literal["right", "left"] = "right",
+    origin: TimeGrouperOrigin = "start_day",
+    offset: Timedelta | None = None,
+    unit: str = "ns",
+) -> tuple[Timestamp, Timestamp]:
+    # First and last offsets should be calculated from the start day to fix an
+    # error cause by resampling across multiple days when a one day period is
+    # not a multiple of the frequency. See GH 8683
+    # To handle frequencies that are not multiple or divisible by a day we let
+    # the possibility to define a fixed origin timestamp. See GH 31809
+    first = first.as_unit(unit)
+    last = last.as_unit(unit)
+    if offset is not None:
+        offset = offset.as_unit(unit)
+
+    freq_value = Timedelta(freq).as_unit(unit)._value
+
+    origin_timestamp = 0  # origin == "epoch"
+    if origin == "start_day":
+        origin_timestamp = first.normalize()._value
+    elif origin == "start":
+        origin_timestamp = first._value
+    elif isinstance(origin, Timestamp):
+        origin_timestamp = origin.as_unit(unit)._value
+    elif origin in ["end", "end_day"]:
+        origin_last = last if origin == "end" else last.ceil("D")
+        sub_freq_times = (origin_last._value - first._value) // freq_value
+        if closed == "left":
+            sub_freq_times += 1
+        first = origin_last - sub_freq_times * freq
+        origin_timestamp = first._value
+    origin_timestamp += offset._value if offset else 0
+
+    # GH 10117 & GH 19375. If first and last contain timezone information,
+    # Perform the calculation in UTC in order to avoid localizing on an
+    # Ambiguous or Nonexistent time.
+    first_tzinfo = first.tzinfo
+    last_tzinfo = last.tzinfo
+    if first_tzinfo is not None:
+        first = first.tz_convert("UTC")
+    if last_tzinfo is not None:
+        last = last.tz_convert("UTC")
+
+    foffset = (first._value - origin_timestamp) % freq_value
+    loffset = (last._value - origin_timestamp) % freq_value
+
+    if closed == "right":
+        if foffset > 0:
+            # roll back
+            fresult_int = first._value - foffset
+        else:
+            fresult_int = first._value - freq_value
+
+        if loffset > 0:
+            # roll forward
+            lresult_int = last._value + (freq_value - loffset)
+        else:
+            # already the end of the road
+            lresult_int = last._value
+    else:  # closed == 'left'
+        if foffset > 0:
+            fresult_int = first._value - foffset
+        else:
+            # start of the road
+            fresult_int = first._value
+
+        if loffset > 0:
+            # roll forward
+            lresult_int = last._value + (freq_value - loffset)
+        else:
+            lresult_int = last._value + freq_value
+    fresult = Timestamp(fresult_int, unit=unit)
+    lresult = Timestamp(lresult_int, unit=unit)
+    if first_tzinfo is not None:
+        fresult = fresult.tz_localize("UTC").tz_convert(first_tzinfo)
+    if last_tzinfo is not None:
+        lresult = lresult.tz_localize("UTC").tz_convert(last_tzinfo)
+    return fresult, lresult
+
+
+def asfreq(
+    obj: NDFrameT,
+    freq,
+    method=None,
+    how=None,
+    normalize: bool = False,
+    fill_value=None,
+) -> NDFrameT:
+    """
+    Utility frequency conversion method for Series/DataFrame.
+
+    See :meth:`pandas.NDFrame.asfreq` for full documentation.
+    """
+    if isinstance(obj.index, PeriodIndex):
+        if method is not None:
+            raise NotImplementedError("'method' argument is not supported")
+
+        if how is None:
+            how = "E"
+
+        if isinstance(freq, BaseOffset):
+            if hasattr(freq, "_period_dtype_code"):
+                freq = freq_to_period_freqstr(freq.n, freq.name)
+            else:
+                raise ValueError(
+                    f"Invalid offset: '{freq.base}' for converting time series "
+                    f"with PeriodIndex."
+                )
+
+        new_obj = obj.copy()
+        new_obj.index = obj.index.asfreq(freq, how=how)
+
+    elif len(obj.index) == 0:
+        new_obj = obj.copy()
+
+        new_obj.index = _asfreq_compat(obj.index, freq)
+    else:
+        unit = None
+        if isinstance(obj.index, DatetimeIndex):
+            # TODO: should we disallow non-DatetimeIndex?
+            unit = obj.index.unit
+        dti = date_range(obj.index.min(), obj.index.max(), freq=freq, unit=unit)
+        dti.name = obj.index.name
+        new_obj = obj.reindex(dti, method=method, fill_value=fill_value)
+        if normalize:
+            new_obj.index = new_obj.index.normalize()
+
+    return new_obj
+
+
+def _asfreq_compat(index: DatetimeIndex | PeriodIndex | TimedeltaIndex, freq):
+    """
+    Helper to mimic asfreq on (empty) DatetimeIndex and TimedeltaIndex.
+
+    Parameters
+    ----------
+    index : PeriodIndex, DatetimeIndex, or TimedeltaIndex
+    freq : DateOffset
+
+    Returns
+    -------
+    same type as index
+    """
+    if len(index) != 0:
+        # This should never be reached, always checked by the caller
+        raise ValueError(
+            "Can only set arbitrary freq for empty DatetimeIndex or TimedeltaIndex"
+        )
+    new_index: Index
+    if isinstance(index, PeriodIndex):
+        new_index = index.asfreq(freq=freq)
+    elif isinstance(index, DatetimeIndex):
+        new_index = DatetimeIndex([], dtype=index.dtype, freq=freq, name=index.name)
+    elif isinstance(index, TimedeltaIndex):
+        new_index = TimedeltaIndex([], dtype=index.dtype, freq=freq, name=index.name)
+    else:  # pragma: no cover
+        raise TypeError(type(index))
+    return new_index
+
+
+def maybe_warn_args_and_kwargs(cls, kernel: str, args, kwargs) -> None:
+    """
+    Warn for deprecation of args and kwargs in resample functions.
+
+    Parameters
+    ----------
+    cls : type
+        Class to warn about.
+    kernel : str
+        Operation name.
+    args : tuple or None
+        args passed by user. Will be None if and only if kernel does not have args.
+    kwargs : dict or None
+        kwargs passed by user. Will be None if and only if kernel does not have kwargs.
+    """
+    warn_args = args is not None and len(args) > 0
+    warn_kwargs = kwargs is not None and len(kwargs) > 0
+    if warn_args and warn_kwargs:
+        msg = "args and kwargs"
+    elif warn_args:
+        msg = "args"
+    elif warn_kwargs:
+        msg = "kwargs"
+    else:
+        return
+    warnings.warn(
+        f"Passing additional {msg} to {cls.__name__}.{kernel} has "
+        "no impact on the result and is deprecated. This will "
+        "raise a TypeError in a future version of pandas.",
+        category=FutureWarning,
+        stacklevel=find_stack_level(),
+    )
+
+
+def _apply(
+    grouped: GroupBy, how: Callable, *args, include_groups: bool, **kwargs
+) -> DataFrame:
+    # GH#7155 - rewrite warning to appear as if it came from `.resample`
+    target_message = "DataFrameGroupBy.apply operated on the grouping columns"
+    new_message = _apply_groupings_depr.format("DataFrameGroupBy", "resample")
+    with rewrite_warning(
+        target_message=target_message,
+        target_category=DeprecationWarning,
+        new_message=new_message,
+    ):
+        result = grouped.apply(how, *args, include_groups=include_groups, **kwargs)
+    return result

videollama2/lib/python3.10/site-packages/pandas/core/sample.py

@@ -0,0 +1,154 @@
+"""
+Module containing utilities for NDFrame.sample() and .GroupBy.sample()
+"""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from pandas._libs import lib
+
+from pandas.core.dtypes.generic import (
+    ABCDataFrame,
+    ABCSeries,
+)
+
+if TYPE_CHECKING:
+    from pandas._typing import AxisInt
+
+    from pandas.core.generic import NDFrame
+
+
+def preprocess_weights(obj: NDFrame, weights, axis: AxisInt) -> np.ndarray:
+    """
+    Process and validate the `weights` argument to `NDFrame.sample` and
+    `.GroupBy.sample`.
+
+    Returns `weights` as an ndarray[np.float64], validated except for normalizing
+    weights (because that must be done groupwise in groupby sampling).
+    """
+    # If a series, align with frame
+    if isinstance(weights, ABCSeries):
+        weights = weights.reindex(obj.axes[axis])
+
+    # Strings acceptable if a dataframe and axis = 0
+    if isinstance(weights, str):
+        if isinstance(obj, ABCDataFrame):
+            if axis == 0:
+                try:
+                    weights = obj[weights]
+                except KeyError as err:
+                    raise KeyError(
+                        "String passed to weights not a valid column"
+                    ) from err
+            else:
+                raise ValueError(
+                    "Strings can only be passed to "
+                    "weights when sampling from rows on "
+                    "a DataFrame"
+                )
+        else:
+            raise ValueError(
+                "Strings cannot be passed as weights when sampling from a Series."
+            )
+
+    if isinstance(obj, ABCSeries):
+        func = obj._constructor
+    else:
+        func = obj._constructor_sliced
+
+    weights = func(weights, dtype="float64")._values
+
+    if len(weights) != obj.shape[axis]:
+        raise ValueError("Weights and axis to be sampled must be of same length")
+
+    if lib.has_infs(weights):
+        raise ValueError("weight vector may not include `inf` values")
+
+    if (weights < 0).any():
+        raise ValueError("weight vector many not include negative values")
+
+    missing = np.isnan(weights)
+    if missing.any():
+        # Don't modify weights in place
+        weights = weights.copy()
+        weights[missing] = 0
+    return weights
+
+
+def process_sampling_size(
+    n: int | None, frac: float | None, replace: bool
+) -> int | None:
+    """
+    Process and validate the `n` and `frac` arguments to `NDFrame.sample` and
+    `.GroupBy.sample`.
+
+    Returns None if `frac` should be used (variable sampling sizes), otherwise returns
+    the constant sampling size.
+    """
+    # If no frac or n, default to n=1.
+    if n is None and frac is None:
+        n = 1
+    elif n is not None and frac is not None:
+        raise ValueError("Please enter a value for `frac` OR `n`, not both")
+    elif n is not None:
+        if n < 0:
+            raise ValueError(
+                "A negative number of rows requested. Please provide `n` >= 0."
+            )
+        if n % 1 != 0:
+            raise ValueError("Only integers accepted as `n` values")
+    else:
+        assert frac is not None  # for mypy
+        if frac > 1 and not replace:
+            raise ValueError(
+                "Replace has to be set to `True` when "
+                "upsampling the population `frac` > 1."
+            )
+        if frac < 0:
+            raise ValueError(
+                "A negative number of rows requested. Please provide `frac` >= 0."
+            )
+
+    return n
+
+
+def sample(
+    obj_len: int,
+    size: int,
+    replace: bool,
+    weights: np.ndarray | None,
+    random_state: np.random.RandomState | np.random.Generator,
+) -> np.ndarray:
+    """
+    Randomly sample `size` indices in `np.arange(obj_len)`
+
+    Parameters
+    ----------
+    obj_len : int
+        The length of the indices being considered
+    size : int
+        The number of values to choose
+    replace : bool
+        Allow or disallow sampling of the same row more than once.
+    weights : np.ndarray[np.float64] or None
+        If None, equal probability weighting, otherwise weights according
+        to the vector normalized
+    random_state: np.random.RandomState or np.random.Generator
+        State used for the random sampling
+
+    Returns
+    -------
+    np.ndarray[np.intp]
+    """
+    if weights is not None:
+        weight_sum = weights.sum()
+        if weight_sum != 0:
+            weights = weights / weight_sum
+        else:
+            raise ValueError("Invalid weights: weights sum to zero")
+
+    return random_state.choice(obj_len, size=size, replace=replace, p=weights).astype(
+        np.intp, copy=False
+    )

videollama2/lib/python3.10/site-packages/pandas/core/shared_docs.py

@@ -0,0 +1,952 @@
+from __future__ import annotations
+
+_shared_docs: dict[str, str] = {}
+
+_shared_docs[
+    "aggregate"
+] = """
+Aggregate using one or more operations over the specified axis.
+
+Parameters
+----------
+func : function, str, list or dict
+    Function to use for aggregating the data. If a function, must either
+    work when passed a {klass} or when passed to {klass}.apply.
+
+    Accepted combinations are:
+
+    - function
+    - string function name
+    - list of functions and/or function names, e.g. ``[np.sum, 'mean']``
+    - dict of axis labels -> functions, function names or list of such.
+{axis}
+*args
+    Positional arguments to pass to `func`.
+**kwargs
+    Keyword arguments to pass to `func`.
+
+Returns
+-------
+scalar, Series or DataFrame
+
+    The return can be:
+
+    * scalar : when Series.agg is called with single function
+    * Series : when DataFrame.agg is called with a single function
+    * DataFrame : when DataFrame.agg is called with several functions
+{see_also}
+Notes
+-----
+The aggregation operations are always performed over an axis, either the
+index (default) or the column axis. This behavior is different from
+`numpy` aggregation functions (`mean`, `median`, `prod`, `sum`, `std`,
+`var`), where the default is to compute the aggregation of the flattened
+array, e.g., ``numpy.mean(arr_2d)`` as opposed to
+``numpy.mean(arr_2d, axis=0)``.
+
+`agg` is an alias for `aggregate`. Use the alias.
+
+Functions that mutate the passed object can produce unexpected
+behavior or errors and are not supported. See :ref:`gotchas.udf-mutation`
+for more details.
+
+A passed user-defined-function will be passed a Series for evaluation.
+{examples}"""
+
+_shared_docs[
+    "compare"
+] = """
+Compare to another {klass} and show the differences.
+
+Parameters
+----------
+other : {klass}
+    Object to compare with.
+
+align_axis : {{0 or 'index', 1 or 'columns'}}, default 1
+    Determine which axis to align the comparison on.
+
+    * 0, or 'index' : Resulting differences are stacked vertically
+        with rows drawn alternately from self and other.
+    * 1, or 'columns' : Resulting differences are aligned horizontally
+        with columns drawn alternately from self and other.
+
+keep_shape : bool, default False
+    If true, all rows and columns are kept.
+    Otherwise, only the ones with different values are kept.
+
+keep_equal : bool, default False
+    If true, the result keeps values that are equal.
+    Otherwise, equal values are shown as NaNs.
+
+result_names : tuple, default ('self', 'other')
+    Set the dataframes names in the comparison.
+
+    .. versionadded:: 1.5.0
+"""
+
+_shared_docs[
+    "groupby"
+] = """
+Group %(klass)s using a mapper or by a Series of columns.
+
+A groupby operation involves some combination of splitting the
+object, applying a function, and combining the results. This can be
+used to group large amounts of data and compute operations on these
+groups.
+
+Parameters
+----------
+by : mapping, function, label, pd.Grouper or list of such
+    Used to determine the groups for the groupby.
+    If ``by`` is a function, it's called on each value of the object's
+    index. If a dict or Series is passed, the Series or dict VALUES
+    will be used to determine the groups (the Series' values are first
+    aligned; see ``.align()`` method). If a list or ndarray of length
+    equal to the selected axis is passed (see the `groupby user guide
+    <https://pandas.pydata.org/pandas-docs/stable/user_guide/groupby.html#splitting-an-object-into-groups>`_),
+    the values are used as-is to determine the groups. A label or list
+    of labels may be passed to group by the columns in ``self``.
+    Notice that a tuple is interpreted as a (single) key.
+axis : {0 or 'index', 1 or 'columns'}, default 0
+    Split along rows (0) or columns (1). For `Series` this parameter
+    is unused and defaults to 0.
+
+    .. deprecated:: 2.1.0
+
+        Will be removed and behave like axis=0 in a future version.
+        For ``axis=1``, do ``frame.T.groupby(...)`` instead.
+
+level : int, level name, or sequence of such, default None
+    If the axis is a MultiIndex (hierarchical), group by a particular
+    level or levels. Do not specify both ``by`` and ``level``.
+as_index : bool, default True
+    Return object with group labels as the
+    index. Only relevant for DataFrame input. as_index=False is
+    effectively "SQL-style" grouped output. This argument has no effect
+    on filtrations (see the `filtrations in the user guide
+    <https://pandas.pydata.org/docs/dev/user_guide/groupby.html#filtration>`_),
+    such as ``head()``, ``tail()``, ``nth()`` and in transformations
+    (see the `transformations in the user guide
+    <https://pandas.pydata.org/docs/dev/user_guide/groupby.html#transformation>`_).
+sort : bool, default True
+    Sort group keys. Get better performance by turning this off.
+    Note this does not influence the order of observations within each
+    group. Groupby preserves the order of rows within each group. If False,
+    the groups will appear in the same order as they did in the original DataFrame.
+    This argument has no effect on filtrations (see the `filtrations in the user guide
+    <https://pandas.pydata.org/docs/dev/user_guide/groupby.html#filtration>`_),
+    such as ``head()``, ``tail()``, ``nth()`` and in transformations
+    (see the `transformations in the user guide
+    <https://pandas.pydata.org/docs/dev/user_guide/groupby.html#transformation>`_).
+
+    .. versionchanged:: 2.0.0
+
+        Specifying ``sort=False`` with an ordered categorical grouper will no
+        longer sort the values.
+
+group_keys : bool, default True
+    When calling apply and the ``by`` argument produces a like-indexed
+    (i.e. :ref:`a transform <groupby.transform>`) result, add group keys to
+    index to identify pieces. By default group keys are not included
+    when the result's index (and column) labels match the inputs, and
+    are included otherwise.
+
+    .. versionchanged:: 1.5.0
+
+       Warns that ``group_keys`` will no longer be ignored when the
+       result from ``apply`` is a like-indexed Series or DataFrame.
+       Specify ``group_keys`` explicitly to include the group keys or
+       not.
+
+    .. versionchanged:: 2.0.0
+
+       ``group_keys`` now defaults to ``True``.
+
+observed : bool, default False
+    This only applies if any of the groupers are Categoricals.
+    If True: only show observed values for categorical groupers.
+    If False: show all values for categorical groupers.
+
+    .. deprecated:: 2.1.0
+
+        The default value will change to True in a future version of pandas.
+
+dropna : bool, default True
+    If True, and if group keys contain NA values, NA values together
+    with row/column will be dropped.
+    If False, NA values will also be treated as the key in groups.
+
+Returns
+-------
+pandas.api.typing.%(klass)sGroupBy
+    Returns a groupby object that contains information about the groups.
+
+See Also
+--------
+resample : Convenience method for frequency conversion and resampling
+    of time series.
+
+Notes
+-----
+See the `user guide
+<https://pandas.pydata.org/pandas-docs/stable/groupby.html>`__ for more
+detailed usage and examples, including splitting an object into groups,
+iterating through groups, selecting a group, aggregation, and more.
+"""
+
+_shared_docs[
+    "melt"
+] = """
+Unpivot a DataFrame from wide to long format, optionally leaving identifiers set.
+
+This function is useful to massage a DataFrame into a format where one
+or more columns are identifier variables (`id_vars`), while all other
+columns, considered measured variables (`value_vars`), are "unpivoted" to
+the row axis, leaving just two non-identifier columns, 'variable' and
+'value'.
+
+Parameters
+----------
+id_vars : scalar, tuple, list, or ndarray, optional
+    Column(s) to use as identifier variables.
+value_vars : scalar, tuple, list, or ndarray, optional
+    Column(s) to unpivot. If not specified, uses all columns that
+    are not set as `id_vars`.
+var_name : scalar, default None
+    Name to use for the 'variable' column. If None it uses
+    ``frame.columns.name`` or 'variable'.
+value_name : scalar, default 'value'
+    Name to use for the 'value' column, can't be an existing column label.
+col_level : scalar, optional
+    If columns are a MultiIndex then use this level to melt.
+ignore_index : bool, default True
+    If True, original index is ignored. If False, the original index is retained.
+    Index labels will be repeated as necessary.
+
+Returns
+-------
+DataFrame
+    Unpivoted DataFrame.
+
+See Also
+--------
+%(other)s : Identical method.
+pivot_table : Create a spreadsheet-style pivot table as a DataFrame.
+DataFrame.pivot : Return reshaped DataFrame organized
+    by given index / column values.
+DataFrame.explode : Explode a DataFrame from list-like
+        columns to long format.
+
+Notes
+-----
+Reference :ref:`the user guide <reshaping.melt>` for more examples.
+
+Examples
+--------
+>>> df = pd.DataFrame({'A': {0: 'a', 1: 'b', 2: 'c'},
+...                    'B': {0: 1, 1: 3, 2: 5},
+...                    'C': {0: 2, 1: 4, 2: 6}})
+>>> df
+   A  B  C
+0  a  1  2
+1  b  3  4
+2  c  5  6
+
+>>> %(caller)sid_vars=['A'], value_vars=['B'])
+   A variable  value
+0  a        B      1
+1  b        B      3
+2  c        B      5
+
+>>> %(caller)sid_vars=['A'], value_vars=['B', 'C'])
+   A variable  value
+0  a        B      1
+1  b        B      3
+2  c        B      5
+3  a        C      2
+4  b        C      4
+5  c        C      6
+
+The names of 'variable' and 'value' columns can be customized:
+
+>>> %(caller)sid_vars=['A'], value_vars=['B'],
+...         var_name='myVarname', value_name='myValname')
+   A myVarname  myValname
+0  a         B          1
+1  b         B          3
+2  c         B          5
+
+Original index values can be kept around:
+
+>>> %(caller)sid_vars=['A'], value_vars=['B', 'C'], ignore_index=False)
+   A variable  value
+0  a        B      1
+1  b        B      3
+2  c        B      5
+0  a        C      2
+1  b        C      4
+2  c        C      6
+
+If you have multi-index columns:
+
+>>> df.columns = [list('ABC'), list('DEF')]
+>>> df
+   A  B  C
+   D  E  F
+0  a  1  2
+1  b  3  4
+2  c  5  6
+
+>>> %(caller)scol_level=0, id_vars=['A'], value_vars=['B'])
+   A variable  value
+0  a        B      1
+1  b        B      3
+2  c        B      5
+
+>>> %(caller)sid_vars=[('A', 'D')], value_vars=[('B', 'E')])
+  (A, D) variable_0 variable_1  value
+0      a          B          E      1
+1      b          B          E      3
+2      c          B          E      5
+"""
+
+_shared_docs[
+    "transform"
+] = """
+Call ``func`` on self producing a {klass} with the same axis shape as self.
+
+Parameters
+----------
+func : function, str, list-like or dict-like
+    Function to use for transforming the data. If a function, must either
+    work when passed a {klass} or when passed to {klass}.apply. If func
+    is both list-like and dict-like, dict-like behavior takes precedence.
+
+    Accepted combinations are:
+
+    - function
+    - string function name
+    - list-like of functions and/or function names, e.g. ``[np.exp, 'sqrt']``
+    - dict-like of axis labels -> functions, function names or list-like of such.
+{axis}
+*args
+    Positional arguments to pass to `func`.
+**kwargs
+    Keyword arguments to pass to `func`.
+
+Returns
+-------
+{klass}
+    A {klass} that must have the same length as self.
+
+Raises
+------
+ValueError : If the returned {klass} has a different length than self.
+
+See Also
+--------
+{klass}.agg : Only perform aggregating type operations.
+{klass}.apply : Invoke function on a {klass}.
+
+Notes
+-----
+Functions that mutate the passed object can produce unexpected
+behavior or errors and are not supported. See :ref:`gotchas.udf-mutation`
+for more details.
+
+Examples
+--------
+>>> df = pd.DataFrame({{'A': range(3), 'B': range(1, 4)}})
+>>> df
+   A  B
+0  0  1
+1  1  2
+2  2  3
+>>> df.transform(lambda x: x + 1)
+   A  B
+0  1  2
+1  2  3
+2  3  4
+
+Even though the resulting {klass} must have the same length as the
+input {klass}, it is possible to provide several input functions:
+
+>>> s = pd.Series(range(3))
+>>> s
+0    0
+1    1
+2    2
+dtype: int64
+>>> s.transform([np.sqrt, np.exp])
+       sqrt        exp
+0  0.000000   1.000000
+1  1.000000   2.718282
+2  1.414214   7.389056
+
+You can call transform on a GroupBy object:
+
+>>> df = pd.DataFrame({{
+...     "Date": [
+...         "2015-05-08", "2015-05-07", "2015-05-06", "2015-05-05",
+...         "2015-05-08", "2015-05-07", "2015-05-06", "2015-05-05"],
+...     "Data": [5, 8, 6, 1, 50, 100, 60, 120],
+... }})
+>>> df
+         Date  Data
+0  2015-05-08     5
+1  2015-05-07     8
+2  2015-05-06     6
+3  2015-05-05     1
+4  2015-05-08    50
+5  2015-05-07   100
+6  2015-05-06    60
+7  2015-05-05   120
+>>> df.groupby('Date')['Data'].transform('sum')
+0     55
+1    108
+2     66
+3    121
+4     55
+5    108
+6     66
+7    121
+Name: Data, dtype: int64
+
+>>> df = pd.DataFrame({{
+...     "c": [1, 1, 1, 2, 2, 2, 2],
+...     "type": ["m", "n", "o", "m", "m", "n", "n"]
+... }})
+>>> df
+   c type
+0  1    m
+1  1    n
+2  1    o
+3  2    m
+4  2    m
+5  2    n
+6  2    n
+>>> df['size'] = df.groupby('c')['type'].transform(len)
+>>> df
+   c type size
+0  1    m    3
+1  1    n    3
+2  1    o    3
+3  2    m    4
+4  2    m    4
+5  2    n    4
+6  2    n    4
+"""
+
+_shared_docs[
+    "storage_options"
+] = """storage_options : dict, optional
+    Extra options that make sense for a particular storage connection, e.g.
+    host, port, username, password, etc. For HTTP(S) URLs the key-value pairs
+    are forwarded to ``urllib.request.Request`` as header options. For other
+    URLs (e.g. starting with "s3://", and "gcs://") the key-value pairs are
+    forwarded to ``fsspec.open``. Please see ``fsspec`` and ``urllib`` for more
+    details, and for more examples on storage options refer `here
+    <https://pandas.pydata.org/docs/user_guide/io.html?
+    highlight=storage_options#reading-writing-remote-files>`_."""
+
+_shared_docs[
+    "compression_options"
+] = """compression : str or dict, default 'infer'
+    For on-the-fly compression of the output data. If 'infer' and '%s' is
+    path-like, then detect compression from the following extensions: '.gz',
+    '.bz2', '.zip', '.xz', '.zst', '.tar', '.tar.gz', '.tar.xz' or '.tar.bz2'
+    (otherwise no compression).
+    Set to ``None`` for no compression.
+    Can also be a dict with key ``'method'`` set
+    to one of {``'zip'``, ``'gzip'``, ``'bz2'``, ``'zstd'``, ``'xz'``, ``'tar'``} and
+    other key-value pairs are forwarded to
+    ``zipfile.ZipFile``, ``gzip.GzipFile``,
+    ``bz2.BZ2File``, ``zstandard.ZstdCompressor``, ``lzma.LZMAFile`` or
+    ``tarfile.TarFile``, respectively.
+    As an example, the following could be passed for faster compression and to create
+    a reproducible gzip archive:
+    ``compression={'method': 'gzip', 'compresslevel': 1, 'mtime': 1}``.
+
+    .. versionadded:: 1.5.0
+        Added support for `.tar` files."""
+
+_shared_docs[
+    "decompression_options"
+] = """compression : str or dict, default 'infer'
+    For on-the-fly decompression of on-disk data. If 'infer' and '%s' is
+    path-like, then detect compression from the following extensions: '.gz',
+    '.bz2', '.zip', '.xz', '.zst', '.tar', '.tar.gz', '.tar.xz' or '.tar.bz2'
+    (otherwise no compression).
+    If using 'zip' or 'tar', the ZIP file must contain only one data file to be read in.
+    Set to ``None`` for no decompression.
+    Can also be a dict with key ``'method'`` set
+    to one of {``'zip'``, ``'gzip'``, ``'bz2'``, ``'zstd'``, ``'xz'``, ``'tar'``} and
+    other key-value pairs are forwarded to
+    ``zipfile.ZipFile``, ``gzip.GzipFile``,
+    ``bz2.BZ2File``, ``zstandard.ZstdDecompressor``, ``lzma.LZMAFile`` or
+    ``tarfile.TarFile``, respectively.
+    As an example, the following could be passed for Zstandard decompression using a
+    custom compression dictionary:
+    ``compression={'method': 'zstd', 'dict_data': my_compression_dict}``.
+
+    .. versionadded:: 1.5.0
+        Added support for `.tar` files."""
+
+_shared_docs[
+    "replace"
+] = """
+    Replace values given in `to_replace` with `value`.
+
+    Values of the {klass} are replaced with other values dynamically.
+    This differs from updating with ``.loc`` or ``.iloc``, which require
+    you to specify a location to update with some value.
+
+    Parameters
+    ----------
+    to_replace : str, regex, list, dict, Series, int, float, or None
+        How to find the values that will be replaced.
+
+        * numeric, str or regex:
+
+            - numeric: numeric values equal to `to_replace` will be
+              replaced with `value`
+            - str: string exactly matching `to_replace` will be replaced
+              with `value`
+            - regex: regexs matching `to_replace` will be replaced with
+              `value`
+
+        * list of str, regex, or numeric:
+
+            - First, if `to_replace` and `value` are both lists, they
+              **must** be the same length.
+            - Second, if ``regex=True`` then all of the strings in **both**
+              lists will be interpreted as regexs otherwise they will match
+              directly. This doesn't matter much for `value` since there
+              are only a few possible substitution regexes you can use.
+            - str, regex and numeric rules apply as above.
+
+        * dict:
+
+            - Dicts can be used to specify different replacement values
+              for different existing values. For example,
+              ``{{'a': 'b', 'y': 'z'}}`` replaces the value 'a' with 'b' and
+              'y' with 'z'. To use a dict in this way, the optional `value`
+              parameter should not be given.
+            - For a DataFrame a dict can specify that different values
+              should be replaced in different columns. For example,
+              ``{{'a': 1, 'b': 'z'}}`` looks for the value 1 in column 'a'
+              and the value 'z' in column 'b' and replaces these values
+              with whatever is specified in `value`. The `value` parameter
+              should not be ``None`` in this case. You can treat this as a
+              special case of passing two lists except that you are
+              specifying the column to search in.
+            - For a DataFrame nested dictionaries, e.g.,
+              ``{{'a': {{'b': np.nan}}}}``, are read as follows: look in column
+              'a' for the value 'b' and replace it with NaN. The optional `value`
+              parameter should not be specified to use a nested dict in this
+              way. You can nest regular expressions as well. Note that
+              column names (the top-level dictionary keys in a nested
+              dictionary) **cannot** be regular expressions.
+
+        * None:
+
+            - This means that the `regex` argument must be a string,
+              compiled regular expression, or list, dict, ndarray or
+              Series of such elements. If `value` is also ``None`` then
+              this **must** be a nested dictionary or Series.
+
+        See the examples section for examples of each of these.
+    value : scalar, dict, list, str, regex, default None
+        Value to replace any values matching `to_replace` with.
+        For a DataFrame a dict of values can be used to specify which
+        value to use for each column (columns not in the dict will not be
+        filled). Regular expressions, strings and lists or dicts of such
+        objects are also allowed.
+    {inplace}
+    limit : int, default None
+        Maximum size gap to forward or backward fill.
+
+        .. deprecated:: 2.1.0
+    regex : bool or same types as `to_replace`, default False
+        Whether to interpret `to_replace` and/or `value` as regular
+        expressions. Alternatively, this could be a regular expression or a
+        list, dict, or array of regular expressions in which case
+        `to_replace` must be ``None``.
+    method : {{'pad', 'ffill', 'bfill'}}
+        The method to use when for replacement, when `to_replace` is a
+        scalar, list or tuple and `value` is ``None``.
+
+        .. deprecated:: 2.1.0
+
+    Returns
+    -------
+    {klass}
+        Object after replacement.
+
+    Raises
+    ------
+    AssertionError
+        * If `regex` is not a ``bool`` and `to_replace` is not
+          ``None``.
+
+    TypeError
+        * If `to_replace` is not a scalar, array-like, ``dict``, or ``None``
+        * If `to_replace` is a ``dict`` and `value` is not a ``list``,
+          ``dict``, ``ndarray``, or ``Series``
+        * If `to_replace` is ``None`` and `regex` is not compilable
+          into a regular expression or is a list, dict, ndarray, or
+          Series.
+        * When replacing multiple ``bool`` or ``datetime64`` objects and
+          the arguments to `to_replace` does not match the type of the
+          value being replaced
+
+    ValueError
+        * If a ``list`` or an ``ndarray`` is passed to `to_replace` and
+          `value` but they are not the same length.
+
+    See Also
+    --------
+    Series.fillna : Fill NA values.
+    DataFrame.fillna : Fill NA values.
+    Series.where : Replace values based on boolean condition.
+    DataFrame.where : Replace values based on boolean condition.
+    DataFrame.map: Apply a function to a Dataframe elementwise.
+    Series.map: Map values of Series according to an input mapping or function.
+    Series.str.replace : Simple string replacement.
+
+    Notes
+    -----
+    * Regex substitution is performed under the hood with ``re.sub``. The
+      rules for substitution for ``re.sub`` are the same.
+    * Regular expressions will only substitute on strings, meaning you
+      cannot provide, for example, a regular expression matching floating
+      point numbers and expect the columns in your frame that have a
+      numeric dtype to be matched. However, if those floating point
+      numbers *are* strings, then you can do this.
+    * This method has *a lot* of options. You are encouraged to experiment
+      and play with this method to gain intuition about how it works.
+    * When dict is used as the `to_replace` value, it is like
+      key(s) in the dict are the to_replace part and
+      value(s) in the dict are the value parameter.
+
+    Examples
+    --------
+
+    **Scalar `to_replace` and `value`**
+
+    >>> s = pd.Series([1, 2, 3, 4, 5])
+    >>> s.replace(1, 5)
+    0    5
+    1    2
+    2    3
+    3    4
+    4    5
+    dtype: int64
+
+    >>> df = pd.DataFrame({{'A': [0, 1, 2, 3, 4],
+    ...                    'B': [5, 6, 7, 8, 9],
+    ...                    'C': ['a', 'b', 'c', 'd', 'e']}})
+    >>> df.replace(0, 5)
+        A  B  C
+    0  5  5  a
+    1  1  6  b
+    2  2  7  c
+    3  3  8  d
+    4  4  9  e
+
+    **List-like `to_replace`**
+
+    >>> df.replace([0, 1, 2, 3], 4)
+        A  B  C
+    0  4  5  a
+    1  4  6  b
+    2  4  7  c
+    3  4  8  d
+    4  4  9  e
+
+    >>> df.replace([0, 1, 2, 3], [4, 3, 2, 1])
+        A  B  C
+    0  4  5  a
+    1  3  6  b
+    2  2  7  c
+    3  1  8  d
+    4  4  9  e
+
+    >>> s.replace([1, 2], method='bfill')
+    0    3
+    1    3
+    2    3
+    3    4
+    4    5
+    dtype: int64
+
+    **dict-like `to_replace`**
+
+    >>> df.replace({{0: 10, 1: 100}})
+            A  B  C
+    0   10  5  a
+    1  100  6  b
+    2    2  7  c
+    3    3  8  d
+    4    4  9  e
+
+    >>> df.replace({{'A': 0, 'B': 5}}, 100)
+            A    B  C
+    0  100  100  a
+    1    1    6  b
+    2    2    7  c
+    3    3    8  d
+    4    4    9  e
+
+    >>> df.replace({{'A': {{0: 100, 4: 400}}}})
+            A  B  C
+    0  100  5  a
+    1    1  6  b
+    2    2  7  c
+    3    3  8  d
+    4  400  9  e
+
+    **Regular expression `to_replace`**
+
+    >>> df = pd.DataFrame({{'A': ['bat', 'foo', 'bait'],
+    ...                    'B': ['abc', 'bar', 'xyz']}})
+    >>> df.replace(to_replace=r'^ba.$', value='new', regex=True)
+            A    B
+    0   new  abc
+    1   foo  new
+    2  bait  xyz
+
+    >>> df.replace({{'A': r'^ba.$'}}, {{'A': 'new'}}, regex=True)
+            A    B
+    0   new  abc
+    1   foo  bar
+    2  bait  xyz
+
+    >>> df.replace(regex=r'^ba.$', value='new')
+            A    B
+    0   new  abc
+    1   foo  new
+    2  bait  xyz
+
+    >>> df.replace(regex={{r'^ba.$': 'new', 'foo': 'xyz'}})
+            A    B
+    0   new  abc
+    1   xyz  new
+    2  bait  xyz
+
+    >>> df.replace(regex=[r'^ba.$', 'foo'], value='new')
+            A    B
+    0   new  abc
+    1   new  new
+    2  bait  xyz
+
+    Compare the behavior of ``s.replace({{'a': None}})`` and
+    ``s.replace('a', None)`` to understand the peculiarities
+    of the `to_replace` parameter:
+
+    >>> s = pd.Series([10, 'a', 'a', 'b', 'a'])
+
+    When one uses a dict as the `to_replace` value, it is like the
+    value(s) in the dict are equal to the `value` parameter.
+    ``s.replace({{'a': None}})`` is equivalent to
+    ``s.replace(to_replace={{'a': None}}, value=None, method=None)``:
+
+    >>> s.replace({{'a': None}})
+    0      10
+    1    None
+    2    None
+    3       b
+    4    None
+    dtype: object
+
+    When ``value`` is not explicitly passed and `to_replace` is a scalar, list
+    or tuple, `replace` uses the method parameter (default 'pad') to do the
+    replacement. So this is why the 'a' values are being replaced by 10
+    in rows 1 and 2 and 'b' in row 4 in this case.
+
+    >>> s.replace('a')
+    0    10
+    1    10
+    2    10
+    3     b
+    4     b
+    dtype: object
+
+        .. deprecated:: 2.1.0
+            The 'method' parameter and padding behavior are deprecated.
+
+    On the other hand, if ``None`` is explicitly passed for ``value``, it will
+    be respected:
+
+    >>> s.replace('a', None)
+    0      10
+    1    None
+    2    None
+    3       b
+    4    None
+    dtype: object
+
+        .. versionchanged:: 1.4.0
+            Previously the explicit ``None`` was silently ignored.
+
+    When ``regex=True``, ``value`` is not ``None`` and `to_replace` is a string,
+    the replacement will be applied in all columns of the DataFrame.
+
+    >>> df = pd.DataFrame({{'A': [0, 1, 2, 3, 4],
+    ...                    'B': ['a', 'b', 'c', 'd', 'e'],
+    ...                    'C': ['f', 'g', 'h', 'i', 'j']}})
+
+    >>> df.replace(to_replace='^[a-g]', value='e', regex=True)
+        A  B  C
+    0  0  e  e
+    1  1  e  e
+    2  2  e  h
+    3  3  e  i
+    4  4  e  j
+
+    If ``value`` is not ``None`` and `to_replace` is a dictionary, the dictionary
+    keys will be the DataFrame columns that the replacement will be applied.
+
+    >>> df.replace(to_replace={{'B': '^[a-c]', 'C': '^[h-j]'}}, value='e', regex=True)
+        A  B  C
+    0  0  e  f
+    1  1  e  g
+    2  2  e  e
+    3  3  d  e
+    4  4  e  e
+"""
+
+_shared_docs[
+    "idxmin"
+] = """
+    Return index of first occurrence of minimum over requested axis.
+
+    NA/null values are excluded.
+
+    Parameters
+    ----------
+    axis : {{0 or 'index', 1 or 'columns'}}, default 0
+        The axis to use. 0 or 'index' for row-wise, 1 or 'columns' for column-wise.
+    skipna : bool, default True
+        Exclude NA/null values. If an entire row/column is NA, the result
+        will be NA.
+    numeric_only : bool, default {numeric_only_default}
+        Include only `float`, `int` or `boolean` data.
+
+        .. versionadded:: 1.5.0
+
+    Returns
+    -------
+    Series
+        Indexes of minima along the specified axis.
+
+    Raises
+    ------
+    ValueError
+        * If the row/column is empty
+
+    See Also
+    --------
+    Series.idxmin : Return index of the minimum element.
+
+    Notes
+    -----
+    This method is the DataFrame version of ``ndarray.argmin``.
+
+    Examples
+    --------
+    Consider a dataset containing food consumption in Argentina.
+
+    >>> df = pd.DataFrame({{'consumption': [10.51, 103.11, 55.48],
+    ...                     'co2_emissions': [37.2, 19.66, 1712]}},
+    ...                   index=['Pork', 'Wheat Products', 'Beef'])
+
+    >>> df
+                    consumption  co2_emissions
+    Pork                  10.51         37.20
+    Wheat Products       103.11         19.66
+    Beef                  55.48       1712.00
+
+    By default, it returns the index for the minimum value in each column.
+
+    >>> df.idxmin()
+    consumption                Pork
+    co2_emissions    Wheat Products
+    dtype: object
+
+    To return the index for the minimum value in each row, use ``axis="columns"``.
+
+    >>> df.idxmin(axis="columns")
+    Pork                consumption
+    Wheat Products    co2_emissions
+    Beef                consumption
+    dtype: object
+"""
+
+_shared_docs[
+    "idxmax"
+] = """
+    Return index of first occurrence of maximum over requested axis.
+
+    NA/null values are excluded.
+
+    Parameters
+    ----------
+    axis : {{0 or 'index', 1 or 'columns'}}, default 0
+        The axis to use. 0 or 'index' for row-wise, 1 or 'columns' for column-wise.
+    skipna : bool, default True
+        Exclude NA/null values. If an entire row/column is NA, the result
+        will be NA.
+    numeric_only : bool, default {numeric_only_default}
+        Include only `float`, `int` or `boolean` data.
+
+        .. versionadded:: 1.5.0
+
+    Returns
+    -------
+    Series
+        Indexes of maxima along the specified axis.
+
+    Raises
+    ------
+    ValueError
+        * If the row/column is empty
+
+    See Also
+    --------
+    Series.idxmax : Return index of the maximum element.
+
+    Notes
+    -----
+    This method is the DataFrame version of ``ndarray.argmax``.
+
+    Examples
+    --------
+    Consider a dataset containing food consumption in Argentina.
+
+    >>> df = pd.DataFrame({{'consumption': [10.51, 103.11, 55.48],
+    ...                     'co2_emissions': [37.2, 19.66, 1712]}},
+    ...                   index=['Pork', 'Wheat Products', 'Beef'])
+
+    >>> df
+                    consumption  co2_emissions
+    Pork                  10.51         37.20
+    Wheat Products       103.11         19.66
+    Beef                  55.48       1712.00
+
+    By default, it returns the index for the maximum value in each column.
+
+    >>> df.idxmax()
+    consumption     Wheat Products
+    co2_emissions             Beef
+    dtype: object
+
+    To return the index for the maximum value in each row, use ``axis="columns"``.
+
+    >>> df.idxmax(axis="columns")
+    Pork              co2_emissions
+    Wheat Products     consumption
+    Beef              co2_emissions
+    dtype: object
+"""

videollama2/lib/python3.10/site-packages/pandas/core/sorting.py

@@ -0,0 +1,748 @@
+""" miscellaneous sorting / groupby utilities """
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import (
+    TYPE_CHECKING,
+    Callable,
+    DefaultDict,
+    cast,
+)
+
+import numpy as np
+
+from pandas._libs import (
+    algos,
+    hashtable,
+    lib,
+)
+from pandas._libs.hashtable import unique_label_indices
+
+from pandas.core.dtypes.common import (
+    ensure_int64,
+    ensure_platform_int,
+)
+from pandas.core.dtypes.generic import (
+    ABCMultiIndex,
+    ABCRangeIndex,
+)
+from pandas.core.dtypes.missing import isna
+
+from pandas.core.construction import extract_array
+
+if TYPE_CHECKING:
+    from collections.abc import (
+        Hashable,
+        Iterable,
+        Sequence,
+    )
+
+    from pandas._typing import (
+        ArrayLike,
+        AxisInt,
+        IndexKeyFunc,
+        Level,
+        NaPosition,
+        Shape,
+        SortKind,
+        npt,
+    )
+
+    from pandas import (
+        MultiIndex,
+        Series,
+    )
+    from pandas.core.arrays import ExtensionArray
+    from pandas.core.indexes.base import Index
+
+
+def get_indexer_indexer(
+    target: Index,
+    level: Level | list[Level] | None,
+    ascending: list[bool] | bool,
+    kind: SortKind,
+    na_position: NaPosition,
+    sort_remaining: bool,
+    key: IndexKeyFunc,
+) -> npt.NDArray[np.intp] | None:
+    """
+    Helper method that return the indexer according to input parameters for
+    the sort_index method of DataFrame and Series.
+
+    Parameters
+    ----------
+    target : Index
+    level : int or level name or list of ints or list of level names
+    ascending : bool or list of bools, default True
+    kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}
+    na_position : {'first', 'last'}
+    sort_remaining : bool
+    key : callable, optional
+
+    Returns
+    -------
+    Optional[ndarray[intp]]
+        The indexer for the new index.
+    """
+
+    # error: Incompatible types in assignment (expression has type
+    # "Union[ExtensionArray, ndarray[Any, Any], Index, Series]", variable has
+    # type "Index")
+    target = ensure_key_mapped(target, key, levels=level)  # type: ignore[assignment]
+    target = target._sort_levels_monotonic()
+
+    if level is not None:
+        _, indexer = target.sortlevel(
+            level,
+            ascending=ascending,
+            sort_remaining=sort_remaining,
+            na_position=na_position,
+        )
+    elif (np.all(ascending) and target.is_monotonic_increasing) or (
+        not np.any(ascending) and target.is_monotonic_decreasing
+    ):
+        # Check monotonic-ness before sort an index (GH 11080)
+        return None
+    elif isinstance(target, ABCMultiIndex):
+        codes = [lev.codes for lev in target._get_codes_for_sorting()]
+        indexer = lexsort_indexer(
+            codes, orders=ascending, na_position=na_position, codes_given=True
+        )
+    else:
+        # ascending can only be a Sequence for MultiIndex
+        indexer = nargsort(
+            target,
+            kind=kind,
+            ascending=cast(bool, ascending),
+            na_position=na_position,
+        )
+    return indexer
+
+
+def get_group_index(
+    labels, shape: Shape, sort: bool, xnull: bool
+) -> npt.NDArray[np.int64]:
+    """
+    For the particular label_list, gets the offsets into the hypothetical list
+    representing the totally ordered cartesian product of all possible label
+    combinations, *as long as* this space fits within int64 bounds;
+    otherwise, though group indices identify unique combinations of
+    labels, they cannot be deconstructed.
+    - If `sort`, rank of returned ids preserve lexical ranks of labels.
+      i.e. returned id's can be used to do lexical sort on labels;
+    - If `xnull` nulls (-1 labels) are passed through.
+
+    Parameters
+    ----------
+    labels : sequence of arrays
+        Integers identifying levels at each location
+    shape : tuple[int, ...]
+        Number of unique levels at each location
+    sort : bool
+        If the ranks of returned ids should match lexical ranks of labels
+    xnull : bool
+        If true nulls are excluded. i.e. -1 values in the labels are
+        passed through.
+
+    Returns
+    -------
+    An array of type int64 where two elements are equal if their corresponding
+    labels are equal at all location.
+
+    Notes
+    -----
+    The length of `labels` and `shape` must be identical.
+    """
+
+    def _int64_cut_off(shape) -> int:
+        acc = 1
+        for i, mul in enumerate(shape):
+            acc *= int(mul)
+            if not acc < lib.i8max:
+                return i
+        return len(shape)
+
+    def maybe_lift(lab, size: int) -> tuple[np.ndarray, int]:
+        # promote nan values (assigned -1 label in lab array)
+        # so that all output values are non-negative
+        return (lab + 1, size + 1) if (lab == -1).any() else (lab, size)
+
+    labels = [ensure_int64(x) for x in labels]
+    lshape = list(shape)
+    if not xnull:
+        for i, (lab, size) in enumerate(zip(labels, shape)):
+            labels[i], lshape[i] = maybe_lift(lab, size)
+
+    labels = list(labels)
+
+    # Iteratively process all the labels in chunks sized so less
+    # than lib.i8max unique int ids will be required for each chunk
+    while True:
+        # how many levels can be done without overflow:
+        nlev = _int64_cut_off(lshape)
+
+        # compute flat ids for the first `nlev` levels
+        stride = np.prod(lshape[1:nlev], dtype="i8")
+        out = stride * labels[0].astype("i8", subok=False, copy=False)
+
+        for i in range(1, nlev):
+            if lshape[i] == 0:
+                stride = np.int64(0)
+            else:
+                stride //= lshape[i]
+            out += labels[i] * stride
+
+        if xnull:  # exclude nulls
+            mask = labels[0] == -1
+            for lab in labels[1:nlev]:
+                mask |= lab == -1
+            out[mask] = -1
+
+        if nlev == len(lshape):  # all levels done!
+            break
+
+        # compress what has been done so far in order to avoid overflow
+        # to retain lexical ranks, obs_ids should be sorted
+        comp_ids, obs_ids = compress_group_index(out, sort=sort)
+
+        labels = [comp_ids] + labels[nlev:]
+        lshape = [len(obs_ids)] + lshape[nlev:]
+
+    return out
+
+
+def get_compressed_ids(
+    labels, sizes: Shape
+) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.int64]]:
+    """
+    Group_index is offsets into cartesian product of all possible labels. This
+    space can be huge, so this function compresses it, by computing offsets
+    (comp_ids) into the list of unique labels (obs_group_ids).
+
+    Parameters
+    ----------
+    labels : list of label arrays
+    sizes : tuple[int] of size of the levels
+
+    Returns
+    -------
+    np.ndarray[np.intp]
+        comp_ids
+    np.ndarray[np.int64]
+        obs_group_ids
+    """
+    ids = get_group_index(labels, sizes, sort=True, xnull=False)
+    return compress_group_index(ids, sort=True)
+
+
+def is_int64_overflow_possible(shape: Shape) -> bool:
+    the_prod = 1
+    for x in shape:
+        the_prod *= int(x)
+
+    return the_prod >= lib.i8max
+
+
+def _decons_group_index(
+    comp_labels: npt.NDArray[np.intp], shape: Shape
+) -> list[npt.NDArray[np.intp]]:
+    # reconstruct labels
+    if is_int64_overflow_possible(shape):
+        # at some point group indices are factorized,
+        # and may not be deconstructed here! wrong path!
+        raise ValueError("cannot deconstruct factorized group indices!")
+
+    label_list = []
+    factor = 1
+    y = np.array(0)
+    x = comp_labels
+    for i in reversed(range(len(shape))):
+        labels = (x - y) % (factor * shape[i]) // factor
+        np.putmask(labels, comp_labels < 0, -1)
+        label_list.append(labels)
+        y = labels * factor
+        factor *= shape[i]
+    return label_list[::-1]
+
+
+def decons_obs_group_ids(
+    comp_ids: npt.NDArray[np.intp],
+    obs_ids: npt.NDArray[np.intp],
+    shape: Shape,
+    labels: Sequence[npt.NDArray[np.signedinteger]],
+    xnull: bool,
+) -> list[npt.NDArray[np.intp]]:
+    """
+    Reconstruct labels from observed group ids.
+
+    Parameters
+    ----------
+    comp_ids : np.ndarray[np.intp]
+    obs_ids: np.ndarray[np.intp]
+    shape : tuple[int]
+    labels : Sequence[np.ndarray[np.signedinteger]]
+    xnull : bool
+        If nulls are excluded; i.e. -1 labels are passed through.
+    """
+    if not xnull:
+        lift = np.fromiter(((a == -1).any() for a in labels), dtype=np.intp)
+        arr_shape = np.asarray(shape, dtype=np.intp) + lift
+        shape = tuple(arr_shape)
+
+    if not is_int64_overflow_possible(shape):
+        # obs ids are deconstructable! take the fast route!
+        out = _decons_group_index(obs_ids, shape)
+        return out if xnull or not lift.any() else [x - y for x, y in zip(out, lift)]
+
+    indexer = unique_label_indices(comp_ids)
+    return [lab[indexer].astype(np.intp, subok=False, copy=True) for lab in labels]
+
+
+def lexsort_indexer(
+    keys: Sequence[ArrayLike | Index | Series],
+    orders=None,
+    na_position: str = "last",
+    key: Callable | None = None,
+    codes_given: bool = False,
+) -> npt.NDArray[np.intp]:
+    """
+    Performs lexical sorting on a set of keys
+
+    Parameters
+    ----------
+    keys : Sequence[ArrayLike | Index | Series]
+        Sequence of arrays to be sorted by the indexer
+        Sequence[Series] is only if key is not None.
+    orders : bool or list of booleans, optional
+        Determines the sorting order for each element in keys. If a list,
+        it must be the same length as keys. This determines whether the
+        corresponding element in keys should be sorted in ascending
+        (True) or descending (False) order. if bool, applied to all
+        elements as above. if None, defaults to True.
+    na_position : {'first', 'last'}, default 'last'
+        Determines placement of NA elements in the sorted list ("last" or "first")
+    key : Callable, optional
+        Callable key function applied to every element in keys before sorting
+    codes_given: bool, False
+        Avoid categorical materialization if codes are already provided.
+
+    Returns
+    -------
+    np.ndarray[np.intp]
+    """
+    from pandas.core.arrays import Categorical
+
+    if na_position not in ["last", "first"]:
+        raise ValueError(f"invalid na_position: {na_position}")
+
+    if isinstance(orders, bool):
+        orders = [orders] * len(keys)
+    elif orders is None:
+        orders = [True] * len(keys)
+
+    labels = []
+
+    for k, order in zip(keys, orders):
+        k = ensure_key_mapped(k, key)
+        if codes_given:
+            codes = cast(np.ndarray, k)
+            n = codes.max() + 1 if len(codes) else 0
+        else:
+            cat = Categorical(k, ordered=True)
+            codes = cat.codes
+            n = len(cat.categories)
+
+        mask = codes == -1
+
+        if na_position == "last" and mask.any():
+            codes = np.where(mask, n, codes)
+
+        # not order means descending
+        if not order:
+            codes = np.where(mask, codes, n - codes - 1)
+
+        labels.append(codes)
+
+    return np.lexsort(labels[::-1])
+
+
+def nargsort(
+    items: ArrayLike | Index | Series,
+    kind: SortKind = "quicksort",
+    ascending: bool = True,
+    na_position: str = "last",
+    key: Callable | None = None,
+    mask: npt.NDArray[np.bool_] | None = None,
+) -> npt.NDArray[np.intp]:
+    """
+    Intended to be a drop-in replacement for np.argsort which handles NaNs.
+
+    Adds ascending, na_position, and key parameters.
+
+    (GH #6399, #5231, #27237)
+
+    Parameters
+    ----------
+    items : np.ndarray, ExtensionArray, Index, or Series
+    kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, default 'quicksort'
+    ascending : bool, default True
+    na_position : {'first', 'last'}, default 'last'
+    key : Optional[Callable], default None
+    mask : Optional[np.ndarray[bool]], default None
+        Passed when called by ExtensionArray.argsort.
+
+    Returns
+    -------
+    np.ndarray[np.intp]
+    """
+
+    if key is not None:
+        # see TestDataFrameSortKey, TestRangeIndex::test_sort_values_key
+        items = ensure_key_mapped(items, key)
+        return nargsort(
+            items,
+            kind=kind,
+            ascending=ascending,
+            na_position=na_position,
+            key=None,
+            mask=mask,
+        )
+
+    if isinstance(items, ABCRangeIndex):
+        return items.argsort(ascending=ascending)
+    elif not isinstance(items, ABCMultiIndex):
+        items = extract_array(items)
+    else:
+        raise TypeError(
+            "nargsort does not support MultiIndex. Use index.sort_values instead."
+        )
+
+    if mask is None:
+        mask = np.asarray(isna(items))
+
+    if not isinstance(items, np.ndarray):
+        # i.e. ExtensionArray
+        return items.argsort(
+            ascending=ascending,
+            kind=kind,
+            na_position=na_position,
+        )
+
+    idx = np.arange(len(items))
+    non_nans = items[~mask]
+    non_nan_idx = idx[~mask]
+
+    nan_idx = np.nonzero(mask)[0]
+    if not ascending:
+        non_nans = non_nans[::-1]
+        non_nan_idx = non_nan_idx[::-1]
+    indexer = non_nan_idx[non_nans.argsort(kind=kind)]
+    if not ascending:
+        indexer = indexer[::-1]
+    # Finally, place the NaNs at the end or the beginning according to
+    # na_position
+    if na_position == "last":
+        indexer = np.concatenate([indexer, nan_idx])
+    elif na_position == "first":
+        indexer = np.concatenate([nan_idx, indexer])
+    else:
+        raise ValueError(f"invalid na_position: {na_position}")
+    return ensure_platform_int(indexer)
+
+
+def nargminmax(values: ExtensionArray, method: str, axis: AxisInt = 0):
+    """
+    Implementation of np.argmin/argmax but for ExtensionArray and which
+    handles missing values.
+
+    Parameters
+    ----------
+    values : ExtensionArray
+    method : {"argmax", "argmin"}
+    axis : int, default 0
+
+    Returns
+    -------
+    int
+    """
+    assert method in {"argmax", "argmin"}
+    func = np.argmax if method == "argmax" else np.argmin
+
+    mask = np.asarray(isna(values))
+    arr_values = values._values_for_argsort()
+
+    if arr_values.ndim > 1:
+        if mask.any():
+            if axis == 1:
+                zipped = zip(arr_values, mask)
+            else:
+                zipped = zip(arr_values.T, mask.T)
+            return np.array([_nanargminmax(v, m, func) for v, m in zipped])
+        return func(arr_values, axis=axis)
+
+    return _nanargminmax(arr_values, mask, func)
+
+
+def _nanargminmax(values: np.ndarray, mask: npt.NDArray[np.bool_], func) -> int:
+    """
+    See nanargminmax.__doc__.
+    """
+    idx = np.arange(values.shape[0])
+    non_nans = values[~mask]
+    non_nan_idx = idx[~mask]
+
+    return non_nan_idx[func(non_nans)]
+
+
+def _ensure_key_mapped_multiindex(
+    index: MultiIndex, key: Callable, level=None
+) -> MultiIndex:
+    """
+    Returns a new MultiIndex in which key has been applied
+    to all levels specified in level (or all levels if level
+    is None). Used for key sorting for MultiIndex.
+
+    Parameters
+    ----------
+    index : MultiIndex
+        Index to which to apply the key function on the
+        specified levels.
+    key : Callable
+        Function that takes an Index and returns an Index of
+        the same shape. This key is applied to each level
+        separately. The name of the level can be used to
+        distinguish different levels for application.
+    level : list-like, int or str, default None
+        Level or list of levels to apply the key function to.
+        If None, key function is applied to all levels. Other
+        levels are left unchanged.
+
+    Returns
+    -------
+    labels : MultiIndex
+        Resulting MultiIndex with modified levels.
+    """
+
+    if level is not None:
+        if isinstance(level, (str, int)):
+            sort_levels = [level]
+        else:
+            sort_levels = level
+
+        sort_levels = [index._get_level_number(lev) for lev in sort_levels]
+    else:
+        sort_levels = list(range(index.nlevels))  # satisfies mypy
+
+    mapped = [
+        ensure_key_mapped(index._get_level_values(level), key)
+        if level in sort_levels
+        else index._get_level_values(level)
+        for level in range(index.nlevels)
+    ]
+
+    return type(index).from_arrays(mapped)
+
+
+def ensure_key_mapped(
+    values: ArrayLike | Index | Series, key: Callable | None, levels=None
+) -> ArrayLike | Index | Series:
+    """
+    Applies a callable key function to the values function and checks
+    that the resulting value has the same shape. Can be called on Index
+    subclasses, Series, DataFrames, or ndarrays.
+
+    Parameters
+    ----------
+    values : Series, DataFrame, Index subclass, or ndarray
+    key : Optional[Callable], key to be called on the values array
+    levels : Optional[List], if values is a MultiIndex, list of levels to
+    apply the key to.
+    """
+    from pandas.core.indexes.api import Index
+
+    if not key:
+        return values
+
+    if isinstance(values, ABCMultiIndex):
+        return _ensure_key_mapped_multiindex(values, key, level=levels)
+
+    result = key(values.copy())
+    if len(result) != len(values):
+        raise ValueError(
+            "User-provided `key` function must not change the shape of the array."
+        )
+
+    try:
+        if isinstance(
+            values, Index
+        ):  # convert to a new Index subclass, not necessarily the same
+            result = Index(result)
+        else:
+            # try to revert to original type otherwise
+            type_of_values = type(values)
+            #  error: Too many arguments for "ExtensionArray"
+            result = type_of_values(result)  # type: ignore[call-arg]
+    except TypeError:
+        raise TypeError(
+            f"User-provided `key` function returned an invalid type {type(result)} \
+            which could not be converted to {type(values)}."
+        )
+
+    return result
+
+
+def get_flattened_list(
+    comp_ids: npt.NDArray[np.intp],
+    ngroups: int,
+    levels: Iterable[Index],
+    labels: Iterable[np.ndarray],
+) -> list[tuple]:
+    """Map compressed group id -> key tuple."""
+    comp_ids = comp_ids.astype(np.int64, copy=False)
+    arrays: DefaultDict[int, list[int]] = defaultdict(list)
+    for labs, level in zip(labels, levels):
+        table = hashtable.Int64HashTable(ngroups)
+        table.map_keys_to_values(comp_ids, labs.astype(np.int64, copy=False))
+        for i in range(ngroups):
+            arrays[i].append(level[table.get_item(i)])
+    return [tuple(array) for array in arrays.values()]
+
+
+def get_indexer_dict(
+    label_list: list[np.ndarray], keys: list[Index]
+) -> dict[Hashable, npt.NDArray[np.intp]]:
+    """
+    Returns
+    -------
+    dict:
+        Labels mapped to indexers.
+    """
+    shape = tuple(len(x) for x in keys)
+
+    group_index = get_group_index(label_list, shape, sort=True, xnull=True)
+    if np.all(group_index == -1):
+        # Short-circuit, lib.indices_fast will return the same
+        return {}
+    ngroups = (
+        ((group_index.size and group_index.max()) + 1)
+        if is_int64_overflow_possible(shape)
+        else np.prod(shape, dtype="i8")
+    )
+
+    sorter = get_group_index_sorter(group_index, ngroups)
+
+    sorted_labels = [lab.take(sorter) for lab in label_list]
+    group_index = group_index.take(sorter)
+
+    return lib.indices_fast(sorter, group_index, keys, sorted_labels)
+
+
+# ----------------------------------------------------------------------
+# sorting levels...cleverly?
+
+
+def get_group_index_sorter(
+    group_index: npt.NDArray[np.intp], ngroups: int | None = None
+) -> npt.NDArray[np.intp]:
+    """
+    algos.groupsort_indexer implements `counting sort` and it is at least
+    O(ngroups), where
+        ngroups = prod(shape)
+        shape = map(len, keys)
+    that is, linear in the number of combinations (cartesian product) of unique
+    values of groupby keys. This can be huge when doing multi-key groupby.
+    np.argsort(kind='mergesort') is O(count x log(count)) where count is the
+    length of the data-frame;
+    Both algorithms are `stable` sort and that is necessary for correctness of
+    groupby operations. e.g. consider:
+        df.groupby(key)[col].transform('first')
+
+    Parameters
+    ----------
+    group_index : np.ndarray[np.intp]
+        signed integer dtype
+    ngroups : int or None, default None
+
+    Returns
+    -------
+    np.ndarray[np.intp]
+    """
+    if ngroups is None:
+        ngroups = 1 + group_index.max()
+    count = len(group_index)
+    alpha = 0.0  # taking complexities literally; there may be
+    beta = 1.0  # some room for fine-tuning these parameters
+    do_groupsort = count > 0 and ((alpha + beta * ngroups) < (count * np.log(count)))
+    if do_groupsort:
+        sorter, _ = algos.groupsort_indexer(
+            ensure_platform_int(group_index),
+            ngroups,
+        )
+        # sorter _should_ already be intp, but mypy is not yet able to verify
+    else:
+        sorter = group_index.argsort(kind="mergesort")
+    return ensure_platform_int(sorter)
+
+
+def compress_group_index(
+    group_index: npt.NDArray[np.int64], sort: bool = True
+) -> tuple[npt.NDArray[np.int64], npt.NDArray[np.int64]]:
+    """
+    Group_index is offsets into cartesian product of all possible labels. This
+    space can be huge, so this function compresses it, by computing offsets
+    (comp_ids) into the list of unique labels (obs_group_ids).
+    """
+    if len(group_index) and np.all(group_index[1:] >= group_index[:-1]):
+        # GH 53806: fast path for sorted group_index
+        unique_mask = np.concatenate(
+            [group_index[:1] > -1, group_index[1:] != group_index[:-1]]
+        )
+        comp_ids = unique_mask.cumsum()
+        comp_ids -= 1
+        obs_group_ids = group_index[unique_mask]
+    else:
+        size_hint = len(group_index)
+        table = hashtable.Int64HashTable(size_hint)
+
+        group_index = ensure_int64(group_index)
+
+        # note, group labels come out ascending (ie, 1,2,3 etc)
+        comp_ids, obs_group_ids = table.get_labels_groupby(group_index)
+
+        if sort and len(obs_group_ids) > 0:
+            obs_group_ids, comp_ids = _reorder_by_uniques(obs_group_ids, comp_ids)
+
+    return ensure_int64(comp_ids), ensure_int64(obs_group_ids)
+
+
+def _reorder_by_uniques(
+    uniques: npt.NDArray[np.int64], labels: npt.NDArray[np.intp]
+) -> tuple[npt.NDArray[np.int64], npt.NDArray[np.intp]]:
+    """
+    Parameters
+    ----------
+    uniques : np.ndarray[np.int64]
+    labels : np.ndarray[np.intp]
+
+    Returns
+    -------
+    np.ndarray[np.int64]
+    np.ndarray[np.intp]
+    """
+    # sorter is index where elements ought to go
+    sorter = uniques.argsort()
+
+    # reverse_indexer is where elements came from
+    reverse_indexer = np.empty(len(sorter), dtype=np.intp)
+    reverse_indexer.put(sorter, np.arange(len(sorter)))
+
+    mask = labels < 0
+
+    # move labels to right locations (ie, unsort ascending labels)
+    labels = reverse_indexer.take(labels)
+    np.putmask(labels, mask, -1)
+
+    # sort observed ids
+    uniques = uniques.take(sorter)
+
+    return uniques, labels

videollama2/lib/python3.10/site-packages/pandas/tseries/__init__.py

@@ -0,0 +1,12 @@
+# ruff: noqa: TCH004
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    # import modules that have public classes/functions:
+    from pandas.tseries import (
+        frequencies,
+        offsets,
+    )
+
+    # and mark only those modules as public
+    __all__ = ["frequencies", "offsets"]

videollama2/lib/python3.10/site-packages/pandas/tseries/api.py

@@ -0,0 +1,10 @@
+"""
+Timeseries API
+"""
+
+from pandas._libs.tslibs.parsing import guess_datetime_format
+
+from pandas.tseries import offsets
+from pandas.tseries.frequencies import infer_freq
+
+__all__ = ["infer_freq", "offsets", "guess_datetime_format"]

videollama2/lib/python3.10/site-packages/pandas/tseries/frequencies.py

@@ -0,0 +1,602 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from pandas._libs import lib
+from pandas._libs.algos import unique_deltas
+from pandas._libs.tslibs import (
+    Timestamp,
+    get_unit_from_dtype,
+    periods_per_day,
+    tz_convert_from_utc,
+)
+from pandas._libs.tslibs.ccalendar import (
+    DAYS,
+    MONTH_ALIASES,
+    MONTH_NUMBERS,
+    MONTHS,
+    int_to_weekday,
+)
+from pandas._libs.tslibs.dtypes import (
+    OFFSET_TO_PERIOD_FREQSTR,
+    freq_to_period_freqstr,
+)
+from pandas._libs.tslibs.fields import (
+    build_field_sarray,
+    month_position_check,
+)
+from pandas._libs.tslibs.offsets import (
+    DateOffset,
+    Day,
+    to_offset,
+)
+from pandas._libs.tslibs.parsing import get_rule_month
+from pandas.util._decorators import cache_readonly
+
+from pandas.core.dtypes.common import is_numeric_dtype
+from pandas.core.dtypes.dtypes import (
+    DatetimeTZDtype,
+    PeriodDtype,
+)
+from pandas.core.dtypes.generic import (
+    ABCIndex,
+    ABCSeries,
+)
+
+from pandas.core.algorithms import unique
+
+if TYPE_CHECKING:
+    from pandas._typing import npt
+
+    from pandas import (
+        DatetimeIndex,
+        Series,
+        TimedeltaIndex,
+    )
+    from pandas.core.arrays.datetimelike import DatetimeLikeArrayMixin
+# --------------------------------------------------------------------
+# Offset related functions
+
+_need_suffix = ["QS", "BQE", "BQS", "YS", "BYE", "BYS"]
+
+for _prefix in _need_suffix:
+    for _m in MONTHS:
+        key = f"{_prefix}-{_m}"
+        OFFSET_TO_PERIOD_FREQSTR[key] = OFFSET_TO_PERIOD_FREQSTR[_prefix]
+
+for _prefix in ["Y", "Q"]:
+    for _m in MONTHS:
+        _alias = f"{_prefix}-{_m}"
+        OFFSET_TO_PERIOD_FREQSTR[_alias] = _alias
+
+for _d in DAYS:
+    OFFSET_TO_PERIOD_FREQSTR[f"W-{_d}"] = f"W-{_d}"
+
+
+def get_period_alias(offset_str: str) -> str | None:
+    """
+    Alias to closest period strings BQ->Q etc.
+    """
+    return OFFSET_TO_PERIOD_FREQSTR.get(offset_str, None)
+
+
+# ---------------------------------------------------------------------
+# Period codes
+
+
+def infer_freq(
+    index: DatetimeIndex | TimedeltaIndex | Series | DatetimeLikeArrayMixin,
+) -> str | None:
+    """
+    Infer the most likely frequency given the input index.
+
+    Parameters
+    ----------
+    index : DatetimeIndex, TimedeltaIndex, Series or array-like
+      If passed a Series will use the values of the series (NOT THE INDEX).
+
+    Returns
+    -------
+    str or None
+        None if no discernible frequency.
+
+    Raises
+    ------
+    TypeError
+        If the index is not datetime-like.
+    ValueError
+        If there are fewer than three values.
+
+    Examples
+    --------
+    >>> idx = pd.date_range(start='2020/12/01', end='2020/12/30', periods=30)
+    >>> pd.infer_freq(idx)
+    'D'
+    """
+    from pandas.core.api import DatetimeIndex
+
+    if isinstance(index, ABCSeries):
+        values = index._values
+        if not (
+            lib.is_np_dtype(values.dtype, "mM")
+            or isinstance(values.dtype, DatetimeTZDtype)
+            or values.dtype == object
+        ):
+            raise TypeError(
+                "cannot infer freq from a non-convertible dtype "
+                f"on a Series of {index.dtype}"
+            )
+        index = values
+
+    inferer: _FrequencyInferer
+
+    if not hasattr(index, "dtype"):
+        pass
+    elif isinstance(index.dtype, PeriodDtype):
+        raise TypeError(
+            "PeriodIndex given. Check the `freq` attribute "
+            "instead of using infer_freq."
+        )
+    elif lib.is_np_dtype(index.dtype, "m"):
+        # Allow TimedeltaIndex and TimedeltaArray
+        inferer = _TimedeltaFrequencyInferer(index)
+        return inferer.get_freq()
+
+    elif is_numeric_dtype(index.dtype):
+        raise TypeError(
+            f"cannot infer freq from a non-convertible index of dtype {index.dtype}"
+        )
+
+    if not isinstance(index, DatetimeIndex):
+        index = DatetimeIndex(index)
+
+    inferer = _FrequencyInferer(index)
+    return inferer.get_freq()
+
+
+class _FrequencyInferer:
+    """
+    Not sure if I can avoid the state machine here
+    """
+
+    def __init__(self, index) -> None:
+        self.index = index
+        self.i8values = index.asi8
+
+        # For get_unit_from_dtype we need the dtype to the underlying ndarray,
+        #  which for tz-aware is not the same as index.dtype
+        if isinstance(index, ABCIndex):
+            # error: Item "ndarray[Any, Any]" of "Union[ExtensionArray,
+            # ndarray[Any, Any]]" has no attribute "_ndarray"
+            self._creso = get_unit_from_dtype(
+                index._data._ndarray.dtype  # type: ignore[union-attr]
+            )
+        else:
+            # otherwise we have DTA/TDA
+            self._creso = get_unit_from_dtype(index._ndarray.dtype)
+
+        # This moves the values, which are implicitly in UTC, to the
+        # the timezone so they are in local time
+        if hasattr(index, "tz"):
+            if index.tz is not None:
+                self.i8values = tz_convert_from_utc(
+                    self.i8values, index.tz, reso=self._creso
+                )
+
+        if len(index) < 3:
+            raise ValueError("Need at least 3 dates to infer frequency")
+
+        self.is_monotonic = (
+            self.index._is_monotonic_increasing or self.index._is_monotonic_decreasing
+        )
+
+    @cache_readonly
+    def deltas(self) -> npt.NDArray[np.int64]:
+        return unique_deltas(self.i8values)
+
+    @cache_readonly
+    def deltas_asi8(self) -> npt.NDArray[np.int64]:
+        # NB: we cannot use self.i8values here because we may have converted
+        #  the tz in __init__
+        return unique_deltas(self.index.asi8)
+
+    @cache_readonly
+    def is_unique(self) -> bool:
+        return len(self.deltas) == 1
+
+    @cache_readonly
+    def is_unique_asi8(self) -> bool:
+        return len(self.deltas_asi8) == 1
+
+    def get_freq(self) -> str | None:
+        """
+        Find the appropriate frequency string to describe the inferred
+        frequency of self.i8values
+
+        Returns
+        -------
+        str or None
+        """
+        if not self.is_monotonic or not self.index._is_unique:
+            return None
+
+        delta = self.deltas[0]
+        ppd = periods_per_day(self._creso)
+        if delta and _is_multiple(delta, ppd):
+            return self._infer_daily_rule()
+
+        # Business hourly, maybe. 17: one day / 65: one weekend
+        if self.hour_deltas in ([1, 17], [1, 65], [1, 17, 65]):
+            return "bh"
+
+        # Possibly intraday frequency.  Here we use the
+        # original .asi8 values as the modified values
+        # will not work around DST transitions.  See #8772
+        if not self.is_unique_asi8:
+            return None
+
+        delta = self.deltas_asi8[0]
+        pph = ppd // 24
+        ppm = pph // 60
+        pps = ppm // 60
+        if _is_multiple(delta, pph):
+            # Hours
+            return _maybe_add_count("h", delta / pph)
+        elif _is_multiple(delta, ppm):
+            # Minutes
+            return _maybe_add_count("min", delta / ppm)
+        elif _is_multiple(delta, pps):
+            # Seconds
+            return _maybe_add_count("s", delta / pps)
+        elif _is_multiple(delta, (pps // 1000)):
+            # Milliseconds
+            return _maybe_add_count("ms", delta / (pps // 1000))
+        elif _is_multiple(delta, (pps // 1_000_000)):
+            # Microseconds
+            return _maybe_add_count("us", delta / (pps // 1_000_000))
+        else:
+            # Nanoseconds
+            return _maybe_add_count("ns", delta)
+
+    @cache_readonly
+    def day_deltas(self) -> list[int]:
+        ppd = periods_per_day(self._creso)
+        return [x / ppd for x in self.deltas]
+
+    @cache_readonly
+    def hour_deltas(self) -> list[int]:
+        pph = periods_per_day(self._creso) // 24
+        return [x / pph for x in self.deltas]
+
+    @cache_readonly
+    def fields(self) -> np.ndarray:  # structured array of fields
+        return build_field_sarray(self.i8values, reso=self._creso)
+
+    @cache_readonly
+    def rep_stamp(self) -> Timestamp:
+        return Timestamp(self.i8values[0], unit=self.index.unit)
+
+    def month_position_check(self) -> str | None:
+        return month_position_check(self.fields, self.index.dayofweek)
+
+    @cache_readonly
+    def mdiffs(self) -> npt.NDArray[np.int64]:
+        nmonths = self.fields["Y"] * 12 + self.fields["M"]
+        return unique_deltas(nmonths.astype("i8"))
+
+    @cache_readonly
+    def ydiffs(self) -> npt.NDArray[np.int64]:
+        return unique_deltas(self.fields["Y"].astype("i8"))
+
+    def _infer_daily_rule(self) -> str | None:
+        annual_rule = self._get_annual_rule()
+        if annual_rule:
+            nyears = self.ydiffs[0]
+            month = MONTH_ALIASES[self.rep_stamp.month]
+            alias = f"{annual_rule}-{month}"
+            return _maybe_add_count(alias, nyears)
+
+        quarterly_rule = self._get_quarterly_rule()
+        if quarterly_rule:
+            nquarters = self.mdiffs[0] / 3
+            mod_dict = {0: 12, 2: 11, 1: 10}
+            month = MONTH_ALIASES[mod_dict[self.rep_stamp.month % 3]]
+            alias = f"{quarterly_rule}-{month}"
+            return _maybe_add_count(alias, nquarters)
+
+        monthly_rule = self._get_monthly_rule()
+        if monthly_rule:
+            return _maybe_add_count(monthly_rule, self.mdiffs[0])
+
+        if self.is_unique:
+            return self._get_daily_rule()
+
+        if self._is_business_daily():
+            return "B"
+
+        wom_rule = self._get_wom_rule()
+        if wom_rule:
+            return wom_rule
+
+        return None
+
+    def _get_daily_rule(self) -> str | None:
+        ppd = periods_per_day(self._creso)
+        days = self.deltas[0] / ppd
+        if days % 7 == 0:
+            # Weekly
+            wd = int_to_weekday[self.rep_stamp.weekday()]
+            alias = f"W-{wd}"
+            return _maybe_add_count(alias, days / 7)
+        else:
+            return _maybe_add_count("D", days)
+
+    def _get_annual_rule(self) -> str | None:
+        if len(self.ydiffs) > 1:
+            return None
+
+        if len(unique(self.fields["M"])) > 1:
+            return None
+
+        pos_check = self.month_position_check()
+
+        if pos_check is None:
+            return None
+        else:
+            return {"cs": "YS", "bs": "BYS", "ce": "YE", "be": "BYE"}.get(pos_check)
+
+    def _get_quarterly_rule(self) -> str | None:
+        if len(self.mdiffs) > 1:
+            return None
+
+        if not self.mdiffs[0] % 3 == 0:
+            return None
+
+        pos_check = self.month_position_check()
+
+        if pos_check is None:
+            return None
+        else:
+            return {"cs": "QS", "bs": "BQS", "ce": "QE", "be": "BQE"}.get(pos_check)
+
+    def _get_monthly_rule(self) -> str | None:
+        if len(self.mdiffs) > 1:
+            return None
+        pos_check = self.month_position_check()
+
+        if pos_check is None:
+            return None
+        else:
+            return {"cs": "MS", "bs": "BMS", "ce": "ME", "be": "BME"}.get(pos_check)
+
+    def _is_business_daily(self) -> bool:
+        # quick check: cannot be business daily
+        if self.day_deltas != [1, 3]:
+            return False
+
+        # probably business daily, but need to confirm
+        first_weekday = self.index[0].weekday()
+        shifts = np.diff(self.i8values)
+        ppd = periods_per_day(self._creso)
+        shifts = np.floor_divide(shifts, ppd)
+        weekdays = np.mod(first_weekday + np.cumsum(shifts), 7)
+
+        return bool(
+            np.all(
+                ((weekdays == 0) & (shifts == 3))
+                | ((weekdays > 0) & (weekdays <= 4) & (shifts == 1))
+            )
+        )
+
+    def _get_wom_rule(self) -> str | None:
+        weekdays = unique(self.index.weekday)
+        if len(weekdays) > 1:
+            return None
+
+        week_of_months = unique((self.index.day - 1) // 7)
+        # Only attempt to infer up to WOM-4. See #9425
+        week_of_months = week_of_months[week_of_months < 4]
+        if len(week_of_months) == 0 or len(week_of_months) > 1:
+            return None
+
+        # get which week
+        week = week_of_months[0] + 1
+        wd = int_to_weekday[weekdays[0]]
+
+        return f"WOM-{week}{wd}"
+
+
+class _TimedeltaFrequencyInferer(_FrequencyInferer):
+    def _infer_daily_rule(self):
+        if self.is_unique:
+            return self._get_daily_rule()
+
+
+def _is_multiple(us, mult: int) -> bool:
+    return us % mult == 0
+
+
+def _maybe_add_count(base: str, count: float) -> str:
+    if count != 1:
+        assert count == int(count)
+        count = int(count)
+        return f"{count}{base}"
+    else:
+        return base
+
+
+# ----------------------------------------------------------------------
+# Frequency comparison
+
+
+def is_subperiod(source, target) -> bool:
+    """
+    Returns True if downsampling is possible between source and target
+    frequencies
+
+    Parameters
+    ----------
+    source : str or DateOffset
+        Frequency converting from
+    target : str or DateOffset
+        Frequency converting to
+
+    Returns
+    -------
+    bool
+    """
+    if target is None or source is None:
+        return False
+    source = _maybe_coerce_freq(source)
+    target = _maybe_coerce_freq(target)
+
+    if _is_annual(target):
+        if _is_quarterly(source):
+            return _quarter_months_conform(
+                get_rule_month(source), get_rule_month(target)
+            )
+        return source in {"D", "C", "B", "M", "h", "min", "s", "ms", "us", "ns"}
+    elif _is_quarterly(target):
+        return source in {"D", "C", "B", "M", "h", "min", "s", "ms", "us", "ns"}
+    elif _is_monthly(target):
+        return source in {"D", "C", "B", "h", "min", "s", "ms", "us", "ns"}
+    elif _is_weekly(target):
+        return source in {target, "D", "C", "B", "h", "min", "s", "ms", "us", "ns"}
+    elif target == "B":
+        return source in {"B", "h", "min", "s", "ms", "us", "ns"}
+    elif target == "C":
+        return source in {"C", "h", "min", "s", "ms", "us", "ns"}
+    elif target == "D":
+        return source in {"D", "h", "min", "s", "ms", "us", "ns"}
+    elif target == "h":
+        return source in {"h", "min", "s", "ms", "us", "ns"}
+    elif target == "min":
+        return source in {"min", "s", "ms", "us", "ns"}
+    elif target == "s":
+        return source in {"s", "ms", "us", "ns"}
+    elif target == "ms":
+        return source in {"ms", "us", "ns"}
+    elif target == "us":
+        return source in {"us", "ns"}
+    elif target == "ns":
+        return source in {"ns"}
+    else:
+        return False
+
+
+def is_superperiod(source, target) -> bool:
+    """
+    Returns True if upsampling is possible between source and target
+    frequencies
+
+    Parameters
+    ----------
+    source : str or DateOffset
+        Frequency converting from
+    target : str or DateOffset
+        Frequency converting to
+
+    Returns
+    -------
+    bool
+    """
+    if target is None or source is None:
+        return False
+    source = _maybe_coerce_freq(source)
+    target = _maybe_coerce_freq(target)
+
+    if _is_annual(source):
+        if _is_annual(target):
+            return get_rule_month(source) == get_rule_month(target)
+
+        if _is_quarterly(target):
+            smonth = get_rule_month(source)
+            tmonth = get_rule_month(target)
+            return _quarter_months_conform(smonth, tmonth)
+        return target in {"D", "C", "B", "M", "h", "min", "s", "ms", "us", "ns"}
+    elif _is_quarterly(source):
+        return target in {"D", "C", "B", "M", "h", "min", "s", "ms", "us", "ns"}
+    elif _is_monthly(source):
+        return target in {"D", "C", "B", "h", "min", "s", "ms", "us", "ns"}
+    elif _is_weekly(source):
+        return target in {source, "D", "C", "B", "h", "min", "s", "ms", "us", "ns"}
+    elif source == "B":
+        return target in {"D", "C", "B", "h", "min", "s", "ms", "us", "ns"}
+    elif source == "C":
+        return target in {"D", "C", "B", "h", "min", "s", "ms", "us", "ns"}
+    elif source == "D":
+        return target in {"D", "C", "B", "h", "min", "s", "ms", "us", "ns"}
+    elif source == "h":
+        return target in {"h", "min", "s", "ms", "us", "ns"}
+    elif source == "min":
+        return target in {"min", "s", "ms", "us", "ns"}
+    elif source == "s":
+        return target in {"s", "ms", "us", "ns"}
+    elif source == "ms":
+        return target in {"ms", "us", "ns"}
+    elif source == "us":
+        return target in {"us", "ns"}
+    elif source == "ns":
+        return target in {"ns"}
+    else:
+        return False
+
+
+def _maybe_coerce_freq(code) -> str:
+    """we might need to coerce a code to a rule_code
+    and uppercase it
+
+    Parameters
+    ----------
+    source : str or DateOffset
+        Frequency converting from
+
+    Returns
+    -------
+    str
+    """
+    assert code is not None
+    if isinstance(code, DateOffset):
+        code = freq_to_period_freqstr(1, code.name)
+    if code in {"h", "min", "s", "ms", "us", "ns"}:
+        return code
+    else:
+        return code.upper()
+
+
+def _quarter_months_conform(source: str, target: str) -> bool:
+    snum = MONTH_NUMBERS[source]
+    tnum = MONTH_NUMBERS[target]
+    return snum % 3 == tnum % 3
+
+
+def _is_annual(rule: str) -> bool:
+    rule = rule.upper()
+    return rule == "Y" or rule.startswith("Y-")
+
+
+def _is_quarterly(rule: str) -> bool:
+    rule = rule.upper()
+    return rule == "Q" or rule.startswith(("Q-", "BQ"))
+
+
+def _is_monthly(rule: str) -> bool:
+    rule = rule.upper()
+    return rule in ("M", "BM")
+
+
+def _is_weekly(rule: str) -> bool:
+    rule = rule.upper()
+    return rule == "W" or rule.startswith("W-")
+
+
+__all__ = [
+    "Day",
+    "get_period_alias",
+    "infer_freq",
+    "is_subperiod",
+    "is_superperiod",
+    "to_offset",
+]

videollama2/lib/python3.10/site-packages/pandas/tseries/holiday.py

@@ -0,0 +1,634 @@
+from __future__ import annotations
+
+from datetime import (
+    datetime,
+    timedelta,
+)
+import warnings
+
+from dateutil.relativedelta import (
+    FR,
+    MO,
+    SA,
+    SU,
+    TH,
+    TU,
+    WE,
+)
+import numpy as np
+
+from pandas.errors import PerformanceWarning
+
+from pandas import (
+    DateOffset,
+    DatetimeIndex,
+    Series,
+    Timestamp,
+    concat,
+    date_range,
+)
+
+from pandas.tseries.offsets import (
+    Day,
+    Easter,
+)
+
+
+def next_monday(dt: datetime) -> datetime:
+    """
+    If holiday falls on Saturday, use following Monday instead;
+    if holiday falls on Sunday, use Monday instead
+    """
+    if dt.weekday() == 5:
+        return dt + timedelta(2)
+    elif dt.weekday() == 6:
+        return dt + timedelta(1)
+    return dt
+
+
+def next_monday_or_tuesday(dt: datetime) -> datetime:
+    """
+    For second holiday of two adjacent ones!
+    If holiday falls on Saturday, use following Monday instead;
+    if holiday falls on Sunday or Monday, use following Tuesday instead
+    (because Monday is already taken by adjacent holiday on the day before)
+    """
+    dow = dt.weekday()
+    if dow in (5, 6):
+        return dt + timedelta(2)
+    if dow == 0:
+        return dt + timedelta(1)
+    return dt
+
+
+def previous_friday(dt: datetime) -> datetime:
+    """
+    If holiday falls on Saturday or Sunday, use previous Friday instead.
+    """
+    if dt.weekday() == 5:
+        return dt - timedelta(1)
+    elif dt.weekday() == 6:
+        return dt - timedelta(2)
+    return dt
+
+
+def sunday_to_monday(dt: datetime) -> datetime:
+    """
+    If holiday falls on Sunday, use day thereafter (Monday) instead.
+    """
+    if dt.weekday() == 6:
+        return dt + timedelta(1)
+    return dt
+
+
+def weekend_to_monday(dt: datetime) -> datetime:
+    """
+    If holiday falls on Sunday or Saturday,
+    use day thereafter (Monday) instead.
+    Needed for holidays such as Christmas observation in Europe
+    """
+    if dt.weekday() == 6:
+        return dt + timedelta(1)
+    elif dt.weekday() == 5:
+        return dt + timedelta(2)
+    return dt
+
+
+def nearest_workday(dt: datetime) -> datetime:
+    """
+    If holiday falls on Saturday, use day before (Friday) instead;
+    if holiday falls on Sunday, use day thereafter (Monday) instead.
+    """
+    if dt.weekday() == 5:
+        return dt - timedelta(1)
+    elif dt.weekday() == 6:
+        return dt + timedelta(1)
+    return dt
+
+
+def next_workday(dt: datetime) -> datetime:
+    """
+    returns next weekday used for observances
+    """
+    dt += timedelta(days=1)
+    while dt.weekday() > 4:
+        # Mon-Fri are 0-4
+        dt += timedelta(days=1)
+    return dt
+
+
+def previous_workday(dt: datetime) -> datetime:
+    """
+    returns previous weekday used for observances
+    """
+    dt -= timedelta(days=1)
+    while dt.weekday() > 4:
+        # Mon-Fri are 0-4
+        dt -= timedelta(days=1)
+    return dt
+
+
+def before_nearest_workday(dt: datetime) -> datetime:
+    """
+    returns previous workday after nearest workday
+    """
+    return previous_workday(nearest_workday(dt))
+
+
+def after_nearest_workday(dt: datetime) -> datetime:
+    """
+    returns next workday after nearest workday
+    needed for Boxing day or multiple holidays in a series
+    """
+    return next_workday(nearest_workday(dt))
+
+
+class Holiday:
+    """
+    Class that defines a holiday with start/end dates and rules
+    for observance.
+    """
+
+    start_date: Timestamp | None
+    end_date: Timestamp | None
+    days_of_week: tuple[int, ...] | None
+
+    def __init__(
+        self,
+        name: str,
+        year=None,
+        month=None,
+        day=None,
+        offset=None,
+        observance=None,
+        start_date=None,
+        end_date=None,
+        days_of_week=None,
+    ) -> None:
+        """
+        Parameters
+        ----------
+        name : str
+            Name of the holiday , defaults to class name
+        offset : array of pandas.tseries.offsets or
+                class from pandas.tseries.offsets
+            computes offset from date
+        observance: function
+            computes when holiday is given a pandas Timestamp
+        days_of_week:
+            provide a tuple of days e.g  (0,1,2,3,) for Monday Through Thursday
+            Monday=0,..,Sunday=6
+
+        Examples
+        --------
+        >>> from dateutil.relativedelta import MO
+
+        >>> USMemorialDay = pd.tseries.holiday.Holiday(
+        ...     "Memorial Day", month=5, day=31, offset=pd.DateOffset(weekday=MO(-1))
+        ... )
+        >>> USMemorialDay
+        Holiday: Memorial Day (month=5, day=31, offset=<DateOffset: weekday=MO(-1)>)
+
+        >>> USLaborDay = pd.tseries.holiday.Holiday(
+        ...     "Labor Day", month=9, day=1, offset=pd.DateOffset(weekday=MO(1))
+        ... )
+        >>> USLaborDay
+        Holiday: Labor Day (month=9, day=1, offset=<DateOffset: weekday=MO(+1)>)
+
+        >>> July3rd = pd.tseries.holiday.Holiday("July 3rd", month=7, day=3)
+        >>> July3rd
+        Holiday: July 3rd (month=7, day=3, )
+
+        >>> NewYears = pd.tseries.holiday.Holiday(
+        ...     "New Years Day", month=1,  day=1,
+        ...      observance=pd.tseries.holiday.nearest_workday
+        ... )
+        >>> NewYears  # doctest: +SKIP
+        Holiday: New Years Day (
+            month=1, day=1, observance=<function nearest_workday at 0x66545e9bc440>
+        )
+
+        >>> July3rd = pd.tseries.holiday.Holiday(
+        ...     "July 3rd", month=7, day=3,
+        ...     days_of_week=(0, 1, 2, 3)
+        ... )
+        >>> July3rd
+        Holiday: July 3rd (month=7, day=3, )
+        """
+        if offset is not None and observance is not None:
+            raise NotImplementedError("Cannot use both offset and observance.")
+
+        self.name = name
+        self.year = year
+        self.month = month
+        self.day = day
+        self.offset = offset
+        self.start_date = (
+            Timestamp(start_date) if start_date is not None else start_date
+        )
+        self.end_date = Timestamp(end_date) if end_date is not None else end_date
+        self.observance = observance
+        assert days_of_week is None or type(days_of_week) == tuple
+        self.days_of_week = days_of_week
+
+    def __repr__(self) -> str:
+        info = ""
+        if self.year is not None:
+            info += f"year={self.year}, "
+        info += f"month={self.month}, day={self.day}, "
+
+        if self.offset is not None:
+            info += f"offset={self.offset}"
+
+        if self.observance is not None:
+            info += f"observance={self.observance}"
+
+        repr = f"Holiday: {self.name} ({info})"
+        return repr
+
+    def dates(
+        self, start_date, end_date, return_name: bool = False
+    ) -> Series | DatetimeIndex:
+        """
+        Calculate holidays observed between start date and end date
+
+        Parameters
+        ----------
+        start_date : starting date, datetime-like, optional
+        end_date : ending date, datetime-like, optional
+        return_name : bool, optional, default=False
+            If True, return a series that has dates and holiday names.
+            False will only return dates.
+
+        Returns
+        -------
+        Series or DatetimeIndex
+            Series if return_name is True
+        """
+        start_date = Timestamp(start_date)
+        end_date = Timestamp(end_date)
+
+        filter_start_date = start_date
+        filter_end_date = end_date
+
+        if self.year is not None:
+            dt = Timestamp(datetime(self.year, self.month, self.day))
+            dti = DatetimeIndex([dt])
+            if return_name:
+                return Series(self.name, index=dti)
+            else:
+                return dti
+
+        dates = self._reference_dates(start_date, end_date)
+        holiday_dates = self._apply_rule(dates)
+        if self.days_of_week is not None:
+            holiday_dates = holiday_dates[
+                np.isin(
+                    # error: "DatetimeIndex" has no attribute "dayofweek"
+                    holiday_dates.dayofweek,  # type: ignore[attr-defined]
+                    self.days_of_week,
+                ).ravel()
+            ]
+
+        if self.start_date is not None:
+            filter_start_date = max(
+                self.start_date.tz_localize(filter_start_date.tz), filter_start_date
+            )
+        if self.end_date is not None:
+            filter_end_date = min(
+                self.end_date.tz_localize(filter_end_date.tz), filter_end_date
+            )
+        holiday_dates = holiday_dates[
+            (holiday_dates >= filter_start_date) & (holiday_dates <= filter_end_date)
+        ]
+        if return_name:
+            return Series(self.name, index=holiday_dates)
+        return holiday_dates
+
+    def _reference_dates(
+        self, start_date: Timestamp, end_date: Timestamp
+    ) -> DatetimeIndex:
+        """
+        Get reference dates for the holiday.
+
+        Return reference dates for the holiday also returning the year
+        prior to the start_date and year following the end_date.  This ensures
+        that any offsets to be applied will yield the holidays within
+        the passed in dates.
+        """
+        if self.start_date is not None:
+            start_date = self.start_date.tz_localize(start_date.tz)
+
+        if self.end_date is not None:
+            end_date = self.end_date.tz_localize(start_date.tz)
+
+        year_offset = DateOffset(years=1)
+        reference_start_date = Timestamp(
+            datetime(start_date.year - 1, self.month, self.day)
+        )
+
+        reference_end_date = Timestamp(
+            datetime(end_date.year + 1, self.month, self.day)
+        )
+        # Don't process unnecessary holidays
+        dates = date_range(
+            start=reference_start_date,
+            end=reference_end_date,
+            freq=year_offset,
+            tz=start_date.tz,
+        )
+
+        return dates
+
+    def _apply_rule(self, dates: DatetimeIndex) -> DatetimeIndex:
+        """
+        Apply the given offset/observance to a DatetimeIndex of dates.
+
+        Parameters
+        ----------
+        dates : DatetimeIndex
+            Dates to apply the given offset/observance rule
+
+        Returns
+        -------
+        Dates with rules applied
+        """
+        if dates.empty:
+            return dates.copy()
+
+        if self.observance is not None:
+            return dates.map(lambda d: self.observance(d))
+
+        if self.offset is not None:
+            if not isinstance(self.offset, list):
+                offsets = [self.offset]
+            else:
+                offsets = self.offset
+            for offset in offsets:
+                # if we are adding a non-vectorized value
+                # ignore the PerformanceWarnings:
+                with warnings.catch_warnings():
+                    warnings.simplefilter("ignore", PerformanceWarning)
+                    dates += offset
+        return dates
+
+
+holiday_calendars = {}
+
+
+def register(cls) -> None:
+    try:
+        name = cls.name
+    except AttributeError:
+        name = cls.__name__
+    holiday_calendars[name] = cls
+
+
+def get_calendar(name: str):
+    """
+    Return an instance of a calendar based on its name.
+
+    Parameters
+    ----------
+    name : str
+        Calendar name to return an instance of
+    """
+    return holiday_calendars[name]()
+
+
+class HolidayCalendarMetaClass(type):
+    def __new__(cls, clsname: str, bases, attrs):
+        calendar_class = super().__new__(cls, clsname, bases, attrs)
+        register(calendar_class)
+        return calendar_class
+
+
+class AbstractHolidayCalendar(metaclass=HolidayCalendarMetaClass):
+    """
+    Abstract interface to create holidays following certain rules.
+    """
+
+    rules: list[Holiday] = []
+    start_date = Timestamp(datetime(1970, 1, 1))
+    end_date = Timestamp(datetime(2200, 12, 31))
+    _cache = None
+
+    def __init__(self, name: str = "", rules=None) -> None:
+        """
+        Initializes holiday object with a given set a rules.  Normally
+        classes just have the rules defined within them.
+
+        Parameters
+        ----------
+        name : str
+            Name of the holiday calendar, defaults to class name
+        rules : array of Holiday objects
+            A set of rules used to create the holidays.
+        """
+        super().__init__()
+        if not name:
+            name = type(self).__name__
+        self.name = name
+
+        if rules is not None:
+            self.rules = rules
+
+    def rule_from_name(self, name: str):
+        for rule in self.rules:
+            if rule.name == name:
+                return rule
+
+        return None
+
+    def holidays(self, start=None, end=None, return_name: bool = False):
+        """
+        Returns a curve with holidays between start_date and end_date
+
+        Parameters
+        ----------
+        start : starting date, datetime-like, optional
+        end : ending date, datetime-like, optional
+        return_name : bool, optional
+            If True, return a series that has dates and holiday names.
+            False will only return a DatetimeIndex of dates.
+
+        Returns
+        -------
+            DatetimeIndex of holidays
+        """
+        if self.rules is None:
+            raise Exception(
+                f"Holiday Calendar {self.name} does not have any rules specified"
+            )
+
+        if start is None:
+            start = AbstractHolidayCalendar.start_date
+
+        if end is None:
+            end = AbstractHolidayCalendar.end_date
+
+        start = Timestamp(start)
+        end = Timestamp(end)
+
+        # If we don't have a cache or the dates are outside the prior cache, we
+        # get them again
+        if self._cache is None or start < self._cache[0] or end > self._cache[1]:
+            pre_holidays = [
+                rule.dates(start, end, return_name=True) for rule in self.rules
+            ]
+            if pre_holidays:
+                # error: Argument 1 to "concat" has incompatible type
+                # "List[Union[Series, DatetimeIndex]]"; expected
+                # "Union[Iterable[DataFrame], Mapping[<nothing>, DataFrame]]"
+                holidays = concat(pre_holidays)  # type: ignore[arg-type]
+            else:
+                # error: Incompatible types in assignment (expression has type
+                # "Series", variable has type "DataFrame")
+                holidays = Series(
+                    index=DatetimeIndex([]), dtype=object
+                )  # type: ignore[assignment]
+
+            self._cache = (start, end, holidays.sort_index())
+
+        holidays = self._cache[2]
+        holidays = holidays[start:end]
+
+        if return_name:
+            return holidays
+        else:
+            return holidays.index
+
+    @staticmethod
+    def merge_class(base, other):
+        """
+        Merge holiday calendars together. The base calendar
+        will take precedence to other. The merge will be done
+        based on each holiday's name.
+
+        Parameters
+        ----------
+        base : AbstractHolidayCalendar
+          instance/subclass or array of Holiday objects
+        other : AbstractHolidayCalendar
+          instance/subclass or array of Holiday objects
+        """
+        try:
+            other = other.rules
+        except AttributeError:
+            pass
+
+        if not isinstance(other, list):
+            other = [other]
+        other_holidays = {holiday.name: holiday for holiday in other}
+
+        try:
+            base = base.rules
+        except AttributeError:
+            pass
+
+        if not isinstance(base, list):
+            base = [base]
+        base_holidays = {holiday.name: holiday for holiday in base}
+
+        other_holidays.update(base_holidays)
+        return list(other_holidays.values())
+
+    def merge(self, other, inplace: bool = False):
+        """
+        Merge holiday calendars together.  The caller's class
+        rules take precedence.  The merge will be done
+        based on each holiday's name.
+
+        Parameters
+        ----------
+        other : holiday calendar
+        inplace : bool (default=False)
+            If True set rule_table to holidays, else return array of Holidays
+        """
+        holidays = self.merge_class(self, other)
+        if inplace:
+            self.rules = holidays
+        else:
+            return holidays
+
+
+USMemorialDay = Holiday(
+    "Memorial Day", month=5, day=31, offset=DateOffset(weekday=MO(-1))
+)
+USLaborDay = Holiday("Labor Day", month=9, day=1, offset=DateOffset(weekday=MO(1)))
+USColumbusDay = Holiday(
+    "Columbus Day", month=10, day=1, offset=DateOffset(weekday=MO(2))
+)
+USThanksgivingDay = Holiday(
+    "Thanksgiving Day", month=11, day=1, offset=DateOffset(weekday=TH(4))
+)
+USMartinLutherKingJr = Holiday(
+    "Birthday of Martin Luther King, Jr.",
+    start_date=datetime(1986, 1, 1),
+    month=1,
+    day=1,
+    offset=DateOffset(weekday=MO(3)),
+)
+USPresidentsDay = Holiday(
+    "Washington's Birthday", month=2, day=1, offset=DateOffset(weekday=MO(3))
+)
+GoodFriday = Holiday("Good Friday", month=1, day=1, offset=[Easter(), Day(-2)])
+
+EasterMonday = Holiday("Easter Monday", month=1, day=1, offset=[Easter(), Day(1)])
+
+
+class USFederalHolidayCalendar(AbstractHolidayCalendar):
+    """
+    US Federal Government Holiday Calendar based on rules specified by:
+    https://www.opm.gov/policy-data-oversight/pay-leave/federal-holidays/
+    """
+
+    rules = [
+        Holiday("New Year's Day", month=1, day=1, observance=nearest_workday),
+        USMartinLutherKingJr,
+        USPresidentsDay,
+        USMemorialDay,
+        Holiday(
+            "Juneteenth National Independence Day",
+            month=6,
+            day=19,
+            start_date="2021-06-18",
+            observance=nearest_workday,
+        ),
+        Holiday("Independence Day", month=7, day=4, observance=nearest_workday),
+        USLaborDay,
+        USColumbusDay,
+        Holiday("Veterans Day", month=11, day=11, observance=nearest_workday),
+        USThanksgivingDay,
+        Holiday("Christmas Day", month=12, day=25, observance=nearest_workday),
+    ]
+
+
+def HolidayCalendarFactory(name: str, base, other, base_class=AbstractHolidayCalendar):
+    rules = AbstractHolidayCalendar.merge_class(base, other)
+    calendar_class = type(name, (base_class,), {"rules": rules, "name": name})
+    return calendar_class
+
+
+__all__ = [
+    "after_nearest_workday",
+    "before_nearest_workday",
+    "FR",
+    "get_calendar",
+    "HolidayCalendarFactory",
+    "MO",
+    "nearest_workday",
+    "next_monday",
+    "next_monday_or_tuesday",
+    "next_workday",
+    "previous_friday",
+    "previous_workday",
+    "register",
+    "SA",
+    "SU",
+    "sunday_to_monday",
+    "TH",
+    "TU",
+    "WE",
+    "weekend_to_monday",
+]

videollama2/lib/python3.10/site-packages/pandas/tseries/offsets.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from pandas._libs.tslibs.offsets import (
+    FY5253,
+    BaseOffset,
+    BDay,
+    BMonthBegin,
+    BMonthEnd,
+    BQuarterBegin,
+    BQuarterEnd,
+    BusinessDay,
+    BusinessHour,
+    BusinessMonthBegin,
+    BusinessMonthEnd,
+    BYearBegin,
+    BYearEnd,
+    CBMonthBegin,
+    CBMonthEnd,
+    CDay,
+    CustomBusinessDay,
+    CustomBusinessHour,
+    CustomBusinessMonthBegin,
+    CustomBusinessMonthEnd,
+    DateOffset,
+    Day,
+    Easter,
+    FY5253Quarter,
+    Hour,
+    LastWeekOfMonth,
+    Micro,
+    Milli,
+    Minute,
+    MonthBegin,
+    MonthEnd,
+    Nano,
+    QuarterBegin,
+    QuarterEnd,
+    Second,
+    SemiMonthBegin,
+    SemiMonthEnd,
+    Tick,
+    Week,
+    WeekOfMonth,
+    YearBegin,
+    YearEnd,
+)
+
+__all__ = [
+    "Day",
+    "BaseOffset",
+    "BusinessDay",
+    "BusinessMonthBegin",
+    "BusinessMonthEnd",
+    "BDay",
+    "CustomBusinessDay",
+    "CustomBusinessMonthBegin",
+    "CustomBusinessMonthEnd",
+    "CDay",
+    "CBMonthEnd",
+    "CBMonthBegin",
+    "MonthBegin",
+    "BMonthBegin",
+    "MonthEnd",
+    "BMonthEnd",
+    "SemiMonthEnd",
+    "SemiMonthBegin",
+    "BusinessHour",
+    "CustomBusinessHour",
+    "YearBegin",
+    "BYearBegin",
+    "YearEnd",
+    "BYearEnd",
+    "QuarterBegin",
+    "BQuarterBegin",
+    "QuarterEnd",
+    "BQuarterEnd",
+    "LastWeekOfMonth",
+    "FY5253Quarter",
+    "FY5253",
+    "Week",
+    "WeekOfMonth",
+    "Easter",
+    "Tick",
+    "Hour",
+    "Minute",
+    "Second",
+    "Milli",
+    "Micro",
+    "Nano",
+    "DateOffset",
+]

vllm/lib/python3.10/site-packages/OpenGL/GL/MESA/__init__.py

@@ -0,0 +1 @@
+"""OpenGL Extensions"""

vllm/lib/python3.10/site-packages/OpenGL/GL/MESA/pack_invert.py

@@ -0,0 +1,37 @@
+'''OpenGL extension MESA.pack_invert
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.MESA.pack_invert to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension adds a new pixel storage parameter to indicate that
+	images are to be packed in top-to-bottom order instead of OpenGL's
+	conventional bottom-to-top order.  Only pixel packing can be
+	inverted (i.e. for glReadPixels, glGetTexImage, glGetConvolutionFilter,
+	etc).
+	
+	Almost all known image file formats store images in top-to-bottom
+	order.  As it is, OpenGL reads images from the frame buffer in
+	bottom-to-top order.  Thus, images usually have to be inverted before
+	writing them to a file with image I/O libraries.  This extension
+	allows images to be read such that inverting isn't needed.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/MESA/pack_invert.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.MESA.pack_invert import *
+from OpenGL.raw.GL.MESA.pack_invert import _EXTENSION_NAME
+
+def glInitPackInvertMESA():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/MESA/resize_buffers.py

@@ -0,0 +1,41 @@
+'''OpenGL extension MESA.resize_buffers
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.MESA.resize_buffers to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	Mesa is often used as a client library with no integration with
+	the computer's window system (an X server, for example).  And since
+	Mesa does not have an event loop nor window system callbacks, it
+	cannot properly respond to window system events.  In particular,
+	Mesa cannot automatically detect when a window has been resized.
+	
+	Mesa's glViewport command queries the current window size and updates
+	its internal data structors accordingly.  This normally works fine
+	since most applications call glViewport in responce to window size
+	changes.
+	
+	In some situations, however, the application may not call glViewport
+	when a window size changes but would still like Mesa to adjust to
+	the new window size.  This extension exports a new function to solve
+	this problem.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/MESA/resize_buffers.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.MESA.resize_buffers import *
+from OpenGL.raw.GL.MESA.resize_buffers import _EXTENSION_NAME
+
+def glInitResizeBuffersMESA():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/MESA/window_pos.py

@@ -0,0 +1,76 @@
+'''OpenGL extension MESA.window_pos
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.MESA.window_pos to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	In order to set the current raster position to a specific window
+	coordinate with the RasterPos command, the modelview matrix, projection
+	matrix and viewport must be set very carefully.  Furthermore, if the
+	desired window coordinate is outside of the window's bounds one must
+	rely on a subtle side-effect of the Bitmap command in order to circumvent
+	frustum clipping.
+	
+	This extension provides a set of functions to directly set the
+	current raster position, bypassing the modelview matrix, the
+	projection matrix and the viewport to window mapping.  Furthermore,
+	clip testing is not performed.
+	
+	This greatly simplifies the process of setting the current raster
+	position to a specific window coordinate prior to calling DrawPixels,
+	CopyPixels or Bitmap.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/MESA/window_pos.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.MESA.window_pos import *
+from OpenGL.raw.GL.MESA.window_pos import _EXTENSION_NAME
+
+def glInitWindowPosMESA():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+glWindowPos2dvMESA=wrapper.wrapper(glWindowPos2dvMESA).setInputArraySize(
+    'v', 2
+)
+glWindowPos2fvMESA=wrapper.wrapper(glWindowPos2fvMESA).setInputArraySize(
+    'v', 2
+)
+glWindowPos2ivMESA=wrapper.wrapper(glWindowPos2ivMESA).setInputArraySize(
+    'v', 2
+)
+glWindowPos2svMESA=wrapper.wrapper(glWindowPos2svMESA).setInputArraySize(
+    'v', 2
+)
+glWindowPos3dvMESA=wrapper.wrapper(glWindowPos3dvMESA).setInputArraySize(
+    'v', 3
+)
+glWindowPos3fvMESA=wrapper.wrapper(glWindowPos3fvMESA).setInputArraySize(
+    'v', 3
+)
+glWindowPos3ivMESA=wrapper.wrapper(glWindowPos3ivMESA).setInputArraySize(
+    'v', 3
+)
+glWindowPos3svMESA=wrapper.wrapper(glWindowPos3svMESA).setInputArraySize(
+    'v', 3
+)
+glWindowPos4dvMESA=wrapper.wrapper(glWindowPos4dvMESA).setInputArraySize(
+    'v', 4
+)
+glWindowPos4fvMESA=wrapper.wrapper(glWindowPos4fvMESA).setInputArraySize(
+    'v', 4
+)
+glWindowPos4ivMESA=wrapper.wrapper(glWindowPos4ivMESA).setInputArraySize(
+    'v', 4
+)
+glWindowPos4svMESA=wrapper.wrapper(glWindowPos4svMESA).setInputArraySize(
+    'v', 4
+)
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/MESA/ycbcr_texture.py

@@ -0,0 +1,39 @@
+'''OpenGL extension MESA.ycbcr_texture
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.MESA.ycbcr_texture to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension supports texture images stored in the YCbCr format.
+	There is no support for converting YCbCr images to RGB or vice versa
+	during pixel transfer.  The texture's YCbCr colors are converted to
+	RGB during texture sampling, after-which, all the usual per-fragment
+	operations take place.  Only 2D texture images are supported (not
+	glDrawPixels, glReadPixels, etc).
+	
+	A YCbCr pixel (texel) is a 16-bit unsigned short with two components.
+	The first component is luminance (Y).  For pixels in even-numbered
+	image columns, the second component is Cb.  For pixels in odd-numbered
+	image columns, the second component is Cr.  If one were to convert the
+	data to RGB one would need to examine two pixels from columns N and N+1
+	(where N is even) to deduce the RGB color.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/MESA/ycbcr_texture.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.MESA.ycbcr_texture import *
+from OpenGL.raw.GL.MESA.ycbcr_texture import _EXTENSION_NAME
+
+def glInitYcbcrTextureMESA():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/MESAX/texture_stack.py

@@ -0,0 +1,66 @@
+'''OpenGL extension MESAX.texture_stack
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.MESAX.texture_stack to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	There are a number of circumstances where an application may wish to
+	blend two textures out of a larger set of textures.  Moreover, in some
+	cases the selected textures may vary on a per-fragment basis within
+	a polygon.  Several examples include:
+	
+	   1. High dynamic range textures.  The application stores several
+	   different "exposures" of an image as different textures.  On a
+	   per-fragment basis, the application selects which exposures are
+	   used.
+	
+	   2. A terrain engine where the altitude of a point determines the
+	   texture applied to it.  If the transition is from beach sand to
+	   grass to rocks to snow, the application will store each texture
+	   in a different texture map, and dynamically select which two
+	   textures to blend at run-time.
+	
+	   3. Storing short video clips in textures.  Each depth slice is a
+	   single frame of video.
+	
+	Several solutions to this problem have been proposed, but they either
+	involve using a separate texture unit for each texture map or using 3D
+	textures without mipmaps.  Both of these options have major drawbacks.
+	
+	This extension provides a third alternative that eliminates the major
+	drawbacks of both previous methods.  A new texture target,
+	TEXTURE_2D_STACK, is added that functions identically to TEXTURE_3D in
+	all aspects except the sizes of the non-base level images.  In
+	traditional 3D texturing, the size of the N+1 LOD is half the size
+	of the N LOD in all three dimensions.  For the TEXTURE_2D_STACK target,
+	the height and width of the N+1 LOD is halved, but the depth is the
+	same for all levels of detail. The texture then becomes a "stack" of
+	2D textures.  The per-fragment texel is selected by the R texture
+	coordinate.
+	
+	References:
+	
+	    http://www.opengl.org/discussion_boards/cgi_directory/ultimatebb.cgi?ubb=get_topic;f=3;t=011557
+	    http://www.opengl.org/discussion_boards/cgi_directory/ultimatebb.cgi?ubb=get_topic;f=3;t=000516
+	    http://www.opengl.org/discussion_boards/cgi_directory/ultimatebb.cgi?ubb=get_topic;f=3;t=011903
+	    http://www.delphi3d.net/articles/viewarticle.php?article=terraintex.htm
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/MESAX/texture_stack.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.MESAX.texture_stack import *
+from OpenGL.raw.GL.MESAX.texture_stack import _EXTENSION_NAME
+
+def glInitTextureStackMESAX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/NV/__init__.py

@@ -0,0 +1 @@
+"""OpenGL Extensions"""

vllm/lib/python3.10/site-packages/OpenGL/GL/NV/depth_clamp.py

@@ -0,0 +1,54 @@
+'''OpenGL extension NV.depth_clamp
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.NV.depth_clamp to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	Conventional OpenGL clips geometric primitives to a clip volume
+	with six faces, two of which are the near and far clip planes.
+	Clipping to the near and far planes of the clip volume ensures that
+	interpolated depth values (after the depth range transform) must be
+	in the [0,1] range.
+	
+	In some rendering applications such as shadow volumes, it is useful
+	to allow line and polygon primitives to be rasterized without
+	clipping the primitive to the near or far clip volume planes (side
+	clip volume planes clip normally).  Without the near and far clip
+	planes, rasterization (pixel coverage determination) in X and Y
+	can proceed normally if we ignore the near and far clip planes.
+	The one major issue is that fragments of a  primitive may extend
+	beyond the conventional window space depth range for depth values
+	(typically the range [0,1]).  Rather than discarding fragments that
+	defy the window space depth range (effectively what near and far
+	plane clipping accomplish), the depth values can be clamped to the
+	current depth range.
+	
+	This extension provides exactly such functionality.  This
+	functionality is useful to obviate the need for near plane capping
+	of stenciled shadow volumes.  The functionality may also be useful
+	for rendering geometry "beyond" the far plane if an alternative
+	algorithm (rather than depth testing) for hidden surface removal is
+	applied to such geometry (specifically, the painter's algorithm).
+	Similar situations at the near clip plane can be avoided at the
+	near clip plane where apparently solid objects can be "seen through"
+	if they intersect the near clip plane.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/NV/depth_clamp.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.NV.depth_clamp import *
+from OpenGL.raw.GL.NV.depth_clamp import _EXTENSION_NAME
+
+def glInitDepthClampNV():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/NV/framebuffer_multisample_coverage.py

@@ -0,0 +1,45 @@
+'''OpenGL extension NV.framebuffer_multisample_coverage
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.NV.framebuffer_multisample_coverage to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension extends the EXT_framebuffer_multisample 
+	specification by providing a new function,
+	RenderBufferStorageMultisampleCoverageNV, that distinguishes 
+	between color samples and coverage samples.
+	
+	EXT_framebuffer_multisample introduced the function 
+	RenderbufferStorageMultisampleEXT as a method of defining the 
+	storage parameters for a multisample render buffer.  This function 
+	takes a <samples> parameter.  Using rules provided by the 
+	specification, the <samples> parameter is resolved to an actual 
+	number of samples that is supported by the underlying hardware.  
+	EXT_framebuffer_multisample does not specify whether <samples>
+	refers to coverage samples or color samples.
+	
+	This extension adds the function 
+	RenderbufferStorageMultisamplCoverageNV, which takes a 
+	<coverageSamples> parameter as well as a <colorSamples> parameter.  
+	These two parameters give developers more fine grained control over
+	the quality of multisampled images.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/NV/framebuffer_multisample_coverage.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.NV.framebuffer_multisample_coverage import *
+from OpenGL.raw.GL.NV.framebuffer_multisample_coverage import _EXTENSION_NAME
+
+def glInitFramebufferMultisampleCoverageNV():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/NV/gpu_program4.py

@@ -0,0 +1,100 @@
+'''OpenGL extension NV.gpu_program4
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.NV.gpu_program4 to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This specification documents the common instruction set and basic
+	functionality provided by NVIDIA's 4th generation of assembly instruction
+	sets supporting programmable graphics pipeline stages.  
+	
+	The instruction set builds upon the basic framework provided by the
+	ARB_vertex_program and ARB_fragment_program extensions to expose
+	considerably more capable hardware.  In addition to new capabilities for
+	vertex and fragment programs, this extension provides a new program type
+	(geometry programs) further described in the NV_geometry_program4
+	specification.
+	
+	NV_gpu_program4 provides a unified instruction set -- all instruction set
+	features are available for all program types, except for a small number of
+	features that make sense only for a specific program type.  It provides
+	fully capable signed and unsigned integer data types, along with a set of
+	arithmetic, logical, and data type conversion instructions capable of
+	operating on integers.  It also provides a uniform set of structured
+	branching constructs (if tests, loops, and subroutines) that fully support
+	run-time condition testing.
+	
+	This extension provides several new texture mapping capabilities.  Shadow
+	cube maps are supported, where cube map faces can encode depth values.
+	Texture lookup instructions can include an immediate texel offset, which
+	can assist in advanced filtering.  New instructions are provided to fetch
+	a single texel by address in a texture map (TXF) and query the size of a
+	specified texture level (TXQ).
+	
+	By and large, vertex and fragment programs written to ARB_vertex_program
+	and ARB_fragment_program can be ported directly by simply changing the
+	program header from "!!ARBvp1.0" or "!!ARBfp1.0" to "!!NVvp4.0" or
+	"!!NVfp4.0", and then modifying the code to take advantage of the expanded
+	feature set.  There are a small number of areas where this extension is
+	not a functional superset of previous vertex program extensions, which are
+	documented in this specification.
+	
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/NV/gpu_program4.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.NV.gpu_program4 import *
+from OpenGL.raw.GL.NV.gpu_program4 import _EXTENSION_NAME
+
+def glInitGpuProgram4NV():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+glProgramLocalParameterI4ivNV=wrapper.wrapper(glProgramLocalParameterI4ivNV).setInputArraySize(
+    'params', 4
+)
+# INPUT glProgramLocalParametersI4ivNV.params size not checked against None
+glProgramLocalParametersI4ivNV=wrapper.wrapper(glProgramLocalParametersI4ivNV).setInputArraySize(
+    'params', None
+)
+glProgramLocalParameterI4uivNV=wrapper.wrapper(glProgramLocalParameterI4uivNV).setInputArraySize(
+    'params', 4
+)
+# INPUT glProgramLocalParametersI4uivNV.params size not checked against None
+glProgramLocalParametersI4uivNV=wrapper.wrapper(glProgramLocalParametersI4uivNV).setInputArraySize(
+    'params', None
+)
+glProgramEnvParameterI4ivNV=wrapper.wrapper(glProgramEnvParameterI4ivNV).setInputArraySize(
+    'params', 4
+)
+# INPUT glProgramEnvParametersI4ivNV.params size not checked against None
+glProgramEnvParametersI4ivNV=wrapper.wrapper(glProgramEnvParametersI4ivNV).setInputArraySize(
+    'params', None
+)
+glProgramEnvParameterI4uivNV=wrapper.wrapper(glProgramEnvParameterI4uivNV).setInputArraySize(
+    'params', 4
+)
+# INPUT glProgramEnvParametersI4uivNV.params size not checked against None
+glProgramEnvParametersI4uivNV=wrapper.wrapper(glProgramEnvParametersI4uivNV).setInputArraySize(
+    'params', None
+)
+glGetProgramLocalParameterIivNV=wrapper.wrapper(glGetProgramLocalParameterIivNV).setOutput(
+    'params',size=(4,),orPassIn=True
+)
+glGetProgramLocalParameterIuivNV=wrapper.wrapper(glGetProgramLocalParameterIuivNV).setOutput(
+    'params',size=(4,),orPassIn=True
+)
+glGetProgramEnvParameterIivNV=wrapper.wrapper(glGetProgramEnvParameterIivNV).setOutput(
+    'params',size=(4,),orPassIn=True
+)
+glGetProgramEnvParameterIuivNV=wrapper.wrapper(glGetProgramEnvParameterIuivNV).setOutput(
+    'params',size=(4,),orPassIn=True
+)
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/NV/gpu_program5_mem_extended.py

@@ -0,0 +1,62 @@
+'''OpenGL extension NV.gpu_program5_mem_extended
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.NV.gpu_program5_mem_extended to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension provides a new set of storage modifiers that can be used by
+	NV_gpu_program5 assembly program instructions loading from or storing to
+	various forms of GPU memory.  In particular, we provide support for loads
+	and stores using the storage modifiers:
+	
+	    .F16X2  .F16X4  .F16    (for 16-bit floating-point scalars/vectors)
+	    .S8X2   .S8X4           (for 8-bit signed integer vectors)
+	    .S16X2  .S16X4          (for 16-bit signed integer vectors)
+	    .U8X2   .U8X4           (for 8-bit unsigned integer vectors)
+	    .U16X2  .U16X4          (for 16-bit unsigned integer vectors)
+	
+	These modifiers are allowed for the following load/store instructions:
+	
+	    LDC             Load from constant buffer
+	
+	    LOAD            Global load
+	    STORE           Global store
+	
+	    LOADIM          Image load (via EXT_shader_image_load_store)
+	    STOREIM         Image store (via EXT_shader_image_load_store)
+	
+	    LDB             Load from storage buffer (via 
+	                      NV_shader_storage_buffer_object) 
+	    STB             Store to storage buffer (via 
+	                      NV_shader_storage_buffer_object) 
+	
+	    LDS             Load from shared memory (via NV_compute_program5)
+	    STS             Store to shared memory (via NV_compute_program5)
+	
+	For assembly programs prior to this extension, it was necessary to access
+	memory using packed types and then unpack with additional shader
+	instructions.
+	
+	Similar capabilities have already been provided in the OpenGL Shading
+	Language (GLSL) via the NV_gpu_shader5 extension, using the extended data
+	types provided there (e.g., "float16_t", "u8vec4", "s16vec2").
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/NV/gpu_program5_mem_extended.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.NV.gpu_program5_mem_extended import *
+from OpenGL.raw.GL.NV.gpu_program5_mem_extended import _EXTENSION_NAME
+
+def glInitGpuProgram5MemExtendedNV():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/NV/occlusion_query.py

@@ -0,0 +1,91 @@
+'''OpenGL extension NV.occlusion_query
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.NV.occlusion_query to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	The HP_occlusion_test extension defines a mechanism whereby an
+	application can query the visibility of an object, where "visible"
+	means that at least one pixel passes the depth and stencil tests.
+	
+	The HP extension has two major shortcomings.
+	
+	- It returns the result as a simple GL_TRUE/GL_FALSE result, when in
+	  fact it is often useful to know exactly how many pixels passed.
+	- It provides only a simple "stop-and-wait" model for using multiple
+	  queries.  The application begins an occlusion test and ends it;
+	  then, at some later point, it asks for the result, at which point
+	  the driver must stop and wait until the result from the previous
+	  test is back before the application can even begin the next one.
+	  This is a very simple model, but its performance is mediocre when
+	  an application wishes to perform many queries, and it eliminates
+	  most of the opportunites for parallelism between the CPU and GPU.
+	
+	This extension solves both of those problems.  It returns as its
+	result the number of pixels that pass, and it provides an interface
+	conceptually similar to that of NV_fence that allows applications to
+	issue many occlusion queries before asking for the result of any one.
+	As a result, they can overlap the time it takes for the occlusion
+	query results to be returned with other, more useful work, such as
+	rendering other parts of the scene or performing other computations
+	on the CPU.
+	
+	There are many situations where a pixel count, rather than a boolean
+	result, is useful.
+	
+	- If the visibility test is an object bounding box being used to
+	  decide whether to skip the object, sometimes it can be acceptable,
+	  and beneficial to performance, to skip an object if less than some
+	  threshold number of pixels could be visible.
+	- Knowing the number of pixels visible in the bounding box may also
+	  help decide what level of detail a model should be drawn with.  If
+	  only a few pixels are visible, a low-detail model may be
+	  acceptable.  In general, this allows level-of-detail mechanisms to
+	  be slightly less ad hoc.
+	- "Depth peeling" techniques, such as order-independent transparency,
+	  would typically like to know when to stop rendering more layers; it
+	  is difficult to come up with a way to determine a priori how many
+	  layers to use.  A boolean count allows applications to stop when
+	  more layers will not affect the image at all, but this will likely
+	  be unacceptable for performance, with minimal gains to image
+	  quality.  Instead, it makes more sense to stop rendering when the
+	  number of pixels goes below a threshold; this should provide better
+	  results than any of these other algorithms.
+	- Occlusion queries can be used as a replacement for glReadPixels of
+	  the depth buffer to determine whether, say, a light source is
+	  visible for the purposes of a lens flare effect or a halo to
+	  simulate glare.  Pixel counts allow you to compute the percentage
+	  of the light source that is visible, and the brightness of these
+	  effects can be modulated accordingly.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/NV/occlusion_query.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.NV.occlusion_query import *
+from OpenGL.raw.GL.NV.occlusion_query import _EXTENSION_NAME
+
+def glInitOcclusionQueryNV():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+glGenOcclusionQueriesNV=wrapper.wrapper(glGenOcclusionQueriesNV).setOutput(
+    'ids',size=lambda x:(x,),pnameArg='n',orPassIn=True
+)
+# INPUT glDeleteOcclusionQueriesNV.ids size not checked against n
+glDeleteOcclusionQueriesNV=wrapper.wrapper(glDeleteOcclusionQueriesNV).setInputArraySize(
+    'ids', None
+)
+glGetOcclusionQueryivNV=wrapper.wrapper(glGetOcclusionQueryivNV).setOutput(
+    'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True
+)
+glGetOcclusionQueryuivNV=wrapper.wrapper(glGetOcclusionQueryuivNV).setOutput(
+    'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True
+)
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/NV/shader_thread_shuffle.py

@@ -0,0 +1,23 @@
+'''OpenGL extension NV.shader_thread_shuffle
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.NV.shader_thread_shuffle to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/NV/shader_thread_shuffle.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.NV.shader_thread_shuffle import *
+from OpenGL.raw.GL.NV.shader_thread_shuffle import _EXTENSION_NAME
+
+def glInitShaderThreadShuffleNV():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/NV/texture_multisample.py

@@ -0,0 +1,40 @@
+'''OpenGL extension NV.texture_multisample
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.NV.texture_multisample to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This specification extends NV_gpu_program4 to support per-sample fetching
+	from multisample textures described in ARB_texture_multisample.
+	Specifically, it adds:
+	
+	  * The TXFMS sample fetch instruction.
+	
+	  * Texture targets corresponding to the multisample textures added by
+	    ARB_texture_multisample.
+	
+	  * A program option to enable these features.
+	
+	This specification also extends the ARB_texture_multisample extension
+	by adding support for EXT_direct_state_access and VCAA multisample
+	coverage with seperate <colorSamples> and <coverageSamples> parameters.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/NV/texture_multisample.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.NV.texture_multisample import *
+from OpenGL.raw.GL.NV.texture_multisample import _EXTENSION_NAME
+
+def glInitTextureMultisampleNV():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/NV/texture_shader.py

@@ -0,0 +1,198 @@
+'''OpenGL extension NV.texture_shader
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.NV.texture_shader to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	Standard OpenGL and the ARB_multitexture extension define a
+	straightforward direct mechanism for mapping sets of texture
+	coordinates to filtered colors.  This extension provides a more
+	functional mechanism.
+	
+	OpenGL's standard texturing mechanism defines a set of texture
+	targets.  Each texture target defines how the texture image
+	is specified and accessed via a set of texture coordinates.
+	OpenGL 1.0 defines the 1D and 2D texture targets.  OpenGL 1.2
+	(and/or the EXT_texture3D extension) defines the 3D texture target.
+	The ARB_texture_cube_map extension defines the cube map texture
+	target.  Each texture unit's texture coordinate set is mapped to a
+	color using the unit's highest priority enabled texture target.
+	
+	This extension introduces texture shader stages.  A sequence of
+	texture shader stages provides a more flexible mechanism for mapping
+	sets of texture coordinates to texture unit RGBA results than standard
+	OpenGL.
+	
+	When the texture shader enable is on, the extension replaces the
+	conventional OpenGL mechanism for mapping sets of texture coordinates
+	to filtered colors with this extension's sequence of texture shader
+	stages.  
+	
+	Each texture shader stage runs one of 21 canned texture shader
+	programs.  These programs support conventional OpenGL texture
+	mapping but also support dependent texture accesses, dot product
+	texture programs, and special modes.  (3D texture mapping
+	texture shader operations are NOT provided by this extension;
+	3D texture mapping texture shader operations are added by the
+	NV_texture_shader2 extension that is layered on this extension.
+	See the NV_texture_shader2 specification.)
+	
+	To facilitate the new texture shader programs, this extension
+	introduces several new texture formats and variations on existing
+	formats.  Existing color texture formats are extended by introducing
+	new signed variants.  Two new types of texture formats (beyond colors)
+	are also introduced.  Texture offset groups encode two signed offsets,
+	and optionally a magnitude or a magnitude and an intensity.  The new
+	HILO (pronounced high-low) formats provide possibly signed, high
+	precision (16-bit) two-component textures.
+	
+	Each program takes as input the stage's interpolated texture
+	coordinate set (s,t,r,q).  Each program generates two results:
+	a shader stage result that may be used as an input to subsequent
+	shader stage programs, and a texture unit RGBA result that becomes the
+	texture color used by the texture unit's texture environment function
+	or becomes the initial value for the corresponding texture register
+	for register combiners. The texture unit RGBA result is always
+	an RGBA color, but the shader stage result may be one of an RGBA
+	color, a HILO value, a texture offset group, a floating-point value,
+	or an invalid result.  When both results are RGBA colors, the shader
+	stage result and the texture unit RGBA result are usually identical
+	(though not in all cases).
+	
+	Additionally, certain programs have a side-effect such as culling
+	the fragment or replacing the fragment's depth value.
+	
+	The twenty-one programs are briefly described:
+	
+	<none>
+	
+	1.   NONE - Always generates a (0,0,0,0) texture unit RGBA result.
+	     Equivalent to disabling all texture targets in conventional
+	     OpenGL.
+	
+	<conventional textures>
+	
+	2.   TEXTURE_1D - Accesses a 1D texture via (s/q).
+	
+	3.   TEXTURE_2D - Accesses a 2D texture via (s/q,t/q).
+	
+	4.   TEXTURE_RECTANGLE_NV - Accesses a rectangular texture via (s/q,t/q).
+	
+	5.   TEXTURE_CUBE_MAP_ARB - Accesses a cube map texture via (s,t,r).
+	
+	<special modes>
+	
+	6.   PASS_THROUGH_NV - Converts a texture coordinate (s,t,r,q)
+	     directly to a [0,1] clamped (r,g,b,a) texture unit RGBA result.
+	
+	7.   CULL_FRAGMENT_NV - Culls the fragment based on the whether each
+	     (s,t,r,q) is "greater than or equal to zero" or "less than zero".
+	
+	<offset textures>
+	
+	8.   OFFSET_TEXTURE_2D_NV - Transforms the signed (ds,dt) components
+	     of a previous texture unit by a 2x2 floating-point matrix and
+	     then uses the result to offset the stage's texture coordinates
+	     for a 2D non-projective texture.
+	
+	9.   OFFSET_TEXTURE_2D_SCALE_NV - Same as above except the magnitude
+	     component of the previous texture unit result scales the red,
+	     green, and blue components of the unsigned RGBA texture 2D
+	     access.
+	
+	10.  OFFSET_TEXTURE_RECTANGLE_NV - Similar to OFFSET_TEXTURE_2D_NV
+	     except that the texture access is into a rectangular
+	     non-projective texture.
+	
+	11.  OFFSET_TEXTURE_RECTANGLE_SCALE_NV - Similar to
+	     OFFSET_TEXTURE_2D_SCALE_NV except that the texture access is
+	     into a rectangular non-projective texture.
+	
+	<dependent textures>
+	
+	12.  DEPENDENT_AR_TEXTURE_2D_NV - Converts the alpha and red
+	     components of a previous shader result into an (s,t) texture
+	     coordinate set to access a 2D non-projective texture.
+	
+	13.  DEPENDENT_GB_TEXTURE_2D_NV - Converts the green and blue
+	     components of a previous shader result into an (s,t) texture
+	     coordinate set to access a 2D non-projective texture.
+	
+	<dot product textures>
+	
+	14.  DOT_PRODUCT_NV - Computes the dot product of the texture
+	     shader's texture coordinate set (s,t,r) with some mapping of the
+	     components of a previous texture shader result.  The component
+	     mapping depends on the type (RGBA or HILO) and signedness of
+	     the stage's previous texture input.  Other dot product texture
+	     programs use the result of this program to compose a texture
+	     coordinate set for a dependent texture access.  The color result
+	     is undefined.
+	
+	15.  DOT_PRODUCT_TEXTURE_2D_NV - When preceded by a DOT_PRODUCT_NV
+	     program in the previous texture shader stage, computes a second
+	     similar dot product and composes the two dot products into (s,t)
+	     texture coordinate set to access a 2D non-projective texture.
+	
+	16.  DOT_PRODUCT_TEXTURE_RECTANGLE_NV - Similar to
+	     DOT_PRODUCT_TEXTURE_2D_NV except that the texture acces is into
+	     a rectangular non-projective texture.  
+	
+	17.  DOT_PRODUCT_TEXTURE_CUBE_MAP_NV - When preceded by two
+	     DOT_PRODUCT_NV programs in the previous two texture shader
+	     stages, computes a third similar dot product and composes the
+	     three dot products into (s,t,r) texture coordinate set to access
+	     a cube map texture.
+	
+	18.  DOT_PRODUCT_REFLECT_CUBE_MAP_NV - When preceded by two
+	     DOT_PRODUCT_NV programs in the previous two texture shader
+	     stages, computes a third similar dot product and composes the
+	     three dot products into a normal vector (Nx,Ny,Nz).  An eye
+	     vector (Ex,Ey,Ez) is composed from the q texture coordinates of
+	     the three stages.  A reflection vector (Rx,Ry,Rz) is computed
+	     based on the normal and eye vectors.  The reflection vector
+	     forms an (s,t,r) texture coordinate set to access a cube map
+	     texture.
+	
+	19.  DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV - Operates like
+	     DOT_PRODUCT_REFLECT_CUBE_MAP_NV except that the eye vector
+	     (Ex,Ey,Ez) is a user-defined constant rather than composed from
+	     the q coordinates of the three stages.
+	
+	20.  DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV - When used instead of the second
+	     DOT_PRODUCT_NV program preceding
+	     a DOT_PRODUCT_REFLECT_CUBE_MAP_NV or
+	     DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV stage, the normal
+	     vector forms an (s,t,r) texture  coordinate set to access a
+	     cube map texture.
+	
+	<dot product depth replace>
+	
+	21.  DOT_PRODUCT_DEPTH_REPLACE_NV - When preceded by a DOT_PRODUCT_NV
+	     program in the previous texture shader stage, computes a second
+	     similar dot product and replaces the fragment's window-space
+	     depth value with the first dot product results divided by
+	     the second.  The texture unit RGBA result is (0,0,0,0).
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/NV/texture_shader.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.NV.texture_shader import *
+from OpenGL.raw.GL.NV.texture_shader import _EXTENSION_NAME
+
+def glInitTextureShaderNV():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION
+GL_OFFSET_TEXTURE_2D_BIAS_NV = GL_OFFSET_TEXTURE_BIAS_NV # alias
+GL_OFFSET_TEXTURE_2D_MATRIX_NV = GL_OFFSET_TEXTURE_MATRIX_NV # alias
+GL_OFFSET_TEXTURE_2D_SCALE_NV = GL_OFFSET_TEXTURE_SCALE_NV # alias

vllm/lib/python3.10/site-packages/OpenGL/GL/NV/vdpau_interop.py

@@ -0,0 +1,59 @@
+'''OpenGL extension NV.vdpau_interop
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.NV.vdpau_interop to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension allows VDPAU video and output surfaces to be used
+	for texturing and rendering.
+	
+	This allows the GL to process and display the content of video
+	streams decoded using VDPAU.
+	
+	Alternatively, the GL may modify VDPAU surfaces in-place, and VDPAU
+	may then process and/or display those surfaces itself.
+	
+	This allows the GL to be used to combine application user-interface
+	elements with decoded video, implement custom video-processing
+	algorithms, etc.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/NV/vdpau_interop.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.NV.vdpau_interop import *
+from OpenGL.raw.GL.NV.vdpau_interop import _EXTENSION_NAME
+
+def glInitVdpauInteropNV():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+# glVDPAURegisterVideoSurfaceNV.vdpSurface is OUTPUT without known output size
+# INPUT glVDPAURegisterVideoSurfaceNV.textureNames size not checked against numTextureNames
+glVDPAURegisterVideoSurfaceNV=wrapper.wrapper(glVDPAURegisterVideoSurfaceNV).setInputArraySize(
+    'textureNames', None
+)
+# glVDPAURegisterOutputSurfaceNV.vdpSurface is OUTPUT without known output size
+# INPUT glVDPAURegisterOutputSurfaceNV.textureNames size not checked against numTextureNames
+glVDPAURegisterOutputSurfaceNV=wrapper.wrapper(glVDPAURegisterOutputSurfaceNV).setInputArraySize(
+    'textureNames', None
+)
+# glVDPAUGetSurfaceivNV.length is OUTPUT without known output size
+glVDPAUGetSurfaceivNV=wrapper.wrapper(glVDPAUGetSurfaceivNV).setOutput(
+    'values',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True
+)
+# INPUT glVDPAUMapSurfacesNV.surfaces size not checked against numSurfaces
+glVDPAUMapSurfacesNV=wrapper.wrapper(glVDPAUMapSurfacesNV).setInputArraySize(
+    'surfaces', None
+)
+# INPUT glVDPAUUnmapSurfacesNV.surfaces size not checked against numSurface
+glVDPAUUnmapSurfacesNV=wrapper.wrapper(glVDPAUUnmapSurfacesNV).setInputArraySize(
+    'surfaces', None
+)
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/NV/vertex_program1_1.py

@@ -0,0 +1,48 @@
+'''OpenGL extension NV.vertex_program1_1
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.NV.vertex_program1_1 to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension adds four new vertex program instructions (DPH,
+	RCC, SUB, and ABS).
+	
+	This extension also supports a position-invariant vertex program
+	option.  A vertex program is position-invariant when it generates
+	the _exact_ same homogenuous position and window space position
+	for a vertex as conventional OpenGL transformation (ignoring vertex
+	blending and weighting).
+	
+	By default, vertex programs are _not_ guaranteed to be
+	position-invariant because there is no guarantee made that the way
+	a vertex program might compute its homogenous position is exactly
+	identical to the way conventional OpenGL transformation computes
+	its homogenous positions.  In a position-invariant vertex program,
+	the homogeneous position (HPOS) is not output by the program.
+	Instead, the OpenGL implementation is expected to compute the HPOS
+	for position-invariant vertex programs in a manner exactly identical
+	to how the homogenous position and window position are computed
+	for a vertex by conventional OpenGL transformation.  In this way
+	position-invariant vertex programs guarantee correct multi-pass
+	rendering semantics in cases where multiple passes are rendered and
+	the second and subsequent passes use a GL_EQUAL depth test.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/NV/vertex_program1_1.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.NV.vertex_program1_1 import *
+from OpenGL.raw.GL.NV.vertex_program1_1 import _EXTENSION_NAME
+
+def glInitVertexProgram11NV():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/NV/vertex_program4.py

@@ -0,0 +1,95 @@
+'''OpenGL extension NV.vertex_program4
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.NV.vertex_program4 to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension builds on the common assembly instruction set
+	infrastructure provided by NV_gpu_program4, adding vertex program-specific
+	features.
+	
+	This extension provides the ability to specify integer vertex attributes
+	that are passed to vertex programs using integer data types, rather than
+	being converted to floating-point values as in existing vertex attribute
+	functions.  The set of input and output bindings provided includes all
+	bindings supported by ARB_vertex_program.  This extension provides
+	additional input bindings identifying the index of the vertex when vertex
+	arrays are used ("vertex.id") and the instance number when instanced
+	arrays are used ("vertex.instance", requires EXT_draw_instanced).  It
+	also provides output bindings allowing vertex programs to directly specify
+	clip distances (for user clipping) plus a set of generic attributes that
+	allow programs to pass a greater number of attributes to subsequent
+	pipeline stages than is possible using only the pre-defined fixed-function
+	vertex outputs.
+	
+	By and large, programs written to ARB_vertex_program can be ported
+	directly by simply changing the program header from "!!ARBvp1.0" to
+	"!!NVvp4.0", and then modifying instructions to take advantage of the
+	expanded feature set.  There are a small number of areas where this
+	extension is not a functional superset of previous vertex program
+	extensions, which are documented in the NV_gpu_program4 specification.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/NV/vertex_program4.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.NV.vertex_program4 import *
+from OpenGL.raw.GL.NV.vertex_program4 import _EXTENSION_NAME
+
+def glInitVertexProgram4NV():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+glVertexAttribI1ivEXT=wrapper.wrapper(glVertexAttribI1ivEXT).setInputArraySize(
+    'v', 1
+)
+glVertexAttribI2ivEXT=wrapper.wrapper(glVertexAttribI2ivEXT).setInputArraySize(
+    'v', 2
+)
+glVertexAttribI3ivEXT=wrapper.wrapper(glVertexAttribI3ivEXT).setInputArraySize(
+    'v', 3
+)
+glVertexAttribI4ivEXT=wrapper.wrapper(glVertexAttribI4ivEXT).setInputArraySize(
+    'v', 4
+)
+glVertexAttribI1uivEXT=wrapper.wrapper(glVertexAttribI1uivEXT).setInputArraySize(
+    'v', 1
+)
+glVertexAttribI2uivEXT=wrapper.wrapper(glVertexAttribI2uivEXT).setInputArraySize(
+    'v', 2
+)
+glVertexAttribI3uivEXT=wrapper.wrapper(glVertexAttribI3uivEXT).setInputArraySize(
+    'v', 3
+)
+glVertexAttribI4uivEXT=wrapper.wrapper(glVertexAttribI4uivEXT).setInputArraySize(
+    'v', 4
+)
+glVertexAttribI4bvEXT=wrapper.wrapper(glVertexAttribI4bvEXT).setInputArraySize(
+    'v', 4
+)
+glVertexAttribI4svEXT=wrapper.wrapper(glVertexAttribI4svEXT).setInputArraySize(
+    'v', 4
+)
+glVertexAttribI4ubvEXT=wrapper.wrapper(glVertexAttribI4ubvEXT).setInputArraySize(
+    'v', 4
+)
+glVertexAttribI4usvEXT=wrapper.wrapper(glVertexAttribI4usvEXT).setInputArraySize(
+    'v', 4
+)
+# INPUT glVertexAttribIPointerEXT.pointer size not checked against 'size,type,stride'
+glVertexAttribIPointerEXT=wrapper.wrapper(glVertexAttribIPointerEXT).setInputArraySize(
+    'pointer', None
+)
+glGetVertexAttribIivEXT=wrapper.wrapper(glGetVertexAttribIivEXT).setOutput(
+    'params',size=(1,),orPassIn=True
+)
+glGetVertexAttribIuivEXT=wrapper.wrapper(glGetVertexAttribIuivEXT).setOutput(
+    'params',size=(1,),orPassIn=True
+)
+### END AUTOGENERATED SECTION