CLN: add typing for dtype arg in core/arrays (GH38808) (#38886)

Author: avinashpancham

pandas/core/arrays/interval.py

@@ -1,7 +1,7 @@
 import operator
 from operator import le, lt
 import textwrap
-from typing import Sequence, Type, TypeVar
+from typing import Optional, Sequence, Type, TypeVar, cast
 
 import numpy as np
 
@@ -14,7 +14,7 @@
     intervals_to_interval_bounds,
 )
 from pandas._libs.missing import NA
-from pandas._typing import ArrayLike
+from pandas._typing import ArrayLike, Dtype, NpDtype
 from pandas.compat.numpy import function as nv
 from pandas.util._decorators import Appender
 
@@ -170,7 +170,7 @@ def __new__(
         cls,
         data,
         closed=None,
-        dtype=None,
+        dtype: Optional[Dtype] = None,
         copy: bool = False,
         verify_integrity: bool = True,
     ):
@@ -212,7 +212,13 @@ def __new__(
 
     @classmethod
     def _simple_new(
-        cls, left, right, closed=None, copy=False, dtype=None, verify_integrity=True
+        cls,
+        left,
+        right,
+        closed=None,
+        copy=False,
+        dtype: Optional[Dtype] = None,
+        verify_integrity=True,
     ):
         result = IntervalMixin.__new__(cls)
 
@@ -223,12 +229,14 @@ def _simple_new(
         if dtype is not None:
             # GH 19262: dtype must be an IntervalDtype to override inferred
             dtype = pandas_dtype(dtype)
-            if not is_interval_dtype(dtype):
+            if is_interval_dtype(dtype):
+                dtype = cast(IntervalDtype, dtype)
+                if dtype.subtype is not None:
+                    left = left.astype(dtype.subtype)
+                    right = right.astype(dtype.subtype)
+            else:
                 msg = f"dtype must be an IntervalDtype, got {dtype}"
                 raise TypeError(msg)
-            elif dtype.subtype is not None:
-                left = left.astype(dtype.subtype)
-                right = right.astype(dtype.subtype)
 
         # coerce dtypes to match if needed
         if is_float_dtype(left) and is_integer_dtype(right):
@@ -279,7 +287,9 @@ def _simple_new(
         return result
 
     @classmethod
-    def _from_sequence(cls, scalars, *, dtype=None, copy=False):
+    def _from_sequence(
+        cls, scalars, *, dtype: Optional[Dtype] = None, copy: bool = False
+    ):
         return cls(scalars, dtype=dtype, copy=copy)
 
     @classmethod
@@ -338,7 +348,9 @@ def _from_factorized(cls, values, original):
             ),
         }
     )
-    def from_breaks(cls, breaks, closed="right", copy=False, dtype=None):
+    def from_breaks(
+        cls, breaks, closed="right", copy: bool = False, dtype: Optional[Dtype] = None
+    ):
         breaks = maybe_convert_platform_interval(breaks)
 
         return cls.from_arrays(breaks[:-1], breaks[1:], closed, copy=copy, dtype=dtype)
@@ -407,7 +419,9 @@ def from_breaks(cls, breaks, closed="right", copy=False, dtype=None):
             ),
         }
     )
-    def from_arrays(cls, left, right, closed="right", copy=False, dtype=None):
+    def from_arrays(
+        cls, left, right, closed="right", copy=False, dtype: Optional[Dtype] = None
+    ):
         left = maybe_convert_platform_interval(left)
         right = maybe_convert_platform_interval(right)
 
@@ -464,7 +478,9 @@ def from_arrays(cls, left, right, closed="right", copy=False, dtype=None):
             ),
         }
     )
-    def from_tuples(cls, data, closed="right", copy=False, dtype=None):
+    def from_tuples(
+        cls, data, closed="right", copy=False, dtype: Optional[Dtype] = None
+    ):
         if len(data):
             left, right = [], []
         else:
@@ -1277,7 +1293,7 @@ def is_non_overlapping_monotonic(self):
     # ---------------------------------------------------------------------
     # Conversion
 
-    def __array__(self, dtype=None) -> np.ndarray:
+    def __array__(self, dtype: Optional[NpDtype] = None) -> np.ndarray:
         """
         Return the IntervalArray's data as a numpy array of Interval
         objects (with dtype='object')

pandas/core/arrays/masked.py

@@ -5,7 +5,7 @@
 import numpy as np
 
 from pandas._libs import lib, missing as libmissing
-from pandas._typing import ArrayLike, Dtype, Scalar
+from pandas._typing import ArrayLike, Dtype, NpDtype, Scalar
 from pandas.errors import AbstractMethodError
 from pandas.util._decorators import cache_readonly, doc
 
@@ -147,7 +147,10 @@ def __invert__(self: BaseMaskedArrayT) -> BaseMaskedArrayT:
         return type(self)(~self._data, self._mask)
 
     def to_numpy(
-        self, dtype=None, copy: bool = False, na_value: Scalar = lib.no_default
+        self,
+        dtype: Optional[NpDtype] = None,
+        copy: bool = False,
+        na_value: Scalar = lib.no_default,
     ) -> np.ndarray:
         """
         Convert to a NumPy Array.
@@ -257,7 +260,7 @@ def astype(self, dtype: Dtype, copy: bool = True) -> ArrayLike:
 
     __array_priority__ = 1000  # higher than ndarray so ops dispatch to us
 
-    def __array__(self, dtype=None) -> np.ndarray:
+    def __array__(self, dtype: Optional[NpDtype] = None) -> np.ndarray:
         """
         the array interface, return my values
         We return an object array here to preserve our scalar values

pandas/core/arrays/numpy_.py

@@ -1,11 +1,11 @@
 import numbers
-from typing import Tuple, Type, Union
+from typing import Optional, Tuple, Type, Union
 
 import numpy as np
 from numpy.lib.mixins import NDArrayOperatorsMixin
 
 from pandas._libs import lib
-from pandas._typing import Scalar
+from pandas._typing import Dtype, NpDtype, Scalar
 from pandas.compat.numpy import function as nv
 
 from pandas.core.dtypes.dtypes import ExtensionDtype
@@ -38,7 +38,7 @@ class PandasDtype(ExtensionDtype):
 
     _metadata = ("_dtype",)
 
-    def __init__(self, dtype: object):
+    def __init__(self, dtype: Optional[NpDtype]):
         self._dtype = np.dtype(dtype)
 
     def __repr__(self) -> str:
@@ -173,7 +173,7 @@ def __init__(self, values: Union[np.ndarray, "PandasArray"], copy: bool = False)
 
     @classmethod
     def _from_sequence(
-        cls, scalars, *, dtype=None, copy: bool = False
+        cls, scalars, *, dtype: Optional[Dtype] = None, copy: bool = False
     ) -> "PandasArray":
         if isinstance(dtype, PandasDtype):
             dtype = dtype._dtype
@@ -200,7 +200,7 @@ def dtype(self) -> PandasDtype:
     # ------------------------------------------------------------------------
     # NumPy Array Interface
 
-    def __array__(self, dtype=None) -> np.ndarray:
+    def __array__(self, dtype: Optional[NpDtype] = None) -> np.ndarray:
         return np.asarray(self._ndarray, dtype=dtype)
 
     _HANDLED_TYPES = (np.ndarray, numbers.Number)
@@ -311,7 +311,15 @@ def prod(self, *, axis=None, skipna=True, min_count=0, **kwargs) -> Scalar:
         )
         return self._wrap_reduction_result(axis, result)
 
-    def mean(self, *, axis=None, dtype=None, out=None, keepdims=False, skipna=True):
+    def mean(
+        self,
+        *,
+        axis=None,
+        dtype: Optional[NpDtype] = None,
+        out=None,
+        keepdims=False,
+        skipna=True,
+    ):
         nv.validate_mean((), {"dtype": dtype, "out": out, "keepdims": keepdims})
         result = nanops.nanmean(self._ndarray, axis=axis, skipna=skipna)
         return self._wrap_reduction_result(axis, result)
@@ -326,7 +334,14 @@ def median(
         return self._wrap_reduction_result(axis, result)
 
     def std(
-        self, *, axis=None, dtype=None, out=None, ddof=1, keepdims=False, skipna=True
+        self,
+        *,
+        axis=None,
+        dtype: Optional[NpDtype] = None,
+        out=None,
+        ddof=1,
+        keepdims=False,
+        skipna=True,
     ):
         nv.validate_stat_ddof_func(
             (), {"dtype": dtype, "out": out, "keepdims": keepdims}, fname="std"
@@ -335,7 +350,14 @@ def std(
         return self._wrap_reduction_result(axis, result)
 
     def var(
-        self, *, axis=None, dtype=None, out=None, ddof=1, keepdims=False, skipna=True
+        self,
+        *,
+        axis=None,
+        dtype: Optional[NpDtype] = None,
+        out=None,
+        ddof=1,
+        keepdims=False,
+        skipna=True,
     ):
         nv.validate_stat_ddof_func(
             (), {"dtype": dtype, "out": out, "keepdims": keepdims}, fname="var"
@@ -344,22 +366,45 @@ def var(
         return self._wrap_reduction_result(axis, result)
 
     def sem(
-        self, *, axis=None, dtype=None, out=None, ddof=1, keepdims=False, skipna=True
+        self,
+        *,
+        axis=None,
+        dtype: Optional[NpDtype] = None,
+        out=None,
+        ddof=1,
+        keepdims=False,
+        skipna=True,
     ):
         nv.validate_stat_ddof_func(
             (), {"dtype": dtype, "out": out, "keepdims": keepdims}, fname="sem"
         )
         result = nanops.nansem(self._ndarray, axis=axis, skipna=skipna, ddof=ddof)
         return self._wrap_reduction_result(axis, result)
 
-    def kurt(self, *, axis=None, dtype=None, out=None, keepdims=False, skipna=True):
+    def kurt(
+        self,
+        *,
+        axis=None,
+        dtype: Optional[NpDtype] = None,
+        out=None,
+        keepdims=False,
+        skipna=True,
+    ):
         nv.validate_stat_ddof_func(
             (), {"dtype": dtype, "out": out, "keepdims": keepdims}, fname="kurt"
         )
         result = nanops.nankurt(self._ndarray, axis=axis, skipna=skipna)
         return self._wrap_reduction_result(axis, result)
 
-    def skew(self, *, axis=None, dtype=None, out=None, keepdims=False, skipna=True):
+    def skew(
+        self,
+        *,
+        axis=None,
+        dtype: Optional[NpDtype] = None,
+        out=None,
+        keepdims=False,
+        skipna=True,
+    ):
         nv.validate_stat_ddof_func(
             (), {"dtype": dtype, "out": out, "keepdims": keepdims}, fname="skew"
         )
@@ -370,7 +415,10 @@ def skew(self, *, axis=None, dtype=None, out=None, keepdims=False, skipna=True):
     # Additional Methods
 
     def to_numpy(
-        self, dtype=None, copy: bool = False, na_value=lib.no_default
+        self,
+        dtype: Optional[NpDtype] = None,
+        copy: bool = False,
+        na_value=lib.no_default,
     ) -> np.ndarray:
         result = np.asarray(self._ndarray, dtype=dtype)
 

pandas/core/arrays/period.py

@@ -27,7 +27,7 @@
     get_period_field_arr,
     period_asfreq_arr,
 )
-from pandas._typing import AnyArrayLike, Dtype
+from pandas._typing import AnyArrayLike, Dtype, NpDtype
 from pandas.util._decorators import cache_readonly, doc
 
 from pandas.core.dtypes.common import (
@@ -160,7 +160,7 @@ class PeriodArray(PeriodMixin, dtl.DatelikeOps):
     # --------------------------------------------------------------------
     # Constructors
 
-    def __init__(self, values, dtype=None, freq=None, copy=False):
+    def __init__(self, values, dtype: Optional[Dtype] = None, freq=None, copy=False):
         freq = validate_dtype_freq(dtype, freq)
 
         if freq is not None:
@@ -187,7 +187,10 @@ def __init__(self, values, dtype=None, freq=None, copy=False):
 
     @classmethod
     def _simple_new(
-        cls, values: np.ndarray, freq: Optional[BaseOffset] = None, dtype=None
+        cls,
+        values: np.ndarray,
+        freq: Optional[BaseOffset] = None,
+        dtype: Optional[Dtype] = None,
     ) -> "PeriodArray":
         # alias for PeriodArray.__init__
         assertion_msg = "Should be numpy array of type i8"
@@ -221,7 +224,7 @@ def _from_sequence(
 
     @classmethod
     def _from_sequence_of_strings(
-        cls, strings, *, dtype=None, copy=False
+        cls, strings, *, dtype: Optional[Dtype] = None, copy=False
     ) -> "PeriodArray":
         return cls._from_sequence(strings, dtype=dtype, copy=copy)
 
@@ -302,7 +305,7 @@ def freq(self) -> BaseOffset:
         """
         return self.dtype.freq
 
-    def __array__(self, dtype=None) -> np.ndarray:
+    def __array__(self, dtype: Optional[NpDtype] = None) -> np.ndarray:
         if dtype == "i8":
             return self.asi8
         elif dtype == bool: