Merge branch 'pandas-scalars' of github.com:bashtage/pandas-stubs into pandas-scalars

Author: bashtage

pandas-stubs/_libs/interval.pyi

@@ -63,8 +63,10 @@ class Interval(IntervalMixin, Generic[_OrderableT]):
     def right(self: Interval[_OrderableT]) -> _OrderableT: ...
     @property
     def closed(self) -> IntervalClosedType: ...
-    mid: _MidDescriptor
-    length: _LengthDescriptor
+    @property
+    def mid(self) -> _MidDescriptor: ...
+    @property
+    def length(self) -> _LengthDescriptor: ...
     def __init__(
         self,
         left: _OrderableT,
@@ -142,10 +144,6 @@ class Interval(IntervalMixin, Generic[_OrderableT]):
     def __floordiv__(self: Interval[float], y: float) -> Interval[float]: ...
     def overlaps(self: Interval[_OrderableT], other: Interval[_OrderableT]) -> bool: ...
 
-def intervals_to_interval_bounds(
-    intervals: np.ndarray, validate_closed: bool = ...
-) -> tuple[np.ndarray, np.ndarray, str]: ...
-
 class IntervalTree(IntervalMixin):
     def __init__(
         self,

pandas-stubs/_typing.pyi

@@ -223,7 +223,7 @@ IndexT = TypeVar("IndexT", bound=Index)
 
 IntervalClosedType: TypeAlias = Literal["left", "right", "both", "neither"]
 
-DateTimeErrorChoices: TypeAlias = Literal["ignore", "raise", "coerce"]
+IgnoreRaiseCoerce: TypeAlias = Literal["ignore", "raise", "coerce"]
 
 # Shared by functions such as drop and astype
 IgnoreRaise: TypeAlias = Literal["ignore", "raise"]

pandas-stubs/core/tools/datetimes.pyi

@@ -26,9 +26,9 @@ from typing_extensions import TypeAlias
 from pandas._libs.tslibs import NaTType
 from pandas._typing import (
     AnyArrayLike,
-    DateTimeErrorChoices,
     DictConvertible,
     IgnoreRaise,
+    IgnoreRaiseCoerce,
     TimestampConvertibleTypes,
     npt,
 )
@@ -70,7 +70,7 @@ def to_datetime(
 @overload
 def to_datetime(
     arg: Series | DictConvertible,
-    errors: DateTimeErrorChoices = ...,
+    errors: IgnoreRaiseCoerce = ...,
     dayfirst: bool = ...,
     yearfirst: bool = ...,
     utc: bool | None = ...,
@@ -91,7 +91,7 @@ def to_datetime(
     | npt.NDArray[np.int_]
     | Index
     | ExtensionArray,
-    errors: DateTimeErrorChoices = ...,
+    errors: IgnoreRaiseCoerce = ...,
     dayfirst: bool = ...,
     yearfirst: bool = ...,
     utc: bool | None = ...,

pandas-stubs/core/tools/numeric.pyi

@@ -1 +1,42 @@
-def to_numeric(arg, errors: str = ..., downcast=...): ...
+from typing import (
+    Literal,
+    Union,
+    overload,
+)
+
+import numpy as np
+import pandas as pd
+from typing_extensions import TypeAlias
+
+from pandas._typing import (
+    IgnoreRaiseCoerce,
+    Scalar,
+    npt,
+)
+
+_Downcast: TypeAlias = Union[Literal["integer", "signed", "unsigned", "float"], None]
+
+@overload
+def to_numeric(
+    arg: Scalar,
+    errors: Literal["raise", "coerce"] = ...,
+    downcast: _Downcast = ...,
+) -> float: ...
+@overload
+def to_numeric(
+    arg: Scalar,
+    errors: Literal["ignore"],
+    downcast: _Downcast = ...,
+) -> Scalar: ...
+@overload
+def to_numeric(
+    arg: list | tuple | np.ndarray,
+    errors: IgnoreRaiseCoerce = ...,
+    downcast: _Downcast = ...,
+) -> npt.NDArray: ...
+@overload
+def to_numeric(
+    arg: pd.Series,
+    errors: IgnoreRaiseCoerce = ...,
+    downcast: _Downcast = ...,
+) -> pd.Series: ...

pandas-stubs/core/tools/timedeltas.pyi

@@ -16,20 +16,20 @@ from pandas._libs.tslibs import Timedelta
 from pandas._libs.tslibs.timedeltas import TimeDeltaUnitChoices
 from pandas._typing import (
     ArrayLike,
-    DateTimeErrorChoices,
+    IgnoreRaiseCoerce,
 )
 
 @overload
 def to_timedelta(
     arg: str | float | timedelta,
     unit: TimeDeltaUnitChoices | None = ...,
-    errors: DateTimeErrorChoices = ...,
+    errors: IgnoreRaiseCoerce = ...,
 ) -> Timedelta: ...
 @overload
 def to_timedelta(
     arg: Series,
     unit: TimeDeltaUnitChoices | None = ...,
-    errors: DateTimeErrorChoices = ...,
+    errors: IgnoreRaiseCoerce = ...,
 ) -> TimedeltaSeries: ...
 @overload
 def to_timedelta(
@@ -40,5 +40,5 @@ def to_timedelta(
     | ArrayLike
     | Index,
     unit: TimeDeltaUnitChoices | None = ...,
-    errors: DateTimeErrorChoices = ...,
+    errors: IgnoreRaiseCoerce = ...,
 ) -> TimedeltaIndex: ...

tests/test_dtypes.py

@@ -0,0 +1,119 @@
+from datetime import (
+    timedelta,
+    timezone,
+)
+
+import numpy as np
+import pandas as pd
+from typing_extensions import assert_type
+
+from tests import check
+
+from pandas.tseries.offsets import (
+    BusinessDay,
+    CustomBusinessDay,
+    Day,
+)
+
+
+def test_datetimetz_dtype() -> None:
+    check(
+        assert_type(pd.DatetimeTZDtype(unit="ns", tz="UTC"), pd.DatetimeTZDtype),
+        pd.DatetimeTZDtype,
+    )
+    check(
+        assert_type(
+            pd.DatetimeTZDtype(unit="ns", tz=timezone(timedelta(hours=1))),
+            pd.DatetimeTZDtype,
+        ),
+        pd.DatetimeTZDtype,
+    )
+
+
+def test_period_dtype() -> None:
+    check(assert_type(pd.PeriodDtype(freq="D"), pd.PeriodDtype), pd.PeriodDtype)
+    check(assert_type(pd.PeriodDtype(freq=Day()), pd.PeriodDtype), pd.PeriodDtype)
+    check(
+        assert_type(pd.PeriodDtype(freq=BusinessDay()), pd.PeriodDtype), pd.PeriodDtype
+    )
+    check(
+        assert_type(pd.PeriodDtype(freq=CustomBusinessDay()), pd.PeriodDtype),
+        pd.PeriodDtype,
+    )
+
+
+def test_interval_dtype() -> None:
+    check(
+        assert_type(
+            pd.Interval(pd.Timestamp("2017-01-01"), pd.Timestamp("2017-01-02")),
+            "pd.Interval[pd.Timestamp]",
+        ),
+        pd.Interval,
+    )
+    check(
+        assert_type(pd.Interval(1, 2, closed="left"), "pd.Interval[int]"), pd.Interval
+    )
+    check(
+        assert_type(pd.Interval(1.0, 2.5, closed="right"), "pd.Interval[float]"),
+        pd.Interval,
+    )
+    check(
+        assert_type(pd.Interval(1.0, 2.5, closed="both"), "pd.Interval[float]"),
+        pd.Interval,
+    )
+    check(
+        assert_type(
+            pd.Interval(
+                pd.Timedelta("1 day"), pd.Timedelta("2 days"), closed="neither"
+            ),
+            "pd.Interval[pd.Timedelta]",
+        ),
+        pd.Interval,
+    )
+
+
+def test_int64_dtype() -> None:
+    check(assert_type(pd.Int64Dtype(), pd.Int64Dtype), pd.Int64Dtype)
+
+
+def test_categorical_dtype() -> None:
+    check(
+        assert_type(
+            pd.CategoricalDtype(categories=["a", "b", "c"], ordered=True),
+            pd.CategoricalDtype,
+        ),
+        pd.CategoricalDtype,
+    )
+    check(
+        assert_type(pd.CategoricalDtype(categories=[1, 2, 3]), pd.CategoricalDtype),
+        pd.CategoricalDtype,
+    )
+
+
+def test_sparse_dtype() -> None:
+    check(assert_type(pd.SparseDtype(str), pd.SparseDtype), pd.SparseDtype)
+    check(assert_type(pd.SparseDtype(complex), pd.SparseDtype), pd.SparseDtype)
+    check(assert_type(pd.SparseDtype(bool), pd.SparseDtype), pd.SparseDtype)
+    check(assert_type(pd.SparseDtype(int), pd.SparseDtype), pd.SparseDtype)
+    check(assert_type(pd.SparseDtype(np.int64), pd.SparseDtype), pd.SparseDtype)
+    check(assert_type(pd.SparseDtype(str), pd.SparseDtype), pd.SparseDtype)
+    check(assert_type(pd.SparseDtype(float), pd.SparseDtype), pd.SparseDtype)
+    check(assert_type(pd.SparseDtype(np.datetime64), pd.SparseDtype), pd.SparseDtype)
+    check(assert_type(pd.SparseDtype(np.timedelta64), pd.SparseDtype), pd.SparseDtype)
+    check(assert_type(pd.SparseDtype("datetime64"), pd.SparseDtype), pd.SparseDtype)
+    check(assert_type(pd.SparseDtype(), pd.SparseDtype), pd.SparseDtype)
+
+
+def test_string_dtype() -> None:
+    check(assert_type(pd.StringDtype("pyarrow"), pd.StringDtype), pd.StringDtype)
+    check(assert_type(pd.StringDtype("python"), pd.StringDtype), pd.StringDtype)
+
+
+def test_boolean_dtype() -> None:
+    check(assert_type(pd.BooleanDtype(), pd.BooleanDtype), pd.BooleanDtype)
+
+
+def test_arrow_dtype() -> None:
+    import pyarrow as pa
+
+    check(assert_type(pd.ArrowDtype(pa.int64()), pd.ArrowDtype), pd.ArrowDtype)

tests/test_pandas.py

@@ -457,6 +457,111 @@ def test_eval():
     )
 
 
+def test_to_numeric_scalar() -> None:
+    check(assert_type(pd.to_numeric(1), float), int)
+    check(assert_type(pd.to_numeric("1.2"), float), float)
+    check(assert_type(pd.to_numeric("blerg", errors="coerce"), float), float)
+    check(assert_type(pd.to_numeric("blerg", errors="ignore"), Scalar), str)
+    check(assert_type(pd.to_numeric(1, downcast="signed"), float), int)
+    check(assert_type(pd.to_numeric(1, downcast="unsigned"), float), int)
+    check(assert_type(pd.to_numeric(1, downcast="float"), float), int)
+    check(assert_type(pd.to_numeric(1, downcast="integer"), float), int)
+
+
+def test_to_numeric_array_like() -> None:
+    check(
+        assert_type(
+            pd.to_numeric([1, 2, 3]),
+            npt.NDArray,
+        ),
+        np.ndarray,
+    )
+    check(
+        assert_type(
+            pd.to_numeric([1.0, 2.0, 3.0]),
+            npt.NDArray,
+        ),
+        np.ndarray,
+    )
+    check(
+        assert_type(
+            pd.to_numeric([1.0, 2.0, "3.0"]),
+            npt.NDArray,
+        ),
+        np.ndarray,
+    )
+    check(
+        assert_type(
+            pd.to_numeric(np.array([1.0, 2.0, "3.0"], dtype=object)),
+            npt.NDArray,
+        ),
+        np.ndarray,
+    )
+    check(
+        assert_type(
+            pd.to_numeric([1.0, 2.0, "blerg"], errors="coerce"),
+            npt.NDArray,
+        ),
+        np.ndarray,
+    )
+    check(
+        assert_type(pd.to_numeric([1.0, 2.0, "blerg"], errors="ignore"), npt.NDArray),
+        np.ndarray,
+    )
+    check(
+        assert_type(
+            pd.to_numeric((1.0, 2.0, 3.0)),
+            npt.NDArray,
+        ),
+        np.ndarray,
+    )
+    check(
+        assert_type(pd.to_numeric([1, 2, 3], downcast="unsigned"), npt.NDArray),
+        np.ndarray,
+    )
+
+
+def test_to_numeric_array_series() -> None:
+    check(
+        assert_type(
+            pd.to_numeric(pd.Series([1, 2, 3])),
+            pd.Series,
+        ),
+        pd.Series,
+    )
+    check(
+        assert_type(
+            pd.to_numeric(pd.Series([1, 2, "blerg"]), errors="coerce"),
+            pd.Series,
+        ),
+        pd.Series,
+    )
+    check(
+        assert_type(
+            pd.to_numeric(pd.Series([1, 2, "blerg"]), errors="ignore"), pd.Series
+        ),
+        pd.Series,
+    )
+    check(
+        assert_type(pd.to_numeric(pd.Series([1, 2, 3]), downcast="signed"), pd.Series),
+        pd.Series,
+    )
+    check(
+        assert_type(
+            pd.to_numeric(pd.Series([1, 2, 3]), downcast="unsigned"), pd.Series
+        ),
+        pd.Series,
+    )
+    check(
+        assert_type(pd.to_numeric(pd.Series([1, 2, 3]), downcast="integer"), pd.Series),
+        pd.Series,
+    )
+    check(
+        assert_type(pd.to_numeric(pd.Series([1, 2, 3]), downcast="float"), pd.Series),
+        pd.Series,
+    )
+
+
 def test_wide_to_long():
     df = pd.DataFrame(
         {