Drop ANN exceptions from *arrays* and core/base.py

pandas-stubs/core/arrays/boolean.pyi

@@ -1,5 +1,4 @@
 from collections.abc import Sequence
-from typing import Any
 
 import numpy as np
 from pandas.core.arrays.integer import IntegerArray
@@ -25,10 +24,7 @@ class BooleanArray(BaseMaskedArray):
         self, values: np_ndarray_bool, mask: np_ndarray_bool, copy: bool = ...
     ) -> None: ...
     @property
-    def dtype(self): ...
-    def __setitem__(self, key, value) -> None: ...
-    def any(self, *, skipna: bool = ..., **kwargs: Any): ...
-    def all(self, *, skipna: bool = ..., **kwargs: Any): ...
+    def dtype(self) -> BooleanDtype: ...
     def __and__(
         self,
         other: (

pandas-stubs/core/arrays/categorical.pyi

@@ -1,49 +1,58 @@
 from collections.abc import (
     Callable,
+    Container,
+    Hashable,
     Sequence,
 )
+import sys
 from typing import (
     Any,
     overload,
 )
 
 import numpy as np
+import numpy.typing as npt
 from pandas import Series
 from pandas.core.accessor import PandasDelegate as PandasDelegate
 from pandas.core.arrays.base import ExtensionArray as ExtensionArray
 from pandas.core.base import NoNewAttributesMixin as NoNewAttributesMixin
 from pandas.core.indexes.base import Index
+from pandas.core.indexes.category import CategoricalIndex
 from typing_extensions import Self
 
 from pandas._typing import (
+    AnyArrayLike,
     ListLike,
     NpDtype,
     Ordered,
     PositionalIndexerTuple,
+    Renamer,
     Scalar,
     ScalarIndexer,
     SequenceIndexer,
-    TakeIndexer,
     np_1darray,
+    np_1darray_anyint,
     np_1darray_bool,
 )
 
 from pandas.core.dtypes.dtypes import CategoricalDtype as CategoricalDtype
 
-def contains(cat, key, container): ...
+def contains(
+    cat: Categorical | CategoricalIndex, key: Hashable, container: Container
+) -> bool: ...
 
 class Categorical(ExtensionArray):
     __array_priority__: int = ...
     def __init__(
         self,
         values: ListLike,
-        categories=...,
-        ordered: bool | None = ...,
-        dtype: CategoricalDtype | None = ...,
-        fastpath: bool = ...,
+        categories: ListLike | None = None,
+        ordered: bool | None = None,
+        dtype: CategoricalDtype | None = None,
+        fastpath: bool = True,
     ) -> None: ...
     @property
-    def categories(self): ...
+    def categories(self) -> Index: ...
     @property
     def ordered(self) -> Ordered: ...
     @property
@@ -62,56 +71,48 @@ class Categorical(ExtensionArray):
     ) -> Categorical: ...
     @property
     def codes(self) -> np_1darray[np.signedinteger]: ...
-    def set_ordered(self, value) -> Categorical: ...
+    def set_ordered(self, value: bool) -> Categorical: ...
     def as_ordered(self) -> Categorical: ...
     def as_unordered(self) -> Categorical: ...
     def set_categories(
         self,
-        new_categories,
+        new_categories: AnyArrayLike,
         ordered: bool | None = False,
         rename: bool = False,
     ) -> Categorical: ...
-    def rename_categories(self, new_categories) -> Categorical: ...
+    def rename_categories(self, new_categories: AnyArrayLike) -> Categorical: ...
     def reorder_categories(
-        self, new_categories, ordered: bool | None = ...
+        self, new_categories: AnyArrayLike, ordered: bool | None = ...
     ) -> Categorical: ...
-    def add_categories(self, new_categories) -> Categorical: ...
-    def remove_categories(self, removals) -> Categorical: ...
     def remove_unused_categories(self) -> Categorical: ...
-    def map(self, mapper): ...
-    def __eq__(self, other) -> bool: ...
-    def __ne__(self, other) -> bool: ...
-    def __lt__(self, other) -> bool: ...
-    def __gt__(self, other) -> bool: ...
-    def __le__(self, other) -> bool: ...
-    def __ge__(self, other) -> bool: ...
-    @property
-    def shape(self): ...
-    def shift(self, periods=1, fill_value=...): ...
+    def map(self, mapper: Renamer) -> CategoricalIndex | Index: ...
     def __array__(
         self, dtype: NpDtype | None = None, copy: bool | None = None
     ) -> np_1darray: ...
     @property
-    def T(self): ...
+    def T(self) -> Self: ...
     @property
     def nbytes(self) -> int: ...
-    def memory_usage(self, deep: bool = ...): ...
+    def memory_usage(self, deep: bool = False) -> int: ...
     def isna(self) -> np_1darray_bool: ...
     def isnull(self) -> np_1darray_bool: ...
     def notna(self) -> np_1darray_bool: ...
     def notnull(self) -> np_1darray_bool: ...
-    def dropna(self): ...
-    def value_counts(self, dropna: bool = True): ...
-    def check_for_ordered(self, op) -> None: ...
-    def argsort(self, *, ascending: bool = ..., kind: str = ..., **kwargs: Any): ...
+    def value_counts(self, dropna: bool = True) -> Series: ...
+    def check_for_ordered(self, op: Any) -> None: ...
+    if sys.version_info >= (3, 11):
+        def argsort(
+            self, *, ascending: bool = ..., kind: str = ..., **kwargs: Any
+        ) -> npt.NDArray[np.intp]: ...
+    else:
+        def argsort(
+            self, *, ascending: bool = ..., kind: str = ..., **kwargs: Any
+        ) -> np_1darray_anyint: ...
+
     def sort_values(
         self, *, inplace: bool = ..., ascending: bool = ..., na_position: str = ...
-    ): ...
-    def view(self, dtype=...): ...
-    def take(
-        self, indexer: TakeIndexer, *, allow_fill: bool = ..., fill_value=...
-    ) -> Categorical: ...
-    def __contains__(self, item) -> bool: ...
+    ) -> Self: ...
+    def __contains__(self, item: Hashable) -> bool: ...
     @overload
     def __getitem__(  # pyrefly: ignore[bad-override,bad-param-name-override]
         self, key: ScalarIndexer
@@ -120,17 +121,9 @@ class Categorical(ExtensionArray):
     def __getitem__(  # ty: ignore[invalid-method-override]
         self, key: SequenceIndexer | PositionalIndexerTuple
     ) -> Self: ...
-    def __setitem__(self, key, value) -> None: ...
-    def min(self, *, skipna: bool = ...): ...
-    def max(self, *, skipna: bool = ...): ...
-    def unique(self): ...
-    def equals(self, other): ...
-    def describe(self): ...
-    def repeat(self, repeats, axis=...): ...
-    def isin(self, values): ...
 
 class CategoricalAccessor(PandasDelegate, NoNewAttributesMixin):
-    def __init__(self, data) -> None: ...
+    def __init__(self, data: Series | CategoricalIndex) -> None: ...
     @property
     def codes(self) -> Series[int]: ...
     @property

pandas-stubs/core/arrays/datetimelike.pyi

@@ -1,10 +1,12 @@
 from collections.abc import Sequence
+from datetime import datetime
 from typing import (
-    Any,
     TypeAlias,
     overload,
 )
 
+import numpy as np
+import numpy.typing as npt
 from pandas.core.arrays.base import (
     ExtensionArray,
     ExtensionOpsMixin,
@@ -17,6 +19,8 @@ from pandas._libs import (
 )
 from pandas._typing import (
     DatetimeLikeScalar,
+    DtypeArg,
+    Frequency,
     NpDtype,
     PositionalIndexerTuple,
     ScalarIndexer,
@@ -30,41 +34,34 @@ from pandas._typing import (
 DTScalarOrNaT: TypeAlias = DatetimeLikeScalar | NaTType
 
 class DatelikeOps:
-    def strftime(self, date_format): ...
+    def strftime(self, date_format: str) -> npt.NDArray[np.object_]: ...
 
 class TimelikeOps:
     @property
     def unit(self) -> TimeUnit: ...
     def as_unit(self, unit: TimeUnit) -> Self: ...
     def round(
         self,
-        freq,
+        freq: Frequency,
         ambiguous: TimeAmbiguous = "raise",
         nonexistent: TimeNonexistent = "raise",
-    ): ...
+    ) -> Self: ...
     def floor(
         self,
-        freq,
+        freq: Frequency,
         ambiguous: TimeAmbiguous = "raise",
         nonexistent: TimeNonexistent = "raise",
-    ): ...
+    ) -> Self: ...
     def ceil(
         self,
-        freq,
+        freq: Frequency,
         ambiguous: TimeAmbiguous = "raise",
         nonexistent: TimeNonexistent = "raise",
-    ): ...
+    ) -> Self: ...
 
 class DatetimeLikeArrayMixin(ExtensionOpsMixin, ExtensionArray):
     @property
     def ndim(self) -> int: ...
-    @property
-    def shape(self): ...
-    def reshape(self, *args: Any, **kwargs: Any): ...
-    def ravel(self, *args: Any, **kwargs: Any): ...
-    def __iter__(self): ...
-    @property
-    def nbytes(self): ...
     def __array__(
         self, dtype: NpDtype | None = None, copy: bool | None = None
     ) -> np_1darray: ...
@@ -79,35 +76,20 @@ class DatetimeLikeArrayMixin(ExtensionOpsMixin, ExtensionArray):
         self, key: SequenceIndexer | PositionalIndexerTuple
     ) -> Self: ...
     def __setitem__(  # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride]
-        self, key: int | Sequence[int] | Sequence[bool] | slice, value
+        self, key: int | Sequence[int] | Sequence[bool] | slice, value: datetime
     ) -> None: ...
-    def view(self, dtype=...): ...
-    def unique(self): ...
-    def copy(self): ...
-    def shift(self, periods: int = 1, fill_value=..., axis: int = ...): ...
-    def repeat(self, repeats, *args: Any, **kwargs: Any): ...
-    def value_counts(self, dropna: bool = True): ...
-    def map(self, mapper): ...
-    def isna(self): ...
+    def view(self, dtype: DtypeArg | None = None) -> Self: ...
+    def copy(self) -> Self: ...
     @property
-    def freq(self): ...
+    def freq(self) -> Frequency | None: ...
     @freq.setter
-    def freq(self, value) -> None: ...
+    def freq(self, value: Frequency | None) -> None: ...
     @property
-    def freqstr(self): ...
+    def freqstr(self) -> str | None: ...
     @property
-    def inferred_freq(self): ...
+    def inferred_freq(self) -> str | None: ...
     @property
-    def resolution(self): ...
+    def resolution(self) -> str: ...
     __pow__ = ...
     __rpow__ = ...
     __rmul__ = ...
-    def __add__(self, other): ...
-    def __radd__(self, other): ...
-    def __sub__(self, other): ...
-    def __rsub__(self, other): ...
-    def __iadd__(self, other): ...
-    def __isub__(self, other): ...
-    def min(self, *, axis=..., skipna: bool = ..., **kwargs: Any): ...
-    def max(self, *, axis=..., skipna: bool = ..., **kwargs: Any): ...
-    def mean(self, *, skipna: bool = ...): ...

pandas-stubs/core/arrays/datetimes.pyi

@@ -3,23 +3,39 @@ import sys
 from typing import Any
 
 import numpy as np
+import numpy.typing as npt
 from pandas.core.arrays.datetimelike import (
     DatelikeOps,
     DatetimeLikeArrayMixin,
     TimelikeOps,
 )
+from pandas.core.arrays.period import PeriodArray
+from pandas.core.indexes.base import Index
+from pandas.core.series import Series
+from typing_extensions import Self
 
+from pandas._libs.tslibs.period import Period
 from pandas._typing import (
+    DtypeArg,
+    Frequency,
     TimeAmbiguous,
     TimeNonexistent,
     TimeZones,
+    np_1darray_float,
+    np_1darray_object,
 )
 
 from pandas.core.dtypes.dtypes import DatetimeTZDtype as DatetimeTZDtype
 
 class DatetimeArray(DatetimeLikeArrayMixin, TimelikeOps, DatelikeOps):
     __array_priority__: int = ...
-    def __init__(self, values, dtype=..., freq=..., copy: bool = ...) -> None: ...
+    def __init__(
+        self,
+        values: Series | Index | DatetimeArray | npt.NDArray[np.object_],
+        dtype: DtypeArg | None = None,
+        freq: Frequency | None = None,
+        copy: bool = False,
+    ) -> None: ...
     # ignore in dtype() is from the pandas source
     if sys.version_info >= (3, 11):
         @property
@@ -28,34 +44,28 @@ class DatetimeArray(DatetimeLikeArrayMixin, TimelikeOps, DatelikeOps):
         @property
         def dtype(self) -> np.dtype[Any] | DatetimeTZDtype: ...  # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride]
 
-    @property
-    def tz(self): ...
-    @tz.setter
-    def tz(self, value) -> None: ...
     @property
     def tzinfo(self) -> _tzinfo | None: ...
     @property
-    def is_normalized(self): ...
-    def __iter__(self): ...
-    def tz_convert(self, tz: TimeZones): ...
+    def is_normalized(self) -> bool: ...
+    def tz_convert(self, tz: TimeZones) -> Self: ...
     def tz_localize(
         self,
         tz: TimeZones,
         ambiguous: TimeAmbiguous = "raise",
         nonexistent: TimeNonexistent = "raise",
-    ): ...
-    def to_pydatetime(self): ...
-    def normalize(self): ...
-    def to_period(self, freq=...): ...
-    def to_perioddelta(self, freq): ...
-    def month_name(self, locale=...): ...
-    def day_name(self, locale=...): ...
+    ) -> Self: ...
+    def to_pydatetime(self) -> np_1darray_object: ...
+    def normalize(self) -> Self: ...
+    def to_period(self, freq: str | Period | None = None) -> PeriodArray: ...
+    def month_name(self, locale: str | None = None) -> Series | Index: ...
+    def day_name(self, locale: str | None = None) -> Series | Index: ...
     @property
-    def time(self): ...
+    def time(self) -> npt.NDArray[np.object_]: ...
     @property
-    def timetz(self): ...
+    def timetz(self) -> npt.NDArray[np.object_]: ...
     @property
-    def date(self): ...
+    def date(self) -> npt.NDArray[np.object_]: ...
     year = ...
     month = ...
     day = ...
@@ -77,4 +87,4 @@ class DatetimeArray(DatetimeLikeArrayMixin, TimelikeOps, DatelikeOps):
     is_year_start = ...
     is_year_end = ...
     is_leap_year = ...
-    def to_julian_date(self): ...
+    def to_julian_date(self) -> np_1darray_float: ...