pandas-dev-pandas-68524-68587

930f023 base
AGENTS.md
AUTHORS.md
CITATION.cff
LICENSE
LICENSES
README.md
asv_bench
build
ci
codecov.yml
doc

environment.yml
generate_pxi.py
generate_version.py
meson.build
meson.options
pandas
pixi.lock
pixi.toml
pyproject.toml
pyright_reportGeneralTypeIssues.json
requirements-dev.txt
scripts
subprojects
web

0+untagged.1.g930f023 /repo/pandas/__init__.py 2.5.4

pandas/tests/io/parser/test_na_values.py:718:            "cannot safely convert passed user dtype of "
pandas/tests/io/parser/test_na_values.py:814:        "cannot safely convert passed user dtype of int(64|32) for "
pandas/_libs/parsers.pyx:1682:                        f"cannot safely convert passed user dtype of "
pandas/_libs/parsers.pyx:1698:                        f"cannot safely convert passed user dtype of "

from __future__ import annotations

from typing import (
    TYPE_CHECKING,
    Any,
    ClassVar,
)

import numpy as np

from pandas.util._decorators import set_module

from pandas.core.dtypes.base import register_extension_dtype
from pandas.core.dtypes.common import is_integer_dtype

from pandas.core.arrays.numeric import (
    NumericArray,
    NumericDtype,
)

if TYPE_CHECKING:
    from collections.abc import Callable


class IntegerDtype(NumericDtype):
    """
    An ExtensionDtype to hold a single size & kind of integer dtype.

    These specific implementations are subclasses of the non-public
    IntegerDtype. For example, we have Int8Dtype to represent signed int 8s.

    The attributes name & type are set when these subclasses are created.
    """

    # The value used to fill '_data' to avoid upcasting
    _internal_fill_value = 1
    _default_np_dtype = np.dtype(np.int64)

…[8629 chars omitted]…
 Sorting is deferred too, so the concatenated
                #  categories arrive in the observation order the non-chunked
                #  path sees, rather than a per-chunk sorted one.
                self.deferred_cat_cols[i] = dtype
                cat = array_type._from_inferred_categories(
                    cats, codes, None, sort_categories=False)
                return cat, na_count, None

pandas/io/parsers/base_parser.py:405:    def _set_noconvert_dtype_columns(

pandas/core/arrays/arrow/array.py:1144:    def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
pandas/core/arrays/base.py:2955:    def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
pandas/core/arrays/categorical.py:1941:    def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
pandas/core/arrays/datetimelike.py:2009:    def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
pandas/core/arrays/masked.py:841:    def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
pandas/core/arrays/numpy_.py:255:    def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
pandas/core/arrays/sparse/array.py:2818:    def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
pandas/core/col.py:309:    def __array_ufunc__(
pandas/core/generic.py:1997:    def __array_ufunc__(
pandas/core/indexes/base.py:955:    def __array_ufunc__(

0+untagged.1.g930f023 2.5.4

 dt <class 'pandas.Series'> datetime64[us]
  logical_and -> 0    True
1    True
2    True
dtype: bool
  logical_or -> 0    True
1    True
2    True
dtype: bool
  logical_xor -> 0    False

1    False
2    False
dtype: bool
  logical_not TypeError ufunc 'logical_not' not supported for the input types, and the inputs could not be safely coerced to any supported types

 dt_tz <class 'pandas.Series'> datetime64[us, UTC]
  logical_and -> 0    True
1    True
2    True
dtype: object
  logical_or -> 0   2020-01-01 00:00:00+00:00
1   2020-01-02 00:00:00+00:00
2   2020-01-03 00:00:00+00:00
dtype: datetime64[us, UTC]
  logical_xor AttributeError 'Timestamp' object has no attribute 'logical_xor'
  logical_not -> 0    False
1    False
2    False
dtype: object

 td <class 'pandas.Series'> timedelta64[us]
  logical_and -> 0    False
1     True
2     True
dtype: bool
  log
…[4400 chars omitted]…
ass 'pandas.Timedelta'> None
  logical_and -> True
  logical_or -> Timedelta('1 days 00:00:00')
  logical_xor AttributeError 'Timedelta' object has no attribute 'logical_xor'
  logical_not -> False

 scalarperiod <class 'pandas.Period'> None
  logical_and -> True
  logical_or -> Period('2020-01-01', 'D')
  logical_xor AttributeError 'Period' object has no attribute 'logical_xor'
  logical_not -> False

--------
        For :class:`pandas.DatetimeIndex`:

        >>> idx = pd.DatetimeIndex(["2020-01-02 01:02:03.004005006"])
        >>> idx
        DatetimeIndex(['2020-01-02 01:02:03.004005006'],
                      dtype='datetime64[ns]', freq=None)
        >>> idx.as_unit("s")
        DatetimeIndex(['2020-01-02 01:02:03'], dtype='datetime64[s]', freq=None)

        For :class:`pandas.TimedeltaIndex`:

        >>> tdelta_idx = pd.to_timedelta(["1 day 3 min 2 us 42 ns"])
        >>> tdelta_idx
        TimedeltaIndex(['1 days 00:03:00.000002042'],
                        dtype='timedelta64[ns]', freq=None)
        >>> tdelta_idx.as_unit("s")
        TimedeltaIndex(['1 days 00:03:00'], dtype='timedelta64[s]', freq=None)
        """
        if unit not in ["s", "ms", "us", "ns"]:
            raise ValueError("Supported units are 's', 'ms', 'us', 'ns'")

        dtype = np.dtype
…[8629 chars omitted]…
          self, ufunc, method, *inputs, **kwargs
            )
            if result is not NotImplemented:
                # e.g. tests.series.test_ufunc.TestNumpyReductions
                return result

        if len(inputs) == 1:
            if method == "reduce":
                # GH#68453 reducing sp_values alone would drop the gaps
                return ufunc.reduce(self._densify(), **kwargs)

round_fn(item, decimals) if not item_isna else item
            for item, item_isna in zip(self, self.isna(), strict=True)
        ]
        return type(self)._from_sequence(rounded, dtype=self.dtype)

    def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
        if any(
            isinstance(other, (ABCSeries, ABCIndex, ABCDataFrame)) for other in inputs
        ):
            return NotImplemented

        result = arraylike.maybe_dispatch_ufunc_to_dunder_op(

            self, ufunc, method, *inputs, **kwargs
        )
        if result is not NotImplemented:
            return result

        if "out" in kwargs:
            return arraylike.dispatch_ufunc_with_out(
                self, ufunc, method, *inputs, **kwargs
            )

        if method == "reduce":
            result = arraylike.dispatch_reduction_ufunc(
                self, u
…[8629 chars omitted]…
ew(
                sp_values, self.sp_index, SparseDtype(sp_values.dtype, fill_value)
            )

        new_inputs = tuple(np.asarray(x) for x in inputs)
        result = getattr(ufunc, method)(*new_inputs, **kwargs)
        if out:
            if len(out) == 1:
                out = out[0]
            return out

        if ufunc.nout > 1:
            return tuple(type(self)(x) for x in result)

"""
Methods that can be shared by many array-like classes or subclasses:
    Series
    Index
    ExtensionArray
"""

from __future__ import annotations

import operator
from typing import (
    Any,

    Self,
)

import numpy as np

from pandas._libs import lib
from pandas._libs.ops_dispatch import maybe_dispatch_ufunc_to_dunder_op

from pandas.core.dtypes.generic import ABCNDFrame

from pandas.core import roperator
from pandas.core.construction import extract_array
from pandas.core.ops.common import unpack_zerodim_and_defer

REDUCTION_ALIASES = {
    "maximum": "max",
    "minimum": "min",
    "add": "sum",
    "multiply": "prod",
}


class OpsMixin:
    # -------------------------------------------------------------
    # Comparisons

    def _cmp_method(self, other, op):
        return NotImplemented

    @unpack_zerodim_and_defer("__eq__")
    def __eq__(self, other) -> Self:  # t
…[6860 chars omitted]…
 other) -> Self:
        return self._arith_method(other, operator.mod)

    @unpack_zerodim_and_defer("__rmod__")
    def __rmod__(self, other) -> Self:
        return self._arith_method(other, roperator.rmod)

    @unpack_zerodim_and_defer("__divmod__")
    def __divmod__(self, other) -> tuple[Self, Self]:
        return self._arith_method(other, divmod)

    @unpack_zerodim_and_defer("__rdivmod__")

455:def dispatch_ufunc_with_out(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
501:def default_array_ufunc(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
517:def dispatch_reduction_ufunc(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
    else:
        # otherwise specific ufunc methods (eg np.<ufunc>.accumulate(..))
        # Those can have an axis keyword and thus can't be called block-by-block
        result = default_array_ufunc(inputs[0], ufunc, method, *inputs, **kwargs)  # pyright: ignore[reportGeneralTypeIssues]
        # e.g. np.negative (only one reached), with "where" and "out" in kwargs

    result = reconstruct(result)
    return result

def _standardize_out_kwarg(**kwargs) -> dict:
    """
    If kwargs contain "out1" and "out2", replace that with a tuple "out"

    np.divmod, np.modf, np.frexp can have either `out=(out1, out2)` or
    `out1=ou
…[3023 chars omitted]…
s=None, which DataFrame.min catches and changes to axis=0.
            # np.minimum.reduce(df) gets here bc axis is not in kwargs,
            #  so we set axis=0 to match the behavior of np.minimum.reduce(df.values)
            kwargs["axis"] = 0

    # By default, numpy's reductions do not skip NaNs, so we have to
    #  pass skipna=False
    return getattr(self, method_name)(skipna=False, **kwargs)

UInt8 [-1] ERR TypeError cannot safely cast non-equivalent int64 to uint8
UInt8 [257] ERR TypeError cannot safely cast non-equivalent int64 to uint8
UInt8 [18446744073709551615] ERR TypeError cannot safely cast non-equivalent uint64 to uint8
UInt8 [9223372036854775808] ERR TypeError cannot safely cast non-equivalent uint64 to uint8
UInt8 [9223372036854775807] ERR TypeError cannot safely cast non-equivalent int64 to uint8
UInt8 [-9223372036854775808] ERR TypeError cannot safely cast non-equivalent int64 to uint8
UInt8 [300.0] ERR TypeError cannot safely cast non-equivalent float64 to uint8
UInt8 [257.0] ERR TypeError cannot safely cast non-equivalent float64 to uint8
UInt8 [-1.0] ERR TypeError cannot safely cast non-equivalent float64 to uint8
UInt8 [1.5] ERR TypeError cannot safely cast non-equivalent object to uint8

Int8 [-1] -> <IntegerArray>

[-1]
Length: 1, dtype: Int8 Int8
Int8 [
…[1951 chars omitted]…
th: 1, dtype: Int64 Int64
Int64 [-9223372036854775808] -> <IntegerArray>
[-9223372036854775808]
Length: 1, dtype: Int64 Int64
Int64 [300.0] -> <IntegerArray>
[300]
Length: 1, dtype: Int64 Int64
Int64 [257.0] -> <IntegerArray>
[257]
Length: 1, dtype: Int64 Int64
Int64 [-1.0] -> <IntegerArray>
[-1]
Length: 1, dtype: Int64 Int64
Int64 [1.5] ERR TypeError cannot safely cast non-equivalent object to int64

/repo/pandas/core/construction.py:717: UserWarning: pyarrow requires pandas 2.2.2 or above, pandas 0+untagged.1.g930f023 is installed. Therefore, pandas-specific integration is not used.
  subarr = lib.maybe_convert_objects(
0+untagged.1.g930f023
c uint8 numpy -1 ERR ValueError dtype_backend numpy is invalid, only 'numpy_nullable' and 'pyarrow' are allowed.
c uint8 numpy_nullable -1 -> 255.0 float64
c uint8 numpy 257 ERR ValueError dtype_backend numpy is invalid, only 'numpy_nullable' and 'pyarrow' are allowed.
c uint8 numpy_nullable 257 -> 1.0 float64
c uint8 numpy 300.0 ERR ValueError dtype_backend numpy is invalid, only 'numpy_nullable' and 'pyarrow' are allowed.
c uint8 numpy_nullable 300.0 ERR ValueError cannot safely convert passed user dtype of uint8 for float64 dtyped data in column 0
c uint8 numpy 257.0 ERR ValueError dtype_backend numpy is invalid, only 'numpy_nullable' and 
…[8630 chars omitted]…
18446744073709551615 ERR ImportError pyarrow requires pandas 2.2.2 or above, pandas 0+untagged.1.g930f023 is installed

pyarrow UInt64 numpy 9223372036854775808 ERR ValueError dtype_backend numpy is invalid, only 'numpy_nullable' and 'pyarrow' are allowed.
pyarrow UInt64 numpy_nullable 9223372036854775808 ERR ImportError pyarrow requires pandas 2.2.2 or above, pandas 0+untagged.1.g930f023 is installed

c uint8 None -1 ERR ValueError dtype_backend None is invalid, only 'numpy_nullable' and 'pyarrow' are allowed.
c uint8 numpy_nullable -1 -> 255.0 float64
c uint8 None 257 ERR ValueError dtype_backend None is invalid, only 'numpy_nullable' and 'pyarrow' are allowed.
c uint8 numpy_nullable 257 -> 1.0 float64
c uint8 None 300.0 ERR ValueError dtype_backend None is invalid, only 'numpy_nullable' and 'pyarrow' are allowed.
c uint8 numpy_nullable 300.0 ERR ValueError cannot safely convert passed user dtype of uint8 for float64 dtyped data in column 0
c uint8 None 257.0 ERR ValueError dtype_backend None is invalid, only 'numpy_nullable' and 'pyarrow' are allowed.
c uint8 numpy_nullable 257.0 ERR ValueError cannot safely convert passed user dtype of uint8 for float64 dtyped data in column 0
c uint8 None 18446744073709551615 ERR ValueError dtype_backend None is invalid, only 'numpy_nullable' a
…[8629 chars omitted]…
thon Int64 None 18446744073709551615 ERR ValueError dtype_backend None is invalid, only 'numpy_nullable' and 'pyarrow' are allowed.
python Int64 numpy_nullable 18446744073709551615 -> -1 Int64

python Int64 None 9223372036854775808 ERR ValueError dtype_backend None is invalid, only 'numpy_nullable' and 'pyarrow' are allowed.
python Int64 numpy_nullable 9223372036854775808 -> -9223372036854775808 Int64

c uint8 None -1 -> 255 uint8
c uint8 numpy_nullable -1 -> 255.0 float64
c uint8 None 257 -> 1 uint8
c uint8 numpy_nullable 257 -> 1.0 float64
c uint8 None 300.0 ERR ValueError cannot safely convert passed user dtype of uint8 for float64 dtyped data in column 0
c uint8 numpy_nullable 300.0 ERR ValueError cannot safely convert passed user dtype of uint8 for float64 dtyped data in column 0
c uint8 None 257.0 ERR ValueError cannot safely convert passed user dtype of uint8 for float64 dtyped data in column 0
c uint8 numpy_nullable 257.0 ERR ValueError cannot safely convert passed user dtype of uint8 for float64 dtyped data in column 0
c uint8 None 18446744073709551615 -> 255 uint8
c uint8 numpy_nullable 18446744073709551615 -> 255.0 float64
c uint8 None 9223372036854775808 -> 0 uint8
c uint8 numpy_nullable 9223372036854775808 -> 0.0 float64

c int8 None -1 -> -1 int8
c int8 numpy_nullable 
…[7824 chars omitted]…
0 -> 300 Int64
python Int64 numpy_nullable 300.0 -> 300 Int64
python Int64 None 257.0 -> 257 Int64
python Int64 numpy_nullable 257.0 -> 257 Int64
python Int64 None 18446744073709551615 -> -1 Int64
python Int64 numpy_nullable 18446744073709551615 -> -1 Int64
python Int64 None 9223372036854775808 -> -9223372036854775808 Int64
python Int64 numpy_nullable 9223372036854775808 -> -9223372036854775808 Int64

* master

ERR <urlopen error [Errno -3] Temporary failure in name resolution>

pandas/tests/arrays/integer/test_arithmetic.py:217:# TODO test unsigned overflow
pandas/tests/arrays/integer/test_construction.py:194:    with pytest.raises(TypeError, match="cannot safely cast non-equivalent"):
pandas/tests/arrays/masked/test_indexing.py:80:    with pytest.raises(TypeError, match="cannot safely cast"):
pandas/tests/arrays/masked/test_indexing.py:83:    with pytest.raises(TypeError, match="cannot safely cast"):
pandas/tests/arrays/masked/test_indexing.py:124:    with pytest.raises(TypeError, match="cannot safely cast"):
pandas/tests/arrays/period/test_constructors.py:232:    msg = f'Parsing "{val}" to datetime overflows'
pandas/tests/arrays/sparse/test_reductions.py:449:def test_frame_sum_narrow_int_column_does_not_overflow():
pandas/tests/arrays/test_array.py:522:        TypeError, match=r"cannot safely cast non-equivalent int(32|64) to uint16"
pandas/tests/arrays/te
…[7862 chars omitted]…
 mistaken for an overflow (the NaT sentinels accumulate past int64 bounds)
pandas/tests/frame/test_reductions.py:2575:def test_sum_timedelta64_overflow_only_in_exempt_slice(axis):

pandas/tests/frame/test_reductions.py:2577:    #  NaT under skipna=False is exempt even though its entries overflow
pandas/tests/frame/test_stack_unstack.py:2753:    def test_unstack_group_index_overflow(self, future_stack):

# going through 2D->1D path
        vals = [(1,), (2,), (3,)]
        ser = pd.Series(vals)
        dtype = ser.array.dtype  # NumpyEADtype
        ser2 = pd.Series(vals, dtype=dtype)
        tm.assert_series_equal(ser, ser2)

    def test_constructor_int_dtype_missing_values(self):
        # GH#43017
        result = pd.Series(index=[0], dtype="int64")
        expected = pd.Series(np.nan, index=[0], dtype="float64")
        tm.assert_series_equal(result, expected)

    def test_constructor_bool_dtype_missing_values(self):
        # GH#43018
        result = pd.Series(index=[0], dtype="bool")
        expected = pd.Series(True, index=[0], dtype="bool")
        tm.assert_series_equal(result, expected)

    def test_constructor_int64_dtype(self, any_int_dtype):
        # GH#44923
        result = pd.Series(["0", "1", "2"], dtype=any_int_dtype)
        expected = pd.Series([0, 1, 
…[7330 chars omitted]…
match=msg):
            pd.Series([-1], dtype=any_unsigned_int_numpy_dtype)

    def test_constructor_floating_data_int_dtype(self, frame_or_series):
        # GH#40110
        arr = np.random.default_rng(2).standard_normal(2)

        # Long-standing behavior (for Series, new in 2.0 for DataFrame)
        #  has been to ignore the dtype on these;
        #  not clear if this is what we want long-term

pandas/_libs/missing.pyx:571:    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
pandas/_libs/tslibs/dtypes.pxd:110:cdef class PeriodDtypeBase:
pandas/_libs/tslibs/dtypes.pyi:11:class PeriodDtypeBase:
pandas/_libs/tslibs/dtypes.pyx:19:cdef class PeriodDtypeBase:
pandas/_libs/tslibs/nattype.pyi:33:class NaTType:
pandas/_libs/tslibs/nattype.pyx:349:class NaTType(_NaT):
pandas/_libs/tslibs/period.pyi:71:class PeriodMixin:
pandas/_libs/tslibs/period.pyi:78:class Period(PeriodMixin):
pandas/_libs/tslibs/period.pyx:1941:cdef class PeriodMixin:
pandas/_libs/tslibs/period.pyx:3352:class Period(_Period):
pandas/_libs/tslibs/timedeltas.pyi:91:class Timedelta(timedelta):
pandas/_libs/tslibs/timedeltas.pyx:2517:class Timedelta(_Timedelta):

pandas/_libs/tslibs/timestamps.pyi:38:class Timestamp(datetime):
pandas/_libs/tslibs/timestamps.pyx:2005:class Timestamp(_Timestamp):
pandas/_libs
…[1720 chars omitted]…
/timedeltas.py:107:class TimedeltaIndex(DatetimeTimedeltaMixin):
pandas/core/resample.py:2237:class PeriodIndexResampler(DatetimeIndexResampler):
pandas/core/resample.py:2325:class PeriodIndexResamplerGroupBy(  # type: ignore[misc]
pandas/core/resample.py:2337:class TimedeltaIndexResampler(DatetimeIndexResampler):
pandas/core/resample.py:2362:class TimedeltaIndexResamplerGroupBy(  # type: ignore[misc]

elif util.is_bool_object(other):
            if not other:
                return False
            return NA
        return NotImplemented

    __rand__ = __and__

    def __or__(self, other):
        if other is True:
            return True
        elif other is False or other is C_NA:

            return NA
        elif util.is_bool_object(other):
            if not other:
                return NA
            return True
        return NotImplemented

    __ror__ = __or__

    def __xor__(self, other):
        if util.is_bool_object(other) or other is C_NA:
            return NA
        return NotImplemented

    __rxor__ = __xor__

    __array_priority__ = 1000
    _HANDLED_TYPES = (np.ndarray, numbers.Number, str, np.bool_)

    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
        types = self._HANDLED_TYPES + (NAType,)
        for x in inputs:
          
…[3813 chars omitted]…
ike.dispatch_ufunc_with_out(
                self, ufunc, method, *inputs, **kwargs
            )

        if method == "reduce":
            result = arraylike.dispatch_reduction_ufunc(
                self, ufunc, method, *inputs, **kwargs
            )
            if result is not NotImplemented:
                return result

        new_inputs = [x if x is not self else x._values for x in inputs]

277:def array_ufunc(self, ufunc: np.ufunc, method: str, *inputs: Any, **kwargs: Any):

    # Determine if we should defer.
    no_defer = (
        np.ndarray.__array_ufunc__,
        cls.__array_ufunc__,
    )

    for item in inputs:
        higher_priority = (
            hasattr(item, "__array_priority__")
            and item.__array_priority__ > self.__array_priority__

        )
        has_array_ufunc = (
            hasattr(item, "__array_ufunc__")
            and type(item).__array_ufunc__ not in no_defer
            and not isinstance(item, self._HANDLED_TYPES)
        )
        if higher_priority or has_array_ufunc:
            return NotImplemented

    # align all the inputs.
    types = tuple(type(x) for x in inputs)
    alignable = [
        x for x, t in zip(inputs, types, strict=True) if issubclass(t, NDFrame)
    ]

    if len(alignable) > 1:
        # This triggers 
…[4937 chars omitted]…

    np.divmod, np.modf, np.frexp can have either `out=(out1, out2)` or
    `out1=out1, out2=out2)`
    """
    if "out" not in kwargs and "out1" in kwargs and "out2" in kwargs:
        out1 = kwargs.pop("out1")
        out2 = kwargs.pop("out2")
        out = (out1, out2)
        kwargs["out"] = out
    return kwargs


def dispatch_ufunc_with_out(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):

return self._arith_method(other, roperator.rpow)


# -----------------------------------------------------------------------------
# Helpers to implement __array_ufunc__


def array_ufunc(self, ufunc: np.ufunc, method: str, *inputs: Any, **kwargs: Any):
    """
    Compatibility with numpy ufuncs.

    See also

    --------
    numpy.org/doc/stable/reference/arrays.classes.html#numpy.class.__array_ufunc__
    """
    from pandas.core.frame import (
        DataFrame,
        Series,
    )
    from pandas.core.generic import NDFrame
    from pandas.core.internals import BlockManager

    cls = type(self)

    kwargs = _standardize_out_kwarg(**kwargs)

    # for binary ops, use our custom dunder methods
    result = maybe_dispatch_ufunc_to_dunder_op(self, ufunc, method, *inputs, **kwargs)
    if result is not NotImplemented:
        return result

    # Determine if we should de
…[1070 chars omitted]…
:
            # We currently don't handle ufunc(DataFrame, Series)
            # well. Previously this raised an internal ValueError. We might
            # support it someday, so raise a NotImplementedError.
            raise NotImplementedError(
                f"Cannot apply ufunc {ufunc} to mixed DataFrame and Series inputs."
            )
        axes = self.axes
        for obj in alignable[1:]:

Period('2020-03-09/2020-03-15', 'W-SUN')

        >>> # Quarter end frequency
        >>> ts.to_period(freq='Q')
        Period('2020Q1', 'Q-DEC')
        """
        from pandas import Period

        if self.tz is not None:
            # GH#21333
            warnings.warn(
                "Converting to Period representation will drop timezone information.",

                UserWarning,
                stacklevel=find_stack_level(),
            )

        return Period(self, freq=freq)


# ----------------------------------------------------------------------

# Python front end to C extension type _Timestamp
# This serves as the box for datetime64

@set_module("pandas")
class Timestamp(_Timestamp):
    """
    Pandas replacement for python datetime.datetime object.

    Timestamp is the pandas equivalent of python's Datetime
    and is interchangeable with it in most cases.
…[8628 chars omitted]…
turn base

    @property
    def value(self) -> int:
        return self._value

    def __reduce_ex__(self, protocol):
        # python 3.6 compat
        # https://bugs.python.org/issue28730
        # now __reduce_ex__ is defined and higher priority than __reduce__
        return self.__reduce__()

    def __reduce__(self):
        return (_nat_unpickle, (None, ))

    def __rtruediv__(self, other):

cp312
/repo/build/cp312/pandas/_libs/tslibs/timestamps.cpython-312-x86_64-linux-gnu.so
/usr/bin/ninja
/usr/local/bin/meson
5:    "meson-python>=0.19.0,<1",
6:    "meson>=1.2.3,<2",
18:build-backend = "mesonpy"
160:[tool.meson-python.args]

75:ABCTimedeltaIndex = cast(
77:    create_pandas_abc_type("ABCTimedeltaIndex", "_typ", ("timedeltaindex",)),
79:ABCPeriodIndex = cast(
81:    create_pandas_abc_type("ABCPeriodIndex", "_typ", ("periodindex",)),
91:ABCIndex = cast(
94:        "ABCIndex",
114:ABCSeries = cast(
116:    create_pandas_abc_type("ABCSeries", "_typ", ("series",)),
130:ABCTimedeltaArray = cast(
132:    create_pandas_abc_type("ABCTimedeltaArray", "_typ", ("timedeltaarray",)),
134:ABCPeriodArray = cast(
136:    create_pandas_abc_type("ABCPeriodArray", "_typ", ("periodarray",)),

138:ABCExtensionArray = cast(
141:        "ABCExtensionArray",
"""define generic base classes for pandas objects"""

from __future__ import annotations

from typing import (
    TYPE_CHECKING,
    Any,
    cast,
)

if TYPE_CHECKING:
    from pandas import (
        Categorical,
        CategoricalIndex,
        DataFrame,
        Datetime
…[3520 chars omitted]…
  create_pandas_abc_type(
        "ABCExtensionArray",
        "_typ",
        # Note: IntervalArray and SparseArray are included bc they have _typ="extension"
        {"extension", "categorical", "periodarray", "datetimearray", "timedeltaarray"},
    ),
)
ABCNumpyExtensionArray = cast(
    "type[NumpyExtensionArray]",
    create_pandas_abc_type("ABCNumpyExtensionArray", "_typ", ("npy_extension",)),
)

pandas/core/dtypes/api.py:9:    is_datetime64_any_dtype,
pandas/core/dtypes/api.py:30:    is_period_dtype,
pandas/core/dtypes/api.py:37:    is_timedelta64_dtype,
pandas/core/dtypes/api.py:51:    "is_datetime64_any_dtype",
pandas/core/dtypes/api.py:72:    "is_period_dtype",
pandas/core/dtypes/api.py:79:    "is_timedelta64_dtype",
pandas/core/dtypes/common.py:337:    :func:`api.types.is_datetime64_any_dtype` instead.
pandas/core/dtypes/common.py:353:    api.types.is_datetime64_any_dtype: Check whether the provided array or
pandas/core/dtypes/common.py:398:    api.types.is_datetime64_any_dtype: Check whether the provided array or
pandas/core/dtypes/common.py:439:def is_timedelta64_dtype(arr_or_dtype) -> bool:
pandas/core/dtypes/common.py:461:    api.types.is_period_dtype : Check whether an array-like or dtype is of the
pandas/core/dtypes/common.py:466:    >>> from pandas.api.types import

…[2273 chars omitted]…
a64_dtype: Check whether an array-like or dtype
pandas/core/dtypes/common.py:1647:def is_ea_or_datetimelike_dtype(dtype: DtypeObj | None) -> bool:
pandas/core/dtypes/common.py:1966:    "is_datetime64_any_dtype",
pandas/core/dtypes/common.py:1986:    "is_period_dtype",
pandas/core/dtypes/common.py:1995:    "is_timedelta64_dtype",
pandas/_libs/lib.pyx:3639:    In [9]: %timeit is_timedelta64_dtype(dtype)

False
    >>> is_int64_dtype(np.int64)  # doctest: +SKIP
    True
    >>> is_int64_dtype("int8")  # doctest: +SKIP
    False
    >>> is_int64_dtype("Int8")  # doctest: +SKIP
    False
    >>> is_int64_dtype(pd.Int64Dtype)  # doctest: +SKIP
    True
    >>> is_int64_dtype(float)  # doctest: +SKIP
    False
    >>> is_int64_dtype(np.uint64)  # unsigned  # doctest: +SKIP

    False
    >>> is_int64_dtype(np.array(["a", "b"]))  # doctest: +SKIP
    False
    >>> is_int64_dtype(np.array([1, 2], dtype=np.int64))  # doctest: +SKIP
    True
    >>> is_int64_dtype(pd.Index([1, 2.0]))  # float  # doctest: +SKIP
    False
    >>> is_int64_dtype(np.array([1, 2], dtype=np.uint32))  # unsigned  # doctest: +SKIP
    False
    """
    # GH#52564
    warnings.warn(
        "is_int64_dtype is deprecated and will be removed in a future "
        "version. Use dtype == np.int64 instead.",
        Pand
…[7017 chars omitted]…
----
    arr_or_dtype : array-like or dtype
        The array or dtype to check.

    Returns
    -------
    boolean
        Whether or not the array or dtype is of a complex dtype.

    See Also
    --------
    api.types.is_complex: Return True if given object is complex.
    api.types.is_numeric_dtype: Check whether the provided array or
                                dtype is of a numeric dtype.

"""
    # GH#52607
    warnings.warn(
        "is_datetime64tz_dtype is deprecated and will be removed in a future "
        "version. Check `isinstance(dtype, pd.DatetimeTZDtype)` instead.",
        Pandas4Warning,
        stacklevel=2,
    )
    if isinstance(arr_or_dtype, DatetimeTZDtype):
        # GH#33400 fastpath for dtype object
        # GH 34986
        return True

    if arr_or_dtype is None:
        return False
    return DatetimeTZDtype.is_dtype(arr_or_dtype)


@set_module("pandas.api.types")
def is_timedelta64_dtype(arr_or_dtype) -> bool:
    """
    Check whether an array-like or dtype is of the timedelta64 dtype.

    This function checks if the provided array-like object or dtype
    corresponds to a timedelta64 dtype, which is used to represent
    differences between two datetime values.

    Parameters
    ----------
    arr_or_dtype : array-like or dtype
   
…[3528 chars omitted]…
.
    api.types.is_complex_dtype: Check whether the provided array or
                                dtype is of a complex dtype.

    Examples
    --------
    >>> from pandas.api.types import is_categorical_dtype
    >>> from pandas import CategoricalDtype
    >>> is_categorical_dtype(object)
    False
    >>> is_categorical_dtype(CategoricalDtype())
    True
    >>> is_categorical_dtype([1, 2, 3])

return _is_dtype_type(arr_or_dtype, classes(np.complexfloating))


def _is_dtype(arr_or_dtype, condition) -> bool:
    """
    Return true if the condition is satisfied for the arr_or_dtype.

    Parameters
    ----------
    arr_or_dtype : array-like, str, np.dtype, or ExtensionArrayType
        The array-like or dtype object whose dtype we want to extract.
    condition : callable[Union[np.dtype, ExtensionDtype]]

    Returns
    -------
    bool

    """
    if arr_or_dtype is None:
        return False
    try:
        dtype = _get_dtype(arr_or_dtype)
    except (TypeError, ValueError):
        return False
    return condition(dtype)


def _get_dtype(arr_or_dtype) -> DtypeObj:
    """
    Get the dtype instance associated with an array
    or dtype object.

    Parameters
    ----------
    arr_or_dtype : array-like or dtype
        The array-like or dtype object whose dtype 
…[2927 chars omitted]…
* Sparse
    * Interval
    * Period
    * DatetimeArray
    * TimedeltaArray

    Third-party libraries may implement arrays or types satisfying
    this interface as well.

    Examples
    --------
    >>> from pandas.api.types import is_extension_array_dtype
    >>> arr = pd.Categorical(["a", "b"])
    >>> is_extension_array_dtype(arr)
    True
    >>> is_extension_array_dtype(arr.dtype)
    True

v2.1.2.rst
v2.1.3.rst
v2.1.4.rst
v2.2.0.rst
v2.2.1.rst
v2.2.2.rst
v2.2.3.rst
v2.3.0.rst
v2.3.1.rst
v2.3.2.rst
v2.3.3.rst
v3.0.0.rst

v3.0.1.rst
v3.0.2.rst
v3.0.3.rst
v3.0.4.rst
v3.0.5.rst
v3.0.6.rst
v3.1.0.rst
whatsnew_0171_html_table.html
doc/source/whatsnew/v3.1.0.rst:791:- Bug in logical operations (``&``, ``|``, ``^``) between a pandas object and any datetime-like operand -- ``datetime64`` (including timezone-aware), ``timedelta64``, :class:`PeriodDtype`, any temporal :class:`ArrowDtype`, their :class:`SparseDtype` spellings, and a :class:`Categorical` of any of them -- silently treating every value, ``NaT`` included, as ``True`` instead of raising ``TypeError`` (:issue:`68452`)

395:- :class:`DataFrame` arithmetic, comparison, and logical operations with an extension-dtype :class:`Series`, :class:`Index`, or array along the default ``axis="columns"`` now follow the same rules as the operation between two :class:`Series` (``axis=0`` already did). The result keeps the extension dtype instead of falling back to NumPy -- ``Int64`` rather than ``int64``, ``boolean`` rather than ``bool`` -- so a comparison involving a missing value now yields ``NA`` instead of ``True`` or ``False``. An operation the dtype declines now raises instead of silently succeeding: arithmetic and ordering comparisons against a ``category`` Series previously operated on the categories as if they were plain scalars and now raise ``TypeError``, while equality against one is unchanged. Conversely, operations that previously raised a spurious error now succeed, such as adding an integer :class:`
…[8630 chars omitted]…
es are all numbers was read as nanoseconds rather than in the dtype's unit, so ``Series([2, 3], dtype=object).astype("m8[s]")`` came back all zeros (:issue:`68688`)
- Bug in :meth:`Series.cumsum` and :meth:`DataFrame.cumsum` on ``timedelta64`` data where a running total that left the representable range silently wrapped to an unrelated value instead of raising ``OutOfBoundsTimedelta`` (:issue:`66551`)

190:The ``pyarrow`` engine gave nullable ``Int64`` categories for integer columns
588:- Performance improvement in :func:`read_csv` with ``engine="c"`` for integer and string columns (:issue:`65350`)
599:- Performance improvement in :func:`read_csv` with ``engine="c"`` when parsing integer columns (:issue:`65347`, :issue:`66459`, :issue:`66487`)
604:- Performance improvement in :func:`read_csv` with ``engine="c"``, most visibly for integer columns, wide frames, and parallel reads (:issue:`66276`)
648:- Performance improvement in :meth:`DataFrame` reductions (e.g. :meth:`DataFrame.any`, :meth:`DataFrame.sum`, :meth:`DataFrame.idxmax`) with ``axis=1`` on extension array dtypes such as :class:`BooleanDtype`, nullable integer/float, and :class:`ArrowDtype` (:issue:`56903`)
851:- Fixed bug in :meth:`DataFrame.idxmax` and :meth:`DataFrame.idxmin` with ``axis=1`` and ``skipna=False`` returni
…[3726 chars omitted]…
 or floating :class:`Series` silently resolving the missing values as if they were ``NaN``; the result now matches the non-sparse equivalent and has ``boolean`` dtype (:issue:`68579`)
1302:- Fixed bug in :meth:`Series.apply` and :meth:`Series.map` where nullable integer dtypes were converted to float, causing precision loss for large integers; now the nullable dtype will be preserved (:issue:`63903`).

415:- Removed the ``freq`` and ``freqstr`` attributes from :class:`.DatetimeArray` and :class:`.TimedeltaArray`. Frequency is now stored only on :class:`DatetimeIndex` and :class:`TimedeltaIndex`; access ``Series.dt.freq`` or wrap the array in an Index to retrieve a frequency. The ``check_freq`` keyword on :func:`testing.assert_extension_array_equal` for these array types has also been removed (:issue:`24566`).
600:- Performance improvement in :func:`read_csv` with ``engine="c"`` when reading from binary file-like objects (e.g. PyArrow S3 file handles) by avoiding unnecessary ``TextIOWrapper`` wrapping (:issue:`46823`)
706:- Fixed bug in :class:`Index` repr where attributes were not wrapped to respect ``display.width`` (:issue:`11552`)
726:- Bug in :attr:`DatetimeIndex.year` and :attr:`Series.dt.year` silently returning a wrapped year, e.g. ``219250468`` for year ``292277026596``, for
…[8629 chars omitted]…
rame.min`, and :meth:`DataFrame.max` on :class:`SparseDtype` columns forcing the result into the column's own dtype: ``count`` returned ``1`` for every sparse column, the sum of a narrow integer column silently wrapped around, the mean of an integer column was truncated to an integer, and a missing result (e.g. from ``min_count`` or an empty column) came back as a fill value or raised (:issue:`55123`)

186:parser, :func:`read_table`, :func:`read_fwf` and :func:`read_excel` included,
601:- Performance improvement in :func:`read_csv` with ``engine="c"`` when reading in parallel: closing a parser no longer blocks the other parser threads while its buffers are freed (:issue:`66272`)
607:- Performance improvement in :func:`read_html` and the Python CSV parser when ``thousands`` is set, fixing catastrophic regex backtracking on cells with many comma-separated digit groups followed by non-numeric text (:issue:`52619`)
994:- :func:`read_csv` with ``engine="pyarrow"`` now raises ``EmptyDataError`` (matching the ``c`` and ``python`` engines) instead of a cryptic ``ParserError`` reporting ``Empty CSV file or block`` when no columns can be parsed from the input (:issue:`66065`)
1022:- Fixed bug in :func:`read_csv` with ``engine="pyarrow"`` where ``skiprows`` was silently ignored unless ``header
…[1699 chars omitted]…
s of the file, so lines the parser had already skipped -- ``skiprows`` lines, and blank or comment lines above the data -- did not count towards it and too many rows were dropped from the end, sometimes leaving an empty ``DataFrame`` (:issue:`36827`)
1070:- Fixed segfault when instantiating the internal ``pandas._libs.parsers.TextReader`` with no arguments; it now raises ``TypeError`` (:issue:`53131`)

./doc/source/whatsnew/v3.1.0.rst:789:- Bug in adding or subtracting a boolean array and ``datetime64`` or ``timedelta64`` data silently treating ``True`` as one unit of the data's resolution instead of raising ``TypeError`` as integer data does; ``datetime64`` with a :class:`BooleanDtype` operand instead raised ``ValueError: Could not convert object to NumPy datetime`` (:issue:`68452`)
./doc/source/whatsnew/v3.1.0.rst:791:- Bug in logical operations (``&``, ``|``, ``^``) between a pandas object and any datetime-like operand -- ``datetime64`` (including timezone-aware), ``timedelta64``, :class:`PeriodDtype`, any temporal :class:`ArrowDtype`, their :class:`SparseDtype` spellings, and a :class:`Categorical` of any of them -- silently treating every value, ``NaT`` included, as ``True`` instead of raising ``TypeError`` (:issue:`68452`)
./pandas/core/arrays/datetimelike.py:1365:            
…[2656 chars omitted]…
rpose: an object
./pandas/tests/series/test_logical_ops.py:637:    # GH#68452 BooleanArray casts the operand with np.asarray(other, dtype="bool");
./pandas/tests/series/test_logical_ops.py:652:    # GH#68452 these two hide the temporal type one level down, the arrow spelling of
./pandas/tests/series/test_logical_ops.py:687:    # GH#68452 the array-operand guard leaves scalars to the paths that already

exp = pd.Series([True, False, True, False], index=list("ABCD"), name="x")
        tm.assert_series_equal(s3 & s4, exp)
        tm.assert_series_equal(s4 & s3, exp)

        # np.nan | True => np.nan, filled with False
        exp_or1 = pd.Series([True, True, True, False], index=list("ABCD"), name="x")
        tm.assert_series_equal(s3 | s4, exp_or1)
        # True | np.nan => True
        exp_or = pd.Series([True, True, True, True], index=list("ABCD"), name="x")
        tm.assert_series_equal(s4 | s3, exp_or)

        tm.assert_frame_equal(s3.to_frame() & s4.to_frame(), exp.to_frame())

        tm.assert_frame_equal(s4.to_frame() & s3.to_frame(), exp.to_frame())

        tm.assert_frame_equal(s3.to_frame() | s4.to_frame(), exp_or1.to_frame())
        tm.assert_frame_equal(s4.to_frame() | s3.to_frame(), exp_or.to_frame())

    def test_int_dtype_different_index_not_bool(self):

…[8629 chars omitted]…
ore.arrays import TimedeltaArray

            return TimedeltaArray._from_sequence(result, dtype=result.dtype)
        return result

    def __rsub__(self, other):
        other_dtype = getattr(other, "dtype", None)
        other_is_dt64 = lib.is_np_dtype(other_dtype, "M") or isinstance(
            other_dtype, DatetimeTZDtype
        )

        if other_is_dt64 and lib.is_np_dtype(self.dtype, "m"):

# GH#68452 a Categorical hides its categories' dtype behind kind "O", so the masked
    #  path read the categories' own truthiness, NaT included
    left = pd.Series([True, False, True], dtype=left_dtype)
    right = pd.Series(pd.Categorical(pd.array(values, dtype=dtype)))

    msg = f"operation 'r?{op.__name__}' not supported for dtype"
    with pytest.raises(TypeError, match=msg):
        op(left, right)
    with pytest.raises(TypeError, match=msg):
        op(right, left)

def test_logical_op_object_dtype_still_truthy():
    # GH#68452 the datetimelike guard stops at object dtype on purpose: an object
    #  container keeps the truthiness of whatever it holds.  The two boolean spellings
    #  disagree about NaT in there, which this pins rather than endorses
    right = np.array([pd.Timestamp("2016-01-01"), pd.NaT, "a"], dtype=object)

    result = pd.Series([True, True, True
…[5298 chars omitted]…
py:408:def logical_op(left: ArrayLike, right: Any, op) -> ArrayLike:
pandas/core/ops/array_ops.py:453:    disallow_datetimelike_logical_op(lvalues, rvalues, op)
pandas/core/ops/array_ops.py:469:        res_values = na_logical_op(lvalues, rvalues, op)
pandas/core/ops/invalid.py:102:def disallow_datetimelike_logical_op(
pandas/core/series.py:7436:        res_values = ops.logical_op(lvalues, rvalues, op)

"""
Templates for invalid operations.
"""

from __future__ import annotations

import operator
from typing import (
    TYPE_CHECKING,
    Any,
    NoReturn,
)

import numpy as np

from pandas._libs import lib

from pandas.core.dtypes.dtypes import (
    ArrowDtype,
    CategoricalDtype,
    PeriodDtype,
)

if TYPE_CHECKING:
    from collections.abc import Callable

    from pandas._libs.missing import NAType
    from pandas._typing import (
        ArrayLike,
        Scalar,
        npt,
    )


def invalid_comparison(
    left: ArrayLike,
    right: ArrayLike | list | range | Scalar | NAType,
    op: Callable[[Any, Any], bool],
) -> npt.NDArray[np.bool_]:
    """
    If a comparison has mismatched types and is not necessarily meaningful,
    follow python3 conventions by:

        - returning all-False for equality
        - returning all-True for inequality
        - raising TypeEr
…[8628 chars omitted]…
A fill value
            #  that later logical ops raise on.
            return result
        return type(self)(result)

    def _logical_needs_dense(self, other) -> bool:
        # The and/or/xor sparse kernels only support boolean/integer subtypes;
        #  everything else (object/float produced by NA upcasting) must be
        #  computed densely. Inspect dtypes without materializing so the fast

69:- :class:`Series` and :class:`DataFrame` with ``timedelta64`` dtype now aligns fractional seconds in string representation for easier reading (:issue:`57188`)
75:- :meth:`ExtensionArray.map` now calls :meth:`ExtensionArray._cast_pointwise_result` to retain the dtype backend, e.g. Arrow-backed arrays now preserve their Arrow dtype through ``map`` (:issue:`57189`, :issue:`62164`)
76:- :func:`read_csv` now supports ``dtype="complex64"`` and ``dtype="complex128"`` with the C engine, enabling round-tripping of complex-number columns written by :meth:`DataFrame.to_csv` (:issue:`9379`)
78:- :meth:`DataFrame.select_dtypes` can now select ``datetime64`` and ``timedelta64`` columns by a specific resolution (e.g. ``"datetime64[us]"``, ``np.dtype("timedelta64[ms]")``), which previously raised; a unit-specific spec matches only columns with exactly that resolution, while a unitless ``"datetime6
…[8630 chars omitted]…
action raising ``TypeError`` instead of returning an empty result when either operand was a length-zero :class:`PeriodIndex` or ``period``-dtype :class:`Series` (:issue:`40624`)
1146:- Bug in adding an integer, timedelta or offset to a :class:`Period` returning ``NaT`` when the result was one step past the lower bound, instead of raising ``OverflowError`` as it already did further out (:issue:`66552`)

pandas/tests/arrays/boolean/test_function.py:9:    "ufunc", [np.add, np.logical_or, np.logical_and, np.logical_xor]
pandas/tests/arrays/boolean/test_function.py:54:@pytest.mark.parametrize("ufunc", [np.logical_not])
pandas/tests/extension/date/array.py:174:        return np.logical_and(
pandas/tests/extension/date/array.py:175:            np.logical_and(

<class 'pandas.Timestamp'> ok patched
<class 'pandas.Timedelta'> ok patched
<class 'pandas.Period'> ok patched
<class 'pandas.api.typing.NaTType'> ok patched

pandas/core/arrays/categorical.py:1967:            f"the numpy op {ufunc.__name__}"

Traceback (most recent call last):
  File "<stdin>", line 8, in <module>
OverflowError: Python int too large to convert to C long

Traceback (most recent call last):
  File "<stdin>", line 8, in <module>
OverflowError: Python int too large to convert to C long

[18446744073709551615, 2] [18446744073709551615                    2]
[9223372036854775808, 2] [9223372036854775808                   2]
<class 'OverflowError'> Python int too large to convert to C long

int64 UInt8 -> <IntegerArray>
[255, 2]
Length: 2, dtype: UInt8 [255   2] [False False]
int64 Int8 -> <IntegerArray>
[-1, 2]
Length: 2, dtype: Int8 [-1  2] [False False]
int64 UInt64 -> <IntegerArray>
[18446744073709551615, 2]
Length: 2, dtype: UInt64 [18446744073709551615                    2] [False False]
int64 Int64 -> <IntegerArray>
[-1, 2]
Length: 2, dtype: Int64 [-1  2] [False False]

int64mask UInt8 -> <IntegerArray>
[<NA>, 2]
Length: 2, dtype: UInt8 [255   2] [ True False]
int64mask Int8 -> <IntegerArray>
[<NA>, 2]
Length: 2, dtype: Int8 [-1  2] [ True False]
int64mask UInt64 -> <IntegerArray>
[<NA>, 2]
Length: 2, dtype: UInt64 [18446744073709551615                    2] [ True False]
int64mask Int64 -> <IntegerArray>
[<NA>, 2]
Length: 2, dtype: Int64 [-1  2] [ True False]

uint64 UInt8 -> <IntegerArray>
[255, 2]
Length: 2, dtype: UInt8 [255   2] [False False]
uint64 Int8 -> <
…[938 chars omitted]…
stype int64mask Int8 -> <IntegerArray>
[<NA>, 2]
Length: 2, dtype: Int8 [-1  2]
astype uint64 UInt8 -> <IntegerArray>
[255, 2]
Length: 2, dtype: UInt8 [255   2]
astype uint64 Int8 -> <IntegerArray>
[-1, 2]
Length: 2, dtype: Int8 [-1  2]
astype uint64mask UInt8 -> <IntegerArray>
[<NA>, 2]
Length: 2, dtype: UInt8 [255   2]
astype uint64mask Int8 -> <IntegerArray>
[<NA>, 2]
Length: 2, dtype: Int8 [-1  2]

from __future__ import annotations

import numbers
from typing import (
    TYPE_CHECKING,
    Any,
    Self,
)

import numpy as np

from pandas._config import is_nan_na

from pandas._libs import (
    lib,
    missing as libmissing,
)
from pandas.errors import AbstractMethodError
from pandas.util._decorators import cache_readonly

from pandas.core.dtypes.common import (
    is_integer_dtype,
    is_string_dtype,
    pandas_dtype,
)

from pandas.core.arrays.masked import (
    BaseMaskedArray,
    BaseMaskedDtype,
)

if TYPE_CHECKING:
    from collections.abc import (
        Callable,
        Mapping,
    )

    import pyarrow

    from pandas._typing import (
        DtypeObj,
        npt,
    )

    from pandas.core.dtypes.dtypes import ExtensionDtype


class NumericDtype(BaseMaskedDtype):
    _default_np_dtype: np.dtype
    _checker: Callable[[Any], bool]  # is_foo_dtype

    def 
…[8629 chars omitted]…
> np.ndarray:
pandas/core/arrays/numeric.py:128:    def _safe_cast(cls, values: np.ndarray, dtype: np.dtype, copy: bool) -> np.ndarray:
pandas/core/arrays/numeric.py:248:        values = dtype_cls._safe_cast(values, dtype, copy=False)
pandas/core/arrays/numeric.py:297:    def _from_sequence_of_strings(
pandas/core/arrays/numeric.py:303:        return cls._from_sequence(scalars, dtype=dtype, copy=copy)

mapping = cls._get_dtype_mapping()
            try:
                dtype = mapping[np.dtype(dtype)]
            except KeyError as err:
                raise ValueError(f"invalid dtype specified {dtype}") from err
        return dtype

    @classmethod
    def _safe_cast(cls, values: np.ndarray, dtype: np.dtype, copy: bool) -> np.ndarray:
        """
        Safely cast the values to the given dtype.

        "safe" in this context means the casting is lossless.
        """
        raise AbstractMethodError(cls)


def _coerce_to_data_and_mask(values, dtype, copy: bool, dtype_cls: type[NumericDtype]):
    checker = dtype_cls._checker
    default_dtype = dtype_cls._default_np_dtype

    mask = None
    inferred_type = None

    if dtype is None and hasattr(values, "dtype"):
        if checker(values.dtype):
            dtype = values.dtype

    if dtype is not None:
       
…[8629 chars omitted]…
 if self.ndim == 1:
            if not self._hasna:
                for val in self._data:
                    yield val
            else:
                na_value = self.dtype.na_value
                for isna_, val in zip(self._mask, self._data, strict=True):
                    if isna_:
                        yield na_value
                    else:
                        yield val
        else:

if copy:
            values = values.copy()
            mask = mask.copy()

        self._data = values
        self._mask = mask

    @classmethod
    def _from_sequence(cls, scalars, *, dtype=None, copy: bool = False) -> Self:
        values, mask = cls._coerce_to_array(scalars, dtype=dtype, copy=copy)
        return cls(values, mask)

    def _cast_pointwise_result(self, values) -> ArrayLike:
        if isna(values).all():
            return type(self)._from_sequence(values, dtype=self.dtype)
        if not (isinstance(values, np.ndarray) and values.dtype == object):
            values = construct_1d_object_array_from_listlike(values)
        result = lib.maybe_convert_objects(values, convert_to_nullable_dtype=True)
        lkind = self.dtype.kind
        rkind = result.dtype.kind
    @overload
    def astype(self, dtype: ExtensionDtype, copy: bool = ...) -> ExtensionArray
…[1437 chars omitted]…
     elif dtype.kind == "M":
            unit = np.datetime_data(dtype)[0]
            na_value = np.datetime64("NaT", unit)  # type: ignore[call-overload]
        else:
pandas/core/arrays/base.py:295:    def _from_sequence(
pandas/core/arrays/base.py:337:    def _from_sequence_of_strings(
pandas/core/arrays/masked.py:169:    def _from_sequence(cls, scalars, *, dtype=None, copy: bool = False) -> Self:

25:class FloatingDtype(NumericDtype):
55:    def _safe_cast(cls, values: np.ndarray, dtype: np.dtype, copy: bool) -> np.ndarray:
from __future__ import annotations

from typing import (
    TYPE_CHECKING,
    Any,
    ClassVar,
)

import numpy as np

from pandas.util._decorators import set_module

from pandas.core.dtypes.base import register_extension_dtype
from pandas.core.dtypes.common import is_float_dtype

from pandas.core.arrays.numeric import (
    NumericArray,
    NumericDtype,
)

if TYPE_CHECKING:
    from collections.abc import Callable


class FloatingDtype(NumericDtype):
    """
    An ExtensionDtype to hold a single size of floating dtype.

    These specific implementations are subclasses of the non-public
    FloatingDtype. For example we have Float32Dtype to represent float32.

    The attributes name & type are set when these subclasses are created.
    """

    # The
…[3264 chars omitted]…
es([2.25, pd.NA], dtype=pd.Float32Dtype())
>>> ser.dtype
Float32Dtype()

For Float64Dtype:

>>> ser = pd.Series([2.25, pd.NA], dtype=pd.Float64Dtype())
>>> ser.dtype
Float64Dtype()
"""

# create the Dtype


@register_extension_dtype
@set_module("pandas")
class Float32Dtype(FloatingDtype):
    type = np.float32
    name: ClassVar[str] = "Float32"
    __doc__ = _dtype_docstring.format(dtype="float32")

17:    using_string_dtype,
134:from pandas.core.dtypes.dtypes import (
140:from pandas.core.dtypes.inference import is_dict_like
144:from pandas._libs.tslibs.dtypes cimport (
458:        list dtype_cast_order  # list[np.dtype]
500:        object dtype
503:        str dtype_backend
524:                  dtype=None,
539:                  dtype_backend="numpy"):
595:        dtype_order = ["int64", "float64", "bool", "object"]
598:            dtype_order = dtype_order[1:]
599:        self.dtype_cast_order = [np.dtype(x) for x in dtype_order]

669:        self.dtype = dtype
670:        self.dtype_backend = dtype_backend
821:            dtype = type(quote_char).__name__
822:            raise TypeError(f'"quotechar" must be string, not {dtype}')
946:                                self.dtype is not None
947:                                and is_dict_like(self.dtype)
948:                     
…[8629 chars omitted]…
merical dtype")
4041:cdef _try_int64(parser_t *parser, int64_t col,
4063:        na_mask = np.zeros(lines, dtype=bool)
4065:            error = _try_int64_nogil(parser, col, line_start, line_end,
4079:cdef int _try_int64_nogil(parser_t *parser, int64_t col,
4139:    result = np.empty(lines, dtype=object)
4454:    na_values[np.dtype(k)] = na_values[k]
4471:    result = np.empty(lines, dtype=np.object_)

is_default_dict_dtype, numeric_ok)
        finally:
            # a column the sweep hands back to the whole-column path must
            # convert there rather than queue again
            self._batched_cols = None
        if batch:
            self._convert_batched(batch, start, end, block_rows, results)

        self.parser_start += end - start

        return results

    cdef _convert_columns(self, dict results, list batch,
                          int64_t start, int64_t end,
                          bint is_default_dict_dtype, bint numeric_ok):
        cdef:
            int64_t i
            int nused = 0
            int kind
            Py_ssize_t nqueued
            kh_str_starts_t *na_hashset = NULL
            object name, col_dtype = None
            set na_fset
            bint na_filter = 0

        for i in range(self.table_width):
   
…[8629 chars omitted]…
  word = coliter_next_with_idx(&it, &token_idx)
            data[i] = str_to_int64(word, _token_len(parser, token_idx),
                                   &error, thousands)
            if error != 0:
                return error

    return 0


@cython.wraparound(False)
@cython.boundscheck(False)
cdef _try_pylong(parser_t *parser, Py_ssize_t col,
                 int64_t line_start, int64_t line_end,

kh_destroy_float64(<kh_float64_t *>st.na_fhashset)
            free(states)

    # -> tuple["ArrayLike", int, np.ndarray | None]:
    cdef _convert_tokens(self, Py_ssize_t i, int64_t start,
                         int64_t end, object name, bint na_filter,
                         kh_str_starts_t *na_hashset,
                         set na_fset, object col_dtype):
        # The third element is the boolean NA mask recorded by the numeric
        # converters, or None for column kinds that do not record one.

        if col_dtype is not None:

            col_res, na_count, na_mask = self._convert_with_dtype(
                col_dtype, i, start, end, na_filter,
                1, na_hashset, na_fset, False)

            # Fallback on the parse (e.g. we requested int dtype,
            # but its actually a float).
            if col_res is not None:
                r
…[5329 chars omitted]…
.any():
                    raise ValueError(
                        f"cannot safely convert passed user dtype of "
                        f"{col_dtype} for {col_res_orig.dtype.name} dtyped data in "
                        f"column {i}")

        return col_res, na_count, na_mask

    cdef _convert_with_dtype(self, object dtype, Py_ssize_t i,
                             int64_t start, int64_t end,

int64_t start, int64_t end,
                             bint na_filter,
                             bint user_dtype,
                             kh_str_starts_t *na_hashset,
                             set na_fset, bint raise_on_invalid):
        if isinstance(dtype, CategoricalDtype):
            # TODO: I suspect that _categorical_convert could be
            # optimized when dtype is an instance of CategoricalDtype
            codes, cats, na_count = _categorical_convert(
                self.parser, i, start, end, na_filter, na_hashset,
                self.encoding_errors)

            array_type = dtype.construct_array_type()
            if self.low_memory_chunking and dtype.categories is None:
                # GH#56044 chunks could each infer a different category dtype,
                #  breaking union_categoricals; defer inference to
        
…[8628 chars omitted]…
nce per column chunk.  This pins which path the parser takes at
            # the first string column converted, so changing the options
            # mid-read (possible only with chunksize / iterator=True) no longer
            # moves one read on or off the fast path partway through.  The
            # object path still picks its storage downstream, per chunk.
            if self._pa_target is None:

28:from pandas.core.dtypes.astype import astype_array
29:from pandas.core.dtypes.common import (
30:    is_bool_dtype,
31:    is_extension_array_dtype,
33:    is_numeric_dtype,
34:    is_string_dtype,
35:    pandas_dtype,
37:from pandas.core.dtypes.dtypes import (
312:                self.dtype,
328:        conv_data = self._convert_data(data)
372:    def _convert_data(
376:        # apply converters

377:        clean_conv = self._clean_mapping(self.converters)
378:        clean_dtypes = self._clean_mapping(self.dtype)
399:        return self._convert_to_ndarrays(
404:            clean_dtypes,
408:    def _convert_to_ndarrays(
413:        converters=None,
414:        dtypes=None,
419:            conv_f = None if converters is None else converters.get(c, None)
420:            if isinstance(dtypes, dict):
421:                cast_type = dtypes.get(c, None)
423:                # single d
…[2091 chars omitted]…
dict) and not is_numeric_dtype(
1408:                    self.dtype
1412:                    isinstance(self.dtype, dict)
1413:                    and col in self.dtype
1415:                        not is_numeric_dtype(self.dtype[col])
1416:                        or is_bool_dtype(self.dtype[col])
1514:        mask = np.zeros(max_len + 1, dtype=int)
1546:        # Support iterators, convert to a list.

data,
            clean_na_values,
            clean_na_fvalues,
            clean_conv,
            clean_dtypes,
        )

    @final
    def _convert_to_ndarrays(
        self,
        dct: Mapping,
        na_values,

        na_fvalues,
        converters=None,
        dtypes=None,
    ) -> dict[Any, np.ndarray]:
        result = {}
        parse_date_cols = validate_parse_dates_presence(self.parse_dates, self.columns)
        for c, values in dct.items():
            conv_f = None if converters is None else converters.get(c, None)
            if isinstance(dtypes, dict):
                cast_type = dtypes.get(c, None)
            else:
                # single dtype or None
                cast_type = dtypes

            if self.na_filter:
                col_na_values, col_na_fvalues = get_na_values(
                    c, na_values, na_fvalues, self.keep_default_na
…[6467 chars omitted]…
      raise ValueError(
                    f"Unable to convert column {column} to type {cast_type}"
                ) from err
        return values

    @cache_readonly
    def _have_mi_columns(self) -> bool:
        if self.header is None:
            return False

        header = self.header
        if isinstance(header, (list, tuple, np.ndarray)):
            return len(header) > 1
        else:

['-1'] UInt8 <IntegerArray>
[255]
Length: 1, dtype: UInt8 [255]
['-1'] Int8 <IntegerArray>
[-1]
Length: 1, dtype: Int8 [-1]
['257'] UInt8 <IntegerArray>
[1]
Length: 1, dtype: UInt8 [1]
['257'] Int8 <IntegerArray>
[1]
Length: 1, dtype: Int8 [1]

['300.0'] UInt8 TypeError cannot safely cast non-equivalent float64 to uint8
['300.0'] Int8 TypeError cannot safely cast non-equivalent float64 to int8
['257.0'] UInt8 TypeError cannot safely cast non-equivalent float64 to uint8
['257.0'] Int8 TypeError cannot safely cast non-equivalent float64 to int8

1758:                masked = self._convert_masked_numeric(
1768:                boolean = self._convert_boolean_masked(
2002:    cdef _convert_masked_numeric(self, dtype, Py_ssize_t i, int64_t start,
2015:    cdef _convert_boolean_masked(self, Py_ssize_t i, int64_t start,

        return _string_box_utf8(self.parser, i, start, end, na_filter,
                                na_hashset, self.encoding_errors)

    # -> ExtensionArray | None
    cdef _parse_numeric_natural(self, Py_ssize_t i, int64_t start,
                                int64_t end, bint na_filter,
                                kh_str_starts_t *na_hashset, set na_fset):

        # Parse a column with the same nogil converters the col_dtype=None
        # inference path uses (int64 -> uint64 -> float64) and build the natural
        # numpy-nullable array (IntegerArray / FloatingArray) -- i.e. what
        # ``read_cs
…[7637 chars omitted]…
[col for col in self.usecols if col >= num_cols]
            if missing_usecols:
                raise ParserError(
                    "Defining usecols with out-of-bounds indices is not allowed. "
                    f"{missing_usecols} are out of bounds.",
                )

    # -> DtypeObj
    cdef object _get_col_dtype(self, int64_t i, bint is_default_dict_dtype, name):
        col_dtype = None

165:def astype_array(values: ArrayLike, dtype: DtypeObj, copy: bool = False) -> ArrayLike:
199:def astype_array_safe(

    elif np.issubdtype(arr.dtype, np.floating) and dtype.kind in "iu":
        return astype_float_to_int_nansafe(arr, dtype, copy)

    elif arr.dtype == object:
        # let the datetimelike constructors do the element-wise conversion,
        #  so a numeric object array is read in the dtype's unit

        if lib.is_np_dtype(dtype, "M"):
            from pandas.core.arrays import DatetimeArray

            dta = DatetimeArray._from_sequence(arr, dtype=dtype)
            return dta._ndarray

        elif lib.is_np_dtype(dtype, "m"):
            from pandas.core.arrays import TimedeltaArray

            if arr.ndim == 2 and len(arr) > 1:
                # whether the unit applies depends on the values, so a neighbouring
                #  column in the same block m
…[4008 chars omitted]…
 copy=copy)
    except (ValueError, TypeError):
        # e.g. _astype_nansafe can fail on object-dtype of strings
        #  trying to convert to float
        if errors == "ignore":
            new_values = values
        else:
            raise

    return new_values


def astype_is_view(dtype: DtypeObj, new_dtype: DtypeObj) -> bool:
    """Checks if astype avoided copying the data.

    Parameters

pandas/tests/arrays/categorical/test_indexing.py:100:            np.random.default_rng(2).integers(0, 5, size=150000).astype(np.int8)
pandas/tests/arrays/categorical/test_indexing.py:126:            np.random.default_rng(2).integers(0, 5, size=150000).astype(np.int8)
pandas/tests/extension/date/array.py:105:            self._month = dates[1].astype(np.uint8)
pandas/tests/extension/date/array.py:106:            self._day = dates[2].astype(np.uint8)
pandas/tests/frame/methods/test_astype.py:574:        df.astype(np.int8, errors="ignore")
pandas/tests/frame/methods/test_drop_duplicates.py:85:    df["E"] = df["C"].astype("int8")
pandas/tests/frame/test_stack_unstack.py:388:                "H": pd.Series([1, 200, 923442]).astype("int8"),
pandas/tests/internals/test_api.py:108:            "uint": np.arange(3, 6).astype("uint8"),
pandas/tests/io/test_stata.py:110:        expected["u8"] = exp
…[560 chars omitted]…
te_"] = expected["byte_"].astype(np.int8)
pandas/tests/reductions/test_reductions.py:1488:        result = ser.astype("uint8").sum()

pandas/tests/series/methods/test_astype.py:59:        ser.astype(np.int8, errors="raise")
pandas/tests/tools/test_to_datetime.py:2612:        df["month"] = df["month"].astype("int8")
pandas/tests/tools/test_to_datetime.py:2613:        df["day"] = df["day"].astype("int8")

c int8 1.5 ERR ValueError cannot safely convert passed user dtype of int8 for float64 dtyped data in column 0
c int8 127.9 ERR ValueError cannot safely convert passed user dtype of int8 for float64 dtyped data in column 0
c int8 128.1 ERR ValueError cannot safely convert passed user dtype of int8 for float64 dtyped data in column 0
c int8 -0.5 ERR ValueError cannot safely convert passed user dtype of int8 for float64 dtyped data in column 0
c int8 255.9 ERR ValueError cannot safely convert passed user dtype of int8 for float64 dtyped data in column 0
c int8 256.0 ERR ValueError cannot safely convert passed user dtype of int8 for float64 dtyped data in column 0
c int8 300.0 ERR ValueError cannot safely convert passed user dtype of int8 for float64 dtyped data in column 0
c int8 257.0 ERR ValueError cannot safely convert passed user dtype of int8 for float64 dtyped data in column 0
c in
…[2198 chars omitted]…
python uint8 300.0 -> 44 uint8
python uint8 257.0 -> 1 uint8

python uint8 18446744073709551615 -> 255 uint8

python int64 1.5 -> 1 int64
python int64 127.9 -> 127 int64
python int64 128.1 -> 128 int64
python int64 -0.5 -> 0 int64
python int64 255.9 -> 255 int64
python int64 256.0 -> 256 int64
python int64 300.0 -> 300 int64
python int64 257.0 -> 257 int64
python int64 18446744073709551615 -> -1 int64

76 - :func:`read_csv` now supports ``dtype="complex64"`` and ``dtype="complex128"`` with the C engine, enabling round-tripping of complex-number columns written by :meth:`DataFrame.to_csv` (:issue:`9379`)
125 :func:`read_csv` with ``dtype="category"`` infers numeric and boolean categories
128 :func:`read_csv` with ``dtype="category"`` and the ``c`` or ``python`` engine
140     In [3]: pd.read_csv(StringIO(data), dtype="category")["a"].dtype
145     In [5]: pd.read_csv(StringIO(data), dtype="category")["a"].dtype
157     In [7]: pd.read_csv(StringIO(data), dtype="str").astype("category")["a"].dtype
176   ``dtype_backend="numpy_nullable"`` (:issue:`66382`).
186 parser, :func:`read_table`, :func:`read_fwf` and :func:`read_excel` included,
210     In [10]: pd.read_csv(StringIO(data), dtype={"a": CategoricalDtype(ordered=True)})["a"].dtype
395 - :class:`DataFrame` arithmetic, comparison, a
…[8630 chars omitted]…
nd raising ``TypeError`` for ``<``/``>``, instead of comparing elementwise like the NumPy-backed and nullable equivalents; mismatched lengths now raise ``ValueError`` (:issue:`67979`)

1302 - Fixed bug in :meth:`Series.apply` and :meth:`Series.map` where nullable integer dtypes were converted to float, causing precision loss for large integers; now the nullable dtype will be preserved (:issue:`63903`).

506 - Deprecated passing a ``format`` for integer or float columns to :func:`read_sql`, :func:`read_sql_query`, and :func:`read_sql_table` via ``parse_dates``. Cast the column to string and call :func:`to_datetime` after reading instead (:issue:`55663`)
508 - Deprecated passing integer or float values to :func:`to_datetime` with a ``format`` argument. Cast numeric values to strings explicitly first to retain the current behavior (:issue:`55663`)
512 - Deprecated silent dtype changes during setitem-with-expansion (e.g. ``ser.loc[new_key] = incompatible_value``). This will raise an error in a future version; cast the object to the desired dtype before the operation to keep the current behavior. The exception is int/uint to float when the value introduces ``NaN``, which is still allowed per PDEP-6 (:issue:`62369`)
541 - Deprecated passing integers to :class:`Period`, :class:`PeriodIndex`
…[8629 chars omitted]…
eries`, and in casting such an array to ``object`` dtype, showing raw integers such as ``1577836800000000000`` instead of :class:`Timestamp`/:class:`Timedelta` values (:issue:`68073`)
1302 - Fixed bug in :meth:`Series.apply` and :meth:`Series.map` where nullable integer dtypes were converted to float, causing precision loss for large integers; now the nullable dtype will be preserved (:issue:`63903`).

pandas/_libs/ops_dispatch.pyx:63:def maybe_dispatch_ufunc_to_dunder_op(
pandas/_libs/ops_dispatch.pyi:7:def maybe_dispatch_ufunc_to_dunder_op(
DISPATCHED_UFUNCS = {
    "add",
    "sub",
    "mul",
    "pow",
    "mod",
    "floordiv",
    "truediv",
    "divmod",
    "eq",

    "ne",
    "lt",
    "gt",
    "le",
    "ge",
    "remainder",
    "matmul",
    "or",
    "xor",
    "and",
    "neg",
    "pos",
    "abs",
}
UNARY_UFUNCS = {
    "neg",
    "pos",
    "abs",
}
UFUNC_ALIASES = {
    "subtract": "sub",
    "multiply": "mul",
    "floor_divide": "floordiv",
    "true_divide": "truediv",
    "power": "pow",
    "remainder": "mod",
    "divide": "truediv",
    "equal": "eq",
    "not_equal": "ne",
    "less": "lt",
    "less_equal": "le",
    "greater": "gt",
    "greater_equal": "ge",
    "bitwise_or": "or",
    "bitwise_and": "and",
    "bitwise_xor": "xor",
    "negative": "ne
…[1411 chars omitted]…

            return meth(inputs[1])

        elif inputs[1] is self:
            name = REVERSED_NAMES.get(op_name, f"__r{op_name}__")

            meth = getattr(self, name, not_implemented)
            result = meth(inputs[0])
            return result

        else:
            # should not be reached, but covering our bases
            return NotImplemented

    else:
        return NotImplemented

pandas/tests/extension/array_with_attr/array.py:22:class FloatAttrDtype(ExtensionDtype):
pandas/tests/extension/base/dim2.py:259:            elif dtype.kind in "ib":
pandas/tests/extension/base/dim2.py:262:                # i.e. dtype.kind == "u"
pandas/tests/extension/base/dim2.py:268:            if data.dtype.kind in "iub":
pandas/tests/extension/base/dtype.py:13:class BaseDtypeTests:
pandas/tests/extension/base/dtype.py:14:    """Base class for ExtensionDtype classes"""
pandas/tests/extension/base/dtype.py:19:    def test_kind(self, dtype):
pandas/tests/extension/base/dtype.py:21:        assert dtype.kind in valid
pandas/tests/extension/base/groupby.py:161:            or dtype.kind == "m"  # in particular duration[*][pyarrow]
pandas/tests/extension/base/methods.py:906:        round_fn = np.round if data.dtype.kind == "c" else round
pandas/tests/extension/base/ops.py:159:    to indi
…[8629 chars omitted]…

          raise TypeError
        elif isinstance(scalars, DateArray):
            if dtype is not None:
                return scalars.astype(dtype, copy=copy)
            if copy:
                return scalars.copy()
            return scalars[:]
        elif isinstance(scalars, np.ndarray):
            scalars = scalars.astype("U10")  # 10 chars for yyyy-mm-dd
            return DateArray(scalars)

from __future__ import annotations

import datetime as dt
from typing import (
    TYPE_CHECKING,
    Any,
    cast,
)

import numpy as np

from pandas.core.dtypes.dtypes import register_extension_dtype

from pandas.api.extensions import (
    ExtensionArray,
    ExtensionDtype,
)
from pandas.api.types import pandas_dtype

if TYPE_CHECKING:
    from collections.abc import Sequence

    from pandas._typing import (
        Dtype,
        PositionalIndexer,
    )


@register_extension_dtype
class DateDtype(ExtensionDtype):
    @property
    def type(self):
        return dt.date

    @property
    def name(self):
        return "DateDtype"

    @classmethod
    def construct_from_string(cls, string: str):
        if not isinstance(string, str):
            raise TypeError(
                f"'construct_from_string' expects a string, got {type(string)}"
            )

        if string ==
…[5142 chars omitted]…

        # Some aliases for common attribute names to ensure pandas supports
        # these
        self._items = self._data = self.data
        # those aliases are currently not working due to assumptions
        # in internal code (GH-20735)
        # self._values = self.values = self.data

    @classmethod
    def _from_sequence(cls, scalars, *, dtype=None, copy=False):
        return cls(scalars)

<class 'pandas.Timestamp'> False None
<class 'pandas.Timedelta'> False None
<class 'pandas.Period'> False None
<class 'pandas.api.typing.NaTType'> False None
<class 'datetime.datetime'> False None
<class 'datetime.date'> False None
<class 'datetime.timedelta'> False None
<class 'numpy.datetime64'> False None
<class 'numpy.timedelta64'> False None

<class 'pandas.Timestamp'> 2020-01-01 00:00:00
add int ERR TypeError Addition/subtraction of integers and integer-arrays with Timestamp is no longer 
add bool ERR TypeError unsupported operand type(s) for +: 'Timestamp' and 'bool'
add timedelta64 ERR UFuncTypeError ufunc 'add' cannot use operands with types dtype('O') and dtype('<m8[D]')
add datetime64 ERR UFuncTypeError ufunc 'add' cannot use operands with types dtype('O') and dtype('<M8[D]')
add Timestamp ERR TypeError unsupported operand type(s) for +: 'Timestamp' and 'Timestamp'
subtract int ERR TypeError Addition/subtraction of integers and integer-arrays with Timestamp is no longer 
subtract bool ERR TypeError unsupported operand type(s) for -: 'Timestamp' and 'bool'
subtract timedelta64 ERR UFuncTypeError ufunc 'subtract' cannot use operands with types dtype('O') and dtype('<m8[D]')
subtract datetime64 ERR UFuncTypeError ufun
…[6730 chars omitted]…
f ArrayType

isnan NaTType ERR TypeError return arrays must be of ArrayType
isfinite int ERR TypeError return arrays must be of ArrayType
isfinite bool ERR TypeError return arrays must be of ArrayType
isfinite timedelta64 ERR TypeError return arrays must be of ArrayType
isfinite datetime64 ERR TypeError return arrays must be of ArrayType
isfinite NaTType ERR TypeError return arrays must be of ArrayType

<class 'pandas.Timestamp'>
add int ERR TypeError Addition/subtraction of integers and integer-arrays with Timestamp is 
add timedelta64 ERR UFuncTypeError ufunc 'add' cannot use operands with types dtype('O') and dtype('<m8[D
add datetime64 ERR UFuncTypeError ufunc 'add' cannot use operands with types dtype('O') and dtype('<M8[D
add Timestamp ERR TypeError unsupported operand type(s) for +: 'Timestamp' and 'Timestamp'
subtract int ERR TypeError Addition/subtraction of integers and integer-arrays with Timestamp is 
subtract timedelta64 ERR UFuncTypeError ufunc 'subtract' cannot use operands with types dtype('O') and dtype('
subtract datetime64 ERR UFuncTypeError ufunc 'subtract' cannot use operands with types dtype('O') and dtype('
subtract Timestamp -> Timedelta('0 days 00:00:00') <class 'pandas.Timedelta'>
equal int -> np.False_ <class 'numpy.bool'>
equal timedelta64 -> np.False_ <cl
…[3884 chars omitted]…

l'>
equal datetime64 -> np.False_ <class 'numpy.bool'>
equal NaTType -> np.False_ <class 'numpy.bool'>
maximum int ERR TypeError '>=' not supported between instances of 'NaTType' and 'int'
maximum timedelta64 -> datetime.timedelta(days=1) <class 'datetime.timedelta'>
maximum datetime64 ERR TypeError Cannot compare NaT with datetime.date object
maximum NaTType -> NaT <class 'pandas.api.typing.NaTType'>

pandas/tests/arithmetic/test_period.py:1486:        result = np.subtract(idx, Period("2012-01", freq="M"))
pandas/tests/arithmetic/test_period.py:1493:        result = np.subtract(Period("2012-01", freq="M"), idx)
pandas/tests/scalar/test_nat.py:167:    assert np.isnan(getattr(pd.NaT, method)())
pandas/tests/scalar/timedelta/test_arithmetic.py:787:        assert np.isnan(td / pd.NaT)
pandas/tests/scalar/timedelta/test_arithmetic.py:961:        assert np.isnan(td // pd.NaT)
pandas/tests/scalar/timedelta/test_arithmetic.py:962:        assert np.isnan(td // np.timedelta64("NaT", "ns"))
pandas/tests/scalar/timedelta/test_arithmetic.py:1047:        assert np.isnan(td.__rfloordiv__(pd.NaT))
pandas/tests/scalar/timedelta/test_arithmetic.py:1048:        assert np.isnan(td.__rfloordiv__(np.timedelta64("NaT", "ns")))

Timestamp isnan ERR TypeError ufunc 'isnan' not supported for the input types, and the inputs could not be saf
Timestamp isinf ERR TypeError ufunc 'isinf' not supported for the input types, and the inputs could not be saf
Timestamp isfinite ERR TypeError ufunc 'isfinite' not supported for the input types, and the inputs could not be 
Timestamp logical_not -> False
Timedelta isnan ERR TypeError ufunc 'isnan' not supported for the input types, and the inputs could not be saf
Timedelta isinf ERR TypeError ufunc 'isinf' not supported for the input types, and the inputs could not be saf
Timedelta isfinite ERR TypeError ufunc 'isfinite' not supported for the input types, and the inputs could not be 
Timedelta logical_not -> False
Period isnan ERR TypeError ufunc 'isnan' not supported for the input types, and the inputs could not be saf
Period isinf ERR TypeError ufunc 'isinf' not supported 
…[146 chars omitted]…
uts could not be 

Period logical_not -> False
NaTType isnan ERR TypeError ufunc 'isnan' not supported for the input types, and the inputs could not be saf
NaTType isinf ERR TypeError ufunc 'isinf' not supported for the input types, and the inputs could not be saf
NaTType isfinite ERR TypeError ufunc 'isfinite' not supported for the input types, and the inputs could not be 
NaTType logical_not -> False

__init__.py
array_ops.py
common.py
dispatch.py
invalid.py
mask_ops.py
missing.py
"""
Arithmetic operations for PandasObjects

This is not a public API.
"""

from __future__ import annotations

from pandas.core.ops.array_ops import (
    arithmetic_op,
    comp_method_OBJECT_ARRAY,
    comparison_op,
    fill_binop,
    get_array_op,
    logical_op,
    maybe_prepare_scalar_for_op,
)
from pandas.core.ops.common import (
    get_op_result_name,
    has_castable_attr,
    maybe_warn_listlike,
    raise_if_2d,
    unpack_zerodim_and_defer,
)
from pandas.core.ops.invalid import (
    disallow_datetimelike_logical_op,
    invalid_comparison,
)
from pandas.core.ops.mask_ops import (
    kleene_and,
    kleene_or,
    kleene_xor,
)
from pandas.core.roperator import (
    radd,
    rand_,
    rdiv,
    rdivmod,
    rfloordiv,
    rmod,
    rmul,
    ror_,
    rpow,
    rsub,
    rtruediv,
    
…[894 chars omitted]…
  "rtruediv",
    "rxor",
pandas/core/arrays/datetimelike.py:137:from pandas.core.ops.invalid import (
pandas/core/arrays/masked.py:94:from pandas.core.ops import invalid_comparison
pandas/core/indexes/multi.py:97:from pandas.core.ops.invalid import make_invalid_op
pandas/core/ops/array_ops.py:62:from pandas.core.ops.invalid import (
pandas/core/ops/__init__.py:25:from pandas.core.ops.invalid import (

if month <= 2:
            year -= 1
            month += 12
        result = (
            day +
            np.trunc((153 * month - 457) / 5) +
            365 * year +
            np.floor(year / 4) -
            np.floor(year / 100) +
            np.floor(year / 400) +
            1721118.5 +
            (hour +

             minute / 60.0 +
             second / 3600.0 +
             microsecond / 3600.0 / 1e+6 +
             self._nanosecond / 3600.0 / 1e+9
             ) / 24.0
        )
        result = maybe_unbox_numpy_scalar(result)
        return result

    def isoweekday(self):
        """
        Return the day of the week represented by the date.

        Monday == 1 ... Sunday == 7.

        See Also
        --------
        Timestamp.weekday : Return the day of the week with Monday=0, Sunday=6.
        Timestamp.isocalendar : Return a tuple containing ISO yea
…[2442 chars omitted]…
 MinMaxReso:
326:cdef class _Timestamp(ABCTimestamp):
2005:class Timestamp(_Timestamp):
330:cdef class ResoState:
1522:class MinMaxReso:
1559:cdef class _Timedelta(timedelta):
2517:class Timedelta(_Timedelta):
1916:class IncompatibleFrequency(TypeError):
1941:cdef class PeriodMixin:
2050:cdef class _Period(PeriodMixin):
3352:class Period(_Period):
86:cdef class _NaT(datetime):
349:class NaTType(_NaT):

else:
            td = Timedelta(td64)
            res_value = td // obj

        result[i] = res_value

    return result


cdef bint is_any_td_scalar(object obj):
    """
    Cython equivalent for `isinstance(obj, (timedelta, np.timedelta64, Tick))`

    Parameters
    ----------
    obj : object

    Returns
    -------
    bool
    """
    return (
        PyDelta_Check(obj) or cnp.is_timedelta64_object(obj) or is_tick_object(obj)
    )


cdef inline _wrapped_to_timedelta(object other):
    # Helper for deprecating cases where we cast str to Timedelta
    td = Timedelta(other)
    if isinstance(other, str):
        from pandas.errors import Pandas4Warning
        warnings.warn(
            # GH#59653
            "Scalar operations between Timedelta and string are "
            "deprecated and will raise in a future version. "
            "Explicitly cast to Timedelta first
…[7737 chars omitted]…
""
    Is this an np.datetime64 object np.datetime64("NaT").
    """
    if cnp.is_datetime64_object(val):
        return cnp.get_datetime64_value(val) == NPY_NAT
    return False


cdef bint is_td64nat(object val):
    """
    Is this an np.timedelta64 object np.timedelta64("NaT").
    """
    if cnp.is_timedelta64_object(val):
        return cnp.get_timedelta64_value(val) == NPY_NAT
    return False

class Period(_Period):
    """
    Represents a period of time.

    A `Period` represents a specific time span rather than a point in time.
    Unlike `Timestamp`, which represents a single instant, a `Period` defines a
    duration, such as a month, quarter, or year. The exact representation is
    determined by the `freq` parameter.

    Parameters
    ----------
    value : Period, str, datetime, date or pandas.Timestamp, default None

        The time period represented (e.g., '4Q2005'). This represents neither
        the start or the end of the period, but rather the entire period itself.
    freq : str, default None
        One of pandas period strings or corresponding objects. Accepted
        strings are listed in the
        :ref:`period alias section <timeseries.period_aliases>` in the user docs.
        If value is datetime, freq is required.
    ordinal : int, default Non
…[3738 chars omitted]…
ter, int day,
3580:def validate_end_alias(how: str) -> str:  # Literal["E", "S"]
4058:def _daysinmonth_fget(self):
4084:cdef int64_t normalize_i8_stamp(int64_t local_val, int64_t ppd):
3266:def truediv_object_array(ndarray left, ndarray right):
3298:def floordiv_object_array(ndarray left, ndarray right):
3328:cdef bint is_any_td_scalar(object obj):
3345:cdef inline _wrapped_to_timedelta(object other):

uint64 int8 [-1] [False] False
uint64 int64 [-9223372036854775808] [False] False
int64 uint8 [255] [False] False

pandas/tests/arrays/boolean/test_arithmetic.py:85:    expected = op(left_array.astype("Int8"), right_array.astype("Int8"))
pandas/tests/arrays/integer/test_dtypes.py:174:    result = arr.astype("Int32", copy=False)
pandas/tests/extension/test_arrow.py:4006:    expected = ser_numpy.dt.components.astype("Int32[pyarrow]")
pandas/tests/extension/test_masked.py:206:                expected = expected.astype("Int8")
pandas/tests/frame/methods/test_astype.py:870:    result = df.astype({"a": Int16DtypeNoCopy()})
pandas/tests/frame/methods/test_to_csv.py:1418:        df["b"] = df["b"].astype("Int16")
pandas/tests/indexes/datetimes/methods/test_isocalendar.py:17:    ).astype({"year": "Int32", "week": "UInt32", "day": "UInt32"})
pandas/tests/indexes/datetimes/methods/test_isocalendar.py:37:    ).astype({"year": "Int32", "week": "UInt32", "day": "UInt32"})
pandas/tests/series/accessors/test_dt_accessor.py:913:        ).astype({"year": "Int32", "week": "UInt32", "day": "UInt32"})

from __future__ import annotations

from collections import abc
import csv
from io import StringIO
import re
from typing import (
    IO,
    TYPE_CHECKING,
    Any,
    Literal,
    cast,

    final,
)
import warnings

import numpy as np

from pandas._libs import lib
from pandas.errors import (
    EmptyDataError,
    ParserError,
    ParserWarning,
)
from pandas.util._decorators import cache_readonly
from pandas.util._exceptions import find_stack_level

from pandas.core.dtypes.astype import astype_array
from pandas.core.dtypes.common import (
    is_bool_dtype,
    is_extension_array_dtype,
    is_integer,
    is_numeric_dtype,
    is_string_dtype,
    pandas_dtype,
)
from pandas.core.dtypes.dtypes import (
    CategoricalDtype,
    ExtensionDtype,
)

from pandas.core import algorithms
from pandas.core.arrays import (
    Categorical,
    ExtensionArray,
)
from pandas.core.arrays.boo
…[302 chars omitted]…
    validate_parse_dates_presence,
)

if TYPE_CHECKING:
    from collections.abc import (
        Hashable,
        Iterator,
        Mapping,
        Sequence,
    )

    from pandas._typing import (
        ArrayLike,
        DtypeObj,
        ReadCsvBuffer,
        Scalar,
        T,
    )

    from pandas import (
        MultiIndex,
17:import numpy as np
29:from pandas.core.dtypes.common import (

pandas/tests/io/parser/test_concatenate_chunks.py:36:        [np.array([1.5, 2.5], dtype=object), np.array(["a", "b"])]
pandas/tests/io/parser/test_textreader.py:288:        reader = _make_reader(dtype={"one": np.uint8, 1: object})
pandas/tests/io/parser/test_upcast.py:54:    arr = np.array([True, False, na_value], dtype="uint8").view(dtype)
pandas/tests/io/parser/test_upcast.py:65:    arr = np.array([True, False, False], dtype="uint8").view(dtype)
pandas/tests/io/parser/usecols/test_usecols_basic.py:535:        dtype={"col1": "string", "col2": "uint8", "col3": "string"},
pandas/tests/io/parser/usecols/test_usecols_basic.py:538:        {"col1": pd.array(["a", "b"]), "col2": np.array([1, 2], dtype="uint8")}
pandas/tests/io/parser/dtypes/test_categorical.py:114:    data = "a,b\n1,x\n,x\n1.0,x\n2,x\n,x"
pandas/tests/io/parser/dtypes/test_categorical.py:117:            "a": pd.Categorical
…[3039 chars omitted]…
as/tests/io/parser/common/test_ints.py:20:1.0,1
pandas/tests/io/parser/common/test_ints.py:21:2.0,2
pandas/tests/io/parser/common/test_ints.py:22:3.0,3

pandas/tests/io/parser/common/test_ints.py:27:    expected = pd.DataFrame([[1.0, 1], [2.0, 2], [3.0, 3]], columns=["A", "B"])
pandas/tests/io/parser/common/test_ints.py:245:5,1;0;0;0;1;1;843;843;843;1;1;1;1;1;1;0;0;1;1;0;0,64.0,;,4321113141090630389"""

return TextReader(
                StringIO(data), delimiter=",", header=None, **kwds, **_na_value_kwargs
            )

        reader = _make_reader(dtype="S5,i4")
        result = reader.read()

        assert result[0].dtype == "S5"

        ex_values = np.array(["a", "aa", "aaa", "aaaa", "aaaaa"], dtype="S5")
        assert (result[0] == ex_values).all()
        assert result[1].dtype == "i4"

        reader = _make_reader(dtype="S4")
        result = reader.read()
        assert result[0].dtype == "S4"
        ex_values = np.array(["a", "aa", "aaa", "aaaa", "aaaa"], dtype="S4")
        assert (result[0] == ex_values).all()
        assert result[1].dtype == "S4"

    def test_pass_dtype(self):
        data = """\
one,two
1,a
2,b
3,c
4,d"""

        def _make_reader(**kwds):
            if "dtype" in kwds:
                kwds["dtype"] = ensure_dtype_objs(kwds["dtype"]
…[2502 chars omitted]…
r.read_csv(StringIO(data))

    expected = pd.DataFrame([[1.0, 1], [2.0, 2], [3.0, 3]], columns=["A", "B"])
    tm.assert_frame_equal(result, expected)


@pytest.mark.parametrize(
    "data,kwargs,expected",
    [
        (
            "A,B\nTrue,1\nFalse,2\nTrue,3",
            {},
            [[True, 1], [False, 2], [True, 3]],
        ),
        (
            "A,B\nYES,1\nno,2\nyes,3\nNo,3\nYes,3",

<class 'pandas.Timestamp'> True
<class 'pandas.Timedelta'> True
<class 'pandas.Period'> True
<class 'pandas.api.typing.NaTType'> True
<class 'numpy.datetime64'> True
<class 'numpy.timedelta64'> True
<class 'pandas.Series'> True
<class 'pandas.Series'> False

Series logical_and NameError name 'numbers' is not defined
Series logical_or NameError name 'numbers' is not defined
Series logical_xor NameError name 'numbers' is not defined
Series logical_not NameError name 'numbers' is not defined
Series logical_and NameError name 'numbers' is not defined
Series logical_or NameError name 'numbers' is not defined
Series logical_xor NameError name 'numbers' is not defined
Series logical_not NameError name 'numbers' is not defined
DatetimeIndex logical_and -> Index([True, True], dtype='bool')
DatetimeIndex logical_or -> Index([True, True], dtype='bool')
DatetimeIndex logical_xor -> Index([False, False], dtype='bool')
DatetimeIndex logical_not TypeError ufunc 'logical_not' not supported for the input types, and the inputs could not be safely coerced to any supported types according to the casting rule ''safe''

DatetimeArray logical_and -> [ True  True]
DatetimeArray logical_or -> [ True  True]
DatetimeArray logical_xor -> [False False]
DatetimeArray logical_not TypeError ufunc 'logical_not' not supported for the input types, and the inputs could not be safely coerced to any supported types according to the casting rule ''safe''

Series logical_and TypeError cannot perform the numpy op logical_and
Series logical_or TypeError cannot perform the numpy op logical_or
Series logical_xor TypeError cannot perform the numpy op logical_xor
Series logical_not TypeError cannot perform the numpy op logical_not
Series logical_and TypeError cannot perform the numpy op logical_and
Series logical_or TypeError cannot perform the numpy op logical_or
Series logical_xor TypeError cannot perform the numpy op logical_xor
Series logical_not TypeError cannot perform the numpy op logical_not
DatetimeIndex logical_and -> Index([True, True], dtype='bool')
DatetimeIndex logical_or -> Index([True, True], dtype='bool')
DatetimeIndex logical_xor -> Index([False, False], dtype='bool')
DatetimeIndex logical_not TypeError ufunc 'logical_not' not supported for the input types, and the inputs could not be safely coerced to any supported types according to the casting rule ''safe''

DatetimeArray logical_and -> [ True  True]
DatetimeArray logical_or -> [ True  True]
DatetimeArray logical_xor -> [False False]
DatetimeArray logical_not TypeError ufunc 'logical_not' not supported for the input types, and the inputs could not be safely coerced to any supported types according to the casting rule ''safe''

def __array_ufunc__(
        self, ufunc: np.ufunc, method: str_t, *inputs: Any, **kwargs: Any
    ) -> Any:
        if any(isinstance(other, (ABCSeries, ABCDataFrame)) for other in inputs):
            return NotImplemented

        result = arraylike.maybe_dispatch_ufunc_to_dunder_op(
            self, ufunc, method, *inputs, **kwargs
        )
        if result is not NotImplemented:
            return result

        if "out" in kwargs:
            # e.g. test_dti_isub_tdi
            return arraylike.dispatch_ufunc_with_out(
                self, ufunc, method, *inputs, **kwargs
            )

        if method == "reduce":
            result = arraylike.dispatch_reduction_ufunc(
                self, ufunc, method, *inputs, **kwargs
            )
            if result is not NotImplemented:
                return result

        new_inputs = [x if x is not self else x._value
…[1355 chars omitted]…

        ``int64``, ``float64``, ``object``, or an extension dtype.

        See Also
        --------
        Index.inferred_type: Return a string of the type inferred from the values.

        Examples
        --------
        >>> idx = pd.Index([1, 2, 3])
        >>> idx
        Index([1, 2, 3], dtype='int64')
        >>> idx.dtype
        dtype('int64')
        """
        return self._data.dtype

def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
        out = kwargs.get("out", ())

        for x in inputs + out:
            if not isinstance(x, (*self._HANDLED_TYPES, SparseArray)):
                return NotImplemented

        # for binary ops, use our custom dunder methods
        result = arraylike.maybe_dispatch_ufunc_to_dunder_op(
            self, ufunc, method, *inputs, **kwargs
        )
        if result is not NotImplemented:

            return result

        if "out" in kwargs:
            # e.g. tests.arrays.sparse.test_arithmetics.test_ndarray_inplace
            res = arraylike.dispatch_ufunc_with_out(
                self, ufunc, method, *inputs, **kwargs
            )
            return res

        if method == "reduce":
            result = arraylike.dispatch_reduction_ufunc(
                self, ufunc, method, *inputs, **kwarg
…[5541 chars omitted]…
__invert__ is not supported for string dtypes")
        else:
            return self._from_pyarrow_array(pc.invert(self._pa_array))

    def __neg__(self) -> Self:
        try:
            return self._from_pyarrow_array(pc.negate_checked(self._pa_array))
        except pa.ArrowNotImplementedError as err:
            raise TypeError(
                f"unary '-' not supported for dtype '{self.dtype}'"

dt logical_and TypeError cannot perform the numpy op logical_and
dt logical_or TypeError cannot perform the numpy op logical_or
dt logical_xor TypeError cannot perform the numpy op logical_xor
dt logical_not TypeError cannot perform the numpy op logical_not
dt_tz logical_and TypeError cannot perform the numpy op logical_and
dt_tz logical_or TypeError cannot perform the numpy op logical_or
dt_tz logical_xor TypeError cannot perform the numpy op logical_xor
dt_tz logical_not TypeError cannot perform the numpy op logical_not
td logical_and TypeError cannot perform the numpy op logical_and
td logical_or TypeError cannot perform the numpy op logical_or
td logical_xor TypeError cannot perform the numpy op logical_xor
td logical_not TypeError cannot perform the numpy op logical_not

period logical_and TypeError cannot perform the numpy op logical_and
period logical_or TypeError cannot perform
…[2236 chars omitted]…
 TypeError cannot perform the numpy op logical_xor
arrtd logical_not TypeError cannot perform the numpy op logical_not
arrperiod logical_and TypeError cannot perform the numpy op logical_and
arrperiod logical_or TypeError cannot perform the numpy op logical_or
arrperiod logical_xor TypeError cannot perform the numpy op logical_xor
arrperiod logical_not TypeError cannot perform the numpy op logical_not

Timestamp logical_and True -> True
Timestamp logical_and <NA> TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'logical_and'>, '__call__', 
Timestamp logical_and 1 -> 1
Timestamp logical_or True -> 2020-01-01 00:00:00
Timestamp logical_or <NA> TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'logical_or'>, '__call__', T
Timestamp logical_or 1 -> 2020-01-01 00:00:00
Timestamp logical_xor True AttributeError 'Timestamp' object has no attribute 'logical_xor'
Timestamp logical_xor <NA> TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'logical_xor'>, '__call__', 
Timestamp logical_xor 1 AttributeError 'Timestamp' object has no attribute 'logical_xor'
Timestamp logical_not True -> False
Timestamp logical_not <NA> -> False
Timestamp logical_not 1 -> False

Timestamp logical_and True -> True
Time
…[4485 chars omitted]…
 
NA logical_xor Timedelta TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'logical_xor'>, '__call__', 
NA logical_xor Period TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'logical_xor'>, '__call__', 
NA logical_xor NaTType TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'logical_xor'>, '__call__',

Traceback (most recent call last):
  File "<stdin>", line 26, in <module>
AssertionError
ninja: Entering directory `build/cp312'
[1/4] Generating write_version_file with a custom command
[2/4] Compiling Cython source /repo/pandas/_libs/tslibs/timestamps.pyx
[3/4] Compiling C object pandas/_libs/tslibs/timestamps.cpython-312-x86_64-linux-gnu.so.p/meson-generated_timestamps.pyx.c.o
[4/4] Linking target pandas/_libs/tslibs/timestamps.cpython-312-x86_64-linux-gnu.so

3261-        return div, other - div * self
3262-
3263-
3264-@cython.wraparound(False)
3265-@cython.boundscheck(False)
3266:def truediv_object_array(ndarray left, ndarray right):
3267-    cdef:
3268-        ndarray[object] result = np.empty((<object>left).shape, dtype=object)
3553-        freq = cls._maybe_convert_freq(freq)
3554-        dtype = PeriodDtypeBase(freq._period_dtype_code, freq.n)
3555-        return cls._from_ordinal(ordinal, dtype=dtype)
3556-

3557-
3558:cdef bint is_period_object(object obj):
3559-    return isinstance(obj, _Period)
3560-
2062-        's'
2063-        """
2064-        return c_NaT
2065-
2066-
2067:c_NaT = NaTType()  # C-visible
2068-NaT = c_NaT        # Python-visible
2069-NaT.__module__ = "pandas"
pandas/_libs/tslibs/timestamps.pyx:4053:    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):

Traceback (most recent call last):
  File "<stdin>", line 13, in <module>
AssertionError: pandas/_libs/tslibs/timedeltas.pyx
pandas/_libs/tslibs/timestamps.pyx:4053:    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
ninja: Entering directory `build/cp312'
[1/1] Generating write_version_file with a custom command

pandas/_libs/tslibs/timedeltas.pyx True False
pandas/_libs/tslibs/period.pyx True False
pandas/_libs/tslibs/nattype.pyx True False
pandas/_libs/tslibs/timestamps.pyx:4053:    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
pandas/_libs/tslibs/timedeltas.pyx:3263:    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
pandas/_libs/tslibs/period.pyx:3557:    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
pandas/_libs/tslibs/nattype.pyx:2066:    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
ninja: Entering directory `build/cp312'
[1/10] Generating write_version_file with a custom command
[2/10] Compiling Cython source /repo/pandas/_libs/tslibs/nattype.pyx
[3/10] Compiling Cython source /repo/pandas/_libs/tslibs/period.pyx
[4/10] Compiling Cython source /repo/pandas/_libs/tslibs/timedeltas.pyx

warning: /repo/pandas/_libs/tslibs/timedeltas
…[421 chars omitted]…
 Compiling C object pandas/_libs/tslibs/period.cpython-312-x86_64-linux-gnu.so.p/meson-generated_period.pyx.c.o
[8/10] Linking target pandas/_libs/tslibs/period.cpython-312-x86_64-linux-gnu.so
[9/10] Compiling C object pandas/_libs/tslibs/timedeltas.cpython-312-x86_64-linux-gnu.so.p/meson-generated_timedeltas.pyx.c.o
[10/10] Linking target pandas/_libs/tslibs/timedeltas.cpython-312-x86_64-linux-gnu.so

Timestamp logical_and True TypeError cannot perform the numpy op logical_and
Timestamp logical_and <NA> TypeError cannot perform the numpy op logical_and
Timestamp logical_and 1 TypeError cannot perform the numpy op logical_and
Timestamp logical_or True TypeError cannot perform the numpy op logical_or
Timestamp logical_or <NA> TypeError cannot perform the numpy op logical_or
Timestamp logical_or 1 TypeError cannot perform the numpy op logical_or
Timestamp logical_xor True TypeError cannot perform the numpy op logical_xor
Timestamp logical_xor <NA> TypeError cannot perform the numpy op logical_xor
Timestamp logical_xor 1 TypeError cannot perform the numpy op logical_xor
Timestamp logical_not True TypeError cannot perform the numpy op logical_not
Timestamp logical_not <NA> TypeError cannot perform the numpy op logical_not
Timestamp logical_not 1 TypeError cannot perform the numpy op log

…[8628 chars omitted]…
d 'int'
nonlog NaTType maximum timedelta64 -> datetime.timedelta(days=1)
nonlog NaTType maximum NaTType -> NaT
nonlog NaTType isnan int TypeError return arrays must be of ArrayType
nonlog NaTType isnan timedelta64 TypeError ufunc 'isnan' not supported for the input types, and the inputs could 
nonlog NaTType isnan NaTType TypeError ufunc 'isnan' not supported for the input types, and the inputs could

Dummy bool logical_and -> third-party
Dummy <class 'numpy.dtypes.BoolDType'> logical_not only left -> 0    False
1     True
dtype: bool
Dummy bool logical_not -> third-party
Dummy datetime64[us] logical_and -> third-party
Dummy datetime64[us] logical_not ERR TypeError cannot perform the numpy op logical_not
NoUfunc bool logical_and -> 0    <__main__.NoUfunc object at 0x79969ed1b2f0>
1                                          False
dtype: object
NoUfunc <class 'numpy.dtypes.BoolDType'> logical_not only left -> 0    False
1     True

dtype: bool
NoUfunc bool logical_not -> None
NoUfunc datetime64[us] logical_and ERR TypeError cannot perform the numpy op logical_and
NoUfunc datetime64[us] logical_not ERR TypeError cannot perform the numpy op logical_not
scalar custom third-party
scalar custom third-party

array int64 UInt8 ERR TypeError cannot safely cast non-equivalent int64 to uint8
array int64 Int8 -> <IntegerArray>
[-1, 2]
Length: 2, dtype: Int8 [-1  2] [False False]
array int64 UInt64 ERR TypeError cannot safely cast non-equivalent int64 to uint64
array int64 Int64 -> <IntegerArray>
[-1, 2]
Length: 2, dtype: Int64 [-1  2] [False False]

array int64mask UInt8 -> <IntegerArray>
[<NA>, 2]
Length: 2, dtype: UInt8 [1 2] [ True False]

array int64mask Int8 -> <IntegerArray>
[<NA>, 2]
Length: 2, dtype: Int8 [1 2] [ True False]
array int64mask UInt64 -> <IntegerArray>
[<NA>, 2]
Length: 2, dtype: UInt64 [1 2] [ True False]
array int64mask Int64 -> <IntegerArray>
[<NA>, 2]
Length: 2, dtype: Int64 [-1  2] [ True False]

array uint64 UInt8 ERR TypeError cannot safely cast non-equivalent uint64 to uint8
array uint64 Int8 ERR TypeError cannot safely cast non-equivalent uint64 to int8
array uint6
…[1015 chars omitted]…
t8 ERR TypeError cannot safely cast non-equivalent uint64 to uint8
astype uint64 Int8 ERR TypeError cannot safely cast non-equivalent uint64 to int8
astype uint64mask UInt8 -> <IntegerArray>
[<NA>, 2]
Length: 2, dtype: UInt8 [1 2] [ True False]
astype uint64mask Int8 -> <IntegerArray>
[<NA>, 2]
Length: 2, dtype: Int8 [1 2] [ True False]
assign hidden -> <IntegerArray>
[<NA>, 2]
Length: 2, dtype: UInt8

ninja: Entering directory `build/cp312'
[1/4] Generating write_version_file with a custom command
[2/4] Compiling Cython source /repo/pandas/_libs/parsers.pyx
[3/4] Compiling C object pandas/_libs/parsers.cpython-312-x86_64-linux-gnu.so.p/meson-generated_parsers.pyx.c.o
[4/4] Linking target pandas/_libs/parsers.cpython-312-x86_64-linux-gnu.so

c uint8 None -1 ERR ValueError cannot safely convert passed user dtype of uint8 for int64 dtyped data in column 0
c uint8 numpy_nullable -1 ERR ValueError cannot safely convert passed user dtype of uint8 for int64 dtyped data in column 0
c uint8 None 257 ERR ValueError cannot safely convert passed user dtype of uint8 for int64 dtyped data in column 0
c uint8 numpy_nullable 257 ERR ValueError cannot safely convert passed user dtype of uint8 for int64 dtyped data in column 0
c uint8 None 300.0 ERR ValueError cannot safely convert passed user dtype of uint8 for float64 dtyped data in column 0
c uint8 numpy_nullable 300.0 ERR ValueError cannot safely convert passed user dtype of uint8 for float64 dtyped data in column 0
c uint8 None 257.0 ERR ValueError cannot safely convert passed user dtype of uint8 for float64 dtyped data in column 0
c uint8 numpy_nullable 257.0 ERR ValueError cannot s
…[8629 chars omitted]…
073709551615 ERR TypeError cannot safely cast non-equivalent uint64 to int64
python Int64 numpy_nullable 18446744073709551615 ERR TypeError cannot safely cast non-equivalent uint64 to int64
python Int64 None 9223372036854775808 ERR TypeError cannot safely cast non-equivalent uint64 to int64

python Int64 numpy_nullable 9223372036854775808 ERR TypeError cannot safely cast non-equivalent uint64 to int64

c uint8 -1 ERR ValueError cannot safely convert passed user dtype of uint8 for int64 dtyped data in column 0
c uint8 257 ERR ValueError cannot safely convert passed user dtype of uint8 for int64 dtyped data in column 0
c uint8 300.0 ERR ValueError cannot safely convert passed user dtype of uint8 for float64 dtyped data in column 0
c uint8 257.0 ERR ValueError cannot safely convert passed user dtype of uint8 for float64 dtyped data in column 0
c uint8 1.5 ERR ValueError cannot safely convert passed user dtype of uint8 for float64 dtyped data in column 0
c uint8 18446744073709551615 ERR ValueError cannot safely convert passed user dtype of uint8 for uint64 dtyped data in column 0
c int8 -1 -> -1 int8
c int8 257 ERR ValueError cannot safely convert passed user dtype of int8 for int64 dtyped data in column 0
c int8 300.0 ERR ValueError cannot safely convert passed user dtype of int8 for f
…[1759 chars omitted]…
8 18446744073709551615 ERR ValueError cannot safely convert passed user dtype of int8 for uint64 dtyped data in column a
python int64 -1 -> -1 int64

python int64 257 -> 257 int64
python int64 300.0 -> 300 int64
python int64 257.0 -> 257 int64
python int64 1.5 -> 1 int64
python int64 18446744073709551615 ERR ValueError cannot safely convert passed user dtype of int64 for uint64 dtyped data in column a

c UInt8 'a\n\n' -> [] UInt8
c UInt8 'a\n1\n\n' -> [1] UInt8
c UInt8 'a\n-1\n\n' ERR TypeError cannot safely cast non-equivalent int64 to uint8
c UInt8 'a\n257\n\n' ERR TypeError cannot safely cast non-equivalent int64 to uint8
c UInt8 'a\n18446744073709551615\n\n' ERR TypeError cannot safely cast non-equivalent uint64 to uint8
c Int8 'a\n\n' -> [] Int8
c Int8 'a\n1\n\n' -> [1] Int8
c Int8 'a\n-1\n\n' -> [-1] Int8
c Int8 'a\n257\n\n' ERR TypeError cannot safely cast non-equivalent int64 to int8
c Int8 'a\n18446744073709551615\n\n' ERR TypeError cannot safely cast non-equivalent uint64 to int8
c UInt64 'a\n\n' -> [] UInt64
c UInt64 'a\n1\n\n' -> [1] UInt64

c UInt64 'a\n-1\n\n' ERR TypeError cannot safely cast non-equivalent int64 to uint64
c UInt64 'a\n257\n\n' -> [257] UInt64
c UInt64 'a\n18446744073709551615\n\n' -> [18446744073709551615] UInt64
c Int64 'a\n\n' -> [] Int64
c Int64 'a\
…[980 chars omitted]…
equivalent int64 to uint64
python UInt64 'a\n257\n\n' -> [257] UInt64
python UInt64 'a\n18446744073709551615\n\n' -> [18446744073709551615] UInt64
python Int64 'a\n\n' -> [] Int64
python Int64 'a\n1\n\n' -> [1] Int64
python Int64 'a\n-1\n\n' -> [-1] Int64
python Int64 'a\n257\n\n' -> [257] Int64
python Int64 'a\n18446744073709551615\n\n' ERR TypeError cannot safely cast non-equivalent uint64 to int64

/repo
AGENTS.md
AUTHORS.md
CITATION.cff
LICENSE
LICENSES
README.md
asv_bench
build
ci
codecov.yml
doc

environment.yml
generate_pxi.py
generate_version.py
meson.build
meson.options
pandas
pixi.lock
pixi.toml
pyproject.toml
pyright_reportGeneralTypeIssues.json
requirements-dev.txt
scripts
subprojects
web

63b1924 base
0+untagged.1.g63b1924

pandas/core/array_algos/datetimelike_accumulations.py
pandas/core/array_algos/masked_accumulations.py
pandas/core/array_algos/masked_reductions.py
pandas/core/array_algos/putmask.py
pandas/core/array_algos/quantile.py
pandas/core/array_algos/replace.py
pandas/core/array_algos/take.py
pandas/core/array_algos/transforms.py
pandas/core/array_algos/__init__.py

/repo/pandas/core/construction.py:717: UserWarning: pyarrow requires pandas 2.2.2 or above, pandas 0+untagged.1.g63b1924 is installed. Therefore, pandas-specific integration is not used.
  subarr = lib.maybe_convert_objects(
c None uint8 '-1' -> 255 uint8
c None uint8 '257' -> 1 uint8
c None uint8 '300.0' !! ValueError cannot safely convert passed user dtype of uint8 for float64 dtyped data in column 0
c None uint8 '257.0' !! ValueError cannot safely convert passed user dtype of uint8 for float64 dtyped data in column 0
c None uint8 '18446744073709551615' -> 255 uint8
c None int8 '-1' -> -1 int8
c None int8 '257' -> 1 int8
c None int8 '300.0' !! ValueError cannot safely convert passed user dtype of int8 for float64 dtyped data in column 0
c None int8 '257.0' !! ValueError cannot safely convert passed user dtype of int8 for float64 dtyped data in column 0
c None int8 '18446744073709551

…[3794 chars omitted]…
thon numpy_nullable UInt8 '18446744073709551615' -> 255 UInt8
python numpy_nullable Int8 '-1' -> -1 Int8
python numpy_nullable Int8 '257' -> 1 Int8
python numpy_nullable Int8 '300.0' !! TypeError cannot safely cast non-equivalent float64 to int8
python numpy_nullable Int8 '257.0' !! TypeError cannot safely cast non-equivalent float64 to int8
python numpy_nullable Int8 '18446744073709551615' -> -1 Int8

out = (out1, out2)
        kwargs["out"] = out
    return kwargs


def dispatch_ufunc_with_out(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
    """
    If we have an `out` keyword, then call the ufunc without `out` and then
    set the result into the given `out`.
    """

    # Note: we assume _standardize_out_kwarg has already been called.

    out = kwargs.pop("out")
    where = kwargs.pop("where", None)

    result = getattr(ufunc, method)(*inputs, **kwargs)

    if result is NotImplemented:
        return NotImplemented

    if isinstance(result, tuple):
        # i.e. np.divmod, np.modf, np.frexp
        if not isinstance(out, tuple) or len(out) != len(result):
            raise NotImplementedError

        for arr, res in zip(out, result, strict=True):
            _assign_where(arr, res, where)

        return out

    if isinstance(out, tuple):
        if len
…[8629 chars omitted]…
alue_for_dtype(result.dtype, compat=False)
                return type(self)(result, fill_value=fill_value)

            # No alignment necessary.
            sp_values = getattr(ufunc, method)(self.sp_values, **kwargs)
            fill_value = getattr(ufunc, method)(self.fill_value, **kwargs)

            if ufunc.nout > 1:
                # multiple outputs. e.g. modf
                arrays = tuple(

Length: 3, dtype: Float64
        """
        if self.dtype._is_boolean:
            return self.copy()
        if not self.dtype._is_numeric:
            raise TypeError(f"Cannot round dtype {self.dtype} as it is non-numeric")
        # Python's builtin round on complex emits DeprecationWarning (and
        # raises TypeError in a future Python release); use np.round there.
        round_fn = np.round if self.dtype.kind == "c" else round
        rounded = [
            round_fn(item, decimals) if not item_isna else item
            for item, item_isna in zip(self, self.isna(), strict=True)

        ]
        return type(self)._from_sequence(rounded, dtype=self.dtype)

    def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
        if any(
            isinstance(other, (ABCSeries, ABCIndex, ABCDataFrame)) for other in inputs
        ):
            return
…[8629 chars omitted]…
like np.logaddexp
            index = [i for i, x in enumerate(inputs) if x is NA][0]
            result = np.broadcast_arrays(*inputs)[index]
            if result.ndim == 0:
                result = result.item()
            if ufunc.nout > 1:
                result = (NA,) * ufunc.nout

        return result


C_NA = NAType()   # C-visible
NA = C_NA         # Python-visible
NA.__module__ = "pandas"

return noconvert_columns

    @final
    def _infer_types(
        self, values, na_values, no_dtype_specified, try_num_bool: bool = True
    ) -> tuple[ArrayLike, int]:
        """
        Infer types of values, possibly casting

        Parameters
        ----------
        values : ndarray

        na_values : set
        no_dtype_specified: Specifies if we want to cast explicitly
        try_num_bool : bool, default try
           try to cast values to numeric (first preference) or boolean

        Returns
        -------
        converted : ndarray or ExtensionArray
        na_count : int
        """
        na_count = 0
        if issubclass(values.dtype.type, (np.number, np.bool_)):
            # If our array has numeric dtype, we don't have to check for strings in isin
            na_values = np.array([val for val in na_values if not isinstance(val, str)])
            m
…[8629 chars omitted]…
        f"Specify dtype option on import or set low_memory=False."
            ]
        )
        warnings.warn(warning_message, DtypeWarning, stacklevel=find_stack_level())
    return result


def ensure_dtype_objs(
    dtype: DtypeArg | dict[Hashable, DtypeArg] | None,
) -> DtypeObj | dict[Hashable, DtypeObj] | None:
    """
    Ensure we have either None, a dtype object, or a dictionary mapping to

See also
    --------
    numpy.org/doc/stable/reference/arrays.classes.html#numpy.class.__array_ufunc__
    """
    from pandas.core.frame import (
        DataFrame,
        Series,
    )
    from pandas.core.generic import NDFrame
    from pandas.core.internals import BlockManager

    cls = type(self)

    kwargs = _standardize_out_kwarg(**kwargs)

    # for binary ops, use our custom dunder methods
    result = maybe_dispatch_ufunc_to_dunder_op(self, ufunc, method, *inputs, **kwargs)
    if result is not NotImplemented:
        return result

    # Determine if we should defer.
    no_defer = (
        np.ndarray.__array_ufunc__,
        cls.__array_ufunc__,
    )

    for item in inputs:
        higher_priority = (
            hasattr(item, "__array_priority__")
            and item.__array_priority__ > self.__array_priority__
        )
        has_array_ufunc = (
         
…[5835 chars omitted]…
e an `out` keyword, then call the ufunc without `out` and then
    set the result into the given `out`.
    """

277:def array_ufunc(self, ufunc: np.ufunc, method: str, *inputs: Any, **kwargs: Any):
331:def is_datetime64_dtype(arr_or_dtype) -> bool:
439:def is_timedelta64_dtype(arr_or_dtype) -> bool:
486:def is_period_dtype(arr_or_dtype) -> bool:
1053:def is_datetime64_any_dtype(arr_or_dtype) -> bool:

pandas/_libs/tslibs/timestamps.pyx:329:    __array_priority__ = 100
pandas/_libs/tslibs/timedeltas.pyx:1567:    __array_priority__ = 100
pandas/_libs/tslibs/period.pyx:2109:    __array_priority__ = 100
pandas/_libs/tslibs/nattype.pyx:91:    __array_priority__ = 100

)
from pandas.core.dtypes.generic import (
    ABCCategoricalIndex,
    ABCDataFrame,
    ABCDatetimeIndex,
    ABCIntervalIndex,
    ABCMultiIndex,
    ABCPeriodIndex,
    ABCRangeIndex,
    ABCSeries,
    ABCTimedeltaIndex,
)

from pandas.core.dtypes.inference import is_dict_like
from pandas.core.dtypes.missing import (
    array_equivalent,
    is_valid_na_for_dtype,
    isna,
)

from pandas.core import (
    arraylike,
    nanops,
    ops,
)
from pandas.core.accessor import Accessor
import pandas.core.algorithms as algos
from pandas.core.array_algos.putmask import validate_putmask
from pandas.core.arrays import (
    ArrowExtensionArray,
    BaseMaskedArray,
    Categorical,
    DatetimeArray,
    ExtensionArray,
    PeriodArray,
    TimedeltaArray,
)
from pandas.core.arrays.floating import FloatingDtype
from pandas.core.arrays.string_ import (
    StringArray,
    StringDtype,
)
f
…[8629 chars omitted]…
ype is of the datetime64 dtype.

    See Also
    --------
    api.types.is_datetime64_dtype : Check whether an array-like or dtype is of the
        datetime64 dtype.
    api.is_datetime64_ns_dtype : Check whether the provided array or dtype is of the
        datetime64[ns] dtype.
    api.is_datetime64tz_dtype : Check whether an array-like or dtype is of a
        DatetimeTZDtype dtype.

    Examples

315:            and not isinstance(item, self._HANDLED_TYPES)
"""
Methods that can be shared by many array-like classes or subclasses:
    Series
    Index
    ExtensionArray
"""

from __future__ import annotations

import operator
from typing import (

    Any,
    Self,
)

import numpy as np

from pandas._libs import lib
from pandas._libs.ops_dispatch import maybe_dispatch_ufunc_to_dunder_op

from pandas.core.dtypes.generic import ABCNDFrame

from pandas.core import roperator
from pandas.core.construction import extract_array
from pandas.core.ops.common import unpack_zerodim_and_defer

REDUCTION_ALIASES = {
    "maximum": "max",
    "minimum": "min",
    "add": "sum",
    "multiply": "prod",
}


class OpsMixin:
    # -------------------------------------------------------------
    # Comparisons

    def _cmp_method(self, other, op):
        return NotImplemented

    @unpack_zerodim
…[6589 chars omitted]…
__floordiv__")
    def __floordiv__(self, other) -> Self:
        return self._arith_method(other, operator.floordiv)

    @unpack_zerodim_and_defer("__rfloordiv")
    def __rfloordiv__(self, other) -> Self:
        return self._arith_method(other, roperator.rfloordiv)

    @unpack_zerodim_and_defer("__mod__")
    def __mod__(self, other) -> Self:
        return self._arith_method(other, operator.mod)

70:class NumpyExtensionArray(
from pandas.core.strings.object_array import ObjectStringArrayMixin

if TYPE_CHECKING:
    from collections.abc import Callable

    from pandas._typing import (
        ArrayLike,
        AxisInt,
        Dtype,
        FillnaOptions,
        InterpolateOptions,

        NpDtype,
        NumpySorter,
        NumpyValueArrayLike,
        Scalar,
        TakeIndexer,
        npt,
    )

    from pandas import Index
    from pandas.arrays import StringArray
    from pandas.core.arrays.base import ExtensionArray


@set_module("pandas.arrays")
class NumpyExtensionArray(
    OpsMixin,
    NDArrayBackedExtensionArray,
    ObjectStringArrayMixin,
):
    """
    A pandas ExtensionArray for NumPy data.

    This is mostly for internal compatibility, and is not especially
    useful on its own.

    Parameters
    ----------
    values : ndarray
        The NumPy ndarray to wrap. Must be 1-dimensional.
    copy : bool, default False
        Whether to copy `values`.

    Attributes
    ----------
    None

    Methods
    -------
    None

1610:    def kind(self) -> str:
1672:    def kind(self) -> str:
1964:    def kind(self) -> str:
2377:    def kind(self) -> str:

pandas/_libs/missing.pyx:40:from pandas._libs.ops_dispatch import maybe_dispatch_ufunc_to_dunder_op
pandas/_libs/missing.pyx:579:        result = maybe_dispatch_ufunc_to_dunder_op(
pandas/_libs/ops_dispatch.pyi:7:def maybe_dispatch_ufunc_to_dunder_op(
pandas/_libs/ops_dispatch.pyx:63:def maybe_dispatch_ufunc_to_dunder_op(

DISPATCHED_UFUNCS = {
    "add",
    "sub",
    "mul",
    "pow",
    "mod",
    "floordiv",
    "truediv",
    "divmod",
    "eq",
    "ne",
    "lt",

    "gt",
    "le",
    "ge",
    "remainder",
    "matmul",
    "or",
    "xor",
    "and",
    "neg",
    "pos",
    "abs",
}
UNARY_UFUNCS = {
    "neg",
    "pos",
    "abs",
}
UFUNC_ALIASES = {
    "subtract": "sub",
    "multiply": "mul",
    "floor_divide": "floordiv",
    "true_divide": "truediv",
    "power": "pow",
    "remainder": "mod",
    "divide": "truediv",
    "equal": "eq",
    "not_equal": "ne",
    "less": "lt",
    "less_equal": "le",
    "greater": "gt",
    "greater_equal": "ge",
    "bitwise_or": "or",
    "bitwise_and": "and",
    "bitwise_xor": "xor",
    "negative": "neg",
    "absolute": "abs",
    "positive": "pos",
}

# For op(., Array) -> Array.__r{op}__
REVERSED_NAMES = {
    "lt": "__gt__",
    "le": "__
…[8630 chars omitted]…
..

    Note: the caller is responsible for ensuring that numpy warnings are
    suppressed (with np.errstate(all="ignore")) if needed.

    Parameters
    ----------
    left : np.ndarray or ExtensionArray
    right : object
        Cannot be a DataFrame or Index.  Series is *not* excluded.
    op : {operator.add, operator.sub, ...}
        Or one of the reversed variants from roperator.

    Returns

result = IntegerArray(
                            np.ones(result_mask.shape, dtype=np.int64), result_mask
                        )
                    elif is_integer_dtype(result):
                        result = IntegerArray(result, result_mask)
                    elif is_bool_dtype(result):
                        result = BooleanArray(result, result_mask)
                    elif is_float_dtype(result):
                        result = FloatingArray(result, result_mask)

                    na_count = result_mask.sum()  # type: ignore[assignment]
                else:

                    na_count = isna(result).sum()  # type: ignore[assignment]
        else:
            result = values
            if values.dtype == np.object_:
                na_count = parsers.sanitize_objects(values, na_values)

        if (
            result.dtype == np.object_
   
…[8629 chars omitted]…
ex,
    ABCSeries,
)
from pandas.core.dtypes.inference import is_list_like
from pandas.core.dtypes.missing import (
    is_valid_na_for_dtype,
    isna,
    na_value_for_dtype,
    notna,
)

from pandas.io._util import _arrow_dtype_mapping

if TYPE_CHECKING:
    from collections.abc import (
        Collection,
        Sequence,
    )

    from pandas._typing import (
        ArrayLike,
        Dtype,

__array__ None None
TypeError ufunc 'logical_not' not supported for the input types, and the inputs could not be safely coerced to any supported types according to the casting rule ''safe''
__array__ None None
<ufunc 'logical_and'> True
ufunc <ufunc 'logical_not'>
TypeError oh

grep: pandas/core/ops/logic.py: No such file or directory

if dtype_backend == "pyarrow":
            pa = import_optional_dependency("pyarrow")
            if isinstance(result, np.ndarray):
                result = ArrowExtensionArray(pa.array(result, from_pandas=True))
            elif isinstance(result, BaseMaskedArray):
                if result._mask.all():
                    # We want an arrow null array here
                    result = ArrowExtensionArray(pa.array([None] * len(result)))
                else:
                    result = ArrowExtensionArray(
                        pa.array(result._data, mask=result._mask)
                    )

            else:
                result = ArrowExtensionArray(
                    pa.array(result.to_numpy(), from_pandas=True)
                )

        return result, na_count

    @overload
    def _do_date_conversions(
        self,
        names: Index,
        data: DataFrame,
…[8629 chars omitted]…
s, parsers._PendingStringColumn):
        return _pa_arrays_to_ea([values])
    return values


def _harmonize_empty_categories(arrs: list[ArrayLike]) -> list[ArrayLike]:
    """
    Give chunks that inferred no categories the others' categories dtype.

    GH#56044 a chunk that is entirely NA yields empty object-dtype categories
    where a populated chunk yields string ones, which union_categoricals

total 1648
drwxr-xr-x 1 root root    4096 Nov  6 23:49 .
drwxr-xr-x 1 root root    4096 Nov  6 23:35 ..
-rw-r--r-- 1 root root      94 Nov  6 23:35 .gitignore
-rw-r--r-- 1 root root     110 Nov  6 23:35 .hgignore
-rw-r--r-- 1 root root  106836 Nov  6 23:43 .ninja_deps
-rw-r--r-- 1 root root   19288 Nov  6 23:49 .ninja_log
drwxr-xr-x 1 root root    4096 Nov  6 23:49 __pycache__
-rw-r--r-- 1 root root 1128378 Nov  6 23:35 _cyutility.c
-rwxr-xr-x 1 root root  241736 Nov  6 23:40 _cyutility.cpython-312-x86_64-linux-gnu.so
drwxr-xr-x 1 root root    4096 Nov  6 23:37 _cyutility.cpython-312-x86_64-linux-gnu.so.p
-rw-r--r-- 1 root root      95 Nov  6 23:49 _version_meson.py

-rw-r--r-- 1 root root   95537 Nov  6 23:35 build.ninja
-rw-r--r-- 1 root root   79908 Nov  6 23:35 compile_commands.json
drwxr-xr-x 1 root root    4096 Nov  6 23:35 meson-info
drwxr-xr-x 1 root root    4096 Nov  6 23:43 m
…[1590 chars omitted]…
 pandas/_libs/tslibs/ccalendar.cpython-312-x86_64-linux-gnu.so.p/meson-generated_ccalendar.pyx.c.o.d
161: DEPFILE_UNQUOTED = pandas/_libs/tslibs/ccalendar.cpython-312-x86_64-linux-gnu.so.p/meson-generated_ccalendar.pyx.c.o.d
167:build pandas/_libs/tslibs/ccalendar.cpython-312-x86_64-linux-gnu.so: c_LINKER pandas/_libs/tslibs/ccalendar.cpython-312-x86_64-linux-gnu.so.p/meson-generated_ccalendar.pyx.c.o

pandas/tests/arrays/boolean/test_arithmetic.py:53:        r"use the bitwise_xor, the `\^` operator, or the logical_xor function instead\."
pandas/tests/arrays/boolean/test_function.py:9:    "ufunc", [np.add, np.logical_or, np.logical_and, np.logical_xor]
pandas/tests/arrays/masked/test_arithmetic.py:213:            r"the bitwise_xor, the `\^` operator, or the logical_xor function instead"
pandas/tests/scalar/test_na_scalar.py:191:def test_logical_or():
pandas/tests/scalar/test_na_scalar.py:209:def test_logical_xor():

137:def _coerce_to_data_and_mask(values, dtype, copy: bool, dtype_cls: type[NumericDtype]):
289:    def _coerce_to_array(
293:        values, mask = _coerce_to_data_and_mask(value, dtype, copy, dtype_cls)
82:def array(
                dtype_if_all_nat=np.dtype("M8[s]"),
            )

    subarr = _sanitize_ndim(subarr, data, dtype, index, allow_2d=allow_2d)

    if isinstance(subarr, np.ndarray):
        # at this point we should have dtype be None or subarr.dtype == dtype
        dtype = cast("np.dtype", dtype)

        subarr = _sanitize_str_dtypes(subarr, data, dtype, copy)

    return subarr


def range_to_ndarray(rng: range) -> np.ndarray:
    """
    Cast a range object to ndarray.
    """
    # GH#30171 perf avoid realizing range as a list in np.array
    try:
        arr = np.arange(rng.start, rng.stop, rng.step, dtype="int64")
    except OverflowError:
        # GH#30173 hand
…[3395 chars omitted]…
----------
    arr : ndarray or list
        Excludes: ExtensionArray, Series, Index.
    dtype : np.dtype
    copy : bool
        If False, don't copy the data if not needed.

    Returns
    -------
    np.ndarray or ExtensionArray
    """
    is_ndarray = isinstance(arr, np.ndarray)

    if dtype == object:
        if not is_ndarray:
            subarr = construct_1d_object_array_from_listlike(arr)

Traceback (most recent call last):
      ...
    ValueError: Cannot pass scalar '1' to 'pandas.array'.
    """
    from pandas.core.arrays import (
        BooleanArray,
        DatetimeArray,
        ExtensionArray,
        FloatingArray,
        IntegerArray,
        NumpyExtensionArray,
        TimedeltaArray,

    )
    from pandas.core.arrays.string_ import StringDtype

    if lib.is_scalar(data):
        msg = f"Cannot pass scalar '{data}' to 'pandas.array'."
        raise ValueError(msg)
    elif isinstance(data, ABCDataFrame):
        raise TypeError("Cannot pass DataFrame to 'pandas.array'")

    if dtype is None and isinstance(data, (ABCSeries, ABCIndex, ExtensionArray)):
        # Note: we exclude np.ndarray here, will do type inference on it
        dtype = data.dtype

    data = extract_array(data, extract_numpy=True)

    # Handle numpy masked arrays: convert masked v
…[8630 chars omitted]…
    key = check_array_indexer(self, key)

        if is_scalar(value):
            if is_valid_na_for_dtype(value, self.dtype) and not (
                lib.is_float(value) and not is_nan_na()
            ):
                self._mask[key] = True
            else:
                value = self._validate_setitem_value(value)
                self._data[key] = value
                self._mask[key] = False

<stdin>:4: Pandas4Warning: 'd' is deprecated and will be removed in a future version. Please use 'D' instead of 'd'.
<stdin>:4: DeprecationWarning: The 'generic' unit for NumPy timedelta is deprecated, and will raise an error in the future. This includes implicit conversion of bare integers (e.g. `+ 1`). Please use a specific unit instead.
Timestamp('2020-01-01 00:00:00') True <class 'pandas.Timestamp'>
NaT True <class 'pandas.api.typing.NaTType'>
Timedelta('1 days 00:00:00') True <class 'pandas.Timedelta'>
Period('2020-01-01', 'D') True <class 'pandas.Period'>
np.datetime64('NaT','generic') True <class 'numpy.datetime64'>
datetime.datetime(2020, 1, 1, 0, 0) True <class 'datetime.datetime'>
datetime.date(2020, 1, 1) True <class 'datetime.date'>
datetime.timedelta(days=1) True <class 'datetime.timedelta'>
<NA> True <class 'pandas.api.typing.NAType'>

return list
        elif pa.types.is_fixed_size_list(pa_type):
            return list
        elif pa.types.is_map(pa_type):
            return list
        elif pa.types.is_struct(pa_type):
            return dict
        elif pa.types.is_null(pa_type):
            # TODO: None? pd.NA? pa.null?
            return type(pa_type)
        elif isinstance(pa_type, pa.BaseExtensionType):
            return type(self)(pa_type.storage_type).type

        raise NotImplementedError(pa_type)

    @property
    def name(self) -> str:  # type: ignore[override]
        """
        A string identifying the data type.
        """
        return f"{self.pyarrow_dtype!s}[{self.storage}]"

    @cache_readonly
    def numpy_dtype(self) -> np.dtype:
        """Return an instance of the related numpy dtype"""
        if pa.types.is_timestamp(self.pyarrow_dtype):
            # pa.timestamp(unit
…[2284 chars omitted]…
_dtype timedelta64[ns]
date32[day] kind M numpy_dtype datetime64[ms]
date64[ms] kind M numpy_dtype datetime64[ms]
time32[s] kind O numpy_dtype object
time64[ns] kind O numpy_dtype object
dictionary<values=timestamp[ns], indices=int8, ordered=0> kind O numpy_dtype object
run_end_encoded<run_ends: int32, values: timestamp[ns]> kind O numpy_dtype object
list<item: timestamp[ns]> kind O numpy_dtype object

<class 'pandas.Series'> datetime64[us]
logical_and TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'logical_and'>, '__call__', 0   2020-01-01
dtype: datetime64[us], <NA>): 'Series', 'NAType'
rev TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'logical_and'>, '__call__', <NA>, 0   2020-01-01
dtype: datetime64[us]): 'NAType', 'Series'
logical_or TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'logical_or'>, '__call__', 0   2020-01-01
dtype: datetime64[us], <NA>): 'Series', 'NAType'
rev TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'logical_or'>, '__call__', <NA>, 0   2020-01-01
dtype: datetime64[us]): 'NAType', 'Series'
logical_xor TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'logical_xor'>, '__call__', 0   2020-
…[2641 chars omitted]…
ies'

logical_xor TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'logical_xor'>, '__call__', 0    2020-01-01
dtype: period[D], <NA>): 'Series', 'NAType'
rev TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'logical_xor'>, '__call__', <NA>, 0    2020-01-01
dtype: period[D]): 'NAType', 'Series'
logical_not 0    False
dtype: object Series

called <ufunc 'add'> __call__
add TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'add'>, '__call__', <__main__.X object at 0x7c001ca267e0>, 1): 'X', 'int'
called <ufunc 'add'> __call__
add TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'add'>, '__call__', <__main__.X object at 0x7c001ca267e0>, <__main__.X object at 0x7c001ca267e0>): 'X', 'X'
called <ufunc 'minimum'> __call__
minimum TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'minimum'>, '__call__', <__main__.X object at 0x7c001ca267e0>, <__main__.X object at 0x7c001ca267e0>): 'X', 'X'
called <ufunc 'logical_or'> __call__
logical_or TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'logical_or'>, '__call__', <__main__.X object at 0x7c001ca267e0>, 1): 'X', 'int'

pandas/core/arrays/masked.py:839:    _HANDLED_TYPES: tuple[type, ...]
pandas/core/arrays/masked.py:848:            if not isinstance(x, (*self._HANDLED_TYPES, BaseMaskedArray)):
pandas/core/arrays/base.py:262:    2. You define a ``_HANDLED_TYPES`` tuple as an attribute on the class.
pandas/core/arrays/sparse/array.py:2816:    _HANDLED_TYPES = (np.ndarray, numbers.Number)
pandas/core/arrays/sparse/array.py:2822:            if not isinstance(x, (*self._HANDLED_TYPES, SparseArray)):
        --------
        ExtensionArray.argsort : Return the indices that would sort this array.

        Notes
        -----
        The caller is responsible for *not* modifying these values in-place, so
        it is safe for implementers to give views on ``self``.

        Functions that use this (e.g. ``ExtensionArray.argsort``) should ignore
        entries with missing values in the original array (acc
…[2136 chars omitted]…
pe for this
            array, ``cls.dtype.type`` or be converted into this type in this method.
        dtype : dtype, optional
            Construct for this particular dtype. This should be a Dtype
            compatible with the ExtensionArray.
        copy : bool, default False
            If True, copy the underlying data.

        Returns
        -------
        ExtensionArray

        See Also

# Note, that the if branch exists for NumPy 1.x support
            return np.asarray(self._data, dtype=dtype)

        return np.array(self._data, dtype=dtype, copy=copy)

    def __array_ufunc__(
        self, ufunc: np.ufunc, method: str_t, *inputs: Any, **kwargs: Any
    ) -> Any:
        if any(isinstance(other, (ABCSeries, ABCDataFrame)) for other in inputs):
            return NotImplemented

        result = arraylike.maybe_dispatch_ufunc_to_dunder_op(

            self, ufunc, method, *inputs, **kwargs
        )
        if result is not NotImplemented:
            return result

        if "out" in kwargs:
            # e.g. test_dti_isub_tdi
            return arraylike.dispatch_ufunc_with_out(
                self, ufunc, method, *inputs, **kwargs
            )

        if method == "reduce":
            result = arraylike.dispatch_reduction_ufunc(
              
…[8629 chars omitted]…

                    self._simple_new(
                        sp_value, self.sp_index, SparseDtype(sp_value.dtype, fv)
                    )
                    for sp_value, fv in zip(sp_values, fill_value, strict=True)
                )
                return arrays

            return self._simple_new(
                sp_values, self.sp_index, SparseDtype(sp_values.dtype, fill_value)
            )

836:def _try_cast(
837-    arr: list | np.ndarray,
838-    dtype: np.dtype,
839-    copy: bool,
840-) -> ArrayLike:
841-    """
842-    Convert input to numpy ndarray and optionally cast to a given dtype.
843-
844-    Parameters
845-    ----------
846-    arr : ndarray or list
847-        Excludes: ExtensionArray, Series, Index.

848-    dtype : np.dtype
849-    copy : bool
850-        If False, don't copy the data if not needed.
851-
852-    Returns
853-    -------
854-    np.ndarray or ExtensionArray
855-    """
856-    is_ndarray = isinstance(arr, np.ndarray)
857-
858-    if dtype == object:
859-        if not is_ndarray:
860-            subarr = construct_1d_object_array_from_listlike(arr)
861-            return subarr
862-        return ensure_wrapped_if_datetimelike(arr).astype(dtype, copy=copy)
863-
864-    elif dtype.kind == "U":
865-        # TODO: test cases with arr.dtype.ki
…[8629 chars omitted]…
se TypeError(
270-                f"values should be {descr} numpy array. Use "
271-                "the 'pd.array' function instead"
272-            )
273-        if values.dtype == np.float16:
274-            # If we don't raise here, then accessing self.dtype would raise
275-            raise TypeError("FloatingArray does not support np.float16 dtype.")
276-
277-        # NB: if is_nan_na() is True

pandas/core/frame.py:419:    _HANDLED_TYPES = (Series, Index, ExtensionArray, np.ndarray)
pandas/core/series.py:328:    _HANDLED_TYPES = (Index, ExtensionArray, np.ndarray)
pandas/core/arraylike.py:315:            and not isinstance(item, self._HANDLED_TYPES)
pandas/core/arrays/base.py:262:    2. You define a ``_HANDLED_TYPES`` tuple as an attribute on the class.
pandas/core/arrays/boolean.py:383:    _HANDLED_TYPES = (np.ndarray, numbers.Number, bool, np.bool_)
pandas/core/arrays/masked.py:839:    _HANDLED_TYPES: tuple[type, ...]
pandas/core/arrays/masked.py:848:            if not isinstance(x, (*self._HANDLED_TYPES, BaseMaskedArray)):
pandas/core/arrays/numeric.py:305:    _HANDLED_TYPES = (np.ndarray, numbers.Number)
pandas/core/arrays/sparse/array.py:2816:    _HANDLED_TYPES = (np.ndarray, numbers.Number)
pandas/core/arrays/sparse/array.py:2822:            if not isinstance(x, (*self._HANDLED_TYPES, SparseArray)):
pandas/core/frame.py:419:    _HANDLED_TYPES = (Series, Index, ExtensionArray, np.ndarray)
pandas/core/series.py:328:    _HANDLED_TYPES = (Index, ExtensionArray, np.ndarray)

<class 'pandas.Timestamp'> <class 'pandas.Timedelta'>
add Timestamp('2020-01-02 00:00:00') Timestamp
subtract Timestamp('2019-12-31 00:00:00') Timestamp
equal np.False_ bool
less TypeError '<' not supported between instances of 'Timestamp' and 'Timedelta'
minimum TypeError '<=' not supported between instances of 'Timestamp' and 'Timedelta'
maximum TypeError '>=' not supported between instances of 'Timestamp' and 'Timedelta'
isnan TypeError ufunc 'isnan' not supported for the input types, and the inputs could not be safely coerced to any supported types according to the casting rule ''safe''
isfinite TypeError ufunc 'isfinite' not supported for the input types, and the inputs could not be safely coerced to any supported types according to the casting rule ''safe''
sin TypeError loop of ufunc does not support argument 0 of type Timestamp which has no callable sin method

 <class 'pand

…[2456 chars omitted]…
the input types, and the inputs could not be safely coerced to any supported types according to the casting rule ''safe''
isfinite TypeError ufunc 'isfinite' not supported for the input types, and the inputs could not be safely coerced to any supported types according to the casting rule ''safe''
sin TypeError loop of ufunc does not support argument 0 of type Timestamp which has no callable sin method

408:def logical_op(left: ArrayLike, right: Any, op) -> ArrayLike:
409-    """
410-    Evaluate a logical operation `|`, `&`, or `^`.
411-
412-    Parameters
413-    ----------
414-    left : np.ndarray or ExtensionArray
415-    right : object
416-        Cannot be a DataFrame, Series, or Index.
417-    op : {operator.and_, operator.or_, operator.xor}
418-        Or one of the reversed variants from roperator.
419-

420-    Returns
421-    -------
422-    ndarray or ExtensionArray
423-    """
424-
425-    def fill_bool(x, left=None):
426-        # if `left` is specifically not-boolean, we do not cast to bool
427-        if x.dtype.kind in "cfO":
428-            # dtypes that can hold NA
429-            mask = isna(x)
430-            if mask.any():
431-                x = x.astype(object)
432-                x[mask] = False
433-
434-        if left is None or left.dtype.kind == "b":
435-
…[4268 chars omitted]…
:1830:            and self.dtype.subtype.kind in "mM"
pandas/core/arrays/sparse/array.py:1960:        if npvalues.dtype.kind in "mM":
pandas/core/arrays/sparse/array.py:2114:            elif dtype.subtype.kind in "mM" and (
pandas/core/arrays/sparse/array.py:2742:            sp_min_max = getattr(valid_vals, kind)()
pandas/core/arrays/sparse/array.py:2993:            if self.dtype.subtype.kind in "mM":

102:def disallow_datetimelike_logical_op(
103-    left: ArrayLike, right: Any, op: Callable[[Any, Any], Any]
104-) -> None:
105-    """
106-    Raise TypeError if either operand of a logical op is a datetimelike array.
107-
108-    Parameters
109-    ----------
110-    left : array-like
111-    right : array-like or scalar
112-    op : operator.{and_, or_, xor}
113-        Or one of the reversed variants from roperator.

114-
115-    Raises
116-    ------
117-    TypeError : if either operand is a datetimelike array, including a categorical
118-        of one
119-    """
120-    # GH#68452 these have no truth value; casting them to bool would make every
121-    #  entry, NaT included, True
122-    if _is_datetimelike_array(left) or _is_datetimelike_array(right):
123-        raise TypeError(
124-            f"operation '{op.__name__}' not supported for "
125-            f"{_operand_repr
…[4061 chars omitted]…
Series "
                    "instead.",
                    Pandas4Warning,
                    stacklevel=find_stack_level(),
                )

            other = np.asarray(other, dtype="bool")
            if other.ndim > 1:
                return NotImplemented
            other, mask = coerce_to_array(other, copy=False)
        elif isinstance(other, np.bool_):
            other = other.item()

"""
Templates for invalid operations.
"""

from __future__ import annotations

import operator
from typing import (
    TYPE_CHECKING,
    Any,
    NoReturn,
)

import numpy as np

from pandas._libs import lib

from pandas.core.dtypes.dtypes import (
    ArrowDtype,
    CategoricalDtype,
    PeriodDtype,
)

if TYPE_CHECKING:
    from collections.abc import Callable

    from pandas._libs.missing import NAType
    from pandas._typing import (
        ArrayLike,
        Scalar,
        npt,
    )


def invalid_comparison(
    left: ArrayLike,
    right: ArrayLike | list | range | Scalar | NAType,
    op: Callable[[Any, Any], bool],
) -> npt.NDArray[np.bool_]:
    """
    If a comparison has mismatched types and is not necessarily meaningful,
    follow python3 conventions by:

        - returning all-False for equality
        - returning all-True for inequality
        - raising TypeEr
…[195 chars omitted]…
risons
    """
    if op is operator.eq:
        res_values = np.zeros(left.shape, dtype=bool)
    elif op is operator.ne:
pandas/core/ops/invalid.py:68:def _is_datetimelike_array(obj: object) -> bool:
pandas/core/ops/invalid.py:122:    if _is_datetimelike_array(left) or _is_datetimelike_array(right):
pandas/tests/dtypes/test_inference.py:1615:    def test_is_datetimelike_array_all_nan_nat_like(self):

<stdin>:3: DeprecationWarning: The 'generic' unit for NumPy timedelta is deprecated, and will raise an error in the future. This includes implicit conversion of bare integers (e.g. `+ 1`). Please use a specific unit instead.
<class 'numpy.datetime64'> False None -1000000.0
<class 'numpy.timedelta64'> False None -1000000.0
<class 'numpy.bool'> False None -1000000.0
<class 'numpy.int64'> False None -1000000.0
<class 'pandas.api.typing.NAType'> True <cyfunction NAType.__array_ufunc__ at 0x7c96f6b20e90> 1000
<class 'pandas.Timestamp'> False None 100
<class 'pandas.Timedelta'> False None 100
<class 'pandas.Period'> False None 100
<class 'pandas.api.typing.NaTType'> False None 100
<class 'numpy.ndarray'> True <method '__array_ufunc__' of 'numpy.ndarray' objects> 0.0

<class 'numpy.ndarray'> datetime64[ns]
logical_and array([<NA>], dtype=object) <class 'numpy.ndarray'>
logical_and array([<NA>], dtype=object) <class 'numpy.ndarray'>
logical_or array([<NA>], dtype=object) <class 'numpy.ndarray'>
logical_or array([<NA>], dtype=object) <class 'numpy.ndarray'>
logical_xor array([<NA>], dtype=object) <class 'numpy.ndarray'>
logical_xor array([<NA>], dtype=object) <class 'numpy.ndarray'>

 <class 'pandas.arrays.DatetimeArray'> datetime64[ns]
logical_and array([<NA>], dtype=object) <class 'numpy.ndarray'>
logical_and array([<NA>], dtype=object) <class 'numpy.ndarray'>
logical_or array([<NA>], dtype=object) <class 'numpy.ndarray'>

logical_or array([<NA>], dtype=object) <class 'numpy.ndarray'>
logical_xor array([<NA>], dtype=object) <class 'numpy.ndarray'>
logical_xor array([<NA>], dtype=object) <class 'numpy.ndarray'>

 <class 'pandas.arrays.PeriodArray'>
…[403 chars omitted]…
numpy.ndarray'> object
logical_and array([<NA>], dtype=object) <class 'numpy.ndarray'>
logical_and array([<NA>], dtype=object) <class 'numpy.ndarray'>
logical_or array([<NA>], dtype=object) <class 'numpy.ndarray'>
logical_or array([<NA>], dtype=object) <class 'numpy.ndarray'>
logical_xor array([<NA>], dtype=object) <class 'numpy.ndarray'>
logical_xor array([<NA>], dtype=object) <class 'numpy.ndarray'>

pandas/tests/extension/date/array.py:174:        return np.logical_and(
pandas/tests/extension/date/array.py:175:            np.logical_and(

"""
Arithmetic operations for PandasObjects

This is not a public API.
"""

from __future__ import annotations

from pandas.core.ops.array_ops import (
    arithmetic_op,
    comp_method_OBJECT_ARRAY,
    comparison_op,

    fill_binop,
    get_array_op,
    logical_op,
    maybe_prepare_scalar_for_op,
)
from pandas.core.ops.common import (
    get_op_result_name,
    has_castable_attr,
    maybe_warn_listlike,
    raise_if_2d,
    unpack_zerodim_and_defer,
)
from pandas.core.ops.invalid import (
    disallow_datetimelike_logical_op,
    invalid_comparison,
)
from pandas.core.ops.mask_ops import (
    kleene_and,
    kleene_or,
    kleene_xor,
)
from pandas.core.roperator import (
    radd,
    rand_,
    rdiv,
    rdivmod,
    rfloordiv,
    rmod,
    rmul,
    ror_,
    rpow,
    rsub,
    rtruediv,
    rxor,
)

# ----------------------------------------------------------------------
…[565 chars omitted]…
    "kleene_xor",
    "logical_op",
    "maybe_prepare_scalar_for_op",
    "maybe_warn_listlike",
    "radd",
    "raise_if_2d",
    "rand_",
    "rdiv",
    "rdivmod",
    "rfloordiv",
    "rmod",
    "rmul",
    "ror_",
    "rpow",
    "rsub",
    "rtruediv",
    "rxor",
    "unpack_zerodim_and_defer",
]
25:from pandas.core.ops.invalid import (
27:    invalid_comparison,
81:    "invalid_comparison",

--------
        >>> arr = pd.array([1.234, 5.678, pd.NA], dtype="Float64")
        >>> arr.round(1)
        <FloatingArray>
        [1.2, 5.7, <NA>]
        Length: 3, dtype: Float64
        """
        if self.dtype._is_boolean:
            return self.copy()
        if not self.dtype._is_numeric:
            raise TypeError(f"Cannot round dtype {self.dtype} as it is non-numeric")
        # Python's builtin round on complex emits DeprecationWarning (and

        # raises TypeError in a future Python release); use np.round there.
        round_fn = np.round if self.dtype.kind == "c" else round
        rounded = [
            round_fn(item, decimals) if not item_isna else item
            for item, item_isna in zip(self, self.isna(), strict=True)
        ]
        return type(self)._from_sequence(rounded, dtype=self.dtype)

    def __array_ufunc__(self, ufunc: np.ufunc, method:
…[8629 chars omitted]…


    def __array__(
        self, dtype: NpDtype | None = None, copy: bool | None = None
    ) -> np.ndarray:
        """Correctly construct numpy arrays when passed to `np.asarray()`."""
        if copy is False:
            # TODO: By using `zero_copy_only` it may be possible to implement this
            raise ValueError(
                "Unable to avoid copy while creating an array as requested."

pandas/core/arrays/masked.py:758:    def astype(self, dtype: npt.DTypeLike, copy: bool = ...) -> np.ndarray: ...
pandas/core/arrays/masked.py:761:    def astype(self, dtype: ExtensionDtype, copy: bool = ...) -> ExtensionArray: ...
pandas/core/arrays/masked.py:764:    def astype(self, dtype: AstypeArg, copy: bool = ...) -> ArrayLike: ...
pandas/core/arrays/masked.py:766:    def astype(self, dtype: AstypeArg, copy: bool = True) -> ArrayLike:
            with warnings.catch_warnings():
                warnings.filterwarnings("ignore", category=RuntimeWarning)
                data = self._data.astype(dtype, copy=copy)
            if self._readonly and not copy and astype_is_view(self.dtype, dtype):
                data = data.view()
                data.flags.writeable = False
        return data

    def tolist(self) -> list:
        """
        Return a list of the values.

        Thes
…[2726 chars omitted]…
ValueError("cannot convert NA to integer")
        if dtype.kind == "b" and self._hasna:
            # careful: astype_nansafe converts np.nan to True
            raise ValueError("cannot convert float NaN to bool")

        data = self.to_numpy(dtype=dtype, na_value=na_value, copy=copy)
        return data

    __array_priority__ = 1000  # higher than ndarray so ops dispatch to us

    def __array__(

and try_num_bool
            and (len(result) == 0 or not isinstance(result[0], int))
        ):
            result, bool_mask = libops.maybe_convert_bool(
                np.asarray(values),
                true_values=self.true_values,
                false_values=self.false_values,
                convert_to_masked_nullable=non_default_dtype_backend,  # type: ignore[arg-type]
            )
            if result.dtype == np.bool_ and non_default_dtype_backend:
                if bool_mask is None:
                    bool_mask = np.zeros(result.shape, dtype=np.bool_)

                result = BooleanArray(result, bool_mask)
            elif result.dtype == np.object_ and non_default_dtype_backend:
                # read_excel sends array of datetime objects
                if not lib.is_datetime_array(result, skipna=True):
                    dtype = StringDtype()
       
…[8628 chars omitted]…
PeriodDtype, whose kind is "O"
        return True
    if dtype.kind in "iufbc":
        return False
    # Anything unrecognized has to land here: a wrong False would reject a
    #  valid assignment, see test_setitem_temporal_still_accepted
    return None


def _is_all_na(value) -> bool:
    """
    Whether every entry of `value` is NA.
    """
    if isinstance(value, (pa.Array, pa.ChunkedArray)):

pandas/_libs/tslibs/timedeltas.pyx:2517:class Timedelta(_Timedelta):
pandas/_libs/tslibs/period.pyx:3352:class Period(_Period):
pandas/_libs/tslibs/timestamps.pyx:2005:class Timestamp(_Timestamp):
pandas/_libs/tslibs/nattype.pyx:349:class NaTType(_NaT):

from decimal import Decimal
import numbers
from sys import maxsize

cimport cython
from cpython.datetime cimport (
    date,
    time,
    timedelta,
)
from cython cimport Py_ssize_t

import numpy as np

cimport numpy as cnp
from numpy cimport (
    flatiter,
    float64_t,
    int64_t,
    ndarray,
    uint8_t,
)

cnp.import_array()

from pandas._libs cimport util
from pandas._libs.tslibs.nattype cimport (
    c_NaT as NaT,
    checknull_with_nat,
    is_dt64nat,
    is_td64nat,
)
from pandas._libs.tslibs.np_datetime cimport (
    get_datetime64_unit,
    import_pandas_datetime,
)

import_pandas_datetime()

from pandas._libs.ops_dispatch import maybe_dispatch_ufunc_to_dunder_op

cdef:
    float64_t INF = <float64_t>np.inf
    float64_t NEGINF = -INF

    int64_t NPY_NAT = util.get_nat()

    bint is_32bit = maxsize <= 2 ** 32

    type cDecimal = Decimal  # for faster isinstance chec
…[2073 chars omitted]…
puts, **kwargs
        )
        if result is NotImplemented:
            # For a NumPy ufunc that's not a binop, like np.logaddexp
            index = [i for i, x in enumerate(inputs) if x is NA][0]
            result = np.broadcast_arrays(*inputs)[index]
            if result.ndim == 0:
                result = result.item()
            if ufunc.nout > 1:
                result = (NA,) * ufunc.nout

[NaT] category DatetimeIndex([], dtype='datetime64[s]', freq=None) datetime64[s]
[<NA>] category Index([], dtype='float64') float64
[None] category Index([], dtype='float64') float64
[NaT] category DatetimeIndex([], dtype='datetime64[s]', freq=None) datetime64[s]
[NaT] category DatetimeIndex([], dtype='datetime64[s]', freq=None) datetime64[s]
[NaT] category DatetimeIndex([], dtype='datetime64[s]', freq=None) datetime64[s]

from __future__ import annotations

from typing import (
    TYPE_CHECKING,
    Any,
    ClassVar,
)

import numpy as np

from pandas.util._decorators import set_module

from pandas.core.dtypes.base import register_extension_dtype
from pandas.core.dtypes.common import is_float_dtype

from pandas.core.arrays.numeric import (
    NumericArray,
    NumericDtype,
)

if TYPE_CHECKING:
    from collections.abc import Callable


class FloatingDtype(NumericDtype):
    """
    An ExtensionDtype to hold a single size of floating dtype.

    These specific implementations are subclasses of the non-public
    FloatingDtype. For example we have Float32Dtype to represent float32.

    The attributes name & type are set when these subclasses are created.
    """

    # The value used to fill '_data' to avoid upcasting
    _internal_fill_value = np.nan
    _default_np_dtype = np.dtype(np.float64)
   
…[4268 chars omitted]…
    <BooleanArray>
    [True, False, <NA>]
    Length: 3, dtype: boolean
    """

    name: ClassVar[str] = "boolean"

    # The value used to fill '_data' to avoid upcasting
    _internal_fill_value = False

    # https://github.com/python/mypy/issues/4125
    # error: Signature of "type" incompatible with supertype "BaseMaskedDtype"
    @property
    def type(self) -> type:  # type: ignore[override]

Traceback (most recent call last):
  File "/repo/pandas/core/arrays/integer.py", line 63, in _safe_cast
    return values.astype(dtype, casting="safe", copy=copy)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
TypeError: Cannot cast array data from dtype('int64') to dtype('uint16') according to the rule 'safe'

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
  File "/repo/pandas/core/construction.py", line 373, in array
    return cls._from_sequence(data, dtype=dtype, copy=copy)

           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/pandas/core/arrays/masked.py", line 170, in _from_sequence
    values, mask = cls._coerce_to_array(scalars, dtype=dtype, copy=copy)
                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/pandas/core/a
…[151 chars omitted]…
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/pandas/core/arrays/numeric.py", line 248, in _coerce_to_data_and_mask
    values = dtype_cls._safe_cast(values, dtype, copy=False)
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/pandas/core/arrays/integer.py", line 69, in _safe_cast
    raise TypeError(
TypeError: cannot safely cast non-equivalent int64 to uint16

grep: pandas/tests/arrays/integer/test_astype.py: No such file or directory
grep: pandas/tests/arrays/masked/test_astype.py: No such file or directory
pandas/tests/arrays/integer/test_construction.py:194:    with pytest.raises(TypeError, match="cannot safely cast non-equivalent"):
pandas/tests/series/test_constructors.py:651:    def test_constructor_broadcast_list(self):
pandas/tests/series/test_constructors.py:753:    def test_constructor_cast(self):
pandas/tests/series/test_constructors.py:900:    def test_constructor_dtype_no_cast(self):
pandas/tests/series/test_constructors.py:1191:    def test_constructor_no_partial_datetime_casting(self):
pandas/tests/series/test_constructors.py:1603:    def test_NaT_cast(self):
pandas/tests/series/test_constructors.py:1668:    def test_constructor_cant_cast_datetimelike(self, index):
pandas/tests/series/test_constructors.py:1694:    def test_co
…[2707 chars omitted]…
.py:849:        exc = IntCastingNaNError

pandas/tests/series/test_constructors.py:897:        with pytest.raises(IntCastingNaNError, match=msg):
pandas/tests/test_downstream.py:14:from pandas.errors import IntCastingNaNError
pandas/tests/test_downstream.py:81:    with pytest.raises(IntCastingNaNError, match=msg):
pandas/tests/test_downstream.py:84:    with pytest.raises(IntCastingNaNError, match=msg):

IntegerArray._from_sequence(values)


def test_to_integer_array_inferred_dtype(constructor):
    # if values has dtype -> respect it
    result = constructor(np.array([1, 2], dtype="int8"))
    assert result.dtype == Int8Dtype()
    result = constructor(np.array([1, 2], dtype="int32"))
    assert result.dtype == Int32Dtype()

    # if values have no dtype -> always int64
    result = constructor([1, 2])

    assert result.dtype == Int64Dtype()


def test_to_integer_array_dtype_keyword(constructor):
    result = constructor([1, 2], dtype="Int8")
    assert result.dtype == Int8Dtype()

    # if values has dtype -> override it
    result = constructor(np.array([1, 2], dtype="int8"), dtype="Int32")
    assert result.dtype == Int32Dtype()


def test_to_integer_array_float():
    result = IntegerArray._from_sequence([1.0, 2.0], dtype="Int64")
    expected = pd.array([1, 2], dtype="In
…[8629 chars omitted]…
.maximum.accumulate,
pandas/tests/series/test_ufunc.py:357:        result = np.maximum.reduce(obj)
pandas/tests/series/test_ufunc.py:451:def test_np_matmul():
pandas/tests/series/test_ufunc.py:457:    result = np.matmul(df1, df2)
pandas/tests/series/test_ufunc.py:462:def test_np_matmul_1D(box, using_python_scalars):
pandas/tests/series/test_ufunc.py:463:    result = np.matmul(box([1, 2]), box([2, 3]))

Timestamp('2020-01-01 00:00:00') Timestamp('2020-01-01 00:00:00')

 Timestamp('2020-01-01 00:00:00') Timedelta('1 days 00:00:00')

 Timestamp('2020-01-01 00:00:00') Period('2020-01', 'M')

 Timestamp('2020-01-01 00:00:00') NaT

 Timedelta('1 days 00:00:00') Timestamp('2020-01-01 00:00:00')

 Timedelta('1 days 00:00:00') Timedelta('1 days 00:00:00')

 Timedelta('1 days 00:00:00') Period('2020-01', 'M')

 Timedelta('1 days 00:00:00') NaT

 Period('2020-01', 'M') Timestamp('2020-01-01 00:00:00')

 Period('2020-01', 'M') Timedelta('1 days 00:00:00')

 Period('2020-01', 'M') Period('2020-01', 'M')

 Period('2020-01', 'M') NaT

 NaT Timestamp('2020-01-01 00:00:00')

 NaT Timedelta('1 days 00:00:00')

 NaT Period('2020-01', 'M')

 NaT NaT

<stdin>:2: DeprecationWarning: The 'generic' unit for NumPy timedelta is deprecated, and will raise an error in the future. This includes implicit conversion of bare integers (e.g. `+ 1`). Please use a specific unit instead.
<class 'numpy.datetime64'> False
<class 'numpy.timedelta64'> True
<class 'numpy.datetime64'> False
<class 'numpy.timedelta64'> True

1266:def needs_i8_conversion(dtype: DtypeObj | None) -> bool:
1267-    """
1268-    Check whether the dtype should be converted to int64.
1269-
1270-    Dtype "needs" such a conversion if the dtype is of a datetime-like dtype
1271-
1272-    Parameters
1273-    ----------
1274-    dtype : np.dtype, ExtensionDtype, or None
1275-
1276-    Returns
1277-    -------

1278-    boolean
1279-        Whether or not the dtype should be converted to int64.
1280-
1281-    Examples
1282-    --------
1283-    >>> needs_i8_conversion(str)
1284-    False
1285-    >>> needs_i8_conversion(np.int64)
1286-    False
1287-    >>> needs_i8_conversion(np.datetime64)
1288-    False
1289-    >>> needs_i8_conversion(np.dtype(np.datetime64))
1290-    True
1291-    >>> needs_i8_conversion(np.array(["a", "b"]))
1292-    False
1293-    >>> needs_i8_conversion(pd.Series([1, 2]))
1294-    False
1295-    >>> needs_i8_co
…[427 chars omitted]…

1307-def is_arrow_temporal_dtype(dtype: DtypeObj | None) -> bool:
1308-    """
1309-    Check whether the dtype is an ArrowDtype holding timestamps or durations.
1310-
1311-    These are not covered by :func:`needs_i8_conversion`, so callers that gate
datetime64[ns] True
timedelta64[ns] True
datetime64[ns, UTC] True
period[D] True
category False
Sparse[datetime64[ns], np.datetime64('NaT','ns')] False

pandas/_libs/tslibs/timestamps.pyx:326:cdef class _Timestamp(ABCTimestamp):
pandas/_libs/tslibs/timedeltas.pyx:1559:cdef class _Timedelta(timedelta):
pandas/_libs/tslibs/period.pyx:2050:cdef class _Period(PeriodMixin):
pandas/_libs/tslibs/nattype.pyx:86:cdef class _NaT(datetime):

pandas/_libs/tslibs/base.pxd:4:cdef class ABCTimestamp(datetime):
pandas/_libs/tslibs/timestamps.pxd:7:from pandas._libs.tslibs.base cimport ABCTimestamp
pandas/_libs/tslibs/timestamps.pxd:22:cdef class _Timestamp(ABCTimestamp):
pandas/_libs/tslibs/base.pyx:11:cdef class ABCTimestamp(datetime):
pandas/_libs/tslibs/timedeltas.pyx:49:from pandas._libs.tslibs.base cimport ABCTimestamp
pandas/_libs/tslibs/timedeltas.pyx:1209:            PyDateTime_Check(other) and not isinstance(other, ABCTimestamp)
pandas/_libs/tslibs/timestamps.pyx:52:from pandas._libs.tslibs.base cimport ABCTimestamp
pandas/_libs/tslibs/timestamps.pyx:326:cdef class _Timestamp(ABCTimestamp):

Sparse[datetime64[ns], np.datetime64('NaT','ns')] kind 'M' subtype datetime64[ns]
Sparse[timedelta64[ns], np.timedelta64('NaT','ns')] kind 'm' subtype timedelta64[ns]
Sparse[int64, 0] kind 'i' subtype int64
category kind 'O' subtype None
period[D] kind 'O' subtype None

<class 'pandas.Timestamp'> Timestamp('2020-01-02 00:00:00') None None
<class 'pandas.Timestamp'> Timestamp('2020-01-02 00:00:00') None None
<class 'pandas.Timedelta'> Timedelta('3 days 00:00:00') None None
<class 'pandas.Timedelta'> Timedelta('3 days 00:00:00') None None
<class 'pandas.Period'> Period('2020-02', 'M') None None
<class 'pandas.Period'> Period('2020-02', 'M') None None
<class 'pandas.api.typing.NaTType'> NaT None None
<class 'pandas.api.typing.NaTType'> NaT None None

Timestamp logical_and True TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'logical_and'>, '__call__', Timestamp('2020-01-01 00:00:00'), <NA>): 'Timestamp', 'NAType'
Timestamp logical_and False TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'logical_and'>, '__call__', <NA>, Timestamp('2020-01-01 00:00:00')): 'NAType', 'Timestamp'
Timestamp logical_or True TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'logical_or'>, '__call__', Timestamp('2020-01-01 00:00:00'), <NA>): 'Timestamp', 'NAType'
Timestamp logical_or False TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'logical_or'>, '__call__', <NA>, Timestamp('2020-01-01 00:00:00')): 'NAType', 'Timestamp'
Timestamp logical_xor True TypeError operand type(s) all returned NotImplemented from __array_ufunc
…[3194 chars omitted]…
c__(<ufunc 'logical_or'>, '__call__', <NA>, NaT): 'NAType', 'NaTType'
NaTType logical_xor True TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'logical_xor'>, '__call__', NaT, <NA>): 'NaTType', 'NAType'
NaTType logical_xor False TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'logical_xor'>, '__call__', <NA>, NaT): 'NAType', 'NaTType'

__all__ = [
    "BaseOffset",
    "Day",
    "IncompatibleFrequency",
    "NaT",
    "NaTType",
    "OutOfBoundsDatetime",
    "OutOfBoundsTimedelta",
    "Period",
    "Resolution",
    "Tick",
    "Timedelta",

    "Timestamp",
    "add_overflowsafe",
    "astype_overflowsafe",
    "delta_to_nanoseconds",
    "dt64arr_to_periodarr",
    "dtypes",
    "get_resolution",
    "get_supported_dtype",
    "get_unit_from_dtype",
    "guess_datetime_format",
    "iNaT",
    "ints_to_pydatetime",
    "ints_to_pytimedelta",
    "is_date_array_normalized",
    "is_supported_dtype",
    "is_unitless",
    "localize_pydatetime",
    "mul_overflowsafe",
    "nat_strings",
    "normalize_i8_timestamps",
    "periods_per_day",
    "periods_per_second",
    "to_offset",
    "tz_compare",
    "tz_convert_from_utc",
    "tz_convert_from_utc_single",
]

from pandas._libs.tslibs import dtypes
from pandas.
…[557 chars omitted]…
.offsets import (
    BaseOffset,
    Day,
    Tick,
    to_offset,
)
from pandas._libs.tslibs.parsing import guess_datetime_format
from pandas._libs.tslibs.period import (
    IncompatibleFrequency,
    Period,
)
from pandas._libs.tslibs.timedeltas import (
    Timedelta,
    delta_to_nanoseconds,
    ints_to_pytimedelta,
)
6:    "NaTType",
48:from pandas._libs.tslibs.nattype import (
50:    NaTType,

pandas/_libs/missing.pyx:27:from pandas._libs.tslibs.nattype cimport (
pandas/_libs/missing.pyx:33:from pandas._libs.tslibs.np_datetime cimport (

64:from pandas.core import (
"""
An interface for extending pandas with custom arrays.

.. warning::

   This is an experimental API and subject to breaking changes
   without warning.
"""

from __future__ import annotations

import operator
from typing import (
    TYPE_CHECKING,
    Any,
    ClassVar,
    Literal,
    Self,
    cast,
    overload,
)
import warnings

import numpy as np

from pandas._libs import (
    algos as libalgos,
    groupby as libgroupby,
    lib,
)
from pandas.compat import set_function_name
from pandas.compat.numpy import function as nv
from pandas.errors import AbstractMethodError
from pandas.util._decorators import (
    cache_readonly,
    set_module,
)
from pandas.util._exceptions import find_stack_level
from pandas.util._validators import (
    validate_bool_kwarg,
    validate_insert_loc,
)

from pandas.core.dtypes.astype import astype_is_view
from pan
…[8576 chars omitted]…
ypes.generic import (
    ABCCategoricalIndex,
    ABCDataFrame,
    ABCDatetimeIndex,
    ABCIntervalIndex,
    ABCMultiIndex,
    ABCPeriodIndex,
    ABCRangeIndex,
    ABCSeries,
    ABCTimedeltaIndex,
)
from pandas.core.dtypes.inference import is_dict_like
from pandas.core.dtypes.missing import (
    array_equivalent,
    is_valid_na_for_dtype,
    isna,
)

from pandas.core import (
    arraylike,

pandas/core/arrays/arrow/array.py:471:class ArrowExtensionArray(
pandas/core/arrays/sparse/array.py:559:class SparseArray(OpsMixin, PandasObject, ExtensionArray):
pandas/core/arrays/categorical.py:258:class Categorical(NDArrayBackedExtensionArray, PandasObject, ObjectStringArrayMixin):
pandas/core/arrays/categorical.py:3084:class CategoricalAccessor(PandasDelegate, PandasObject, NoNewAttributesMixin):
102-        NumpySorter,
103-        NumpyValueArrayLike,
104-        PositionalIndexer,
105-        RankMethod,
106-        RankNaOption,
107-        ScalarIndexer,
108-        SequenceIndexer,
109-        Shape,

110-        SortKind,
111-        TakeIndexer,
112-        npt,
113-    )
114-
115-    from pandas import (
116-        Index,
117-        Series,
118-    )
119-
120-
121-@set_module("pandas.api.extensions")
122:class ExtensionArray:
--
3215-            mask=isna_mask,
3216-   
…[1275 chars omitted]…
icate ExtensionArray.__array_ufunc__ but convert with
1157-            # na_value=np.nan (float, not object) in the default fallback,
1158-            # then re-mask NA positions in the result.
1159-            if any(
1160-                isinstance(other, (ABCSeries, ABCIndex, ABCDataFrame))
1161-                for other in inputs
1162-            ):
1163-                return NotImplemented
1164-

Timestamp logical_and True bool
Timestamp logical_or Timestamp('2020-01-01 00:00:00') Timestamp
Timestamp logical_xor AttributeError 'Timestamp' object has no attribute 'logical_xor'
Timestamp logical_not False bool
Timedelta logical_and True bool
Timedelta logical_or Timedelta('1 days 00:00:00') Timedelta
Timedelta logical_xor AttributeError 'Timedelta' object has no attribute 'logical_xor'
Timedelta logical_not False bool
Period logical_and True bool
Period logical_or Period('2020-01-01', 'D') Period
Period logical_xor AttributeError 'Period' object has no attribute 'logical_xor'
Period logical_not False bool

NaTType logical_and True bool
NaTType logical_or NaT NaTType
NaTType logical_xor AttributeError 'NaTType' object has no attribute 'logical_xor'
NaTType logical_not False bool

non_default_dtype_backend = (
            no_dtype_specified and dtype_backend is not lib.no_default
        )
        result: ArrayLike

        if try_num_bool and is_object_dtype(values.dtype):
            # exclude e.g DatetimeIndex here
            try:
                result, result_mask = lib.maybe_convert_numeric(
                    values,
                    na_values,
                    False,

                    convert_to_masked_nullable=non_default_dtype_backend,  # type: ignore[arg-type]
                )
            except (ValueError, TypeError):
                # e.g. encountering datetime string gets ValueError
                #  TypeError can be raised in floatify
                na_count = parsers.sanitize_objects(values, na_values)
                result = values
            else:
                if non_default_dtype_backend:
                    if resu
…[2983 chars omitted]…
o/parser/test_na_values.py:718:            "cannot safely convert passed user dtype of "
pandas/tests/io/parser/test_na_values.py:814:        "cannot safely convert passed user dtype of int(64|32) for "
pandas/_libs/parsers.pyx:1682:                        f"cannot safely convert passed user dtype of "
pandas/_libs/parsers.pyx:1698:                        f"cannot safely convert passed user dtype of "

else:
                        # This error is raised from trying to convert to uint64,
                        # and we discover that we cannot convert to any numerical
                        # dtype successfully. As a result, we leave the data
                        # column AS IS with object dtype.
                        col_res, na_count = self._string_convert(
                            i, start, end, 0, na_hashset,
                            allow_pyarrow=col_dtype is None)
                        na_mask = None
                        if na_filter:
                            self.na_left_literal = True
                except OverflowError:

                    na_mask = None
                    try:
                        col_res, na_count = _try_pylong(self.parser, i, start,
                                                        end, na_filter, na_has
…[7306 chars omitted]…
er_dtype,
1708-                             kh_str_starts_t *na_hashset,
1709-                             set na_fset, bint raise_on_invalid):
1710-        if isinstance(dtype, CategoricalDtype):
1711-            # TODO: I suspect that _categorical_convert could be
1712-            # optimized when dtype is an instance of CategoricalDtype
1713-            codes, cats, na_count = _categorical_convert(

construction UInt8 <IntegerArray>
[<NA>]
Length: 1, dtype: UInt8 [231]
assign UInt8 TypeError cannot safely cast non-equivalent int64 to uint8
construction Int8 <IntegerArray>
[<NA>]
Length: 1, dtype: Int8 [-25]
assign Int8 TypeError cannot safely cast non-equivalent int64 to int8

and (len(result) == 0 or not isinstance(result[0], int))
        ):
            result, bool_mask = libops.maybe_convert_bool(
                np.asarray(values),
                true_values=self.true_values,
                false_values=self.false_values,
                convert_to_masked_nullable=non_default_dtype_backend,  # type: ignore[arg-type]
            )
            if result.dtype == np.bool_ and non_default_dtype_backend:
                if bool_mask is None:
                    bool_mask = np.zeros(result.shape, dtype=np.bool_)
                result = BooleanArray(result, bool_mask)

            elif result.dtype == np.object_ and non_default_dtype_backend:
                # read_excel sends array of datetime objects
                if not lib.is_datetime_array(result, skipna=True):
                    dtype = StringDtype()
                    cls = dtype.cons
…[8630 chars omitted]…
ount = _categorical_convert(
                self.parser, i, start, end, na_filter, na_hashset,
                self.encoding_errors)

            array_type = dtype.construct_array_type()
            if self.low_memory_chunking and dtype.categories is None:
                # GH#56044 chunks could each infer a different category dtype,
                #  breaking union_categoricals; defer inference to

<class 'pandas.Timestamp'>
add TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'add'>, '__call__', Timestamp('2020-01-01 00:00:00'), Timestamp('2020-01-01 00:00:00')): 'Timestamp', 'Timestamp'
subtract TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'subtract'>, '__call__', Timestamp('2020-01-01 00:00:00'), Timestamp('2020-01-01 00:00:00')): 'Timestamp', 'Timestamp'
equal TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'equal'>, '__call__', Timestamp('2020-01-01 00:00:00'), Timestamp('2020-01-01 00:00:00')): 'Timestamp', 'Timestamp'
minimum TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'minimum'>, '__call__', Timestamp('2020-01-01 00:00:00'), Timestamp('2020-01-01 00:00:00')): 'Timestamp', 'Timestamp'
maximum TypeError operand type(s) all returned
…[5392 chars omitted]…
call__', NaT): 'NaTType'
sin TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'sin'>, '__call__', NaT): 'NaTType'
negative TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'negative'>, '__call__', NaT): 'NaTType'
isnat TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'isnat'>, '__call__', NaT): 'NaTType'

na_count > 0 and not isinstance(col_dtype, ExtensionDtype)
            or self.dtype_backend != "numpy"
        ):
            use_dtype_backend = self.dtype_backend != "numpy" and col_dtype is None
            col_res = _maybe_upcast(
                col_res,
                use_dtype_backend=use_dtype_backend,
                dtype_backend=self.dtype_backend,
                na_mask=na_mask,
            )

        if col_res is None:

            raise ParserError(f"Unable to parse column {i}")

        results[i] = col_res

    cdef int64_t _block_rows(self, int64_t lines):
        """
        Rows per conversion block: about `_BLOCK_BYTES` of the chunk's parser
        state (tokens, word_ends, line_start), so a block stays in L1 across
        the columns' passes.  One block when blocking is off.
        """
        cdef int64_t bytes_per_row, block_rows, block_bytes =
…[8630 chars omitted]…
return result, na_count, None
        elif dtype == object:
            result, na_count = self._string_convert(i, start, end, na_filter,
                                                    na_hashset)
            return result, na_count, None
        elif dtype.kind == "M":
            raise TypeError(f"the dtype {dtype} is not supported "
                            f"for parsing, pass this column "

"""
Constructor functions intended to be shared by pd.array, Series.__init__,
and Index.__new__.

These should not depend on core.internals.
"""

from __future__ import annotations

from typing import (
    TYPE_CHECKING,
    cast,

    overload,
)

import numpy as np
from numpy import ma

from pandas._config import using_string_dtype

from pandas._libs import lib
from pandas._libs.tslibs import (
    get_supported_dtype,
    is_supported_dtype,
)
from pandas.util._decorators import set_module

from pandas.core.dtypes.base import ExtensionDtype
from pandas.core.dtypes.cast import (
    construct_1d_arraylike_from_scalar,
    construct_1d_object_array_from_listlike,
    maybe_cast_to_datetime,
    maybe_cast_to_integer_array,
    maybe_promote,
)
from pandas.core.dtypes.common import (
    ensure_object,
    is_list_like,
    is_object_dtype,
    pandas_dtype,
)
from pandas.core.dtypes.
…[5207 chars omitted]…
rt (
        ArrayLike,
        Shape,
    )

# -----------------------------------------------------------------------------
# Masking NA values and fallbacks for operations numpy does not support


def fill_binop(left, right, fill_value):
    """
    If a non-None fill_value is given, replace null entries in left and right
    with this value, but only in positions where _one_ of left/right is null,

# Constructors

    def __init__(
        self, values: np.ndarray | NumpyExtensionArray, copy: bool = False
    ) -> None:
        if isinstance(values, type(self)):
            values = values._ndarray
        if not isinstance(values, np.ndarray):
            raise ValueError(
                f"'values' must be a NumPy array, not {type(values).__name__}"
            )

        if values.ndim == 0:
            # Technically we support 2, but do not advertise that fact.
            raise ValueError("NumpyExtensionArray must be 1-dimensional.")

        if copy:
            values = values.copy()

        dtype = NumpyEADtype(values.dtype)
        super().__init__(values, dtype)

    @classmethod
    def _from_sequence(
        cls, scalars, *, dtype: Dtype | None = None, copy: bool = False
    ) -> NumpyExtensionArray:
        if isinstance(dtype, NumpyEADtype):
            dtype
…[1250 chars omitted]…
/core/construction.py:391:                return NumpyExtensionArray._from_sequence(
pandas/core/construction.py:421:                return NumpyExtensionArray._from_sequence(
pandas/core/construction.py:431:            return NumpyExtensionArray._from_sequence(data, dtype=data.dtype, copy=copy)
pandas/core/construction.py:449:    return NumpyExtensionArray._from_sequence(data, dtype=dtype, copy=copy)

# Copyright (c) 2012, Lambda Foundry, Inc.
# See LICENSE for the license
from collections import defaultdict
from csv import (
    QUOTE_MINIMAL,
    QUOTE_NONE,
    QUOTE_NONNUMERIC,
)
from datetime import (
    timedelta,
    timezone,
)

import warnings

from pandas._config import (
    is_nan_na,
    using_string_dtype,
)

from pandas.compat.pyarrow import HAS_PYARROW
from pandas.util._exceptions import find_stack_level

from pandas import (
    ArrowDtype,
    Index,
    StringDtype,
)
from pandas.core.arrays import (
    ArrowExtensionArray,
    ArrowStringArray,
    BooleanArray,
    DatetimeArray,
    FloatingArray,
    IntegerArray,
)

cimport cython
from cpython.bytes cimport (
    PyBytes_AsString,
    PyBytes_AsStringAndSize,
    PyBytes_FromStringAndSize,
)
from cpython.exc cimport (
    PyErr_Fetch,
    PyErr_Occurred,
)
from cpython.long cimport PyLong_FromString
from cp
…[6498 chars omitted]…
ount = _categorical_convert(
                self.parser, i, start, end, na_filter, na_hashset,
                self.encoding_errors)

            array_type = dtype.construct_array_type()
            if self.low_memory_chunking and dtype.categories is None:
                # GH#56044 chunks could each infer a different category dtype,
                #  breaking union_categoricals; defer inference to

and (len(result) == 0 or not isinstance(result[0], int))
        ):
            result, bool_mask = libops.maybe_convert_bool(
                np.asarray(values),
                true_values=self.true_values,
                false_values=self.false_values,
                convert_to_masked_nullable=non_default_dtype_backend,  # type: ignore[arg-type]
            )
            if result.dtype == np.bool_ and non_default_dtype_backend:
                if bool_mask is None:
                    bool_mask = np.zeros(result.shape, dtype=np.bool_)
                result = BooleanArray(result, bool_mask)

            elif result.dtype == np.object_ and non_default_dtype_backend:
                # read_excel sends array of datetime objects
                if not lib.is_datetime_array(result, skipna=True):
                    dtype = StringDtype()
                    cls = dtype.cons
…[8629 chars omitted]…
-        Convert the queued columns together, a block of rows at a time, so a
1452-        block of the chunk's `word_ends` and tokens is read from DRAM once and
--
1608-                        return col_res, na_count, None
1609-                    if state is not None:
1610-                        state.failed = True
1611-            col_res, na_count = self._string_convert(i, start, end, na_filter,

and try_num_bool
            and (len(result) == 0 or not isinstance(result[0], int))
        ):
            result, bool_mask = libops.maybe_convert_bool(
                np.asarray(values),
                true_values=self.true_values,
                false_values=self.false_values,
                convert_to_masked_nullable=non_default_dtype_backend,  # type: ignore[arg-type]
            )
            if result.dtype == np.bool_ and non_default_dtype_backend:
                if bool_mask is None:
                    bool_mask = np.zeros(result.shape, dtype=np.bool_)

                result = BooleanArray(result, bool_mask)
            elif result.dtype == np.object_ and non_default_dtype_backend:
                # read_excel sends array of datetime objects
                if not lib.is_datetime_array(result, skipna=True):
                    dtype = StringDtype()
       
…[8629 chars omitted]…
turns that
        # array, or None to signal "not confidently numeric" (non-numeric data,
        # or ints wider than uint64 which the string path renders as Python
        # ints), in which case the caller should fall back to the string path.
        cdef:
            object ivals = None
            object mask = None

        try:
            ivals, _, mask = _try_int64(self.parser, i, start, end,

and (len(result) == 0 or not isinstance(result[0], int))
        ):
            result, bool_mask = libops.maybe_convert_bool(
                np.asarray(values),
                true_values=self.true_values,
                false_values=self.false_values,
                convert_to_masked_nullable=non_default_dtype_backend,  # type: ignore[arg-type]
            )
            if result.dtype == np.bool_ and non_default_dtype_backend:
                if bool_mask is None:
                    bool_mask = np.zeros(result.shape, dtype=np.bool_)
                result = BooleanArray(result, bool_mask)

            elif result.dtype == np.object_ and non_default_dtype_backend:
                # read_excel sends array of datetime objects
                if not lib.is_datetime_array(result, skipna=True):
                    dtype = StringDtype()
                    cls = dtype.cons
…[2018 chars omitted]…
         date_format=self.date_format,
            )
            # error: Unsupported target for indexed assignment
            # ("Mapping[Hashable, ExtensionArray | ndarray[Any, Any]] | DataFrame")
            data[colspec] = result  # type: ignore[index]

        return data

    @final
    def _check_data_length(
        self,
        columns: Sequence[Hashable],
        data: Sequence[ArrayLike],

and (len(result) == 0 or not isinstance(result[0], int))
        ):
            result, bool_mask = libops.maybe_convert_bool(
                np.asarray(values),
                true_values=self.true_values,
                false_values=self.false_values,
                convert_to_masked_nullable=non_default_dtype_backend,  # type: ignore[arg-type]
            )
            if result.dtype == np.bool_ and non_default_dtype_backend:
                if bool_mask is None:
                    bool_mask = np.zeros(result.shape, dtype=np.bool_)
                result = BooleanArray(result, bool_mask)

            elif result.dtype == np.object_ and non_default_dtype_backend:
                # read_excel sends array of datetime objects
                if not lib.is_datetime_array(result, skipna=True):
                    dtype = StringDtype()
                    cls = dtype.cons
…[8629 chars omitted]…
                             na_filter, na_hashset,
1848-                                              self.true_set, self.false_set)
1849-            if user_dtype and na_count is not None:
1850-                if na_count > 0:
1851-                    raise ValueError(f"Bool column has NA values in column {i}")
1852-            return result, na_count, None
1853-
1854-        elif dtype.kind == "S":

return results

    cdef _convert_columns(self, dict results, list batch,
                          int64_t start, int64_t end,
                          bint is_default_dict_dtype, bint numeric_ok):
        cdef:
            int64_t i
            int nused = 0
            int kind
            Py_ssize_t nqueued
            kh_str_starts_t *na_hashset = NULL
            object name, col_dtype = None

            set na_fset
            bint na_filter = 0

        for i in range(self.table_width):
            if i < self.leading_cols:
                # Pass through leading columns always
                name = i
            elif (self.usecols and not callable(self.usecols) and
                    nused == len(self.usecols)):
                # Once we've gathered all requested columns, stop. GH5766
                break
            else:
                name = self._get_column_na
…[3906 chars omitted]…
ne line_start
1146:        breaking union_categoricals, so _convert_with_dtype defers it during
1582:            col_res, na_count, na_mask = self._convert_with_dtype(
1626:                    # _convert_with_dtype to avoid its default allow_pyarrow=False.
1634:                    col_res, na_count, na_mask = self._convert_with_dtype(
1704:    cdef _convert_with_dtype(self, object dtype, Py_ssize_t i,

cdef _finalize_datetime_chunks(self, list chunks):
        """
        For parse_dates fastpath columns where a chunk fell back to strings,
        rebuild the already-converted chunks' object-string arrays from their
        raw-byte receipts so the column is all-or-nothing, exactly like a
        non-chunked read.
        """
        cdef _DatetimeChunkState state

        if self.dt_chunk_states is None:
            return
        for col, state in self.dt_chunk_states.items():

            if not state.failed:
                continue
            for chunk_idx, arena, offsets, use_dtype_backend in state.receipts:
                strs = _box_arena_utf8(arena, offsets, self.encoding_errors)
                if use_dtype_backend:
                    strs = _maybe_upcast(
                        strs,
                        use_dtype_backend=True,
                        dtype_bac
…[8629 chars omitted]…
 allow_pyarrow=col_dtype is None)
                        if na_filter:
                            self.na_left_literal = True

                if col_res is not None:
                    break

        # we had a fallback parse on the dtype, so now try to cast
        if col_res is not None and col_dtype is not None:
            # If col_res is bool, it might actually be a bool array mixed with NaNs

IntegerArray Int64 UInt8 [np.uint8(231)] [231] [False]
IntegerArray Int64 Int8 [np.int8(-25)] [-25] [False]
IntegerArray UInt16 UInt8 [np.uint8(231)] [231] [False]
IntegerArray UInt16 Int8 [np.int8(-25)] [-25] [False]
IntegerArray Int8 UInt8 [np.uint8(1)] [1] [False]
IntegerArray Int8 Int8 [np.int8(1)] [1] [False]
MaskedArray int64 UInt8 [<NA>] [231] [ True]
MaskedArray int64 Int8 [<NA>] [-25] [ True]

IntegerArray uint8 [255, 2] uint8
IntegerArray int8 [-1, 2] int8
IntegerArray UInt8 [255, 2] UInt8
IntegerArray Int8 [-1, 2] Int8
MaskedArray uint8 IntCastingNaNError Cannot convert non-finite values (NA or inf) to integer. Replace or remove non-finite values or cast to an integer type that supports these values (e.g. 'Int64')
MaskedArray int8 IntCastingNaNError Cannot convert non-finite values (NA or inf) to integer. Replace or remove non-finite values or cast to an integer type that supports these values (e.g. 'Int64')
MaskedArray UInt8 [<NA>, 2] UInt8
MaskedArray Int8 [<NA>, 2] Int8
ndarray uint8 [255, 2] uint8
ndarray int8 [-1, 2] int8
ndarray UInt8 TypeError cannot safely cast non-equivalent int64 to uint8
ndarray Int8 [-1, 2] Int8

and (len(result) == 0 or not isinstance(result[0], int))
        ):
            result, bool_mask = libops.maybe_convert_bool(
                np.asarray(values),
                true_values=self.true_values,
                false_values=self.false_values,
                convert_to_masked_nullable=non_default_dtype_backend,  # type: ignore[arg-type]
            )
            if result.dtype == np.bool_ and non_default_dtype_backend:
                if bool_mask is None:
                    bool_mask = np.zeros(result.shape, dtype=np.bool_)
                result = BooleanArray(result, bool_mask)

            elif result.dtype == np.object_ and non_default_dtype_backend:
                # read_excel sends array of datetime objects
                if not lib.is_datetime_array(result, skipna=True):
                    dtype = StringDtype()
                    cls = dtype.cons
…[5805 chars omitted]…
olumns: Sequence[HashableT], dtype: DtypeArg | None = None
    ) -> tuple[Index, list[HashableT], dict[HashableT, Series]]:
        columns = list(columns)

        index_col = self.index_col
        index_names = self.index_names

        # Convert `dtype` to a defaultdict of some kind.
        # This will enable us to write `dtype[col_name]`
        # without worrying about KeyError issues later on.

[1.2, 2.5] Int8 <IntegerArray>
[1, 2]
Length: 2, dtype: Int8
[1.2, 2.5] Int64 <IntegerArray>
[1, 2]
Length: 2, dtype: Int64
[1.0, 2.0] Int8 <IntegerArray>
[1, 2]
Length: 2, dtype: Int8
[1.0, 2.0] Int64 <IntegerArray>
[1, 2]
Length: 2, dtype: Int64

list uint8 OverflowError Python integer -1 out of bounds for uint8
list int8 OverflowError Python integer 257 out of bounds for int8
list UInt8 TypeError cannot safely cast non-equivalent int64 to uint8
list Int8 TypeError cannot safely cast non-equivalent int64 to int8
ndarray uint8 [np.uint8(255), np.uint8(1)] uint8
ndarray int8 [np.int8(-1), np.int8(1)] int8
ndarray UInt8 TypeError cannot safely cast non-equivalent int64 to uint8
ndarray Int8 TypeError cannot safely cast non-equivalent int64 to int8
MaskedArray uint8 IntCastingNaNError Cannot convert non-finite values (NA or inf) to integer. Replace or remove non-finite values or cast to an integer type that supports these values (e.g. 'Int64')
MaskedArray int8 IntCastingNaNError Cannot convert non-finite values (NA or inf) to integer. Replace or remove non-finite values or cast to an integer type that supports these values (e.g. '
…[177 chars omitted]…
 to integer. Replace or remove non-finite values or cast to an integer type that supports these values (e.g. 'Int64')

MaskedArray int8 IntCastingNaNError Cannot convert non-finite values (NA or inf) to integer. Replace or remove non-finite values or cast to an integer type that supports these values (e.g. 'Int64')
MaskedArray UInt8 [<NA>, np.uint8(231)] UInt8
MaskedArray Int8 [<NA>, np.int8(-25)] Int8

<stdin>:3: Pandas4Warning: 'd' is deprecated and will be removed in a future version. Please use 'D' instead of 'd'.
<class 'pandas.Timestamp'> True False
<class 'pandas.Timedelta'> False True
<class 'pandas.Period'> False False
<class 'pandas.api.typing.NaTType'> False False

<class 'pandas.Timestamp'> None None
<class 'pandas.Timedelta'> None None
<class 'pandas.Period'> None None
<class 'pandas.api.typing.NaTType'> None None

"""
SparseArray data structure
"""

from __future__ import annotations

from collections import abc
import numbers
import operator
from typing import (
    TYPE_CHECKING,
    Any,

    Literal,
    Self,
    cast,
    overload,
)
import warnings

import numpy as np

from pandas._config.config import _global_config as config

from pandas._libs import (
    lib,
    missing as libmissing,
)
import pandas._libs.sparse as splib
from pandas._libs.sparse import (
    BlockIndex,
    IntIndex,
    SparseIndex,
)
from pandas._libs.tslibs import (
    NaT,
    Timedelta,
    Timestamp,
    is_supported_dtype,
)
from pandas.compat import PYPY
from pandas.compat.numpy import function as nv
from pandas.errors import (
    Pandas4Warning,
    PerformanceWarning,
)
from pandas.util._decorators import (
    set_module,
)
from pandas.util._exceptions import find_stack_level
from pandas.util._validator
…[4611 chars omitted]…
das.core.common as com
pandas/core/arrays/sparse/array.py-97-from pandas.core.construction import (
pandas/core/arrays/sparse/array.py-98-    ensure_wrapped_if_datetimelike,
pandas/core/arrays/sparse/array.py-99-    extract_array,
pandas/core/arrays/sparse/array.py-100-    sanitize_array,
pandas/core/arrays/sparse/array.py-101-)
pandas/core/arrays/sparse/array.py-102-from pandas.core.indexers import (

int8 127.0 False False int 127
int8 np.float64(127.0) np.False_ np.False_ int 127
int8 9.223372036854776e+18 True False int 9223372036854775808
int8 1.8446744073709552e+19 True False int 18446744073709551616
int8 -128.0 False False int -128
int8 1127.0 True False int 1127
uint8 255.0 False False int 255
uint8 np.float64(255.0) np.False_ np.False_ int 255
uint8 9.223372036854776e+18 True False int 9223372036854775808
uint8 1.8446744073709552e+19 True False int 18446744073709551616
uint8 0.0 False False int 0
uint8 1255.0 True False int 1255

int64 9.223372036854776e+18 True False int 9223372036854775808
int64 np.float64(9.223372036854776e+18) np.False_ np.False_ int 9223372036854775808
int64 9.223372036854776e+18 True False int 9223372036854775808
int64 1.8446744073709552e+19 True False int 18446744073709551616
int64 -9.223372036854776e+18 False False int -9223372036854775808
int64 9.22
…[27 chars omitted]…
e int 9223372036854775808
uint64 1.8446744073709552e+19 True False int 18446744073709551616
uint64 np.float64(1.8446744073709552e+19) np.False_ np.False_ int 18446744073709551616
uint64 9.223372036854776e+18 False False int 9223372036854775808
uint64 1.8446744073709552e+19 True False int 18446744073709551616
uint64 0.0 False False int 0
uint64 1.8446744073709552e+19 True False int 18446744073709551616

pandas/tests/io/parser/dtypes/test_dtypes_basic.py:28:def test_dtype_all_columns(
pandas/tests/io/parser/dtypes/test_dtypes_basic.py:70:def test_dtype_per_column(all_parsers):
pandas/tests/io/parser/dtypes/test_dtypes_basic.py:87:def test_invalid_dtype_per_column(all_parsers):
pandas/tests/io/parser/dtypes/test_dtypes_basic.py:100:def test_raise_on_passed_int_dtype_with_nas(all_parsers):
pandas/tests/io/parser/dtypes/test_dtypes_basic.py:119:def test_dtype_with_converters(all_parsers):
pandas/tests/io/parser/dtypes/test_dtypes_basic.py:146:def test_numeric_dtype(all_parsers, any_real_numpy_dtype):
pandas/tests/io/parser/dtypes/test_dtypes_basic.py:161:def test_complex_dtype(all_parsers, data, dtype):
pandas/tests/io/parser/dtypes/test_dtypes_basic.py:170:def test_complex_dtype_roundtrip(all_parsers, temp_file):
pandas/tests/io/parser/dtypes/test_dtypes_basic.py:180:def test_complex_dt
…[3840 chars omitted]…
ers):
pandas/tests/io/parser/test_upcast.py:19:def test_maybe_upcast(any_real_numpy_dtype):

pandas/tests/io/parser/test_upcast.py:36:def test_maybe_upcast_no_na(any_real_numpy_dtype):
pandas/tests/io/parser/test_upcast.py:54:    arr = np.array([True, False, na_value], dtype="uint8").view(dtype)
pandas/tests/io/parser/test_upcast.py:65:    arr = np.array([True, False, False], dtype="uint8").view(dtype)

"""
Tests dtype specification during parsing
for all of the parsers defined in parsers.py
"""

from collections import defaultdict
from io import StringIO

import numpy as np
import pytest

from pandas.compat.pyarrow import pa_version_under25p0

from pandas.errors import (
    EmptyDataError,
    Pandas4Warning,
    ParserWarning,
)

import pandas as pd
import pandas._testing as tm
from pandas.core.arrays import IntegerArray

xfail_pyarrow = pytest.mark.usefixtures("pyarrow_xfail")


@pytest.mark.parametrize("dtype", [str, object])
@pytest.mark.parametrize("check_orig", [True, False])
def test_dtype_all_columns(
    all_parsers, dtype, check_orig, using_infer_string, temp_file, request
):
    # see gh-3795, gh-6607
    parser = all_parsers

    if (
        parser.engine == "pyarrow"
        and dtype is object
        and not check_orig
        and pa_version_under25p0
    ):
        
…[4951 chars omitted]…
idened it to float64 to hold
    # the missing value and then cast to string, yielding "44794724.0"
    if dtype == "string[pyarrow]":
        pytest.importorskip("pyarrow")
    parser = all_parsers
    data = "var1,var2\n44794724,x\n,y\n"

    result = parser.read_csv(StringIO(data), dtype=dtype)

    expected = pd.DataFrame(
        {"var1": ["44794724", None], "var2": ["x", "y"]}, dtype=dtype
    )

pandas/io/parsers/python_parser.py:490:                    cvals = self._cast_types(cvals, cast_type, c)
pandas/io/parsers/python_parser.py:496:    def _cast_types(self, values: ArrayLike, cast_type: DtypeObj, column) -> ArrayLike:

cvals = self._cast_types(cvals, cast_type, c)

            result[c] = cvals
        return result

    @final
    def _cast_types(self, values: ArrayLike, cast_type: DtypeObj, column) -> ArrayLike:
        """
        Cast values to specified type

        Parameters
        ----------

        values : ndarray or ExtensionArray
        cast_type : np.dtype or ExtensionDtype
           dtype to cast values to
        column : string
            column name - used only for error reporting

        Returns
        -------
        converted : ndarray or ExtensionArray
        """
        if isinstance(cast_type, CategoricalDtype):
            cats = Index(values, copy=False).unique().dropna()
            codes = cats.get_indexer(values)
            if cast_type.categories is None:
                # GH#56044 mirror the type inference performed on ordinary
             
…[2963 chars omitted]…
      raise ValueError(
                    f"Unable to convert column {column} to type {cast_type}"
                ) from err
        return values

    @cache_readonly
    def _have_mi_columns(self) -> bool:
        if self.header is None:
            return False

        header = self.header
        if isinstance(header, (list, tuple, np.ndarray)):
            return len(header) > 1
        else:

815:    def __array__(
816-        self, dtype: NpDtype | None = None, copy: bool | None = None
817-    ) -> np.ndarray:
818-        """
819-        the array interface, return my values
820-        We return an object array here to preserve our scalar values
821-        """
822-        if copy is False:
823-            if not self._hasna:
824-                # special case, here we can simply return the underlying data
825-                result = np.array(self._data, dtype=dtype, copy=copy)
826-                # If the ExtensionArray is readonly, make the numpy array readonly too

827-                if self._readonly:
828-                    result = result.view()
829-                    result.flags.writeable = False
830-                return result
831-            raise ValueError(
832-                "Unable to avoid copy while creating an array as requested."
833-            )

…[3600 chars omitted]…
      raise ValueError(
710-                    f"cannot convert to '{dtype}'-dtype NumPy array "
711-                    "with missing values. Specify an appropriate 'na_value' "
712-                    "for this dtype."
<IntegerArray>
[1, <NA>]
Length: 2, dtype: Int64 [ 1. nan] float64 [1 1] [False  True]
<FloatingArray>
[1.0, <NA>]
Length: 2, dtype: Float64 [ 1. nan] float64 [ 1. nan] [False  True]

mapping = self._dtype_cls._get_dtype_mapping()
        return mapping[self._data.dtype]

    @classmethod
    def _coerce_to_array(
        cls, value, *, dtype: DtypeObj, copy: bool = False
    ) -> tuple[np.ndarray, np.ndarray]:
        dtype_cls = cls._dtype_cls
        values, mask = _coerce_to_data_and_mask(value, dtype, copy, dtype_cls)
        return values, mask

    @classmethod

    def _from_sequence_of_strings(
        cls, strings, *, dtype: ExtensionDtype, copy: bool = False
    ) -> Self:
        from pandas.core.tools.numeric import to_numeric

        scalars = to_numeric(strings, errors="raise", dtype_backend="numpy_nullable")
        return cls._from_sequence(scalars, dtype=dtype, copy=copy)

    _HANDLED_TYPES = (np.ndarray, numbers.Number)
pandas/core/arrays/numeric.py:297:    def _from_sequence_of_strings(
pandas/core/arrays/numeric.py:297:    def _from_se
…[230 chars omitted]…
ols.numeric import to_numeric
pandas/core/arrays/numeric.py-301-
pandas/core/arrays/numeric.py-302-        scalars = to_numeric(strings, errors="raise", dtype_backend="numpy_nullable")
pandas/core/arrays/numeric.py-303-        return cls._from_sequence(scalars, dtype=dtype, copy=copy)
pandas/core/arrays/numeric.py-304-
pandas/core/arrays/numeric.py-305-    _HANDLED_TYPES = (np.ndarray, numbers.Number)

uint64 18446744073709551615 int8 TypeError cannot safely cast non-equivalent uint64 to int8
uint64 18446744073709551615 uint8 TypeError cannot safely cast non-equivalent uint64 to uint8
uint64 18446744073709551615 int64 TypeError cannot safely cast non-equivalent uint64 to int64
eq cast [-1] [False]
uint64 9223372036854775808 int8 TypeError cannot safely cast non-equivalent uint64 to int8
uint64 9223372036854775808 uint8 TypeError cannot safely cast non-equivalent uint64 to uint8
uint64 9223372036854775808 int64 TypeError cannot safely cast non-equivalent uint64 to int64
eq cast [0] [False]
uint64 9223372036854775807 int8 TypeError cannot safely cast non-equivalent uint64 to int8
uint64 9223372036854775807 uint8 TypeError cannot safely cast non-equivalent uint64 to uint8
uint64 9223372036854775807 int64 [np.int64(9223372036854775807)]
eq cast [-1] [False]

int64 -1 int8 [np.int8(-1)]
int64 -1 uint8 TypeError cannot safely cast non-equivalent int64 to uint8
int64 -1 int64 [np.int64(-1)]
eq cast [-1] [ True]
int64 255 int8 TypeError cannot safely cast non-equivalent int64 to int8
int64 255 uint8 [np.uint8(255)]
int64 255 int64 [np.int64(255)]
eq cast [-1] [False]

"""
Define extension dtypes.
"""

from __future__ import annotations

from datetime import (
    date,
    datetime,
    time,
    timedelta,
)

from decimal import Decimal
import re
from typing import (
    TYPE_CHECKING,
    Any,
    Self,
    cast,
)
import warnings
import zoneinfo

import numpy as np

from pandas._config.config import _global_config as config

from pandas._libs import (
    lib,
    missing as libmissing,
)
from pandas._libs.interval import Interval
from pandas._libs.properties import cache_readonly
from pandas._libs.tslibs import (
    BaseOffset,
    NaT,
    NaTType,
    Period,
    Timedelta,
    Timestamp,
    is_supported_dtype,
    is_unitless,
    timezones,
    to_offset,
    tz_compare,
)
from pandas._libs.tslibs.dtypes import (
    PeriodDtypeBase,
    abbrev_to_npy_unit,
)
from pandas._libs.tslibs.offsets import BDay
from pandas.compat import (
    HAS_
…[5424 chars omitted]…
ter code (one of 'biufcmMOSUV'), default 'O'
202-
199:    def kind(self) -> str:
200-        """
201-        A character code (one of 'biufcmMOSUV'), default 'O'
202-
203-        This should match the NumPy dtype used when the array is
204-        converted to an ndarray, which is probably 'O' for object if
205-        the extension type cannot be represented as a built-in NumPy
206-        type.
207-

@property
    def kind(self) -> str:
        """
        A character code (one of 'biufcmMOSUV'), default 'O'

        This should match the NumPy dtype used when the array is
        converted to an ndarray, which is probably 'O' for object if
        the extension type cannot be represented as a built-in NumPy
        type.

        See Also
        --------

        numpy.dtype.kind
        """
        return "O"

    @property
    def name(self) -> str:
        """
        A string identifying the data type.

        Will be used for display in, e.g. ``Series.dtype``
        """
period[D] O <class 'str'>
datetime64[ns, UTC] M <class 'str'>
Sparse[int64, 0] i <class 'str'>
category O <class 'str'>
timestamp[ns][pyarrow] M <class 'str'>

source ndarray int64 array([ -1, 257])
array uint8 -> [np.uint8(255), np.uint8(1)] uint8
array int8 -> [np.int8(-1), np.int8(1)] int8
array int64 -> [np.int64(-1), np.int64(257)] int64
array UInt8 !! TypeError cannot safely cast non-equivalent int64 to uint8
array Int8 !! TypeError cannot safely cast non-equivalent int64 to int8
Series uint8 !! OverflowError Trying to coerce negative values to unsigned integers
Series int8 !! ValueError Values are too large to be losslessly converted to int8. To cast anyway, use pd.Series(values).astype(int8)
Series int64 -> [-1, 257] int64
Series UInt8 !! TypeError cannot safely cast non-equivalent int64 to uint8
Series Int8 !! TypeError cannot safely cast non-equivalent int64 to int8
Index uint8 !! OverflowError Trying to coerce negative values to unsigned integers

Index int8 !! ValueError Values are too large to be losslessly converted to int8. To
…[4846 chars omitted]…
775808)] int64
array UInt8 -> [np.uint8(0)] UInt8
array Int8 -> [np.int8(0)] Int8
Series uint8 -> [0] uint8
Series int8 -> [0] int8
Series int64 -> [-9223372036854775808] int64
Series UInt8 -> [np.uint8(0)] UInt8
Series Int8 -> [np.int8(0)] Int8
Index uint8 -> [0] uint8
Index int8 -> [0] int8
Index int64 -> [-9223372036854775808] int64
Index UInt8 -> [np.uint8(0)] UInt8
Index Int8 -> [np.int8(0)] Int8

Series uint8 0    255
1      1
dtype: uint8
Series int8 0   -1
1    1
dtype: int8
Series UInt8 TypeError cannot safely cast non-equivalent int64 to uint8
Series Int8 TypeError cannot safely cast non-equivalent int64 to int8
Index uint8 Index([255, 1], dtype='uint8')
Index int8 Index([-1, 1], dtype='int8')
Index UInt8 TypeError cannot safely cast non-equivalent int64 to uint8
Index Int8 TypeError cannot safely cast non-equivalent int64 to int8

IntegerArray uint8 [255   1]
IntegerArray int8 [-1  1]
IntegerArray UInt8 <IntegerArray>
[255, 1]
Length: 2, dtype: UInt8
IntegerArray Int8 <IntegerArray>
[-1, 1]
Length: 2, dtype: Int8

758:    def astype(self, dtype: npt.DTypeLike, copy: bool = ...) -> np.ndarray: ...
759-
760-    @overload
761:    def astype(self, dtype: ExtensionDtype, copy: bool = ...) -> ExtensionArray: ...
762-
763-    @overload
764:    def astype(self, dtype: AstypeArg, copy: bool = ...) -> ArrayLike: ...
765-
766:    def astype(self, dtype: AstypeArg, copy: bool = True) -> ArrayLike:
767-        dtype = pandas_dtype(dtype)
768-
769-        if dtype == self.dtype:

770-            if copy:
771-                return self.copy()
772-            return self
773-
774-        # if we are astyping to another nullable masked dtype, we can fastpath
775-        if isinstance(dtype, BaseMaskedDtype):
776-            # TODO deal with NaNs for FloatingArray case
777-            with warnings.catch_warnings():
778-                warnings.filterwarnings("ignore", category=RuntimeWarning)
779-              
…[3069 chars omitted]…
s + out:
848-            if not isinstance(x, (*self._HANDLED_TYPES, BaseMaskedArray)):
849-                return NotImplemented
850-
851-        # for binary ops, use our custom dunder methods
852-        result = arraylike.maybe_dispatch_ufunc_to_dunder_op(
853-            self, ufunc, method, *inputs, **kwargs
854-        )
855-        if result is not NotImplemented:
856-            return result

Timestamp add TypeError unsupported operand type(s) for +: 'Timestamp' and 'Timestamp'
Timestamp minimum -> Timestamp('2020-01-01 00:00:00') Timestamp None None
Timestamp equal -> np.True_ bool () bool
Timestamp logical_or -> Timestamp('2020-01-01 00:00:00') Timestamp None None
Timestamp logical_not -> False bool None None
Timedelta add -> Timedelta('2 days 00:00:00') Timedelta None None
Timedelta minimum -> Timedelta('1 days 00:00:00') Timedelta None None
Timedelta equal -> np.True_ bool () bool
Timedelta logical_or -> Timedelta('1 days 00:00:00') Timedelta None None
Timedelta logical_not -> False bool None None
Period add TypeError unsupported operand type(s) for +: 'Period' and 'Period'
Period minimum -> Period('2020-01-01', 'D') Period None None

Period equal -> np.True_ bool () bool
Period logical_or -> Period('2020-01-01', 'D') Period None None
Period logical_not -> False bool None None
NaTType add -> NaT NaTType None None
NaTType minimum -> NaT NaTType None None
NaTType equal -> np.False_ bool () bool
NaTType logical_or -> NaT NaTType None None
NaTType logical_not -> False bool None None

from __future__ import annotations

from collections import abc
import csv
from io import StringIO
import re
from typing import (
    IO,
    TYPE_CHECKING,
    Any,
    Literal,
    cast,

    final,
)
import warnings

import numpy as np

from pandas._libs import lib
from pandas.errors import (
    EmptyDataError,
    ParserError,
    ParserWarning,
)
from pandas.util._decorators import cache_readonly
from pandas.util._exceptions import find_stack_level

from pandas.core.dtypes.astype import astype_array
from pandas.core.dtypes.common import (
    is_bool_dtype,
    is_extension_array_dtype,
    is_integer,
    is_numeric_dtype,
    is_string_dtype,
    pandas_dtype,
)
from pandas.core.dtypes.dtypes import (
    CategoricalDtype,
    ExtensionDtype,
)

from pandas.core import algorithms
from pandas.core.arrays import (
    Categorical,
    ExtensionArray,
)
from pandas.core.arrays.boo
…[7812 chars omitted]…
dtypes import NumpyEADtype
31-from pandas.core.dtypes.missing import (
32-    is_valid_na_for_dtype,
33-    isna,
34-)
35-
36-from pandas.core import (
37-    arraylike,
38-    missing,
39-    nanops,
40-    ops,
41-)
42-from pandas.core.arraylike import OpsMixin
43-from pandas.core.arrays._mixins import NDArrayBackedExtensionArray
44-from pandas.core.construction import ensure_wrapped_if_datetimelike

------
    TypeError : on inequality comparisons
    """
    if op is operator.eq:
        res_values = np.zeros(left.shape, dtype=bool)
    elif op is operator.ne:
        res_values = np.ones(left.shape, dtype=bool)
    else:
        typ = type(right).__name__
        raise TypeError(f"Invalid comparison between dtype={left.dtype} and {typ}")
    return res_values

def _is_datetimelike_scalar(obj: object) -> bool:
    from datetime import date, datetime, timedelta

    from pandas._libs.tslibs import (
        NaTType,
        Period,
        Timedelta,
        Timestamp,
    )

    return isinstance(
        obj,
        (
            NaTType,
            Period,
            Timestamp,
            Timedelta,
            np.datetime64,
            np.timedelta64,
            date,
            datetime,
            timedelta,
        ),
    )


def _is_datetimelike_array(obj: ob
…[2996 chars omitted]…
nc: np.ufunc, method: str, *inputs, **kwargs):
pandas/core/arrays/categorical.py:1941:    def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
pandas/core/arrays/sparse/array.py:2818:    def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
pandas/core/arrays/arrow/array.py:1144:    def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):

<stdin>:4: Pandas4Warning: 'd' is deprecated and will be removed in a future version. Please use 'D' instead of 'd'.
<stdin>:4: DeprecationWarning: The 'generic' unit for NumPy timedelta is deprecated, and will raise an error in the future. This includes implicit conversion of bare integers (e.g. `+ 1`). Please use a specific unit instead.
/repo/pandas/core/construction.py:717: UserWarning: pyarrow requires pandas 2.2.2 or above, pandas 0+untagged.1.g63b1924 is installed. Therefore, pandas-specific integration is not used.
  subarr = lib.maybe_convert_objects(
WRONG DatetimeArray logical_and NameError name 'arraylike' is not defined
WRONG DatetimeArray logical_or NameError name 'arraylike' is not defined
WRONG DatetimeArray logical_xor NameError name 'arraylike' is not defined
WRONG DatetimeArray logical_not NameError name 'arraylike' is not defined
BAD ndarray logical_and [ True  Tru
…[8629 chars omitted]…
ython numpy_nullable Int8 257 TypeError cannot safely cast non-equivalent int64 to int8
CSV err python numpy_nullable Int8 300.0 TypeError cannot safely cast non-equivalent float64 to int8

CSV err python numpy_nullable Int8 257.0 TypeError cannot safely cast non-equivalent float64 to int8
CSV err python numpy_nullable Int8 18446744073709551615 TypeError cannot safely cast non-equivalent uint64 to int8

ninja: Entering directory `build/cp312'
[1/18] Compiling Cython source /repo/pandas/_libs/missing.pyx
[2/18] Compiling Cython source /repo/pandas/_libs/tslibs/nattype.pyx
[3/18] Compiling Cython source /repo/pandas/_libs/tslibs/timedeltas.pyx
warning: /repo/pandas/_libs/tslibs/timedeltas.pyx:2014:12: Python attribute access is not usefully protected by critical_section
warning: /repo/pandas/_libs/tslibs/timedeltas.pyx:2015:12: Python attribute access is not usefully protected by critical_section
[4/18] Compiling Cython source /repo/pandas/_libs/tslibs/period.pyx
[5/18] Compiling Cython source /repo/pandas/_libs/tslibs/timestamps.pyx
[6/18] Compiling Cython source /repo/pandas/_libs/parsers.pyx
[7/18] Compiling C object pandas/_libs/missing.cpython-312-x86_64-linux-gnu.so.p/meson-generated_missing.pyx.c.o
[8/18] Linking target pandas/_libs/missing.cpython-312-x86_64-linux-gnu.so
[9/18]

…[609 chars omitted]…
o
[15/18] Compiling C object pandas/_libs/tslibs/timedeltas.cpython-312-x86_64-linux-gnu.so.p/meson-generated_timedeltas.pyx.c.o
[16/18] Linking target pandas/_libs/tslibs/timedeltas.cpython-312-x86_64-linux-gnu.so
[17/18] Compiling C object pandas/_libs/parsers.cpython-312-x86_64-linux-gnu.so.p/meson-generated_parsers.pyx.c.o
[18/18] Linking target pandas/_libs/parsers.cpython-312-x86_64-linux-gnu.so

<stdin>:3: Pandas4Warning: 'd' is deprecated and will be removed in a future version. Please use 'D' instead of 'd'.
<stdin>:3: DeprecationWarning: The 'generic' unit for NumPy timedelta is deprecated, and will raise an error in the future. This includes implicit conversion of bare integers (e.g. `+ 1`). Please use a specific unit instead.
/repo/pandas/core/construction.py:717: UserWarning: pyarrow requires pandas 2.2.2 or above, pandas 0+untagged.1.g63b1924 is installed. Therefore, pandas-specific integration is not used.
  subarr = lib.maybe_convert_objects(
BAD ndarray logical_and [ True]
BAD ndarray logical_or [ True]
BAD ndarray logical_xor [False]
WRONG ndarray logical_not TypeError ufunc 'logical_not' not supported for the input types, and the inputs could not be safely coerced to any supported types according to the casting rule ''safe''
BAD datetime64 logical_and True
BAD dat
…[7815 chars omitted]…
1 Int8

CSV python numpy_nullable Int8 257 TypeError cannot safely cast non-equivalent int64 to int8
CSV python numpy_nullable Int8 300.0 TypeError cannot safely cast non-equivalent float64 to int8
CSV python numpy_nullable Int8 257.0 TypeError cannot safely cast non-equivalent float64 to int8
CSV python numpy_nullable Int8 18446744073709551615 TypeError cannot safely cast non-equivalent uint64 to int8

Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
  File "/repo/pandas/core/series.py", line 410, in __init__
    dtype = self._validate_dtype(dtype)
            ^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/pandas/core/generic.py", line 486, in _validate_dtype
    dtype = pandas_dtype(dtype)
            ^^^^^^^^^^^^^^^^^^^
  File "/repo/pandas/core/dtypes/common.py", line 1899, in pandas_dtype
    npdtype = np.dtype(dtype)
              ^^^^^^^^^^^^^^^
TypeError: Invalid datetime unit in metadata string "[ns,UTC]"

<stdin>:2: Pandas4Warning: 'd' is deprecated and will be removed in a future version. Please use 'D' instead of 'd'.
Series datetime64[us]
TypeError cannot perform the numpy op logical_and
TypeError cannot perform the numpy op logical_or
TypeError cannot perform the numpy op logical_xor
TypeError cannot perform the numpy op logical_not
Series datetime64[us, UTC]
TypeError cannot perform the numpy op logical_and
TypeError cannot perform the numpy op logical_or
TypeError cannot perform the numpy op logical_xor
TypeError cannot perform the numpy op logical_not
Series timedelta64[us]

TypeError cannot perform the numpy op logical_and
TypeError cannot perform the numpy op logical_or
TypeError cannot perform the numpy op logical_xor
TypeError cannot perform the numpy op logical_not
Series period[D]
TypeError cannot perform the numpy op logical_and
TypeError cannot perform the numpy op logica
…[632 chars omitted]…
rror cannot perform the numpy op logical_or
TypeError cannot perform the numpy op logical_xor
TypeError cannot perform the numpy op logical_not
ndarray datetime64[ns]
OK logical_and [ True]
OK logical_or [ True]
OK logical_xor [False]
TypeError ufunc 'logical_not' not supported for the input types, and the inputs could not be safely coerced to any supported types according to the casting rule ''safe''

try <class 'numpy.ndarray'> [ True]
X ufunc logical_and __call__
TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'logical_and'>, '__call__', array(['2020-01-01T00:00:00.000000000'], dtype='datetime64[ns]'), <__main__.X object at 0x74528ab3f0b0>): 'ndarray', 'X'
X ufunc logical_and __call__
TypeError operand type(s) all returned NotImplemented from __array_ufunc__(<ufunc 'logical_and'>, '__call__', <__main__.X object at 0x74528ab3f0b0>, array(['2020-01-01T00:00:00.000000000'], dtype='datetime64[ns]')): 'X', 'ndarray'
reduce True
reduce True
reduce True
ValueError reduce only supported for binary functions