Add files using upload-large-folder tool

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/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
+        )

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas/core/flags.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+import weakref
+
+if TYPE_CHECKING:
+    from pandas.core.generic import NDFrame
+
+
+class Flags:
+    """
+    Flags that apply to pandas objects.
+
+    Parameters
+    ----------
+    obj : Series or DataFrame
+        The object these flags are associated with.
+    allows_duplicate_labels : bool, default True
+        Whether to allow duplicate labels in this object. By default,
+        duplicate labels are permitted. Setting this to ``False`` will
+        cause an :class:`errors.DuplicateLabelError` to be raised when
+        `index` (or columns for DataFrame) is not unique, or any
+        subsequent operation on introduces duplicates.
+        See :ref:`duplicates.disallow` for more.
+
+        .. warning::
+
+           This is an experimental feature. Currently, many methods fail to
+           propagate the ``allows_duplicate_labels`` value. In future versions
+           it is expected that every method taking or returning one or more
+           DataFrame or Series objects will propagate ``allows_duplicate_labels``.
+
+    Examples
+    --------
+    Attributes can be set in two ways:
+
+    >>> df = pd.DataFrame()
+    >>> df.flags
+    <Flags(allows_duplicate_labels=True)>
+    >>> df.flags.allows_duplicate_labels = False
+    >>> df.flags
+    <Flags(allows_duplicate_labels=False)>
+
+    >>> df.flags['allows_duplicate_labels'] = True
+    >>> df.flags
+    <Flags(allows_duplicate_labels=True)>
+    """
+
+    _keys: set[str] = {"allows_duplicate_labels"}
+
+    def __init__(self, obj: NDFrame, *, allows_duplicate_labels: bool) -> None:
+        self._allows_duplicate_labels = allows_duplicate_labels
+        self._obj = weakref.ref(obj)
+
+    @property
+    def allows_duplicate_labels(self) -> bool:
+        """
+        Whether this object allows duplicate labels.
+
+        Setting ``allows_duplicate_labels=False`` ensures that the
+        index (and columns of a DataFrame) are unique. Most methods
+        that accept and return a Series or DataFrame will propagate
+        the value of ``allows_duplicate_labels``.
+
+        See :ref:`duplicates` for more.
+
+        See Also
+        --------
+        DataFrame.attrs : Set global metadata on this object.
+        DataFrame.set_flags : Set global flags on this object.
+
+        Examples
+        --------
+        >>> df = pd.DataFrame({"A": [1, 2]}, index=['a', 'a'])
+        >>> df.flags.allows_duplicate_labels
+        True
+        >>> df.flags.allows_duplicate_labels = False
+        Traceback (most recent call last):
+            ...
+        pandas.errors.DuplicateLabelError: Index has duplicates.
+              positions
+        label
+        a        [0, 1]
+        """
+        return self._allows_duplicate_labels
+
+    @allows_duplicate_labels.setter
+    def allows_duplicate_labels(self, value: bool) -> None:
+        value = bool(value)
+        obj = self._obj()
+        if obj is None:
+            raise ValueError("This flag's object has been deleted.")
+
+        if not value:
+            for ax in obj.axes:
+                ax._maybe_check_unique()
+
+        self._allows_duplicate_labels = value
+
+    def __getitem__(self, key: str):
+        if key not in self._keys:
+            raise KeyError(key)
+
+        return getattr(self, key)
+
+    def __setitem__(self, key: str, value) -> None:
+        if key not in self._keys:
+            raise ValueError(f"Unknown flag {key}. Must be one of {self._keys}")
+        setattr(self, key, value)
+
+    def __repr__(self) -> str:
+        return f"<Flags(allows_duplicate_labels={self.allows_duplicate_labels})>"
+
+    def __eq__(self, other) -> bool:
+        if isinstance(other, type(self)):
+            return self.allows_duplicate_labels == other.allows_duplicate_labels
+        return False

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas/core/roperator.py

@@ -0,0 +1,62 @@
+"""
+Reversed Operations not available in the stdlib operator module.
+Defining these instead of using lambdas allows us to reference them by name.
+"""
+from __future__ import annotations
+
+import operator
+
+
+def radd(left, right):
+    return right + left
+
+
+def rsub(left, right):
+    return right - left
+
+
+def rmul(left, right):
+    return right * left
+
+
+def rdiv(left, right):
+    return right / left
+
+
+def rtruediv(left, right):
+    return right / left
+
+
+def rfloordiv(left, right):
+    return right // left
+
+
+def rmod(left, right):
+    # check if right is a string as % is the string
+    # formatting operation; this is a TypeError
+    # otherwise perform the op
+    if isinstance(right, str):
+        typ = type(left).__name__
+        raise TypeError(f"{typ} cannot perform the operation mod")
+
+    return right % left
+
+
+def rdivmod(left, right):
+    return divmod(right, left)
+
+
+def rpow(left, right):
+    return right**left
+
+
+def rand_(left, right):
+    return operator.and_(right, left)
+
+
+def ror_(left, right):
+    return operator.or_(right, left)
+
+
+def rxor(left, right):
+    return operator.xor(right, left)

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas/tests/test_aggregation.py

@@ -0,0 +1,93 @@
+import numpy as np
+import pytest
+
+from pandas.core.apply import (
+    _make_unique_kwarg_list,
+    maybe_mangle_lambdas,
+)
+
+
+def test_maybe_mangle_lambdas_passthrough():
+    assert maybe_mangle_lambdas("mean") == "mean"
+    assert maybe_mangle_lambdas(lambda x: x).__name__ == "<lambda>"
+    # don't mangel single lambda.
+    assert maybe_mangle_lambdas([lambda x: x])[0].__name__ == "<lambda>"
+
+
+def test_maybe_mangle_lambdas_listlike():
+    aggfuncs = [lambda x: 1, lambda x: 2]
+    result = maybe_mangle_lambdas(aggfuncs)
+    assert result[0].__name__ == "<lambda_0>"
+    assert result[1].__name__ == "<lambda_1>"
+    assert aggfuncs[0](None) == result[0](None)
+    assert aggfuncs[1](None) == result[1](None)
+
+
+def test_maybe_mangle_lambdas():
+    func = {"A": [lambda x: 0, lambda x: 1]}
+    result = maybe_mangle_lambdas(func)
+    assert result["A"][0].__name__ == "<lambda_0>"
+    assert result["A"][1].__name__ == "<lambda_1>"
+
+
+def test_maybe_mangle_lambdas_args():
+    func = {"A": [lambda x, a, b=1: (0, a, b), lambda x: 1]}
+    result = maybe_mangle_lambdas(func)
+    assert result["A"][0].__name__ == "<lambda_0>"
+    assert result["A"][1].__name__ == "<lambda_1>"
+
+    assert func["A"][0](0, 1) == (0, 1, 1)
+    assert func["A"][0](0, 1, 2) == (0, 1, 2)
+    assert func["A"][0](0, 2, b=3) == (0, 2, 3)
+
+
+def test_maybe_mangle_lambdas_named():
+    func = {"C": np.mean, "D": {"foo": np.mean, "bar": np.mean}}
+    result = maybe_mangle_lambdas(func)
+    assert result == func
+
+
+@pytest.mark.parametrize(
+    "order, expected_reorder",
+    [
+        (
+            [
+                ("height", "<lambda>"),
+                ("height", "max"),
+                ("weight", "max"),
+                ("height", "<lambda>"),
+                ("weight", "<lambda>"),
+            ],
+            [
+                ("height", "<lambda>_0"),
+                ("height", "max"),
+                ("weight", "max"),
+                ("height", "<lambda>_1"),
+                ("weight", "<lambda>"),
+            ],
+        ),
+        (
+            [
+                ("col2", "min"),
+                ("col1", "<lambda>"),
+                ("col1", "<lambda>"),
+                ("col1", "<lambda>"),
+            ],
+            [
+                ("col2", "min"),
+                ("col1", "<lambda>_0"),
+                ("col1", "<lambda>_1"),
+                ("col1", "<lambda>_2"),
+            ],
+        ),
+        (
+            [("col", "<lambda>"), ("col", "<lambda>"), ("col", "<lambda>")],
+            [("col", "<lambda>_0"), ("col", "<lambda>_1"), ("col", "<lambda>_2")],
+        ),
+    ],
+)
+def test_make_unique(order, expected_reorder):
+    # GH 27519, test if make_unique function reorders correctly
+    result = _make_unique_kwarg_list(order)
+
+    assert result == expected_reorder

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas/tests/test_algos.py

@@ -0,0 +1,2041 @@
+from datetime import datetime
+import struct
+
+import numpy as np
+import pytest
+
+from pandas._libs import (
+    algos as libalgos,
+    hashtable as ht,
+)
+
+from pandas.core.dtypes.common import (
+    is_bool_dtype,
+    is_complex_dtype,
+    is_float_dtype,
+    is_integer_dtype,
+    is_object_dtype,
+)
+from pandas.core.dtypes.dtypes import CategoricalDtype
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    CategoricalIndex,
+    DataFrame,
+    DatetimeIndex,
+    Index,
+    IntervalIndex,
+    MultiIndex,
+    NaT,
+    Period,
+    PeriodIndex,
+    Series,
+    Timedelta,
+    Timestamp,
+    cut,
+    date_range,
+    timedelta_range,
+    to_datetime,
+    to_timedelta,
+)
+import pandas._testing as tm
+import pandas.core.algorithms as algos
+from pandas.core.arrays import (
+    DatetimeArray,
+    TimedeltaArray,
+)
+import pandas.core.common as com
+
+
+class TestFactorize:
+    def test_factorize_complex(self):
+        # GH#17927
+        array = [1, 2, 2 + 1j]
+        msg = "factorize with argument that is not not a Series"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            labels, uniques = algos.factorize(array)
+
+        expected_labels = np.array([0, 1, 2], dtype=np.intp)
+        tm.assert_numpy_array_equal(labels, expected_labels)
+
+        # Should return a complex dtype in the future
+        expected_uniques = np.array([(1 + 0j), (2 + 0j), (2 + 1j)], dtype=object)
+        tm.assert_numpy_array_equal(uniques, expected_uniques)
+
+    @pytest.mark.parametrize("sort", [True, False])
+    def test_factorize(self, index_or_series_obj, sort):
+        obj = index_or_series_obj
+        result_codes, result_uniques = obj.factorize(sort=sort)
+
+        constructor = Index
+        if isinstance(obj, MultiIndex):
+            constructor = MultiIndex.from_tuples
+        expected_arr = obj.unique()
+        if expected_arr.dtype == np.float16:
+            expected_arr = expected_arr.astype(np.float32)
+        expected_uniques = constructor(expected_arr)
+        if (
+            isinstance(obj, Index)
+            and expected_uniques.dtype == bool
+            and obj.dtype == object
+        ):
+            expected_uniques = expected_uniques.astype(object)
+
+        if sort:
+            expected_uniques = expected_uniques.sort_values()
+
+        # construct an integer ndarray so that
+        # `expected_uniques.take(expected_codes)` is equal to `obj`
+        expected_uniques_list = list(expected_uniques)
+        expected_codes = [expected_uniques_list.index(val) for val in obj]
+        expected_codes = np.asarray(expected_codes, dtype=np.intp)
+
+        tm.assert_numpy_array_equal(result_codes, expected_codes)
+        tm.assert_index_equal(result_uniques, expected_uniques, exact=True)
+
+    def test_series_factorize_use_na_sentinel_false(self):
+        # GH#35667
+        values = np.array([1, 2, 1, np.nan])
+        ser = Series(values)
+        codes, uniques = ser.factorize(use_na_sentinel=False)
+
+        expected_codes = np.array([0, 1, 0, 2], dtype=np.intp)
+        expected_uniques = Index([1.0, 2.0, np.nan])
+
+        tm.assert_numpy_array_equal(codes, expected_codes)
+        tm.assert_index_equal(uniques, expected_uniques)
+
+    def test_basic(self):
+        items = np.array(["a", "b", "b", "a", "a", "c", "c", "c"], dtype=object)
+        codes, uniques = algos.factorize(items)
+        tm.assert_numpy_array_equal(uniques, np.array(["a", "b", "c"], dtype=object))
+
+        codes, uniques = algos.factorize(items, sort=True)
+        exp = np.array([0, 1, 1, 0, 0, 2, 2, 2], dtype=np.intp)
+        tm.assert_numpy_array_equal(codes, exp)
+        exp = np.array(["a", "b", "c"], dtype=object)
+        tm.assert_numpy_array_equal(uniques, exp)
+
+        arr = np.arange(5, dtype=np.intp)[::-1]
+
+        codes, uniques = algos.factorize(arr)
+        exp = np.array([0, 1, 2, 3, 4], dtype=np.intp)
+        tm.assert_numpy_array_equal(codes, exp)
+        exp = np.array([4, 3, 2, 1, 0], dtype=arr.dtype)
+        tm.assert_numpy_array_equal(uniques, exp)
+
+        codes, uniques = algos.factorize(arr, sort=True)
+        exp = np.array([4, 3, 2, 1, 0], dtype=np.intp)
+        tm.assert_numpy_array_equal(codes, exp)
+        exp = np.array([0, 1, 2, 3, 4], dtype=arr.dtype)
+        tm.assert_numpy_array_equal(uniques, exp)
+
+        arr = np.arange(5.0)[::-1]
+
+        codes, uniques = algos.factorize(arr)
+        exp = np.array([0, 1, 2, 3, 4], dtype=np.intp)
+        tm.assert_numpy_array_equal(codes, exp)
+        exp = np.array([4.0, 3.0, 2.0, 1.0, 0.0], dtype=arr.dtype)
+        tm.assert_numpy_array_equal(uniques, exp)
+
+        codes, uniques = algos.factorize(arr, sort=True)
+        exp = np.array([4, 3, 2, 1, 0], dtype=np.intp)
+        tm.assert_numpy_array_equal(codes, exp)
+        exp = np.array([0.0, 1.0, 2.0, 3.0, 4.0], dtype=arr.dtype)
+        tm.assert_numpy_array_equal(uniques, exp)
+
+    def test_mixed(self):
+        # doc example reshaping.rst
+        x = Series(["A", "A", np.nan, "B", 3.14, np.inf])
+        codes, uniques = algos.factorize(x)
+
+        exp = np.array([0, 0, -1, 1, 2, 3], dtype=np.intp)
+        tm.assert_numpy_array_equal(codes, exp)
+        exp = Index(["A", "B", 3.14, np.inf])
+        tm.assert_index_equal(uniques, exp)
+
+        codes, uniques = algos.factorize(x, sort=True)
+        exp = np.array([2, 2, -1, 3, 0, 1], dtype=np.intp)
+        tm.assert_numpy_array_equal(codes, exp)
+        exp = Index([3.14, np.inf, "A", "B"])
+        tm.assert_index_equal(uniques, exp)
+
+    def test_factorize_datetime64(self):
+        # M8
+        v1 = Timestamp("20130101 09:00:00.00004")
+        v2 = Timestamp("20130101")
+        x = Series([v1, v1, v1, v2, v2, v1])
+        codes, uniques = algos.factorize(x)
+
+        exp = np.array([0, 0, 0, 1, 1, 0], dtype=np.intp)
+        tm.assert_numpy_array_equal(codes, exp)
+        exp = DatetimeIndex([v1, v2])
+        tm.assert_index_equal(uniques, exp)
+
+        codes, uniques = algos.factorize(x, sort=True)
+        exp = np.array([1, 1, 1, 0, 0, 1], dtype=np.intp)
+        tm.assert_numpy_array_equal(codes, exp)
+        exp = DatetimeIndex([v2, v1])
+        tm.assert_index_equal(uniques, exp)
+
+    def test_factorize_period(self):
+        # period
+        v1 = Period("201302", freq="M")
+        v2 = Period("201303", freq="M")
+        x = Series([v1, v1, v1, v2, v2, v1])
+
+        # periods are not 'sorted' as they are converted back into an index
+        codes, uniques = algos.factorize(x)
+        exp = np.array([0, 0, 0, 1, 1, 0], dtype=np.intp)
+        tm.assert_numpy_array_equal(codes, exp)
+        tm.assert_index_equal(uniques, PeriodIndex([v1, v2]))
+
+        codes, uniques = algos.factorize(x, sort=True)
+        exp = np.array([0, 0, 0, 1, 1, 0], dtype=np.intp)
+        tm.assert_numpy_array_equal(codes, exp)
+        tm.assert_index_equal(uniques, PeriodIndex([v1, v2]))
+
+    def test_factorize_timedelta(self):
+        # GH 5986
+        v1 = to_timedelta("1 day 1 min")
+        v2 = to_timedelta("1 day")
+        x = Series([v1, v2, v1, v1, v2, v2, v1])
+        codes, uniques = algos.factorize(x)
+        exp = np.array([0, 1, 0, 0, 1, 1, 0], dtype=np.intp)
+        tm.assert_numpy_array_equal(codes, exp)
+        tm.assert_index_equal(uniques, to_timedelta([v1, v2]))
+
+        codes, uniques = algos.factorize(x, sort=True)
+        exp = np.array([1, 0, 1, 1, 0, 0, 1], dtype=np.intp)
+        tm.assert_numpy_array_equal(codes, exp)
+        tm.assert_index_equal(uniques, to_timedelta([v2, v1]))
+
+    def test_factorize_nan(self):
+        # nan should map to na_sentinel, not reverse_indexer[na_sentinel]
+        # rizer.factorize should not raise an exception if na_sentinel indexes
+        # outside of reverse_indexer
+        key = np.array([1, 2, 1, np.nan], dtype="O")
+        rizer = ht.ObjectFactorizer(len(key))
+        for na_sentinel in (-1, 20):
+            ids = rizer.factorize(key, na_sentinel=na_sentinel)
+            expected = np.array([0, 1, 0, na_sentinel], dtype=np.intp)
+            assert len(set(key)) == len(set(expected))
+            tm.assert_numpy_array_equal(pd.isna(key), expected == na_sentinel)
+            tm.assert_numpy_array_equal(ids, expected)
+
+    def test_factorizer_with_mask(self):
+        # GH#49549
+        data = np.array([1, 2, 3, 1, 1, 0], dtype="int64")
+        mask = np.array([False, False, False, False, False, True])
+        rizer = ht.Int64Factorizer(len(data))
+        result = rizer.factorize(data, mask=mask)
+        expected = np.array([0, 1, 2, 0, 0, -1], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+        expected_uniques = np.array([1, 2, 3], dtype="int64")
+        tm.assert_numpy_array_equal(rizer.uniques.to_array(), expected_uniques)
+
+    def test_factorizer_object_with_nan(self):
+        # GH#49549
+        data = np.array([1, 2, 3, 1, np.nan])
+        rizer = ht.ObjectFactorizer(len(data))
+        result = rizer.factorize(data.astype(object))
+        expected = np.array([0, 1, 2, 0, -1], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+        expected_uniques = np.array([1, 2, 3], dtype=object)
+        tm.assert_numpy_array_equal(rizer.uniques.to_array(), expected_uniques)
+
+    @pytest.mark.parametrize(
+        "data, expected_codes, expected_uniques",
+        [
+            (
+                [(1, 1), (1, 2), (0, 0), (1, 2), "nonsense"],
+                [0, 1, 2, 1, 3],
+                [(1, 1), (1, 2), (0, 0), "nonsense"],
+            ),
+            (
+                [(1, 1), (1, 2), (0, 0), (1, 2), (1, 2, 3)],
+                [0, 1, 2, 1, 3],
+                [(1, 1), (1, 2), (0, 0), (1, 2, 3)],
+            ),
+            ([(1, 1), (1, 2), (0, 0), (1, 2)], [0, 1, 2, 1], [(1, 1), (1, 2), (0, 0)]),
+        ],
+    )
+    def test_factorize_tuple_list(self, data, expected_codes, expected_uniques):
+        # GH9454
+        msg = "factorize with argument that is not not a Series"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            codes, uniques = pd.factorize(data)
+
+        tm.assert_numpy_array_equal(codes, np.array(expected_codes, dtype=np.intp))
+
+        expected_uniques_array = com.asarray_tuplesafe(expected_uniques, dtype=object)
+        tm.assert_numpy_array_equal(uniques, expected_uniques_array)
+
+    def test_complex_sorting(self):
+        # gh 12666 - check no segfault
+        x17 = np.array([complex(i) for i in range(17)], dtype=object)
+
+        msg = "'[<>]' not supported between instances of .*"
+        with pytest.raises(TypeError, match=msg):
+            algos.factorize(x17[::-1], sort=True)
+
+    def test_numeric_dtype_factorize(self, any_real_numpy_dtype):
+        # GH41132
+        dtype = any_real_numpy_dtype
+        data = np.array([1, 2, 2, 1], dtype=dtype)
+        expected_codes = np.array([0, 1, 1, 0], dtype=np.intp)
+        expected_uniques = np.array([1, 2], dtype=dtype)
+
+        codes, uniques = algos.factorize(data)
+        tm.assert_numpy_array_equal(codes, expected_codes)
+        tm.assert_numpy_array_equal(uniques, expected_uniques)
+
+    def test_float64_factorize(self, writable):
+        data = np.array([1.0, 1e8, 1.0, 1e-8, 1e8, 1.0], dtype=np.float64)
+        data.setflags(write=writable)
+        expected_codes = np.array([0, 1, 0, 2, 1, 0], dtype=np.intp)
+        expected_uniques = np.array([1.0, 1e8, 1e-8], dtype=np.float64)
+
+        codes, uniques = algos.factorize(data)
+        tm.assert_numpy_array_equal(codes, expected_codes)
+        tm.assert_numpy_array_equal(uniques, expected_uniques)
+
+    def test_uint64_factorize(self, writable):
+        data = np.array([2**64 - 1, 1, 2**64 - 1], dtype=np.uint64)
+        data.setflags(write=writable)
+        expected_codes = np.array([0, 1, 0], dtype=np.intp)
+        expected_uniques = np.array([2**64 - 1, 1], dtype=np.uint64)
+
+        codes, uniques = algos.factorize(data)
+        tm.assert_numpy_array_equal(codes, expected_codes)
+        tm.assert_numpy_array_equal(uniques, expected_uniques)
+
+    def test_int64_factorize(self, writable):
+        data = np.array([2**63 - 1, -(2**63), 2**63 - 1], dtype=np.int64)
+        data.setflags(write=writable)
+        expected_codes = np.array([0, 1, 0], dtype=np.intp)
+        expected_uniques = np.array([2**63 - 1, -(2**63)], dtype=np.int64)
+
+        codes, uniques = algos.factorize(data)
+        tm.assert_numpy_array_equal(codes, expected_codes)
+        tm.assert_numpy_array_equal(uniques, expected_uniques)
+
+    def test_string_factorize(self, writable):
+        data = np.array(["a", "c", "a", "b", "c"], dtype=object)
+        data.setflags(write=writable)
+        expected_codes = np.array([0, 1, 0, 2, 1], dtype=np.intp)
+        expected_uniques = np.array(["a", "c", "b"], dtype=object)
+
+        codes, uniques = algos.factorize(data)
+        tm.assert_numpy_array_equal(codes, expected_codes)
+        tm.assert_numpy_array_equal(uniques, expected_uniques)
+
+    def test_object_factorize(self, writable):
+        data = np.array(["a", "c", None, np.nan, "a", "b", NaT, "c"], dtype=object)
+        data.setflags(write=writable)
+        expected_codes = np.array([0, 1, -1, -1, 0, 2, -1, 1], dtype=np.intp)
+        expected_uniques = np.array(["a", "c", "b"], dtype=object)
+
+        codes, uniques = algos.factorize(data)
+        tm.assert_numpy_array_equal(codes, expected_codes)
+        tm.assert_numpy_array_equal(uniques, expected_uniques)
+
+    def test_datetime64_factorize(self, writable):
+        # GH35650 Verify whether read-only datetime64 array can be factorized
+        data = np.array([np.datetime64("2020-01-01T00:00:00.000")], dtype="M8[ns]")
+        data.setflags(write=writable)
+        expected_codes = np.array([0], dtype=np.intp)
+        expected_uniques = np.array(
+            ["2020-01-01T00:00:00.000000000"], dtype="datetime64[ns]"
+        )
+
+        codes, uniques = pd.factorize(data)
+        tm.assert_numpy_array_equal(codes, expected_codes)
+        tm.assert_numpy_array_equal(uniques, expected_uniques)
+
+    @pytest.mark.parametrize("sort", [True, False])
+    def test_factorize_rangeindex(self, sort):
+        # increasing -> sort doesn't matter
+        ri = pd.RangeIndex.from_range(range(10))
+        expected = np.arange(10, dtype=np.intp), ri
+
+        result = algos.factorize(ri, sort=sort)
+        tm.assert_numpy_array_equal(result[0], expected[0])
+        tm.assert_index_equal(result[1], expected[1], exact=True)
+
+        result = ri.factorize(sort=sort)
+        tm.assert_numpy_array_equal(result[0], expected[0])
+        tm.assert_index_equal(result[1], expected[1], exact=True)
+
+    @pytest.mark.parametrize("sort", [True, False])
+    def test_factorize_rangeindex_decreasing(self, sort):
+        # decreasing -> sort matters
+        ri = pd.RangeIndex.from_range(range(10))
+        expected = np.arange(10, dtype=np.intp), ri
+
+        ri2 = ri[::-1]
+        expected = expected[0], ri2
+        if sort:
+            expected = expected[0][::-1], expected[1][::-1]
+
+        result = algos.factorize(ri2, sort=sort)
+        tm.assert_numpy_array_equal(result[0], expected[0])
+        tm.assert_index_equal(result[1], expected[1], exact=True)
+
+        result = ri2.factorize(sort=sort)
+        tm.assert_numpy_array_equal(result[0], expected[0])
+        tm.assert_index_equal(result[1], expected[1], exact=True)
+
+    def test_deprecate_order(self):
+        # gh 19727 - check warning is raised for deprecated keyword, order.
+        # Test not valid once order keyword is removed.
+        data = np.array([2**63, 1, 2**63], dtype=np.uint64)
+        with pytest.raises(TypeError, match="got an unexpected keyword"):
+            algos.factorize(data, order=True)
+        with tm.assert_produces_warning(False):
+            algos.factorize(data)
+
+    @pytest.mark.parametrize(
+        "data",
+        [
+            np.array([0, 1, 0], dtype="u8"),
+            np.array([-(2**63), 1, -(2**63)], dtype="i8"),
+            np.array(["__nan__", "foo", "__nan__"], dtype="object"),
+        ],
+    )
+    def test_parametrized_factorize_na_value_default(self, data):
+        # arrays that include the NA default for that type, but isn't used.
+        codes, uniques = algos.factorize(data)
+        expected_uniques = data[[0, 1]]
+        expected_codes = np.array([0, 1, 0], dtype=np.intp)
+        tm.assert_numpy_array_equal(codes, expected_codes)
+        tm.assert_numpy_array_equal(uniques, expected_uniques)
+
+    @pytest.mark.parametrize(
+        "data, na_value",
+        [
+            (np.array([0, 1, 0, 2], dtype="u8"), 0),
+            (np.array([1, 0, 1, 2], dtype="u8"), 1),
+            (np.array([-(2**63), 1, -(2**63), 0], dtype="i8"), -(2**63)),
+            (np.array([1, -(2**63), 1, 0], dtype="i8"), 1),
+            (np.array(["a", "", "a", "b"], dtype=object), "a"),
+            (np.array([(), ("a", 1), (), ("a", 2)], dtype=object), ()),
+            (np.array([("a", 1), (), ("a", 1), ("a", 2)], dtype=object), ("a", 1)),
+        ],
+    )
+    def test_parametrized_factorize_na_value(self, data, na_value):
+        codes, uniques = algos.factorize_array(data, na_value=na_value)
+        expected_uniques = data[[1, 3]]
+        expected_codes = np.array([-1, 0, -1, 1], dtype=np.intp)
+        tm.assert_numpy_array_equal(codes, expected_codes)
+        tm.assert_numpy_array_equal(uniques, expected_uniques)
+
+    @pytest.mark.parametrize("sort", [True, False])
+    @pytest.mark.parametrize(
+        "data, uniques",
+        [
+            (
+                np.array(["b", "a", None, "b"], dtype=object),
+                np.array(["b", "a"], dtype=object),
+            ),
+            (
+                pd.array([2, 1, np.nan, 2], dtype="Int64"),
+                pd.array([2, 1], dtype="Int64"),
+            ),
+        ],
+        ids=["numpy_array", "extension_array"],
+    )
+    def test_factorize_use_na_sentinel(self, sort, data, uniques):
+        codes, uniques = algos.factorize(data, sort=sort, use_na_sentinel=True)
+        if sort:
+            expected_codes = np.array([1, 0, -1, 1], dtype=np.intp)
+            expected_uniques = algos.safe_sort(uniques)
+        else:
+            expected_codes = np.array([0, 1, -1, 0], dtype=np.intp)
+            expected_uniques = uniques
+        tm.assert_numpy_array_equal(codes, expected_codes)
+        if isinstance(data, np.ndarray):
+            tm.assert_numpy_array_equal(uniques, expected_uniques)
+        else:
+            tm.assert_extension_array_equal(uniques, expected_uniques)
+
+    @pytest.mark.parametrize(
+        "data, expected_codes, expected_uniques",
+        [
+            (
+                ["a", None, "b", "a"],
+                np.array([0, 1, 2, 0], dtype=np.dtype("intp")),
+                np.array(["a", np.nan, "b"], dtype=object),
+            ),
+            (
+                ["a", np.nan, "b", "a"],
+                np.array([0, 1, 2, 0], dtype=np.dtype("intp")),
+                np.array(["a", np.nan, "b"], dtype=object),
+            ),
+        ],
+    )
+    def test_object_factorize_use_na_sentinel_false(
+        self, data, expected_codes, expected_uniques
+    ):
+        codes, uniques = algos.factorize(
+            np.array(data, dtype=object), use_na_sentinel=False
+        )
+
+        tm.assert_numpy_array_equal(uniques, expected_uniques, strict_nan=True)
+        tm.assert_numpy_array_equal(codes, expected_codes, strict_nan=True)
+
+    @pytest.mark.parametrize(
+        "data, expected_codes, expected_uniques",
+        [
+            (
+                [1, None, 1, 2],
+                np.array([0, 1, 0, 2], dtype=np.dtype("intp")),
+                np.array([1, np.nan, 2], dtype="O"),
+            ),
+            (
+                [1, np.nan, 1, 2],
+                np.array([0, 1, 0, 2], dtype=np.dtype("intp")),
+                np.array([1, np.nan, 2], dtype=np.float64),
+            ),
+        ],
+    )
+    def test_int_factorize_use_na_sentinel_false(
+        self, data, expected_codes, expected_uniques
+    ):
+        msg = "factorize with argument that is not not a Series"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            codes, uniques = algos.factorize(data, use_na_sentinel=False)
+
+        tm.assert_numpy_array_equal(uniques, expected_uniques, strict_nan=True)
+        tm.assert_numpy_array_equal(codes, expected_codes, strict_nan=True)
+
+    @pytest.mark.parametrize(
+        "data, expected_codes, expected_uniques",
+        [
+            (
+                Index(Categorical(["a", "a", "b"])),
+                np.array([0, 0, 1], dtype=np.intp),
+                CategoricalIndex(["a", "b"], categories=["a", "b"], dtype="category"),
+            ),
+            (
+                Series(Categorical(["a", "a", "b"])),
+                np.array([0, 0, 1], dtype=np.intp),
+                CategoricalIndex(["a", "b"], categories=["a", "b"], dtype="category"),
+            ),
+            (
+                Series(DatetimeIndex(["2017", "2017"], tz="US/Eastern")),
+                np.array([0, 0], dtype=np.intp),
+                DatetimeIndex(["2017"], tz="US/Eastern"),
+            ),
+        ],
+    )
+    def test_factorize_mixed_values(self, data, expected_codes, expected_uniques):
+        # GH 19721
+        codes, uniques = algos.factorize(data)
+        tm.assert_numpy_array_equal(codes, expected_codes)
+        tm.assert_index_equal(uniques, expected_uniques)
+
+    def test_factorize_interval_non_nano(self, unit):
+        # GH#56099
+        left = DatetimeIndex(["2016-01-01", np.nan, "2015-10-11"]).as_unit(unit)
+        right = DatetimeIndex(["2016-01-02", np.nan, "2015-10-15"]).as_unit(unit)
+        idx = IntervalIndex.from_arrays(left, right)
+        codes, cats = idx.factorize()
+        assert cats.dtype == f"interval[datetime64[{unit}], right]"
+
+        ts = Timestamp(0).as_unit(unit)
+        idx2 = IntervalIndex.from_arrays(left - ts, right - ts)
+        codes2, cats2 = idx2.factorize()
+        assert cats2.dtype == f"interval[timedelta64[{unit}], right]"
+
+        idx3 = IntervalIndex.from_arrays(
+            left.tz_localize("US/Pacific"), right.tz_localize("US/Pacific")
+        )
+        codes3, cats3 = idx3.factorize()
+        assert cats3.dtype == f"interval[datetime64[{unit}, US/Pacific], right]"
+
+
+class TestUnique:
+    def test_ints(self):
+        arr = np.random.default_rng(2).integers(0, 100, size=50)
+
+        result = algos.unique(arr)
+        assert isinstance(result, np.ndarray)
+
+    def test_objects(self):
+        arr = np.random.default_rng(2).integers(0, 100, size=50).astype("O")
+
+        result = algos.unique(arr)
+        assert isinstance(result, np.ndarray)
+
+    def test_object_refcount_bug(self):
+        lst = np.array(["A", "B", "C", "D", "E"], dtype=object)
+        for i in range(1000):
+            len(algos.unique(lst))
+
+    def test_on_index_object(self):
+        mindex = MultiIndex.from_arrays(
+            [np.arange(5).repeat(5), np.tile(np.arange(5), 5)]
+        )
+        expected = mindex.values
+        expected.sort()
+
+        mindex = mindex.repeat(2)
+
+        result = pd.unique(mindex)
+        result.sort()
+
+        tm.assert_almost_equal(result, expected)
+
+    def test_dtype_preservation(self, any_numpy_dtype):
+        # GH 15442
+        if any_numpy_dtype in (tm.BYTES_DTYPES + tm.STRING_DTYPES):
+            data = [1, 2, 2]
+            uniques = [1, 2]
+        elif is_integer_dtype(any_numpy_dtype):
+            data = [1, 2, 2]
+            uniques = [1, 2]
+        elif is_float_dtype(any_numpy_dtype):
+            data = [1, 2, 2]
+            uniques = [1.0, 2.0]
+        elif is_complex_dtype(any_numpy_dtype):
+            data = [complex(1, 0), complex(2, 0), complex(2, 0)]
+            uniques = [complex(1, 0), complex(2, 0)]
+        elif is_bool_dtype(any_numpy_dtype):
+            data = [True, True, False]
+            uniques = [True, False]
+        elif is_object_dtype(any_numpy_dtype):
+            data = ["A", "B", "B"]
+            uniques = ["A", "B"]
+        else:
+            # datetime64[ns]/M8[ns]/timedelta64[ns]/m8[ns] tested elsewhere
+            data = [1, 2, 2]
+            uniques = [1, 2]
+
+        result = Series(data, dtype=any_numpy_dtype).unique()
+        expected = np.array(uniques, dtype=any_numpy_dtype)
+
+        if any_numpy_dtype in tm.STRING_DTYPES:
+            expected = expected.astype(object)
+
+        if expected.dtype.kind in ["m", "M"]:
+            # We get TimedeltaArray/DatetimeArray
+            assert isinstance(result, (DatetimeArray, TimedeltaArray))
+            result = np.array(result)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_datetime64_dtype_array_returned(self):
+        # GH 9431
+        expected = np.array(
+            [
+                "2015-01-03T00:00:00.000000000",
+                "2015-01-01T00:00:00.000000000",
+            ],
+            dtype="M8[ns]",
+        )
+
+        dt_index = to_datetime(
+            [
+                "2015-01-03T00:00:00.000000000",
+                "2015-01-01T00:00:00.000000000",
+                "2015-01-01T00:00:00.000000000",
+            ]
+        )
+        result = algos.unique(dt_index)
+        tm.assert_numpy_array_equal(result, expected)
+        assert result.dtype == expected.dtype
+
+        s = Series(dt_index)
+        result = algos.unique(s)
+        tm.assert_numpy_array_equal(result, expected)
+        assert result.dtype == expected.dtype
+
+        arr = s.values
+        result = algos.unique(arr)
+        tm.assert_numpy_array_equal(result, expected)
+        assert result.dtype == expected.dtype
+
+    def test_datetime_non_ns(self):
+        a = np.array(["2000", "2000", "2001"], dtype="datetime64[s]")
+        result = pd.unique(a)
+        expected = np.array(["2000", "2001"], dtype="datetime64[s]")
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_timedelta_non_ns(self):
+        a = np.array(["2000", "2000", "2001"], dtype="timedelta64[s]")
+        result = pd.unique(a)
+        expected = np.array([2000, 2001], dtype="timedelta64[s]")
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_timedelta64_dtype_array_returned(self):
+        # GH 9431
+        expected = np.array([31200, 45678, 10000], dtype="m8[ns]")
+
+        td_index = to_timedelta([31200, 45678, 31200, 10000, 45678])
+        result = algos.unique(td_index)
+        tm.assert_numpy_array_equal(result, expected)
+        assert result.dtype == expected.dtype
+
+        s = Series(td_index)
+        result = algos.unique(s)
+        tm.assert_numpy_array_equal(result, expected)
+        assert result.dtype == expected.dtype
+
+        arr = s.values
+        result = algos.unique(arr)
+        tm.assert_numpy_array_equal(result, expected)
+        assert result.dtype == expected.dtype
+
+    def test_uint64_overflow(self):
+        s = Series([1, 2, 2**63, 2**63], dtype=np.uint64)
+        exp = np.array([1, 2, 2**63], dtype=np.uint64)
+        tm.assert_numpy_array_equal(algos.unique(s), exp)
+
+    def test_nan_in_object_array(self):
+        duplicated_items = ["a", np.nan, "c", "c"]
+        result = pd.unique(np.array(duplicated_items, dtype=object))
+        expected = np.array(["a", np.nan, "c"], dtype=object)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_categorical(self):
+        # we are expecting to return in the order
+        # of appearance
+        expected = Categorical(list("bac"))
+
+        # we are expecting to return in the order
+        # of the categories
+        expected_o = Categorical(list("bac"), categories=list("abc"), ordered=True)
+
+        # GH 15939
+        c = Categorical(list("baabc"))
+        result = c.unique()
+        tm.assert_categorical_equal(result, expected)
+
+        result = algos.unique(c)
+        tm.assert_categorical_equal(result, expected)
+
+        c = Categorical(list("baabc"), ordered=True)
+        result = c.unique()
+        tm.assert_categorical_equal(result, expected_o)
+
+        result = algos.unique(c)
+        tm.assert_categorical_equal(result, expected_o)
+
+        # Series of categorical dtype
+        s = Series(Categorical(list("baabc")), name="foo")
+        result = s.unique()
+        tm.assert_categorical_equal(result, expected)
+
+        result = pd.unique(s)
+        tm.assert_categorical_equal(result, expected)
+
+        # CI -> return CI
+        ci = CategoricalIndex(Categorical(list("baabc"), categories=list("abc")))
+        expected = CategoricalIndex(expected)
+        result = ci.unique()
+        tm.assert_index_equal(result, expected)
+
+        result = pd.unique(ci)
+        tm.assert_index_equal(result, expected)
+
+    def test_datetime64tz_aware(self, unit):
+        # GH 15939
+
+        dti = Index(
+            [
+                Timestamp("20160101", tz="US/Eastern"),
+                Timestamp("20160101", tz="US/Eastern"),
+            ]
+        ).as_unit(unit)
+        ser = Series(dti)
+
+        result = ser.unique()
+        expected = dti[:1]._data
+        tm.assert_extension_array_equal(result, expected)
+
+        result = dti.unique()
+        expected = dti[:1]
+        tm.assert_index_equal(result, expected)
+
+        result = pd.unique(ser)
+        expected = dti[:1]._data
+        tm.assert_extension_array_equal(result, expected)
+
+        result = pd.unique(dti)
+        expected = dti[:1]
+        tm.assert_index_equal(result, expected)
+
+    def test_order_of_appearance(self):
+        # 9346
+        # light testing of guarantee of order of appearance
+        # these also are the doc-examples
+        result = pd.unique(Series([2, 1, 3, 3]))
+        tm.assert_numpy_array_equal(result, np.array([2, 1, 3], dtype="int64"))
+
+        result = pd.unique(Series([2] + [1] * 5))
+        tm.assert_numpy_array_equal(result, np.array([2, 1], dtype="int64"))
+
+        msg = "unique with argument that is not not a Series, Index,"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = pd.unique(list("aabc"))
+        expected = np.array(["a", "b", "c"], dtype=object)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = pd.unique(Series(Categorical(list("aabc"))))
+        expected = Categorical(list("abc"))
+        tm.assert_categorical_equal(result, expected)
+
+    def test_order_of_appearance_dt64(self, unit):
+        ser = Series([Timestamp("20160101"), Timestamp("20160101")]).dt.as_unit(unit)
+        result = pd.unique(ser)
+        expected = np.array(["2016-01-01T00:00:00.000000000"], dtype=f"M8[{unit}]")
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_order_of_appearance_dt64tz(self, unit):
+        dti = DatetimeIndex(
+            [
+                Timestamp("20160101", tz="US/Eastern"),
+                Timestamp("20160101", tz="US/Eastern"),
+            ]
+        ).as_unit(unit)
+        result = pd.unique(dti)
+        expected = DatetimeIndex(
+            ["2016-01-01 00:00:00"], dtype=f"datetime64[{unit}, US/Eastern]", freq=None
+        )
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "arg ,expected",
+        [
+            (("1", "1", "2"), np.array(["1", "2"], dtype=object)),
+            (("foo",), np.array(["foo"], dtype=object)),
+        ],
+    )
+    def test_tuple_with_strings(self, arg, expected):
+        # see GH 17108
+        msg = "unique with argument that is not not a Series"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = pd.unique(arg)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_obj_none_preservation(self):
+        # GH 20866
+        arr = np.array(["foo", None], dtype=object)
+        result = pd.unique(arr)
+        expected = np.array(["foo", None], dtype=object)
+
+        tm.assert_numpy_array_equal(result, expected, strict_nan=True)
+
+    def test_signed_zero(self):
+        # GH 21866
+        a = np.array([-0.0, 0.0])
+        result = pd.unique(a)
+        expected = np.array([-0.0])  # 0.0 and -0.0 are equivalent
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_different_nans(self):
+        # GH 21866
+        # create different nans from bit-patterns:
+        NAN1 = struct.unpack("d", struct.pack("=Q", 0x7FF8000000000000))[0]
+        NAN2 = struct.unpack("d", struct.pack("=Q", 0x7FF8000000000001))[0]
+        assert NAN1 != NAN1
+        assert NAN2 != NAN2
+        a = np.array([NAN1, NAN2])  # NAN1 and NAN2 are equivalent
+        result = pd.unique(a)
+        expected = np.array([np.nan])
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize("el_type", [np.float64, object])
+    def test_first_nan_kept(self, el_type):
+        # GH 22295
+        # create different nans from bit-patterns:
+        bits_for_nan1 = 0xFFF8000000000001
+        bits_for_nan2 = 0x7FF8000000000001
+        NAN1 = struct.unpack("d", struct.pack("=Q", bits_for_nan1))[0]
+        NAN2 = struct.unpack("d", struct.pack("=Q", bits_for_nan2))[0]
+        assert NAN1 != NAN1
+        assert NAN2 != NAN2
+        a = np.array([NAN1, NAN2], dtype=el_type)
+        result = pd.unique(a)
+        assert result.size == 1
+        # use bit patterns to identify which nan was kept:
+        result_nan_bits = struct.unpack("=Q", struct.pack("d", result[0]))[0]
+        assert result_nan_bits == bits_for_nan1
+
+    def test_do_not_mangle_na_values(self, unique_nulls_fixture, unique_nulls_fixture2):
+        # GH 22295
+        if unique_nulls_fixture is unique_nulls_fixture2:
+            return  # skip it, values not unique
+        a = np.array([unique_nulls_fixture, unique_nulls_fixture2], dtype=object)
+        result = pd.unique(a)
+        assert result.size == 2
+        assert a[0] is unique_nulls_fixture
+        assert a[1] is unique_nulls_fixture2
+
+    def test_unique_masked(self, any_numeric_ea_dtype):
+        # GH#48019
+        ser = Series([1, pd.NA, 2] * 3, dtype=any_numeric_ea_dtype)
+        result = pd.unique(ser)
+        expected = pd.array([1, pd.NA, 2], dtype=any_numeric_ea_dtype)
+        tm.assert_extension_array_equal(result, expected)
+
+
+def test_nunique_ints(index_or_series_or_array):
+    # GH#36327
+    values = index_or_series_or_array(np.random.default_rng(2).integers(0, 20, 30))
+    result = algos.nunique_ints(values)
+    expected = len(algos.unique(values))
+    assert result == expected
+
+
+class TestIsin:
+    def test_invalid(self):
+        msg = (
+            r"only list-like objects are allowed to be passed to isin\(\), "
+            r"you passed a `int`"
+        )
+        with pytest.raises(TypeError, match=msg):
+            algos.isin(1, 1)
+        with pytest.raises(TypeError, match=msg):
+            algos.isin(1, [1])
+        with pytest.raises(TypeError, match=msg):
+            algos.isin([1], 1)
+
+    def test_basic(self):
+        msg = "isin with argument that is not not a Series"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = algos.isin([1, 2], [1])
+        expected = np.array([True, False])
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = algos.isin(np.array([1, 2]), [1])
+        expected = np.array([True, False])
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = algos.isin(Series([1, 2]), [1])
+        expected = np.array([True, False])
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = algos.isin(Series([1, 2]), Series([1]))
+        expected = np.array([True, False])
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = algos.isin(Series([1, 2]), {1})
+        expected = np.array([True, False])
+        tm.assert_numpy_array_equal(result, expected)
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = algos.isin(["a", "b"], ["a"])
+        expected = np.array([True, False])
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = algos.isin(Series(["a", "b"]), Series(["a"]))
+        expected = np.array([True, False])
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = algos.isin(Series(["a", "b"]), {"a"})
+        expected = np.array([True, False])
+        tm.assert_numpy_array_equal(result, expected)
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = algos.isin(["a", "b"], [1])
+        expected = np.array([False, False])
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_i8(self):
+        arr = date_range("20130101", periods=3).values
+        result = algos.isin(arr, [arr[0]])
+        expected = np.array([True, False, False])
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = algos.isin(arr, arr[0:2])
+        expected = np.array([True, True, False])
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = algos.isin(arr, set(arr[0:2]))
+        expected = np.array([True, True, False])
+        tm.assert_numpy_array_equal(result, expected)
+
+        arr = timedelta_range("1 day", periods=3).values
+        result = algos.isin(arr, [arr[0]])
+        expected = np.array([True, False, False])
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = algos.isin(arr, arr[0:2])
+        expected = np.array([True, True, False])
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = algos.isin(arr, set(arr[0:2]))
+        expected = np.array([True, True, False])
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype1", ["m8[ns]", "M8[ns]", "M8[ns, UTC]", "period[D]"])
+    @pytest.mark.parametrize("dtype", ["i8", "f8", "u8"])
+    def test_isin_datetimelike_values_numeric_comps(self, dtype, dtype1):
+        # Anything but object and we get all-False shortcut
+
+        dta = date_range("2013-01-01", periods=3)._values
+        arr = Series(dta.view("i8")).array.view(dtype1)
+
+        comps = arr.view("i8").astype(dtype)
+
+        result = algos.isin(comps, arr)
+        expected = np.zeros(comps.shape, dtype=bool)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_large(self):
+        s = date_range("20000101", periods=2000000, freq="s").values
+        result = algos.isin(s, s[0:2])
+        expected = np.zeros(len(s), dtype=bool)
+        expected[0] = True
+        expected[1] = True
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype", ["m8[ns]", "M8[ns]", "M8[ns, UTC]", "period[D]"])
+    def test_isin_datetimelike_all_nat(self, dtype):
+        # GH#56427
+        dta = date_range("2013-01-01", periods=3)._values
+        arr = Series(dta.view("i8")).array.view(dtype)
+
+        arr[0] = NaT
+        result = algos.isin(arr, [NaT])
+        expected = np.array([True, False, False], dtype=bool)
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype", ["m8[ns]", "M8[ns]", "M8[ns, UTC]"])
+    def test_isin_datetimelike_strings_deprecated(self, dtype):
+        # GH#53111
+        dta = date_range("2013-01-01", periods=3)._values
+        arr = Series(dta.view("i8")).array.view(dtype)
+
+        vals = [str(x) for x in arr]
+        msg = "The behavior of 'isin' with dtype=.* is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = algos.isin(arr, vals)
+        assert res.all()
+
+        vals2 = np.array(vals, dtype=str)
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res2 = algos.isin(arr, vals2)
+        assert res2.all()
+
+    def test_isin_dt64tz_with_nat(self):
+        # the all-NaT values used to get inferred to tznaive, which was evaluated
+        #  as non-matching GH#56427
+        dti = date_range("2016-01-01", periods=3, tz="UTC")
+        ser = Series(dti)
+        ser[0] = NaT
+
+        res = algos.isin(ser._values, [NaT])
+        exp = np.array([True, False, False], dtype=bool)
+        tm.assert_numpy_array_equal(res, exp)
+
+    def test_categorical_from_codes(self):
+        # GH 16639
+        vals = np.array([0, 1, 2, 0])
+        cats = ["a", "b", "c"]
+        Sd = Series(Categorical([1]).from_codes(vals, cats))
+        St = Series(Categorical([1]).from_codes(np.array([0, 1]), cats))
+        expected = np.array([True, True, False, True])
+        result = algos.isin(Sd, St)
+        tm.assert_numpy_array_equal(expected, result)
+
+    def test_categorical_isin(self):
+        vals = np.array([0, 1, 2, 0])
+        cats = ["a", "b", "c"]
+        cat = Categorical([1]).from_codes(vals, cats)
+        other = Categorical([1]).from_codes(np.array([0, 1]), cats)
+
+        expected = np.array([True, True, False, True])
+        result = algos.isin(cat, other)
+        tm.assert_numpy_array_equal(expected, result)
+
+    def test_same_nan_is_in(self):
+        # GH 22160
+        # nan is special, because from " a is b" doesn't follow "a == b"
+        # at least, isin() should follow python's "np.nan in [nan] == True"
+        # casting to -> np.float64 -> another float-object somewhere on
+        # the way could lead jeopardize this behavior
+        comps = [np.nan]  # could be casted to float64
+        values = [np.nan]
+        expected = np.array([True])
+        msg = "isin with argument that is not not a Series"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = algos.isin(comps, values)
+        tm.assert_numpy_array_equal(expected, result)
+
+    def test_same_nan_is_in_large(self):
+        # https://github.com/pandas-dev/pandas/issues/22205
+        s = np.tile(1.0, 1_000_001)
+        s[0] = np.nan
+        result = algos.isin(s, np.array([np.nan, 1]))
+        expected = np.ones(len(s), dtype=bool)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_same_nan_is_in_large_series(self):
+        # https://github.com/pandas-dev/pandas/issues/22205
+        s = np.tile(1.0, 1_000_001)
+        series = Series(s)
+        s[0] = np.nan
+        result = series.isin(np.array([np.nan, 1]))
+        expected = Series(np.ones(len(s), dtype=bool))
+        tm.assert_series_equal(result, expected)
+
+    def test_same_object_is_in(self):
+        # GH 22160
+        # there could be special treatment for nans
+        # the user however could define a custom class
+        # with similar behavior, then we at least should
+        # fall back to usual python's behavior: "a in [a] == True"
+        class LikeNan:
+            def __eq__(self, other) -> bool:
+                return False
+
+            def __hash__(self):
+                return 0
+
+        a, b = LikeNan(), LikeNan()
+
+        msg = "isin with argument that is not not a Series"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            # same object -> True
+            tm.assert_numpy_array_equal(algos.isin([a], [a]), np.array([True]))
+            # different objects -> False
+            tm.assert_numpy_array_equal(algos.isin([a], [b]), np.array([False]))
+
+    def test_different_nans(self):
+        # GH 22160
+        # all nans are handled as equivalent
+
+        comps = [float("nan")]
+        values = [float("nan")]
+        assert comps[0] is not values[0]  # different nan-objects
+
+        # as list of python-objects:
+        result = algos.isin(np.array(comps), values)
+        tm.assert_numpy_array_equal(np.array([True]), result)
+
+        # as object-array:
+        result = algos.isin(
+            np.asarray(comps, dtype=object), np.asarray(values, dtype=object)
+        )
+        tm.assert_numpy_array_equal(np.array([True]), result)
+
+        # as float64-array:
+        result = algos.isin(
+            np.asarray(comps, dtype=np.float64), np.asarray(values, dtype=np.float64)
+        )
+        tm.assert_numpy_array_equal(np.array([True]), result)
+
+    def test_no_cast(self):
+        # GH 22160
+        # ensure 42 is not casted to a string
+        comps = ["ss", 42]
+        values = ["42"]
+        expected = np.array([False, False])
+        msg = "isin with argument that is not not a Series, Index"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = algos.isin(comps, values)
+        tm.assert_numpy_array_equal(expected, result)
+
+    @pytest.mark.parametrize("empty", [[], Series(dtype=object), np.array([])])
+    def test_empty(self, empty):
+        # see gh-16991
+        vals = Index(["a", "b"])
+        expected = np.array([False, False])
+
+        result = algos.isin(vals, empty)
+        tm.assert_numpy_array_equal(expected, result)
+
+    def test_different_nan_objects(self):
+        # GH 22119
+        comps = np.array(["nan", np.nan * 1j, float("nan")], dtype=object)
+        vals = np.array([float("nan")], dtype=object)
+        expected = np.array([False, False, True])
+        result = algos.isin(comps, vals)
+        tm.assert_numpy_array_equal(expected, result)
+
+    def test_different_nans_as_float64(self):
+        # GH 21866
+        # create different nans from bit-patterns,
+        # these nans will land in different buckets in the hash-table
+        # if no special care is taken
+        NAN1 = struct.unpack("d", struct.pack("=Q", 0x7FF8000000000000))[0]
+        NAN2 = struct.unpack("d", struct.pack("=Q", 0x7FF8000000000001))[0]
+        assert NAN1 != NAN1
+        assert NAN2 != NAN2
+
+        # check that NAN1 and NAN2 are equivalent:
+        arr = np.array([NAN1, NAN2], dtype=np.float64)
+        lookup1 = np.array([NAN1], dtype=np.float64)
+        result = algos.isin(arr, lookup1)
+        expected = np.array([True, True])
+        tm.assert_numpy_array_equal(result, expected)
+
+        lookup2 = np.array([NAN2], dtype=np.float64)
+        result = algos.isin(arr, lookup2)
+        expected = np.array([True, True])
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_isin_int_df_string_search(self):
+        """Comparing df with int`s (1,2) with a string at isin() ("1")
+        -> should not match values because int 1 is not equal str 1"""
+        df = DataFrame({"values": [1, 2]})
+        result = df.isin(["1"])
+        expected_false = DataFrame({"values": [False, False]})
+        tm.assert_frame_equal(result, expected_false)
+
+    def test_isin_nan_df_string_search(self):
+        """Comparing df with nan value (np.nan,2) with a string at isin() ("NaN")
+        -> should not match values because np.nan is not equal str NaN"""
+        df = DataFrame({"values": [np.nan, 2]})
+        result = df.isin(np.array(["NaN"], dtype=object))
+        expected_false = DataFrame({"values": [False, False]})
+        tm.assert_frame_equal(result, expected_false)
+
+    def test_isin_float_df_string_search(self):
+        """Comparing df with floats (1.4245,2.32441) with a string at isin() ("1.4245")
+        -> should not match values because float 1.4245 is not equal str 1.4245"""
+        df = DataFrame({"values": [1.4245, 2.32441]})
+        result = df.isin(np.array(["1.4245"], dtype=object))
+        expected_false = DataFrame({"values": [False, False]})
+        tm.assert_frame_equal(result, expected_false)
+
+    def test_isin_unsigned_dtype(self):
+        # GH#46485
+        ser = Series([1378774140726870442], dtype=np.uint64)
+        result = ser.isin([1378774140726870528])
+        expected = Series(False)
+        tm.assert_series_equal(result, expected)
+
+
+class TestValueCounts:
+    def test_value_counts(self):
+        arr = np.random.default_rng(1234).standard_normal(4)
+        factor = cut(arr, 4)
+
+        # assert isinstance(factor, n)
+        msg = "pandas.value_counts is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = algos.value_counts(factor)
+        breaks = [-1.606, -1.018, -0.431, 0.155, 0.741]
+        index = IntervalIndex.from_breaks(breaks).astype(CategoricalDtype(ordered=True))
+        expected = Series([1, 0, 2, 1], index=index, name="count")
+        tm.assert_series_equal(result.sort_index(), expected.sort_index())
+
+    def test_value_counts_bins(self):
+        s = [1, 2, 3, 4]
+        msg = "pandas.value_counts is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = algos.value_counts(s, bins=1)
+        expected = Series(
+            [4], index=IntervalIndex.from_tuples([(0.996, 4.0)]), name="count"
+        )
+        tm.assert_series_equal(result, expected)
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = algos.value_counts(s, bins=2, sort=False)
+        expected = Series(
+            [2, 2],
+            index=IntervalIndex.from_tuples([(0.996, 2.5), (2.5, 4.0)]),
+            name="count",
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_value_counts_dtypes(self):
+        msg2 = "pandas.value_counts is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg2):
+            result = algos.value_counts(np.array([1, 1.0]))
+        assert len(result) == 1
+
+        with tm.assert_produces_warning(FutureWarning, match=msg2):
+            result = algos.value_counts(np.array([1, 1.0]), bins=1)
+        assert len(result) == 1
+
+        with tm.assert_produces_warning(FutureWarning, match=msg2):
+            result = algos.value_counts(Series([1, 1.0, "1"]))  # object
+        assert len(result) == 2
+
+        msg = "bins argument only works with numeric data"
+        with pytest.raises(TypeError, match=msg):
+            with tm.assert_produces_warning(FutureWarning, match=msg2):
+                algos.value_counts(np.array(["1", 1], dtype=object), bins=1)
+
+    def test_value_counts_nat(self):
+        td = Series([np.timedelta64(10000), NaT], dtype="timedelta64[ns]")
+        dt = to_datetime(["NaT", "2014-01-01"])
+
+        msg = "pandas.value_counts is deprecated"
+
+        for ser in [td, dt]:
+            with tm.assert_produces_warning(FutureWarning, match=msg):
+                vc = algos.value_counts(ser)
+                vc_with_na = algos.value_counts(ser, dropna=False)
+            assert len(vc) == 1
+            assert len(vc_with_na) == 2
+
+        exp_dt = Series({Timestamp("2014-01-01 00:00:00"): 1}, name="count")
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result_dt = algos.value_counts(dt)
+        tm.assert_series_equal(result_dt, exp_dt)
+
+        exp_td = Series({np.timedelta64(10000): 1}, name="count")
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result_td = algos.value_counts(td)
+        tm.assert_series_equal(result_td, exp_td)
+
+    @pytest.mark.parametrize("dtype", [object, "M8[us]"])
+    def test_value_counts_datetime_outofbounds(self, dtype):
+        # GH 13663
+        ser = Series(
+            [
+                datetime(3000, 1, 1),
+                datetime(5000, 1, 1),
+                datetime(5000, 1, 1),
+                datetime(6000, 1, 1),
+                datetime(3000, 1, 1),
+                datetime(3000, 1, 1),
+            ],
+            dtype=dtype,
+        )
+        res = ser.value_counts()
+
+        exp_index = Index(
+            [datetime(3000, 1, 1), datetime(5000, 1, 1), datetime(6000, 1, 1)],
+            dtype=dtype,
+        )
+        exp = Series([3, 2, 1], index=exp_index, name="count")
+        tm.assert_series_equal(res, exp)
+
+    def test_categorical(self):
+        s = Series(Categorical(list("aaabbc")))
+        result = s.value_counts()
+        expected = Series(
+            [3, 2, 1], index=CategoricalIndex(["a", "b", "c"]), name="count"
+        )
+
+        tm.assert_series_equal(result, expected, check_index_type=True)
+
+        # preserve order?
+        s = s.cat.as_ordered()
+        result = s.value_counts()
+        expected.index = expected.index.as_ordered()
+        tm.assert_series_equal(result, expected, check_index_type=True)
+
+    def test_categorical_nans(self):
+        s = Series(Categorical(list("aaaaabbbcc")))  # 4,3,2,1 (nan)
+        s.iloc[1] = np.nan
+        result = s.value_counts()
+        expected = Series(
+            [4, 3, 2],
+            index=CategoricalIndex(["a", "b", "c"], categories=["a", "b", "c"]),
+            name="count",
+        )
+        tm.assert_series_equal(result, expected, check_index_type=True)
+        result = s.value_counts(dropna=False)
+        expected = Series(
+            [4, 3, 2, 1], index=CategoricalIndex(["a", "b", "c", np.nan]), name="count"
+        )
+        tm.assert_series_equal(result, expected, check_index_type=True)
+
+        # out of order
+        s = Series(
+            Categorical(list("aaaaabbbcc"), ordered=True, categories=["b", "a", "c"])
+        )
+        s.iloc[1] = np.nan
+        result = s.value_counts()
+        expected = Series(
+            [4, 3, 2],
+            index=CategoricalIndex(
+                ["a", "b", "c"],
+                categories=["b", "a", "c"],
+                ordered=True,
+            ),
+            name="count",
+        )
+        tm.assert_series_equal(result, expected, check_index_type=True)
+
+        result = s.value_counts(dropna=False)
+        expected = Series(
+            [4, 3, 2, 1],
+            index=CategoricalIndex(
+                ["a", "b", "c", np.nan], categories=["b", "a", "c"], ordered=True
+            ),
+            name="count",
+        )
+        tm.assert_series_equal(result, expected, check_index_type=True)
+
+    def test_categorical_zeroes(self):
+        # keep the `d` category with 0
+        s = Series(Categorical(list("bbbaac"), categories=list("abcd"), ordered=True))
+        result = s.value_counts()
+        expected = Series(
+            [3, 2, 1, 0],
+            index=Categorical(
+                ["b", "a", "c", "d"], categories=list("abcd"), ordered=True
+            ),
+            name="count",
+        )
+        tm.assert_series_equal(result, expected, check_index_type=True)
+
+    def test_value_counts_dropna(self):
+        # https://github.com/pandas-dev/pandas/issues/9443#issuecomment-73719328
+
+        tm.assert_series_equal(
+            Series([True, True, False]).value_counts(dropna=True),
+            Series([2, 1], index=[True, False], name="count"),
+        )
+        tm.assert_series_equal(
+            Series([True, True, False]).value_counts(dropna=False),
+            Series([2, 1], index=[True, False], name="count"),
+        )
+
+        tm.assert_series_equal(
+            Series([True] * 3 + [False] * 2 + [None] * 5).value_counts(dropna=True),
+            Series([3, 2], index=Index([True, False], dtype=object), name="count"),
+        )
+        tm.assert_series_equal(
+            Series([True] * 5 + [False] * 3 + [None] * 2).value_counts(dropna=False),
+            Series([5, 3, 2], index=[True, False, None], name="count"),
+        )
+        tm.assert_series_equal(
+            Series([10.3, 5.0, 5.0]).value_counts(dropna=True),
+            Series([2, 1], index=[5.0, 10.3], name="count"),
+        )
+        tm.assert_series_equal(
+            Series([10.3, 5.0, 5.0]).value_counts(dropna=False),
+            Series([2, 1], index=[5.0, 10.3], name="count"),
+        )
+
+        tm.assert_series_equal(
+            Series([10.3, 5.0, 5.0, None]).value_counts(dropna=True),
+            Series([2, 1], index=[5.0, 10.3], name="count"),
+        )
+
+        result = Series([10.3, 10.3, 5.0, 5.0, 5.0, None]).value_counts(dropna=False)
+        expected = Series([3, 2, 1], index=[5.0, 10.3, None], name="count")
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype", (np.float64, object, "M8[ns]"))
+    def test_value_counts_normalized(self, dtype):
+        # GH12558
+        s = Series([1] * 2 + [2] * 3 + [np.nan] * 5)
+        s_typed = s.astype(dtype)
+        result = s_typed.value_counts(normalize=True, dropna=False)
+        expected = Series(
+            [0.5, 0.3, 0.2],
+            index=Series([np.nan, 2.0, 1.0], dtype=dtype),
+            name="proportion",
+        )
+        tm.assert_series_equal(result, expected)
+
+        result = s_typed.value_counts(normalize=True, dropna=True)
+        expected = Series(
+            [0.6, 0.4], index=Series([2.0, 1.0], dtype=dtype), name="proportion"
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_value_counts_uint64(self):
+        arr = np.array([2**63], dtype=np.uint64)
+        expected = Series([1], index=[2**63], name="count")
+        msg = "pandas.value_counts is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = algos.value_counts(arr)
+
+        tm.assert_series_equal(result, expected)
+
+        arr = np.array([-1, 2**63], dtype=object)
+        expected = Series([1, 1], index=[-1, 2**63], name="count")
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = algos.value_counts(arr)
+
+        tm.assert_series_equal(result, expected)
+
+    def test_value_counts_series(self):
+        # GH#54857
+        values = np.array([3, 1, 2, 3, 4, np.nan])
+        result = Series(values).value_counts(bins=3)
+        expected = Series(
+            [2, 2, 1],
+            index=IntervalIndex.from_tuples(
+                [(0.996, 2.0), (2.0, 3.0), (3.0, 4.0)], dtype="interval[float64, right]"
+            ),
+            name="count",
+        )
+        tm.assert_series_equal(result, expected)
+
+
+class TestDuplicated:
+    def test_duplicated_with_nas(self):
+        keys = np.array([0, 1, np.nan, 0, 2, np.nan], dtype=object)
+
+        result = algos.duplicated(keys)
+        expected = np.array([False, False, False, True, False, True])
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = algos.duplicated(keys, keep="first")
+        expected = np.array([False, False, False, True, False, True])
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = algos.duplicated(keys, keep="last")
+        expected = np.array([True, False, True, False, False, False])
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = algos.duplicated(keys, keep=False)
+        expected = np.array([True, False, True, True, False, True])
+        tm.assert_numpy_array_equal(result, expected)
+
+        keys = np.empty(8, dtype=object)
+        for i, t in enumerate(
+            zip([0, 0, np.nan, np.nan] * 2, [0, np.nan, 0, np.nan] * 2)
+        ):
+            keys[i] = t
+
+        result = algos.duplicated(keys)
+        falses = [False] * 4
+        trues = [True] * 4
+        expected = np.array(falses + trues)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = algos.duplicated(keys, keep="last")
+        expected = np.array(trues + falses)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = algos.duplicated(keys, keep=False)
+        expected = np.array(trues + trues)
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "case",
+        [
+            np.array([1, 2, 1, 5, 3, 2, 4, 1, 5, 6]),
+            np.array([1.1, 2.2, 1.1, np.nan, 3.3, 2.2, 4.4, 1.1, np.nan, 6.6]),
+            np.array(
+                [
+                    1 + 1j,
+                    2 + 2j,
+                    1 + 1j,
+                    5 + 5j,
+                    3 + 3j,
+                    2 + 2j,
+                    4 + 4j,
+                    1 + 1j,
+                    5 + 5j,
+                    6 + 6j,
+                ]
+            ),
+            np.array(["a", "b", "a", "e", "c", "b", "d", "a", "e", "f"], dtype=object),
+            np.array(
+                [1, 2**63, 1, 3**5, 10, 2**63, 39, 1, 3**5, 7], dtype=np.uint64
+            ),
+        ],
+    )
+    def test_numeric_object_likes(self, case):
+        exp_first = np.array(
+            [False, False, True, False, False, True, False, True, True, False]
+        )
+        exp_last = np.array(
+            [True, True, True, True, False, False, False, False, False, False]
+        )
+        exp_false = exp_first | exp_last
+
+        res_first = algos.duplicated(case, keep="first")
+        tm.assert_numpy_array_equal(res_first, exp_first)
+
+        res_last = algos.duplicated(case, keep="last")
+        tm.assert_numpy_array_equal(res_last, exp_last)
+
+        res_false = algos.duplicated(case, keep=False)
+        tm.assert_numpy_array_equal(res_false, exp_false)
+
+        # index
+        for idx in [Index(case), Index(case, dtype="category")]:
+            res_first = idx.duplicated(keep="first")
+            tm.assert_numpy_array_equal(res_first, exp_first)
+
+            res_last = idx.duplicated(keep="last")
+            tm.assert_numpy_array_equal(res_last, exp_last)
+
+            res_false = idx.duplicated(keep=False)
+            tm.assert_numpy_array_equal(res_false, exp_false)
+
+        # series
+        for s in [Series(case), Series(case, dtype="category")]:
+            res_first = s.duplicated(keep="first")
+            tm.assert_series_equal(res_first, Series(exp_first))
+
+            res_last = s.duplicated(keep="last")
+            tm.assert_series_equal(res_last, Series(exp_last))
+
+            res_false = s.duplicated(keep=False)
+            tm.assert_series_equal(res_false, Series(exp_false))
+
+    def test_datetime_likes(self):
+        dt = [
+            "2011-01-01",
+            "2011-01-02",
+            "2011-01-01",
+            "NaT",
+            "2011-01-03",
+            "2011-01-02",
+            "2011-01-04",
+            "2011-01-01",
+            "NaT",
+            "2011-01-06",
+        ]
+        td = [
+            "1 days",
+            "2 days",
+            "1 days",
+            "NaT",
+            "3 days",
+            "2 days",
+            "4 days",
+            "1 days",
+            "NaT",
+            "6 days",
+        ]
+
+        cases = [
+            np.array([Timestamp(d) for d in dt]),
+            np.array([Timestamp(d, tz="US/Eastern") for d in dt]),
+            np.array([Period(d, freq="D") for d in dt]),
+            np.array([np.datetime64(d) for d in dt]),
+            np.array([Timedelta(d) for d in td]),
+        ]
+
+        exp_first = np.array(
+            [False, False, True, False, False, True, False, True, True, False]
+        )
+        exp_last = np.array(
+            [True, True, True, True, False, False, False, False, False, False]
+        )
+        exp_false = exp_first | exp_last
+
+        for case in cases:
+            res_first = algos.duplicated(case, keep="first")
+            tm.assert_numpy_array_equal(res_first, exp_first)
+
+            res_last = algos.duplicated(case, keep="last")
+            tm.assert_numpy_array_equal(res_last, exp_last)
+
+            res_false = algos.duplicated(case, keep=False)
+            tm.assert_numpy_array_equal(res_false, exp_false)
+
+            # index
+            for idx in [
+                Index(case),
+                Index(case, dtype="category"),
+                Index(case, dtype=object),
+            ]:
+                res_first = idx.duplicated(keep="first")
+                tm.assert_numpy_array_equal(res_first, exp_first)
+
+                res_last = idx.duplicated(keep="last")
+                tm.assert_numpy_array_equal(res_last, exp_last)
+
+                res_false = idx.duplicated(keep=False)
+                tm.assert_numpy_array_equal(res_false, exp_false)
+
+            # series
+            for s in [
+                Series(case),
+                Series(case, dtype="category"),
+                Series(case, dtype=object),
+            ]:
+                res_first = s.duplicated(keep="first")
+                tm.assert_series_equal(res_first, Series(exp_first))
+
+                res_last = s.duplicated(keep="last")
+                tm.assert_series_equal(res_last, Series(exp_last))
+
+                res_false = s.duplicated(keep=False)
+                tm.assert_series_equal(res_false, Series(exp_false))
+
+    @pytest.mark.parametrize("case", [Index([1, 2, 3]), pd.RangeIndex(0, 3)])
+    def test_unique_index(self, case):
+        assert case.is_unique is True
+        tm.assert_numpy_array_equal(case.duplicated(), np.array([False, False, False]))
+
+    @pytest.mark.parametrize(
+        "arr, uniques",
+        [
+            (
+                [(0, 0), (0, 1), (1, 0), (1, 1), (0, 0), (0, 1), (1, 0), (1, 1)],
+                [(0, 0), (0, 1), (1, 0), (1, 1)],
+            ),
+            (
+                [("b", "c"), ("a", "b"), ("a", "b"), ("b", "c")],
+                [("b", "c"), ("a", "b")],
+            ),
+            ([("a", 1), ("b", 2), ("a", 3), ("a", 1)], [("a", 1), ("b", 2), ("a", 3)]),
+        ],
+    )
+    def test_unique_tuples(self, arr, uniques):
+        # https://github.com/pandas-dev/pandas/issues/16519
+        expected = np.empty(len(uniques), dtype=object)
+        expected[:] = uniques
+
+        msg = "unique with argument that is not not a Series"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = pd.unique(arr)
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "array,expected",
+        [
+            (
+                [1 + 1j, 0, 1, 1j, 1 + 2j, 1 + 2j],
+                # Should return a complex dtype in the future
+                np.array([(1 + 1j), 0j, (1 + 0j), 1j, (1 + 2j)], dtype=object),
+            )
+        ],
+    )
+    def test_unique_complex_numbers(self, array, expected):
+        # GH 17927
+        msg = "unique with argument that is not not a Series"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = pd.unique(array)
+        tm.assert_numpy_array_equal(result, expected)
+
+
+class TestHashTable:
+    @pytest.mark.parametrize(
+        "htable, data",
+        [
+            (ht.PyObjectHashTable, [f"foo_{i}" for i in range(1000)]),
+            (ht.StringHashTable, [f"foo_{i}" for i in range(1000)]),
+            (ht.Float64HashTable, np.arange(1000, dtype=np.float64)),
+            (ht.Int64HashTable, np.arange(1000, dtype=np.int64)),
+            (ht.UInt64HashTable, np.arange(1000, dtype=np.uint64)),
+        ],
+    )
+    def test_hashtable_unique(self, htable, data, writable):
+        # output of maker has guaranteed unique elements
+        s = Series(data)
+        if htable == ht.Float64HashTable:
+            # add NaN for float column
+            s.loc[500] = np.nan
+        elif htable == ht.PyObjectHashTable:
+            # use different NaN types for object column
+            s.loc[500:502] = [np.nan, None, NaT]
+
+        # create duplicated selection
+        s_duplicated = s.sample(frac=3, replace=True).reset_index(drop=True)
+        s_duplicated.values.setflags(write=writable)
+
+        # drop_duplicates has own cython code (hash_table_func_helper.pxi)
+        # and is tested separately; keeps first occurrence like ht.unique()
+        expected_unique = s_duplicated.drop_duplicates(keep="first").values
+        result_unique = htable().unique(s_duplicated.values)
+        tm.assert_numpy_array_equal(result_unique, expected_unique)
+
+        # test return_inverse=True
+        # reconstruction can only succeed if the inverse is correct
+        result_unique, result_inverse = htable().unique(
+            s_duplicated.values, return_inverse=True
+        )
+        tm.assert_numpy_array_equal(result_unique, expected_unique)
+        reconstr = result_unique[result_inverse]
+        tm.assert_numpy_array_equal(reconstr, s_duplicated.values)
+
+    @pytest.mark.parametrize(
+        "htable, data",
+        [
+            (ht.PyObjectHashTable, [f"foo_{i}" for i in range(1000)]),
+            (ht.StringHashTable, [f"foo_{i}" for i in range(1000)]),
+            (ht.Float64HashTable, np.arange(1000, dtype=np.float64)),
+            (ht.Int64HashTable, np.arange(1000, dtype=np.int64)),
+            (ht.UInt64HashTable, np.arange(1000, dtype=np.uint64)),
+        ],
+    )
+    def test_hashtable_factorize(self, htable, writable, data):
+        # output of maker has guaranteed unique elements
+        s = Series(data)
+        if htable == ht.Float64HashTable:
+            # add NaN for float column
+            s.loc[500] = np.nan
+        elif htable == ht.PyObjectHashTable:
+            # use different NaN types for object column
+            s.loc[500:502] = [np.nan, None, NaT]
+
+        # create duplicated selection
+        s_duplicated = s.sample(frac=3, replace=True).reset_index(drop=True)
+        s_duplicated.values.setflags(write=writable)
+        na_mask = s_duplicated.isna().values
+
+        result_unique, result_inverse = htable().factorize(s_duplicated.values)
+
+        # drop_duplicates has own cython code (hash_table_func_helper.pxi)
+        # and is tested separately; keeps first occurrence like ht.factorize()
+        # since factorize removes all NaNs, we do the same here
+        expected_unique = s_duplicated.dropna().drop_duplicates().values
+        tm.assert_numpy_array_equal(result_unique, expected_unique)
+
+        # reconstruction can only succeed if the inverse is correct. Since
+        # factorize removes the NaNs, those have to be excluded here as well
+        result_reconstruct = result_unique[result_inverse[~na_mask]]
+        expected_reconstruct = s_duplicated.dropna().values
+        tm.assert_numpy_array_equal(result_reconstruct, expected_reconstruct)
+
+
+class TestRank:
+    @pytest.mark.parametrize(
+        "arr",
+        [
+            [np.nan, np.nan, 5.0, 5.0, 5.0, np.nan, 1, 2, 3, np.nan],
+            [4.0, np.nan, 5.0, 5.0, 5.0, np.nan, 1, 2, 4.0, np.nan],
+        ],
+    )
+    def test_scipy_compat(self, arr):
+        sp_stats = pytest.importorskip("scipy.stats")
+
+        arr = np.array(arr)
+
+        mask = ~np.isfinite(arr)
+        arr = arr.copy()
+        result = libalgos.rank_1d(arr)
+        arr[mask] = np.inf
+        exp = sp_stats.rankdata(arr)
+        exp[mask] = np.nan
+        tm.assert_almost_equal(result, exp)
+
+    @pytest.mark.parametrize("dtype", np.typecodes["AllInteger"])
+    def test_basic(self, writable, dtype):
+        exp = np.array([1, 2], dtype=np.float64)
+
+        data = np.array([1, 100], dtype=dtype)
+        data.setflags(write=writable)
+        ser = Series(data)
+        result = algos.rank(ser)
+        tm.assert_numpy_array_equal(result, exp)
+
+    @pytest.mark.parametrize("dtype", [np.float64, np.uint64])
+    def test_uint64_overflow(self, dtype):
+        exp = np.array([1, 2], dtype=np.float64)
+
+        s = Series([1, 2**63], dtype=dtype)
+        tm.assert_numpy_array_equal(algos.rank(s), exp)
+
+    def test_too_many_ndims(self):
+        arr = np.array([[[1, 2, 3], [4, 5, 6], [7, 8, 9]]])
+        msg = "Array with ndim > 2 are not supported"
+
+        with pytest.raises(TypeError, match=msg):
+            algos.rank(arr)
+
+    @pytest.mark.single_cpu
+    def test_pct_max_many_rows(self):
+        # GH 18271
+        values = np.arange(2**24 + 1)
+        result = algos.rank(values, pct=True).max()
+        assert result == 1
+
+        values = np.arange(2**25 + 2).reshape(2**24 + 1, 2)
+        result = algos.rank(values, pct=True).max()
+        assert result == 1
+
+
+class TestMode:
+    def test_no_mode(self):
+        exp = Series([], dtype=np.float64, index=Index([], dtype=int))
+        tm.assert_numpy_array_equal(algos.mode(np.array([])), exp.values)
+
+    @pytest.mark.parametrize("dt", np.typecodes["AllInteger"] + np.typecodes["Float"])
+    def test_mode_single(self, dt):
+        # GH 15714
+        exp_single = [1]
+        data_single = [1]
+
+        exp_multi = [1]
+        data_multi = [1, 1]
+
+        ser = Series(data_single, dtype=dt)
+        exp = Series(exp_single, dtype=dt)
+        tm.assert_numpy_array_equal(algos.mode(ser.values), exp.values)
+        tm.assert_series_equal(ser.mode(), exp)
+
+        ser = Series(data_multi, dtype=dt)
+        exp = Series(exp_multi, dtype=dt)
+        tm.assert_numpy_array_equal(algos.mode(ser.values), exp.values)
+        tm.assert_series_equal(ser.mode(), exp)
+
+    def test_mode_obj_int(self):
+        exp = Series([1], dtype=int)
+        tm.assert_numpy_array_equal(algos.mode(exp.values), exp.values)
+
+        exp = Series(["a", "b", "c"], dtype=object)
+        tm.assert_numpy_array_equal(algos.mode(exp.values), exp.values)
+
+    @pytest.mark.parametrize("dt", np.typecodes["AllInteger"] + np.typecodes["Float"])
+    def test_number_mode(self, dt):
+        exp_single = [1]
+        data_single = [1] * 5 + [2] * 3
+
+        exp_multi = [1, 3]
+        data_multi = [1] * 5 + [2] * 3 + [3] * 5
+
+        ser = Series(data_single, dtype=dt)
+        exp = Series(exp_single, dtype=dt)
+        tm.assert_numpy_array_equal(algos.mode(ser.values), exp.values)
+        tm.assert_series_equal(ser.mode(), exp)
+
+        ser = Series(data_multi, dtype=dt)
+        exp = Series(exp_multi, dtype=dt)
+        tm.assert_numpy_array_equal(algos.mode(ser.values), exp.values)
+        tm.assert_series_equal(ser.mode(), exp)
+
+    def test_strobj_mode(self):
+        exp = ["b"]
+        data = ["a"] * 2 + ["b"] * 3
+
+        ser = Series(data, dtype="c")
+        exp = Series(exp, dtype="c")
+        tm.assert_numpy_array_equal(algos.mode(ser.values), exp.values)
+        tm.assert_series_equal(ser.mode(), exp)
+
+    @pytest.mark.parametrize("dt", [str, object])
+    def test_strobj_multi_char(self, dt):
+        exp = ["bar"]
+        data = ["foo"] * 2 + ["bar"] * 3
+
+        ser = Series(data, dtype=dt)
+        exp = Series(exp, dtype=dt)
+        tm.assert_numpy_array_equal(algos.mode(ser.values), exp.values)
+        tm.assert_series_equal(ser.mode(), exp)
+
+    def test_datelike_mode(self):
+        exp = Series(["1900-05-03", "2011-01-03", "2013-01-02"], dtype="M8[ns]")
+        ser = Series(["2011-01-03", "2013-01-02", "1900-05-03"], dtype="M8[ns]")
+        tm.assert_extension_array_equal(algos.mode(ser.values), exp._values)
+        tm.assert_series_equal(ser.mode(), exp)
+
+        exp = Series(["2011-01-03", "2013-01-02"], dtype="M8[ns]")
+        ser = Series(
+            ["2011-01-03", "2013-01-02", "1900-05-03", "2011-01-03", "2013-01-02"],
+            dtype="M8[ns]",
+        )
+        tm.assert_extension_array_equal(algos.mode(ser.values), exp._values)
+        tm.assert_series_equal(ser.mode(), exp)
+
+    def test_timedelta_mode(self):
+        exp = Series(["-1 days", "0 days", "1 days"], dtype="timedelta64[ns]")
+        ser = Series(["1 days", "-1 days", "0 days"], dtype="timedelta64[ns]")
+        tm.assert_extension_array_equal(algos.mode(ser.values), exp._values)
+        tm.assert_series_equal(ser.mode(), exp)
+
+        exp = Series(["2 min", "1 day"], dtype="timedelta64[ns]")
+        ser = Series(
+            ["1 day", "1 day", "-1 day", "-1 day 2 min", "2 min", "2 min"],
+            dtype="timedelta64[ns]",
+        )
+        tm.assert_extension_array_equal(algos.mode(ser.values), exp._values)
+        tm.assert_series_equal(ser.mode(), exp)
+
+    def test_mixed_dtype(self):
+        exp = Series(["foo"], dtype=object)
+        ser = Series([1, "foo", "foo"])
+        tm.assert_numpy_array_equal(algos.mode(ser.values), exp.values)
+        tm.assert_series_equal(ser.mode(), exp)
+
+    def test_uint64_overflow(self):
+        exp = Series([2**63], dtype=np.uint64)
+        ser = Series([1, 2**63, 2**63], dtype=np.uint64)
+        tm.assert_numpy_array_equal(algos.mode(ser.values), exp.values)
+        tm.assert_series_equal(ser.mode(), exp)
+
+        exp = Series([1, 2**63], dtype=np.uint64)
+        ser = Series([1, 2**63], dtype=np.uint64)
+        tm.assert_numpy_array_equal(algos.mode(ser.values), exp.values)
+        tm.assert_series_equal(ser.mode(), exp)
+
+    def test_categorical(self):
+        c = Categorical([1, 2])
+        exp = c
+        res = Series(c).mode()._values
+        tm.assert_categorical_equal(res, exp)
+
+        c = Categorical([1, "a", "a"])
+        exp = Categorical(["a"], categories=[1, "a"])
+        res = Series(c).mode()._values
+        tm.assert_categorical_equal(res, exp)
+
+        c = Categorical([1, 1, 2, 3, 3])
+        exp = Categorical([1, 3], categories=[1, 2, 3])
+        res = Series(c).mode()._values
+        tm.assert_categorical_equal(res, exp)
+
+    def test_index(self):
+        idx = Index([1, 2, 3])
+        exp = Series([1, 2, 3], dtype=np.int64)
+        tm.assert_numpy_array_equal(algos.mode(idx), exp.values)
+
+        idx = Index([1, "a", "a"])
+        exp = Series(["a"], dtype=object)
+        tm.assert_numpy_array_equal(algos.mode(idx), exp.values)
+
+        idx = Index([1, 1, 2, 3, 3])
+        exp = Series([1, 3], dtype=np.int64)
+        tm.assert_numpy_array_equal(algos.mode(idx), exp.values)
+
+        idx = Index(
+            ["1 day", "1 day", "-1 day", "-1 day 2 min", "2 min", "2 min"],
+            dtype="timedelta64[ns]",
+        )
+        with pytest.raises(AttributeError, match="TimedeltaIndex"):
+            # algos.mode expects Arraylike, does *not* unwrap TimedeltaIndex
+            algos.mode(idx)
+
+    def test_ser_mode_with_name(self):
+        # GH 46737
+        ser = Series([1, 1, 3], name="foo")
+        result = ser.mode()
+        expected = Series([1], name="foo")
+        tm.assert_series_equal(result, expected)
+
+
+class TestDiff:
+    @pytest.mark.parametrize("dtype", ["M8[ns]", "m8[ns]"])
+    def test_diff_datetimelike_nat(self, dtype):
+        # NaT - NaT is NaT, not 0
+        arr = np.arange(12).astype(np.int64).view(dtype).reshape(3, 4)
+        arr[:, 2] = arr.dtype.type("NaT", "ns")
+        result = algos.diff(arr, 1, axis=0)
+
+        expected = np.ones(arr.shape, dtype="timedelta64[ns]") * 4
+        expected[:, 2] = np.timedelta64("NaT", "ns")
+        expected[0, :] = np.timedelta64("NaT", "ns")
+
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = algos.diff(arr.T, 1, axis=1)
+        tm.assert_numpy_array_equal(result, expected.T)
+
+    def test_diff_ea_axis(self):
+        dta = date_range("2016-01-01", periods=3, tz="US/Pacific")._data
+
+        msg = "cannot diff DatetimeArray on axis=1"
+        with pytest.raises(ValueError, match=msg):
+            algos.diff(dta, 1, axis=1)
+
+    @pytest.mark.parametrize("dtype", ["int8", "int16"])
+    def test_diff_low_precision_int(self, dtype):
+        arr = np.array([0, 1, 1, 0, 0], dtype=dtype)
+        result = algos.diff(arr, 1)
+        expected = np.array([np.nan, 1, 0, -1, 0], dtype="float32")
+        tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("op", [np.array, pd.array])
+def test_union_with_duplicates(op):
+    # GH#36289
+    lvals = op([3, 1, 3, 4])
+    rvals = op([2, 3, 1, 1])
+    expected = op([3, 3, 1, 1, 4, 2])
+    if isinstance(expected, np.ndarray):
+        result = algos.union_with_duplicates(lvals, rvals)
+        tm.assert_numpy_array_equal(result, expected)
+    else:
+        result = algos.union_with_duplicates(lvals, rvals)
+        tm.assert_extension_array_equal(result, expected)

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas/tests/test_common.py

@@ -0,0 +1,267 @@
+import collections
+from functools import partial
+import string
+import subprocess
+import sys
+import textwrap
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import Series
+import pandas._testing as tm
+from pandas.core import ops
+import pandas.core.common as com
+from pandas.util.version import Version
+
+
+def test_get_callable_name():
+    getname = com.get_callable_name
+
+    def fn(x):
+        return x
+
+    lambda_ = lambda x: x
+    part1 = partial(fn)
+    part2 = partial(part1)
+
+    class somecall:
+        def __call__(self):
+            # This shouldn't actually get called below; somecall.__init__
+            #  should.
+            raise NotImplementedError
+
+    assert getname(fn) == "fn"
+    assert getname(lambda_)
+    assert getname(part1) == "fn"
+    assert getname(part2) == "fn"
+    assert getname(somecall()) == "somecall"
+    assert getname(1) is None
+
+
+def test_any_none():
+    assert com.any_none(1, 2, 3, None)
+    assert not com.any_none(1, 2, 3, 4)
+
+
+def test_all_not_none():
+    assert com.all_not_none(1, 2, 3, 4)
+    assert not com.all_not_none(1, 2, 3, None)
+    assert not com.all_not_none(None, None, None, None)
+
+
+def test_random_state():
+    # Check with seed
+    state = com.random_state(5)
+    assert state.uniform() == np.random.RandomState(5).uniform()
+
+    # Check with random state object
+    state2 = np.random.RandomState(10)
+    assert com.random_state(state2).uniform() == np.random.RandomState(10).uniform()
+
+    # check with no arg random state
+    assert com.random_state() is np.random
+
+    # check array-like
+    # GH32503
+    state_arr_like = np.random.default_rng(None).integers(
+        0, 2**31, size=624, dtype="uint32"
+    )
+    assert (
+        com.random_state(state_arr_like).uniform()
+        == np.random.RandomState(state_arr_like).uniform()
+    )
+
+    # Check BitGenerators
+    # GH32503
+    assert (
+        com.random_state(np.random.MT19937(3)).uniform()
+        == np.random.RandomState(np.random.MT19937(3)).uniform()
+    )
+    assert (
+        com.random_state(np.random.PCG64(11)).uniform()
+        == np.random.RandomState(np.random.PCG64(11)).uniform()
+    )
+
+    # Error for floats or strings
+    msg = (
+        "random_state must be an integer, array-like, a BitGenerator, Generator, "
+        "a numpy RandomState, or None"
+    )
+    with pytest.raises(ValueError, match=msg):
+        com.random_state("test")
+
+    with pytest.raises(ValueError, match=msg):
+        com.random_state(5.5)
+
+
+@pytest.mark.parametrize(
+    "left, right, expected",
+    [
+        (Series([1], name="x"), Series([2], name="x"), "x"),
+        (Series([1], name="x"), Series([2], name="y"), None),
+        (Series([1]), Series([2], name="x"), None),
+        (Series([1], name="x"), Series([2]), None),
+        (Series([1], name="x"), [2], "x"),
+        ([1], Series([2], name="y"), "y"),
+        # matching NAs
+        (Series([1], name=np.nan), pd.Index([], name=np.nan), np.nan),
+        (Series([1], name=np.nan), pd.Index([], name=pd.NaT), None),
+        (Series([1], name=pd.NA), pd.Index([], name=pd.NA), pd.NA),
+        # tuple name GH#39757
+        (
+            Series([1], name=np.int64(1)),
+            pd.Index([], name=(np.int64(1), np.int64(2))),
+            None,
+        ),
+        (
+            Series([1], name=(np.int64(1), np.int64(2))),
+            pd.Index([], name=(np.int64(1), np.int64(2))),
+            (np.int64(1), np.int64(2)),
+        ),
+        pytest.param(
+            Series([1], name=(np.float64("nan"), np.int64(2))),
+            pd.Index([], name=(np.float64("nan"), np.int64(2))),
+            (np.float64("nan"), np.int64(2)),
+            marks=pytest.mark.xfail(
+                reason="Not checking for matching NAs inside tuples."
+            ),
+        ),
+    ],
+)
+def test_maybe_match_name(left, right, expected):
+    res = ops.common._maybe_match_name(left, right)
+    assert res is expected or res == expected
+
+
+def test_standardize_mapping():
+    # No uninitialized defaultdicts
+    msg = r"to_dict\(\) only accepts initialized defaultdicts"
+    with pytest.raises(TypeError, match=msg):
+        com.standardize_mapping(collections.defaultdict)
+
+    # No non-mapping subtypes, instance
+    msg = "unsupported type: <class 'list'>"
+    with pytest.raises(TypeError, match=msg):
+        com.standardize_mapping([])
+
+    # No non-mapping subtypes, class
+    with pytest.raises(TypeError, match=msg):
+        com.standardize_mapping(list)
+
+    fill = {"bad": "data"}
+    assert com.standardize_mapping(fill) == dict
+
+    # Convert instance to type
+    assert com.standardize_mapping({}) == dict
+
+    dd = collections.defaultdict(list)
+    assert isinstance(com.standardize_mapping(dd), partial)
+
+
+def test_git_version():
+    # GH 21295
+    git_version = pd.__git_version__
+    assert len(git_version) == 40
+    assert all(c in string.hexdigits for c in git_version)
+
+
+def test_version_tag():
+    version = Version(pd.__version__)
+    try:
+        version > Version("0.0.1")
+    except TypeError:
+        raise ValueError(
+            "No git tags exist, please sync tags between upstream and your repo"
+        )
+
+
+@pytest.mark.parametrize(
+    "obj", [(obj,) for obj in pd.__dict__.values() if callable(obj)]
+)
+def test_serializable(obj):
+    # GH 35611
+    unpickled = tm.round_trip_pickle(obj)
+    assert type(obj) == type(unpickled)
+
+
+class TestIsBoolIndexer:
+    def test_non_bool_array_with_na(self):
+        # in particular, this should not raise
+        arr = np.array(["A", "B", np.nan], dtype=object)
+        assert not com.is_bool_indexer(arr)
+
+    def test_list_subclass(self):
+        # GH#42433
+
+        class MyList(list):
+            pass
+
+        val = MyList(["a"])
+
+        assert not com.is_bool_indexer(val)
+
+        val = MyList([True])
+        assert com.is_bool_indexer(val)
+
+    def test_frozenlist(self):
+        # GH#42461
+        data = {"col1": [1, 2], "col2": [3, 4]}
+        df = pd.DataFrame(data=data)
+
+        frozen = df.index.names[1:]
+        assert not com.is_bool_indexer(frozen)
+
+        result = df[frozen]
+        expected = df[[]]
+        tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("with_exception", [True, False])
+def test_temp_setattr(with_exception):
+    # GH#45954
+    ser = Series(dtype=object)
+    ser.name = "first"
+    # Raise a ValueError in either case to satisfy pytest.raises
+    match = "Inside exception raised" if with_exception else "Outside exception raised"
+    with pytest.raises(ValueError, match=match):
+        with com.temp_setattr(ser, "name", "second"):
+            assert ser.name == "second"
+            if with_exception:
+                raise ValueError("Inside exception raised")
+        raise ValueError("Outside exception raised")
+    assert ser.name == "first"
+
+
+@pytest.mark.single_cpu
+def test_str_size():
+    # GH#21758
+    a = "a"
+    expected = sys.getsizeof(a)
+    pyexe = sys.executable.replace("\\", "/")
+    call = [
+        pyexe,
+        "-c",
+        "a='a';import sys;sys.getsizeof(a);import pandas;print(sys.getsizeof(a));",
+    ]
+    result = subprocess.check_output(call).decode()[-4:-1].strip("\n")
+    assert int(result) == int(expected)
+
+
+@pytest.mark.single_cpu
+def test_bz2_missing_import():
+    # Check whether bz2 missing import is handled correctly (issue #53857)
+    code = """
+        import sys
+        sys.modules['bz2'] = None
+        import pytest
+        import pandas as pd
+        from pandas.compat import get_bz2_file
+        msg = 'bz2 module not available.'
+        with pytest.raises(RuntimeError, match=msg):
+            get_bz2_file()
+    """
+    code = textwrap.dedent(code)
+    call = [sys.executable, "-c", code]
+    subprocess.check_output(call)

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas/tests/test_downstream.py

@@ -0,0 +1,362 @@
+"""
+Testing that we work in the downstream packages
+"""
+import array
+import subprocess
+import sys
+
+import numpy as np
+import pytest
+
+from pandas.errors import IntCastingNaNError
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    DatetimeIndex,
+    Series,
+    TimedeltaIndex,
+)
+import pandas._testing as tm
+from pandas.core.arrays import (
+    DatetimeArray,
+    TimedeltaArray,
+)
+
+
+@pytest.fixture
+def df():
+    return DataFrame({"A": [1, 2, 3]})
+
+
+def test_dask(df):
+    # dask sets "compute.use_numexpr" to False, so catch the current value
+    # and ensure to reset it afterwards to avoid impacting other tests
+    olduse = pd.get_option("compute.use_numexpr")
+
+    try:
+        pytest.importorskip("toolz")
+        dd = pytest.importorskip("dask.dataframe")
+
+        ddf = dd.from_pandas(df, npartitions=3)
+        assert ddf.A is not None
+        assert ddf.compute() is not None
+    finally:
+        pd.set_option("compute.use_numexpr", olduse)
+
+
+def test_dask_ufunc():
+    # dask sets "compute.use_numexpr" to False, so catch the current value
+    # and ensure to reset it afterwards to avoid impacting other tests
+    olduse = pd.get_option("compute.use_numexpr")
+
+    try:
+        da = pytest.importorskip("dask.array")
+        dd = pytest.importorskip("dask.dataframe")
+
+        s = Series([1.5, 2.3, 3.7, 4.0])
+        ds = dd.from_pandas(s, npartitions=2)
+
+        result = da.fix(ds).compute()
+        expected = np.fix(s)
+        tm.assert_series_equal(result, expected)
+    finally:
+        pd.set_option("compute.use_numexpr", olduse)
+
+
+def test_construct_dask_float_array_int_dtype_match_ndarray():
+    # GH#40110 make sure we treat a float-dtype dask array with the same
+    #  rules we would for an ndarray
+    dd = pytest.importorskip("dask.dataframe")
+
+    arr = np.array([1, 2.5, 3])
+    darr = dd.from_array(arr)
+
+    res = Series(darr)
+    expected = Series(arr)
+    tm.assert_series_equal(res, expected)
+
+    # GH#49599 in 2.0 we raise instead of silently ignoring the dtype
+    msg = "Trying to coerce float values to integers"
+    with pytest.raises(ValueError, match=msg):
+        Series(darr, dtype="i8")
+
+    msg = r"Cannot convert non-finite values \(NA or inf\) to integer"
+    arr[2] = np.nan
+    with pytest.raises(IntCastingNaNError, match=msg):
+        Series(darr, dtype="i8")
+    # which is the same as we get with a numpy input
+    with pytest.raises(IntCastingNaNError, match=msg):
+        Series(arr, dtype="i8")
+
+
+def test_xarray(df):
+    pytest.importorskip("xarray")
+
+    assert df.to_xarray() is not None
+
+
+def test_xarray_cftimeindex_nearest():
+    # https://github.com/pydata/xarray/issues/3751
+    cftime = pytest.importorskip("cftime")
+    xarray = pytest.importorskip("xarray")
+
+    times = xarray.cftime_range("0001", periods=2)
+    key = cftime.DatetimeGregorian(2000, 1, 1)
+    result = times.get_indexer([key], method="nearest")
+    expected = 1
+    assert result == expected
+
+
+@pytest.mark.single_cpu
+def test_oo_optimizable():
+    # GH 21071
+    subprocess.check_call([sys.executable, "-OO", "-c", "import pandas"])
+
+
+@pytest.mark.single_cpu
+def test_oo_optimized_datetime_index_unpickle():
+    # GH 42866
+    subprocess.check_call(
+        [
+            sys.executable,
+            "-OO",
+            "-c",
+            (
+                "import pandas as pd, pickle; "
+                "pickle.loads(pickle.dumps(pd.date_range('2021-01-01', periods=1)))"
+            ),
+        ]
+    )
+
+
+def test_statsmodels():
+    smf = pytest.importorskip("statsmodels.formula.api")
+
+    df = DataFrame(
+        {"Lottery": range(5), "Literacy": range(5), "Pop1831": range(100, 105)}
+    )
+    smf.ols("Lottery ~ Literacy + np.log(Pop1831)", data=df).fit()
+
+
+def test_scikit_learn():
+    pytest.importorskip("sklearn")
+    from sklearn import (
+        datasets,
+        svm,
+    )
+
+    digits = datasets.load_digits()
+    clf = svm.SVC(gamma=0.001, C=100.0)
+    clf.fit(digits.data[:-1], digits.target[:-1])
+    clf.predict(digits.data[-1:])
+
+
+def test_seaborn():
+    seaborn = pytest.importorskip("seaborn")
+    tips = DataFrame(
+        {"day": pd.date_range("2023", freq="D", periods=5), "total_bill": range(5)}
+    )
+    seaborn.stripplot(x="day", y="total_bill", data=tips)
+
+
+def test_pandas_datareader():
+    pytest.importorskip("pandas_datareader")
+
+
+@pytest.mark.filterwarnings("ignore:Passing a BlockManager:DeprecationWarning")
+def test_pyarrow(df):
+    pyarrow = pytest.importorskip("pyarrow")
+    table = pyarrow.Table.from_pandas(df)
+    result = table.to_pandas()
+    tm.assert_frame_equal(result, df)
+
+
+def test_yaml_dump(df):
+    # GH#42748
+    yaml = pytest.importorskip("yaml")
+
+    dumped = yaml.dump(df)
+
+    loaded = yaml.load(dumped, Loader=yaml.Loader)
+    tm.assert_frame_equal(df, loaded)
+
+    loaded2 = yaml.load(dumped, Loader=yaml.UnsafeLoader)
+    tm.assert_frame_equal(df, loaded2)
+
+
+@pytest.mark.single_cpu
+def test_missing_required_dependency():
+    # GH 23868
+    # To ensure proper isolation, we pass these flags
+    # -S : disable site-packages
+    # -s : disable user site-packages
+    # -E : disable PYTHON* env vars, especially PYTHONPATH
+    # https://github.com/MacPython/pandas-wheels/pull/50
+
+    pyexe = sys.executable.replace("\\", "/")
+
+    # We skip this test if pandas is installed as a site package. We first
+    # import the package normally and check the path to the module before
+    # executing the test which imports pandas with site packages disabled.
+    call = [pyexe, "-c", "import pandas;print(pandas.__file__)"]
+    output = subprocess.check_output(call).decode()
+    if "site-packages" in output:
+        pytest.skip("pandas installed as site package")
+
+    # This test will fail if pandas is installed as a site package. The flags
+    # prevent pandas being imported and the test will report Failed: DID NOT
+    # RAISE <class 'subprocess.CalledProcessError'>
+    call = [pyexe, "-sSE", "-c", "import pandas"]
+
+    msg = (
+        rf"Command '\['{pyexe}', '-sSE', '-c', 'import pandas'\]' "
+        "returned non-zero exit status 1."
+    )
+
+    with pytest.raises(subprocess.CalledProcessError, match=msg) as exc:
+        subprocess.check_output(call, stderr=subprocess.STDOUT)
+
+    output = exc.value.stdout.decode()
+    for name in ["numpy", "pytz", "dateutil"]:
+        assert name in output
+
+
+def test_frame_setitem_dask_array_into_new_col():
+    # GH#47128
+
+    # dask sets "compute.use_numexpr" to False, so catch the current value
+    # and ensure to reset it afterwards to avoid impacting other tests
+    olduse = pd.get_option("compute.use_numexpr")
+
+    try:
+        da = pytest.importorskip("dask.array")
+
+        dda = da.array([1, 2])
+        df = DataFrame({"a": ["a", "b"]})
+        df["b"] = dda
+        df["c"] = dda
+        df.loc[[False, True], "b"] = 100
+        result = df.loc[[1], :]
+        expected = DataFrame({"a": ["b"], "b": [100], "c": [2]}, index=[1])
+        tm.assert_frame_equal(result, expected)
+    finally:
+        pd.set_option("compute.use_numexpr", olduse)
+
+
+def test_pandas_priority():
+    # GH#48347
+
+    class MyClass:
+        __pandas_priority__ = 5000
+
+        def __radd__(self, other):
+            return self
+
+    left = MyClass()
+    right = Series(range(3))
+
+    assert right.__add__(left) is NotImplemented
+    assert right + left is left
+
+
+@pytest.fixture(
+    params=[
+        "memoryview",
+        "array",
+        pytest.param("dask", marks=td.skip_if_no("dask.array")),
+        pytest.param("xarray", marks=td.skip_if_no("xarray")),
+    ]
+)
+def array_likes(request):
+    """
+    Fixture giving a numpy array and a parametrized 'data' object, which can
+    be a memoryview, array, dask or xarray object created from the numpy array.
+    """
+    # GH#24539 recognize e.g xarray, dask, ...
+    arr = np.array([1, 2, 3], dtype=np.int64)
+
+    name = request.param
+    if name == "memoryview":
+        data = memoryview(arr)
+    elif name == "array":
+        data = array.array("i", arr)
+    elif name == "dask":
+        import dask.array
+
+        data = dask.array.array(arr)
+    elif name == "xarray":
+        import xarray as xr
+
+        data = xr.DataArray(arr)
+
+    return arr, data
+
+
+@pytest.mark.parametrize("dtype", ["M8[ns]", "m8[ns]"])
+def test_from_obscure_array(dtype, array_likes):
+    # GH#24539 recognize e.g xarray, dask, ...
+    # Note: we dont do this for PeriodArray bc _from_sequence won't accept
+    #  an array of integers
+    # TODO: could check with arraylike of Period objects
+    arr, data = array_likes
+
+    cls = {"M8[ns]": DatetimeArray, "m8[ns]": TimedeltaArray}[dtype]
+
+    depr_msg = f"{cls.__name__}.__init__ is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=depr_msg):
+        expected = cls(arr)
+    result = cls._from_sequence(data, dtype=dtype)
+    tm.assert_extension_array_equal(result, expected)
+
+    if not isinstance(data, memoryview):
+        # FIXME(GH#44431) these raise on memoryview and attempted fix
+        #  fails on py3.10
+        func = {"M8[ns]": pd.to_datetime, "m8[ns]": pd.to_timedelta}[dtype]
+        result = func(arr).array
+        expected = func(data).array
+        tm.assert_equal(result, expected)
+
+    # Let's check the Indexes while we're here
+    idx_cls = {"M8[ns]": DatetimeIndex, "m8[ns]": TimedeltaIndex}[dtype]
+    result = idx_cls(arr)
+    expected = idx_cls(data)
+    tm.assert_index_equal(result, expected)
+
+
+def test_dataframe_consortium() -> None:
+    """
+    Test some basic methods of the dataframe consortium standard.
+
+    Full testing is done at https://github.com/data-apis/dataframe-api-compat,
+    this is just to check that the entry point works as expected.
+    """
+    pytest.importorskip("dataframe_api_compat")
+    df_pd = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+    df = df_pd.__dataframe_consortium_standard__()
+    result_1 = df.get_column_names()
+    expected_1 = ["a", "b"]
+    assert result_1 == expected_1
+
+    ser = Series([1, 2, 3], name="a")
+    col = ser.__column_consortium_standard__()
+    assert col.name == "a"
+
+
+def test_xarray_coerce_unit():
+    # GH44053
+    xr = pytest.importorskip("xarray")
+
+    arr = xr.DataArray([1, 2, 3])
+    result = pd.to_datetime(arr, unit="ns")
+    expected = DatetimeIndex(
+        [
+            "1970-01-01 00:00:00.000000001",
+            "1970-01-01 00:00:00.000000002",
+            "1970-01-01 00:00:00.000000003",
+        ],
+        dtype="datetime64[ns]",
+        freq=None,
+    )
+    tm.assert_index_equal(result, expected)

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas/tests/test_errors.py

@@ -0,0 +1,112 @@
+import pytest
+
+from pandas.errors import (
+    AbstractMethodError,
+    UndefinedVariableError,
+)
+
+import pandas as pd
+
+
+@pytest.mark.parametrize(
+    "exc",
+    [
+        "AttributeConflictWarning",
+        "CSSWarning",
+        "CategoricalConversionWarning",
+        "ClosedFileError",
+        "DataError",
+        "DatabaseError",
+        "DtypeWarning",
+        "EmptyDataError",
+        "IncompatibilityWarning",
+        "IndexingError",
+        "InvalidColumnName",
+        "InvalidComparison",
+        "InvalidVersion",
+        "LossySetitemError",
+        "MergeError",
+        "NoBufferPresent",
+        "NumExprClobberingError",
+        "NumbaUtilError",
+        "OptionError",
+        "OutOfBoundsDatetime",
+        "ParserError",
+        "ParserWarning",
+        "PerformanceWarning",
+        "PossibleDataLossError",
+        "PossiblePrecisionLoss",
+        "PyperclipException",
+        "SettingWithCopyError",
+        "SettingWithCopyWarning",
+        "SpecificationError",
+        "UnsortedIndexError",
+        "UnsupportedFunctionCall",
+        "ValueLabelTypeMismatch",
+    ],
+)
+def test_exception_importable(exc):
+    from pandas import errors
+
+    err = getattr(errors, exc)
+    assert err is not None
+
+    # check that we can raise on them
+
+    msg = "^$"
+
+    with pytest.raises(err, match=msg):
+        raise err()
+
+
+def test_catch_oob():
+    from pandas import errors
+
+    msg = "Cannot cast 1500-01-01 00:00:00 to unit='ns' without overflow"
+    with pytest.raises(errors.OutOfBoundsDatetime, match=msg):
+        pd.Timestamp("15000101").as_unit("ns")
+
+
+@pytest.mark.parametrize(
+    "is_local",
+    [
+        True,
+        False,
+    ],
+)
+def test_catch_undefined_variable_error(is_local):
+    variable_name = "x"
+    if is_local:
+        msg = f"local variable '{variable_name}' is not defined"
+    else:
+        msg = f"name '{variable_name}' is not defined"
+
+    with pytest.raises(UndefinedVariableError, match=msg):
+        raise UndefinedVariableError(variable_name, is_local)
+
+
+class Foo:
+    @classmethod
+    def classmethod(cls):
+        raise AbstractMethodError(cls, methodtype="classmethod")
+
+    @property
+    def property(self):
+        raise AbstractMethodError(self, methodtype="property")
+
+    def method(self):
+        raise AbstractMethodError(self)
+
+
+def test_AbstractMethodError_classmethod():
+    xpr = "This classmethod must be defined in the concrete class Foo"
+    with pytest.raises(AbstractMethodError, match=xpr):
+        Foo.classmethod()
+
+    xpr = "This property must be defined in the concrete class Foo"
+    with pytest.raises(AbstractMethodError, match=xpr):
+        Foo().property
+
+    xpr = "This method must be defined in the concrete class Foo"
+    with pytest.raises(AbstractMethodError, match=xpr):
+        Foo().method()

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas/tests/test_expressions.py

@@ -0,0 +1,466 @@
+import operator
+import re
+
+import numpy as np
+import pytest
+
+from pandas import option_context
+import pandas._testing as tm
+from pandas.core.api import (
+    DataFrame,
+    Index,
+    Series,
+)
+from pandas.core.computation import expressions as expr
+
+
+@pytest.fixture
+def _frame():
+    return DataFrame(
+        np.random.default_rng(2).standard_normal((10001, 4)),
+        columns=list("ABCD"),
+        dtype="float64",
+    )
+
+
+@pytest.fixture
+def _frame2():
+    return DataFrame(
+        np.random.default_rng(2).standard_normal((100, 4)),
+        columns=list("ABCD"),
+        dtype="float64",
+    )
+
+
+@pytest.fixture
+def _mixed(_frame):
+    return DataFrame(
+        {
+            "A": _frame["A"].copy(),
+            "B": _frame["B"].astype("float32"),
+            "C": _frame["C"].astype("int64"),
+            "D": _frame["D"].astype("int32"),
+        }
+    )
+
+
+@pytest.fixture
+def _mixed2(_frame2):
+    return DataFrame(
+        {
+            "A": _frame2["A"].copy(),
+            "B": _frame2["B"].astype("float32"),
+            "C": _frame2["C"].astype("int64"),
+            "D": _frame2["D"].astype("int32"),
+        }
+    )
+
+
+@pytest.fixture
+def _integer():
+    return DataFrame(
+        np.random.default_rng(2).integers(1, 100, size=(10001, 4)),
+        columns=list("ABCD"),
+        dtype="int64",
+    )
+
+
+@pytest.fixture
+def _integer_integers(_integer):
+    # integers to get a case with zeros
+    return _integer * np.random.default_rng(2).integers(0, 2, size=np.shape(_integer))
+
+
+@pytest.fixture
+def _integer2():
+    return DataFrame(
+        np.random.default_rng(2).integers(1, 100, size=(101, 4)),
+        columns=list("ABCD"),
+        dtype="int64",
+    )
+
+
+@pytest.fixture
+def _array(_frame):
+    return _frame["A"].values.copy()
+
+
+@pytest.fixture
+def _array2(_frame2):
+    return _frame2["A"].values.copy()
+
+
+@pytest.fixture
+def _array_mixed(_mixed):
+    return _mixed["D"].values.copy()
+
+
+@pytest.fixture
+def _array_mixed2(_mixed2):
+    return _mixed2["D"].values.copy()
+
+
+@pytest.mark.skipif(not expr.USE_NUMEXPR, reason="not using numexpr")
+class TestExpressions:
+    @staticmethod
+    def call_op(df, other, flex: bool, opname: str):
+        if flex:
+            op = lambda x, y: getattr(x, opname)(y)
+            op.__name__ = opname
+        else:
+            op = getattr(operator, opname)
+
+        with option_context("compute.use_numexpr", False):
+            expected = op(df, other)
+
+        expr.get_test_result()
+
+        result = op(df, other)
+        return result, expected
+
+    @pytest.mark.parametrize(
+        "fixture",
+        [
+            "_integer",
+            "_integer2",
+            "_integer_integers",
+            "_frame",
+            "_frame2",
+            "_mixed",
+            "_mixed2",
+        ],
+    )
+    @pytest.mark.parametrize("flex", [True, False])
+    @pytest.mark.parametrize(
+        "arith", ["add", "sub", "mul", "mod", "truediv", "floordiv"]
+    )
+    def test_run_arithmetic(self, request, fixture, flex, arith, monkeypatch):
+        df = request.getfixturevalue(fixture)
+        with monkeypatch.context() as m:
+            m.setattr(expr, "_MIN_ELEMENTS", 0)
+            result, expected = self.call_op(df, df, flex, arith)
+
+            if arith == "truediv":
+                assert all(x.kind == "f" for x in expected.dtypes.values)
+            tm.assert_equal(expected, result)
+
+            for i in range(len(df.columns)):
+                result, expected = self.call_op(
+                    df.iloc[:, i], df.iloc[:, i], flex, arith
+                )
+                if arith == "truediv":
+                    assert expected.dtype.kind == "f"
+                tm.assert_equal(expected, result)
+
+    @pytest.mark.parametrize(
+        "fixture",
+        [
+            "_integer",
+            "_integer2",
+            "_integer_integers",
+            "_frame",
+            "_frame2",
+            "_mixed",
+            "_mixed2",
+        ],
+    )
+    @pytest.mark.parametrize("flex", [True, False])
+    def test_run_binary(self, request, fixture, flex, comparison_op, monkeypatch):
+        """
+        tests solely that the result is the same whether or not numexpr is
+        enabled.  Need to test whether the function does the correct thing
+        elsewhere.
+        """
+        df = request.getfixturevalue(fixture)
+        arith = comparison_op.__name__
+        with option_context("compute.use_numexpr", False):
+            other = df.copy() + 1
+
+        with monkeypatch.context() as m:
+            m.setattr(expr, "_MIN_ELEMENTS", 0)
+            expr.set_test_mode(True)
+
+            result, expected = self.call_op(df, other, flex, arith)
+
+            used_numexpr = expr.get_test_result()
+            assert used_numexpr, "Did not use numexpr as expected."
+            tm.assert_equal(expected, result)
+
+            for i in range(len(df.columns)):
+                binary_comp = other.iloc[:, i] + 1
+                self.call_op(df.iloc[:, i], binary_comp, flex, "add")
+
+    def test_invalid(self):
+        array = np.random.default_rng(2).standard_normal(1_000_001)
+        array2 = np.random.default_rng(2).standard_normal(100)
+
+        # no op
+        result = expr._can_use_numexpr(operator.add, None, array, array, "evaluate")
+        assert not result
+
+        # min elements
+        result = expr._can_use_numexpr(operator.add, "+", array2, array2, "evaluate")
+        assert not result
+
+        # ok, we only check on first part of expression
+        result = expr._can_use_numexpr(operator.add, "+", array, array2, "evaluate")
+        assert result
+
+    @pytest.mark.filterwarnings("ignore:invalid value encountered in:RuntimeWarning")
+    @pytest.mark.parametrize(
+        "opname,op_str",
+        [("add", "+"), ("sub", "-"), ("mul", "*"), ("truediv", "/"), ("pow", "**")],
+    )
+    @pytest.mark.parametrize(
+        "left_fix,right_fix", [("_array", "_array2"), ("_array_mixed", "_array_mixed2")]
+    )
+    def test_binary_ops(self, request, opname, op_str, left_fix, right_fix):
+        left = request.getfixturevalue(left_fix)
+        right = request.getfixturevalue(right_fix)
+
+        def testit(left, right, opname, op_str):
+            if opname == "pow":
+                left = np.abs(left)
+
+            op = getattr(operator, opname)
+
+            # array has 0s
+            result = expr.evaluate(op, left, left, use_numexpr=True)
+            expected = expr.evaluate(op, left, left, use_numexpr=False)
+            tm.assert_numpy_array_equal(result, expected)
+
+            result = expr._can_use_numexpr(op, op_str, right, right, "evaluate")
+            assert not result
+
+        with option_context("compute.use_numexpr", False):
+            testit(left, right, opname, op_str)
+
+        expr.set_numexpr_threads(1)
+        testit(left, right, opname, op_str)
+        expr.set_numexpr_threads()
+        testit(left, right, opname, op_str)
+
+    @pytest.mark.parametrize(
+        "left_fix,right_fix", [("_array", "_array2"), ("_array_mixed", "_array_mixed2")]
+    )
+    def test_comparison_ops(self, request, comparison_op, left_fix, right_fix):
+        left = request.getfixturevalue(left_fix)
+        right = request.getfixturevalue(right_fix)
+
+        def testit():
+            f12 = left + 1
+            f22 = right + 1
+
+            op = comparison_op
+
+            result = expr.evaluate(op, left, f12, use_numexpr=True)
+            expected = expr.evaluate(op, left, f12, use_numexpr=False)
+            tm.assert_numpy_array_equal(result, expected)
+
+            result = expr._can_use_numexpr(op, op, right, f22, "evaluate")
+            assert not result
+
+        with option_context("compute.use_numexpr", False):
+            testit()
+
+        expr.set_numexpr_threads(1)
+        testit()
+        expr.set_numexpr_threads()
+        testit()
+
+    @pytest.mark.parametrize("cond", [True, False])
+    @pytest.mark.parametrize("fixture", ["_frame", "_frame2", "_mixed", "_mixed2"])
+    def test_where(self, request, cond, fixture):
+        df = request.getfixturevalue(fixture)
+
+        def testit():
+            c = np.empty(df.shape, dtype=np.bool_)
+            c.fill(cond)
+            result = expr.where(c, df.values, df.values + 1)
+            expected = np.where(c, df.values, df.values + 1)
+            tm.assert_numpy_array_equal(result, expected)
+
+        with option_context("compute.use_numexpr", False):
+            testit()
+
+        expr.set_numexpr_threads(1)
+        testit()
+        expr.set_numexpr_threads()
+        testit()
+
+    @pytest.mark.parametrize(
+        "op_str,opname", [("/", "truediv"), ("//", "floordiv"), ("**", "pow")]
+    )
+    def test_bool_ops_raise_on_arithmetic(self, op_str, opname):
+        df = DataFrame(
+            {
+                "a": np.random.default_rng(2).random(10) > 0.5,
+                "b": np.random.default_rng(2).random(10) > 0.5,
+            }
+        )
+
+        msg = f"operator '{opname}' not implemented for bool dtypes"
+        f = getattr(operator, opname)
+        err_msg = re.escape(msg)
+
+        with pytest.raises(NotImplementedError, match=err_msg):
+            f(df, df)
+
+        with pytest.raises(NotImplementedError, match=err_msg):
+            f(df.a, df.b)
+
+        with pytest.raises(NotImplementedError, match=err_msg):
+            f(df.a, True)
+
+        with pytest.raises(NotImplementedError, match=err_msg):
+            f(False, df.a)
+
+        with pytest.raises(NotImplementedError, match=err_msg):
+            f(False, df)
+
+        with pytest.raises(NotImplementedError, match=err_msg):
+            f(df, True)
+
+    @pytest.mark.parametrize(
+        "op_str,opname", [("+", "add"), ("*", "mul"), ("-", "sub")]
+    )
+    def test_bool_ops_warn_on_arithmetic(self, op_str, opname):
+        n = 10
+        df = DataFrame(
+            {
+                "a": np.random.default_rng(2).random(n) > 0.5,
+                "b": np.random.default_rng(2).random(n) > 0.5,
+            }
+        )
+
+        subs = {"+": "|", "*": "&", "-": "^"}
+        sub_funcs = {"|": "or_", "&": "and_", "^": "xor"}
+
+        f = getattr(operator, opname)
+        fe = getattr(operator, sub_funcs[subs[op_str]])
+
+        if op_str == "-":
+            # raises TypeError
+            return
+
+        with tm.use_numexpr(True, min_elements=5):
+            with tm.assert_produces_warning():
+                r = f(df, df)
+                e = fe(df, df)
+                tm.assert_frame_equal(r, e)
+
+            with tm.assert_produces_warning():
+                r = f(df.a, df.b)
+                e = fe(df.a, df.b)
+                tm.assert_series_equal(r, e)
+
+            with tm.assert_produces_warning():
+                r = f(df.a, True)
+                e = fe(df.a, True)
+                tm.assert_series_equal(r, e)
+
+            with tm.assert_produces_warning():
+                r = f(False, df.a)
+                e = fe(False, df.a)
+                tm.assert_series_equal(r, e)
+
+            with tm.assert_produces_warning():
+                r = f(False, df)
+                e = fe(False, df)
+                tm.assert_frame_equal(r, e)
+
+            with tm.assert_produces_warning():
+                r = f(df, True)
+                e = fe(df, True)
+                tm.assert_frame_equal(r, e)
+
+    @pytest.mark.parametrize(
+        "test_input,expected",
+        [
+            (
+                DataFrame(
+                    [[0, 1, 2, "aa"], [0, 1, 2, "aa"]], columns=["a", "b", "c", "dtype"]
+                ),
+                DataFrame([[False, False], [False, False]], columns=["a", "dtype"]),
+            ),
+            (
+                DataFrame(
+                    [[0, 3, 2, "aa"], [0, 4, 2, "aa"], [0, 1, 1, "bb"]],
+                    columns=["a", "b", "c", "dtype"],
+                ),
+                DataFrame(
+                    [[False, False], [False, False], [False, False]],
+                    columns=["a", "dtype"],
+                ),
+            ),
+        ],
+    )
+    def test_bool_ops_column_name_dtype(self, test_input, expected):
+        # GH 22383 - .ne fails if columns containing column name 'dtype'
+        result = test_input.loc[:, ["a", "dtype"]].ne(test_input.loc[:, ["a", "dtype"]])
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "arith", ("add", "sub", "mul", "mod", "truediv", "floordiv")
+    )
+    @pytest.mark.parametrize("axis", (0, 1))
+    def test_frame_series_axis(self, axis, arith, _frame, monkeypatch):
+        # GH#26736 Dataframe.floordiv(Series, axis=1) fails
+
+        df = _frame
+        if axis == 1:
+            other = df.iloc[0, :]
+        else:
+            other = df.iloc[:, 0]
+
+        with monkeypatch.context() as m:
+            m.setattr(expr, "_MIN_ELEMENTS", 0)
+
+            op_func = getattr(df, arith)
+
+            with option_context("compute.use_numexpr", False):
+                expected = op_func(other, axis=axis)
+
+            result = op_func(other, axis=axis)
+            tm.assert_frame_equal(expected, result)
+
+    @pytest.mark.parametrize(
+        "op",
+        [
+            "__mod__",
+            "__rmod__",
+            "__floordiv__",
+            "__rfloordiv__",
+        ],
+    )
+    @pytest.mark.parametrize("box", [DataFrame, Series, Index])
+    @pytest.mark.parametrize("scalar", [-5, 5])
+    def test_python_semantics_with_numexpr_installed(
+        self, op, box, scalar, monkeypatch
+    ):
+        # https://github.com/pandas-dev/pandas/issues/36047
+        with monkeypatch.context() as m:
+            m.setattr(expr, "_MIN_ELEMENTS", 0)
+            data = np.arange(-50, 50)
+            obj = box(data)
+            method = getattr(obj, op)
+            result = method(scalar)
+
+            # compare result with numpy
+            with option_context("compute.use_numexpr", False):
+                expected = method(scalar)
+
+            tm.assert_equal(result, expected)
+
+            # compare result element-wise with Python
+            for i, elem in enumerate(data):
+                if box == DataFrame:
+                    scalar_result = result.iloc[i, 0]
+                else:
+                    scalar_result = result[i]
+                try:
+                    expected = getattr(int(elem), op)(scalar)
+                except ZeroDivisionError:
+                    pass
+                else:
+                    assert scalar_result == expected

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas/tests/test_flags.py

@@ -0,0 +1,48 @@
+import pytest
+
+import pandas as pd
+
+
+class TestFlags:
+    def test_equality(self):
+        a = pd.DataFrame().set_flags(allows_duplicate_labels=True).flags
+        b = pd.DataFrame().set_flags(allows_duplicate_labels=False).flags
+
+        assert a == a
+        assert b == b
+        assert a != b
+        assert a != 2
+
+    def test_set(self):
+        df = pd.DataFrame().set_flags(allows_duplicate_labels=True)
+        a = df.flags
+        a.allows_duplicate_labels = False
+        assert a.allows_duplicate_labels is False
+        a["allows_duplicate_labels"] = True
+        assert a.allows_duplicate_labels is True
+
+    def test_repr(self):
+        a = repr(pd.DataFrame({"A"}).set_flags(allows_duplicate_labels=True).flags)
+        assert a == "<Flags(allows_duplicate_labels=True)>"
+        a = repr(pd.DataFrame({"A"}).set_flags(allows_duplicate_labels=False).flags)
+        assert a == "<Flags(allows_duplicate_labels=False)>"
+
+    def test_obj_ref(self):
+        df = pd.DataFrame()
+        flags = df.flags
+        del df
+        with pytest.raises(ValueError, match="object has been deleted"):
+            flags.allows_duplicate_labels = True
+
+    def test_getitem(self):
+        df = pd.DataFrame()
+        flags = df.flags
+        assert flags["allows_duplicate_labels"] is True
+        flags["allows_duplicate_labels"] = False
+        assert flags["allows_duplicate_labels"] is False
+
+        with pytest.raises(KeyError, match="a"):
+            flags["a"]
+
+        with pytest.raises(ValueError, match="a"):
+            flags["a"] = 10

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas/tests/test_multilevel.py

@@ -0,0 +1,355 @@
+import datetime
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    MultiIndex,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestMultiLevel:
+    def test_reindex_level(self, multiindex_year_month_day_dataframe_random_data):
+        # axis=0
+        ymd = multiindex_year_month_day_dataframe_random_data
+
+        month_sums = ymd.groupby("month").sum()
+        result = month_sums.reindex(ymd.index, level=1)
+        expected = ymd.groupby(level="month").transform("sum")
+
+        tm.assert_frame_equal(result, expected)
+
+        # Series
+        result = month_sums["A"].reindex(ymd.index, level=1)
+        expected = ymd["A"].groupby(level="month").transform("sum")
+        tm.assert_series_equal(result, expected, check_names=False)
+
+        # axis=1
+        msg = "DataFrame.groupby with axis=1 is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            gb = ymd.T.groupby("month", axis=1)
+
+        month_sums = gb.sum()
+        result = month_sums.reindex(columns=ymd.index, level=1)
+        expected = ymd.groupby(level="month").transform("sum").T
+        tm.assert_frame_equal(result, expected)
+
+    def test_reindex(self, multiindex_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+
+        expected = frame.iloc[[0, 3]]
+        reindexed = frame.loc[[("foo", "one"), ("bar", "one")]]
+        tm.assert_frame_equal(reindexed, expected)
+
+    def test_reindex_preserve_levels(
+        self, multiindex_year_month_day_dataframe_random_data, using_copy_on_write
+    ):
+        ymd = multiindex_year_month_day_dataframe_random_data
+
+        new_index = ymd.index[::10]
+        chunk = ymd.reindex(new_index)
+        if using_copy_on_write:
+            assert chunk.index.is_(new_index)
+        else:
+            assert chunk.index is new_index
+
+        chunk = ymd.loc[new_index]
+        assert chunk.index.equals(new_index)
+
+        ymdT = ymd.T
+        chunk = ymdT.reindex(columns=new_index)
+        if using_copy_on_write:
+            assert chunk.columns.is_(new_index)
+        else:
+            assert chunk.columns is new_index
+
+        chunk = ymdT.loc[:, new_index]
+        assert chunk.columns.equals(new_index)
+
+    def test_groupby_transform(self, multiindex_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+
+        s = frame["A"]
+        grouper = s.index.get_level_values(0)
+
+        grouped = s.groupby(grouper, group_keys=False)
+
+        applied = grouped.apply(lambda x: x * 2)
+        expected = grouped.transform(lambda x: x * 2)
+        result = applied.reindex(expected.index)
+        tm.assert_series_equal(result, expected, check_names=False)
+
+    def test_groupby_corner(self):
+        midx = MultiIndex(
+            levels=[["foo"], ["bar"], ["baz"]],
+            codes=[[0], [0], [0]],
+            names=["one", "two", "three"],
+        )
+        df = DataFrame(
+            [np.random.default_rng(2).random(4)],
+            columns=["a", "b", "c", "d"],
+            index=midx,
+        )
+        # should work
+        df.groupby(level="three")
+
+    def test_groupby_level_no_obs(self):
+        # #1697
+        midx = MultiIndex.from_tuples(
+            [
+                ("f1", "s1"),
+                ("f1", "s2"),
+                ("f2", "s1"),
+                ("f2", "s2"),
+                ("f3", "s1"),
+                ("f3", "s2"),
+            ]
+        )
+        df = DataFrame([[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12]], columns=midx)
+        df1 = df.loc(axis=1)[df.columns.map(lambda u: u[0] in ["f2", "f3"])]
+
+        msg = "DataFrame.groupby with axis=1 is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            grouped = df1.groupby(axis=1, level=0)
+        result = grouped.sum()
+        assert (result.columns == ["f2", "f3"]).all()
+
+    def test_setitem_with_expansion_multiindex_columns(
+        self, multiindex_year_month_day_dataframe_random_data
+    ):
+        ymd = multiindex_year_month_day_dataframe_random_data
+
+        df = ymd[:5].T
+        df[2000, 1, 10] = df[2000, 1, 7]
+        assert isinstance(df.columns, MultiIndex)
+        assert (df[2000, 1, 10] == df[2000, 1, 7]).all()
+
+    def test_alignment(self):
+        x = Series(
+            data=[1, 2, 3], index=MultiIndex.from_tuples([("A", 1), ("A", 2), ("B", 3)])
+        )
+
+        y = Series(
+            data=[4, 5, 6], index=MultiIndex.from_tuples([("Z", 1), ("Z", 2), ("B", 3)])
+        )
+
+        res = x - y
+        exp_index = x.index.union(y.index)
+        exp = x.reindex(exp_index) - y.reindex(exp_index)
+        tm.assert_series_equal(res, exp)
+
+        # hit non-monotonic code path
+        res = x[::-1] - y[::-1]
+        exp_index = x.index.union(y.index)
+        exp = x.reindex(exp_index) - y.reindex(exp_index)
+        tm.assert_series_equal(res, exp)
+
+    def test_groupby_multilevel(self, multiindex_year_month_day_dataframe_random_data):
+        ymd = multiindex_year_month_day_dataframe_random_data
+
+        result = ymd.groupby(level=[0, 1]).mean()
+
+        k1 = ymd.index.get_level_values(0)
+        k2 = ymd.index.get_level_values(1)
+
+        expected = ymd.groupby([k1, k2]).mean()
+
+        # TODO groupby with level_values drops names
+        tm.assert_frame_equal(result, expected, check_names=False)
+        assert result.index.names == ymd.index.names[:2]
+
+        result2 = ymd.groupby(level=ymd.index.names[:2]).mean()
+        tm.assert_frame_equal(result, result2)
+
+    def test_multilevel_consolidate(self):
+        index = MultiIndex.from_tuples(
+            [("foo", "one"), ("foo", "two"), ("bar", "one"), ("bar", "two")]
+        )
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((4, 4)), index=index, columns=index
+        )
+        df["Totals", ""] = df.sum(1)
+        df = df._consolidate()
+
+    def test_level_with_tuples(self):
+        index = MultiIndex(
+            levels=[[("foo", "bar", 0), ("foo", "baz", 0), ("foo", "qux", 0)], [0, 1]],
+            codes=[[0, 0, 1, 1, 2, 2], [0, 1, 0, 1, 0, 1]],
+        )
+
+        series = Series(np.random.default_rng(2).standard_normal(6), index=index)
+        frame = DataFrame(np.random.default_rng(2).standard_normal((6, 4)), index=index)
+
+        result = series[("foo", "bar", 0)]
+        result2 = series.loc[("foo", "bar", 0)]
+        expected = series[:2]
+        expected.index = expected.index.droplevel(0)
+        tm.assert_series_equal(result, expected)
+        tm.assert_series_equal(result2, expected)
+
+        with pytest.raises(KeyError, match=r"^\(\('foo', 'bar', 0\), 2\)$"):
+            series[("foo", "bar", 0), 2]
+
+        result = frame.loc[("foo", "bar", 0)]
+        result2 = frame.xs(("foo", "bar", 0))
+        expected = frame[:2]
+        expected.index = expected.index.droplevel(0)
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result2, expected)
+
+        index = MultiIndex(
+            levels=[[("foo", "bar"), ("foo", "baz"), ("foo", "qux")], [0, 1]],
+            codes=[[0, 0, 1, 1, 2, 2], [0, 1, 0, 1, 0, 1]],
+        )
+
+        series = Series(np.random.default_rng(2).standard_normal(6), index=index)
+        frame = DataFrame(np.random.default_rng(2).standard_normal((6, 4)), index=index)
+
+        result = series[("foo", "bar")]
+        result2 = series.loc[("foo", "bar")]
+        expected = series[:2]
+        expected.index = expected.index.droplevel(0)
+        tm.assert_series_equal(result, expected)
+        tm.assert_series_equal(result2, expected)
+
+        result = frame.loc[("foo", "bar")]
+        result2 = frame.xs(("foo", "bar"))
+        expected = frame[:2]
+        expected.index = expected.index.droplevel(0)
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result2, expected)
+
+    def test_reindex_level_partial_selection(self, multiindex_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+
+        result = frame.reindex(["foo", "qux"], level=0)
+        expected = frame.iloc[[0, 1, 2, 7, 8, 9]]
+        tm.assert_frame_equal(result, expected)
+
+        result = frame.T.reindex(["foo", "qux"], axis=1, level=0)
+        tm.assert_frame_equal(result, expected.T)
+
+        result = frame.loc[["foo", "qux"]]
+        tm.assert_frame_equal(result, expected)
+
+        result = frame["A"].loc[["foo", "qux"]]
+        tm.assert_series_equal(result, expected["A"])
+
+        result = frame.T.loc[:, ["foo", "qux"]]
+        tm.assert_frame_equal(result, expected.T)
+
+    @pytest.mark.parametrize("d", [4, "d"])
+    def test_empty_frame_groupby_dtypes_consistency(self, d):
+        # GH 20888
+        group_keys = ["a", "b", "c"]
+        df = DataFrame({"a": [1], "b": [2], "c": [3], "d": [d]})
+
+        g = df[df.a == 2].groupby(group_keys)
+        result = g.first().index
+        expected = MultiIndex(
+            levels=[[1], [2], [3]], codes=[[], [], []], names=["a", "b", "c"]
+        )
+
+        tm.assert_index_equal(result, expected)
+
+    def test_duplicate_groupby_issues(self):
+        idx_tp = [
+            ("600809", "20061231"),
+            ("600809", "20070331"),
+            ("600809", "20070630"),
+            ("600809", "20070331"),
+        ]
+        dt = ["demo", "demo", "demo", "demo"]
+
+        idx = MultiIndex.from_tuples(idx_tp, names=["STK_ID", "RPT_Date"])
+        s = Series(dt, index=idx)
+
+        result = s.groupby(s.index).first()
+        assert len(result) == 3
+
+    def test_subsets_multiindex_dtype(self):
+        # GH 20757
+        data = [["x", 1]]
+        columns = [("a", "b", np.nan), ("a", "c", 0.0)]
+        df = DataFrame(data, columns=MultiIndex.from_tuples(columns))
+        expected = df.dtypes.a.b
+        result = df.a.b.dtypes
+        tm.assert_series_equal(result, expected)
+
+    def test_datetime_object_multiindex(self):
+        data_dic = {
+            (0, datetime.date(2018, 3, 3)): {"A": 1, "B": 10},
+            (0, datetime.date(2018, 3, 4)): {"A": 2, "B": 11},
+            (1, datetime.date(2018, 3, 3)): {"A": 3, "B": 12},
+            (1, datetime.date(2018, 3, 4)): {"A": 4, "B": 13},
+        }
+        result = DataFrame.from_dict(data_dic, orient="index")
+        data = {"A": [1, 2, 3, 4], "B": [10, 11, 12, 13]}
+        index = [
+            [0, 0, 1, 1],
+            [
+                datetime.date(2018, 3, 3),
+                datetime.date(2018, 3, 4),
+                datetime.date(2018, 3, 3),
+                datetime.date(2018, 3, 4),
+            ],
+        ]
+        expected = DataFrame(data=data, index=index)
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_multiindex_with_na(self):
+        df = DataFrame(
+            [
+                ["A", np.nan, 1.23, 4.56],
+                ["A", "G", 1.23, 4.56],
+                ["A", "D", 9.87, 10.54],
+            ],
+            columns=["pivot_0", "pivot_1", "col_1", "col_2"],
+        ).set_index(["pivot_0", "pivot_1"])
+
+        df.at[("A", "F"), "col_2"] = 0.0
+
+        expected = DataFrame(
+            [
+                ["A", np.nan, 1.23, 4.56],
+                ["A", "G", 1.23, 4.56],
+                ["A", "D", 9.87, 10.54],
+                ["A", "F", np.nan, 0.0],
+            ],
+            columns=["pivot_0", "pivot_1", "col_1", "col_2"],
+        ).set_index(["pivot_0", "pivot_1"])
+
+        tm.assert_frame_equal(df, expected)
+
+
+class TestSorted:
+    """everything you wanted to test about sorting"""
+
+    def test_sort_non_lexsorted(self):
+        # degenerate case where we sort but don't
+        # have a satisfying result :<
+        # GH 15797
+        idx = MultiIndex(
+            [["A", "B", "C"], ["c", "b", "a"]], [[0, 1, 2, 0, 1, 2], [0, 2, 1, 1, 0, 2]]
+        )
+
+        df = DataFrame({"col": range(len(idx))}, index=idx, dtype="int64")
+        assert df.index.is_monotonic_increasing is False
+
+        sorted = df.sort_index()
+        assert sorted.index.is_monotonic_increasing is True
+
+        expected = DataFrame(
+            {"col": [1, 4, 5, 2]},
+            index=MultiIndex.from_tuples(
+                [("B", "a"), ("B", "c"), ("C", "a"), ("C", "b")]
+            ),
+            dtype="int64",
+        )
+        result = sorted.loc[pd.IndexSlice["B":"C", "a":"c"], :]
+        tm.assert_frame_equal(result, expected)

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas/tests/test_nanops.py

@@ -0,0 +1,1274 @@
+from functools import partial
+
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+from pandas.core.dtypes.common import is_integer_dtype
+
+import pandas as pd
+from pandas import (
+    Series,
+    isna,
+)
+import pandas._testing as tm
+from pandas.core import nanops
+
+use_bn = nanops._USE_BOTTLENECK
+
+
+@pytest.fixture
+def disable_bottleneck(monkeypatch):
+    with monkeypatch.context() as m:
+        m.setattr(nanops, "_USE_BOTTLENECK", False)
+        yield
+
+
+@pytest.fixture
+def arr_shape():
+    return 11, 7
+
+
+@pytest.fixture
+def arr_float(arr_shape):
+    return np.random.default_rng(2).standard_normal(arr_shape)
+
+
+@pytest.fixture
+def arr_complex(arr_float):
+    return arr_float + arr_float * 1j
+
+
+@pytest.fixture
+def arr_int(arr_shape):
+    return np.random.default_rng(2).integers(-10, 10, arr_shape)
+
+
+@pytest.fixture
+def arr_bool(arr_shape):
+    return np.random.default_rng(2).integers(0, 2, arr_shape) == 0
+
+
+@pytest.fixture
+def arr_str(arr_float):
+    return np.abs(arr_float).astype("S")
+
+
+@pytest.fixture
+def arr_utf(arr_float):
+    return np.abs(arr_float).astype("U")
+
+
+@pytest.fixture
+def arr_date(arr_shape):
+    return np.random.default_rng(2).integers(0, 20000, arr_shape).astype("M8[ns]")
+
+
+@pytest.fixture
+def arr_tdelta(arr_shape):
+    return np.random.default_rng(2).integers(0, 20000, arr_shape).astype("m8[ns]")
+
+
+@pytest.fixture
+def arr_nan(arr_shape):
+    return np.tile(np.nan, arr_shape)
+
+
+@pytest.fixture
+def arr_float_nan(arr_float, arr_nan):
+    return np.vstack([arr_float, arr_nan])
+
+
+@pytest.fixture
+def arr_nan_float1(arr_nan, arr_float):
+    return np.vstack([arr_nan, arr_float])
+
+
+@pytest.fixture
+def arr_nan_nan(arr_nan):
+    return np.vstack([arr_nan, arr_nan])
+
+
+@pytest.fixture
+def arr_inf(arr_float):
+    return arr_float * np.inf
+
+
+@pytest.fixture
+def arr_float_inf(arr_float, arr_inf):
+    return np.vstack([arr_float, arr_inf])
+
+
+@pytest.fixture
+def arr_nan_inf(arr_nan, arr_inf):
+    return np.vstack([arr_nan, arr_inf])
+
+
+@pytest.fixture
+def arr_float_nan_inf(arr_float, arr_nan, arr_inf):
+    return np.vstack([arr_float, arr_nan, arr_inf])
+
+
+@pytest.fixture
+def arr_nan_nan_inf(arr_nan, arr_inf):
+    return np.vstack([arr_nan, arr_nan, arr_inf])
+
+
+@pytest.fixture
+def arr_obj(
+    arr_float, arr_int, arr_bool, arr_complex, arr_str, arr_utf, arr_date, arr_tdelta
+):
+    return np.vstack(
+        [
+            arr_float.astype("O"),
+            arr_int.astype("O"),
+            arr_bool.astype("O"),
+            arr_complex.astype("O"),
+            arr_str.astype("O"),
+            arr_utf.astype("O"),
+            arr_date.astype("O"),
+            arr_tdelta.astype("O"),
+        ]
+    )
+
+
+@pytest.fixture
+def arr_nan_nanj(arr_nan):
+    with np.errstate(invalid="ignore"):
+        return arr_nan + arr_nan * 1j
+
+
+@pytest.fixture
+def arr_complex_nan(arr_complex, arr_nan_nanj):
+    with np.errstate(invalid="ignore"):
+        return np.vstack([arr_complex, arr_nan_nanj])
+
+
+@pytest.fixture
+def arr_nan_infj(arr_inf):
+    with np.errstate(invalid="ignore"):
+        return arr_inf * 1j
+
+
+@pytest.fixture
+def arr_complex_nan_infj(arr_complex, arr_nan_infj):
+    with np.errstate(invalid="ignore"):
+        return np.vstack([arr_complex, arr_nan_infj])
+
+
+@pytest.fixture
+def arr_float_1d(arr_float):
+    return arr_float[:, 0]
+
+
+@pytest.fixture
+def arr_nan_1d(arr_nan):
+    return arr_nan[:, 0]
+
+
+@pytest.fixture
+def arr_float_nan_1d(arr_float_nan):
+    return arr_float_nan[:, 0]
+
+
+@pytest.fixture
+def arr_float1_nan_1d(arr_float1_nan):
+    return arr_float1_nan[:, 0]
+
+
+@pytest.fixture
+def arr_nan_float1_1d(arr_nan_float1):
+    return arr_nan_float1[:, 0]
+
+
+class TestnanopsDataFrame:
+    def setup_method(self):
+        nanops._USE_BOTTLENECK = False
+
+        arr_shape = (11, 7)
+
+        self.arr_float = np.random.default_rng(2).standard_normal(arr_shape)
+        self.arr_float1 = np.random.default_rng(2).standard_normal(arr_shape)
+        self.arr_complex = self.arr_float + self.arr_float1 * 1j
+        self.arr_int = np.random.default_rng(2).integers(-10, 10, arr_shape)
+        self.arr_bool = np.random.default_rng(2).integers(0, 2, arr_shape) == 0
+        self.arr_str = np.abs(self.arr_float).astype("S")
+        self.arr_utf = np.abs(self.arr_float).astype("U")
+        self.arr_date = (
+            np.random.default_rng(2).integers(0, 20000, arr_shape).astype("M8[ns]")
+        )
+        self.arr_tdelta = (
+            np.random.default_rng(2).integers(0, 20000, arr_shape).astype("m8[ns]")
+        )
+
+        self.arr_nan = np.tile(np.nan, arr_shape)
+        self.arr_float_nan = np.vstack([self.arr_float, self.arr_nan])
+        self.arr_float1_nan = np.vstack([self.arr_float1, self.arr_nan])
+        self.arr_nan_float1 = np.vstack([self.arr_nan, self.arr_float1])
+        self.arr_nan_nan = np.vstack([self.arr_nan, self.arr_nan])
+
+        self.arr_inf = self.arr_float * np.inf
+        self.arr_float_inf = np.vstack([self.arr_float, self.arr_inf])
+
+        self.arr_nan_inf = np.vstack([self.arr_nan, self.arr_inf])
+        self.arr_float_nan_inf = np.vstack([self.arr_float, self.arr_nan, self.arr_inf])
+        self.arr_nan_nan_inf = np.vstack([self.arr_nan, self.arr_nan, self.arr_inf])
+        self.arr_obj = np.vstack(
+            [
+                self.arr_float.astype("O"),
+                self.arr_int.astype("O"),
+                self.arr_bool.astype("O"),
+                self.arr_complex.astype("O"),
+                self.arr_str.astype("O"),
+                self.arr_utf.astype("O"),
+                self.arr_date.astype("O"),
+                self.arr_tdelta.astype("O"),
+            ]
+        )
+
+        with np.errstate(invalid="ignore"):
+            self.arr_nan_nanj = self.arr_nan + self.arr_nan * 1j
+            self.arr_complex_nan = np.vstack([self.arr_complex, self.arr_nan_nanj])
+
+            self.arr_nan_infj = self.arr_inf * 1j
+            self.arr_complex_nan_infj = np.vstack([self.arr_complex, self.arr_nan_infj])
+
+        self.arr_float_2d = self.arr_float
+        self.arr_float1_2d = self.arr_float1
+
+        self.arr_nan_2d = self.arr_nan
+        self.arr_float_nan_2d = self.arr_float_nan
+        self.arr_float1_nan_2d = self.arr_float1_nan
+        self.arr_nan_float1_2d = self.arr_nan_float1
+
+        self.arr_float_1d = self.arr_float[:, 0]
+        self.arr_float1_1d = self.arr_float1[:, 0]
+
+        self.arr_nan_1d = self.arr_nan[:, 0]
+        self.arr_float_nan_1d = self.arr_float_nan[:, 0]
+        self.arr_float1_nan_1d = self.arr_float1_nan[:, 0]
+        self.arr_nan_float1_1d = self.arr_nan_float1[:, 0]
+
+    def teardown_method(self):
+        nanops._USE_BOTTLENECK = use_bn
+
+    def check_results(self, targ, res, axis, check_dtype=True):
+        res = getattr(res, "asm8", res)
+
+        if (
+            axis != 0
+            and hasattr(targ, "shape")
+            and targ.ndim
+            and targ.shape != res.shape
+        ):
+            res = np.split(res, [targ.shape[0]], axis=0)[0]
+
+        try:
+            tm.assert_almost_equal(targ, res, check_dtype=check_dtype)
+        except AssertionError:
+            # handle timedelta dtypes
+            if hasattr(targ, "dtype") and targ.dtype == "m8[ns]":
+                raise
+
+            # There are sometimes rounding errors with
+            # complex and object dtypes.
+            # If it isn't one of those, re-raise the error.
+            if not hasattr(res, "dtype") or res.dtype.kind not in ["c", "O"]:
+                raise
+            # convert object dtypes to something that can be split into
+            # real and imaginary parts
+            if res.dtype.kind == "O":
+                if targ.dtype.kind != "O":
+                    res = res.astype(targ.dtype)
+                else:
+                    cast_dtype = "c16" if hasattr(np, "complex128") else "f8"
+                    res = res.astype(cast_dtype)
+                    targ = targ.astype(cast_dtype)
+            # there should never be a case where numpy returns an object
+            # but nanops doesn't, so make that an exception
+            elif targ.dtype.kind == "O":
+                raise
+            tm.assert_almost_equal(np.real(targ), np.real(res), check_dtype=check_dtype)
+            tm.assert_almost_equal(np.imag(targ), np.imag(res), check_dtype=check_dtype)
+
+    def check_fun_data(
+        self,
+        testfunc,
+        targfunc,
+        testarval,
+        targarval,
+        skipna,
+        check_dtype=True,
+        empty_targfunc=None,
+        **kwargs,
+    ):
+        for axis in list(range(targarval.ndim)) + [None]:
+            targartempval = targarval if skipna else testarval
+            if skipna and empty_targfunc and isna(targartempval).all():
+                targ = empty_targfunc(targartempval, axis=axis, **kwargs)
+            else:
+                targ = targfunc(targartempval, axis=axis, **kwargs)
+
+            if targartempval.dtype == object and (
+                targfunc is np.any or targfunc is np.all
+            ):
+                # GH#12863 the numpy functions will retain e.g. floatiness
+                if isinstance(targ, np.ndarray):
+                    targ = targ.astype(bool)
+                else:
+                    targ = bool(targ)
+
+            res = testfunc(testarval, axis=axis, skipna=skipna, **kwargs)
+
+            if (
+                isinstance(targ, np.complex128)
+                and isinstance(res, float)
+                and np.isnan(targ)
+                and np.isnan(res)
+            ):
+                # GH#18463
+                targ = res
+
+            self.check_results(targ, res, axis, check_dtype=check_dtype)
+            if skipna:
+                res = testfunc(testarval, axis=axis, **kwargs)
+                self.check_results(targ, res, axis, check_dtype=check_dtype)
+            if axis is None:
+                res = testfunc(testarval, skipna=skipna, **kwargs)
+                self.check_results(targ, res, axis, check_dtype=check_dtype)
+            if skipna and axis is None:
+                res = testfunc(testarval, **kwargs)
+                self.check_results(targ, res, axis, check_dtype=check_dtype)
+
+        if testarval.ndim <= 1:
+            return
+
+        # Recurse on lower-dimension
+        testarval2 = np.take(testarval, 0, axis=-1)
+        targarval2 = np.take(targarval, 0, axis=-1)
+        self.check_fun_data(
+            testfunc,
+            targfunc,
+            testarval2,
+            targarval2,
+            skipna=skipna,
+            check_dtype=check_dtype,
+            empty_targfunc=empty_targfunc,
+            **kwargs,
+        )
+
+    def check_fun(
+        self, testfunc, targfunc, testar, skipna, empty_targfunc=None, **kwargs
+    ):
+        targar = testar
+        if testar.endswith("_nan") and hasattr(self, testar[:-4]):
+            targar = testar[:-4]
+
+        testarval = getattr(self, testar)
+        targarval = getattr(self, targar)
+        self.check_fun_data(
+            testfunc,
+            targfunc,
+            testarval,
+            targarval,
+            skipna=skipna,
+            empty_targfunc=empty_targfunc,
+            **kwargs,
+        )
+
+    def check_funs(
+        self,
+        testfunc,
+        targfunc,
+        skipna,
+        allow_complex=True,
+        allow_all_nan=True,
+        allow_date=True,
+        allow_tdelta=True,
+        allow_obj=True,
+        **kwargs,
+    ):
+        self.check_fun(testfunc, targfunc, "arr_float", skipna, **kwargs)
+        self.check_fun(testfunc, targfunc, "arr_float_nan", skipna, **kwargs)
+        self.check_fun(testfunc, targfunc, "arr_int", skipna, **kwargs)
+        self.check_fun(testfunc, targfunc, "arr_bool", skipna, **kwargs)
+        objs = [
+            self.arr_float.astype("O"),
+            self.arr_int.astype("O"),
+            self.arr_bool.astype("O"),
+        ]
+
+        if allow_all_nan:
+            self.check_fun(testfunc, targfunc, "arr_nan", skipna, **kwargs)
+
+        if allow_complex:
+            self.check_fun(testfunc, targfunc, "arr_complex", skipna, **kwargs)
+            self.check_fun(testfunc, targfunc, "arr_complex_nan", skipna, **kwargs)
+            if allow_all_nan:
+                self.check_fun(testfunc, targfunc, "arr_nan_nanj", skipna, **kwargs)
+            objs += [self.arr_complex.astype("O")]
+
+        if allow_date:
+            targfunc(self.arr_date)
+            self.check_fun(testfunc, targfunc, "arr_date", skipna, **kwargs)
+            objs += [self.arr_date.astype("O")]
+
+        if allow_tdelta:
+            try:
+                targfunc(self.arr_tdelta)
+            except TypeError:
+                pass
+            else:
+                self.check_fun(testfunc, targfunc, "arr_tdelta", skipna, **kwargs)
+                objs += [self.arr_tdelta.astype("O")]
+
+        if allow_obj:
+            self.arr_obj = np.vstack(objs)
+            # some nanops handle object dtypes better than their numpy
+            # counterparts, so the numpy functions need to be given something
+            # else
+            if allow_obj == "convert":
+                targfunc = partial(
+                    self._badobj_wrap, func=targfunc, allow_complex=allow_complex
+                )
+            self.check_fun(testfunc, targfunc, "arr_obj", skipna, **kwargs)
+
+    def _badobj_wrap(self, value, func, allow_complex=True, **kwargs):
+        if value.dtype.kind == "O":
+            if allow_complex:
+                value = value.astype("c16")
+            else:
+                value = value.astype("f8")
+        return func(value, **kwargs)
+
+    @pytest.mark.parametrize(
+        "nan_op,np_op", [(nanops.nanany, np.any), (nanops.nanall, np.all)]
+    )
+    def test_nan_funcs(self, nan_op, np_op, skipna):
+        self.check_funs(nan_op, np_op, skipna, allow_all_nan=False, allow_date=False)
+
+    def test_nansum(self, skipna):
+        self.check_funs(
+            nanops.nansum,
+            np.sum,
+            skipna,
+            allow_date=False,
+            check_dtype=False,
+            empty_targfunc=np.nansum,
+        )
+
+    def test_nanmean(self, skipna):
+        self.check_funs(
+            nanops.nanmean, np.mean, skipna, allow_obj=False, allow_date=False
+        )
+
+    @pytest.mark.filterwarnings("ignore::RuntimeWarning")
+    def test_nanmedian(self, skipna):
+        self.check_funs(
+            nanops.nanmedian,
+            np.median,
+            skipna,
+            allow_complex=False,
+            allow_date=False,
+            allow_obj="convert",
+        )
+
+    @pytest.mark.parametrize("ddof", range(3))
+    def test_nanvar(self, ddof, skipna):
+        self.check_funs(
+            nanops.nanvar,
+            np.var,
+            skipna,
+            allow_complex=False,
+            allow_date=False,
+            allow_obj="convert",
+            ddof=ddof,
+        )
+
+    @pytest.mark.parametrize("ddof", range(3))
+    def test_nanstd(self, ddof, skipna):
+        self.check_funs(
+            nanops.nanstd,
+            np.std,
+            skipna,
+            allow_complex=False,
+            allow_date=False,
+            allow_obj="convert",
+            ddof=ddof,
+        )
+
+    @pytest.mark.parametrize("ddof", range(3))
+    def test_nansem(self, ddof, skipna):
+        sp_stats = pytest.importorskip("scipy.stats")
+
+        with np.errstate(invalid="ignore"):
+            self.check_funs(
+                nanops.nansem,
+                sp_stats.sem,
+                skipna,
+                allow_complex=False,
+                allow_date=False,
+                allow_tdelta=False,
+                allow_obj="convert",
+                ddof=ddof,
+            )
+
+    @pytest.mark.filterwarnings("ignore::RuntimeWarning")
+    @pytest.mark.parametrize(
+        "nan_op,np_op", [(nanops.nanmin, np.min), (nanops.nanmax, np.max)]
+    )
+    def test_nanops_with_warnings(self, nan_op, np_op, skipna):
+        self.check_funs(nan_op, np_op, skipna, allow_obj=False)
+
+    def _argminmax_wrap(self, value, axis=None, func=None):
+        res = func(value, axis)
+        nans = np.min(value, axis)
+        nullnan = isna(nans)
+        if res.ndim:
+            res[nullnan] = -1
+        elif (
+            hasattr(nullnan, "all")
+            and nullnan.all()
+            or not hasattr(nullnan, "all")
+            and nullnan
+        ):
+            res = -1
+        return res
+
+    @pytest.mark.filterwarnings("ignore::RuntimeWarning")
+    def test_nanargmax(self, skipna):
+        func = partial(self._argminmax_wrap, func=np.argmax)
+        self.check_funs(nanops.nanargmax, func, skipna, allow_obj=False)
+
+    @pytest.mark.filterwarnings("ignore::RuntimeWarning")
+    def test_nanargmin(self, skipna):
+        func = partial(self._argminmax_wrap, func=np.argmin)
+        self.check_funs(nanops.nanargmin, func, skipna, allow_obj=False)
+
+    def _skew_kurt_wrap(self, values, axis=None, func=None):
+        if not isinstance(values.dtype.type, np.floating):
+            values = values.astype("f8")
+        result = func(values, axis=axis, bias=False)
+        # fix for handling cases where all elements in an axis are the same
+        if isinstance(result, np.ndarray):
+            result[np.max(values, axis=axis) == np.min(values, axis=axis)] = 0
+            return result
+        elif np.max(values) == np.min(values):
+            return 0.0
+        return result
+
+    def test_nanskew(self, skipna):
+        sp_stats = pytest.importorskip("scipy.stats")
+
+        func = partial(self._skew_kurt_wrap, func=sp_stats.skew)
+        with np.errstate(invalid="ignore"):
+            self.check_funs(
+                nanops.nanskew,
+                func,
+                skipna,
+                allow_complex=False,
+                allow_date=False,
+                allow_tdelta=False,
+            )
+
+    def test_nankurt(self, skipna):
+        sp_stats = pytest.importorskip("scipy.stats")
+
+        func1 = partial(sp_stats.kurtosis, fisher=True)
+        func = partial(self._skew_kurt_wrap, func=func1)
+        with np.errstate(invalid="ignore"):
+            self.check_funs(
+                nanops.nankurt,
+                func,
+                skipna,
+                allow_complex=False,
+                allow_date=False,
+                allow_tdelta=False,
+            )
+
+    def test_nanprod(self, skipna):
+        self.check_funs(
+            nanops.nanprod,
+            np.prod,
+            skipna,
+            allow_date=False,
+            allow_tdelta=False,
+            empty_targfunc=np.nanprod,
+        )
+
+    def check_nancorr_nancov_2d(self, checkfun, targ0, targ1, **kwargs):
+        res00 = checkfun(self.arr_float_2d, self.arr_float1_2d, **kwargs)
+        res01 = checkfun(
+            self.arr_float_2d,
+            self.arr_float1_2d,
+            min_periods=len(self.arr_float_2d) - 1,
+            **kwargs,
+        )
+        tm.assert_almost_equal(targ0, res00)
+        tm.assert_almost_equal(targ0, res01)
+
+        res10 = checkfun(self.arr_float_nan_2d, self.arr_float1_nan_2d, **kwargs)
+        res11 = checkfun(
+            self.arr_float_nan_2d,
+            self.arr_float1_nan_2d,
+            min_periods=len(self.arr_float_2d) - 1,
+            **kwargs,
+        )
+        tm.assert_almost_equal(targ1, res10)
+        tm.assert_almost_equal(targ1, res11)
+
+        targ2 = np.nan
+        res20 = checkfun(self.arr_nan_2d, self.arr_float1_2d, **kwargs)
+        res21 = checkfun(self.arr_float_2d, self.arr_nan_2d, **kwargs)
+        res22 = checkfun(self.arr_nan_2d, self.arr_nan_2d, **kwargs)
+        res23 = checkfun(self.arr_float_nan_2d, self.arr_nan_float1_2d, **kwargs)
+        res24 = checkfun(
+            self.arr_float_nan_2d,
+            self.arr_nan_float1_2d,
+            min_periods=len(self.arr_float_2d) - 1,
+            **kwargs,
+        )
+        res25 = checkfun(
+            self.arr_float_2d,
+            self.arr_float1_2d,
+            min_periods=len(self.arr_float_2d) + 1,
+            **kwargs,
+        )
+        tm.assert_almost_equal(targ2, res20)
+        tm.assert_almost_equal(targ2, res21)
+        tm.assert_almost_equal(targ2, res22)
+        tm.assert_almost_equal(targ2, res23)
+        tm.assert_almost_equal(targ2, res24)
+        tm.assert_almost_equal(targ2, res25)
+
+    def check_nancorr_nancov_1d(self, checkfun, targ0, targ1, **kwargs):
+        res00 = checkfun(self.arr_float_1d, self.arr_float1_1d, **kwargs)
+        res01 = checkfun(
+            self.arr_float_1d,
+            self.arr_float1_1d,
+            min_periods=len(self.arr_float_1d) - 1,
+            **kwargs,
+        )
+        tm.assert_almost_equal(targ0, res00)
+        tm.assert_almost_equal(targ0, res01)
+
+        res10 = checkfun(self.arr_float_nan_1d, self.arr_float1_nan_1d, **kwargs)
+        res11 = checkfun(
+            self.arr_float_nan_1d,
+            self.arr_float1_nan_1d,
+            min_periods=len(self.arr_float_1d) - 1,
+            **kwargs,
+        )
+        tm.assert_almost_equal(targ1, res10)
+        tm.assert_almost_equal(targ1, res11)
+
+        targ2 = np.nan
+        res20 = checkfun(self.arr_nan_1d, self.arr_float1_1d, **kwargs)
+        res21 = checkfun(self.arr_float_1d, self.arr_nan_1d, **kwargs)
+        res22 = checkfun(self.arr_nan_1d, self.arr_nan_1d, **kwargs)
+        res23 = checkfun(self.arr_float_nan_1d, self.arr_nan_float1_1d, **kwargs)
+        res24 = checkfun(
+            self.arr_float_nan_1d,
+            self.arr_nan_float1_1d,
+            min_periods=len(self.arr_float_1d) - 1,
+            **kwargs,
+        )
+        res25 = checkfun(
+            self.arr_float_1d,
+            self.arr_float1_1d,
+            min_periods=len(self.arr_float_1d) + 1,
+            **kwargs,
+        )
+        tm.assert_almost_equal(targ2, res20)
+        tm.assert_almost_equal(targ2, res21)
+        tm.assert_almost_equal(targ2, res22)
+        tm.assert_almost_equal(targ2, res23)
+        tm.assert_almost_equal(targ2, res24)
+        tm.assert_almost_equal(targ2, res25)
+
+    def test_nancorr(self):
+        targ0 = np.corrcoef(self.arr_float_2d, self.arr_float1_2d)[0, 1]
+        targ1 = np.corrcoef(self.arr_float_2d.flat, self.arr_float1_2d.flat)[0, 1]
+        self.check_nancorr_nancov_2d(nanops.nancorr, targ0, targ1)
+        targ0 = np.corrcoef(self.arr_float_1d, self.arr_float1_1d)[0, 1]
+        targ1 = np.corrcoef(self.arr_float_1d.flat, self.arr_float1_1d.flat)[0, 1]
+        self.check_nancorr_nancov_1d(nanops.nancorr, targ0, targ1, method="pearson")
+
+    def test_nancorr_pearson(self):
+        targ0 = np.corrcoef(self.arr_float_2d, self.arr_float1_2d)[0, 1]
+        targ1 = np.corrcoef(self.arr_float_2d.flat, self.arr_float1_2d.flat)[0, 1]
+        self.check_nancorr_nancov_2d(nanops.nancorr, targ0, targ1, method="pearson")
+        targ0 = np.corrcoef(self.arr_float_1d, self.arr_float1_1d)[0, 1]
+        targ1 = np.corrcoef(self.arr_float_1d.flat, self.arr_float1_1d.flat)[0, 1]
+        self.check_nancorr_nancov_1d(nanops.nancorr, targ0, targ1, method="pearson")
+
+    def test_nancorr_kendall(self):
+        sp_stats = pytest.importorskip("scipy.stats")
+
+        targ0 = sp_stats.kendalltau(self.arr_float_2d, self.arr_float1_2d)[0]
+        targ1 = sp_stats.kendalltau(self.arr_float_2d.flat, self.arr_float1_2d.flat)[0]
+        self.check_nancorr_nancov_2d(nanops.nancorr, targ0, targ1, method="kendall")
+        targ0 = sp_stats.kendalltau(self.arr_float_1d, self.arr_float1_1d)[0]
+        targ1 = sp_stats.kendalltau(self.arr_float_1d.flat, self.arr_float1_1d.flat)[0]
+        self.check_nancorr_nancov_1d(nanops.nancorr, targ0, targ1, method="kendall")
+
+    def test_nancorr_spearman(self):
+        sp_stats = pytest.importorskip("scipy.stats")
+
+        targ0 = sp_stats.spearmanr(self.arr_float_2d, self.arr_float1_2d)[0]
+        targ1 = sp_stats.spearmanr(self.arr_float_2d.flat, self.arr_float1_2d.flat)[0]
+        self.check_nancorr_nancov_2d(nanops.nancorr, targ0, targ1, method="spearman")
+        targ0 = sp_stats.spearmanr(self.arr_float_1d, self.arr_float1_1d)[0]
+        targ1 = sp_stats.spearmanr(self.arr_float_1d.flat, self.arr_float1_1d.flat)[0]
+        self.check_nancorr_nancov_1d(nanops.nancorr, targ0, targ1, method="spearman")
+
+    def test_invalid_method(self):
+        pytest.importorskip("scipy")
+        targ0 = np.corrcoef(self.arr_float_2d, self.arr_float1_2d)[0, 1]
+        targ1 = np.corrcoef(self.arr_float_2d.flat, self.arr_float1_2d.flat)[0, 1]
+        msg = "Unknown method 'foo', expected one of 'kendall', 'spearman'"
+        with pytest.raises(ValueError, match=msg):
+            self.check_nancorr_nancov_1d(nanops.nancorr, targ0, targ1, method="foo")
+
+    def test_nancov(self):
+        targ0 = np.cov(self.arr_float_2d, self.arr_float1_2d)[0, 1]
+        targ1 = np.cov(self.arr_float_2d.flat, self.arr_float1_2d.flat)[0, 1]
+        self.check_nancorr_nancov_2d(nanops.nancov, targ0, targ1)
+        targ0 = np.cov(self.arr_float_1d, self.arr_float1_1d)[0, 1]
+        targ1 = np.cov(self.arr_float_1d.flat, self.arr_float1_1d.flat)[0, 1]
+        self.check_nancorr_nancov_1d(nanops.nancov, targ0, targ1)
+
+
+@pytest.mark.parametrize(
+    "arr, correct",
+    [
+        ("arr_complex", False),
+        ("arr_int", False),
+        ("arr_bool", False),
+        ("arr_str", False),
+        ("arr_utf", False),
+        ("arr_complex", False),
+        ("arr_complex_nan", False),
+        ("arr_nan_nanj", False),
+        ("arr_nan_infj", True),
+        ("arr_complex_nan_infj", True),
+    ],
+)
+def test_has_infs_non_float(request, arr, correct, disable_bottleneck):
+    val = request.getfixturevalue(arr)
+    while getattr(val, "ndim", True):
+        res0 = nanops._has_infs(val)
+        if correct:
+            assert res0
+        else:
+            assert not res0
+
+        if not hasattr(val, "ndim"):
+            break
+
+        # Reduce dimension for next step in the loop
+        val = np.take(val, 0, axis=-1)
+
+
+@pytest.mark.parametrize(
+    "arr, correct",
+    [
+        ("arr_float", False),
+        ("arr_nan", False),
+        ("arr_float_nan", False),
+        ("arr_nan_nan", False),
+        ("arr_float_inf", True),
+        ("arr_inf", True),
+        ("arr_nan_inf", True),
+        ("arr_float_nan_inf", True),
+        ("arr_nan_nan_inf", True),
+    ],
+)
+@pytest.mark.parametrize("astype", [None, "f4", "f2"])
+def test_has_infs_floats(request, arr, correct, astype, disable_bottleneck):
+    val = request.getfixturevalue(arr)
+    if astype is not None:
+        val = val.astype(astype)
+    while getattr(val, "ndim", True):
+        res0 = nanops._has_infs(val)
+        if correct:
+            assert res0
+        else:
+            assert not res0
+
+        if not hasattr(val, "ndim"):
+            break
+
+        # Reduce dimension for next step in the loop
+        val = np.take(val, 0, axis=-1)
+
+
+@pytest.mark.parametrize(
+    "fixture", ["arr_float", "arr_complex", "arr_int", "arr_bool", "arr_str", "arr_utf"]
+)
+def test_bn_ok_dtype(fixture, request, disable_bottleneck):
+    obj = request.getfixturevalue(fixture)
+    assert nanops._bn_ok_dtype(obj.dtype, "test")
+
+
+@pytest.mark.parametrize(
+    "fixture",
+    [
+        "arr_date",
+        "arr_tdelta",
+        "arr_obj",
+    ],
+)
+def test_bn_not_ok_dtype(fixture, request, disable_bottleneck):
+    obj = request.getfixturevalue(fixture)
+    assert not nanops._bn_ok_dtype(obj.dtype, "test")
+
+
+class TestEnsureNumeric:
+    def test_numeric_values(self):
+        # Test integer
+        assert nanops._ensure_numeric(1) == 1
+
+        # Test float
+        assert nanops._ensure_numeric(1.1) == 1.1
+
+        # Test complex
+        assert nanops._ensure_numeric(1 + 2j) == 1 + 2j
+
+    def test_ndarray(self):
+        # Test numeric ndarray
+        values = np.array([1, 2, 3])
+        assert np.allclose(nanops._ensure_numeric(values), values)
+
+        # Test object ndarray
+        o_values = values.astype(object)
+        assert np.allclose(nanops._ensure_numeric(o_values), values)
+
+        # Test convertible string ndarray
+        s_values = np.array(["1", "2", "3"], dtype=object)
+        msg = r"Could not convert \['1' '2' '3'\] to numeric"
+        with pytest.raises(TypeError, match=msg):
+            nanops._ensure_numeric(s_values)
+
+        # Test non-convertible string ndarray
+        s_values = np.array(["foo", "bar", "baz"], dtype=object)
+        msg = r"Could not convert .* to numeric"
+        with pytest.raises(TypeError, match=msg):
+            nanops._ensure_numeric(s_values)
+
+    def test_convertable_values(self):
+        with pytest.raises(TypeError, match="Could not convert string '1' to numeric"):
+            nanops._ensure_numeric("1")
+        with pytest.raises(
+            TypeError, match="Could not convert string '1.1' to numeric"
+        ):
+            nanops._ensure_numeric("1.1")
+        with pytest.raises(
+            TypeError, match=r"Could not convert string '1\+1j' to numeric"
+        ):
+            nanops._ensure_numeric("1+1j")
+
+    def test_non_convertable_values(self):
+        msg = "Could not convert string 'foo' to numeric"
+        with pytest.raises(TypeError, match=msg):
+            nanops._ensure_numeric("foo")
+
+        # with the wrong type, python raises TypeError for us
+        msg = "argument must be a string or a number"
+        with pytest.raises(TypeError, match=msg):
+            nanops._ensure_numeric({})
+        with pytest.raises(TypeError, match=msg):
+            nanops._ensure_numeric([])
+
+
+class TestNanvarFixedValues:
+    # xref GH10242
+    # Samples from a normal distribution.
+    @pytest.fixture
+    def variance(self):
+        return 3.0
+
+    @pytest.fixture
+    def samples(self, variance):
+        return self.prng.normal(scale=variance**0.5, size=100000)
+
+    def test_nanvar_all_finite(self, samples, variance):
+        actual_variance = nanops.nanvar(samples)
+        tm.assert_almost_equal(actual_variance, variance, rtol=1e-2)
+
+    def test_nanvar_nans(self, samples, variance):
+        samples_test = np.nan * np.ones(2 * samples.shape[0])
+        samples_test[::2] = samples
+
+        actual_variance = nanops.nanvar(samples_test, skipna=True)
+        tm.assert_almost_equal(actual_variance, variance, rtol=1e-2)
+
+        actual_variance = nanops.nanvar(samples_test, skipna=False)
+        tm.assert_almost_equal(actual_variance, np.nan, rtol=1e-2)
+
+    def test_nanstd_nans(self, samples, variance):
+        samples_test = np.nan * np.ones(2 * samples.shape[0])
+        samples_test[::2] = samples
+
+        actual_std = nanops.nanstd(samples_test, skipna=True)
+        tm.assert_almost_equal(actual_std, variance**0.5, rtol=1e-2)
+
+        actual_std = nanops.nanvar(samples_test, skipna=False)
+        tm.assert_almost_equal(actual_std, np.nan, rtol=1e-2)
+
+    def test_nanvar_axis(self, samples, variance):
+        # Generate some sample data.
+        samples_unif = self.prng.uniform(size=samples.shape[0])
+        samples = np.vstack([samples, samples_unif])
+
+        actual_variance = nanops.nanvar(samples, axis=1)
+        tm.assert_almost_equal(
+            actual_variance, np.array([variance, 1.0 / 12]), rtol=1e-2
+        )
+
+    def test_nanvar_ddof(self):
+        n = 5
+        samples = self.prng.uniform(size=(10000, n + 1))
+        samples[:, -1] = np.nan  # Force use of our own algorithm.
+
+        variance_0 = nanops.nanvar(samples, axis=1, skipna=True, ddof=0).mean()
+        variance_1 = nanops.nanvar(samples, axis=1, skipna=True, ddof=1).mean()
+        variance_2 = nanops.nanvar(samples, axis=1, skipna=True, ddof=2).mean()
+
+        # The unbiased estimate.
+        var = 1.0 / 12
+        tm.assert_almost_equal(variance_1, var, rtol=1e-2)
+
+        # The underestimated variance.
+        tm.assert_almost_equal(variance_0, (n - 1.0) / n * var, rtol=1e-2)
+
+        # The overestimated variance.
+        tm.assert_almost_equal(variance_2, (n - 1.0) / (n - 2.0) * var, rtol=1e-2)
+
+    @pytest.mark.parametrize("axis", range(2))
+    @pytest.mark.parametrize("ddof", range(3))
+    def test_ground_truth(self, axis, ddof):
+        # Test against values that were precomputed with Numpy.
+        samples = np.empty((4, 4))
+        samples[:3, :3] = np.array(
+            [
+                [0.97303362, 0.21869576, 0.55560287],
+                [0.72980153, 0.03109364, 0.99155171],
+                [0.09317602, 0.60078248, 0.15871292],
+            ]
+        )
+        samples[3] = samples[:, 3] = np.nan
+
+        # Actual variances along axis=0, 1 for ddof=0, 1, 2
+        variance = np.array(
+            [
+                [
+                    [0.13762259, 0.05619224, 0.11568816],
+                    [0.20643388, 0.08428837, 0.17353224],
+                    [0.41286776, 0.16857673, 0.34706449],
+                ],
+                [
+                    [0.09519783, 0.16435395, 0.05082054],
+                    [0.14279674, 0.24653093, 0.07623082],
+                    [0.28559348, 0.49306186, 0.15246163],
+                ],
+            ]
+        )
+
+        # Test nanvar.
+        var = nanops.nanvar(samples, skipna=True, axis=axis, ddof=ddof)
+        tm.assert_almost_equal(var[:3], variance[axis, ddof])
+        assert np.isnan(var[3])
+
+        # Test nanstd.
+        std = nanops.nanstd(samples, skipna=True, axis=axis, ddof=ddof)
+        tm.assert_almost_equal(std[:3], variance[axis, ddof] ** 0.5)
+        assert np.isnan(std[3])
+
+    @pytest.mark.parametrize("ddof", range(3))
+    def test_nanstd_roundoff(self, ddof):
+        # Regression test for GH 10242 (test data taken from GH 10489). Ensure
+        # that variance is stable.
+        data = Series(766897346 * np.ones(10))
+        result = data.std(ddof=ddof)
+        assert result == 0.0
+
+    @property
+    def prng(self):
+        return np.random.default_rng(2)
+
+
+class TestNanskewFixedValues:
+    # xref GH 11974
+    # Test data + skewness value (computed with scipy.stats.skew)
+    @pytest.fixture
+    def samples(self):
+        return np.sin(np.linspace(0, 1, 200))
+
+    @pytest.fixture
+    def actual_skew(self):
+        return -0.1875895205961754
+
+    @pytest.mark.parametrize("val", [3075.2, 3075.3, 3075.5])
+    def test_constant_series(self, val):
+        # xref GH 11974
+        data = val * np.ones(300)
+        skew = nanops.nanskew(data)
+        assert skew == 0.0
+
+    def test_all_finite(self):
+        alpha, beta = 0.3, 0.1
+        left_tailed = self.prng.beta(alpha, beta, size=100)
+        assert nanops.nanskew(left_tailed) < 0
+
+        alpha, beta = 0.1, 0.3
+        right_tailed = self.prng.beta(alpha, beta, size=100)
+        assert nanops.nanskew(right_tailed) > 0
+
+    def test_ground_truth(self, samples, actual_skew):
+        skew = nanops.nanskew(samples)
+        tm.assert_almost_equal(skew, actual_skew)
+
+    def test_axis(self, samples, actual_skew):
+        samples = np.vstack([samples, np.nan * np.ones(len(samples))])
+        skew = nanops.nanskew(samples, axis=1)
+        tm.assert_almost_equal(skew, np.array([actual_skew, np.nan]))
+
+    def test_nans(self, samples):
+        samples = np.hstack([samples, np.nan])
+        skew = nanops.nanskew(samples, skipna=False)
+        assert np.isnan(skew)
+
+    def test_nans_skipna(self, samples, actual_skew):
+        samples = np.hstack([samples, np.nan])
+        skew = nanops.nanskew(samples, skipna=True)
+        tm.assert_almost_equal(skew, actual_skew)
+
+    @property
+    def prng(self):
+        return np.random.default_rng(2)
+
+
+class TestNankurtFixedValues:
+    # xref GH 11974
+    # Test data + kurtosis value (computed with scipy.stats.kurtosis)
+    @pytest.fixture
+    def samples(self):
+        return np.sin(np.linspace(0, 1, 200))
+
+    @pytest.fixture
+    def actual_kurt(self):
+        return -1.2058303433799713
+
+    @pytest.mark.parametrize("val", [3075.2, 3075.3, 3075.5])
+    def test_constant_series(self, val):
+        # xref GH 11974
+        data = val * np.ones(300)
+        kurt = nanops.nankurt(data)
+        assert kurt == 0.0
+
+    def test_all_finite(self):
+        alpha, beta = 0.3, 0.1
+        left_tailed = self.prng.beta(alpha, beta, size=100)
+        assert nanops.nankurt(left_tailed) < 2
+
+        alpha, beta = 0.1, 0.3
+        right_tailed = self.prng.beta(alpha, beta, size=100)
+        assert nanops.nankurt(right_tailed) < 0
+
+    def test_ground_truth(self, samples, actual_kurt):
+        kurt = nanops.nankurt(samples)
+        tm.assert_almost_equal(kurt, actual_kurt)
+
+    def test_axis(self, samples, actual_kurt):
+        samples = np.vstack([samples, np.nan * np.ones(len(samples))])
+        kurt = nanops.nankurt(samples, axis=1)
+        tm.assert_almost_equal(kurt, np.array([actual_kurt, np.nan]))
+
+    def test_nans(self, samples):
+        samples = np.hstack([samples, np.nan])
+        kurt = nanops.nankurt(samples, skipna=False)
+        assert np.isnan(kurt)
+
+    def test_nans_skipna(self, samples, actual_kurt):
+        samples = np.hstack([samples, np.nan])
+        kurt = nanops.nankurt(samples, skipna=True)
+        tm.assert_almost_equal(kurt, actual_kurt)
+
+    @property
+    def prng(self):
+        return np.random.default_rng(2)
+
+
+class TestDatetime64NaNOps:
+    @pytest.fixture(params=["s", "ms", "us", "ns"])
+    def unit(self, request):
+        return request.param
+
+    # Enabling mean changes the behavior of DataFrame.mean
+    # See https://github.com/pandas-dev/pandas/issues/24752
+    def test_nanmean(self, unit):
+        dti = pd.date_range("2016-01-01", periods=3).as_unit(unit)
+        expected = dti[1]
+
+        for obj in [dti, dti._data]:
+            result = nanops.nanmean(obj)
+            assert result == expected
+
+        dti2 = dti.insert(1, pd.NaT)
+
+        for obj in [dti2, dti2._data]:
+            result = nanops.nanmean(obj)
+            assert result == expected
+
+    @pytest.mark.parametrize("constructor", ["M8", "m8"])
+    def test_nanmean_skipna_false(self, constructor, unit):
+        dtype = f"{constructor}[{unit}]"
+        arr = np.arange(12).astype(np.int64).view(dtype).reshape(4, 3)
+
+        arr[-1, -1] = "NaT"
+
+        result = nanops.nanmean(arr, skipna=False)
+        assert np.isnat(result)
+        assert result.dtype == dtype
+
+        result = nanops.nanmean(arr, axis=0, skipna=False)
+        expected = np.array([4, 5, "NaT"], dtype=arr.dtype)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = nanops.nanmean(arr, axis=1, skipna=False)
+        expected = np.array([arr[0, 1], arr[1, 1], arr[2, 1], arr[-1, -1]])
+        tm.assert_numpy_array_equal(result, expected)
+
+
+def test_use_bottleneck():
+    if nanops._BOTTLENECK_INSTALLED:
+        with pd.option_context("use_bottleneck", True):
+            assert pd.get_option("use_bottleneck")
+
+        with pd.option_context("use_bottleneck", False):
+            assert not pd.get_option("use_bottleneck")
+
+
+@pytest.mark.parametrize(
+    "numpy_op, expected",
+    [
+        (np.sum, 10),
+        (np.nansum, 10),
+        (np.mean, 2.5),
+        (np.nanmean, 2.5),
+        (np.median, 2.5),
+        (np.nanmedian, 2.5),
+        (np.min, 1),
+        (np.max, 4),
+        (np.nanmin, 1),
+        (np.nanmax, 4),
+    ],
+)
+def test_numpy_ops(numpy_op, expected):
+    # GH8383
+    result = numpy_op(Series([1, 2, 3, 4]))
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "operation",
+    [
+        nanops.nanany,
+        nanops.nanall,
+        nanops.nansum,
+        nanops.nanmean,
+        nanops.nanmedian,
+        nanops.nanstd,
+        nanops.nanvar,
+        nanops.nansem,
+        nanops.nanargmax,
+        nanops.nanargmin,
+        nanops.nanmax,
+        nanops.nanmin,
+        nanops.nanskew,
+        nanops.nankurt,
+        nanops.nanprod,
+    ],
+)
+def test_nanops_independent_of_mask_param(operation):
+    # GH22764
+    ser = Series([1, 2, np.nan, 3, np.nan, 4])
+    mask = ser.isna()
+    median_expected = operation(ser._values)
+    median_result = operation(ser._values, mask=mask)
+    assert median_expected == median_result
+
+
+@pytest.mark.parametrize("min_count", [-1, 0])
+def test_check_below_min_count_negative_or_zero_min_count(min_count):
+    # GH35227
+    result = nanops.check_below_min_count((21, 37), None, min_count)
+    expected_result = False
+    assert result == expected_result
+
+
+@pytest.mark.parametrize(
+    "mask", [None, np.array([False, False, True]), np.array([True] + 9 * [False])]
+)
+@pytest.mark.parametrize("min_count, expected_result", [(1, False), (101, True)])
+def test_check_below_min_count_positive_min_count(mask, min_count, expected_result):
+    # GH35227
+    shape = (10, 10)
+    result = nanops.check_below_min_count(shape, mask, min_count)
+    assert result == expected_result
+
+
+@td.skip_if_windows
+@td.skip_if_32bit
+@pytest.mark.parametrize("min_count, expected_result", [(1, False), (2812191852, True)])
+def test_check_below_min_count_large_shape(min_count, expected_result):
+    # GH35227 large shape used to show that the issue is fixed
+    shape = (2244367, 1253)
+    result = nanops.check_below_min_count(shape, mask=None, min_count=min_count)
+    assert result == expected_result
+
+
+@pytest.mark.parametrize("func", ["nanmean", "nansum"])
+def test_check_bottleneck_disallow(any_real_numpy_dtype, func):
+    # GH 42878 bottleneck sometimes produces unreliable results for mean and sum
+    assert not nanops._bn_ok_dtype(np.dtype(any_real_numpy_dtype).type, func)
+
+
+@pytest.mark.parametrize("val", [2**55, -(2**55), 20150515061816532])
+def test_nanmean_overflow(disable_bottleneck, val):
+    # GH 10155
+    # In the previous implementation mean can overflow for int dtypes, it
+    # is now consistent with numpy
+
+    ser = Series(val, index=range(500), dtype=np.int64)
+    result = ser.mean()
+    np_result = ser.values.mean()
+    assert result == val
+    assert result == np_result
+    assert result.dtype == np.float64
+
+
+@pytest.mark.parametrize(
+    "dtype",
+    [
+        np.int16,
+        np.int32,
+        np.int64,
+        np.float32,
+        np.float64,
+        getattr(np, "float128", None),
+    ],
+)
+@pytest.mark.parametrize("method", ["mean", "std", "var", "skew", "kurt", "min", "max"])
+def test_returned_dtype(disable_bottleneck, dtype, method):
+    if dtype is None:
+        pytest.skip("np.float128 not available")
+
+    ser = Series(range(10), dtype=dtype)
+    result = getattr(ser, method)()
+    if is_integer_dtype(dtype) and method not in ["min", "max"]:
+        assert result.dtype == np.float64
+    else:
+        assert result.dtype == dtype

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas/tests/test_optional_dependency.py

@@ -0,0 +1,100 @@
+import sys
+import types
+
+import pytest
+
+from pandas.compat._optional import (
+    VERSIONS,
+    import_optional_dependency,
+)
+
+import pandas._testing as tm
+
+
+def test_import_optional():
+    match = "Missing .*notapackage.* pip .* conda .* notapackage"
+    with pytest.raises(ImportError, match=match) as exc_info:
+        import_optional_dependency("notapackage")
+    # The original exception should be there as context:
+    assert isinstance(exc_info.value.__context__, ImportError)
+
+    result = import_optional_dependency("notapackage", errors="ignore")
+    assert result is None
+
+
+def test_xlrd_version_fallback():
+    pytest.importorskip("xlrd")
+    import_optional_dependency("xlrd")
+
+
+def test_bad_version(monkeypatch):
+    name = "fakemodule"
+    module = types.ModuleType(name)
+    module.__version__ = "0.9.0"
+    sys.modules[name] = module
+    monkeypatch.setitem(VERSIONS, name, "1.0.0")
+
+    match = "Pandas requires .*1.0.0.* of .fakemodule.*'0.9.0'"
+    with pytest.raises(ImportError, match=match):
+        import_optional_dependency("fakemodule")
+
+    # Test min_version parameter
+    result = import_optional_dependency("fakemodule", min_version="0.8")
+    assert result is module
+
+    with tm.assert_produces_warning(UserWarning):
+        result = import_optional_dependency("fakemodule", errors="warn")
+    assert result is None
+
+    module.__version__ = "1.0.0"  # exact match is OK
+    result = import_optional_dependency("fakemodule")
+    assert result is module
+
+    with pytest.raises(ImportError, match="Pandas requires version '1.1.0'"):
+        import_optional_dependency("fakemodule", min_version="1.1.0")
+
+    with tm.assert_produces_warning(UserWarning):
+        result = import_optional_dependency(
+            "fakemodule", errors="warn", min_version="1.1.0"
+        )
+    assert result is None
+
+    result = import_optional_dependency(
+        "fakemodule", errors="ignore", min_version="1.1.0"
+    )
+    assert result is None
+
+
+def test_submodule(monkeypatch):
+    # Create a fake module with a submodule
+    name = "fakemodule"
+    module = types.ModuleType(name)
+    module.__version__ = "0.9.0"
+    sys.modules[name] = module
+    sub_name = "submodule"
+    submodule = types.ModuleType(sub_name)
+    setattr(module, sub_name, submodule)
+    sys.modules[f"{name}.{sub_name}"] = submodule
+    monkeypatch.setitem(VERSIONS, name, "1.0.0")
+
+    match = "Pandas requires .*1.0.0.* of .fakemodule.*'0.9.0'"
+    with pytest.raises(ImportError, match=match):
+        import_optional_dependency("fakemodule.submodule")
+
+    with tm.assert_produces_warning(UserWarning):
+        result = import_optional_dependency("fakemodule.submodule", errors="warn")
+    assert result is None
+
+    module.__version__ = "1.0.0"  # exact match is OK
+    result = import_optional_dependency("fakemodule.submodule")
+    assert result is submodule
+
+
+def test_no_version_raises(monkeypatch):
+    name = "fakemodule"
+    module = types.ModuleType(name)
+    sys.modules[name] = module
+    monkeypatch.setitem(VERSIONS, name, "1.0.0")
+
+    with pytest.raises(ImportError, match="Can't determine .* fakemodule"):
+        import_optional_dependency(name)

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas/tests/test_register_accessor.py

@@ -0,0 +1,103 @@
+from collections.abc import Generator
+import contextlib
+
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.core import accessor
+
+
+def test_dirname_mixin() -> None:
+    # GH37173
+
+    class X(accessor.DirNamesMixin):
+        x = 1
+        y: int
+
+        def __init__(self) -> None:
+            self.z = 3
+
+    result = [attr_name for attr_name in dir(X()) if not attr_name.startswith("_")]
+
+    assert result == ["x", "z"]
+
+
+@contextlib.contextmanager
+def ensure_removed(obj, attr) -> Generator[None, None, None]:
+    """Ensure that an attribute added to 'obj' during the test is
+    removed when we're done
+    """
+    try:
+        yield
+    finally:
+        try:
+            delattr(obj, attr)
+        except AttributeError:
+            pass
+        obj._accessors.discard(attr)
+
+
+class MyAccessor:
+    def __init__(self, obj) -> None:
+        self.obj = obj
+        self.item = "item"
+
+    @property
+    def prop(self):
+        return self.item
+
+    def method(self):
+        return self.item
+
+
+@pytest.mark.parametrize(
+    "obj, registrar",
+    [
+        (pd.Series, pd.api.extensions.register_series_accessor),
+        (pd.DataFrame, pd.api.extensions.register_dataframe_accessor),
+        (pd.Index, pd.api.extensions.register_index_accessor),
+    ],
+)
+def test_register(obj, registrar):
+    with ensure_removed(obj, "mine"):
+        before = set(dir(obj))
+        registrar("mine")(MyAccessor)
+        o = obj([]) if obj is not pd.Series else obj([], dtype=object)
+        assert o.mine.prop == "item"
+        after = set(dir(obj))
+        assert (before ^ after) == {"mine"}
+        assert "mine" in obj._accessors
+
+
+def test_accessor_works():
+    with ensure_removed(pd.Series, "mine"):
+        pd.api.extensions.register_series_accessor("mine")(MyAccessor)
+
+        s = pd.Series([1, 2])
+        assert s.mine.obj is s
+
+        assert s.mine.prop == "item"
+        assert s.mine.method() == "item"
+
+
+def test_overwrite_warns():
+    match = r".*MyAccessor.*fake.*Series.*"
+    with tm.assert_produces_warning(UserWarning, match=match):
+        with ensure_removed(pd.Series, "fake"):
+            setattr(pd.Series, "fake", 123)
+            pd.api.extensions.register_series_accessor("fake")(MyAccessor)
+            s = pd.Series([1, 2])
+            assert s.fake.prop == "item"
+
+
+def test_raises_attribute_error():
+    with ensure_removed(pd.Series, "bad"):
+
+        @pd.api.extensions.register_series_accessor("bad")
+        class Bad:
+            def __init__(self, data) -> None:
+                raise AttributeError("whoops")
+
+        with pytest.raises(AttributeError, match="whoops"):
+            pd.Series([], dtype=object).bad

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas/tests/test_sorting.py

@@ -0,0 +1,487 @@
+from collections import defaultdict
+from datetime import datetime
+from itertools import product
+
+import numpy as np
+import pytest
+
+from pandas import (
+    NA,
+    DataFrame,
+    MultiIndex,
+    Series,
+    array,
+    concat,
+    merge,
+)
+import pandas._testing as tm
+from pandas.core.algorithms import safe_sort
+import pandas.core.common as com
+from pandas.core.sorting import (
+    _decons_group_index,
+    get_group_index,
+    is_int64_overflow_possible,
+    lexsort_indexer,
+    nargsort,
+)
+
+
+@pytest.fixture
+def left_right():
+    low, high, n = -1 << 10, 1 << 10, 1 << 20
+    left = DataFrame(
+        np.random.default_rng(2).integers(low, high, (n, 7)), columns=list("ABCDEFG")
+    )
+    left["left"] = left.sum(axis=1)
+
+    # one-2-one match
+    i = np.random.default_rng(2).permutation(len(left))
+    right = left.iloc[i].copy()
+    right.columns = right.columns[:-1].tolist() + ["right"]
+    right.index = np.arange(len(right))
+    right["right"] *= -1
+    return left, right
+
+
+class TestSorting:
+    @pytest.mark.slow
+    def test_int64_overflow(self):
+        B = np.concatenate((np.arange(1000), np.arange(1000), np.arange(500)))
+        A = np.arange(2500)
+        df = DataFrame(
+            {
+                "A": A,
+                "B": B,
+                "C": A,
+                "D": B,
+                "E": A,
+                "F": B,
+                "G": A,
+                "H": B,
+                "values": np.random.default_rng(2).standard_normal(2500),
+            }
+        )
+
+        lg = df.groupby(["A", "B", "C", "D", "E", "F", "G", "H"])
+        rg = df.groupby(["H", "G", "F", "E", "D", "C", "B", "A"])
+
+        left = lg.sum()["values"]
+        right = rg.sum()["values"]
+
+        exp_index, _ = left.index.sortlevel()
+        tm.assert_index_equal(left.index, exp_index)
+
+        exp_index, _ = right.index.sortlevel(0)
+        tm.assert_index_equal(right.index, exp_index)
+
+        tups = list(map(tuple, df[["A", "B", "C", "D", "E", "F", "G", "H"]].values))
+        tups = com.asarray_tuplesafe(tups)
+
+        expected = df.groupby(tups).sum()["values"]
+
+        for k, v in expected.items():
+            assert left[k] == right[k[::-1]]
+            assert left[k] == v
+        assert len(left) == len(right)
+
+    def test_int64_overflow_groupby_large_range(self):
+        # GH9096
+        values = range(55109)
+        data = DataFrame.from_dict({"a": values, "b": values, "c": values, "d": values})
+        grouped = data.groupby(["a", "b", "c", "d"])
+        assert len(grouped) == len(values)
+
+    @pytest.mark.parametrize("agg", ["mean", "median"])
+    def test_int64_overflow_groupby_large_df_shuffled(self, agg):
+        rs = np.random.default_rng(2)
+        arr = rs.integers(-1 << 12, 1 << 12, (1 << 15, 5))
+        i = rs.choice(len(arr), len(arr) * 4)
+        arr = np.vstack((arr, arr[i]))  # add some duplicate rows
+
+        i = rs.permutation(len(arr))
+        arr = arr[i]  # shuffle rows
+
+        df = DataFrame(arr, columns=list("abcde"))
+        df["jim"], df["joe"] = np.zeros((2, len(df)))
+        gr = df.groupby(list("abcde"))
+
+        # verify this is testing what it is supposed to test!
+        assert is_int64_overflow_possible(gr._grouper.shape)
+
+        mi = MultiIndex.from_arrays(
+            [ar.ravel() for ar in np.array_split(np.unique(arr, axis=0), 5, axis=1)],
+            names=list("abcde"),
+        )
+
+        res = DataFrame(
+            np.zeros((len(mi), 2)), columns=["jim", "joe"], index=mi
+        ).sort_index()
+
+        tm.assert_frame_equal(getattr(gr, agg)(), res)
+
+    @pytest.mark.parametrize(
+        "order, na_position, exp",
+        [
+            [
+                True,
+                "last",
+                list(range(5, 105)) + list(range(5)) + list(range(105, 110)),
+            ],
+            [
+                True,
+                "first",
+                list(range(5)) + list(range(105, 110)) + list(range(5, 105)),
+            ],
+            [
+                False,
+                "last",
+                list(range(104, 4, -1)) + list(range(5)) + list(range(105, 110)),
+            ],
+            [
+                False,
+                "first",
+                list(range(5)) + list(range(105, 110)) + list(range(104, 4, -1)),
+            ],
+        ],
+    )
+    def test_lexsort_indexer(self, order, na_position, exp):
+        keys = [[np.nan] * 5 + list(range(100)) + [np.nan] * 5]
+        result = lexsort_indexer(keys, orders=order, na_position=na_position)
+        tm.assert_numpy_array_equal(result, np.array(exp, dtype=np.intp))
+
+    @pytest.mark.parametrize(
+        "ascending, na_position, exp",
+        [
+            [
+                True,
+                "last",
+                list(range(5, 105)) + list(range(5)) + list(range(105, 110)),
+            ],
+            [
+                True,
+                "first",
+                list(range(5)) + list(range(105, 110)) + list(range(5, 105)),
+            ],
+            [
+                False,
+                "last",
+                list(range(104, 4, -1)) + list(range(5)) + list(range(105, 110)),
+            ],
+            [
+                False,
+                "first",
+                list(range(5)) + list(range(105, 110)) + list(range(104, 4, -1)),
+            ],
+        ],
+    )
+    def test_nargsort(self, ascending, na_position, exp):
+        # list places NaNs last, np.array(..., dtype="O") may not place NaNs first
+        items = np.array([np.nan] * 5 + list(range(100)) + [np.nan] * 5, dtype="O")
+
+        # mergesort is the most difficult to get right because we want it to be
+        # stable.
+
+        # According to numpy/core/tests/test_multiarray, """The number of
+        # sorted items must be greater than ~50 to check the actual algorithm
+        # because quick and merge sort fall over to insertion sort for small
+        # arrays."""
+
+        result = nargsort(
+            items, kind="mergesort", ascending=ascending, na_position=na_position
+        )
+        tm.assert_numpy_array_equal(result, np.array(exp), check_dtype=False)
+
+
+class TestMerge:
+    def test_int64_overflow_outer_merge(self):
+        # #2690, combinatorial explosion
+        df1 = DataFrame(
+            np.random.default_rng(2).standard_normal((1000, 7)),
+            columns=list("ABCDEF") + ["G1"],
+        )
+        df2 = DataFrame(
+            np.random.default_rng(3).standard_normal((1000, 7)),
+            columns=list("ABCDEF") + ["G2"],
+        )
+        result = merge(df1, df2, how="outer")
+        assert len(result) == 2000
+
+    @pytest.mark.slow
+    def test_int64_overflow_check_sum_col(self, left_right):
+        left, right = left_right
+
+        out = merge(left, right, how="outer")
+        assert len(out) == len(left)
+        tm.assert_series_equal(out["left"], -out["right"], check_names=False)
+        result = out.iloc[:, :-2].sum(axis=1)
+        tm.assert_series_equal(out["left"], result, check_names=False)
+        assert result.name is None
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize("how", ["left", "right", "outer", "inner"])
+    def test_int64_overflow_how_merge(self, left_right, how):
+        left, right = left_right
+
+        out = merge(left, right, how="outer")
+        out.sort_values(out.columns.tolist(), inplace=True)
+        out.index = np.arange(len(out))
+        tm.assert_frame_equal(out, merge(left, right, how=how, sort=True))
+
+    @pytest.mark.slow
+    def test_int64_overflow_sort_false_order(self, left_right):
+        left, right = left_right
+
+        # check that left merge w/ sort=False maintains left frame order
+        out = merge(left, right, how="left", sort=False)
+        tm.assert_frame_equal(left, out[left.columns.tolist()])
+
+        out = merge(right, left, how="left", sort=False)
+        tm.assert_frame_equal(right, out[right.columns.tolist()])
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize("how", ["left", "right", "outer", "inner"])
+    @pytest.mark.parametrize("sort", [True, False])
+    def test_int64_overflow_one_to_many_none_match(self, how, sort):
+        # one-2-many/none match
+        low, high, n = -1 << 10, 1 << 10, 1 << 11
+        left = DataFrame(
+            np.random.default_rng(2).integers(low, high, (n, 7)).astype("int64"),
+            columns=list("ABCDEFG"),
+        )
+
+        # confirm that this is checking what it is supposed to check
+        shape = left.apply(Series.nunique).values
+        assert is_int64_overflow_possible(shape)
+
+        # add duplicates to left frame
+        left = concat([left, left], ignore_index=True)
+
+        right = DataFrame(
+            np.random.default_rng(3).integers(low, high, (n // 2, 7)).astype("int64"),
+            columns=list("ABCDEFG"),
+        )
+
+        # add duplicates & overlap with left to the right frame
+        i = np.random.default_rng(4).choice(len(left), n)
+        right = concat([right, right, left.iloc[i]], ignore_index=True)
+
+        left["left"] = np.random.default_rng(2).standard_normal(len(left))
+        right["right"] = np.random.default_rng(2).standard_normal(len(right))
+
+        # shuffle left & right frames
+        i = np.random.default_rng(5).permutation(len(left))
+        left = left.iloc[i].copy()
+        left.index = np.arange(len(left))
+
+        i = np.random.default_rng(6).permutation(len(right))
+        right = right.iloc[i].copy()
+        right.index = np.arange(len(right))
+
+        # manually compute outer merge
+        ldict, rdict = defaultdict(list), defaultdict(list)
+
+        for idx, row in left.set_index(list("ABCDEFG")).iterrows():
+            ldict[idx].append(row["left"])
+
+        for idx, row in right.set_index(list("ABCDEFG")).iterrows():
+            rdict[idx].append(row["right"])
+
+        vals = []
+        for k, lval in ldict.items():
+            rval = rdict.get(k, [np.nan])
+            for lv, rv in product(lval, rval):
+                vals.append(
+                    k
+                    + (
+                        lv,
+                        rv,
+                    )
+                )
+
+        for k, rval in rdict.items():
+            if k not in ldict:
+                vals.extend(
+                    k
+                    + (
+                        np.nan,
+                        rv,
+                    )
+                    for rv in rval
+                )
+
+        def align(df):
+            df = df.sort_values(df.columns.tolist())
+            df.index = np.arange(len(df))
+            return df
+
+        out = DataFrame(vals, columns=list("ABCDEFG") + ["left", "right"])
+        out = align(out)
+
+        jmask = {
+            "left": out["left"].notna(),
+            "right": out["right"].notna(),
+            "inner": out["left"].notna() & out["right"].notna(),
+            "outer": np.ones(len(out), dtype="bool"),
+        }
+
+        mask = jmask[how]
+        frame = align(out[mask].copy())
+        assert mask.all() ^ mask.any() or how == "outer"
+
+        res = merge(left, right, how=how, sort=sort)
+        if sort:
+            kcols = list("ABCDEFG")
+            tm.assert_frame_equal(
+                res[kcols].copy(), res[kcols].sort_values(kcols, kind="mergesort")
+            )
+
+        # as in GH9092 dtypes break with outer/right join
+        # 2021-12-18: dtype does not break anymore
+        tm.assert_frame_equal(frame, align(res))
+
+
+@pytest.mark.parametrize(
+    "codes_list, shape",
+    [
+        [
+            [
+                np.tile([0, 1, 2, 3, 0, 1, 2, 3], 100).astype(np.int64),
+                np.tile([0, 2, 4, 3, 0, 1, 2, 3], 100).astype(np.int64),
+                np.tile([5, 1, 0, 2, 3, 0, 5, 4], 100).astype(np.int64),
+            ],
+            (4, 5, 6),
+        ],
+        [
+            [
+                np.tile(np.arange(10000, dtype=np.int64), 5),
+                np.tile(np.arange(10000, dtype=np.int64), 5),
+            ],
+            (10000, 10000),
+        ],
+    ],
+)
+def test_decons(codes_list, shape):
+    group_index = get_group_index(codes_list, shape, sort=True, xnull=True)
+    codes_list2 = _decons_group_index(group_index, shape)
+
+    for a, b in zip(codes_list, codes_list2):
+        tm.assert_numpy_array_equal(a, b)
+
+
+class TestSafeSort:
+    @pytest.mark.parametrize(
+        "arg, exp",
+        [
+            [[3, 1, 2, 0, 4], [0, 1, 2, 3, 4]],
+            [
+                np.array(list("baaacb"), dtype=object),
+                np.array(list("aaabbc"), dtype=object),
+            ],
+            [[], []],
+        ],
+    )
+    def test_basic_sort(self, arg, exp):
+        result = safe_sort(np.array(arg))
+        expected = np.array(exp)
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize("verify", [True, False])
+    @pytest.mark.parametrize(
+        "codes, exp_codes",
+        [
+            [[0, 1, 1, 2, 3, 0, -1, 4], [3, 1, 1, 2, 0, 3, -1, 4]],
+            [[], []],
+        ],
+    )
+    def test_codes(self, verify, codes, exp_codes):
+        values = np.array([3, 1, 2, 0, 4])
+        expected = np.array([0, 1, 2, 3, 4])
+
+        result, result_codes = safe_sort(
+            values, codes, use_na_sentinel=True, verify=verify
+        )
+        expected_codes = np.array(exp_codes, dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+        tm.assert_numpy_array_equal(result_codes, expected_codes)
+
+    def test_codes_out_of_bound(self):
+        values = np.array([3, 1, 2, 0, 4])
+        expected = np.array([0, 1, 2, 3, 4])
+
+        # out of bound indices
+        codes = [0, 101, 102, 2, 3, 0, 99, 4]
+        result, result_codes = safe_sort(values, codes, use_na_sentinel=True)
+        expected_codes = np.array([3, -1, -1, 2, 0, 3, -1, 4], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+        tm.assert_numpy_array_equal(result_codes, expected_codes)
+
+    def test_mixed_integer(self):
+        values = np.array(["b", 1, 0, "a", 0, "b"], dtype=object)
+        result = safe_sort(values)
+        expected = np.array([0, 0, 1, "a", "b", "b"], dtype=object)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_mixed_integer_with_codes(self):
+        values = np.array(["b", 1, 0, "a"], dtype=object)
+        codes = [0, 1, 2, 3, 0, -1, 1]
+        result, result_codes = safe_sort(values, codes)
+        expected = np.array([0, 1, "a", "b"], dtype=object)
+        expected_codes = np.array([3, 1, 0, 2, 3, -1, 1], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+        tm.assert_numpy_array_equal(result_codes, expected_codes)
+
+    def test_unsortable(self):
+        # GH 13714
+        arr = np.array([1, 2, datetime.now(), 0, 3], dtype=object)
+        msg = "'[<>]' not supported between instances of .*"
+        with pytest.raises(TypeError, match=msg):
+            safe_sort(arr)
+
+    @pytest.mark.parametrize(
+        "arg, codes, err, msg",
+        [
+            [1, None, TypeError, "Only np.ndarray, ExtensionArray, and Index"],
+            [np.array([0, 1, 2]), 1, TypeError, "Only list-like objects or None"],
+            [np.array([0, 1, 2, 1]), [0, 1], ValueError, "values should be unique"],
+        ],
+    )
+    def test_exceptions(self, arg, codes, err, msg):
+        with pytest.raises(err, match=msg):
+            safe_sort(values=arg, codes=codes)
+
+    @pytest.mark.parametrize(
+        "arg, exp", [[[1, 3, 2], [1, 2, 3]], [[1, 3, np.nan, 2], [1, 2, 3, np.nan]]]
+    )
+    def test_extension_array(self, arg, exp):
+        a = array(arg, dtype="Int64")
+        result = safe_sort(a)
+        expected = array(exp, dtype="Int64")
+        tm.assert_extension_array_equal(result, expected)
+
+    @pytest.mark.parametrize("verify", [True, False])
+    def test_extension_array_codes(self, verify):
+        a = array([1, 3, 2], dtype="Int64")
+        result, codes = safe_sort(a, [0, 1, -1, 2], use_na_sentinel=True, verify=verify)
+        expected_values = array([1, 2, 3], dtype="Int64")
+        expected_codes = np.array([0, 2, -1, 1], dtype=np.intp)
+        tm.assert_extension_array_equal(result, expected_values)
+        tm.assert_numpy_array_equal(codes, expected_codes)
+
+
+def test_mixed_str_null(nulls_fixture):
+    values = np.array(["b", nulls_fixture, "a", "b"], dtype=object)
+    result = safe_sort(values)
+    expected = np.array(["a", "b", "b", nulls_fixture], dtype=object)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+def test_safe_sort_multiindex():
+    # GH#48412
+    arr1 = Series([2, 1, NA, NA], dtype="Int64")
+    arr2 = [2, 1, 3, 3]
+    midx = MultiIndex.from_arrays([arr1, arr2])
+    result = safe_sort(midx)
+    expected = MultiIndex.from_arrays(
+        [Series([1, 2, NA, NA], dtype="Int64"), [1, 2, 3, 3]]
+    )
+    tm.assert_index_equal(result, expected)

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas/tests/test_take.py

@@ -0,0 +1,307 @@
+from datetime import datetime
+
+import numpy as np
+import pytest
+
+from pandas._libs import iNaT
+
+import pandas._testing as tm
+import pandas.core.algorithms as algos
+
+
+@pytest.fixture(
+    params=[
+        (np.int8, np.int16(127), np.int8),
+        (np.int8, np.int16(128), np.int16),
+        (np.int32, 1, np.int32),
+        (np.int32, 2.0, np.float64),
+        (np.int32, 3.0 + 4.0j, np.complex128),
+        (np.int32, True, np.object_),
+        (np.int32, "", np.object_),
+        (np.float64, 1, np.float64),
+        (np.float64, 2.0, np.float64),
+        (np.float64, 3.0 + 4.0j, np.complex128),
+        (np.float64, True, np.object_),
+        (np.float64, "", np.object_),
+        (np.complex128, 1, np.complex128),
+        (np.complex128, 2.0, np.complex128),
+        (np.complex128, 3.0 + 4.0j, np.complex128),
+        (np.complex128, True, np.object_),
+        (np.complex128, "", np.object_),
+        (np.bool_, 1, np.object_),
+        (np.bool_, 2.0, np.object_),
+        (np.bool_, 3.0 + 4.0j, np.object_),
+        (np.bool_, True, np.bool_),
+        (np.bool_, "", np.object_),
+    ]
+)
+def dtype_fill_out_dtype(request):
+    return request.param
+
+
+class TestTake:
+    def test_1d_fill_nonna(self, dtype_fill_out_dtype):
+        dtype, fill_value, out_dtype = dtype_fill_out_dtype
+        data = np.random.default_rng(2).integers(0, 2, 4).astype(dtype)
+        indexer = [2, 1, 0, -1]
+
+        result = algos.take_nd(data, indexer, fill_value=fill_value)
+        assert (result[[0, 1, 2]] == data[[2, 1, 0]]).all()
+        assert result[3] == fill_value
+        assert result.dtype == out_dtype
+
+        indexer = [2, 1, 0, 1]
+
+        result = algos.take_nd(data, indexer, fill_value=fill_value)
+        assert (result[[0, 1, 2, 3]] == data[indexer]).all()
+        assert result.dtype == dtype
+
+    def test_2d_fill_nonna(self, dtype_fill_out_dtype):
+        dtype, fill_value, out_dtype = dtype_fill_out_dtype
+        data = np.random.default_rng(2).integers(0, 2, (5, 3)).astype(dtype)
+        indexer = [2, 1, 0, -1]
+
+        result = algos.take_nd(data, indexer, axis=0, fill_value=fill_value)
+        assert (result[[0, 1, 2], :] == data[[2, 1, 0], :]).all()
+        assert (result[3, :] == fill_value).all()
+        assert result.dtype == out_dtype
+
+        result = algos.take_nd(data, indexer, axis=1, fill_value=fill_value)
+        assert (result[:, [0, 1, 2]] == data[:, [2, 1, 0]]).all()
+        assert (result[:, 3] == fill_value).all()
+        assert result.dtype == out_dtype
+
+        indexer = [2, 1, 0, 1]
+        result = algos.take_nd(data, indexer, axis=0, fill_value=fill_value)
+        assert (result[[0, 1, 2, 3], :] == data[indexer, :]).all()
+        assert result.dtype == dtype
+
+        result = algos.take_nd(data, indexer, axis=1, fill_value=fill_value)
+        assert (result[:, [0, 1, 2, 3]] == data[:, indexer]).all()
+        assert result.dtype == dtype
+
+    def test_3d_fill_nonna(self, dtype_fill_out_dtype):
+        dtype, fill_value, out_dtype = dtype_fill_out_dtype
+
+        data = np.random.default_rng(2).integers(0, 2, (5, 4, 3)).astype(dtype)
+        indexer = [2, 1, 0, -1]
+
+        result = algos.take_nd(data, indexer, axis=0, fill_value=fill_value)
+        assert (result[[0, 1, 2], :, :] == data[[2, 1, 0], :, :]).all()
+        assert (result[3, :, :] == fill_value).all()
+        assert result.dtype == out_dtype
+
+        result = algos.take_nd(data, indexer, axis=1, fill_value=fill_value)
+        assert (result[:, [0, 1, 2], :] == data[:, [2, 1, 0], :]).all()
+        assert (result[:, 3, :] == fill_value).all()
+        assert result.dtype == out_dtype
+
+        result = algos.take_nd(data, indexer, axis=2, fill_value=fill_value)
+        assert (result[:, :, [0, 1, 2]] == data[:, :, [2, 1, 0]]).all()
+        assert (result[:, :, 3] == fill_value).all()
+        assert result.dtype == out_dtype
+
+        indexer = [2, 1, 0, 1]
+        result = algos.take_nd(data, indexer, axis=0, fill_value=fill_value)
+        assert (result[[0, 1, 2, 3], :, :] == data[indexer, :, :]).all()
+        assert result.dtype == dtype
+
+        result = algos.take_nd(data, indexer, axis=1, fill_value=fill_value)
+        assert (result[:, [0, 1, 2, 3], :] == data[:, indexer, :]).all()
+        assert result.dtype == dtype
+
+        result = algos.take_nd(data, indexer, axis=2, fill_value=fill_value)
+        assert (result[:, :, [0, 1, 2, 3]] == data[:, :, indexer]).all()
+        assert result.dtype == dtype
+
+    def test_1d_other_dtypes(self):
+        arr = np.random.default_rng(2).standard_normal(10).astype(np.float32)
+
+        indexer = [1, 2, 3, -1]
+        result = algos.take_nd(arr, indexer)
+        expected = arr.take(indexer)
+        expected[-1] = np.nan
+        tm.assert_almost_equal(result, expected)
+
+    def test_2d_other_dtypes(self):
+        arr = np.random.default_rng(2).standard_normal((10, 5)).astype(np.float32)
+
+        indexer = [1, 2, 3, -1]
+
+        # axis=0
+        result = algos.take_nd(arr, indexer, axis=0)
+        expected = arr.take(indexer, axis=0)
+        expected[-1] = np.nan
+        tm.assert_almost_equal(result, expected)
+
+        # axis=1
+        result = algos.take_nd(arr, indexer, axis=1)
+        expected = arr.take(indexer, axis=1)
+        expected[:, -1] = np.nan
+        tm.assert_almost_equal(result, expected)
+
+    def test_1d_bool(self):
+        arr = np.array([0, 1, 0], dtype=bool)
+
+        result = algos.take_nd(arr, [0, 2, 2, 1])
+        expected = arr.take([0, 2, 2, 1])
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = algos.take_nd(arr, [0, 2, -1])
+        assert result.dtype == np.object_
+
+    def test_2d_bool(self):
+        arr = np.array([[0, 1, 0], [1, 0, 1], [0, 1, 1]], dtype=bool)
+
+        result = algos.take_nd(arr, [0, 2, 2, 1])
+        expected = arr.take([0, 2, 2, 1], axis=0)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = algos.take_nd(arr, [0, 2, 2, 1], axis=1)
+        expected = arr.take([0, 2, 2, 1], axis=1)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = algos.take_nd(arr, [0, 2, -1])
+        assert result.dtype == np.object_
+
+    def test_2d_float32(self):
+        arr = np.random.default_rng(2).standard_normal((4, 3)).astype(np.float32)
+        indexer = [0, 2, -1, 1, -1]
+
+        # axis=0
+        result = algos.take_nd(arr, indexer, axis=0)
+
+        expected = arr.take(indexer, axis=0)
+        expected[[2, 4], :] = np.nan
+        tm.assert_almost_equal(result, expected)
+
+        # axis=1
+        result = algos.take_nd(arr, indexer, axis=1)
+        expected = arr.take(indexer, axis=1)
+        expected[:, [2, 4]] = np.nan
+        tm.assert_almost_equal(result, expected)
+
+    def test_2d_datetime64(self):
+        # 2005/01/01 - 2006/01/01
+        arr = (
+            np.random.default_rng(2).integers(11_045_376, 11_360_736, (5, 3))
+            * 100_000_000_000
+        )
+        arr = arr.view(dtype="datetime64[ns]")
+        indexer = [0, 2, -1, 1, -1]
+
+        # axis=0
+        result = algos.take_nd(arr, indexer, axis=0)
+        expected = arr.take(indexer, axis=0)
+        expected.view(np.int64)[[2, 4], :] = iNaT
+        tm.assert_almost_equal(result, expected)
+
+        result = algos.take_nd(arr, indexer, axis=0, fill_value=datetime(2007, 1, 1))
+        expected = arr.take(indexer, axis=0)
+        expected[[2, 4], :] = datetime(2007, 1, 1)
+        tm.assert_almost_equal(result, expected)
+
+        # axis=1
+        result = algos.take_nd(arr, indexer, axis=1)
+        expected = arr.take(indexer, axis=1)
+        expected.view(np.int64)[:, [2, 4]] = iNaT
+        tm.assert_almost_equal(result, expected)
+
+        result = algos.take_nd(arr, indexer, axis=1, fill_value=datetime(2007, 1, 1))
+        expected = arr.take(indexer, axis=1)
+        expected[:, [2, 4]] = datetime(2007, 1, 1)
+        tm.assert_almost_equal(result, expected)
+
+    def test_take_axis_0(self):
+        arr = np.arange(12).reshape(4, 3)
+        result = algos.take(arr, [0, -1])
+        expected = np.array([[0, 1, 2], [9, 10, 11]])
+        tm.assert_numpy_array_equal(result, expected)
+
+        # allow_fill=True
+        result = algos.take(arr, [0, -1], allow_fill=True, fill_value=0)
+        expected = np.array([[0, 1, 2], [0, 0, 0]])
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_take_axis_1(self):
+        arr = np.arange(12).reshape(4, 3)
+        result = algos.take(arr, [0, -1], axis=1)
+        expected = np.array([[0, 2], [3, 5], [6, 8], [9, 11]])
+        tm.assert_numpy_array_equal(result, expected)
+
+        # allow_fill=True
+        result = algos.take(arr, [0, -1], axis=1, allow_fill=True, fill_value=0)
+        expected = np.array([[0, 0], [3, 0], [6, 0], [9, 0]])
+        tm.assert_numpy_array_equal(result, expected)
+
+        # GH#26976 make sure we validate along the correct axis
+        with pytest.raises(IndexError, match="indices are out-of-bounds"):
+            algos.take(arr, [0, 3], axis=1, allow_fill=True, fill_value=0)
+
+    def test_take_non_hashable_fill_value(self):
+        arr = np.array([1, 2, 3])
+        indexer = np.array([1, -1])
+        with pytest.raises(ValueError, match="fill_value must be a scalar"):
+            algos.take(arr, indexer, allow_fill=True, fill_value=[1])
+
+        # with object dtype it is allowed
+        arr = np.array([1, 2, 3], dtype=object)
+        result = algos.take(arr, indexer, allow_fill=True, fill_value=[1])
+        expected = np.array([2, [1]], dtype=object)
+        tm.assert_numpy_array_equal(result, expected)
+
+
+class TestExtensionTake:
+    # The take method found in pd.api.extensions
+
+    def test_bounds_check_large(self):
+        arr = np.array([1, 2])
+
+        msg = "indices are out-of-bounds"
+        with pytest.raises(IndexError, match=msg):
+            algos.take(arr, [2, 3], allow_fill=True)
+
+        msg = "index 2 is out of bounds for( axis 0 with)? size 2"
+        with pytest.raises(IndexError, match=msg):
+            algos.take(arr, [2, 3], allow_fill=False)
+
+    def test_bounds_check_small(self):
+        arr = np.array([1, 2, 3], dtype=np.int64)
+        indexer = [0, -1, -2]
+
+        msg = r"'indices' contains values less than allowed \(-2 < -1\)"
+        with pytest.raises(ValueError, match=msg):
+            algos.take(arr, indexer, allow_fill=True)
+
+        result = algos.take(arr, indexer)
+        expected = np.array([1, 3, 2], dtype=np.int64)
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize("allow_fill", [True, False])
+    def test_take_empty(self, allow_fill):
+        arr = np.array([], dtype=np.int64)
+        # empty take is ok
+        result = algos.take(arr, [], allow_fill=allow_fill)
+        tm.assert_numpy_array_equal(arr, result)
+
+        msg = "|".join(
+            [
+                "cannot do a non-empty take from an empty axes.",
+                "indices are out-of-bounds",
+            ]
+        )
+        with pytest.raises(IndexError, match=msg):
+            algos.take(arr, [0], allow_fill=allow_fill)
+
+    def test_take_na_empty(self):
+        result = algos.take(np.array([]), [-1, -1], allow_fill=True, fill_value=0.0)
+        expected = np.array([0.0, 0.0])
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_take_coerces_list(self):
+        arr = [1, 2, 3]
+        msg = "take accepting non-standard inputs is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = algos.take(arr, [0, 0])
+        expected = np.array([1, 1])
+        tm.assert_numpy_array_equal(result, expected)

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas/util/__init__.py

@@ -0,0 +1,29 @@
+def __getattr__(key: str):
+    # These imports need to be lazy to avoid circular import errors
+    if key == "hash_array":
+        from pandas.core.util.hashing import hash_array
+
+        return hash_array
+    if key == "hash_pandas_object":
+        from pandas.core.util.hashing import hash_pandas_object
+
+        return hash_pandas_object
+    if key == "Appender":
+        from pandas.util._decorators import Appender
+
+        return Appender
+    if key == "Substitution":
+        from pandas.util._decorators import Substitution
+
+        return Substitution
+
+    if key == "cache_readonly":
+        from pandas.util._decorators import cache_readonly
+
+        return cache_readonly
+
+    raise AttributeError(f"module 'pandas.util' has no attribute '{key}'")
+
+
+def capitalize_first_letter(s):
+    return s[:1].upper() + s[1:]

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas/util/_decorators.py

@@ -0,0 +1,508 @@
+from __future__ import annotations
+
+from functools import wraps
+import inspect
+from textwrap import dedent
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    cast,
+)
+import warnings
+
+from pandas._libs.properties import cache_readonly
+from pandas._typing import (
+    F,
+    T,
+)
+from pandas.util._exceptions import find_stack_level
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+
+def deprecate(
+    name: str,
+    alternative: Callable[..., Any],
+    version: str,
+    alt_name: str | None = None,
+    klass: type[Warning] | None = None,
+    stacklevel: int = 2,
+    msg: str | None = None,
+) -> Callable[[F], F]:
+    """
+    Return a new function that emits a deprecation warning on use.
+
+    To use this method for a deprecated function, another function
+    `alternative` with the same signature must exist. The deprecated
+    function will emit a deprecation warning, and in the docstring
+    it will contain the deprecation directive with the provided version
+    so it can be detected for future removal.
+
+    Parameters
+    ----------
+    name : str
+        Name of function to deprecate.
+    alternative : func
+        Function to use instead.
+    version : str
+        Version of pandas in which the method has been deprecated.
+    alt_name : str, optional
+        Name to use in preference of alternative.__name__.
+    klass : Warning, default FutureWarning
+    stacklevel : int, default 2
+    msg : str
+        The message to display in the warning.
+        Default is '{name} is deprecated. Use {alt_name} instead.'
+    """
+    alt_name = alt_name or alternative.__name__
+    klass = klass or FutureWarning
+    warning_msg = msg or f"{name} is deprecated, use {alt_name} instead."
+
+    @wraps(alternative)
+    def wrapper(*args, **kwargs) -> Callable[..., Any]:
+        warnings.warn(warning_msg, klass, stacklevel=stacklevel)
+        return alternative(*args, **kwargs)
+
+    # adding deprecated directive to the docstring
+    msg = msg or f"Use `{alt_name}` instead."
+    doc_error_msg = (
+        "deprecate needs a correctly formatted docstring in "
+        "the target function (should have a one liner short "
+        "summary, and opening quotes should be in their own "
+        f"line). Found:\n{alternative.__doc__}"
+    )
+
+    # when python is running in optimized mode (i.e. `-OO`), docstrings are
+    # removed, so we check that a docstring with correct formatting is used
+    # but we allow empty docstrings
+    if alternative.__doc__:
+        if alternative.__doc__.count("\n") < 3:
+            raise AssertionError(doc_error_msg)
+        empty1, summary, empty2, doc_string = alternative.__doc__.split("\n", 3)
+        if empty1 or empty2 and not summary:
+            raise AssertionError(doc_error_msg)
+        wrapper.__doc__ = dedent(
+            f"""
+        {summary.strip()}
+
+        .. deprecated:: {version}
+            {msg}
+
+        {dedent(doc_string)}"""
+        )
+    # error: Incompatible return value type (got "Callable[[VarArg(Any), KwArg(Any)],
+    # Callable[...,Any]]", expected "Callable[[F], F]")
+    return wrapper  # type: ignore[return-value]
+
+
+def deprecate_kwarg(
+    old_arg_name: str,
+    new_arg_name: str | None,
+    mapping: Mapping[Any, Any] | Callable[[Any], Any] | None = None,
+    stacklevel: int = 2,
+) -> Callable[[F], F]:
+    """
+    Decorator to deprecate a keyword argument of a function.
+
+    Parameters
+    ----------
+    old_arg_name : str
+        Name of argument in function to deprecate
+    new_arg_name : str or None
+        Name of preferred argument in function. Use None to raise warning that
+        ``old_arg_name`` keyword is deprecated.
+    mapping : dict or callable
+        If mapping is present, use it to translate old arguments to
+        new arguments. A callable must do its own value checking;
+        values not found in a dict will be forwarded unchanged.
+
+    Examples
+    --------
+    The following deprecates 'cols', using 'columns' instead
+
+    >>> @deprecate_kwarg(old_arg_name='cols', new_arg_name='columns')
+    ... def f(columns=''):
+    ...     print(columns)
+    ...
+    >>> f(columns='should work ok')
+    should work ok
+
+    >>> f(cols='should raise warning')  # doctest: +SKIP
+    FutureWarning: cols is deprecated, use columns instead
+      warnings.warn(msg, FutureWarning)
+    should raise warning
+
+    >>> f(cols='should error', columns="can\'t pass do both")  # doctest: +SKIP
+    TypeError: Can only specify 'cols' or 'columns', not both
+
+    >>> @deprecate_kwarg('old', 'new', {'yes': True, 'no': False})
+    ... def f(new=False):
+    ...     print('yes!' if new else 'no!')
+    ...
+    >>> f(old='yes')  # doctest: +SKIP
+    FutureWarning: old='yes' is deprecated, use new=True instead
+      warnings.warn(msg, FutureWarning)
+    yes!
+
+    To raise a warning that a keyword will be removed entirely in the future
+
+    >>> @deprecate_kwarg(old_arg_name='cols', new_arg_name=None)
+    ... def f(cols='', another_param=''):
+    ...     print(cols)
+    ...
+    >>> f(cols='should raise warning')  # doctest: +SKIP
+    FutureWarning: the 'cols' keyword is deprecated and will be removed in a
+    future version please takes steps to stop use of 'cols'
+    should raise warning
+    >>> f(another_param='should not raise warning')  # doctest: +SKIP
+    should not raise warning
+
+    >>> f(cols='should raise warning', another_param='')  # doctest: +SKIP
+    FutureWarning: the 'cols' keyword is deprecated and will be removed in a
+    future version please takes steps to stop use of 'cols'
+    should raise warning
+    """
+    if mapping is not None and not hasattr(mapping, "get") and not callable(mapping):
+        raise TypeError(
+            "mapping from old to new argument values must be dict or callable!"
+        )
+
+    def _deprecate_kwarg(func: F) -> F:
+        @wraps(func)
+        def wrapper(*args, **kwargs) -> Callable[..., Any]:
+            old_arg_value = kwargs.pop(old_arg_name, None)
+
+            if old_arg_value is not None:
+                if new_arg_name is None:
+                    msg = (
+                        f"the {repr(old_arg_name)} keyword is deprecated and "
+                        "will be removed in a future version. Please take "
+                        f"steps to stop the use of {repr(old_arg_name)}"
+                    )
+                    warnings.warn(msg, FutureWarning, stacklevel=stacklevel)
+                    kwargs[old_arg_name] = old_arg_value
+                    return func(*args, **kwargs)
+
+                elif mapping is not None:
+                    if callable(mapping):
+                        new_arg_value = mapping(old_arg_value)
+                    else:
+                        new_arg_value = mapping.get(old_arg_value, old_arg_value)
+                    msg = (
+                        f"the {old_arg_name}={repr(old_arg_value)} keyword is "
+                        "deprecated, use "
+                        f"{new_arg_name}={repr(new_arg_value)} instead."
+                    )
+                else:
+                    new_arg_value = old_arg_value
+                    msg = (
+                        f"the {repr(old_arg_name)} keyword is deprecated, "
+                        f"use {repr(new_arg_name)} instead."
+                    )
+
+                warnings.warn(msg, FutureWarning, stacklevel=stacklevel)
+                if kwargs.get(new_arg_name) is not None:
+                    msg = (
+                        f"Can only specify {repr(old_arg_name)} "
+                        f"or {repr(new_arg_name)}, not both."
+                    )
+                    raise TypeError(msg)
+                kwargs[new_arg_name] = new_arg_value
+            return func(*args, **kwargs)
+
+        return cast(F, wrapper)
+
+    return _deprecate_kwarg
+
+
+def _format_argument_list(allow_args: list[str]) -> str:
+    """
+    Convert the allow_args argument (either string or integer) of
+    `deprecate_nonkeyword_arguments` function to a string describing
+    it to be inserted into warning message.
+
+    Parameters
+    ----------
+    allowed_args : list, tuple or int
+        The `allowed_args` argument for `deprecate_nonkeyword_arguments`,
+        but None value is not allowed.
+
+    Returns
+    -------
+    str
+        The substring describing the argument list in best way to be
+        inserted to the warning message.
+
+    Examples
+    --------
+    `format_argument_list([])` -> ''
+    `format_argument_list(['a'])` -> "except for the arguments 'a'"
+    `format_argument_list(['a', 'b'])` -> "except for the arguments 'a' and 'b'"
+    `format_argument_list(['a', 'b', 'c'])` ->
+        "except for the arguments 'a', 'b' and 'c'"
+    """
+    if "self" in allow_args:
+        allow_args.remove("self")
+    if not allow_args:
+        return ""
+    elif len(allow_args) == 1:
+        return f" except for the argument '{allow_args[0]}'"
+    else:
+        last = allow_args[-1]
+        args = ", ".join(["'" + x + "'" for x in allow_args[:-1]])
+        return f" except for the arguments {args} and '{last}'"
+
+
+def future_version_msg(version: str | None) -> str:
+    """Specify which version of pandas the deprecation will take place in."""
+    if version is None:
+        return "In a future version of pandas"
+    else:
+        return f"Starting with pandas version {version}"
+
+
+def deprecate_nonkeyword_arguments(
+    version: str | None,
+    allowed_args: list[str] | None = None,
+    name: str | None = None,
+) -> Callable[[F], F]:
+    """
+    Decorator to deprecate a use of non-keyword arguments of a function.
+
+    Parameters
+    ----------
+    version : str, optional
+        The version in which positional arguments will become
+        keyword-only. If None, then the warning message won't
+        specify any particular version.
+
+    allowed_args : list, optional
+        In case of list, it must be the list of names of some
+        first arguments of the decorated functions that are
+        OK to be given as positional arguments. In case of None value,
+        defaults to list of all arguments not having the
+        default value.
+
+    name : str, optional
+        The specific name of the function to show in the warning
+        message. If None, then the Qualified name of the function
+        is used.
+    """
+
+    def decorate(func):
+        old_sig = inspect.signature(func)
+
+        if allowed_args is not None:
+            allow_args = allowed_args
+        else:
+            allow_args = [
+                p.name
+                for p in old_sig.parameters.values()
+                if p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD)
+                and p.default is p.empty
+            ]
+
+        new_params = [
+            p.replace(kind=p.KEYWORD_ONLY)
+            if (
+                p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD)
+                and p.name not in allow_args
+            )
+            else p
+            for p in old_sig.parameters.values()
+        ]
+        new_params.sort(key=lambda p: p.kind)
+        new_sig = old_sig.replace(parameters=new_params)
+
+        num_allow_args = len(allow_args)
+        msg = (
+            f"{future_version_msg(version)} all arguments of "
+            f"{name or func.__qualname__}{{arguments}} will be keyword-only."
+        )
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            if len(args) > num_allow_args:
+                warnings.warn(
+                    msg.format(arguments=_format_argument_list(allow_args)),
+                    FutureWarning,
+                    stacklevel=find_stack_level(),
+                )
+            return func(*args, **kwargs)
+
+        # error: "Callable[[VarArg(Any), KwArg(Any)], Any]" has no
+        # attribute "__signature__"
+        wrapper.__signature__ = new_sig  # type: ignore[attr-defined]
+        return wrapper
+
+    return decorate
+
+
+def doc(*docstrings: None | str | Callable, **params) -> Callable[[F], F]:
+    """
+    A decorator to take docstring templates, concatenate them and perform string
+    substitution on them.
+
+    This decorator will add a variable "_docstring_components" to the wrapped
+    callable to keep track the original docstring template for potential usage.
+    If it should be consider as a template, it will be saved as a string.
+    Otherwise, it will be saved as callable, and later user __doc__ and dedent
+    to get docstring.
+
+    Parameters
+    ----------
+    *docstrings : None, str, or callable
+        The string / docstring / docstring template to be appended in order
+        after default docstring under callable.
+    **params
+        The string which would be used to format docstring template.
+    """
+
+    def decorator(decorated: F) -> F:
+        # collecting docstring and docstring templates
+        docstring_components: list[str | Callable] = []
+        if decorated.__doc__:
+            docstring_components.append(dedent(decorated.__doc__))
+
+        for docstring in docstrings:
+            if docstring is None:
+                continue
+            if hasattr(docstring, "_docstring_components"):
+                docstring_components.extend(
+                    docstring._docstring_components  # pyright: ignore[reportGeneralTypeIssues]
+                )
+            elif isinstance(docstring, str) or docstring.__doc__:
+                docstring_components.append(docstring)
+
+        params_applied = [
+            component.format(**params)
+            if isinstance(component, str) and len(params) > 0
+            else component
+            for component in docstring_components
+        ]
+
+        decorated.__doc__ = "".join(
+            [
+                component
+                if isinstance(component, str)
+                else dedent(component.__doc__ or "")
+                for component in params_applied
+            ]
+        )
+
+        # error: "F" has no attribute "_docstring_components"
+        decorated._docstring_components = (  # type: ignore[attr-defined]
+            docstring_components
+        )
+        return decorated
+
+    return decorator
+
+
+# Substitution and Appender are derived from matplotlib.docstring (1.1.0)
+# module https://matplotlib.org/users/license.html
+
+
+class Substitution:
+    """
+    A decorator to take a function's docstring and perform string
+    substitution on it.
+
+    This decorator should be robust even if func.__doc__ is None
+    (for example, if -OO was passed to the interpreter)
+
+    Usage: construct a docstring.Substitution with a sequence or
+    dictionary suitable for performing substitution; then
+    decorate a suitable function with the constructed object. e.g.
+
+    sub_author_name = Substitution(author='Jason')
+
+    @sub_author_name
+    def some_function(x):
+        "%(author)s wrote this function"
+
+    # note that some_function.__doc__ is now "Jason wrote this function"
+
+    One can also use positional arguments.
+
+    sub_first_last_names = Substitution('Edgar Allen', 'Poe')
+
+    @sub_first_last_names
+    def some_function(x):
+        "%s %s wrote the Raven"
+    """
+
+    def __init__(self, *args, **kwargs) -> None:
+        if args and kwargs:
+            raise AssertionError("Only positional or keyword args are allowed")
+
+        self.params = args or kwargs
+
+    def __call__(self, func: F) -> F:
+        func.__doc__ = func.__doc__ and func.__doc__ % self.params
+        return func
+
+    def update(self, *args, **kwargs) -> None:
+        """
+        Update self.params with supplied args.
+        """
+        if isinstance(self.params, dict):
+            self.params.update(*args, **kwargs)
+
+
+class Appender:
+    """
+    A function decorator that will append an addendum to the docstring
+    of the target function.
+
+    This decorator should be robust even if func.__doc__ is None
+    (for example, if -OO was passed to the interpreter).
+
+    Usage: construct a docstring.Appender with a string to be joined to
+    the original docstring. An optional 'join' parameter may be supplied
+    which will be used to join the docstring and addendum. e.g.
+
+    add_copyright = Appender("Copyright (c) 2009", join='\n')
+
+    @add_copyright
+    def my_dog(has='fleas'):
+        "This docstring will have a copyright below"
+        pass
+    """
+
+    addendum: str | None
+
+    def __init__(self, addendum: str | None, join: str = "", indents: int = 0) -> None:
+        if indents > 0:
+            self.addendum = indent(addendum, indents=indents)
+        else:
+            self.addendum = addendum
+        self.join = join
+
+    def __call__(self, func: T) -> T:
+        func.__doc__ = func.__doc__ if func.__doc__ else ""
+        self.addendum = self.addendum if self.addendum else ""
+        docitems = [func.__doc__, self.addendum]
+        func.__doc__ = dedent(self.join.join(docitems))
+        return func
+
+
+def indent(text: str | None, indents: int = 1) -> str:
+    if not text or not isinstance(text, str):
+        return ""
+    jointext = "".join(["\n"] + ["    "] * indents)
+    return jointext.join(text.split("\n"))
+
+
+__all__ = [
+    "Appender",
+    "cache_readonly",
+    "deprecate",
+    "deprecate_kwarg",
+    "deprecate_nonkeyword_arguments",
+    "doc",
+    "future_version_msg",
+    "Substitution",
+]

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas/util/_doctools.py

@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+import pandas as pd
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+
+class TablePlotter:
+    """
+    Layout some DataFrames in vertical/horizontal layout for explanation.
+    Used in merging.rst
+    """
+
+    def __init__(
+        self,
+        cell_width: float = 0.37,
+        cell_height: float = 0.25,
+        font_size: float = 7.5,
+    ) -> None:
+        self.cell_width = cell_width
+        self.cell_height = cell_height
+        self.font_size = font_size
+
+    def _shape(self, df: pd.DataFrame) -> tuple[int, int]:
+        """
+        Calculate table shape considering index levels.
+        """
+        row, col = df.shape
+        return row + df.columns.nlevels, col + df.index.nlevels
+
+    def _get_cells(self, left, right, vertical) -> tuple[int, int]:
+        """
+        Calculate appropriate figure size based on left and right data.
+        """
+        if vertical:
+            # calculate required number of cells
+            vcells = max(sum(self._shape(df)[0] for df in left), self._shape(right)[0])
+            hcells = max(self._shape(df)[1] for df in left) + self._shape(right)[1]
+        else:
+            vcells = max([self._shape(df)[0] for df in left] + [self._shape(right)[0]])
+            hcells = sum([self._shape(df)[1] for df in left] + [self._shape(right)[1]])
+        return hcells, vcells
+
+    def plot(self, left, right, labels: Iterable[str] = (), vertical: bool = True):
+        """
+        Plot left / right DataFrames in specified layout.
+
+        Parameters
+        ----------
+        left : list of DataFrames before operation is applied
+        right : DataFrame of operation result
+        labels : list of str to be drawn as titles of left DataFrames
+        vertical : bool, default True
+            If True, use vertical layout. If False, use horizontal layout.
+        """
+        from matplotlib import gridspec
+        import matplotlib.pyplot as plt
+
+        if not isinstance(left, list):
+            left = [left]
+        left = [self._conv(df) for df in left]
+        right = self._conv(right)
+
+        hcells, vcells = self._get_cells(left, right, vertical)
+
+        if vertical:
+            figsize = self.cell_width * hcells, self.cell_height * vcells
+        else:
+            # include margin for titles
+            figsize = self.cell_width * hcells, self.cell_height * vcells
+        fig = plt.figure(figsize=figsize)
+
+        if vertical:
+            gs = gridspec.GridSpec(len(left), hcells)
+            # left
+            max_left_cols = max(self._shape(df)[1] for df in left)
+            max_left_rows = max(self._shape(df)[0] for df in left)
+            for i, (_left, _label) in enumerate(zip(left, labels)):
+                ax = fig.add_subplot(gs[i, 0:max_left_cols])
+                self._make_table(ax, _left, title=_label, height=1.0 / max_left_rows)
+            # right
+            ax = plt.subplot(gs[:, max_left_cols:])
+            self._make_table(ax, right, title="Result", height=1.05 / vcells)
+            fig.subplots_adjust(top=0.9, bottom=0.05, left=0.05, right=0.95)
+        else:
+            max_rows = max(self._shape(df)[0] for df in left + [right])
+            height = 1.0 / np.max(max_rows)
+            gs = gridspec.GridSpec(1, hcells)
+            # left
+            i = 0
+            for df, _label in zip(left, labels):
+                sp = self._shape(df)
+                ax = fig.add_subplot(gs[0, i : i + sp[1]])
+                self._make_table(ax, df, title=_label, height=height)
+                i += sp[1]
+            # right
+            ax = plt.subplot(gs[0, i:])
+            self._make_table(ax, right, title="Result", height=height)
+            fig.subplots_adjust(top=0.85, bottom=0.05, left=0.05, right=0.95)
+
+        return fig
+
+    def _conv(self, data):
+        """
+        Convert each input to appropriate for table outplot.
+        """
+        if isinstance(data, pd.Series):
+            if data.name is None:
+                data = data.to_frame(name="")
+            else:
+                data = data.to_frame()
+        data = data.fillna("NaN")
+        return data
+
+    def _insert_index(self, data):
+        # insert is destructive
+        data = data.copy()
+        idx_nlevels = data.index.nlevels
+        if idx_nlevels == 1:
+            data.insert(0, "Index", data.index)
+        else:
+            for i in range(idx_nlevels):
+                data.insert(i, f"Index{i}", data.index._get_level_values(i))
+
+        col_nlevels = data.columns.nlevels
+        if col_nlevels > 1:
+            col = data.columns._get_level_values(0)
+            values = [
+                data.columns._get_level_values(i)._values for i in range(1, col_nlevels)
+            ]
+            col_df = pd.DataFrame(values)
+            data.columns = col_df.columns
+            data = pd.concat([col_df, data])
+            data.columns = col
+        return data
+
+    def _make_table(self, ax, df, title: str, height: float | None = None) -> None:
+        if df is None:
+            ax.set_visible(False)
+            return
+
+        from pandas import plotting
+
+        idx_nlevels = df.index.nlevels
+        col_nlevels = df.columns.nlevels
+        # must be convert here to get index levels for colorization
+        df = self._insert_index(df)
+        tb = plotting.table(ax, df, loc=9)
+        tb.set_fontsize(self.font_size)
+
+        if height is None:
+            height = 1.0 / (len(df) + 1)
+
+        props = tb.properties()
+        for (r, c), cell in props["celld"].items():
+            if c == -1:
+                cell.set_visible(False)
+            elif r < col_nlevels and c < idx_nlevels:
+                cell.set_visible(False)
+            elif r < col_nlevels or c < idx_nlevels:
+                cell.set_facecolor("#AAAAAA")
+            cell.set_height(height)
+
+        ax.set_title(title, size=self.font_size)
+        ax.axis("off")
+
+
+def main() -> None:
+    import matplotlib.pyplot as plt
+
+    p = TablePlotter()
+
+    df1 = pd.DataFrame({"A": [10, 11, 12], "B": [20, 21, 22], "C": [30, 31, 32]})
+    df2 = pd.DataFrame({"A": [10, 12], "C": [30, 32]})
+
+    p.plot([df1, df2], pd.concat([df1, df2]), labels=["df1", "df2"], vertical=True)
+    plt.show()
+
+    df3 = pd.DataFrame({"X": [10, 12], "Z": [30, 32]})
+
+    p.plot(
+        [df1, df3], pd.concat([df1, df3], axis=1), labels=["df1", "df2"], vertical=False
+    )
+    plt.show()
+
+    idx = pd.MultiIndex.from_tuples(
+        [(1, "A"), (1, "B"), (1, "C"), (2, "A"), (2, "B"), (2, "C")]
+    )
+    column = pd.MultiIndex.from_tuples([(1, "A"), (1, "B")])
+    df3 = pd.DataFrame({"v1": [1, 2, 3, 4, 5, 6], "v2": [5, 6, 7, 8, 9, 10]}, index=idx)
+    df3.columns = column
+    p.plot(df3, df3, labels=["df3"])
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas/util/_exceptions.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import contextlib
+import inspect
+import os
+import re
+from typing import TYPE_CHECKING
+import warnings
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+    from types import FrameType
+
+
+@contextlib.contextmanager
+def rewrite_exception(old_name: str, new_name: str) -> Generator[None, None, None]:
+    """
+    Rewrite the message of an exception.
+    """
+    try:
+        yield
+    except Exception as err:
+        if not err.args:
+            raise
+        msg = str(err.args[0])
+        msg = msg.replace(old_name, new_name)
+        args: tuple[str, ...] = (msg,)
+        if len(err.args) > 1:
+            args = args + err.args[1:]
+        err.args = args
+        raise
+
+
+def find_stack_level() -> int:
+    """
+    Find the first place in the stack that is not inside pandas
+    (tests notwithstanding).
+    """
+
+    import pandas as pd
+
+    pkg_dir = os.path.dirname(pd.__file__)
+    test_dir = os.path.join(pkg_dir, "tests")
+
+    # https://stackoverflow.com/questions/17407119/python-inspect-stack-is-slow
+    frame: FrameType | None = inspect.currentframe()
+    try:
+        n = 0
+        while frame:
+            filename = inspect.getfile(frame)
+            if filename.startswith(pkg_dir) and not filename.startswith(test_dir):
+                frame = frame.f_back
+                n += 1
+            else:
+                break
+    finally:
+        # See note in
+        # https://docs.python.org/3/library/inspect.html#inspect.Traceback
+        del frame
+    return n
+
+
+@contextlib.contextmanager
+def rewrite_warning(
+    target_message: str,
+    target_category: type[Warning],
+    new_message: str,
+    new_category: type[Warning] | None = None,
+) -> Generator[None, None, None]:
+    """
+    Rewrite the message of a warning.
+
+    Parameters
+    ----------
+    target_message : str
+        Warning message to match.
+    target_category : Warning
+        Warning type to match.
+    new_message : str
+        New warning message to emit.
+    new_category : Warning or None, default None
+        New warning type to emit. When None, will be the same as target_category.
+    """
+    if new_category is None:
+        new_category = target_category
+    with warnings.catch_warnings(record=True) as record:
+        yield
+    if len(record) > 0:
+        match = re.compile(target_message)
+        for warning in record:
+            if warning.category is target_category and re.search(
+                match, str(warning.message)
+            ):
+                category = new_category
+                message: Warning | str = new_message
+            else:
+                category, message = warning.category, warning.message
+            warnings.warn_explicit(
+                message=message,
+                category=category,
+                filename=warning.filename,
+                lineno=warning.lineno,
+            )

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas/util/_print_versions.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+import codecs
+import json
+import locale
+import os
+import platform
+import struct
+import sys
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pandas._typing import JSONSerializable
+
+from pandas.compat._optional import (
+    VERSIONS,
+    get_version,
+    import_optional_dependency,
+)
+
+
+def _get_commit_hash() -> str | None:
+    """
+    Use vendored versioneer code to get git hash, which handles
+    git worktree correctly.
+    """
+    try:
+        from pandas._version_meson import (  # pyright: ignore [reportMissingImports]
+            __git_version__,
+        )
+
+        return __git_version__
+    except ImportError:
+        from pandas._version import get_versions
+
+        versions = get_versions()
+        return versions["full-revisionid"]
+
+
+def _get_sys_info() -> dict[str, JSONSerializable]:
+    """
+    Returns system information as a JSON serializable dictionary.
+    """
+    uname_result = platform.uname()
+    language_code, encoding = locale.getlocale()
+    return {
+        "commit": _get_commit_hash(),
+        "python": platform.python_version(),
+        "python-bits": struct.calcsize("P") * 8,
+        "OS": uname_result.system,
+        "OS-release": uname_result.release,
+        "Version": uname_result.version,
+        "machine": uname_result.machine,
+        "processor": uname_result.processor,
+        "byteorder": sys.byteorder,
+        "LC_ALL": os.environ.get("LC_ALL"),
+        "LANG": os.environ.get("LANG"),
+        "LOCALE": {"language-code": language_code, "encoding": encoding},
+    }
+
+
+def _get_dependency_info() -> dict[str, JSONSerializable]:
+    """
+    Returns dependency information as a JSON serializable dictionary.
+    """
+    deps = [
+        "pandas",
+        # required
+        "numpy",
+        "pytz",
+        "dateutil",
+        # install / build,
+        "pip",
+        "Cython",
+        # docs
+        "sphinx",
+        # Other, not imported.
+        "IPython",
+    ]
+    # Optional dependencies
+    deps.extend(list(VERSIONS))
+
+    result: dict[str, JSONSerializable] = {}
+    for modname in deps:
+        try:
+            mod = import_optional_dependency(modname, errors="ignore")
+        except Exception:
+            # Dependency conflicts may cause a non ImportError
+            result[modname] = "N/A"
+        else:
+            result[modname] = get_version(mod) if mod else None
+    return result
+
+
+def show_versions(as_json: str | bool = False) -> None:
+    """
+    Provide useful information, important for bug reports.
+
+    It comprises info about hosting operation system, pandas version,
+    and versions of other installed relative packages.
+
+    Parameters
+    ----------
+    as_json : str or bool, default False
+        * If False, outputs info in a human readable form to the console.
+        * If str, it will be considered as a path to a file.
+          Info will be written to that file in JSON format.
+        * If True, outputs info in JSON format to the console.
+
+    Examples
+    --------
+    >>> pd.show_versions()  # doctest: +SKIP
+    Your output may look something like this:
+    INSTALLED VERSIONS
+    ------------------
+    commit           : 37ea63d540fd27274cad6585082c91b1283f963d
+    python           : 3.10.6.final.0
+    python-bits      : 64
+    OS               : Linux
+    OS-release       : 5.10.102.1-microsoft-standard-WSL2
+    Version          : #1 SMP Wed Mar 2 00:30:59 UTC 2022
+    machine          : x86_64
+    processor        : x86_64
+    byteorder        : little
+    LC_ALL           : None
+    LANG             : en_GB.UTF-8
+    LOCALE           : en_GB.UTF-8
+    pandas           : 2.0.1
+    numpy            : 1.24.3
+    ...
+    """
+    sys_info = _get_sys_info()
+    deps = _get_dependency_info()
+
+    if as_json:
+        j = {"system": sys_info, "dependencies": deps}
+
+        if as_json is True:
+            sys.stdout.writelines(json.dumps(j, indent=2))
+        else:
+            assert isinstance(as_json, str)  # needed for mypy
+            with codecs.open(as_json, "wb", encoding="utf8") as f:
+                json.dump(j, f, indent=2)
+
+    else:
+        assert isinstance(sys_info["LOCALE"], dict)  # needed for mypy
+        language_code = sys_info["LOCALE"]["language-code"]
+        encoding = sys_info["LOCALE"]["encoding"]
+        sys_info["LOCALE"] = f"{language_code}.{encoding}"
+
+        maxlen = max(len(x) for x in deps)
+        print("\nINSTALLED VERSIONS")
+        print("------------------")
+        for k, v in sys_info.items():
+            print(f"{k:<{maxlen}}: {v}")
+        print("")
+        for k, v in deps.items():
+            print(f"{k:<{maxlen}}: {v}")

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas/util/_test_decorators.py

@@ -0,0 +1,173 @@
+"""
+This module provides decorator functions which can be applied to test objects
+in order to skip those objects when certain conditions occur. A sample use case
+is to detect if the platform is missing ``matplotlib``. If so, any test objects
+which require ``matplotlib`` and decorated with ``@td.skip_if_no("matplotlib")``
+will be skipped by ``pytest`` during the execution of the test suite.
+
+To illustrate, after importing this module:
+
+import pandas.util._test_decorators as td
+
+The decorators can be applied to classes:
+
+@td.skip_if_no("package")
+class Foo:
+    ...
+
+Or individual functions:
+
+@td.skip_if_no("package")
+def test_foo():
+    ...
+
+For more information, refer to the ``pytest`` documentation on ``skipif``.
+"""
+from __future__ import annotations
+
+import locale
+from typing import (
+    TYPE_CHECKING,
+    Callable,
+)
+
+import pytest
+
+from pandas._config import get_option
+
+if TYPE_CHECKING:
+    from pandas._typing import F
+
+from pandas._config.config import _get_option
+
+from pandas.compat import (
+    IS64,
+    is_platform_windows,
+)
+from pandas.compat._optional import import_optional_dependency
+
+
+def skip_if_installed(package: str) -> pytest.MarkDecorator:
+    """
+    Skip a test if a package is installed.
+
+    Parameters
+    ----------
+    package : str
+        The name of the package.
+
+    Returns
+    -------
+    pytest.MarkDecorator
+        a pytest.mark.skipif to use as either a test decorator or a
+        parametrization mark.
+    """
+    return pytest.mark.skipif(
+        bool(import_optional_dependency(package, errors="ignore")),
+        reason=f"Skipping because {package} is installed.",
+    )
+
+
+def skip_if_no(package: str, min_version: str | None = None) -> pytest.MarkDecorator:
+    """
+    Generic function to help skip tests when required packages are not
+    present on the testing system.
+
+    This function returns a pytest mark with a skip condition that will be
+    evaluated during test collection. An attempt will be made to import the
+    specified ``package`` and optionally ensure it meets the ``min_version``
+
+    The mark can be used as either a decorator for a test class or to be
+    applied to parameters in pytest.mark.parametrize calls or parametrized
+    fixtures. Use pytest.importorskip if an imported moduled is later needed
+    or for test functions.
+
+    If the import and version check are unsuccessful, then the test function
+    (or test case when used in conjunction with parametrization) will be
+    skipped.
+
+    Parameters
+    ----------
+    package: str
+        The name of the required package.
+    min_version: str or None, default None
+        Optional minimum version of the package.
+
+    Returns
+    -------
+    pytest.MarkDecorator
+        a pytest.mark.skipif to use as either a test decorator or a
+        parametrization mark.
+    """
+    msg = f"Could not import '{package}'"
+    if min_version:
+        msg += f" satisfying a min_version of {min_version}"
+    return pytest.mark.skipif(
+        not bool(
+            import_optional_dependency(
+                package, errors="ignore", min_version=min_version
+            )
+        ),
+        reason=msg,
+    )
+
+
+skip_if_32bit = pytest.mark.skipif(not IS64, reason="skipping for 32 bit")
+skip_if_windows = pytest.mark.skipif(is_platform_windows(), reason="Running on Windows")
+skip_if_not_us_locale = pytest.mark.skipif(
+    locale.getlocale()[0] != "en_US",
+    reason=f"Set local {locale.getlocale()[0]} is not en_US",
+)
+
+
+def parametrize_fixture_doc(*args) -> Callable[[F], F]:
+    """
+    Intended for use as a decorator for parametrized fixture,
+    this function will wrap the decorated function with a pytest
+    ``parametrize_fixture_doc`` mark. That mark will format
+    initial fixture docstring by replacing placeholders {0}, {1} etc
+    with parameters passed as arguments.
+
+    Parameters
+    ----------
+    args: iterable
+        Positional arguments for docstring.
+
+    Returns
+    -------
+    function
+        The decorated function wrapped within a pytest
+        ``parametrize_fixture_doc`` mark
+    """
+
+    def documented_fixture(fixture):
+        fixture.__doc__ = fixture.__doc__.format(*args)
+        return fixture
+
+    return documented_fixture
+
+
+def mark_array_manager_not_yet_implemented(request) -> None:
+    mark = pytest.mark.xfail(reason="Not yet implemented for ArrayManager")
+    request.applymarker(mark)
+
+
+skip_array_manager_not_yet_implemented = pytest.mark.xfail(
+    _get_option("mode.data_manager", silent=True) == "array",
+    reason="Not yet implemented for ArrayManager",
+)
+
+skip_array_manager_invalid_test = pytest.mark.skipif(
+    _get_option("mode.data_manager", silent=True) == "array",
+    reason="Test that relies on BlockManager internals or specific behaviour",
+)
+
+skip_copy_on_write_not_yet_implemented = pytest.mark.xfail(
+    get_option("mode.copy_on_write") is True,
+    reason="Not yet implemented/adapted for Copy-on-Write mode",
+)
+
+skip_copy_on_write_invalid_test = pytest.mark.skipif(
+    get_option("mode.copy_on_write") is True,
+    reason="Test not valid for Copy-on-Write mode",
+)

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas/util/_tester.py

@@ -0,0 +1,53 @@
+"""
+Entrypoint for testing from the top-level namespace.
+"""
+from __future__ import annotations
+
+import os
+import sys
+
+from pandas.compat._optional import import_optional_dependency
+
+PKG = os.path.dirname(os.path.dirname(__file__))
+
+
+def test(extra_args: list[str] | None = None, run_doctests: bool = False) -> None:
+    """
+    Run the pandas test suite using pytest.
+
+    By default, runs with the marks -m "not slow and not network and not db"
+
+    Parameters
+    ----------
+    extra_args : list[str], default None
+        Extra marks to run the tests.
+    run_doctests : bool, default False
+        Whether to only run the Python and Cython doctests. If you would like to run
+        both doctests/regular tests, just append "--doctest-modules"/"--doctest-cython"
+        to extra_args.
+
+    Examples
+    --------
+    >>> pd.test()  # doctest: +SKIP
+    running: pytest...
+    """
+    pytest = import_optional_dependency("pytest")
+    import_optional_dependency("hypothesis")
+    cmd = ["-m not slow and not network and not db"]
+    if extra_args:
+        if not isinstance(extra_args, list):
+            extra_args = [extra_args]
+        cmd = extra_args
+    if run_doctests:
+        cmd = [
+            "--doctest-modules",
+            "--doctest-cython",
+            f"--ignore={os.path.join(PKG, 'tests')}",
+        ]
+    cmd += [PKG]
+    joined = " ".join(cmd)
+    print(f"running: pytest {joined}")
+    sys.exit(pytest.main(cmd))
+
+
+__all__ = ["test"]

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/pandas/util/_validators.py

@@ -0,0 +1,456 @@
+"""
+Module that contains many useful utilities
+for validating data or function arguments
+"""
+from __future__ import annotations
+
+from collections.abc import (
+    Iterable,
+    Sequence,
+)
+from typing import (
+    TypeVar,
+    overload,
+)
+
+import numpy as np
+
+from pandas._libs import lib
+
+from pandas.core.dtypes.common import (
+    is_bool,
+    is_integer,
+)
+
+BoolishT = TypeVar("BoolishT", bool, int)
+BoolishNoneT = TypeVar("BoolishNoneT", bool, int, None)
+
+
+def _check_arg_length(fname, args, max_fname_arg_count, compat_args) -> None:
+    """
+    Checks whether 'args' has length of at most 'compat_args'. Raises
+    a TypeError if that is not the case, similar to in Python when a
+    function is called with too many arguments.
+    """
+    if max_fname_arg_count < 0:
+        raise ValueError("'max_fname_arg_count' must be non-negative")
+
+    if len(args) > len(compat_args):
+        max_arg_count = len(compat_args) + max_fname_arg_count
+        actual_arg_count = len(args) + max_fname_arg_count
+        argument = "argument" if max_arg_count == 1 else "arguments"
+
+        raise TypeError(
+            f"{fname}() takes at most {max_arg_count} {argument} "
+            f"({actual_arg_count} given)"
+        )
+
+
+def _check_for_default_values(fname, arg_val_dict, compat_args) -> None:
+    """
+    Check that the keys in `arg_val_dict` are mapped to their
+    default values as specified in `compat_args`.
+
+    Note that this function is to be called only when it has been
+    checked that arg_val_dict.keys() is a subset of compat_args
+    """
+    for key in arg_val_dict:
+        # try checking equality directly with '=' operator,
+        # as comparison may have been overridden for the left
+        # hand object
+        try:
+            v1 = arg_val_dict[key]
+            v2 = compat_args[key]
+
+            # check for None-ness otherwise we could end up
+            # comparing a numpy array vs None
+            if (v1 is not None and v2 is None) or (v1 is None and v2 is not None):
+                match = False
+            else:
+                match = v1 == v2
+
+            if not is_bool(match):
+                raise ValueError("'match' is not a boolean")
+
+        # could not compare them directly, so try comparison
+        # using the 'is' operator
+        except ValueError:
+            match = arg_val_dict[key] is compat_args[key]
+
+        if not match:
+            raise ValueError(
+                f"the '{key}' parameter is not supported in "
+                f"the pandas implementation of {fname}()"
+            )
+
+
+def validate_args(fname, args, max_fname_arg_count, compat_args) -> None:
+    """
+    Checks whether the length of the `*args` argument passed into a function
+    has at most `len(compat_args)` arguments and whether or not all of these
+    elements in `args` are set to their default values.
+
+    Parameters
+    ----------
+    fname : str
+        The name of the function being passed the `*args` parameter
+    args : tuple
+        The `*args` parameter passed into a function
+    max_fname_arg_count : int
+        The maximum number of arguments that the function `fname`
+        can accept, excluding those in `args`. Used for displaying
+        appropriate error messages. Must be non-negative.
+    compat_args : dict
+        A dictionary of keys and their associated default values.
+        In order to accommodate buggy behaviour in some versions of `numpy`,
+        where a signature displayed keyword arguments but then passed those
+        arguments **positionally** internally when calling downstream
+        implementations, a dict ensures that the original
+        order of the keyword arguments is enforced.
+
+    Raises
+    ------
+    TypeError
+        If `args` contains more values than there are `compat_args`
+    ValueError
+        If `args` contains values that do not correspond to those
+        of the default values specified in `compat_args`
+    """
+    _check_arg_length(fname, args, max_fname_arg_count, compat_args)
+
+    # We do this so that we can provide a more informative
+    # error message about the parameters that we are not
+    # supporting in the pandas implementation of 'fname'
+    kwargs = dict(zip(compat_args, args))
+    _check_for_default_values(fname, kwargs, compat_args)
+
+
+def _check_for_invalid_keys(fname, kwargs, compat_args) -> None:
+    """
+    Checks whether 'kwargs' contains any keys that are not
+    in 'compat_args' and raises a TypeError if there is one.
+    """
+    # set(dict) --> set of the dictionary's keys
+    diff = set(kwargs) - set(compat_args)
+
+    if diff:
+        bad_arg = next(iter(diff))
+        raise TypeError(f"{fname}() got an unexpected keyword argument '{bad_arg}'")
+
+
+def validate_kwargs(fname, kwargs, compat_args) -> None:
+    """
+    Checks whether parameters passed to the **kwargs argument in a
+    function `fname` are valid parameters as specified in `*compat_args`
+    and whether or not they are set to their default values.
+
+    Parameters
+    ----------
+    fname : str
+        The name of the function being passed the `**kwargs` parameter
+    kwargs : dict
+        The `**kwargs` parameter passed into `fname`
+    compat_args: dict
+        A dictionary of keys that `kwargs` is allowed to have and their
+        associated default values
+
+    Raises
+    ------
+    TypeError if `kwargs` contains keys not in `compat_args`
+    ValueError if `kwargs` contains keys in `compat_args` that do not
+    map to the default values specified in `compat_args`
+    """
+    kwds = kwargs.copy()
+    _check_for_invalid_keys(fname, kwargs, compat_args)
+    _check_for_default_values(fname, kwds, compat_args)
+
+
+def validate_args_and_kwargs(
+    fname, args, kwargs, max_fname_arg_count, compat_args
+) -> None:
+    """
+    Checks whether parameters passed to the *args and **kwargs argument in a
+    function `fname` are valid parameters as specified in `*compat_args`
+    and whether or not they are set to their default values.
+
+    Parameters
+    ----------
+    fname: str
+        The name of the function being passed the `**kwargs` parameter
+    args: tuple
+        The `*args` parameter passed into a function
+    kwargs: dict
+        The `**kwargs` parameter passed into `fname`
+    max_fname_arg_count: int
+        The minimum number of arguments that the function `fname`
+        requires, excluding those in `args`. Used for displaying
+        appropriate error messages. Must be non-negative.
+    compat_args: dict
+        A dictionary of keys that `kwargs` is allowed to
+        have and their associated default values.
+
+    Raises
+    ------
+    TypeError if `args` contains more values than there are
+    `compat_args` OR `kwargs` contains keys not in `compat_args`
+    ValueError if `args` contains values not at the default value (`None`)
+    `kwargs` contains keys in `compat_args` that do not map to the default
+    value as specified in `compat_args`
+
+    See Also
+    --------
+    validate_args : Purely args validation.
+    validate_kwargs : Purely kwargs validation.
+
+    """
+    # Check that the total number of arguments passed in (i.e.
+    # args and kwargs) does not exceed the length of compat_args
+    _check_arg_length(
+        fname, args + tuple(kwargs.values()), max_fname_arg_count, compat_args
+    )
+
+    # Check there is no overlap with the positional and keyword
+    # arguments, similar to what is done in actual Python functions
+    args_dict = dict(zip(compat_args, args))
+
+    for key in args_dict:
+        if key in kwargs:
+            raise TypeError(
+                f"{fname}() got multiple values for keyword argument '{key}'"
+            )
+
+    kwargs.update(args_dict)
+    validate_kwargs(fname, kwargs, compat_args)
+
+
+def validate_bool_kwarg(
+    value: BoolishNoneT,
+    arg_name: str,
+    none_allowed: bool = True,
+    int_allowed: bool = False,
+) -> BoolishNoneT:
+    """
+    Ensure that argument passed in arg_name can be interpreted as boolean.
+
+    Parameters
+    ----------
+    value : bool
+        Value to be validated.
+    arg_name : str
+        Name of the argument. To be reflected in the error message.
+    none_allowed : bool, default True
+        Whether to consider None to be a valid boolean.
+    int_allowed : bool, default False
+        Whether to consider integer value to be a valid boolean.
+
+    Returns
+    -------
+    value
+        The same value as input.
+
+    Raises
+    ------
+    ValueError
+        If the value is not a valid boolean.
+    """
+    good_value = is_bool(value)
+    if none_allowed:
+        good_value = good_value or (value is None)
+
+    if int_allowed:
+        good_value = good_value or isinstance(value, int)
+
+    if not good_value:
+        raise ValueError(
+            f'For argument "{arg_name}" expected type bool, received '
+            f"type {type(value).__name__}."
+        )
+    return value  # pyright: ignore[reportGeneralTypeIssues]
+
+
+def validate_fillna_kwargs(value, method, validate_scalar_dict_value: bool = True):
+    """
+    Validate the keyword arguments to 'fillna'.
+
+    This checks that exactly one of 'value' and 'method' is specified.
+    If 'method' is specified, this validates that it's a valid method.
+
+    Parameters
+    ----------
+    value, method : object
+        The 'value' and 'method' keyword arguments for 'fillna'.
+    validate_scalar_dict_value : bool, default True
+        Whether to validate that 'value' is a scalar or dict. Specifically,
+        validate that it is not a list or tuple.
+
+    Returns
+    -------
+    value, method : object
+    """
+    from pandas.core.missing import clean_fill_method
+
+    if value is None and method is None:
+        raise ValueError("Must specify a fill 'value' or 'method'.")
+    if value is None and method is not None:
+        method = clean_fill_method(method)
+
+    elif value is not None and method is None:
+        if validate_scalar_dict_value and isinstance(value, (list, tuple)):
+            raise TypeError(
+                '"value" parameter must be a scalar or dict, but '
+                f'you passed a "{type(value).__name__}"'
+            )
+
+    elif value is not None and method is not None:
+        raise ValueError("Cannot specify both 'value' and 'method'.")
+
+    return value, method
+
+
+def validate_percentile(q: float | Iterable[float]) -> np.ndarray:
+    """
+    Validate percentiles (used by describe and quantile).
+
+    This function checks if the given float or iterable of floats is a valid percentile
+    otherwise raises a ValueError.
+
+    Parameters
+    ----------
+    q: float or iterable of floats
+        A single percentile or an iterable of percentiles.
+
+    Returns
+    -------
+    ndarray
+        An ndarray of the percentiles if valid.
+
+    Raises
+    ------
+    ValueError if percentiles are not in given interval([0, 1]).
+    """
+    q_arr = np.asarray(q)
+    # Don't change this to an f-string. The string formatting
+    # is too expensive for cases where we don't need it.
+    msg = "percentiles should all be in the interval [0, 1]"
+    if q_arr.ndim == 0:
+        if not 0 <= q_arr <= 1:
+            raise ValueError(msg)
+    else:
+        if not all(0 <= qs <= 1 for qs in q_arr):
+            raise ValueError(msg)
+    return q_arr
+
+
+@overload
+def validate_ascending(ascending: BoolishT) -> BoolishT:
+    ...
+
+
+@overload
+def validate_ascending(ascending: Sequence[BoolishT]) -> list[BoolishT]:
+    ...
+
+
+def validate_ascending(
+    ascending: bool | int | Sequence[BoolishT],
+) -> bool | int | list[BoolishT]:
+    """Validate ``ascending`` kwargs for ``sort_index`` method."""
+    kwargs = {"none_allowed": False, "int_allowed": True}
+    if not isinstance(ascending, Sequence):
+        return validate_bool_kwarg(ascending, "ascending", **kwargs)
+
+    return [validate_bool_kwarg(item, "ascending", **kwargs) for item in ascending]
+
+
+def validate_endpoints(closed: str | None) -> tuple[bool, bool]:
+    """
+    Check that the `closed` argument is among [None, "left", "right"]
+
+    Parameters
+    ----------
+    closed : {None, "left", "right"}
+
+    Returns
+    -------
+    left_closed : bool
+    right_closed : bool
+
+    Raises
+    ------
+    ValueError : if argument is not among valid values
+    """
+    left_closed = False
+    right_closed = False
+
+    if closed is None:
+        left_closed = True
+        right_closed = True
+    elif closed == "left":
+        left_closed = True
+    elif closed == "right":
+        right_closed = True
+    else:
+        raise ValueError("Closed has to be either 'left', 'right' or None")
+
+    return left_closed, right_closed
+
+
+def validate_inclusive(inclusive: str | None) -> tuple[bool, bool]:
+    """
+    Check that the `inclusive` argument is among {"both", "neither", "left", "right"}.
+
+    Parameters
+    ----------
+    inclusive : {"both", "neither", "left", "right"}
+
+    Returns
+    -------
+    left_right_inclusive : tuple[bool, bool]
+
+    Raises
+    ------
+    ValueError : if argument is not among valid values
+    """
+    left_right_inclusive: tuple[bool, bool] | None = None
+
+    if isinstance(inclusive, str):
+        left_right_inclusive = {
+            "both": (True, True),
+            "left": (True, False),
+            "right": (False, True),
+            "neither": (False, False),
+        }.get(inclusive)
+
+    if left_right_inclusive is None:
+        raise ValueError(
+            "Inclusive has to be either 'both', 'neither', 'left' or 'right'"
+        )
+
+    return left_right_inclusive
+
+
+def validate_insert_loc(loc: int, length: int) -> int:
+    """
+    Check that we have an integer between -length and length, inclusive.
+
+    Standardize negative loc to within [0, length].
+
+    The exceptions we raise on failure match np.insert.
+    """
+    if not is_integer(loc):
+        raise TypeError(f"loc must be an integer between -{length} and {length}")
+
+    if loc < 0:
+        loc += length
+    if not 0 <= loc <= length:
+        raise IndexError(f"loc must be an integer between -{length} and {length}")
+    return loc  # pyright: ignore[reportGeneralTypeIssues]
+
+
+def check_dtype_backend(dtype_backend) -> None:
+    if dtype_backend is not lib.no_default:
+        if dtype_backend not in ["numpy_nullable", "pyarrow"]:
+            raise ValueError(
+                f"dtype_backend {dtype_backend} is invalid, only 'numpy_nullable' and "
+                f"'pyarrow' are allowed.",
+            )

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/torch/_export/db/examples/__init__.py

@@ -0,0 +1,61 @@
+# mypy: allow-untyped-defs
+import dataclasses
+import glob
+import inspect
+from os.path import basename, dirname, isfile, join
+
+import torch
+from torch._export.db.case import (
+    _EXAMPLE_CASES,
+    _EXAMPLE_CONFLICT_CASES,
+    _EXAMPLE_REWRITE_CASES,
+    SupportLevel,
+    export_case,
+    ExportCase,
+)
+
+
+def _collect_examples():
+    case_names = glob.glob(join(dirname(__file__), "*.py"))
+    case_names = [
+        basename(f)[:-3] for f in case_names if isfile(f) and not f.endswith("__init__.py")
+    ]
+
+    case_fields = {f.name for f in dataclasses.fields(ExportCase)}
+    for case_name in case_names:
+        case = __import__(case_name, globals(), locals(), [], 1)
+        variables = [name for name in dir(case) if name in case_fields]
+        export_case(**{v: getattr(case, v) for v in variables})(case.model)
+
+_collect_examples()
+
+def all_examples():
+    return _EXAMPLE_CASES
+
+
+if len(_EXAMPLE_CONFLICT_CASES) > 0:
+
+    def get_name(case):
+        model = case.model
+        if isinstance(model, torch.nn.Module):
+            model = type(model)
+        return model.__name__
+
+    msg = "Error on conflict export case name.\n"
+    for case_name, cases in _EXAMPLE_CONFLICT_CASES.items():
+        msg += f"Case name {case_name} is associated with multiple cases:\n  "
+        msg += f"[{','.join(map(get_name, cases))}]\n"
+
+    raise RuntimeError(msg)
+
+
+def filter_examples_by_support_level(support_level: SupportLevel):
+    return {
+        key: val
+        for key, val in all_examples().items()
+        if val.support_level == support_level
+    }
+
+
+def get_rewrite_cases(case):
+    return _EXAMPLE_REWRITE_CASES.get(case.name, [])

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/torch/_export/db/examples/assume_constant_result.py

@@ -0,0 +1,20 @@
+# mypy: allow-untyped-defs
+import torch
+import torch._dynamo as torchdynamo
+
+
+class AssumeConstantResult(torch.nn.Module):
+    """
+    Applying `assume_constant_result` decorator to burn make non-tracable code as constant.
+    """
+
+    @torchdynamo.assume_constant_result
+    def get_item(self, y):
+        return y.int().item()
+
+    def forward(self, x, y):
+        return x[: self.get_item(y)]
+
+example_args = (torch.randn(3, 2), torch.tensor(4))
+tags = {"torch.escape-hatch"}
+model = AssumeConstantResult()

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/torch/_export/db/examples/autograd_function.py

@@ -0,0 +1,25 @@
+# mypy: allow-untyped-defs
+import torch
+
+class MyAutogradFunction(torch.autograd.Function):
+    @staticmethod
+    # pyrefly: ignore [bad-override]
+    def forward(ctx, x):
+        return x.clone()
+
+    @staticmethod
+    # pyrefly: ignore [bad-override]
+    def backward(ctx, grad_output):
+        return grad_output + 1
+
+class AutogradFunction(torch.nn.Module):
+    """
+    TorchDynamo does not keep track of backward() on autograd functions. We recommend to
+    use `allow_in_graph` to mitigate this problem.
+    """
+
+    def forward(self, x):
+        return MyAutogradFunction.apply(x)
+
+example_args = (torch.randn(3, 2),)
+model = AutogradFunction()

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/torch/_export/db/examples/class_method.py

@@ -0,0 +1,22 @@
+# mypy: allow-untyped-defs
+import torch
+
+class ClassMethod(torch.nn.Module):
+    """
+    Class methods are inlined during tracing.
+    """
+
+    @classmethod
+    def method(cls, x):
+        return x + 1
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.linear = torch.nn.Linear(4, 2)
+
+    def forward(self, x):
+        x = self.linear(x)
+        return self.method(x) * self.__class__.method(x) * type(self).method(x)
+
+example_args = (torch.randn(3, 4),)
+model = ClassMethod()

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/torch/_export/db/examples/cond_branch_class_method.py

@@ -0,0 +1,44 @@
+# mypy: allow-untyped-defs
+import torch
+
+from functorch.experimental.control_flow import cond
+
+class MySubModule(torch.nn.Module):
+    def foo(self, x):
+        return x.cos()
+
+    def forward(self, x):
+        return self.foo(x)
+
+class CondBranchClassMethod(torch.nn.Module):
+    """
+    The branch functions (`true_fn` and `false_fn`) passed to cond() must follow these rules:
+      - both branches must take the same args, which must also match the branch args passed to cond.
+      - both branches must return a single tensor
+      - returned tensor must have the same tensor metadata, e.g. shape and dtype
+      - branch function can be free function, nested function, lambda, class methods
+      - branch function can not have closure variables
+      - no inplace mutations on inputs or global variables
+
+
+    This example demonstrates using class method in cond().
+
+    NOTE: If the `pred` is test on a dim with batch size < 2, it will be specialized.
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.subm = MySubModule()
+
+    def bar(self, x):
+        return x.sin()
+
+    def forward(self, x):
+        return cond(x.shape[0] <= 2, self.subm.forward, self.bar, [x])
+
+example_args = (torch.randn(3),)
+tags = {
+    "torch.cond",
+    "torch.dynamic-shape",
+}
+model = CondBranchClassMethod()

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/torch/_export/db/examples/cond_branch_nested_function.py

@@ -0,0 +1,41 @@
+# mypy: allow-untyped-defs
+import torch
+
+from functorch.experimental.control_flow import cond
+
+class CondBranchNestedFunction(torch.nn.Module):
+    """
+    The branch functions (`true_fn` and `false_fn`) passed to cond() must follow these rules:
+      - both branches must take the same args, which must also match the branch args passed to cond.
+      - both branches must return a single tensor
+      - returned tensor must have the same tensor metadata, e.g. shape and dtype
+      - branch function can be free function, nested function, lambda, class methods
+      - branch function can not have closure variables
+      - no inplace mutations on inputs or global variables
+
+    This example demonstrates using nested function in cond().
+
+    NOTE: If the `pred` is test on a dim with batch size < 2, it will be specialized.
+    """
+
+    def forward(self, x):
+        def true_fn(x):
+            def inner_true_fn(y):
+                return x + y
+
+            return inner_true_fn(x)
+
+        def false_fn(x):
+            def inner_false_fn(y):
+                return x - y
+
+            return inner_false_fn(x)
+
+        return cond(x.shape[0] < 10, true_fn, false_fn, [x])
+
+example_args = (torch.randn(3),)
+tags = {
+    "torch.cond",
+    "torch.dynamic-shape",
+}
+model = CondBranchNestedFunction()

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/torch/_export/db/examples/cond_branch_nonlocal_variables.py

@@ -0,0 +1,59 @@
+# mypy: allow-untyped-defs
+import torch
+
+from functorch.experimental.control_flow import cond
+
+class CondBranchNonlocalVariables(torch.nn.Module):
+    """
+    The branch functions (`true_fn` and `false_fn`) passed to cond() must follow these rules:
+    - both branches must take the same args, which must also match the branch args passed to cond.
+    - both branches must return a single tensor
+    - returned tensor must have the same tensor metadata, e.g. shape and dtype
+    - branch function can be free function, nested function, lambda, class methods
+    - branch function can not have closure variables
+    - no inplace mutations on inputs or global variables
+
+    This example demonstrates how to rewrite code to avoid capturing closure variables in branch functions.
+
+    The code below will not work because capturing closure variables is not supported.
+    ```
+    my_tensor_var = x + 100
+    my_primitive_var = 3.14
+
+    def true_fn(y):
+        nonlocal my_tensor_var, my_primitive_var
+        return y + my_tensor_var + my_primitive_var
+
+    def false_fn(y):
+        nonlocal my_tensor_var, my_primitive_var
+        return y - my_tensor_var - my_primitive_var
+
+    return cond(x.shape[0] > 5, true_fn, false_fn, [x])
+    ```
+
+    NOTE: If the `pred` is test on a dim with batch size < 2, it will be specialized.
+    """
+
+    def forward(self, x):
+        my_tensor_var = x + 100
+        my_primitive_var = 3.14
+
+        def true_fn(x, y, z):
+            return x + y + z
+
+        def false_fn(x, y, z):
+            return x - y - z
+
+        return cond(
+            x.shape[0] > 5,
+            true_fn,
+            false_fn,
+            [x, my_tensor_var, torch.tensor(my_primitive_var)],
+        )
+
+example_args = (torch.randn(6),)
+tags = {
+    "torch.cond",
+    "torch.dynamic-shape",
+}
+model = CondBranchNonlocalVariables()

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/torch/_export/db/examples/cond_closed_over_variable.py

@@ -0,0 +1,22 @@
+# mypy: allow-untyped-defs
+import torch
+
+from functorch.experimental.control_flow import cond
+
+class CondClosedOverVariable(torch.nn.Module):
+    """
+    torch.cond() supports branches closed over arbitrary variables.
+    """
+
+    def forward(self, pred, x):
+        def true_fn(val):
+            return x * 2
+
+        def false_fn(val):
+            return x - 2
+
+        return cond(pred, true_fn, false_fn, [x + 1])
+
+example_args = (torch.tensor(True), torch.randn(3, 2))
+tags = {"torch.cond", "python.closure"}
+model = CondClosedOverVariable()

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/torch/_export/db/examples/cond_operands.py

@@ -0,0 +1,35 @@
+# mypy: allow-untyped-defs
+import torch
+
+from torch.export import Dim
+
+x = torch.randn(3, 2)
+y = torch.randn(2)
+dim0_x = Dim("dim0_x")
+
+class CondOperands(torch.nn.Module):
+    """
+    The operands passed to cond() must be:
+    - a list of tensors
+    - match arguments of `true_fn` and `false_fn`
+
+    NOTE: If the `pred` is test on a dim with batch size < 2, it will be specialized.
+    """
+
+    def forward(self, x, y):
+        def true_fn(x, y):
+            return x + y
+
+        def false_fn(x, y):
+            return x - y
+
+        return torch.cond(x.shape[0] > 2, true_fn, false_fn, [x, y])
+
+example_args = (x, y)
+tags = {
+    "torch.cond",
+    "torch.dynamic-shape",
+}
+extra_inputs = (torch.randn(2, 2), torch.randn(2))
+dynamic_shapes = {"x": {0: dim0_x}, "y": None}
+model = CondOperands()

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/torch/_export/db/examples/cond_predicate.py

@@ -0,0 +1,25 @@
+# mypy: allow-untyped-defs
+import torch
+
+from functorch.experimental.control_flow import cond
+
+class CondPredicate(torch.nn.Module):
+    """
+    The conditional statement (aka predicate) passed to cond() must be one of the following:
+      - torch.Tensor with a single element
+      - boolean expression
+
+    NOTE: If the `pred` is test on a dim with batch size < 2, it will be specialized.
+    """
+
+    def forward(self, x):
+        pred = x.dim() > 2 and x.shape[2] > 10
+
+        return cond(pred, lambda x: x.cos(), lambda y: y.sin(), [x])
+
+example_args = (torch.randn(6, 4, 3),)
+tags = {
+    "torch.cond",
+    "torch.dynamic-shape",
+}
+model = CondPredicate()

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/torch/_export/db/examples/constrain_as_size_example.py

@@ -0,0 +1,23 @@
+# mypy: allow-untyped-defs
+import torch
+
+
+class ConstrainAsSizeExample(torch.nn.Module):
+    """
+    If the value is not known at tracing time, you can provide hint so that we
+    can trace further. Please look at torch._check APIs.
+    """
+
+    def forward(self, x):
+        a = x.item()
+        torch._check(a >= 0)
+        torch._check(a <= 5)
+        return torch.zeros((a, 5))
+
+
+example_args = (torch.tensor(4),)
+tags = {
+    "torch.dynamic-value",
+    "torch.escape-hatch",
+}
+model = ConstrainAsSizeExample()

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/torch/_export/db/examples/constrain_as_value_example.py

@@ -0,0 +1,26 @@
+# mypy: allow-untyped-defs
+import torch
+
+
+class ConstrainAsValueExample(torch.nn.Module):
+    """
+    If the value is not known at tracing time, you can provide hint so that we
+    can trace further. Please look at torch._check API.
+    """
+
+    def forward(self, x, y):
+        a = x.item()
+        torch._check(a >= 0)
+        torch._check(a <= 5)
+
+        if a < 6:
+            return y.sin()
+        return y.cos()
+
+
+example_args = (torch.tensor(4), torch.randn(5, 5))
+tags = {
+    "torch.dynamic-value",
+    "torch.escape-hatch",
+}
+model = ConstrainAsValueExample()

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/torch/_export/db/examples/decorator.py

@@ -0,0 +1,23 @@
+# mypy: allow-untyped-defs
+import functools
+
+import torch
+
+def test_decorator(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        return func(*args, **kwargs) + 1
+
+    return wrapper
+
+class Decorator(torch.nn.Module):
+    """
+    Decorators calls are inlined into the exported function during tracing.
+    """
+
+    @test_decorator
+    def forward(self, x, y):
+        return x + y
+
+example_args = (torch.randn(3, 2), torch.randn(3, 2))
+model = Decorator()

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/torch/_export/db/examples/dictionary.py

@@ -0,0 +1,17 @@
+# mypy: allow-untyped-defs
+import torch
+
+class Dictionary(torch.nn.Module):
+    """
+    Dictionary structures are inlined and flattened along tracing.
+    """
+
+    def forward(self, x, y):
+        elements = {}
+        elements["x2"] = x * x
+        y = y * elements["x2"]
+        return {"y": y}
+
+example_args = (torch.randn(3, 2), torch.tensor(4))
+tags = {"python.data-structure"}
+model = Dictionary()

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/torch/_export/db/examples/dynamic_shape_assert.py

@@ -0,0 +1,18 @@
+# mypy: allow-untyped-defs
+import torch
+
+class DynamicShapeAssert(torch.nn.Module):
+    """
+    A basic usage of python assertion.
+    """
+
+    def forward(self, x):
+        # assertion with error message
+        assert x.shape[0] > 2, f"{x.shape[0]} is greater than 2"
+        # assertion without error message
+        assert x.shape[0] > 1
+        return x
+
+example_args = (torch.randn(3, 2),)
+tags = {"python.assert"}
+model = DynamicShapeAssert()

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/torch/_export/db/examples/dynamic_shape_constructor.py

@@ -0,0 +1,15 @@
+# mypy: allow-untyped-defs
+import torch
+
+class DynamicShapeConstructor(torch.nn.Module):
+    """
+    Tensor constructors should be captured with dynamic shape inputs rather
+    than being baked in with static shape.
+    """
+
+    def forward(self, x):
+        return torch.zeros(x.shape[0] * 2)
+
+example_args = (torch.randn(3, 2),)
+tags = {"torch.dynamic-shape"}
+model = DynamicShapeConstructor()

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/torch/_export/db/examples/dynamic_shape_if_guard.py

@@ -0,0 +1,19 @@
+# mypy: allow-untyped-defs
+import torch
+
+class DynamicShapeIfGuard(torch.nn.Module):
+    """
+    `if` statement with backed dynamic shape predicate will be specialized into
+    one particular branch and generate a guard. However, export will fail if the
+    the dimension is marked as dynamic shape from higher level API.
+    """
+
+    def forward(self, x):
+        if x.shape[0] == 3:
+            return x.cos()
+
+        return x.sin()
+
+example_args = (torch.randn(3, 2, 2),)
+tags = {"torch.dynamic-shape", "python.control-flow"}
+model = DynamicShapeIfGuard()

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/torch/_export/db/examples/dynamic_shape_map.py

@@ -0,0 +1,19 @@
+# mypy: allow-untyped-defs
+import torch
+
+from functorch.experimental.control_flow import map
+
+class DynamicShapeMap(torch.nn.Module):
+    """
+    functorch map() maps a function over the first tensor dimension.
+    """
+
+    def forward(self, xs, y):
+        def body(x, y):
+            return x + y
+
+        return map(body, xs, y)
+
+example_args = (torch.randn(3, 2), torch.randn(2))
+tags = {"torch.dynamic-shape", "torch.map"}
+model = DynamicShapeMap()

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/torch/_export/db/examples/dynamic_shape_round.py

@@ -0,0 +1,21 @@
+# mypy: allow-untyped-defs
+import torch
+
+from torch._export.db.case import SupportLevel
+from torch.export import Dim
+
+class DynamicShapeRound(torch.nn.Module):
+    """
+    Calling round on dynamic shapes is not supported.
+    """
+
+    def forward(self, x):
+        return x[: round(x.shape[0] / 2)]
+
+x = torch.randn(3, 2)
+dim0_x = Dim("dim0_x")
+example_args = (x,)
+tags = {"torch.dynamic-shape", "python.builtin"}
+support_level = SupportLevel.NOT_SUPPORTED_YET
+dynamic_shapes = {"x": {0: dim0_x}}
+model = DynamicShapeRound()

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/torch/_export/db/examples/dynamic_shape_slicing.py

@@ -0,0 +1,15 @@
+# mypy: allow-untyped-defs
+import torch
+
+class DynamicShapeSlicing(torch.nn.Module):
+    """
+    Slices with dynamic shape arguments should be captured into the graph
+    rather than being baked in.
+    """
+
+    def forward(self, x):
+        return x[: x.shape[0] - 2, x.shape[1] - 1 :: 2]
+
+example_args = (torch.randn(3, 2),)
+tags = {"torch.dynamic-shape"}
+model = DynamicShapeSlicing()

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/torch/_export/db/examples/fn_with_kwargs.py

@@ -0,0 +1,30 @@
+# mypy: allow-untyped-defs
+import torch
+
+class FnWithKwargs(torch.nn.Module):
+    """
+    Keyword arguments are not supported at the moment.
+    """
+
+    def forward(self, pos0, tuple0, *myargs, mykw0, **mykwargs):
+        out = pos0
+        for arg in tuple0:
+            out = out * arg
+        for arg in myargs:
+            out = out * arg
+        out = out * mykw0
+        out = out * mykwargs["input0"] * mykwargs["input1"]
+        return out
+
+example_args = (
+    torch.randn(4),
+    (torch.randn(4), torch.randn(4)),
+    *[torch.randn(4), torch.randn(4)]
+)
+example_kwargs = {
+    "mykw0": torch.randn(4),
+    "input0": torch.randn(4),
+    "input1": torch.randn(4),
+}
+tags = {"python.data-structure"}
+model = FnWithKwargs()

Prism/LLaDA/LLaDA_Prism/.venv/lib/python3.12/site-packages/torch/_export/db/examples/list_contains.py

@@ -0,0 +1,17 @@
+# mypy: allow-untyped-defs
+import torch
+
+class ListContains(torch.nn.Module):
+    """
+    List containment relation can be checked on a dynamic shape or constants.
+    """
+
+    def forward(self, x):
+        assert x.size(-1) in [6, 2]
+        assert x.size(0) not in [4, 5, 6]
+        assert "monkey" not in ["cow", "pig"]
+        return x + x
+
+example_args = (torch.randn(3, 2),)
+tags = {"torch.dynamic-shape", "python.data-structure", "python.assert"}
+model = ListContains()