From 9f90081eb42253838d00eb96ed36070cc4128958 Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Sun, 2 Nov 2025 15:30:36 +0100 Subject: [PATCH 1/9] add NumpyExtensionArray --- pandas-stubs/_libs/arrays.pyi | 1 + pandas-stubs/core/arrays/_mixins.pyi | 5 +++++ pandas-stubs/core/arrays/numpy_.pyi | 6 ++++++ pandas-stubs/core/strings/object_array.pyi | 1 + 4 files changed, 13 insertions(+) create mode 100644 pandas-stubs/_libs/arrays.pyi create mode 100644 pandas-stubs/core/arrays/_mixins.pyi create mode 100644 pandas-stubs/core/strings/object_array.pyi diff --git a/pandas-stubs/_libs/arrays.pyi b/pandas-stubs/_libs/arrays.pyi new file mode 100644 index 000000000..740dc7469 --- /dev/null +++ b/pandas-stubs/_libs/arrays.pyi @@ -0,0 +1 @@ +class NDArrayBacked: ... diff --git a/pandas-stubs/core/arrays/_mixins.pyi b/pandas-stubs/core/arrays/_mixins.pyi new file mode 100644 index 000000000..c34cbd231 --- /dev/null +++ b/pandas-stubs/core/arrays/_mixins.pyi @@ -0,0 +1,5 @@ +from pandas.core.arrays.base import ExtensionArray + +from pandas._libs.arrays import NDArrayBacked + +class NDArrayBackedExtensionArray(NDArrayBacked, ExtensionArray): ... diff --git a/pandas-stubs/core/arrays/numpy_.pyi b/pandas-stubs/core/arrays/numpy_.pyi index 760d82e84..96a7a72a3 100644 --- a/pandas-stubs/core/arrays/numpy_.pyi +++ b/pandas-stubs/core/arrays/numpy_.pyi @@ -1,9 +1,12 @@ import numpy as np from numpy.lib.mixins import NDArrayOperatorsMixin +from pandas.core.arraylike import OpsMixin +from pandas.core.arrays._mixins import NDArrayBackedExtensionArray from pandas.core.arrays.base import ( ExtensionArray, ExtensionOpsMixin, ) +from pandas.core.strings.object_array import ObjectStringArrayMixin from pandas.core.dtypes.dtypes import ExtensionDtype @@ -14,3 +17,6 @@ class PandasDtype(ExtensionDtype): def itemsize(self) -> int: ... class PandasArray(ExtensionArray, ExtensionOpsMixin, NDArrayOperatorsMixin): ... +class NumpyExtensionArray( + OpsMixin, NDArrayBackedExtensionArray, ObjectStringArrayMixin +): ... diff --git a/pandas-stubs/core/strings/object_array.pyi b/pandas-stubs/core/strings/object_array.pyi new file mode 100644 index 000000000..3fd853b0f --- /dev/null +++ b/pandas-stubs/core/strings/object_array.pyi @@ -0,0 +1 @@ +class ObjectStringArrayMixin: ... From 4d3e615938c8b59b1a54b7315e4515eef5ffc8f8 Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Tue, 4 Nov 2025 11:54:58 +0100 Subject: [PATCH 2/9] add all arrays --- pandas-stubs/_libs/arrays.pyi | 39 +++++++++++++- pandas-stubs/core/arrays/__init__.pyi | 54 ++++++++++++++----- .../core/arrays/_arrow_string_mixins.pyi | 1 + pandas-stubs/core/arrays/_mixins.pyi | 12 ++++- pandas-stubs/core/arrays/arrow/__init__.pyi | 7 +++ pandas-stubs/core/arrays/arrow/accessors.pyi | 5 ++ pandas-stubs/core/arrays/arrow/array.pyi | 7 +++ pandas-stubs/core/arrays/base.pyi | 4 +- pandas-stubs/core/arrays/floating.pyi | 6 ++- pandas-stubs/core/arrays/numeric.pyi | 8 +++ pandas-stubs/core/arrays/period.pyi | 13 +++++ pandas-stubs/core/arrays/string_.pyi | 7 ++- pandas-stubs/core/arrays/string_arrow.pyi | 7 +++ 13 files changed, 151 insertions(+), 19 deletions(-) create mode 100644 pandas-stubs/core/arrays/_arrow_string_mixins.pyi create mode 100644 pandas-stubs/core/arrays/arrow/accessors.pyi create mode 100644 pandas-stubs/core/arrays/arrow/array.pyi create mode 100644 pandas-stubs/core/arrays/string_arrow.pyi diff --git a/pandas-stubs/_libs/arrays.pyi b/pandas-stubs/_libs/arrays.pyi index 740dc7469..59a8da922 100644 --- a/pandas-stubs/_libs/arrays.pyi +++ b/pandas-stubs/_libs/arrays.pyi @@ -1 +1,38 @@ -class NDArrayBacked: ... +from collections.abc import Sequence +from typing import Any + +import numpy as np +from typing_extensions import Self + +from pandas._typing import ( + AnyArrayLikeInt, + AxisInt, + DtypeObj, + Shape, +) + +class NDArrayBacked: + _dtype: DtypeObj + _ndarray: np.ndarray + def __setstate__(self, state: Any) -> None: ... + def __len__(self) -> int: ... + @property + def shape(self) -> Shape: ... + @property + def ndim(self) -> int: ... + @property + def size(self) -> int: ... + @property + def nbytes(self) -> int: ... + def copy(self, order=...) -> Self: ... + def delete(self, loc, axis=...) -> Self: ... + def swapaxes(self, axis1, axis2) -> Self: ... + def repeat( + self, + repeats: int | Sequence[int] | AnyArrayLikeInt, + axis: AxisInt | None = None, + ) -> Self: ... + def reshape(self, *args: Any, **kwargs: Any) -> Self: ... + def ravel(self, order=...) -> Self: ... + @property + def T(self) -> Self: ... diff --git a/pandas-stubs/core/arrays/__init__.pyi b/pandas-stubs/core/arrays/__init__.pyi index b9fb5f749..f183e9236 100644 --- a/pandas-stubs/core/arrays/__init__.pyi +++ b/pandas-stubs/core/arrays/__init__.pyi @@ -1,15 +1,43 @@ +from pandas.core.arrays.arrow import ArrowExtensionArray from pandas.core.arrays.base import ( - ExtensionArray as ExtensionArray, - ExtensionOpsMixin as ExtensionOpsMixin, - ExtensionScalarOpsMixin as ExtensionScalarOpsMixin, + ExtensionArray, + ExtensionOpsMixin, + ExtensionScalarOpsMixin, ) -from pandas.core.arrays.boolean import BooleanArray as BooleanArray -from pandas.core.arrays.categorical import Categorical as Categorical -from pandas.core.arrays.datetimes import DatetimeArray as DatetimeArray -from pandas.core.arrays.integer import IntegerArray as IntegerArray -from pandas.core.arrays.interval import IntervalArray as IntervalArray -from pandas.core.arrays.numpy_ import PandasArray as PandasArray -from pandas.core.arrays.period import PeriodArray as PeriodArray -from pandas.core.arrays.sparse import SparseArray as SparseArray -from pandas.core.arrays.string_ import StringArray as StringArray -from pandas.core.arrays.timedeltas import TimedeltaArray as TimedeltaArray +from pandas.core.arrays.boolean import BooleanArray +from pandas.core.arrays.categorical import Categorical +from pandas.core.arrays.datetimes import DatetimeArray +from pandas.core.arrays.floating import FloatingArray +from pandas.core.arrays.integer import IntegerArray +from pandas.core.arrays.interval import IntervalArray +from pandas.core.arrays.masked import BaseMaskedArray +from pandas.core.arrays.numpy_ import NumpyExtensionArray +from pandas.core.arrays.period import ( + PeriodArray, + period_array, +) +from pandas.core.arrays.sparse import SparseArray +from pandas.core.arrays.string_ import StringArray +from pandas.core.arrays.string_arrow import ArrowStringArray +from pandas.core.arrays.timedeltas import TimedeltaArray + +__all__ = [ + "ArrowExtensionArray", + "ArrowStringArray", + "BaseMaskedArray", + "BooleanArray", + "Categorical", + "DatetimeArray", + "ExtensionArray", + "ExtensionOpsMixin", + "ExtensionScalarOpsMixin", + "FloatingArray", + "IntegerArray", + "IntervalArray", + "NumpyExtensionArray", + "PeriodArray", + "SparseArray", + "StringArray", + "TimedeltaArray", + "period_array", +] diff --git a/pandas-stubs/core/arrays/_arrow_string_mixins.pyi b/pandas-stubs/core/arrays/_arrow_string_mixins.pyi new file mode 100644 index 000000000..8c2984e50 --- /dev/null +++ b/pandas-stubs/core/arrays/_arrow_string_mixins.pyi @@ -0,0 +1 @@ +class ArrowStringArrayMixin: ... diff --git a/pandas-stubs/core/arrays/_mixins.pyi b/pandas-stubs/core/arrays/_mixins.pyi index c34cbd231..4141b6538 100644 --- a/pandas-stubs/core/arrays/_mixins.pyi +++ b/pandas-stubs/core/arrays/_mixins.pyi @@ -1,5 +1,15 @@ from pandas.core.arrays.base import ExtensionArray +from pandas.core.series import Series +from typing_extensions import Self from pandas._libs.arrays import NDArrayBacked +from pandas._typing import ( + AxisInt, + Scalar, +) -class NDArrayBackedExtensionArray(NDArrayBacked, ExtensionArray): ... +class NDArrayBackedExtensionArray(NDArrayBacked, ExtensionArray): + def argmin(self, axis: AxisInt = 0, skipna: bool = True) -> int: ... + def argmax(self, axis: AxisInt = 0, skipna: bool = True) -> int: ... + def insert(self, loc: int, item: Scalar) -> Self: ... + def value_counts(self, dropna: bool = True) -> Series[int]: ... diff --git a/pandas-stubs/core/arrays/arrow/__init__.pyi b/pandas-stubs/core/arrays/arrow/__init__.pyi index e69de29bb..50274a2de 100644 --- a/pandas-stubs/core/arrays/arrow/__init__.pyi +++ b/pandas-stubs/core/arrays/arrow/__init__.pyi @@ -0,0 +1,7 @@ +from pandas.core.arrays.arrow.accessors import ( + ListAccessor, + StructAccessor, +) +from pandas.core.arrays.arrow.array import ArrowExtensionArray + +__all__ = ["ArrowExtensionArray", "ListAccessor", "StructAccessor"] diff --git a/pandas-stubs/core/arrays/arrow/accessors.pyi b/pandas-stubs/core/arrays/arrow/accessors.pyi new file mode 100644 index 000000000..409d642c7 --- /dev/null +++ b/pandas-stubs/core/arrays/arrow/accessors.pyi @@ -0,0 +1,5 @@ +from abc import ABCMeta + +class ArrowAccessor(metaclass=ABCMeta): ... +class ListAccessor(ArrowAccessor): ... +class StructAccessor(ArrowAccessor): ... diff --git a/pandas-stubs/core/arrays/arrow/array.pyi b/pandas-stubs/core/arrays/arrow/array.pyi new file mode 100644 index 000000000..026fe1955 --- /dev/null +++ b/pandas-stubs/core/arrays/arrow/array.pyi @@ -0,0 +1,7 @@ +from pandas.core.arraylike import OpsMixin +from pandas.core.arrays._arrow_string_mixins import ArrowStringArrayMixin +from pandas.core.arrays.base import ExtensionArraySupportsAnyAll + +class ArrowExtensionArray( + OpsMixin, ExtensionArraySupportsAnyAll, ArrowStringArrayMixin +): ... diff --git a/pandas-stubs/core/arrays/base.pyi b/pandas-stubs/core/arrays/base.pyi index 09bf2b0cb..8814db2c3 100644 --- a/pandas-stubs/core/arrays/base.pyi +++ b/pandas-stubs/core/arrays/base.pyi @@ -85,7 +85,7 @@ class ExtensionArray: ) -> np.intp: ... def factorize(self, use_na_sentinel: bool = True) -> tuple[np_1darray, Self]: ... def repeat( - self, repeats: int | AnyArrayLikeInt | Sequence[int], axis: None = None + self, repeats: int | Sequence[int] | AnyArrayLikeInt, axis: None = None ) -> Self: ... def take( self, @@ -112,6 +112,8 @@ class ExtensionArray: **kwargs: Any, ) -> Self: ... +class ExtensionArraySupportsAnyAll(ExtensionArray): ... + class ExtensionOpsMixin: @classmethod def _add_arithmetic_ops(cls) -> None: ... diff --git a/pandas-stubs/core/arrays/floating.pyi b/pandas-stubs/core/arrays/floating.pyi index 78d72f875..682756167 100644 --- a/pandas-stubs/core/arrays/floating.pyi +++ b/pandas-stubs/core/arrays/floating.pyi @@ -1,4 +1,8 @@ -from pandas.core.arrays.numeric import NumericDtype +from pandas.core.arrays.numeric import ( + NumericArray, + NumericDtype, +) class Float32Dtype(NumericDtype): ... class Float64Dtype(NumericDtype): ... +class FloatingArray(NumericArray): ... diff --git a/pandas-stubs/core/arrays/numeric.pyi b/pandas-stubs/core/arrays/numeric.pyi index eacf8825b..5ea899dac 100644 --- a/pandas-stubs/core/arrays/numeric.pyi +++ b/pandas-stubs/core/arrays/numeric.pyi @@ -1,3 +1,11 @@ +from pandas.core.arrays.masked import BaseMaskedArray + +from pandas._libs.properties import cache_readonly + from pandas.core.dtypes.dtypes import BaseMaskedDtype class NumericDtype(BaseMaskedDtype): ... + +class NumericArray(BaseMaskedArray): + @cache_readonly + def dtype(self) -> NumericDtype: ... diff --git a/pandas-stubs/core/arrays/period.pyi b/pandas-stubs/core/arrays/period.pyi index 5eaf014dc..783702ce3 100644 --- a/pandas-stubs/core/arrays/period.pyi +++ b/pandas-stubs/core/arrays/period.pyi @@ -1,3 +1,5 @@ +from collections.abc import Sequence + from pandas import PeriodDtype from pandas.core.arrays.datetimelike import ( DatelikeOps, @@ -5,8 +7,13 @@ from pandas.core.arrays.datetimelike import ( ) from pandas._libs.tslibs import Timestamp +from pandas._libs.tslibs.offsets import ( + BaseOffset, + Tick, +) from pandas._libs.tslibs.period import Period from pandas._typing import ( + AnyArrayLike, NpDtype, PeriodFrequency, np_1darray, @@ -47,3 +54,9 @@ class PeriodArray(DatetimeLikeArrayMixin, DatelikeOps): self, freq: PeriodFrequency | None = None, how: str = ... ) -> Timestamp: ... def asfreq(self, freq: str | None = ..., how: str = "E") -> Period: ... + +def period_array( + data: Sequence[Period | str | None] | AnyArrayLike, + freq: str | Tick | BaseOffset | None = None, + copy: bool = False, +) -> PeriodArray: ... diff --git a/pandas-stubs/core/arrays/string_.pyi b/pandas-stubs/core/arrays/string_.pyi index 845870de7..556c92436 100644 --- a/pandas-stubs/core/arrays/string_.pyi +++ b/pandas-stubs/core/arrays/string_.pyi @@ -1,6 +1,7 @@ from typing import Literal -from pandas.core.arrays import PandasArray +from pandas.core.arrays.base import ExtensionArray +from pandas.core.arrays.numpy_ import NumpyExtensionArray from pandas._libs.missing import NAType @@ -11,7 +12,9 @@ class StringDtype(ExtensionDtype): @property def na_value(self) -> NAType: ... -class StringArray(PandasArray): +class BaseStringArray(ExtensionArray): ... + +class StringArray(BaseStringArray, NumpyExtensionArray): def __init__(self, values, copy: bool = ...) -> None: ... def __arrow_array__(self, type=...): ... def __setitem__(self, key, value) -> None: ... diff --git a/pandas-stubs/core/arrays/string_arrow.pyi b/pandas-stubs/core/arrays/string_arrow.pyi new file mode 100644 index 000000000..20be1de04 --- /dev/null +++ b/pandas-stubs/core/arrays/string_arrow.pyi @@ -0,0 +1,7 @@ +from pandas.core.arrays.arrow.array import ArrowExtensionArray +from pandas.core.arrays.string_ import BaseStringArray +from pandas.core.strings.object_array import ObjectStringArrayMixin + +class ArrowStringArray( + ObjectStringArrayMixin, ArrowExtensionArray, BaseStringArray +): ... From 1ec94470a69a6be97f305ba7c62fc80c6c2f2060 Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Tue, 4 Nov 2025 12:45:15 +0100 Subject: [PATCH 3/9] removed disappeared classes --- pandas-stubs/core/arrays/numpy_.pyi | 15 --------------- 1 file changed, 15 deletions(-) diff --git a/pandas-stubs/core/arrays/numpy_.pyi b/pandas-stubs/core/arrays/numpy_.pyi index 96a7a72a3..afe191746 100644 --- a/pandas-stubs/core/arrays/numpy_.pyi +++ b/pandas-stubs/core/arrays/numpy_.pyi @@ -1,22 +1,7 @@ -import numpy as np -from numpy.lib.mixins import NDArrayOperatorsMixin from pandas.core.arraylike import OpsMixin from pandas.core.arrays._mixins import NDArrayBackedExtensionArray -from pandas.core.arrays.base import ( - ExtensionArray, - ExtensionOpsMixin, -) from pandas.core.strings.object_array import ObjectStringArrayMixin -from pandas.core.dtypes.dtypes import ExtensionDtype - -class PandasDtype(ExtensionDtype): - @property - def numpy_dtype(self) -> np.dtype: ... - @property - def itemsize(self) -> int: ... - -class PandasArray(ExtensionArray, ExtensionOpsMixin, NDArrayOperatorsMixin): ... class NumpyExtensionArray( OpsMixin, NDArrayBackedExtensionArray, ObjectStringArrayMixin ): ... From 759079d6f58821171263f5bd1790b1dc86a7f33e Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Tue, 4 Nov 2025 12:54:20 +0100 Subject: [PATCH 4/9] fixup --- pandas-stubs/arrays/__init__.pyi | 39 ++++++++++++++++++++++++-------- 1 file changed, 29 insertions(+), 10 deletions(-) diff --git a/pandas-stubs/arrays/__init__.pyi b/pandas-stubs/arrays/__init__.pyi index 8dd78cc95..f7199f86e 100644 --- a/pandas-stubs/arrays/__init__.pyi +++ b/pandas-stubs/arrays/__init__.pyi @@ -1,12 +1,31 @@ from pandas.core.arrays import ( - BooleanArray as BooleanArray, - Categorical as Categorical, - DatetimeArray as DatetimeArray, - IntegerArray as IntegerArray, - IntervalArray as IntervalArray, - PandasArray as PandasArray, - PeriodArray as PeriodArray, - SparseArray as SparseArray, - StringArray as StringArray, - TimedeltaArray as TimedeltaArray, + ArrowExtensionArray, + ArrowStringArray, + BooleanArray, + Categorical, + DatetimeArray, + FloatingArray, + IntegerArray, + IntervalArray, + NumpyExtensionArray, + PeriodArray, + SparseArray, + StringArray, + TimedeltaArray, ) + +__all__ = [ + "ArrowExtensionArray", + "ArrowStringArray", + "BooleanArray", + "Categorical", + "DatetimeArray", + "FloatingArray", + "IntegerArray", + "IntervalArray", + "NumpyExtensionArray", + "PeriodArray", + "SparseArray", + "StringArray", + "TimedeltaArray", +] From 8173ca382d5c24b338311368ce679c0e619c81b5 Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Mon, 10 Nov 2025 13:25:07 +0100 Subject: [PATCH 5/9] remove internal APIs and add tests --- pandas-stubs/core/arrays/boolean.pyi | 23 ++++-- pandas-stubs/core/arrays/datetimes.pyi | 90 ++++++----------------- pandas-stubs/core/arrays/timedeltas.pyi | 76 +++++++------------- pandas-stubs/core/construction.pyi | 95 +++++++++++++++++++++++-- tests/arrays/test_arrays.py | 12 ---- tests/arrays/test_boolean_arrays.py | 13 ++++ tests/arrays/test_integer_arrays.py | 13 ++++ 7 files changed, 178 insertions(+), 144 deletions(-) delete mode 100644 tests/arrays/test_arrays.py create mode 100644 tests/arrays/test_boolean_arrays.py create mode 100644 tests/arrays/test_integer_arrays.py diff --git a/pandas-stubs/core/arrays/boolean.pyi b/pandas-stubs/core/arrays/boolean.pyi index 224bae066..b26dae7da 100644 --- a/pandas-stubs/core/arrays/boolean.pyi +++ b/pandas-stubs/core/arrays/boolean.pyi @@ -1,7 +1,10 @@ -from typing import Any +from collections.abc import Sequence import numpy as np from pandas.core.arrays.masked import BaseMaskedArray as BaseMaskedArray +from pandas.core.indexes.base import Index +from pandas.core.series import Series +from typing_extensions import Self from pandas._libs.missing import NAType from pandas._typing import type_t @@ -16,10 +19,18 @@ class BooleanDtype(ExtensionDtype): class BooleanArray(BaseMaskedArray): def __init__( - self, values: np.ndarray, mask: np.ndarray, copy: bool = ... + self, + values: ( + Sequence[bool | np.bool] + | np.typing.NDArray[np.bool] + | Index[bool] + | Series[bool] + | Self + ), + mask: np.ndarray, + copy: bool = False, ) -> 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( # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride] + self, + ) -> np.dtypes.BoolDType: ... diff --git a/pandas-stubs/core/arrays/datetimes.pyi b/pandas-stubs/core/arrays/datetimes.pyi index 8067b195f..3932eb452 100644 --- a/pandas-stubs/core/arrays/datetimes.pyi +++ b/pandas-stubs/core/arrays/datetimes.pyi @@ -1,4 +1,5 @@ -from datetime import tzinfo as _tzinfo +from collections.abc import Sequence +from datetime import datetime import numpy as np from pandas.core.arrays.datetimelike import ( @@ -6,78 +7,27 @@ from pandas.core.arrays.datetimelike import ( DatetimeLikeArrayMixin, TimelikeOps, ) +from pandas.core.indexes.datetimes import DatetimeIndex +from pandas.core.series import Series +from typing_extensions import Self -from pandas._typing import ( - TimeAmbiguous, - TimeNonexistent, - TimeZones, -) - -from pandas.core.dtypes.dtypes import DatetimeTZDtype as DatetimeTZDtype +from pandas._libs.tslibs.timestamps import Timestamp class DatetimeArray(DatetimeLikeArrayMixin, TimelikeOps, DatelikeOps): __array_priority__: int = ... - def __init__(self, values, dtype=..., freq=..., copy: bool = ...) -> None: ... - # ignore in dtype() is from the pandas source - @property - def dtype(self) -> np.dtype | 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 tz_localize( + def __init__( 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=...): ... - @property - def time(self): ... - @property - def timetz(self): ... + values: ( + Sequence[datetime | np.datetime64] + | np.typing.NDArray[np.datetime64] + | DatetimeIndex + | Series[Timestamp] + | Self + ), + dtype: np.dtype | None = None, + copy: bool = False, + ) -> None: ... @property - def date(self): ... - year = ... - month = ... - day = ... - hour = ... - minute = ... - second = ... - microsecond = ... - nanosecond = ... - dayofweek = ... - weekday = ... - dayofyear = ... - quarter = ... - days_in_month = ... - daysinmonth = ... - is_month_start = ... - is_month_end = ... - is_quarter_start = ... - is_quarter_end = ... - is_year_start = ... - is_year_end = ... - is_leap_year = ... - def to_julian_date(self): ... - -def objects_to_datetime64ns( - data, - dayfirst, - yearfirst, - utc: bool = ..., - errors: str = ..., - require_iso8601: bool = ..., - allow_object: bool = ..., -): ... + def dtype( # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride] + self, + ) -> np.dtypes.DateTime64DType: ... diff --git a/pandas-stubs/core/arrays/timedeltas.pyi b/pandas-stubs/core/arrays/timedeltas.pyi index fd0d71c99..1994bcaca 100644 --- a/pandas-stubs/core/arrays/timedeltas.pyi +++ b/pandas-stubs/core/arrays/timedeltas.pyi @@ -1,64 +1,38 @@ from collections.abc import Sequence from datetime import timedelta +import numpy as np from pandas.core.arrays.datetimelike import ( DatetimeLikeArrayMixin, TimelikeOps, ) +from pandas.core.indexes.timedeltas import TimedeltaIndex +from pandas.core.series import Series +from typing_extensions import Self + +from pandas._libs.tslibs.timedeltas import Timedelta +from pandas._typing import np_1darray + +from pandas.core.dtypes.base import ExtensionDtype class TimedeltaArray(DatetimeLikeArrayMixin, TimelikeOps): __array_priority__: int = ... @property - def dtype(self): ... - def __init__(self, values, dtype=..., freq=..., copy: bool = ...) -> None: ... - def sum( - self, - *, - axis=..., - dtype=..., - out=..., - keepdims: bool = ..., - initial=..., - skipna: bool = ..., - min_count: int = ..., - ): ... - def std( - self, - *, - axis=..., - dtype=..., - out=..., - ddof: int = ..., - keepdims: bool = ..., - skipna: bool = ..., - ): ... - def median( + def dtype( # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride] self, + ) -> np.dtypes.TimeDelta64DType: ... + def __init__(self, values, dtype=..., freq=..., copy: bool = ...) -> None: ... + @classmethod + def _from_sequence( + cls, + data: ( + Sequence[timedelta | np.timedelta64] + | np_1darray[np.timedelta64] + | TimedeltaIndex + | Series[Timedelta] + | Self + ), *, - axis=..., - out=..., - overwrite_input: bool = ..., - keepdims: bool = ..., - skipna: bool = ..., - ): ... - def __mul__(self, other): ... - __rmul__ = ... - def __truediv__(self, other): ... - def __rtruediv__(self, other): ... - def __floordiv__(self, other): ... - def __rfloordiv__(self, other): ... - def __mod__(self, other): ... - def __rmod__(self, other): ... - def __divmod__(self, other): ... - def __rdivmod__(self, other): ... - def __neg__(self): ... - def __pos__(self): ... - def __abs__(self): ... - def total_seconds(self) -> int: ... - def to_pytimedelta(self) -> Sequence[timedelta]: ... - days: int = ... - seconds: int = ... - microseconds: int = ... - nanoseconds: int = ... - @property - def components(self) -> int: ... + dtype: np.dtype | ExtensionDtype | None = None, + copy: bool = True, + ) -> TimedeltaArray: ... diff --git a/pandas-stubs/core/construction.pyi b/pandas-stubs/core/construction.pyi index 2372c1edc..ba43e5365 100644 --- a/pandas-stubs/core/construction.pyi +++ b/pandas-stubs/core/construction.pyi @@ -1,23 +1,108 @@ from collections.abc import Sequence -from typing import overload +from typing import ( + Any, + overload, +) import numpy as np from pandas.core.arrays.base import ExtensionArray +from pandas.core.arrays.boolean import BooleanArray +from pandas.core.arrays.datetimes import DatetimeArray +from pandas.core.arrays.floating import FloatingArray from pandas.core.arrays.integer import IntegerArray +from pandas.core.arrays.numpy_ import NumpyExtensionArray +from pandas.core.arrays.timedeltas import TimedeltaArray +from pandas.core.indexes.base import Index +from pandas.core.indexes.datetimes import DatetimeIndex +from pandas.core.indexes.range import RangeIndex +from pandas.core.indexes.timedeltas import TimedeltaIndex +from pandas.core.series import Series from pandas._libs.missing import NAType +from pandas._libs.tslibs.nattype import NaTType +from pandas._libs.tslibs.timedeltas import Timedelta +from pandas._libs.tslibs.timestamps import Timestamp +from pandas._typing import ( + np_ndarray, + np_ndarray_anyint, + np_ndarray_bool, + np_ndarray_dt, + np_ndarray_float, + np_ndarray_td, +) from pandas.core.dtypes.dtypes import ExtensionDtype @overload -def array( - data: Sequence[int] | Sequence[int | NAType], +def array( # type: ignore[overload-overlap] # pyright: ignore[reportOverlappingOverload] + data: Sequence[NAType | None], + dtype: str | np.dtype | ExtensionDtype | None = None, + copy: bool = True, +) -> NumpyExtensionArray: ... +@overload +def array( # type: ignore[overload-overlap] # pyright: ignore[reportOverlappingOverload] + data: ( + Sequence[bool | np.bool | NAType | None] + | np_ndarray_bool + | BooleanArray + | Index[bool] + | Series[int] + ), + dtype: str | np.dtype | ExtensionDtype | None = None, + copy: bool = True, +) -> BooleanArray: ... +@overload +def array( # type: ignore[overload-overlap] + data: ( + Sequence[int | np.integer | NAType | None] + | np_ndarray_anyint + | IntegerArray + | Index[int] + | RangeIndex + | Series[int] + ), dtype: str | np.dtype | ExtensionDtype | None = None, copy: bool = True, ) -> IntegerArray: ... @overload +def array( # type: ignore[overload-overlap] + data: ( + Sequence[float | np.floating | NAType | None] + | np_ndarray_float + | FloatingArray + | Index[float] + | Series[float] + ), + dtype: str | np.dtype | ExtensionDtype | None = None, + copy: bool = True, +) -> FloatingArray: ... +@overload +def array( # type: ignore[overload-overlap] + data: ( + Sequence[Timestamp | np.datetime64 | NaTType | None] + | np_ndarray_dt + | DatetimeArray + | DatetimeIndex + | Series[Timestamp] + ), + dtype: str | np.dtype | ExtensionDtype | None = None, + copy: bool = True, +) -> DatetimeArray: ... +@overload +def array( # type: ignore[overload-overlap] + data: ( + Sequence[Timedelta | np.timedelta64 | NaTType | None] + | np_ndarray_td + | TimedeltaArray + | TimedeltaIndex + | Series[Timedelta] + ), + dtype: str | np.dtype | ExtensionDtype | None = None, + copy: bool = True, +) -> TimedeltaArray: ... +@overload def array( - data: Sequence[object], + data: Sequence[Any] | np_ndarray | ExtensionArray | Index | Series, dtype: str | np.dtype | ExtensionDtype | None = None, copy: bool = True, -) -> ExtensionArray: ... +) -> NumpyExtensionArray: ... diff --git a/tests/arrays/test_arrays.py b/tests/arrays/test_arrays.py deleted file mode 100644 index fd4cca834..000000000 --- a/tests/arrays/test_arrays.py +++ /dev/null @@ -1,12 +0,0 @@ -from pandas.core.arrays.integer import IntegerArray -from pandas.core.construction import array -from typing_extensions import assert_type - -from pandas._libs.missing import NA - -from tests import check - - -def test_construction() -> None: - check(assert_type(array([1]), IntegerArray), IntegerArray) - check(assert_type(array([1, NA]), IntegerArray), IntegerArray) diff --git a/tests/arrays/test_boolean_arrays.py b/tests/arrays/test_boolean_arrays.py new file mode 100644 index 000000000..33a1835d1 --- /dev/null +++ b/tests/arrays/test_boolean_arrays.py @@ -0,0 +1,13 @@ +import numpy as np +import pandas as pd +from pandas.core.arrays.boolean import BooleanArray +from typing_extensions import assert_type + +from tests import check + + +def test_construction() -> None: + check(assert_type(pd.array([True]), BooleanArray), BooleanArray) + check(assert_type(pd.array([True, np.bool(True)]), BooleanArray), BooleanArray) + check(assert_type(pd.array([True, None]), BooleanArray), BooleanArray) + check(assert_type(pd.array([True, pd.NA]), BooleanArray), BooleanArray) diff --git a/tests/arrays/test_integer_arrays.py b/tests/arrays/test_integer_arrays.py new file mode 100644 index 000000000..3ccee7446 --- /dev/null +++ b/tests/arrays/test_integer_arrays.py @@ -0,0 +1,13 @@ +import numpy as np +import pandas as pd +from pandas.core.arrays.integer import IntegerArray +from typing_extensions import assert_type + +from tests import check + + +def test_construction() -> None: + check(assert_type(pd.array([1]), IntegerArray), IntegerArray) + check(assert_type(pd.array([1, np.int64(1)]), IntegerArray), IntegerArray) + check(assert_type(pd.array([1, None]), IntegerArray), IntegerArray) + check(assert_type(pd.array([1, pd.NA, None]), IntegerArray), IntegerArray) From 039d315288e9dc62f2806ba03709a218cf0e247a Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Mon, 10 Nov 2025 15:40:43 +0100 Subject: [PATCH 6/9] tests --- pandas-stubs/core/construction.pyi | 55 +++++++++++++++-------------- tests/arrays/test_boolean_arrays.py | 4 +++ tests/arrays/test_integer_arrays.py | 9 +++++ 3 files changed, 41 insertions(+), 27 deletions(-) diff --git a/pandas-stubs/core/construction.pyi b/pandas-stubs/core/construction.pyi index ba43e5365..09b6b20eb 100644 --- a/pandas-stubs/core/construction.pyi +++ b/pandas-stubs/core/construction.pyi @@ -1,6 +1,7 @@ from collections.abc import Sequence from typing import ( Any, + Never, overload, ) @@ -23,6 +24,11 @@ from pandas._libs.tslibs.nattype import NaTType from pandas._libs.tslibs.timedeltas import Timedelta from pandas._libs.tslibs.timestamps import Timestamp from pandas._typing import ( + BooleanDtypeArg, + FloatDtypeArg, + IntDtypeArg, + TimedeltaDtypeArg, + TimestampDtypeArg, np_ndarray, np_ndarray_anyint, np_ndarray_bool, @@ -35,45 +41,34 @@ from pandas.core.dtypes.dtypes import ExtensionDtype @overload def array( # type: ignore[overload-overlap] # pyright: ignore[reportOverlappingOverload] + data: Sequence[Never] | Index[Never] | Series[Never], + dtype: str | np.dtype | ExtensionDtype | None = None, + copy: bool = True, +) -> ExtensionArray: ... +@overload +def array( # type: ignore[overload-overlap] data: Sequence[NAType | None], dtype: str | np.dtype | ExtensionDtype | None = None, copy: bool = True, ) -> NumpyExtensionArray: ... @overload -def array( # type: ignore[overload-overlap] # pyright: ignore[reportOverlappingOverload] - data: ( - Sequence[bool | np.bool | NAType | None] - | np_ndarray_bool - | BooleanArray - | Index[bool] - | Series[int] - ), - dtype: str | np.dtype | ExtensionDtype | None = None, +def array( # type: ignore[overload-overlap] + data: Sequence[bool | np.bool | NAType | None] | np_ndarray_bool | BooleanArray, + dtype: BooleanDtypeArg | None = None, copy: bool = True, ) -> BooleanArray: ... @overload def array( # type: ignore[overload-overlap] - data: ( - Sequence[int | np.integer | NAType | None] - | np_ndarray_anyint - | IntegerArray - | Index[int] - | RangeIndex - | Series[int] - ), - dtype: str | np.dtype | ExtensionDtype | None = None, + data: Sequence[int | np.integer | NAType | None] | np_ndarray_anyint | IntegerArray, + dtype: IntDtypeArg | None = None, copy: bool = True, ) -> IntegerArray: ... @overload def array( # type: ignore[overload-overlap] data: ( - Sequence[float | np.floating | NAType | None] - | np_ndarray_float - | FloatingArray - | Index[float] - | Series[float] + Sequence[float | np.floating | NAType | None] | np_ndarray_float | FloatingArray ), - dtype: str | np.dtype | ExtensionDtype | None = None, + dtype: FloatDtypeArg | None = None, copy: bool = True, ) -> FloatingArray: ... @overload @@ -85,7 +80,7 @@ def array( # type: ignore[overload-overlap] | DatetimeIndex | Series[Timestamp] ), - dtype: str | np.dtype | ExtensionDtype | None = None, + dtype: TimestampDtypeArg | None = None, copy: bool = True, ) -> DatetimeArray: ... @overload @@ -97,12 +92,18 @@ def array( # type: ignore[overload-overlap] | TimedeltaIndex | Series[Timedelta] ), - dtype: str | np.dtype | ExtensionDtype | None = None, + dtype: TimedeltaDtypeArg | None = None, copy: bool = True, ) -> TimedeltaArray: ... @overload def array( - data: Sequence[Any] | np_ndarray | ExtensionArray | Index | Series, + data: Sequence[object] | np.typing.NDArray[np.object_] | RangeIndex, dtype: str | np.dtype | ExtensionDtype | None = None, copy: bool = True, ) -> NumpyExtensionArray: ... +@overload +def array( + data: Sequence[Any] | np_ndarray | ExtensionArray | Index[Any] | Series[Any], + dtype: str | np.dtype | ExtensionDtype | None = None, + copy: bool = True, +) -> ExtensionArray: ... diff --git a/tests/arrays/test_boolean_arrays.py b/tests/arrays/test_boolean_arrays.py index 33a1835d1..5d7344c25 100644 --- a/tests/arrays/test_boolean_arrays.py +++ b/tests/arrays/test_boolean_arrays.py @@ -11,3 +11,7 @@ def test_construction() -> None: check(assert_type(pd.array([True, np.bool(True)]), BooleanArray), BooleanArray) check(assert_type(pd.array([True, None]), BooleanArray), BooleanArray) check(assert_type(pd.array([True, pd.NA]), BooleanArray), BooleanArray) + + check(assert_type(pd.array(np.array([1], np.bool_)), BooleanArray), BooleanArray) + + check(assert_type(pd.array(pd.array([True])), BooleanArray), BooleanArray) diff --git a/tests/arrays/test_integer_arrays.py b/tests/arrays/test_integer_arrays.py index 3ccee7446..a8a3d574f 100644 --- a/tests/arrays/test_integer_arrays.py +++ b/tests/arrays/test_integer_arrays.py @@ -11,3 +11,12 @@ def test_construction() -> None: check(assert_type(pd.array([1, np.int64(1)]), IntegerArray), IntegerArray) check(assert_type(pd.array([1, None]), IntegerArray), IntegerArray) check(assert_type(pd.array([1, pd.NA, None]), IntegerArray), IntegerArray) + + check( + assert_type( # type: ignore[assert-type] # I do not understand + pd.array(np.array([1], np.int64)), IntegerArray + ), + IntegerArray, + ) + + check(assert_type(pd.array(pd.array([1])), IntegerArray), IntegerArray) From 5370fc4fc1ca134d15943daaa9d01af48ba51417 Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Mon, 10 Nov 2025 16:03:59 +0100 Subject: [PATCH 7/9] more overloads --- pandas-stubs/core/arrays/integer.pyi | 9 +++- pandas-stubs/core/construction.pyi | 64 +++++++++++++++++++++++++++- 2 files changed, 70 insertions(+), 3 deletions(-) diff --git a/pandas-stubs/core/arrays/integer.pyi b/pandas-stubs/core/arrays/integer.pyi index a32233414..3ed2b5d2f 100644 --- a/pandas-stubs/core/arrays/integer.pyi +++ b/pandas-stubs/core/arrays/integer.pyi @@ -1,3 +1,4 @@ +import numpy as np from pandas.core.arrays.masked import BaseMaskedArray from pandas._libs.missing import NAType @@ -16,8 +17,12 @@ class _IntegerDtype(ExtensionDtype): class IntegerArray(BaseMaskedArray): @property def dtype(self) -> _IntegerDtype: ... - def __init__(self, values, mask, copy: bool = ...) -> None: ... - def __setitem__(self, key, value) -> None: ... + def __init__( + self, + values: np.typing.NDArray[np.integer], + mask: np.typing.NDArray[np.bool], + copy: bool = False, + ) -> None: ... class Int8Dtype(_IntegerDtype): ... class Int16Dtype(_IntegerDtype): ... diff --git a/pandas-stubs/core/construction.pyi b/pandas-stubs/core/construction.pyi index 09b6b20eb..bdf141811 100644 --- a/pandas-stubs/core/construction.pyi +++ b/pandas-stubs/core/construction.pyi @@ -6,27 +6,43 @@ from typing import ( ) import numpy as np +from pandas.core.arrays.arrow.array import ArrowExtensionArray from pandas.core.arrays.base import ExtensionArray from pandas.core.arrays.boolean import BooleanArray +from pandas.core.arrays.categorical import Categorical from pandas.core.arrays.datetimes import DatetimeArray from pandas.core.arrays.floating import FloatingArray from pandas.core.arrays.integer import IntegerArray +from pandas.core.arrays.interval import IntervalArray from pandas.core.arrays.numpy_ import NumpyExtensionArray +from pandas.core.arrays.period import PeriodArray +from pandas.core.arrays.sparse.array import SparseArray +from pandas.core.arrays.string_ import StringArray from pandas.core.arrays.timedeltas import TimedeltaArray from pandas.core.indexes.base import Index +from pandas.core.indexes.category import CategoricalIndex from pandas.core.indexes.datetimes import DatetimeIndex +from pandas.core.indexes.interval import IntervalIndex +from pandas.core.indexes.period import PeriodIndex from pandas.core.indexes.range import RangeIndex from pandas.core.indexes.timedeltas import TimedeltaIndex from pandas.core.series import Series +from pandas._libs.interval import Interval from pandas._libs.missing import NAType +from pandas._libs.sparse import SparseIndex from pandas._libs.tslibs.nattype import NaTType +from pandas._libs.tslibs.period import Period from pandas._libs.tslibs.timedeltas import Timedelta from pandas._libs.tslibs.timestamps import Timestamp from pandas._typing import ( BooleanDtypeArg, + CategoryDtypeArg, FloatDtypeArg, IntDtypeArg, + IntervalT, + SequenceNotStr, + StrDtypeArg, TimedeltaDtypeArg, TimestampDtypeArg, np_ndarray, @@ -34,10 +50,15 @@ from pandas._typing import ( np_ndarray_bool, np_ndarray_dt, np_ndarray_float, + np_ndarray_str, np_ndarray_td, ) -from pandas.core.dtypes.dtypes import ExtensionDtype +from pandas.core.dtypes.dtypes import ( + ExtensionDtype, + IntervalDtype, + PeriodDtype, +) @overload def array( # type: ignore[overload-overlap] # pyright: ignore[reportOverlappingOverload] @@ -96,12 +117,53 @@ def array( # type: ignore[overload-overlap] copy: bool = True, ) -> TimedeltaArray: ... @overload +def array( + data: SequenceNotStr[str | np.str_ | NAType | None] | np_ndarray_str | StringArray, + dtype: StrDtypeArg | None = None, + copy: bool = True, +) -> StringArray: ... +@overload +def array( # type: ignore[overload-overlap] # pyright: ignore[reportOverlappingOverload] + data: Sequence[Period | NAType | None] | PeriodArray | PeriodIndex | Series[Period], + dtype: PeriodDtype | None = None, + copy: bool = True, +) -> PeriodIndex: ... +@overload +def array( # type: ignore[overload-overlap] + data: ( + Sequence[IntervalT | NAType | None] + | IntervalIndex + | Series[Interval] + | IntervalArray + ), + dtype: IntervalDtype | None = None, + copy: bool = True, +) -> IntervalArray: ... +@overload +def array( + data: Categorical | CategoricalIndex, + dtype: CategoryDtypeArg | None = None, + copy: bool = True, +) -> Categorical: ... +@overload def array( data: Sequence[object] | np.typing.NDArray[np.object_] | RangeIndex, dtype: str | np.dtype | ExtensionDtype | None = None, copy: bool = True, ) -> NumpyExtensionArray: ... @overload +def array( # type: ignore[overload-overlap] + data: SparseArray | SparseIndex, + dtype: str | np.dtype | ExtensionDtype | None = None, + copy: bool = True, +) -> SparseIndex: ... +@overload +def array( + data: ArrowExtensionArray, + dtype: str | np.dtype | ExtensionDtype | None = None, + copy: bool = True, +) -> ArrowExtensionArray: ... +@overload def array( data: Sequence[Any] | np_ndarray | ExtensionArray | Index[Any] | Series[Any], dtype: str | np.dtype | ExtensionDtype | None = None, From 9766fa31b80d40246dc541f7bcb3f24e66d4f39c Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Mon, 10 Nov 2025 17:06:00 +0100 Subject: [PATCH 8/9] more tests --- pandas-stubs/core/construction.pyi | 11 ++++-- ...oolean_arrays.py => test_boolean_array.py} | 2 +- tests/arrays/test_datetime_array.py | 34 +++++++++++++++++++ tests/arrays/test_floating_array.py | 22 ++++++++++++ ...nteger_arrays.py => test_integer_array.py} | 2 +- 5 files changed, 66 insertions(+), 5 deletions(-) rename tests/arrays/{test_boolean_arrays.py => test_boolean_array.py} (95%) create mode 100644 tests/arrays/test_datetime_array.py create mode 100644 tests/arrays/test_floating_array.py rename tests/arrays/{test_integer_arrays.py => test_integer_array.py} (95%) diff --git a/pandas-stubs/core/construction.pyi b/pandas-stubs/core/construction.pyi index bdf141811..9b51e20f6 100644 --- a/pandas-stubs/core/construction.pyi +++ b/pandas-stubs/core/construction.pyi @@ -1,7 +1,10 @@ from collections.abc import Sequence +from datetime import ( + datetime, + timedelta, +) from typing import ( Any, - Never, overload, ) @@ -27,6 +30,7 @@ from pandas.core.indexes.period import PeriodIndex from pandas.core.indexes.range import RangeIndex from pandas.core.indexes.timedeltas import TimedeltaIndex from pandas.core.series import Series +from typing_extensions import Never from pandas._libs.interval import Interval from pandas._libs.missing import NAType @@ -95,7 +99,8 @@ def array( # type: ignore[overload-overlap] @overload def array( # type: ignore[overload-overlap] data: ( - Sequence[Timestamp | np.datetime64 | NaTType | None] + Sequence[datetime | NaTType | None] + | Sequence[np.datetime64 | NaTType | None] | np_ndarray_dt | DatetimeArray | DatetimeIndex @@ -107,7 +112,7 @@ def array( # type: ignore[overload-overlap] @overload def array( # type: ignore[overload-overlap] data: ( - Sequence[Timedelta | np.timedelta64 | NaTType | None] + Sequence[timedelta | np.timedelta64 | NaTType | None] | np_ndarray_td | TimedeltaArray | TimedeltaIndex diff --git a/tests/arrays/test_boolean_arrays.py b/tests/arrays/test_boolean_array.py similarity index 95% rename from tests/arrays/test_boolean_arrays.py rename to tests/arrays/test_boolean_array.py index 5d7344c25..7b3c4c174 100644 --- a/tests/arrays/test_boolean_arrays.py +++ b/tests/arrays/test_boolean_array.py @@ -6,7 +6,7 @@ from tests import check -def test_construction() -> None: +def test_constructor() -> None: check(assert_type(pd.array([True]), BooleanArray), BooleanArray) check(assert_type(pd.array([True, np.bool(True)]), BooleanArray), BooleanArray) check(assert_type(pd.array([True, None]), BooleanArray), BooleanArray) diff --git a/tests/arrays/test_datetime_array.py b/tests/arrays/test_datetime_array.py new file mode 100644 index 000000000..3aeea9530 --- /dev/null +++ b/tests/arrays/test_datetime_array.py @@ -0,0 +1,34 @@ +from datetime import datetime + +import numpy as np +import pandas as pd +from pandas.core.arrays.datetimes import DatetimeArray +from typing_extensions import assert_type + +from tests import check + + +def test_constructor() -> None: + dt = datetime(2025, 11, 10) + check(assert_type(pd.array([dt]), DatetimeArray), DatetimeArray) + check(assert_type(pd.array([dt, pd.Timestamp(dt)]), DatetimeArray), DatetimeArray) + check(assert_type(pd.array([dt, None]), DatetimeArray), DatetimeArray) + check(assert_type(pd.array([dt, pd.NaT, None]), DatetimeArray), DatetimeArray) + + np_dt = np.datetime64(dt) + check(assert_type(pd.array([np_dt]), DatetimeArray), DatetimeArray) + check(assert_type(pd.array([np_dt, None]), DatetimeArray), DatetimeArray) + check(assert_type(pd.array([np_dt, pd.NaT]), DatetimeArray), DatetimeArray) + + check( + assert_type( # type: ignore[assert-type] # I do not understand + pd.array(np.array([dt], np.datetime64)), DatetimeArray + ), + DatetimeArray, + ) + + check(assert_type(pd.array(pd.array([dt])), DatetimeArray), DatetimeArray) + + check(assert_type(pd.array(pd.Index([dt])), DatetimeArray), DatetimeArray) + + check(assert_type(pd.array(pd.Series([dt])), DatetimeArray), DatetimeArray) diff --git a/tests/arrays/test_floating_array.py b/tests/arrays/test_floating_array.py new file mode 100644 index 000000000..e274ad46e --- /dev/null +++ b/tests/arrays/test_floating_array.py @@ -0,0 +1,22 @@ +import numpy as np +import pandas as pd +from pandas.core.arrays.floating import FloatingArray +from typing_extensions import assert_type + +from tests import check + + +def test_constructor() -> None: + check(assert_type(pd.array([1.0]), FloatingArray), FloatingArray) + check(assert_type(pd.array([1.0, np.float64(1)]), FloatingArray), FloatingArray) + check(assert_type(pd.array([1.0, None]), FloatingArray), FloatingArray) + check(assert_type(pd.array([1.0, pd.NA, None]), FloatingArray), FloatingArray) + + check( + assert_type( # type: ignore[assert-type] # I do not understand + pd.array(np.array([1.0], np.float64)), FloatingArray + ), + FloatingArray, + ) + + check(assert_type(pd.array(pd.array([1.0])), FloatingArray), FloatingArray) diff --git a/tests/arrays/test_integer_arrays.py b/tests/arrays/test_integer_array.py similarity index 95% rename from tests/arrays/test_integer_arrays.py rename to tests/arrays/test_integer_array.py index a8a3d574f..66733083a 100644 --- a/tests/arrays/test_integer_arrays.py +++ b/tests/arrays/test_integer_array.py @@ -6,7 +6,7 @@ from tests import check -def test_construction() -> None: +def test_constructor() -> None: check(assert_type(pd.array([1]), IntegerArray), IntegerArray) check(assert_type(pd.array([1, np.int64(1)]), IntegerArray), IntegerArray) check(assert_type(pd.array([1, None]), IntegerArray), IntegerArray) From 0f030005535b2072df568e241a9dfb12bd47e943 Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Mon, 10 Nov 2025 18:13:00 +0100 Subject: [PATCH 9/9] mypy --- tests/arrays/test_datetime_array.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/tests/arrays/test_datetime_array.py b/tests/arrays/test_datetime_array.py index 3aeea9530..10e36a7f7 100644 --- a/tests/arrays/test_datetime_array.py +++ b/tests/arrays/test_datetime_array.py @@ -1,10 +1,13 @@ from datetime import datetime +from typing import cast import numpy as np import pandas as pd from pandas.core.arrays.datetimes import DatetimeArray from typing_extensions import assert_type +from pandas._libs.tslibs.nattype import NaTType + from tests import check @@ -18,7 +21,8 @@ def test_constructor() -> None: np_dt = np.datetime64(dt) check(assert_type(pd.array([np_dt]), DatetimeArray), DatetimeArray) check(assert_type(pd.array([np_dt, None]), DatetimeArray), DatetimeArray) - check(assert_type(pd.array([np_dt, pd.NaT]), DatetimeArray), DatetimeArray) + dt_nat = cast(list[np.datetime64 | NaTType], [np_dt, pd.NaT]) + check(assert_type(pd.array(dt_nat), DatetimeArray), DatetimeArray) check( assert_type( # type: ignore[assert-type] # I do not understand