TYP: fix type ignores (pandas-dev#40434)

Author: jbrockmendel

pandas/_testing/_io.py

@@ -93,9 +93,7 @@ def dec(f):
         is_decorating = not kwargs and len(args) == 1 and callable(args[0])
         if is_decorating:
             f = args[0]
-            # error: Incompatible types in assignment (expression has type
-            # "List[<nothing>]", variable has type "Tuple[Any, ...]")
-            args = []  # type: ignore[assignment]
+            args = ()
             return dec(f)
         else:
             return dec

pandas/compat/numpy/__init__.py

@@ -27,41 +27,39 @@
 _tz_regex = re.compile("[+-]0000$")
 
 
-def tz_replacer(s):
-    if isinstance(s, str):
-        if s.endswith("Z"):
-            s = s[:-1]
-        elif _tz_regex.search(s):
-            s = s[:-5]
-    return s
+def _tz_replacer(tstring):
+    if isinstance(tstring, str):
+        if tstring.endswith("Z"):
+            tstring = tstring[:-1]
+        elif _tz_regex.search(tstring):
+            tstring = tstring[:-5]
+    return tstring
 
 
-def np_datetime64_compat(s, *args, **kwargs):
+def np_datetime64_compat(tstring: str, unit: str = "ns"):
     """
     provide compat for construction of strings to numpy datetime64's with
     tz-changes in 1.11 that make '2015-01-01 09:00:00Z' show a deprecation
     warning, when need to pass '2015-01-01 09:00:00'
     """
-    s = tz_replacer(s)
-    # error: No overload variant of "datetime64" matches argument types "Any",
-    # "Tuple[Any, ...]", "Dict[str, Any]"
-    return np.datetime64(s, *args, **kwargs)  # type: ignore[call-overload]
+    tstring = _tz_replacer(tstring)
+    return np.datetime64(tstring, unit)
 
 
-def np_array_datetime64_compat(arr, *args, **kwargs):
+def np_array_datetime64_compat(arr, dtype="M8[ns]"):
     """
     provide compat for construction of an array of strings to a
     np.array(..., dtype=np.datetime64(..))
     tz-changes in 1.11 that make '2015-01-01 09:00:00Z' show a deprecation
     warning, when need to pass '2015-01-01 09:00:00'
     """
-    # is_list_like
+    # is_list_like; can't import as it would be circular
     if hasattr(arr, "__iter__") and not isinstance(arr, (str, bytes)):
-        arr = [tz_replacer(s) for s in arr]
+        arr = [_tz_replacer(s) for s in arr]
     else:
-        arr = tz_replacer(arr)
+        arr = _tz_replacer(arr)
 
-    return np.array(arr, *args, **kwargs)
+    return np.array(arr, dtype=dtype)
 
 
 __all__ = [

pandas/core/dtypes/concat.py

@@ -14,9 +14,9 @@
 from pandas.core.dtypes.common import (
     is_categorical_dtype,
     is_dtype_equal,
-    is_extension_array_dtype,
     is_sparse,
 )
+from pandas.core.dtypes.dtypes import ExtensionDtype
 from pandas.core.dtypes.generic import (
     ABCCategoricalIndex,
     ABCSeries,
@@ -64,14 +64,13 @@ def _cast_to_common_type(arr: ArrayLike, dtype: DtypeObj) -> ArrayLike:
         # are not coming from Index/Series._values), eg in BlockManager.quantile
         arr = ensure_wrapped_if_datetimelike(arr)
 
-    if is_extension_array_dtype(dtype) and isinstance(arr, np.ndarray):
-        # numpy's astype cannot handle ExtensionDtypes
-        return pd_array(arr, dtype=dtype, copy=False)
-    # error: Argument 1 to "astype" of "_ArrayOrScalarCommon" has incompatible type
-    # "Union[dtype[Any], ExtensionDtype]"; expected "Union[dtype[Any], None, type,
-    # _SupportsDType, str, Union[Tuple[Any, int], Tuple[Any, Union[int, Sequence[int]]],
-    # List[Any], _DTypeDict, Tuple[Any, Any]]]"
-    return arr.astype(dtype, copy=False)  # type: ignore[arg-type]
+    if isinstance(dtype, ExtensionDtype):
+        if isinstance(arr, np.ndarray):
+            # numpy's astype cannot handle ExtensionDtypes
+            return pd_array(arr, dtype=dtype, copy=False)
+        return arr.astype(dtype, copy=False)
+
+    return arr.astype(dtype, copy=False)
 
 
 def concat_compat(to_concat, axis: int = 0, ea_compat_axis: bool = False):
@@ -115,7 +114,7 @@ def is_nonempty(x) -> bool:
 
     all_empty = not len(non_empties)
     single_dtype = len({x.dtype for x in to_concat}) == 1
-    any_ea = any(is_extension_array_dtype(x.dtype) for x in to_concat)
+    any_ea = any(isinstance(x.dtype, ExtensionDtype) for x in to_concat)
 
     if any_ea:
         # we ignore axis here, as internally concatting with EAs is always
@@ -354,7 +353,7 @@ def _concat_datetime(to_concat, axis=0):
 
     result = type(to_concat[0])._concat_same_type(to_concat, axis=axis)
 
-    if result.ndim == 2 and is_extension_array_dtype(result.dtype):
+    if result.ndim == 2 and isinstance(result.dtype, ExtensionDtype):
         # TODO(EA2D): kludge not necessary with 2D EAs
         assert result.shape[0] == 1
         result = result[0]

pandas/core/dtypes/dtypes.py

@@ -83,7 +83,7 @@ class PandasExtensionDtype(ExtensionDtype):
     num = 100
     shape: Tuple[int, ...] = ()
     itemsize = 8
-    base = None
+    base: Optional[DtypeObj] = None
     isbuiltin = 0
     isnative = 0
     _cache: Dict[str_type, PandasExtensionDtype] = {}
@@ -180,9 +180,7 @@ class CategoricalDtype(PandasExtensionDtype, ExtensionDtype):
     type: Type[CategoricalDtypeType] = CategoricalDtypeType
     kind: str_type = "O"
     str = "|O08"
-    # error: Incompatible types in assignment (expression has type "dtype",
-    # base class "PandasExtensionDtype" defined the type as "None")
-    base = np.dtype("O")  # type: ignore[assignment]
+    base = np.dtype("O")
     _metadata = ("categories", "ordered")
     _cache: Dict[str_type, PandasExtensionDtype] = {}
 
@@ -676,9 +674,7 @@ class DatetimeTZDtype(PandasExtensionDtype):
     kind: str_type = "M"
     str = "|M8[ns]"
     num = 101
-    # error: Incompatible types in assignment (expression has type "dtype",
-    # base class "PandasExtensionDtype" defined the type as "None")
-    base = np.dtype("M8[ns]")  # type: ignore[assignment]
+    base = np.dtype("M8[ns]")
     na_value = NaT
     _metadata = ("unit", "tz")
     _match = re.compile(r"(datetime64|M8)\[(?P<unit>.+), (?P<tz>.+)\]")
@@ -844,9 +840,7 @@ class PeriodDtype(dtypes.PeriodDtypeBase, PandasExtensionDtype):
     type: Type[Period] = Period
     kind: str_type = "O"
     str = "|O08"
-    # error: Incompatible types in assignment (expression has type "dtype",
-    # base class "PandasExtensionDtype" defined the type as "None")
-    base = np.dtype("O")  # type: ignore[assignment]
+    base = np.dtype("O")
     num = 102
     _metadata = ("freq",)
     _match = re.compile(r"(P|p)eriod\[(?P<freq>.+)\]")
@@ -1046,9 +1040,7 @@ class IntervalDtype(PandasExtensionDtype):
     name = "interval"
     kind: str_type = "O"
     str = "|O08"
-    # error: Incompatible types in assignment (expression has type "dtype",
-    # base class "PandasExtensionDtype" defined the type as "None")
-    base = np.dtype("O")  # type: ignore[assignment]
+    base = np.dtype("O")
     num = 103
     _metadata = (
         "subtype",

pandas/core/indexes/numeric.py

@@ -292,12 +292,9 @@ def _convert_arr_indexer(self, keyarr):
         if is_integer_dtype(keyarr) or (
             lib.infer_dtype(keyarr, skipna=False) == "integer"
         ):
-            dtype = np.uint64
+            dtype = np.dtype(np.uint64)
 
-        # error: Argument "dtype" to "asarray_tuplesafe" has incompatible type
-        # "Optional[Type[unsignedinteger[Any]]]"; expected "Union[str, dtype[Any],
-        # None]"
-        return com.asarray_tuplesafe(keyarr, dtype=dtype)  # type: ignore[arg-type]
+        return com.asarray_tuplesafe(keyarr, dtype=dtype)
 
 
 _float64_descr_args = {

pandas/core/indexes/range.py

@@ -6,6 +6,7 @@
 from typing import (
     TYPE_CHECKING,
     Any,
+    Callable,
     Hashable,
     List,
     Optional,
@@ -900,7 +901,7 @@ def _arith_method(self, other, op):
         ]:
             return op(self._int64index, other)
 
-        step = False
+        step: Optional[Callable] = None
         if op in [operator.mul, ops.rmul, operator.truediv, ops.rtruediv]:
             step = op
 
@@ -913,8 +914,7 @@ def _arith_method(self, other, op):
             # apply if we have an override
             if step:
                 with np.errstate(all="ignore"):
-                    # error: "bool" not callable
-                    rstep = step(left.step, right)  # type: ignore[operator]
+                    rstep = step(left.step, right)
 
                 # we don't have a representable op
                 # so return a base index

pandas/core/internals/api.py

@@ -13,7 +13,10 @@
 from pandas._libs.internals import BlockPlacement
 from pandas._typing import Dtype
 
-from pandas.core.dtypes.common import is_datetime64tz_dtype
+from pandas.core.dtypes.common import (
+    is_datetime64tz_dtype,
+    pandas_dtype,
+)
 
 from pandas.core.arrays import DatetimeArray
 from pandas.core.internals.blocks import (
@@ -40,11 +43,10 @@ def make_block(
     - Block.make_block_same_class
     - Block.__init__
     """
-    # error: Argument 2 to "extract_pandas_array" has incompatible type
-    # "Union[ExtensionDtype, str, dtype[Any], Type[str], Type[float], Type[int],
-    # Type[complex], Type[bool], Type[object], None]"; expected "Union[dtype[Any],
-    # ExtensionDtype, None]"
-    values, dtype = extract_pandas_array(values, dtype, ndim)  # type: ignore[arg-type]
+    if dtype is not None:
+        dtype = pandas_dtype(dtype)
+
+    values, dtype = extract_pandas_array(values, dtype, ndim)
 
     if klass is None:
         dtype = dtype or values.dtype

pandas/core/nanops.py

@@ -28,6 +28,7 @@
     DtypeObj,
     F,
     Scalar,
+    Shape,
 )
 from pandas.compat._optional import import_optional_dependency
 
@@ -650,22 +651,16 @@ def nanmean(
         values, skipna, fill_value=0, mask=mask
     )
     dtype_sum = dtype_max
-    dtype_count = np.float64
+    dtype_count = np.dtype(np.float64)
 
     # not using needs_i8_conversion because that includes period
     if dtype.kind in ["m", "M"]:
-        # error: Incompatible types in assignment (expression has type "Type[float64]",
-        # variable has type "dtype[Any]")
-        dtype_sum = np.float64  # type: ignore[assignment]
+        dtype_sum = np.dtype(np.float64)
     elif is_integer_dtype(dtype):
-        # error: Incompatible types in assignment (expression has type "Type[float64]",
-        # variable has type "dtype[Any]")
-        dtype_sum = np.float64  # type: ignore[assignment]
+        dtype_sum = np.dtype(np.float64)
     elif is_float_dtype(dtype):
         dtype_sum = dtype
-        # error: Incompatible types in assignment (expression has type "dtype[Any]",
-        # variable has type "Type[float64]")
-        dtype_count = dtype  # type: ignore[assignment]
+        dtype_count = dtype
 
     count = _get_counts(values.shape, mask, axis, dtype=dtype_count)
     the_sum = _ensure_numeric(values.sum(axis, dtype=dtype_sum))
@@ -787,7 +782,7 @@ def get_empty_reduction_result(
 
 
 def _get_counts_nanvar(
-    value_counts: Tuple[int],
+    values_shape: Shape,
     mask: Optional[np.ndarray],
     axis: Optional[int],
     ddof: int,
@@ -799,7 +794,7 @@ def _get_counts_nanvar(
 
     Parameters
     ----------
-    values_shape : Tuple[int]
+    values_shape : Tuple[int, ...]
         shape tuple from values ndarray, used if mask is None
     mask : Optional[ndarray[bool]]
         locations in values that should be considered missing
@@ -816,7 +811,7 @@ def _get_counts_nanvar(
     d : scalar or array
     """
     dtype = get_dtype(dtype)
-    count = _get_counts(value_counts, mask, axis, dtype=dtype)
+    count = _get_counts(values_shape, mask, axis, dtype=dtype)
     # error: Unsupported operand types for - ("int" and "generic")
     # error: Unsupported operand types for - ("float" and "generic")
     d = count - dtype.type(ddof)  # type: ignore[operator]
@@ -991,11 +986,7 @@ def nansem(
     if not is_float_dtype(values.dtype):
         values = values.astype("f8")
 
-    # error: Argument 1 to "_get_counts_nanvar" has incompatible type
-    # "Tuple[int, ...]"; expected "Tuple[int]"
-    count, _ = _get_counts_nanvar(
-        values.shape, mask, axis, ddof, values.dtype  # type: ignore[arg-type]
-    )
+    count, _ = _get_counts_nanvar(values.shape, mask, axis, ddof, values.dtype)
     var = nanvar(values, axis=axis, skipna=skipna, ddof=ddof)
 
     return np.sqrt(var) / np.sqrt(count)

pandas/io/formats/format.py

@@ -82,8 +82,11 @@
     notna,
 )
 
-from pandas.core.arrays.datetimes import DatetimeArray
-from pandas.core.arrays.timedeltas import TimedeltaArray
+from pandas.core.arrays import (
+    Categorical,
+    DatetimeArray,
+    TimedeltaArray,
+)
 from pandas.core.base import PandasObject
 import pandas.core.common as com
 from pandas.core.construction import extract_array
@@ -106,7 +109,6 @@
 
 if TYPE_CHECKING:
     from pandas import (
-        Categorical,
         DataFrame,
         Series,
     )
@@ -1565,12 +1567,9 @@ def _format_strings(self) -> List[str]:
             # no attribute "_formatter"
             formatter = values._formatter(boxed=True)  # type: ignore[union-attr]
 
-        if is_categorical_dtype(values.dtype):
+        if isinstance(values, Categorical):
             # Categorical is special for now, so that we can preserve tzinfo
-
-            # error: Item "ExtensionArray" of "Union[Any, ExtensionArray]" has no
-            # attribute "_internal_get_values"
-            array = values._internal_get_values()  # type: ignore[union-attr]
+            array = values._internal_get_values()
         else:
             array = np.asarray(values)