diff --git a/environment.yml b/environment.yml
index f54bf41c14c75..ebf22bbf067a6 100644
--- a/environment.yml
+++ b/environment.yml
@@ -3,7 +3,7 @@ channels:
- conda-forge
dependencies:
# required
- - numpy>=1.16.5, <1.20 # gh-39513
+ - numpy>=1.16.5
- python=3
- python-dateutil>=2.7.3
- pytz
diff --git a/pandas/compat/numpy/__init__.py b/pandas/compat/numpy/__init__.py
index 1d8077da76469..e551f05efa31b 100644
--- a/pandas/compat/numpy/__init__.py
+++ b/pandas/compat/numpy/__init__.py
@@ -43,7 +43,9 @@ def np_datetime64_compat(s, *args, **kwargs):
warning, when need to pass '2015-01-01 09:00:00'
"""
s = tz_replacer(s)
- return np.datetime64(s, *args, **kwargs)
+ # 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]
def np_array_datetime64_compat(arr, *args, **kwargs):
diff --git a/pandas/core/aggregation.py b/pandas/core/aggregation.py
index 0a4e03fa97402..a8a761b5f4aac 100644
--- a/pandas/core/aggregation.py
+++ b/pandas/core/aggregation.py
@@ -181,7 +181,9 @@ def normalize_keyword_aggregation(kwargs: dict) -> Tuple[dict, List[str], List[i
# get the new index of columns by comparison
col_idx_order = Index(uniquified_aggspec).get_indexer(uniquified_order)
- return aggspec, columns, col_idx_order
+ # error: Incompatible return value type (got "Tuple[defaultdict[Any, Any],
+ # Any, ndarray]", expected "Tuple[Dict[Any, Any], List[str], List[int]]")
+ return aggspec, columns, col_idx_order # type: ignore[return-value]
def _make_unique_kwarg_list(
diff --git a/pandas/core/algorithms.py b/pandas/core/algorithms.py
index 04eef635dc79b..57e57f48fdfe5 100644
--- a/pandas/core/algorithms.py
+++ b/pandas/core/algorithms.py
@@ -157,7 +157,10 @@ def _ensure_data(values: ArrayLike) -> Tuple[np.ndarray, DtypeObj]:
with catch_warnings():
simplefilter("ignore", np.ComplexWarning)
values = ensure_float64(values)
- return values, np.dtype("float64")
+ # error: Incompatible return value type (got "Tuple[ExtensionArray,
+ # dtype[floating[_64Bit]]]", expected "Tuple[ndarray, Union[dtype[Any],
+ # ExtensionDtype]]")
+ return values, np.dtype("float64") # type: ignore[return-value]
except (TypeError, ValueError, OverflowError):
# if we are trying to coerce to a dtype
@@ -173,7 +176,9 @@ def _ensure_data(values: ArrayLike) -> Tuple[np.ndarray, DtypeObj]:
elif is_timedelta64_dtype(values.dtype):
from pandas import TimedeltaIndex
- values = TimedeltaIndex(values)._data
+ # error: Incompatible types in assignment (expression has type
+ # "TimedeltaArray", variable has type "ndarray")
+ values = TimedeltaIndex(values)._data # type: ignore[assignment]
else:
# Datetime
if values.ndim > 1 and is_datetime64_ns_dtype(values.dtype):
@@ -182,27 +187,45 @@ def _ensure_data(values: ArrayLike) -> Tuple[np.ndarray, DtypeObj]:
# TODO(EA2D): special case not needed with 2D EAs
asi8 = values.view("i8")
dtype = values.dtype
- return asi8, dtype
+ # error: Incompatible return value type (got "Tuple[Any,
+ # Union[dtype, ExtensionDtype, None]]", expected
+ # "Tuple[ndarray, Union[dtype, ExtensionDtype]]")
+ return asi8, dtype # type: ignore[return-value]
from pandas import DatetimeIndex
- values = DatetimeIndex(values)._data
+ # Incompatible types in assignment (expression has type "DatetimeArray",
+ # variable has type "ndarray")
+ values = DatetimeIndex(values)._data # type: ignore[assignment]
dtype = values.dtype
- return values.asi8, dtype
+ # error: Item "ndarray" of "Union[PeriodArray, Any, ndarray]" has no attribute
+ # "asi8"
+ return values.asi8, dtype # type: ignore[union-attr]
elif is_categorical_dtype(values.dtype):
- values = cast("Categorical", values)
- values = values.codes
+ # error: Incompatible types in assignment (expression has type "Categorical",
+ # variable has type "ndarray")
+ values = cast("Categorical", values) # type: ignore[assignment]
+ # error: Incompatible types in assignment (expression has type "ndarray",
+ # variable has type "ExtensionArray")
+ # error: Item "ndarray" of "Union[Any, ndarray]" has no attribute "codes"
+ values = values.codes # type: ignore[assignment,union-attr]
dtype = pandas_dtype("category")
# we are actually coercing to int64
# until our algos support int* directly (not all do)
values = ensure_int64(values)
- return values, dtype
+ # error: Incompatible return value type (got "Tuple[ExtensionArray,
+ # Union[dtype[Any], ExtensionDtype]]", expected "Tuple[ndarray,
+ # Union[dtype[Any], ExtensionDtype]]")
+ return values, dtype # type: ignore[return-value]
# we have failed, return object
- values = np.asarray(values, dtype=object)
+
+ # error: Incompatible types in assignment (expression has type "ndarray", variable
+ # has type "ExtensionArray")
+ values = np.asarray(values, dtype=object) # type: ignore[assignment]
return ensure_object(values), np.dtype("object")
@@ -227,24 +250,40 @@ def _reconstruct_data(
return values
if is_extension_array_dtype(dtype):
- cls = dtype.construct_array_type()
+ # error: Item "dtype[Any]" of "Union[dtype[Any], ExtensionDtype]" has no
+ # attribute "construct_array_type"
+ cls = dtype.construct_array_type() # type: ignore[union-attr]
if isinstance(values, cls) and values.dtype == dtype:
return values
values = cls._from_sequence(values)
elif is_bool_dtype(dtype):
- values = values.astype(dtype, copy=False)
+ # error: Argument 1 to "astype" of "_ArrayOrScalarCommon" has
+ # incompatible type "Union[dtype, ExtensionDtype]"; expected
+ # "Union[dtype, None, type, _SupportsDtype, str, Tuple[Any, int],
+ # Tuple[Any, Union[int, Sequence[int]]], List[Any], _DtypeDict,
+ # Tuple[Any, Any]]"
+ values = values.astype(dtype, copy=False) # type: ignore[arg-type]
# we only support object dtypes bool Index
if isinstance(original, ABCIndex):
values = values.astype(object, copy=False)
elif dtype is not None:
if is_datetime64_dtype(dtype):
- dtype = "datetime64[ns]"
+ # error: Incompatible types in assignment (expression has type
+ # "str", variable has type "Union[dtype, ExtensionDtype]")
+ dtype = "datetime64[ns]" # type: ignore[assignment]
elif is_timedelta64_dtype(dtype):
- dtype = "timedelta64[ns]"
+ # error: Incompatible types in assignment (expression has type
+ # "str", variable has type "Union[dtype, ExtensionDtype]")
+ dtype = "timedelta64[ns]" # type: ignore[assignment]
- values = values.astype(dtype, copy=False)
+ # error: Argument 1 to "astype" of "_ArrayOrScalarCommon" has
+ # incompatible type "Union[dtype, ExtensionDtype]"; expected
+ # "Union[dtype, None, type, _SupportsDtype, str, Tuple[Any, int],
+ # Tuple[Any, Union[int, Sequence[int]]], List[Any], _DtypeDict,
+ # Tuple[Any, Any]]"
+ values = values.astype(dtype, copy=False) # type: ignore[arg-type]
return values
@@ -296,14 +335,18 @@ def _get_values_for_rank(values: ArrayLike):
if is_categorical_dtype(values):
values = cast("Categorical", values)._values_for_rank()
- values, _ = _ensure_data(values)
+ # error: Incompatible types in assignment (expression has type "ndarray", variable
+ # has type "ExtensionArray")
+ values, _ = _ensure_data(values) # type: ignore[assignment]
return values
def get_data_algo(values: ArrayLike):
values = _get_values_for_rank(values)
- ndtype = _check_object_for_strings(values)
+ # error: Argument 1 to "_check_object_for_strings" has incompatible type
+ # "ExtensionArray"; expected "ndarray"
+ ndtype = _check_object_for_strings(values) # type: ignore[arg-type]
htable = _hashtables.get(ndtype, _hashtables["object"])
return htable, values
@@ -460,17 +503,46 @@ def isin(comps: AnyArrayLike, values: AnyArrayLike) -> np.ndarray:
)
if not isinstance(values, (ABCIndex, ABCSeries, ABCExtensionArray, np.ndarray)):
- values = _ensure_arraylike(list(values))
+ # error: Incompatible types in assignment (expression has type "ExtensionArray",
+ # variable has type "Index")
+ # error: Incompatible types in assignment (expression has type "ExtensionArray",
+ # variable has type "Series")
+ # error: Incompatible types in assignment (expression has type "ExtensionArray",
+ # variable has type "ndarray")
+ values = _ensure_arraylike(list(values)) # type: ignore[assignment]
elif isinstance(values, ABCMultiIndex):
# Avoid raising in extract_array
- values = np.array(values)
- else:
- values = extract_array(values, extract_numpy=True)
- comps = _ensure_arraylike(comps)
- comps = extract_array(comps, extract_numpy=True)
+ # error: Incompatible types in assignment (expression has type "ndarray",
+ # variable has type "ExtensionArray")
+ # error: Incompatible types in assignment (expression has type "ndarray",
+ # variable has type "Index")
+ # error: Incompatible types in assignment (expression has type "ndarray",
+ # variable has type "Series")
+ values = np.array(values) # type: ignore[assignment]
+ else:
+ # error: Incompatible types in assignment (expression has type "Union[Any,
+ # ExtensionArray]", variable has type "Index")
+ # error: Incompatible types in assignment (expression has type "Union[Any,
+ # ExtensionArray]", variable has type "Series")
+ values = extract_array(values, extract_numpy=True) # type: ignore[assignment]
+
+ # error: Incompatible types in assignment (expression has type "ExtensionArray",
+ # variable has type "Index")
+ # error: Incompatible types in assignment (expression has type "ExtensionArray",
+ # variable has type "Series")
+ # error: Incompatible types in assignment (expression has type "ExtensionArray",
+ # variable has type "ndarray")
+ comps = _ensure_arraylike(comps) # type: ignore[assignment]
+ # error: Incompatible types in assignment (expression has type "Union[Any,
+ # ExtensionArray]", variable has type "Index")
+ # error: Incompatible types in assignment (expression has type "Union[Any,
+ # ExtensionArray]", variable has type "Series")
+ comps = extract_array(comps, extract_numpy=True) # type: ignore[assignment]
if is_extension_array_dtype(comps.dtype):
- return comps.isin(values)
+ # error: Incompatible return value type (got "Series", expected "ndarray")
+ # error: Item "ndarray" of "Union[Any, ndarray]" has no attribute "isin"
+ return comps.isin(values) # type: ignore[return-value,union-attr]
elif needs_i8_conversion(comps.dtype):
# Dispatch to DatetimeLikeArrayMixin.isin
@@ -501,7 +573,19 @@ def f(c, v):
f = np.in1d
else:
- common = np.find_common_type([values.dtype, comps.dtype], [])
+ # error: List item 0 has incompatible type "Union[Any, dtype[Any],
+ # ExtensionDtype]"; expected "Union[dtype[Any], None, type, _SupportsDType, str,
+ # Tuple[Any, Union[int, Sequence[int]]], List[Any], _DTypeDict, Tuple[Any,
+ # Any]]"
+ # error: List item 1 has incompatible type "Union[Any, ExtensionDtype]";
+ # expected "Union[dtype[Any], None, type, _SupportsDType, str, Tuple[Any,
+ # Union[int, Sequence[int]]], List[Any], _DTypeDict, Tuple[Any, Any]]"
+ # error: List item 1 has incompatible type "Union[dtype[Any], ExtensionDtype]";
+ # expected "Union[dtype[Any], None, type, _SupportsDType, str, Tuple[Any,
+ # Union[int, Sequence[int]]], List[Any], _DTypeDict, Tuple[Any, Any]]"
+ common = np.find_common_type(
+ [values.dtype, comps.dtype], [] # type: ignore[list-item]
+ )
values = values.astype(common, copy=False)
comps = comps.astype(common, copy=False)
name = common.name
@@ -916,7 +1000,9 @@ def duplicated(values: ArrayLike, keep: Union[str, bool] = "first") -> np.ndarra
-------
duplicated : ndarray
"""
- values, _ = _ensure_data(values)
+ # error: Incompatible types in assignment (expression has type "ndarray", variable
+ # has type "ExtensionArray")
+ values, _ = _ensure_data(values) # type: ignore[assignment]
ndtype = values.dtype.name
f = getattr(htable, f"duplicated_{ndtype}")
return f(values, keep=keep)
@@ -1188,7 +1274,9 @@ def _get_score(at):
else:
q = np.asarray(q, np.float64)
result = [_get_score(x) for x in q]
- result = np.array(result, dtype=np.float64)
+ # error: Incompatible types in assignment (expression has type
+ # "ndarray", variable has type "List[Any]")
+ result = np.array(result, dtype=np.float64) # type: ignore[assignment]
return result
@@ -1776,7 +1864,11 @@ def safe_sort(
if not isinstance(values, (np.ndarray, ABCExtensionArray)):
# don't convert to string types
dtype, _ = infer_dtype_from_array(values)
- values = np.asarray(values, dtype=dtype)
+ # error: Argument "dtype" to "asarray" 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]]]"
+ values = np.asarray(values, dtype=dtype) # type: ignore[arg-type]
sorter = None
diff --git a/pandas/core/apply.py b/pandas/core/apply.py
index cccd88ccb7a1e..57147461284fb 100644
--- a/pandas/core/apply.py
+++ b/pandas/core/apply.py
@@ -1016,7 +1016,11 @@ def apply_standard(self) -> FrameOrSeriesUnion:
with np.errstate(all="ignore"):
if isinstance(f, np.ufunc):
- return f(obj)
+ # error: Argument 1 to "__call__" of "ufunc" has incompatible type
+ # "Series"; expected "Union[Union[int, float, complex, str, bytes,
+ # generic], Sequence[Union[int, float, complex, str, bytes, generic]],
+ # Sequence[Sequence[Any]], _SupportsArray]"
+ return f(obj) # type: ignore[arg-type]
# row-wise access
if is_extension_array_dtype(obj.dtype) and hasattr(obj._values, "map"):
diff --git a/pandas/core/array_algos/putmask.py b/pandas/core/array_algos/putmask.py
index 93046f476c6ba..b552a1be4c36e 100644
--- a/pandas/core/array_algos/putmask.py
+++ b/pandas/core/array_algos/putmask.py
@@ -120,7 +120,11 @@ def putmask_smart(values: np.ndarray, mask: np.ndarray, new) -> np.ndarray:
return _putmask_preserve(values, new, mask)
dtype = find_common_type([values.dtype, new.dtype])
- values = values.astype(dtype)
+ # 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]]]"
+ values = values.astype(dtype) # type: ignore[arg-type]
return _putmask_preserve(values, new, mask)
@@ -187,10 +191,16 @@ def extract_bool_array(mask: ArrayLike) -> np.ndarray:
# We could have BooleanArray, Sparse[bool], ...
# Except for BooleanArray, this is equivalent to just
# np.asarray(mask, dtype=bool)
- mask = mask.to_numpy(dtype=bool, na_value=False)
- mask = np.asarray(mask, dtype=bool)
- return mask
+ # error: Incompatible types in assignment (expression has type "ndarray",
+ # variable has type "ExtensionArray")
+ mask = mask.to_numpy(dtype=bool, na_value=False) # type: ignore[assignment]
+
+ # error: Incompatible types in assignment (expression has type "ndarray", variable
+ # has type "ExtensionArray")
+ mask = np.asarray(mask, dtype=bool) # type: ignore[assignment]
+ # error: Incompatible return value type (got "ExtensionArray", expected "ndarray")
+ return mask # type: ignore[return-value]
def setitem_datetimelike_compat(values: np.ndarray, num_set: int, other):
diff --git a/pandas/core/array_algos/quantile.py b/pandas/core/array_algos/quantile.py
index 802fc4db0a36d..501d3308b7d8b 100644
--- a/pandas/core/array_algos/quantile.py
+++ b/pandas/core/array_algos/quantile.py
@@ -143,10 +143,17 @@ def quantile_ea_compat(
mask = np.asarray(values.isna())
mask = np.atleast_2d(mask)
- values, fill_value = values._values_for_factorize()
- values = np.atleast_2d(values)
-
- result = quantile_with_mask(values, mask, fill_value, qs, interpolation, axis)
+ # error: Incompatible types in assignment (expression has type "ndarray", variable
+ # has type "ExtensionArray")
+ values, fill_value = values._values_for_factorize() # type: ignore[assignment]
+ # error: No overload variant of "atleast_2d" matches argument type "ExtensionArray"
+ values = np.atleast_2d(values) # type: ignore[call-overload]
+
+ # error: Argument 1 to "quantile_with_mask" has incompatible type "ExtensionArray";
+ # expected "ndarray"
+ result = quantile_with_mask(
+ values, mask, fill_value, qs, interpolation, axis # type: ignore[arg-type]
+ )
if not is_sparse(orig.dtype):
# shape[0] should be 1 as long as EAs are 1D
@@ -160,4 +167,5 @@ def quantile_ea_compat(
assert result.shape == (1, len(qs)), result.shape
result = type(orig)._from_factorized(result[0], orig)
- return result
+ # error: Incompatible return value type (got "ndarray", expected "ExtensionArray")
+ return result # type: ignore[return-value]
diff --git a/pandas/core/array_algos/replace.py b/pandas/core/array_algos/replace.py
index 201b9fdcc51cc..b0c0799750859 100644
--- a/pandas/core/array_algos/replace.py
+++ b/pandas/core/array_algos/replace.py
@@ -95,7 +95,9 @@ def _check_comparison_types(
if is_numeric_v_string_like(a, b):
# GH#29553 avoid deprecation warnings from numpy
- return np.zeros(a.shape, dtype=bool)
+ # error: Incompatible return value type (got "ndarray", expected
+ # "Union[ExtensionArray, bool]")
+ return np.zeros(a.shape, dtype=bool) # type: ignore[return-value]
elif is_datetimelike_v_numeric(a, b):
# GH#29553 avoid deprecation warnings from numpy
@@ -152,6 +154,8 @@ def re_replacer(s):
f = np.vectorize(re_replacer, otypes=[values.dtype])
if mask is None:
- values[:] = f(values)
+ # error: Invalid index type "slice" for "ExtensionArray"; expected type
+ # "Union[int, ndarray]"
+ values[:] = f(values) # type: ignore[index]
else:
values[mask] = f(values[mask])
diff --git a/pandas/core/array_algos/take.py b/pandas/core/array_algos/take.py
index 054497089c5ab..7eed31663f1cb 100644
--- a/pandas/core/array_algos/take.py
+++ b/pandas/core/array_algos/take.py
@@ -140,7 +140,14 @@ def take_1d(
"""
if not isinstance(arr, np.ndarray):
# ExtensionArray -> dispatch to their method
- return arr.take(indexer, fill_value=fill_value, allow_fill=allow_fill)
+
+ # error: Argument 1 to "take" of "ExtensionArray" has incompatible type
+ # "ndarray"; expected "Sequence[int]"
+ return arr.take(
+ indexer, # type: ignore[arg-type]
+ fill_value=fill_value,
+ allow_fill=allow_fill,
+ )
indexer, dtype, fill_value, mask_info = _take_preprocess_indexer_and_fill_value(
arr, indexer, 0, None, fill_value, allow_fill
@@ -174,7 +181,9 @@ def take_2d_multi(
row_idx = ensure_int64(row_idx)
col_idx = ensure_int64(col_idx)
- indexer = row_idx, col_idx
+ # error: Incompatible types in assignment (expression has type "Tuple[Any, Any]",
+ # variable has type "ndarray")
+ indexer = row_idx, col_idx # type: ignore[assignment]
mask_info = None
# check for promotion based on types only (do this first because
@@ -485,8 +494,13 @@ def _take_preprocess_indexer_and_fill_value(
if dtype != arr.dtype and (out is None or out.dtype != dtype):
# check if promotion is actually required based on indexer
mask = indexer == -1
- needs_masking = mask.any()
- mask_info = mask, needs_masking
+ # error: Item "bool" of "Union[Any, bool]" has no attribute "any"
+ # [union-attr]
+ needs_masking = mask.any() # type: ignore[union-attr]
+ # error: Incompatible types in assignment (expression has type
+ # "Tuple[Union[Any, bool], Any]", variable has type
+ # "Optional[Tuple[None, bool]]")
+ mask_info = mask, needs_masking # type: ignore[assignment]
if needs_masking:
if out is not None and out.dtype != dtype:
raise TypeError("Incompatible type for fill_value")
diff --git a/pandas/core/arraylike.py b/pandas/core/arraylike.py
index 3f45f503d0f62..588fe8adc7241 100644
--- a/pandas/core/arraylike.py
+++ b/pandas/core/arraylike.py
@@ -258,7 +258,12 @@ def array_ufunc(self, ufunc: np.ufunc, method: str, *inputs: Any, **kwargs: Any)
return result
# Determine if we should defer.
- no_defer = (np.ndarray.__array_ufunc__, cls.__array_ufunc__)
+
+ # error: "Type[ndarray]" has no attribute "__array_ufunc__"
+ no_defer = (
+ np.ndarray.__array_ufunc__, # type: ignore[attr-defined]
+ cls.__array_ufunc__,
+ )
for item in inputs:
higher_priority = (
diff --git a/pandas/core/arrays/_mixins.py b/pandas/core/arrays/_mixins.py
index d54d1855ac2f8..8beafe3fe4578 100644
--- a/pandas/core/arrays/_mixins.py
+++ b/pandas/core/arrays/_mixins.py
@@ -104,7 +104,9 @@ def take(
new_data = take(
self._ndarray,
- indices,
+ # error: Argument 2 to "take" has incompatible type "Sequence[int]";
+ # expected "ndarray"
+ indices, # type: ignore[arg-type]
allow_fill=allow_fill,
fill_value=fill_value,
axis=axis,
@@ -147,7 +149,8 @@ def ndim(self) -> int:
@cache_readonly
def size(self) -> int:
- return np.prod(self.shape)
+ # error: Incompatible return value type (got "number", expected "int")
+ return np.prod(self.shape) # type: ignore[return-value]
@cache_readonly
def nbytes(self) -> int:
@@ -217,7 +220,9 @@ def _concat_same_type(
new_values = [x._ndarray for x in to_concat]
new_values = np.concatenate(new_values, axis=axis)
- return to_concat[0]._from_backing_data(new_values)
+ # error: Argument 1 to "_from_backing_data" of "NDArrayBackedExtensionArray" has
+ # incompatible type "List[ndarray]"; expected "ndarray"
+ return to_concat[0]._from_backing_data(new_values) # type: ignore[arg-type]
@doc(ExtensionArray.searchsorted)
def searchsorted(self, value, side="left", sorter=None):
@@ -258,7 +263,13 @@ def __getitem__(
return self._box_func(result)
return self._from_backing_data(result)
- key = extract_array(key, extract_numpy=True)
+ # error: Value of type variable "AnyArrayLike" of "extract_array" cannot be
+ # "Union[int, slice, ndarray]"
+ # error: Incompatible types in assignment (expression has type "ExtensionArray",
+ # variable has type "Union[int, slice, ndarray]")
+ key = extract_array( # type: ignore[type-var,assignment]
+ key, extract_numpy=True
+ )
key = check_array_indexer(self, key)
result = self._ndarray[key]
if lib.is_scalar(result):
@@ -274,9 +285,14 @@ def fillna(
value, method = validate_fillna_kwargs(value, method)
mask = self.isna()
- value = missing.check_value_size(value, mask, len(self))
+ # error: Argument 2 to "check_value_size" has incompatible type
+ # "ExtensionArray"; expected "ndarray"
+ value = missing.check_value_size(
+ value, mask, len(self) # type: ignore[arg-type]
+ )
- if mask.any():
+ # error: "ExtensionArray" has no attribute "any"
+ if mask.any(): # type: ignore[attr-defined]
if method is not None:
# TODO: check value is None
# (for now) when self.ndim == 2, we assume axis=0
@@ -412,7 +428,8 @@ def value_counts(self, dropna: bool = True):
)
if dropna:
- values = self[~self.isna()]._ndarray
+ # error: Unsupported operand type for ~ ("ExtensionArray")
+ values = self[~self.isna()]._ndarray # type: ignore[operator]
else:
values = self._ndarray
diff --git a/pandas/core/arrays/_ranges.py b/pandas/core/arrays/_ranges.py
index c001c57ffe757..34d5ea6cfb20d 100644
--- a/pandas/core/arrays/_ranges.py
+++ b/pandas/core/arrays/_ranges.py
@@ -161,7 +161,9 @@ def _generate_range_overflow_safe_signed(
# Putting this into a DatetimeArray/TimedeltaArray
# would incorrectly be interpreted as NaT
raise OverflowError
- return result
+ # error: Incompatible return value type (got "signedinteger[_64Bit]",
+ # expected "int")
+ return result # type: ignore[return-value]
except (FloatingPointError, OverflowError):
# with endpoint negative and addend positive we risk
# FloatingPointError; with reversed signed we risk OverflowError
@@ -175,11 +177,16 @@ def _generate_range_overflow_safe_signed(
# watch out for very special case in which we just slightly
# exceed implementation bounds, but when passing the result to
# np.arange will get a result slightly within the bounds
- result = np.uint64(endpoint) + np.uint64(addend)
+
+ # error: Incompatible types in assignment (expression has type
+ # "unsignedinteger[_64Bit]", variable has type "signedinteger[_64Bit]")
+ result = np.uint64(endpoint) + np.uint64(addend) # type: ignore[assignment]
i64max = np.uint64(np.iinfo(np.int64).max)
assert result > i64max
if result <= i64max + np.uint64(stride):
- return result
+ # error: Incompatible return value type (got "unsignedinteger", expected
+ # "int")
+ return result # type: ignore[return-value]
raise OutOfBoundsDatetime(
f"Cannot generate range with {side}={endpoint} and periods={periods}"
diff --git a/pandas/core/arrays/base.py b/pandas/core/arrays/base.py
index 86a1bcf24167c..99838602eeb63 100644
--- a/pandas/core/arrays/base.py
+++ b/pandas/core/arrays/base.py
@@ -391,13 +391,15 @@ def __contains__(self, item) -> bool:
if not self._can_hold_na:
return False
elif item is self.dtype.na_value or isinstance(item, self.dtype.type):
- return self.isna().any()
+ # error: "ExtensionArray" has no attribute "any"
+ return self.isna().any() # type: ignore[attr-defined]
else:
return False
else:
return (item == self).any()
- def __eq__(self, other: Any) -> ArrayLike:
+ # error: Signature of "__eq__" incompatible with supertype "object"
+ def __eq__(self, other: Any) -> ArrayLike: # type: ignore[override]
"""
Return for `self == other` (element-wise equality).
"""
@@ -409,7 +411,8 @@ def __eq__(self, other: Any) -> ArrayLike:
# underlying arrays)
raise AbstractMethodError(self)
- def __ne__(self, other: Any) -> ArrayLike:
+ # error: Signature of "__ne__" incompatible with supertype "object"
+ def __ne__(self, other: Any) -> ArrayLike: # type: ignore[override]
"""
Return for `self != other` (element-wise in-equality).
"""
@@ -446,7 +449,12 @@ def to_numpy(
-------
numpy.ndarray
"""
- result = np.asarray(self, dtype=dtype)
+ # error: Argument "dtype" to "asarray" 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],
+ # None, type, _SupportsDType, str, Union[Tuple[Any, int], Tuple[Any, Union[int,
+ # Sequence[int]]], List[Any], _DTypeDict, Tuple[Any, Any]]]"
+ result = np.asarray(self, dtype=dtype) # type: ignore[arg-type]
if copy or na_value is not lib.no_default:
result = result.copy()
if na_value is not lib.no_default:
@@ -476,7 +484,8 @@ def size(self) -> int:
"""
The number of elements in the array.
"""
- return np.prod(self.shape)
+ # error: Incompatible return value type (got "number", expected "int")
+ return np.prod(self.shape) # type: ignore[return-value]
@property
def ndim(self) -> int:
@@ -639,7 +648,8 @@ def argmin(self, skipna: bool = True) -> int:
ExtensionArray.argmax
"""
validate_bool_kwarg(skipna, "skipna")
- if not skipna and self.isna().any():
+ # error: "ExtensionArray" has no attribute "any"
+ if not skipna and self.isna().any(): # type: ignore[attr-defined]
raise NotImplementedError
return nargminmax(self, "argmin")
@@ -663,7 +673,8 @@ def argmax(self, skipna: bool = True) -> int:
ExtensionArray.argmin
"""
validate_bool_kwarg(skipna, "skipna")
- if not skipna and self.isna().any():
+ # error: "ExtensionArray" has no attribute "any"
+ if not skipna and self.isna().any(): # type: ignore[attr-defined]
raise NotImplementedError
return nargminmax(self, "argmax")
@@ -697,9 +708,14 @@ def fillna(self, value=None, method=None, limit=None):
value, method = validate_fillna_kwargs(value, method)
mask = self.isna()
- value = missing.check_value_size(value, mask, len(self))
+ # error: Argument 2 to "check_value_size" has incompatible type
+ # "ExtensionArray"; expected "ndarray"
+ value = missing.check_value_size(
+ value, mask, len(self) # type: ignore[arg-type]
+ )
- if mask.any():
+ # error: "ExtensionArray" has no attribute "any"
+ if mask.any(): # type: ignore[attr-defined]
if method is not None:
func = missing.get_fill_func(method)
new_values, _ = func(self.astype(object), limit=limit, mask=mask)
@@ -720,7 +736,8 @@ def dropna(self):
-------
valid : ExtensionArray
"""
- return self[~self.isna()]
+ # error: Unsupported operand type for ~ ("ExtensionArray")
+ return self[~self.isna()] # type: ignore[operator]
def shift(self, periods: int = 1, fill_value: object = None) -> ExtensionArray:
"""
@@ -865,7 +882,8 @@ def equals(self, other: object) -> bool:
if isinstance(equal_values, ExtensionArray):
# boolean array with NA -> fill with False
equal_values = equal_values.fillna(False)
- equal_na = self.isna() & other.isna()
+ # error: Unsupported left operand type for & ("ExtensionArray")
+ equal_na = self.isna() & other.isna() # type: ignore[operator]
return bool((equal_values | equal_na).all())
def isin(self, values) -> np.ndarray:
@@ -954,7 +972,9 @@ def factorize(self, na_sentinel: int = -1) -> Tuple[np.ndarray, ExtensionArray]:
)
uniques = self._from_factorized(uniques, self)
- return codes, uniques
+ # error: Incompatible return value type (got "Tuple[ndarray, ndarray]",
+ # expected "Tuple[ndarray, ExtensionArray]")
+ return codes, uniques # type: ignore[return-value]
_extension_array_shared_docs[
"repeat"
@@ -1136,7 +1156,9 @@ def view(self, dtype: Optional[Dtype] = None) -> ArrayLike:
# giving a view with the same dtype as self.
if dtype is not None:
raise NotImplementedError(dtype)
- return self[:]
+ # error: Incompatible return value type (got "Union[ExtensionArray, Any]",
+ # expected "ndarray")
+ return self[:] # type: ignore[return-value]
# ------------------------------------------------------------------------
# Printing
diff --git a/pandas/core/arrays/boolean.py b/pandas/core/arrays/boolean.py
index b37cf0a0ec579..a84b33d3da9af 100644
--- a/pandas/core/arrays/boolean.py
+++ b/pandas/core/arrays/boolean.py
@@ -406,14 +406,18 @@ def astype(self, dtype, copy: bool = True) -> ArrayLike:
dtype = pandas_dtype(dtype)
if isinstance(dtype, ExtensionDtype):
- return super().astype(dtype, copy)
+ # error: Incompatible return value type (got "ExtensionArray", expected
+ # "ndarray")
+ return super().astype(dtype, copy) # type: ignore[return-value]
if is_bool_dtype(dtype):
# astype_nansafe converts np.nan to True
if self._hasna:
raise ValueError("cannot convert float NaN to bool")
else:
- return self._data.astype(dtype, copy=copy)
+ # error: Incompatible return value type (got "ndarray", expected
+ # "ExtensionArray")
+ return self._data.astype(dtype, copy=copy) # type: ignore[return-value]
# for integer, error if there are missing values
if is_integer_dtype(dtype) and self._hasna:
@@ -425,7 +429,12 @@ def astype(self, dtype, copy: bool = True) -> ArrayLike:
if is_float_dtype(dtype):
na_value = np.nan
# coerce
- return self.to_numpy(dtype=dtype, na_value=na_value, copy=False)
+
+ # error: Incompatible return value type (got "ndarray", expected
+ # "ExtensionArray")
+ return self.to_numpy( # type: ignore[return-value]
+ dtype=dtype, na_value=na_value, copy=False
+ )
def _values_for_argsort(self) -> np.ndarray:
"""
@@ -613,7 +622,9 @@ def _logical_method(self, other, op):
elif op.__name__ in {"xor", "rxor"}:
result, mask = ops.kleene_xor(self._data, other, self._mask, mask)
- return BooleanArray(result, mask)
+ # error: Argument 2 to "BooleanArray" has incompatible type "Optional[Any]";
+ # expected "ndarray"
+ return BooleanArray(result, mask) # type: ignore[arg-type]
def _cmp_method(self, other, op):
from pandas.arrays import (
diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index 8c242e3800e48..8588bc9aa94ec 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -412,7 +412,12 @@ def __init__(
if null_mask.any():
# We remove null values here, then below will re-insert
# them, grep "full_codes"
- arr = [values[idx] for idx in np.where(~null_mask)[0]]
+
+ # error: Incompatible types in assignment (expression has type
+ # "List[Any]", variable has type "ExtensionArray")
+ arr = [ # type: ignore[assignment]
+ values[idx] for idx in np.where(~null_mask)[0]
+ ]
arr = sanitize_array(arr, None)
values = arr
@@ -440,7 +445,9 @@ def __init__(
dtype = CategoricalDtype(categories, dtype.ordered)
elif is_categorical_dtype(values.dtype):
- old_codes = extract_array(values)._codes
+ # error: Item "ExtensionArray" of "Union[Any, ExtensionArray]" has no
+ # attribute "_codes"
+ old_codes = extract_array(values)._codes # type: ignore[union-attr]
codes = recode_for_categories(
old_codes, values.dtype.categories, dtype.categories, copy=copy
)
@@ -504,13 +511,32 @@ def astype(self, dtype: Dtype, copy: bool = True) -> ArrayLike:
raise ValueError("Cannot convert float NaN to integer")
elif len(self.codes) == 0 or len(self.categories) == 0:
- result = np.array(self, dtype=dtype, copy=copy)
+ # error: Incompatible types in assignment (expression has type "ndarray",
+ # variable has type "Categorical")
+ result = np.array( # type: ignore[assignment]
+ self,
+ # error: Argument "dtype" to "array" has incompatible type
+ # "Union[ExtensionDtype, str, dtype[Any], Type[str], Type[float],
+ # Type[int], Type[complex], Type[bool], Type[object]]"; expected
+ # "Union[dtype[Any], None, type, _SupportsDType, str, Union[Tuple[Any,
+ # int], Tuple[Any, Union[int, Sequence[int]]], List[Any], _DTypeDict,
+ # Tuple[Any, Any]]]"
+ dtype=dtype, # type: ignore[arg-type]
+ copy=copy,
+ )
else:
# GH8628 (PERF): astype category codes instead of astyping array
try:
new_cats = np.asarray(self.categories)
- new_cats = new_cats.astype(dtype=dtype, copy=copy)
+ # error: Argument "dtype" to "astype" of "_ArrayOrScalarCommon" has
+ # incompatible type "Union[ExtensionDtype, dtype[Any]]"; expected
+ # "Union[dtype[Any], None, type, _SupportsDType, str, Union[Tuple[Any,
+ # int], Tuple[Any, Union[int, Sequence[int]]], List[Any], _DTypeDict,
+ # Tuple[Any, Any]]]"
+ new_cats = new_cats.astype(
+ dtype=dtype, copy=copy # type: ignore[arg-type]
+ )
except (
TypeError, # downstream error msg for CategoricalIndex is misleading
ValueError,
@@ -518,9 +544,14 @@ def astype(self, dtype: Dtype, copy: bool = True) -> ArrayLike:
msg = f"Cannot cast {self.categories.dtype} dtype to {dtype}"
raise ValueError(msg)
- result = take_nd(new_cats, libalgos.ensure_platform_int(self._codes))
+ # error: Incompatible types in assignment (expression has type "ndarray",
+ # variable has type "Categorical")
+ result = take_nd( # type: ignore[assignment]
+ new_cats, libalgos.ensure_platform_int(self._codes)
+ )
- return result
+ # error: Incompatible return value type (got "Categorical", expected "ndarray")
+ return result # type: ignore[return-value]
@cache_readonly
def itemsize(self) -> int:
@@ -1311,7 +1342,9 @@ def _validate_searchsorted_value(self, value):
codes = self._unbox_scalar(value)
else:
locs = [self.categories.get_loc(x) for x in value]
- codes = np.array(locs, dtype=self.codes.dtype)
+ # error: Incompatible types in assignment (expression has type
+ # "ndarray", variable has type "int")
+ codes = np.array(locs, dtype=self.codes.dtype) # type: ignore[assignment]
return codes
def _validate_fill_value(self, fill_value):
@@ -2126,7 +2159,11 @@ def mode(self, dropna=True):
if dropna:
good = self._codes != -1
codes = self._codes[good]
- codes = sorted(htable.mode_int64(ensure_int64(codes), dropna))
+ # error: Incompatible types in assignment (expression has type "List[Any]",
+ # variable has type "ndarray")
+ codes = sorted( # type: ignore[assignment]
+ htable.mode_int64(ensure_int64(codes), dropna)
+ )
codes = coerce_indexer_dtype(codes, self.dtype.categories)
return self._from_backing_data(codes)
@@ -2418,7 +2455,11 @@ def _str_get_dummies(self, sep="|"):
# sep may not be in categories. Just bail on this.
from pandas.core.arrays import PandasArray
- return PandasArray(self.astype(str))._str_get_dummies(sep)
+ # error: Argument 1 to "PandasArray" has incompatible type
+ # "ExtensionArray"; expected "Union[ndarray, PandasArray]"
+ return PandasArray(self.astype(str))._str_get_dummies( # type: ignore[arg-type]
+ sep
+ )
# The Series.cat accessor
@@ -2618,7 +2659,8 @@ def _get_codes_for_values(values, categories: Index) -> np.ndarray:
# Only hit here when we've already coerced to object dtypee.
hash_klass, vals = get_data_algo(values)
- _, cats = get_data_algo(categories)
+ # error: Value of type variable "ArrayLike" of "get_data_algo" cannot be "Index"
+ _, cats = get_data_algo(categories) # type: ignore[type-var]
t = hash_klass(len(cats))
t.map_locations(cats)
return coerce_indexer_dtype(t.lookup(vals), cats)
diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index 633a20d6bed37..c2ac7517ecba3 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -378,7 +378,10 @@ def _get_getitem_freq(self, key):
return self._get_getitem_freq(new_key)
return freq
- def __setitem__(
+ # error: Argument 1 of "__setitem__" is incompatible with supertype
+ # "ExtensionArray"; supertype defines the argument type as "Union[int,
+ # ndarray]"
+ def __setitem__( # type: ignore[override]
self,
key: Union[int, Sequence[int], Sequence[bool], slice],
value: Union[NaTType, Any, Sequence[Any]],
@@ -455,26 +458,45 @@ def view(self, dtype: Optional[Dtype] = None) -> ArrayLike:
# dtypes here. Everything else we pass through to the underlying
# ndarray.
if dtype is None or dtype is self.dtype:
- return type(self)(self._ndarray, dtype=self.dtype)
+ # error: Incompatible return value type (got "DatetimeLikeArrayMixin",
+ # expected "ndarray")
+ return type(self)( # type: ignore[return-value]
+ self._ndarray, dtype=self.dtype
+ )
if isinstance(dtype, type):
# we sometimes pass non-dtype objects, e.g np.ndarray;
# pass those through to the underlying ndarray
- return self._ndarray.view(dtype)
+
+ # error: Incompatible return value type (got "ndarray", expected
+ # "ExtensionArray")
+ return self._ndarray.view(dtype) # type: ignore[return-value]
dtype = pandas_dtype(dtype)
if isinstance(dtype, (PeriodDtype, DatetimeTZDtype)):
cls = dtype.construct_array_type()
- return cls(self.asi8, dtype=dtype)
+ # error: Incompatible return value type (got "Union[PeriodArray,
+ # DatetimeArray]", expected "ndarray")
+ return cls(self.asi8, dtype=dtype) # type: ignore[return-value]
elif dtype == "M8[ns]":
from pandas.core.arrays import DatetimeArray
- return DatetimeArray(self.asi8, dtype=dtype)
+ # error: Incompatible return value type (got "DatetimeArray", expected
+ # "ndarray")
+ return DatetimeArray(self.asi8, dtype=dtype) # type: ignore[return-value]
elif dtype == "m8[ns]":
from pandas.core.arrays import TimedeltaArray
- return TimedeltaArray(self.asi8, dtype=dtype)
- return self._ndarray.view(dtype=dtype)
+ # error: Incompatible return value type (got "TimedeltaArray", expected
+ # "ndarray")
+ return TimedeltaArray(self.asi8, dtype=dtype) # type: ignore[return-value]
+ # error: Incompatible return value type (got "ndarray", expected
+ # "ExtensionArray")
+ # error: Argument "dtype" to "view" of "_ArrayOrScalarCommon" has incompatible
+ # type "Union[ExtensionDtype, dtype[Any]]"; 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 self._ndarray.view(dtype=dtype) # type: ignore[return-value,arg-type]
# ------------------------------------------------------------------
# ExtensionArray Interface
@@ -849,7 +871,9 @@ def isin(self, values) -> np.ndarray:
# ------------------------------------------------------------------
# Null Handling
- def isna(self) -> np.ndarray:
+ # error: Return type "ndarray" of "isna" incompatible with return type "ArrayLike"
+ # in supertype "ExtensionArray"
+ def isna(self) -> np.ndarray: # type: ignore[override]
return self._isnan
@property # NB: override with cache_readonly in immutable subclasses
@@ -864,7 +888,8 @@ def _hasnans(self) -> np.ndarray:
"""
return if I have any nans; enables various perf speedups
"""
- return bool(self._isnan.any())
+ # error: Incompatible return value type (got "bool", expected "ndarray")
+ return bool(self._isnan.any()) # type: ignore[return-value]
def _maybe_mask_results(
self, result: np.ndarray, fill_value=iNaT, convert=None
@@ -1208,7 +1233,13 @@ def _addsub_object_array(self, other: np.ndarray, op):
res_values = op(self.astype("O"), np.asarray(other))
result = pd_array(res_values.ravel())
- result = extract_array(result, extract_numpy=True).reshape(self.shape)
+ # error: Item "ExtensionArray" of "Union[Any, ExtensionArray]" has no attribute
+ # "reshape"
+ result = extract_array(
+ result, extract_numpy=True
+ ).reshape( # type: ignore[union-attr]
+ self.shape
+ )
return result
def _time_shift(self, periods, freq=None):
@@ -1758,7 +1789,8 @@ def _with_freq(self, freq):
freq = to_offset(self.inferred_freq)
arr = self.view()
- arr._freq = freq
+ # error: "ExtensionArray" has no attribute "_freq"
+ arr._freq = freq # type: ignore[attr-defined]
return arr
# --------------------------------------------------------------
diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
index ce0ea7bca55cd..7e200097d7e82 100644
--- a/pandas/core/arrays/datetimes.py
+++ b/pandas/core/arrays/datetimes.py
@@ -504,7 +504,10 @@ def _box_func(self, x) -> Union[Timestamp, NaTType]:
return Timestamp(x, freq=self.freq, tz=self.tz)
@property
- def dtype(self) -> Union[np.dtype, DatetimeTZDtype]:
+ # error: Return type "Union[dtype, DatetimeTZDtype]" of "dtype"
+ # incompatible with return type "ExtensionDtype" in supertype
+ # "ExtensionArray"
+ def dtype(self) -> Union[np.dtype, DatetimeTZDtype]: # type: ignore[override]
"""
The dtype for the DatetimeArray.
diff --git a/pandas/core/arrays/floating.py b/pandas/core/arrays/floating.py
index aace5583ff47a..bbe2f23421fcf 100644
--- a/pandas/core/arrays/floating.py
+++ b/pandas/core/arrays/floating.py
@@ -305,19 +305,27 @@ def astype(self, dtype, copy: bool = True) -> ArrayLike:
dtype = pandas_dtype(dtype)
if isinstance(dtype, ExtensionDtype):
- return super().astype(dtype, copy=copy)
+ # error: Incompatible return value type (got "ExtensionArray", expected
+ # "ndarray")
+ return super().astype(dtype, copy=copy) # type: ignore[return-value]
# coerce
if is_float_dtype(dtype):
# In astype, we consider dtype=float to also mean na_value=np.nan
kwargs = {"na_value": np.nan}
elif is_datetime64_dtype(dtype):
- kwargs = {"na_value": np.datetime64("NaT")}
+ # error: Dict entry 0 has incompatible type "str": "datetime64"; expected
+ # "str": "float"
+ kwargs = {"na_value": np.datetime64("NaT")} # type: ignore[dict-item]
else:
kwargs = {}
- data = self.to_numpy(dtype=dtype, **kwargs)
- return astype_nansafe(data, dtype, copy=False)
+ # error: Argument 2 to "to_numpy" of "BaseMaskedArray" has incompatible
+ # type "**Dict[str, float]"; expected "bool"
+ data = self.to_numpy(dtype=dtype, **kwargs) # type: ignore[arg-type]
+ # error: Incompatible return value type (got "ExtensionArray", expected
+ # "ndarray")
+ return astype_nansafe(data, dtype, copy=False) # type: ignore[return-value]
def _values_for_argsort(self) -> np.ndarray:
return self._data
diff --git a/pandas/core/arrays/integer.py b/pandas/core/arrays/integer.py
index 61d63d2eed6e9..b2308233a6272 100644
--- a/pandas/core/arrays/integer.py
+++ b/pandas/core/arrays/integer.py
@@ -101,7 +101,17 @@ def _get_common_dtype(self, dtypes: List[DtypeObj]) -> Optional[DtypeObj]:
):
return None
np_dtype = np.find_common_type(
- [t.numpy_dtype if isinstance(t, BaseMaskedDtype) else t for t in dtypes], []
+ # error: List comprehension has incompatible type List[Union[Any,
+ # dtype, ExtensionDtype]]; expected List[Union[dtype, None, type,
+ # _SupportsDtype, str, Tuple[Any, Union[int, Sequence[int]]],
+ # List[Any], _DtypeDict, Tuple[Any, Any]]]
+ [
+ t.numpy_dtype # type: ignore[misc]
+ if isinstance(t, BaseMaskedDtype)
+ else t
+ for t in dtypes
+ ],
+ [],
)
if np.issubdtype(np_dtype, np.integer):
return INT_STR_TO_DTYPE[str(np_dtype)]
@@ -359,18 +369,26 @@ def astype(self, dtype, copy: bool = True) -> ArrayLike:
dtype = pandas_dtype(dtype)
if isinstance(dtype, ExtensionDtype):
- return super().astype(dtype, copy=copy)
+ # error: Incompatible return value type (got "ExtensionArray", expected
+ # "ndarray")
+ return super().astype(dtype, copy=copy) # type: ignore[return-value]
# coerce
if is_float_dtype(dtype):
# In astype, we consider dtype=float to also mean na_value=np.nan
na_value = np.nan
elif is_datetime64_dtype(dtype):
- na_value = np.datetime64("NaT")
+ # error: Incompatible types in assignment (expression has type
+ # "datetime64", variable has type "float")
+ na_value = np.datetime64("NaT") # type: ignore[assignment]
else:
na_value = lib.no_default
- return self.to_numpy(dtype=dtype, na_value=na_value, copy=False)
+ # error: Incompatible return value type (got "ndarray", expected
+ # "ExtensionArray")
+ return self.to_numpy( # type: ignore[return-value]
+ dtype=dtype, na_value=na_value, copy=False
+ )
def _values_for_argsort(self) -> np.ndarray:
"""
diff --git a/pandas/core/arrays/interval.py b/pandas/core/arrays/interval.py
index f192a34514390..7ccdad11761ab 100644
--- a/pandas/core/arrays/interval.py
+++ b/pandas/core/arrays/interval.py
@@ -641,7 +641,11 @@ def __getitem__(self, key):
if is_scalar(left) and isna(left):
return self._fill_value
return Interval(left, right, self.closed)
- if np.ndim(left) > 1:
+ # error: Argument 1 to "ndim" has incompatible type "Union[ndarray,
+ # ExtensionArray]"; expected "Union[Union[int, float, complex, str, bytes,
+ # generic], Sequence[Union[int, float, complex, str, bytes, generic]],
+ # Sequence[Sequence[Any]], _SupportsArray]"
+ if np.ndim(left) > 1: # type: ignore[arg-type]
# GH#30588 multi-dimensional indexer disallowed
raise ValueError("multi-dimensional indexing not allowed")
return self._shallow_copy(left, right)
@@ -907,7 +911,9 @@ def copy(self: IntervalArrayT) -> IntervalArrayT:
# TODO: Could skip verify_integrity here.
return type(self).from_arrays(left, right, closed=closed)
- def isna(self) -> np.ndarray:
+ # error: Return type "ndarray" of "isna" incompatible with return type
+ # "ArrayLike" in supertype "ExtensionArray"
+ def isna(self) -> np.ndarray: # type: ignore[override]
return isna(self._left)
def shift(
@@ -1612,7 +1618,10 @@ def _maybe_convert_platform_interval(values) -> ArrayLike:
# GH 19016
# empty lists/tuples get object dtype by default, but this is
# prohibited for IntervalArray, so coerce to integer instead
- return np.array([], dtype=np.int64)
+
+ # error: Incompatible return value type (got "ndarray", expected
+ # "ExtensionArray")
+ return np.array([], dtype=np.int64) # type: ignore[return-value]
elif not is_list_like(values) or isinstance(values, ABCDataFrame):
# This will raise later, but we avoid passing to maybe_convert_platform
return values
@@ -1624,4 +1633,5 @@ def _maybe_convert_platform_interval(values) -> ArrayLike:
else:
values = extract_array(values, extract_numpy=True)
- return maybe_convert_platform(values)
+ # error: Incompatible return value type (got "ExtensionArray", expected "ndarray")
+ return maybe_convert_platform(values) # type: ignore[return-value]
diff --git a/pandas/core/arrays/masked.py b/pandas/core/arrays/masked.py
index eff06a5c62894..ac0ac2bb21d62 100644
--- a/pandas/core/arrays/masked.py
+++ b/pandas/core/arrays/masked.py
@@ -212,7 +212,10 @@ def __len__(self) -> int:
def __invert__(self: BaseMaskedArrayT) -> BaseMaskedArrayT:
return type(self)(~self._data, self._mask.copy())
- def to_numpy(
+ # error: Argument 1 of "to_numpy" is incompatible with supertype "ExtensionArray";
+ # supertype defines the argument type as "Union[ExtensionDtype, str, dtype[Any],
+ # Type[str], Type[float], Type[int], Type[complex], Type[bool], Type[object], None]"
+ def to_numpy( # type: ignore[override]
self,
dtype: Optional[NpDtype] = None,
copy: bool = False,
@@ -281,7 +284,9 @@ def to_numpy(
if na_value is lib.no_default:
na_value = libmissing.NA
if dtype is None:
- dtype = object
+ # error: Incompatible types in assignment (expression has type
+ # "Type[object]", variable has type "Union[str, dtype[Any], None]")
+ dtype = object # type: ignore[assignment]
if self._hasna:
if (
not is_object_dtype(dtype)
@@ -305,8 +310,12 @@ def astype(self, dtype: Dtype, copy: bool = True) -> ArrayLike:
if is_dtype_equal(dtype, self.dtype):
if copy:
- return self.copy()
- return self
+ # error: Incompatible return value type (got "BaseMaskedArray", expected
+ # "ndarray")
+ return self.copy() # type: ignore[return-value]
+ # error: Incompatible return value type (got "BaseMaskedArray", expected
+ # "ndarray")
+ return self # type: ignore[return-value]
# if we are astyping to another nullable masked dtype, we can fastpath
if isinstance(dtype, BaseMaskedDtype):
@@ -316,7 +325,9 @@ def astype(self, dtype: Dtype, copy: bool = True) -> ArrayLike:
# not directly depending on the `copy` keyword
mask = self._mask if data is self._data else self._mask.copy()
cls = dtype.construct_array_type()
- return cls(data, mask, copy=False)
+ # error: Incompatible return value type (got "BaseMaskedArray", expected
+ # "ndarray")
+ return cls(data, mask, copy=False) # type: ignore[return-value]
if isinstance(dtype, ExtensionDtype):
eacls = dtype.construct_array_type()
@@ -346,9 +357,13 @@ def _hasna(self) -> bool:
# Note: this is expensive right now! The hope is that we can
# make this faster by having an optional mask, but not have to change
# source code using it..
- return self._mask.any()
- def isna(self) -> np.ndarray:
+ # error: Incompatible return value type (got "bool_", expected "bool")
+ return self._mask.any() # type: ignore[return-value]
+
+ # error: Return type "ndarray" of "isna" incompatible with return type
+ # "ArrayLike" in supertype "ExtensionArray"
+ def isna(self) -> np.ndarray: # type: ignore[override]
return self._mask
@property
@@ -394,7 +409,9 @@ def take(
return type(self)(result, mask, copy=False)
- def isin(self, values) -> BooleanArray:
+ # error: Return type "BooleanArray" of "isin" incompatible with return type
+ # "ndarray" in supertype "ExtensionArray"
+ def isin(self, values) -> BooleanArray: # type: ignore[override]
from pandas.core.arrays import BooleanArray
@@ -404,7 +421,9 @@ def isin(self, values) -> BooleanArray:
result += self._mask
else:
result *= np.invert(self._mask)
- mask = np.zeros_like(self, dtype=bool)
+ # error: No overload variant of "zeros_like" matches argument types
+ # "BaseMaskedArray", "Type[bool]"
+ mask = np.zeros_like(self, dtype=bool) # type: ignore[call-overload]
return BooleanArray(result, mask, copy=False)
def copy(self: BaseMaskedArrayT) -> BaseMaskedArrayT:
@@ -422,8 +441,14 @@ def factorize(self, na_sentinel: int = -1) -> Tuple[np.ndarray, ExtensionArray]:
# the hashtables don't handle all different types of bits
uniques = uniques.astype(self.dtype.numpy_dtype, copy=False)
- uniques = type(self)(uniques, np.zeros(len(uniques), dtype=bool))
- return codes, uniques
+ # error: Incompatible types in assignment (expression has type
+ # "BaseMaskedArray", variable has type "ndarray")
+ uniques = type(self)( # type: ignore[assignment]
+ uniques, np.zeros(len(uniques), dtype=bool)
+ )
+ # error: Incompatible return value type (got "Tuple[ndarray, ndarray]",
+ # expected "Tuple[ndarray, ExtensionArray]")
+ return codes, uniques # type: ignore[return-value]
def value_counts(self, dropna: bool = True) -> Series:
"""
diff --git a/pandas/core/arrays/numpy_.py b/pandas/core/arrays/numpy_.py
index fd95ab987b18a..bef047c29413b 100644
--- a/pandas/core/arrays/numpy_.py
+++ b/pandas/core/arrays/numpy_.py
@@ -97,7 +97,12 @@ def _from_sequence(
if isinstance(dtype, PandasDtype):
dtype = dtype._dtype
- result = np.asarray(scalars, dtype=dtype)
+ # error: Argument "dtype" to "asarray" has incompatible type
+ # "Union[ExtensionDtype, str, dtype[Any], dtype[floating[_64Bit]], Type[object],
+ # None]"; expected "Union[dtype[Any], None, type, _SupportsDType, str,
+ # Union[Tuple[Any, int], Tuple[Any, Union[int, Sequence[int]]], List[Any],
+ # _DTypeDict, Tuple[Any, Any]]]"
+ result = np.asarray(scalars, dtype=dtype) # type: ignore[arg-type]
if (
result.ndim > 1
and not hasattr(scalars, "dtype")
@@ -185,7 +190,9 @@ def __array_ufunc__(self, ufunc, method: str, *inputs, **kwargs):
# ------------------------------------------------------------------------
# Pandas ExtensionArray Interface
- def isna(self) -> np.ndarray:
+ # error: Return type "ndarray" of "isna" incompatible with return type
+ # "ArrayLike" in supertype "ExtensionArray"
+ def isna(self) -> np.ndarray: # type: ignore[override]
return isna(self._ndarray)
def _validate_fill_value(self, fill_value):
@@ -341,7 +348,10 @@ def skew(
# ------------------------------------------------------------------------
# Additional Methods
- def to_numpy(
+ # error: Argument 1 of "to_numpy" is incompatible with supertype "ExtensionArray";
+ # supertype defines the argument type as "Union[ExtensionDtype, str, dtype[Any],
+ # Type[str], Type[float], Type[int], Type[complex], Type[bool], Type[object], None]"
+ def to_numpy( # type: ignore[override]
self,
dtype: Optional[NpDtype] = None,
copy: bool = False,
diff --git a/pandas/core/arrays/period.py b/pandas/core/arrays/period.py
index 7e9e13400e11f..d91522a9e1bb6 100644
--- a/pandas/core/arrays/period.py
+++ b/pandas/core/arrays/period.py
@@ -1125,9 +1125,12 @@ def _make_field_arrays(*fields):
elif length is None:
length = len(x)
+ # error: Argument 2 to "repeat" has incompatible type "Optional[int]"; expected
+ # "Union[Union[int, integer[Any]], Union[bool, bool_], ndarray, Sequence[Union[int,
+ # integer[Any]]], Sequence[Union[bool, bool_]], Sequence[Sequence[Any]]]"
return [
np.asarray(x)
if isinstance(x, (np.ndarray, list, ABCSeries))
- else np.repeat(x, length)
+ else np.repeat(x, length) # type: ignore[arg-type]
for x in fields
]
diff --git a/pandas/core/arrays/sparse/accessor.py b/pandas/core/arrays/sparse/accessor.py
index c3d11793dbd8c..d4faea4fbc42c 100644
--- a/pandas/core/arrays/sparse/accessor.py
+++ b/pandas/core/arrays/sparse/accessor.py
@@ -354,7 +354,9 @@ def density(self) -> float:
"""
Ratio of non-sparse points to total (dense) data points.
"""
- return np.mean([column.array.density for _, column in self._parent.items()])
+ # error: Incompatible return value type (got "number", expected "float")
+ tmp = np.mean([column.array.density for _, column in self._parent.items()])
+ return tmp # type: ignore[return-value]
@staticmethod
def _prep_index(data, index, columns):
diff --git a/pandas/core/arrays/sparse/array.py b/pandas/core/arrays/sparse/array.py
index a209037f9a9a6..088a1165e4df0 100644
--- a/pandas/core/arrays/sparse/array.py
+++ b/pandas/core/arrays/sparse/array.py
@@ -365,7 +365,12 @@ def __init__(
# dtype inference
if data is None:
# TODO: What should the empty dtype be? Object or float?
- data = np.array([], dtype=dtype)
+
+ # error: Argument "dtype" to "array" has incompatible type
+ # "Union[ExtensionDtype, dtype[Any], None]"; expected "Union[dtype[Any],
+ # None, type, _SupportsDType, str, Union[Tuple[Any, int], Tuple[Any,
+ # Union[int, Sequence[int]]], List[Any], _DTypeDict, Tuple[Any, Any]]]"
+ data = np.array([], dtype=dtype) # type: ignore[arg-type]
if not is_array_like(data):
try:
@@ -394,7 +399,14 @@ def __init__(
if isinstance(data, type(self)) and sparse_index is None:
sparse_index = data._sparse_index
- sparse_values = np.asarray(data.sp_values, dtype=dtype)
+ # error: Argument "dtype" to "asarray" has incompatible type
+ # "Union[ExtensionDtype, dtype[Any], Type[object], None]"; expected
+ # "Union[dtype[Any], None, type, _SupportsDType, str, Union[Tuple[Any, int],
+ # Tuple[Any, Union[int, Sequence[int]]], List[Any], _DTypeDict, Tuple[Any,
+ # Any]]]"
+ sparse_values = np.asarray(
+ data.sp_values, dtype=dtype # type: ignore[arg-type]
+ )
elif sparse_index is None:
data = extract_array(data, extract_numpy=True)
if not isinstance(data, np.ndarray):
@@ -412,10 +424,21 @@ def __init__(
fill_value = np.datetime64("NaT", "ns")
data = np.asarray(data)
sparse_values, sparse_index, fill_value = make_sparse(
- data, kind=kind, fill_value=fill_value, dtype=dtype
+ # error: Argument "dtype" to "make_sparse" has incompatible type
+ # "Union[ExtensionDtype, dtype[Any], Type[object], None]"; expected
+ # "Union[str, dtype[Any], None]"
+ data,
+ kind=kind,
+ fill_value=fill_value,
+ dtype=dtype, # type: ignore[arg-type]
)
else:
- sparse_values = np.asarray(data, dtype=dtype)
+ # error: Argument "dtype" to "asarray" has incompatible type
+ # "Union[ExtensionDtype, dtype[Any], Type[object], None]"; expected
+ # "Union[dtype[Any], None, type, _SupportsDType, str, Union[Tuple[Any, int],
+ # Tuple[Any, Union[int, Sequence[int]]], List[Any], _DTypeDict, Tuple[Any,
+ # Any]]]"
+ sparse_values = np.asarray(data, dtype=dtype) # type: ignore[arg-type]
if len(sparse_values) != sparse_index.npoints:
raise AssertionError(
f"Non array-like type {type(sparse_values)} must "
@@ -503,7 +526,9 @@ def __array__(self, dtype: Optional[NpDtype] = None) -> np.ndarray:
try:
dtype = np.result_type(self.sp_values.dtype, type(fill_value))
except TypeError:
- dtype = object
+ # error: Incompatible types in assignment (expression has type
+ # "Type[object]", variable has type "Union[str, dtype[Any], None]")
+ dtype = object # type: ignore[assignment]
out = np.full(self.shape, fill_value, dtype=dtype)
out[self.sp_index.to_int_index().indices] = self.sp_values
@@ -748,7 +773,9 @@ def factorize(self, na_sentinel=-1):
# Given that we have to return a dense array of codes, why bother
# implementing an efficient factorize?
codes, uniques = algos.factorize(np.asarray(self), na_sentinel=na_sentinel)
- uniques = SparseArray(uniques, dtype=self.dtype)
+ # error: Incompatible types in assignment (expression has type "SparseArray",
+ # variable has type "Union[ndarray, Index]")
+ uniques = SparseArray(uniques, dtype=self.dtype) # type: ignore[assignment]
return codes, uniques
def value_counts(self, dropna: bool = True):
@@ -857,7 +884,9 @@ def take(self, indices, *, allow_fill=False, fill_value=None) -> SparseArray:
result = self._take_with_fill(indices, fill_value=fill_value)
kwargs = {}
else:
- result = self._take_without_fill(indices)
+ # error: Incompatible types in assignment (expression has type
+ # "Union[ndarray, SparseArray]", variable has type "ndarray")
+ result = self._take_without_fill(indices) # type: ignore[assignment]
kwargs = {"dtype": self.dtype}
return type(self)(result, fill_value=self.fill_value, kind=self.kind, **kwargs)
@@ -1094,14 +1123,38 @@ def astype(self, dtype: Optional[Dtype] = None, copy=True):
else:
return self.copy()
dtype = self.dtype.update_dtype(dtype)
- subtype = pandas_dtype(dtype._subtype_with_str)
+ # error: Item "ExtensionDtype" of "Union[ExtensionDtype, str, dtype[Any],
+ # Type[str], Type[float], Type[int], Type[complex], Type[bool], Type[object],
+ # None]" has no attribute "_subtype_with_str"
+ # error: Item "str" of "Union[ExtensionDtype, str, dtype[Any], Type[str],
+ # Type[float], Type[int], Type[complex], Type[bool], Type[object], None]" has no
+ # attribute "_subtype_with_str"
+ # error: Item "dtype[Any]" of "Union[ExtensionDtype, str, dtype[Any], Type[str],
+ # Type[float], Type[int], Type[complex], Type[bool], Type[object], None]" has no
+ # attribute "_subtype_with_str"
+ # error: Item "ABCMeta" of "Union[ExtensionDtype, str, dtype[Any], Type[str],
+ # Type[float], Type[int], Type[complex], Type[bool], Type[object], None]" has no
+ # attribute "_subtype_with_str"
+ # error: Item "type" of "Union[ExtensionDtype, str, dtype[Any], Type[str],
+ # Type[float], Type[int], Type[complex], Type[bool], Type[object], None]" has no
+ # attribute "_subtype_with_str"
+ # error: Item "None" of "Union[ExtensionDtype, str, dtype[Any], Type[str],
+ # Type[float], Type[int], Type[complex], Type[bool], Type[object], None]" has no
+ # attribute "_subtype_with_str"
+ subtype = pandas_dtype(dtype._subtype_with_str) # type: ignore[union-attr]
# TODO copy=False is broken for astype_nansafe with int -> float, so cannot
# passthrough copy keyword: https://github.com/pandas-dev/pandas/issues/34456
sp_values = astype_nansafe(self.sp_values, subtype, copy=True)
- if sp_values is self.sp_values and copy:
+ # error: Non-overlapping identity check (left operand type: "ExtensionArray",
+ # right operand t...ype: "ndarray")
+ if sp_values is self.sp_values and copy: # type: ignore[comparison-overlap]
sp_values = sp_values.copy()
- return self._simple_new(sp_values, self.sp_index, dtype)
+ # error: Argument 1 to "_simple_new" of "SparseArray" has incompatible type
+ # "ExtensionArray"; expected "ndarray"
+ return self._simple_new(
+ sp_values, self.sp_index, dtype # type: ignore[arg-type]
+ )
def map(self, mapper):
"""
@@ -1396,7 +1449,11 @@ def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
return type(self)(result)
def __abs__(self):
- return np.abs(self)
+ # error: Argument 1 to "__call__" of "ufunc" has incompatible type
+ # "SparseArray"; expected "Union[Union[int, float, complex, str, bytes,
+ # generic], Sequence[Union[int, float, complex, str, bytes, generic]],
+ # Sequence[Sequence[Any]], _SupportsArray]"
+ return np.abs(self) # type: ignore[arg-type]
# ------------------------------------------------------------------------
# Ops
@@ -1545,7 +1602,11 @@ def make_sparse(
index = make_sparse_index(length, indices, kind)
sparsified_values = arr[mask]
if dtype is not None:
- sparsified_values = astype_nansafe(sparsified_values, dtype=dtype)
+ # error: Argument "dtype" to "astype_nansafe" has incompatible type "Union[str,
+ # dtype[Any]]"; expected "Union[dtype[Any], ExtensionDtype]"
+ sparsified_values = astype_nansafe(
+ sparsified_values, dtype=dtype # type: ignore[arg-type]
+ )
# TODO: copy
return sparsified_values, index, fill_value
diff --git a/pandas/core/arrays/sparse/dtype.py b/pandas/core/arrays/sparse/dtype.py
index 948edcbd99e64..9e61675002e64 100644
--- a/pandas/core/arrays/sparse/dtype.py
+++ b/pandas/core/arrays/sparse/dtype.py
@@ -342,7 +342,10 @@ def update_dtype(self, dtype):
if is_extension_array_dtype(dtype):
raise TypeError("sparse arrays of extension dtypes not supported")
- fill_value = astype_nansafe(np.array(self.fill_value), dtype).item()
+ # error: "ExtensionArray" has no attribute "item"
+ fill_value = astype_nansafe(
+ np.array(self.fill_value), dtype
+ ).item() # type: ignore[attr-defined]
dtype = cls(dtype, fill_value=fill_value)
return dtype
diff --git a/pandas/core/arrays/string_.py b/pandas/core/arrays/string_.py
index 6fd68050bc8dc..67cd6c63c1faa 100644
--- a/pandas/core/arrays/string_.py
+++ b/pandas/core/arrays/string_.py
@@ -320,7 +320,9 @@ def astype(self, dtype, copy=True):
values = arr.astype(dtype.numpy_dtype)
return IntegerArray(values, mask, copy=False)
elif isinstance(dtype, FloatingDtype):
- arr = self.copy()
+ # error: Incompatible types in assignment (expression has type
+ # "StringArray", variable has type "ndarray")
+ arr = self.copy() # type: ignore[assignment]
mask = self.isna()
arr[mask] = "0"
values = arr.astype(dtype.numpy_dtype)
@@ -434,7 +436,12 @@ def _str_map(self, f, na_value=None, dtype: Optional[Dtype] = None):
mask.view("uint8"),
convert=False,
na_value=na_value,
- dtype=np.dtype(dtype),
+ # error: Value of type variable "_DTypeScalar" of "dtype" cannot be
+ # "object"
+ # error: Argument 1 to "dtype" has incompatible type
+ # "Union[ExtensionDtype, str, dtype[Any], Type[object]]"; expected
+ # "Type[object]"
+ dtype=np.dtype(dtype), # type: ignore[type-var,arg-type]
)
if not na_value_is_na:
diff --git a/pandas/core/arrays/string_arrow.py b/pandas/core/arrays/string_arrow.py
index e003efeabcb66..efdc18cd071b5 100644
--- a/pandas/core/arrays/string_arrow.py
+++ b/pandas/core/arrays/string_arrow.py
@@ -248,7 +248,10 @@ def __arrow_array__(self, type=None):
"""Convert myself to a pyarrow Array or ChunkedArray."""
return self._data
- def to_numpy(
+ # error: Argument 1 of "to_numpy" is incompatible with supertype "ExtensionArray";
+ # supertype defines the argument type as "Union[ExtensionDtype, str, dtype[Any],
+ # Type[str], Type[float], Type[int], Type[complex], Type[bool], Type[object], None]"
+ def to_numpy( # type: ignore[override]
self,
dtype: Optional[NpDtype] = None,
copy: bool = False,
@@ -341,7 +344,9 @@ def __getitem__(self, item: Any) -> Any:
if not len(item):
return type(self)(pa.chunked_array([], type=pa.string()))
elif is_integer_dtype(item.dtype):
- return self.take(item)
+ # error: Argument 1 to "take" of "ArrowStringArray" has incompatible
+ # type "ndarray"; expected "Sequence[int]"
+ return self.take(item) # type: ignore[arg-type]
elif is_bool_dtype(item.dtype):
return type(self)(self._data.filter(item))
else:
@@ -400,7 +405,13 @@ def fillna(self, value=None, method=None, limit=None):
if mask.any():
if method is not None:
func = missing.get_fill_func(method)
- new_values, _ = func(self.to_numpy(object), limit=limit, mask=mask)
+ # error: Argument 1 to "to_numpy" of "ArrowStringArray" has incompatible
+ # type "Type[object]"; expected "Union[str, dtype[Any], None]"
+ new_values, _ = func(
+ self.to_numpy(object), # type: ignore[arg-type]
+ limit=limit,
+ mask=mask,
+ )
new_values = self._from_sequence(new_values)
else:
# fill with value
@@ -423,7 +434,9 @@ def nbytes(self) -> int:
"""
return self._data.nbytes
- def isna(self) -> np.ndarray:
+ # error: Return type "ndarray" of "isna" incompatible with return type "ArrayLike"
+ # in supertype "ExtensionArray"
+ def isna(self) -> np.ndarray: # type: ignore[override]
"""
Boolean NumPy array indicating if each value is missing.
@@ -498,7 +511,8 @@ def __setitem__(self, key: Union[int, np.ndarray], value: Any) -> None:
# Slice data and insert in-between
new_data = [
- *self._data[0:key].chunks,
+ # error: Slice index must be an integer or None
+ *self._data[0:key].chunks, # type: ignore[misc]
pa.array([value], type=pa.string()),
*self._data[(key + 1) :].chunks,
]
@@ -589,7 +603,9 @@ def take(
if not is_array_like(indices):
indices_array = np.asanyarray(indices)
else:
- indices_array = indices
+ # error: Incompatible types in assignment (expression has type
+ # "Sequence[int]", variable has type "ndarray")
+ indices_array = indices # type: ignore[assignment]
if len(self._data) == 0 and (indices_array >= 0).any():
raise IndexError("cannot do a non-empty take")
diff --git a/pandas/core/arrays/timedeltas.py b/pandas/core/arrays/timedeltas.py
index c371e27eeceac..5a45a8d105f6e 100644
--- a/pandas/core/arrays/timedeltas.py
+++ b/pandas/core/arrays/timedeltas.py
@@ -148,7 +148,9 @@ def _box_func(self, x) -> Union[Timedelta, NaTType]:
return Timedelta(x, unit="ns")
@property
- def dtype(self) -> np.dtype:
+ # error: Return type "dtype" of "dtype" incompatible with return type
+ # "ExtensionDtype" in supertype "ExtensionArray"
+ def dtype(self) -> np.dtype: # type: ignore[override]
"""
The dtype for the TimedeltaArray.
@@ -666,7 +668,11 @@ def __floordiv__(self, other):
return result
elif is_object_dtype(other.dtype):
- result = [self[n] // other[n] for n in range(len(self))]
+ # error: Incompatible types in assignment (expression has type
+ # "List[Any]", variable has type "ndarray")
+ result = [ # type: ignore[assignment]
+ self[n] // other[n] for n in range(len(self))
+ ]
result = np.array(result)
if lib.infer_dtype(result, skipna=False) == "timedelta":
result, _ = sequence_to_td64ns(result)
@@ -720,7 +726,11 @@ def __rfloordiv__(self, other):
return result
elif is_object_dtype(other.dtype):
- result = [other[n] // self[n] for n in range(len(self))]
+ # error: Incompatible types in assignment (expression has type
+ # "List[Any]", variable has type "ndarray")
+ result = [ # type: ignore[assignment]
+ other[n] // self[n] for n in range(len(self))
+ ]
result = np.array(result)
return result
diff --git a/pandas/core/base.py b/pandas/core/base.py
index c02f7bb2edf58..1943aafc7c760 100644
--- a/pandas/core/base.py
+++ b/pandas/core/base.py
@@ -617,7 +617,12 @@ def to_numpy(
f"to_numpy() got an unexpected keyword argument '{bad_keys}'"
)
- result = np.asarray(self._values, dtype=dtype)
+ # error: Argument "dtype" to "asarray" 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],
+ # None, type, _SupportsDType, str, Union[Tuple[Any, int], Tuple[Any, Union[int,
+ # Sequence[int]]], List[Any], _DTypeDict, Tuple[Any, Any]]]"
+ result = np.asarray(self._values, dtype=dtype) # type: ignore[arg-type]
# TODO(GH-24345): Avoid potential double copy
if copy or na_value is not lib.no_default:
result = result.copy()
@@ -730,12 +735,17 @@ def argmax(self, axis=None, skipna: bool = True, *args, **kwargs) -> int:
skipna = nv.validate_argmax_with_skipna(skipna, args, kwargs)
if isinstance(delegate, ExtensionArray):
- if not skipna and delegate.isna().any():
+ # error: "ExtensionArray" has no attribute "any"
+ if not skipna and delegate.isna().any(): # type: ignore[attr-defined]
return -1
else:
return delegate.argmax()
else:
- return nanops.nanargmax(delegate, skipna=skipna)
+ # error: Incompatible return value type (got "Union[int, ndarray]", expected
+ # "int")
+ return nanops.nanargmax( # type: ignore[return-value]
+ delegate, skipna=skipna
+ )
def min(self, axis=None, skipna: bool = True, *args, **kwargs):
"""
@@ -788,12 +798,17 @@ def argmin(self, axis=None, skipna=True, *args, **kwargs) -> int:
skipna = nv.validate_argmin_with_skipna(skipna, args, kwargs)
if isinstance(delegate, ExtensionArray):
- if not skipna and delegate.isna().any():
+ # error: "ExtensionArray" has no attribute "any"
+ if not skipna and delegate.isna().any(): # type: ignore[attr-defined]
return -1
else:
return delegate.argmin()
else:
- return nanops.nanargmin(delegate, skipna=skipna)
+ # error: Incompatible return value type (got "Union[int, ndarray]", expected
+ # "int")
+ return nanops.nanargmin( # type: ignore[return-value]
+ delegate, skipna=skipna
+ )
def tolist(self):
"""
@@ -1318,4 +1333,6 @@ def drop_duplicates(self, keep="first"):
return self[~duplicated] # type: ignore[index]
def duplicated(self, keep: Union[str, bool] = "first") -> np.ndarray:
- return duplicated(self._values, keep=keep)
+ # error: Value of type variable "ArrayLike" of "duplicated" cannot be
+ # "Union[ExtensionArray, ndarray]"
+ return duplicated(self._values, keep=keep) # type: ignore[type-var]
diff --git a/pandas/core/common.py b/pandas/core/common.py
index 0b2dec371bf02..83848e0532253 100644
--- a/pandas/core/common.py
+++ b/pandas/core/common.py
@@ -228,9 +228,16 @@ def asarray_tuplesafe(values, dtype: Optional[NpDtype] = None) -> np.ndarray:
if not (isinstance(values, (list, tuple)) or hasattr(values, "__array__")):
values = list(values)
elif isinstance(values, ABCIndex):
- return values._values
-
- if isinstance(values, list) and dtype in [np.object_, object]:
+ # error: Incompatible return value type (got "Union[ExtensionArray, ndarray]",
+ # expected "ndarray")
+ return values._values # type: ignore[return-value]
+
+ # error: Non-overlapping container check (element type: "Union[str, dtype[Any],
+ # None]", container item type: "type")
+ if isinstance(values, list) and dtype in [ # type: ignore[comparison-overlap]
+ np.object_,
+ object,
+ ]:
return construct_1d_object_array_from_listlike(values)
result = np.asarray(values, dtype=dtype)
diff --git a/pandas/core/construction.py b/pandas/core/construction.py
index 43900709ad11f..46f32ee401603 100644
--- a/pandas/core/construction.py
+++ b/pandas/core/construction.py
@@ -306,7 +306,17 @@ def array(
# Note: we exclude np.ndarray here, will do type inference on it
dtype = data.dtype
- data = extract_array(data, extract_numpy=True)
+ # error: Value of type variable "AnyArrayLike" of "extract_array" cannot be
+ # "Union[Sequence[object], ExtensionArray]"
+ # error: Value of type variable "AnyArrayLike" of "extract_array" cannot be
+ # "Union[Sequence[object], Index]"
+ # error: Incompatible types in assignment (expression has type "ExtensionArray",
+ # variable has type "Union[Sequence[object], Index]")
+ # error: Incompatible types in assignment (expression has type "ExtensionArray",
+ # variable has type "Union[Sequence[object], Series]")
+ # error: Incompatible types in assignment (expression has type "ExtensionArray",
+ # variable has type "Union[Sequence[object], ndarray]")
+ data = extract_array(data, extract_numpy=True) # type: ignore[type-var,assignment]
# this returns None for not-found dtypes.
if isinstance(dtype, str):
@@ -500,7 +510,9 @@ def sanitize_array(
try:
subarr = _try_cast(data, dtype, copy, True)
except ValueError:
- subarr = np.array(data, copy=copy)
+ # error: Incompatible types in assignment (expression has type
+ # "ndarray", variable has type "ExtensionArray")
+ subarr = np.array(data, copy=copy) # type: ignore[assignment]
else:
# we will try to copy by-definition here
subarr = _try_cast(data, dtype, copy, raise_cast_failure)
@@ -513,7 +525,9 @@ def sanitize_array(
subarr = subarr.astype(dtype, copy=copy)
elif copy:
subarr = subarr.copy()
- return subarr
+ # error: Incompatible return value type (got "ExtensionArray", expected
+ # "ndarray")
+ return subarr # type: ignore[return-value]
elif isinstance(data, (list, tuple, abc.Set, abc.ValuesView)) and len(data) > 0:
# TODO: deque, array.array
@@ -526,7 +540,10 @@ def sanitize_array(
subarr = _try_cast(data, dtype, copy, raise_cast_failure)
else:
subarr = maybe_convert_platform(data)
- subarr = maybe_cast_to_datetime(subarr, dtype)
+ # error: Incompatible types in assignment (expression has type
+ # "Union[ExtensionArray, ndarray, List[Any]]", variable has type
+ # "ExtensionArray")
+ subarr = maybe_cast_to_datetime(subarr, dtype) # type: ignore[assignment]
elif isinstance(data, range):
# GH#16804
@@ -547,7 +564,13 @@ def sanitize_array(
subarr = _sanitize_ndim(subarr, data, dtype, index)
if not (is_extension_array_dtype(subarr.dtype) or is_extension_array_dtype(dtype)):
- subarr = _sanitize_str_dtypes(subarr, data, dtype, copy)
+ # error: Incompatible types in assignment (expression has type "ndarray",
+ # variable has type "ExtensionArray")
+ # error: Argument 1 to "_sanitize_str_dtypes" has incompatible type
+ # "ExtensionArray"; expected "ndarray"
+ subarr = _sanitize_str_dtypes( # type: ignore[assignment]
+ subarr, data, dtype, copy # type: ignore[arg-type]
+ )
is_object_or_str_dtype = is_object_dtype(dtype) or is_string_dtype(dtype)
if is_object_dtype(subarr.dtype) and not is_object_or_str_dtype:
@@ -556,7 +579,8 @@ def sanitize_array(
subarr = array(subarr)
subarr = extract_array(subarr, extract_numpy=True)
- return subarr
+ # error: Incompatible return value type (got "ExtensionArray", expected "ndarray")
+ return subarr # type: ignore[return-value]
def _sanitize_ndim(
@@ -577,11 +601,25 @@ def _sanitize_ndim(
raise ValueError("Data must be 1-dimensional")
if is_object_dtype(dtype) and isinstance(dtype, ExtensionDtype):
# i.e. PandasDtype("O")
- result = com.asarray_tuplesafe(data, dtype=object)
+
+ # error: Incompatible types in assignment (expression has type "ndarray",
+ # variable has type "ExtensionArray")
+ # error: Argument "dtype" to "asarray_tuplesafe" has incompatible type
+ # "Type[object]"; expected "Union[str, dtype[Any], None]"
+ result = com.asarray_tuplesafe( # type: ignore[assignment]
+ data, dtype=object # type: ignore[arg-type]
+ )
cls = dtype.construct_array_type()
result = cls._from_sequence(result, dtype=dtype)
else:
- result = com.asarray_tuplesafe(data, dtype=dtype)
+ # error: Incompatible types in assignment (expression has type "ndarray",
+ # variable has type "ExtensionArray")
+ # error: Argument "dtype" to "asarray_tuplesafe" has incompatible type
+ # "Union[dtype[Any], ExtensionDtype, None]"; expected "Union[str,
+ # dtype[Any], None]"
+ result = com.asarray_tuplesafe( # type: ignore[assignment]
+ data, dtype=dtype # type: ignore[arg-type]
+ )
return result
@@ -600,7 +638,11 @@ def _sanitize_str_dtypes(
# GH#19853: If data is a scalar, result has already the result
if not lib.is_scalar(data):
if not np.all(isna(data)):
- data = np.array(data, dtype=dtype, copy=False)
+ # error: Argument "dtype" to "array" has incompatible type
+ # "Union[dtype[Any], ExtensionDtype, None]"; expected "Union[dtype[Any],
+ # None, type, _SupportsDType, str, Union[Tuple[Any, int], Tuple[Any,
+ # Union[int, Sequence[int]]], List[Any], _DTypeDict, Tuple[Any, Any]]]"
+ data = np.array(data, dtype=dtype, copy=False) # type: ignore[arg-type]
result = np.array(data, dtype=object, copy=copy)
return result
@@ -647,7 +689,9 @@ def _try_cast(
and not copy
and dtype is None
):
- return arr
+ # error: Incompatible return value type (got "ndarray", expected
+ # "ExtensionArray")
+ return arr # type: ignore[return-value]
if isinstance(dtype, ExtensionDtype) and (dtype.kind != "M" or is_sparse(dtype)):
# create an extension array from its dtype
@@ -666,7 +710,12 @@ def _try_cast(
# that we can convert the data to the requested dtype.
if is_integer_dtype(dtype):
# this will raise if we have e.g. floats
- maybe_cast_to_integer_array(arr, dtype)
+
+ # error: Argument 2 to "maybe_cast_to_integer_array" has incompatible type
+ # "Union[dtype, ExtensionDtype, None]"; expected "Union[ExtensionDtype, str,
+ # dtype, Type[str], Type[float], Type[int], Type[complex], Type[bool],
+ # Type[object]]"
+ maybe_cast_to_integer_array(arr, dtype) # type: ignore[arg-type]
subarr = arr
else:
subarr = maybe_cast_to_datetime(arr, dtype)
diff --git a/pandas/core/describe.py b/pandas/core/describe.py
index 3a872c6202e04..57a33e7f90e51 100644
--- a/pandas/core/describe.py
+++ b/pandas/core/describe.py
@@ -192,7 +192,9 @@ def _select_data(self):
# when some numerics are found, keep only numerics
default_include = [np.number]
if self.datetime_is_numeric:
- default_include.append("datetime")
+ # error: Argument 1 to "append" of "list" has incompatible type "str";
+ # expected "Type[number[Any]]"
+ default_include.append("datetime") # type: ignore[arg-type]
data = self.obj.select_dtypes(include=default_include)
if len(data.columns) == 0:
data = self.obj
@@ -232,7 +234,10 @@ def describe_numeric_1d(series: Series, percentiles: Sequence[float]) -> Series:
"""
from pandas import Series
- formatted_percentiles = format_percentiles(percentiles)
+ # error: Argument 1 to "format_percentiles" has incompatible type "Sequence[float]";
+ # expected "Union[ndarray, List[Union[int, float]], List[float], List[Union[str,
+ # float]]]"
+ formatted_percentiles = format_percentiles(percentiles) # type: ignore[arg-type]
stat_index = ["count", "mean", "std", "min"] + formatted_percentiles + ["max"]
d = (
@@ -336,7 +341,10 @@ def describe_timestamp_1d(data: Series, percentiles: Sequence[float]) -> Series:
# GH-30164
from pandas import Series
- formatted_percentiles = format_percentiles(percentiles)
+ # error: Argument 1 to "format_percentiles" has incompatible type "Sequence[float]";
+ # expected "Union[ndarray, List[Union[int, float]], List[float], List[Union[str,
+ # float]]]"
+ formatted_percentiles = format_percentiles(percentiles) # type: ignore[arg-type]
stat_index = ["count", "mean", "min"] + formatted_percentiles + ["max"]
d = (
@@ -392,7 +400,9 @@ def refine_percentiles(percentiles: Optional[Sequence[float]]) -> Sequence[float
The percentiles to include in the output.
"""
if percentiles is None:
- return np.array([0.25, 0.5, 0.75])
+ # error: Incompatible return value type (got "ndarray", expected
+ # "Sequence[float]")
+ return np.array([0.25, 0.5, 0.75]) # type: ignore[return-value]
# explicit conversion of `percentiles` to list
percentiles = list(percentiles)
@@ -404,7 +414,9 @@ def refine_percentiles(percentiles: Optional[Sequence[float]]) -> Sequence[float
if 0.5 not in percentiles:
percentiles.append(0.5)
- percentiles = np.asarray(percentiles)
+ # error: Incompatible types in assignment (expression has type "ndarray", variable
+ # has type "Optional[Sequence[float]]")
+ percentiles = np.asarray(percentiles) # type: ignore[assignment]
# sort and check for duplicates
unique_pcts = np.unique(percentiles)
diff --git a/pandas/core/dtypes/cast.py b/pandas/core/dtypes/cast.py
index 6eca89e1a8744..c5d672b207369 100644
--- a/pandas/core/dtypes/cast.py
+++ b/pandas/core/dtypes/cast.py
@@ -128,12 +128,16 @@ def maybe_convert_platform(
else:
# The caller is responsible for ensuring that we have np.ndarray
# or ExtensionArray here.
- arr = values
+
+ # error: Incompatible types in assignment (expression has type "Union[ndarray,
+ # ExtensionArray]", variable has type "ndarray")
+ arr = values # type: ignore[assignment]
if arr.dtype == object:
arr = lib.maybe_convert_objects(arr)
- return arr
+ # error: Incompatible return value type (got "ndarray", expected "ExtensionArray")
+ return arr # type: ignore[return-value]
def is_nested_object(obj) -> bool:
@@ -279,7 +283,9 @@ def maybe_downcast_to_dtype(
with suppress(TypeError):
# e.g. TypeError: int() argument must be a string, a
# bytes-like object or a number, not 'Period
- return PeriodArray(result, freq=dtype.freq)
+
+ # error: "dtype[Any]" has no attribute "freq"
+ return PeriodArray(result, freq=dtype.freq) # type: ignore[attr-defined]
converted = maybe_downcast_numeric(result, dtype, do_round)
if converted is not result:
@@ -406,11 +412,20 @@ def maybe_cast_result(
):
# We have to special case categorical so as not to upcast
# things like counts back to categorical
- cls = dtype.construct_array_type()
- result = maybe_cast_to_extension_array(cls, result, dtype=dtype)
+
+ # error: Item "dtype[Any]" of "Union[dtype[Any], ExtensionDtype]" has no
+ # attribute "construct_array_type"
+ cls = dtype.construct_array_type() # type: ignore[union-attr]
+ # error: Argument "dtype" to "maybe_cast_to_extension_array" has incompatible
+ # type "Union[dtype[Any], ExtensionDtype]"; expected "Optional[ExtensionDtype]"
+ result = maybe_cast_to_extension_array(
+ cls, result, dtype=dtype # type: ignore[arg-type]
+ )
elif numeric_only and is_numeric_dtype(dtype) or not numeric_only:
- result = maybe_downcast_to_dtype(result, dtype)
+ # error: Argument 2 to "maybe_downcast_to_dtype" has incompatible type
+ # "Union[dtype[Any], ExtensionDtype]"; expected "Union[str, dtype[Any]]"
+ result = maybe_downcast_to_dtype(result, dtype) # type: ignore[arg-type]
return result
@@ -532,7 +547,11 @@ def maybe_upcast_putmask(result: np.ndarray, mask: np.ndarray) -> np.ndarray:
new_dtype = ensure_dtype_can_hold_na(result.dtype)
if new_dtype != result.dtype:
- result = result.astype(new_dtype, copy=True)
+ # 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]]]"
+ result = result.astype(new_dtype, copy=True) # type: ignore[arg-type]
np.place(result, mask, np.nan)
@@ -615,7 +634,9 @@ def _maybe_promote(dtype: np.dtype, fill_value=np.nan):
kinds = ["i", "u", "f", "c", "m", "M"]
if is_valid_na_for_dtype(fill_value, dtype) and dtype.kind in kinds:
- dtype = ensure_dtype_can_hold_na(dtype)
+ # error: Incompatible types in assignment (expression has type
+ # "Union[dtype[Any], ExtensionDtype]", variable has type "dtype[Any]")
+ dtype = ensure_dtype_can_hold_na(dtype) # type: ignore[assignment]
fv = na_value_for_dtype(dtype)
return dtype, fv
@@ -666,13 +687,15 @@ def _maybe_promote(dtype: np.dtype, fill_value=np.nan):
if fv.tz is None:
return dtype, fv.asm8
- return np.dtype(object), fill_value
+ # error: Value of type variable "_DTypeScalar" of "dtype" cannot be "object"
+ return np.dtype(object), fill_value # type: ignore[type-var]
elif issubclass(dtype.type, np.timedelta64):
inferred, fv = infer_dtype_from_scalar(fill_value, pandas_dtype=True)
if inferred == dtype:
return dtype, fv
- return np.dtype(object), fill_value
+ # error: Value of type variable "_DTypeScalar" of "dtype" cannot be "object"
+ return np.dtype(object), fill_value # type: ignore[type-var]
elif is_float(fill_value):
if issubclass(dtype.type, np.bool_):
@@ -916,7 +939,9 @@ def infer_dtype_from_array(
(dtype('O'), [1, '1'])
"""
if isinstance(arr, np.ndarray):
- return arr.dtype, arr
+ # error: Incompatible return value type (got "Tuple[dtype, ndarray]", expected
+ # "Tuple[Union[dtype, ExtensionDtype], ExtensionArray]")
+ return arr.dtype, arr # type: ignore[return-value]
if not is_list_like(arr):
raise TypeError("'arr' must be list-like")
@@ -925,7 +950,9 @@ def infer_dtype_from_array(
return arr.dtype, arr
elif isinstance(arr, ABCSeries):
- return arr.dtype, np.asarray(arr)
+ # error: Incompatible return value type (got "Tuple[Any, ndarray]", expected
+ # "Tuple[Union[dtype, ExtensionDtype], ExtensionArray]")
+ return arr.dtype, np.asarray(arr) # type: ignore[return-value]
# don't force numpy coerce with nan's
inferred = lib.infer_dtype(arr, skipna=False)
@@ -1005,7 +1032,14 @@ def invalidate_string_dtypes(dtype_set: Set[DtypeObj]):
Change string like dtypes to object for
``DataFrame.select_dtypes()``.
"""
- non_string_dtypes = dtype_set - {np.dtype("S").type, np.dtype("<U").type}
+ # error: Argument 1 to <set> has incompatible type "Type[generic]"; expected
+ # "Union[dtype[Any], ExtensionDtype, None]"
+ # error: Argument 2 to <set> has incompatible type "Type[generic]"; expected
+ # "Union[dtype[Any], ExtensionDtype, None]"
+ non_string_dtypes = dtype_set - {
+ np.dtype("S").type, # type: ignore[arg-type]
+ np.dtype("<U").type, # type: ignore[arg-type]
+ }
if non_string_dtypes != dtype_set:
raise TypeError("string dtypes are not allowed, use 'object' instead")
@@ -1033,12 +1067,18 @@ def astype_dt64_to_dt64tz(
from pandas.core.construction import ensure_wrapped_if_datetimelike
values = ensure_wrapped_if_datetimelike(values)
- values = cast("DatetimeArray", values)
+ # error: Incompatible types in assignment (expression has type "DatetimeArray",
+ # variable has type "ndarray")
+ values = cast("DatetimeArray", values) # type: ignore[assignment]
aware = isinstance(dtype, DatetimeTZDtype)
if via_utc:
# Series.astype behavior
- assert values.tz is None and aware # caller is responsible for checking this
+
+ # caller is responsible for checking this
+
+ # error: "ndarray" has no attribute "tz"
+ assert values.tz is None and aware # type: ignore[attr-defined]
dtype = cast(DatetimeTZDtype, dtype)
if copy:
@@ -1056,12 +1096,17 @@ def astype_dt64_to_dt64tz(
# FIXME: GH#33401 this doesn't match DatetimeArray.astype, which
# goes through the `not via_utc` path
- return values.tz_localize("UTC").tz_convert(dtype.tz)
+
+ # error: "ndarray" has no attribute "tz_localize"
+ return values.tz_localize("UTC").tz_convert( # type: ignore[attr-defined]
+ dtype.tz
+ )
else:
# DatetimeArray/DatetimeIndex.astype behavior
- if values.tz is None and aware:
+ # error: "ndarray" has no attribute "tz"
+ if values.tz is None and aware: # type: ignore[attr-defined]
dtype = cast(DatetimeTZDtype, dtype)
level = find_stack_level()
warnings.warn(
@@ -1072,17 +1117,20 @@ def astype_dt64_to_dt64tz(
stacklevel=level,
)
- return values.tz_localize(dtype.tz)
+ # error: "ndarray" has no attribute "tz_localize"
+ return values.tz_localize(dtype.tz) # type: ignore[attr-defined]
elif aware:
# GH#18951: datetime64_tz dtype but not equal means different tz
dtype = cast(DatetimeTZDtype, dtype)
- result = values.tz_convert(dtype.tz)
+ # error: "ndarray" has no attribute "tz_convert"
+ result = values.tz_convert(dtype.tz) # type: ignore[attr-defined]
if copy:
result = result.copy()
return result
- elif values.tz is not None:
+ # error: "ndarray" has no attribute "tz"
+ elif values.tz is not None: # type: ignore[attr-defined]
level = find_stack_level()
warnings.warn(
"Using .astype to convert from timezone-aware dtype to "
@@ -1093,7 +1141,10 @@ def astype_dt64_to_dt64tz(
stacklevel=level,
)
- result = values.tz_convert("UTC").tz_localize(None)
+ # error: "ndarray" has no attribute "tz_convert"
+ result = values.tz_convert("UTC").tz_localize( # type: ignore[attr-defined]
+ None
+ )
if copy:
result = result.copy()
return result
@@ -1161,7 +1212,8 @@ def astype_nansafe(
flat = arr.ravel("K")
result = astype_nansafe(flat, dtype, copy=copy, skipna=skipna)
order = "F" if flags.f_contiguous else "C"
- return result.reshape(arr.shape, order=order)
+ # error: "ExtensionArray" has no attribute "reshape"; maybe "shape"?
+ return result.reshape(arr.shape, order=order) # type: ignore[attr-defined]
# We get here with 0-dim from sparse
arr = np.atleast_1d(arr)
@@ -1179,7 +1231,9 @@ def astype_nansafe(
from pandas.core.construction import ensure_wrapped_if_datetimelike
arr = ensure_wrapped_if_datetimelike(arr)
- return arr.astype(dtype, copy=copy)
+ # error: Incompatible return value type (got "ndarray", expected
+ # "ExtensionArray")
+ return arr.astype(dtype, copy=copy) # type: ignore[return-value]
if issubclass(dtype.type, str):
return lib.ensure_string_array(arr, skipna=skipna, convert_na_value=False)
@@ -1196,11 +1250,15 @@ def astype_nansafe(
)
if isna(arr).any():
raise ValueError("Cannot convert NaT values to integer")
- return arr.view(dtype)
+ # error: Incompatible return value type (got "ndarray", expected
+ # "ExtensionArray")
+ return arr.view(dtype) # type: ignore[return-value]
# allow frequency conversions
if dtype.kind == "M":
- return arr.astype(dtype)
+ # error: Incompatible return value type (got "ndarray", expected
+ # "ExtensionArray")
+ return arr.astype(dtype) # type: ignore[return-value]
raise TypeError(f"cannot astype a datetimelike from [{arr.dtype}] to [{dtype}]")
@@ -1216,10 +1274,16 @@ def astype_nansafe(
)
if isna(arr).any():
raise ValueError("Cannot convert NaT values to integer")
- return arr.view(dtype)
+ # error: Incompatible return value type (got "ndarray", expected
+ # "ExtensionArray")
+ return arr.view(dtype) # type: ignore[return-value]
elif dtype.kind == "m":
- return astype_td64_unit_conversion(arr, dtype, copy=copy)
+ # error: Incompatible return value type (got "ndarray", expected
+ # "ExtensionArray")
+ return astype_td64_unit_conversion( # type: ignore[return-value]
+ arr, dtype, copy=copy
+ )
raise TypeError(f"cannot astype a timedelta from [{arr.dtype}] to [{dtype}]")
@@ -1240,11 +1304,23 @@ def astype_nansafe(
elif is_datetime64_dtype(dtype):
from pandas import to_datetime
- return astype_nansafe(to_datetime(arr).values, dtype, copy=copy)
+ # error: Incompatible return value type (got "ExtensionArray", expected
+ # "ndarray")
+ return astype_nansafe( # type: ignore[return-value]
+ # error: No overload variant of "to_datetime" matches argument type
+ # "ndarray"
+ to_datetime(arr).values, # type: ignore[call-overload]
+ dtype,
+ copy=copy,
+ )
elif is_timedelta64_dtype(dtype):
from pandas import to_timedelta
- return astype_nansafe(to_timedelta(arr)._values, dtype, copy=copy)
+ # error: Incompatible return value type (got "ExtensionArray", expected
+ # "ndarray")
+ return astype_nansafe( # type: ignore[return-value]
+ to_timedelta(arr)._values, dtype, copy=copy
+ )
if dtype.name in ("datetime64", "timedelta64"):
msg = (
@@ -1255,9 +1331,13 @@ def astype_nansafe(
if copy or is_object_dtype(arr.dtype) or is_object_dtype(dtype):
# Explicit copy, or required since NumPy can't view from / to object.
- return arr.astype(dtype, copy=True)
- return arr.astype(dtype, copy=copy)
+ # error: Incompatible return value type (got "ndarray", expected
+ # "ExtensionArray")
+ return arr.astype(dtype, copy=True) # type: ignore[return-value]
+
+ # error: Incompatible return value type (got "ndarray", expected "ExtensionArray")
+ return arr.astype(dtype, copy=copy) # type: ignore[return-value]
def astype_array(values: ArrayLike, dtype: DtypeObj, copy: bool = False) -> ArrayLike:
@@ -1286,7 +1366,11 @@ def astype_array(values: ArrayLike, dtype: DtypeObj, copy: bool = False) -> Arra
raise TypeError(msg)
if is_datetime64tz_dtype(dtype) and is_datetime64_dtype(values.dtype):
- return astype_dt64_to_dt64tz(values, dtype, copy, via_utc=True)
+ # error: Incompatible return value type (got "DatetimeArray", expected
+ # "ndarray")
+ return astype_dt64_to_dt64tz( # type: ignore[return-value]
+ values, dtype, copy, via_utc=True
+ )
if is_dtype_equal(values.dtype, dtype):
if copy:
@@ -1297,11 +1381,19 @@ def astype_array(values: ArrayLike, dtype: DtypeObj, copy: bool = False) -> Arra
values = values.astype(dtype, copy=copy)
else:
- values = astype_nansafe(values, dtype, copy=copy)
+ # error: Incompatible types in assignment (expression has type "ExtensionArray",
+ # variable has type "ndarray")
+ # error: Argument 1 to "astype_nansafe" has incompatible type "ExtensionArray";
+ # expected "ndarray"
+ values = astype_nansafe( # type: ignore[assignment]
+ values, dtype, copy=copy # type: ignore[arg-type]
+ )
# in pandas we don't store numpy str dtypes, so convert to object
if isinstance(dtype, np.dtype) and issubclass(values.dtype.type, str):
- values = np.array(values, dtype=object)
+ # error: Incompatible types in assignment (expression has type "ndarray",
+ # variable has type "ExtensionArray")
+ values = np.array(values, dtype=object) # type: ignore[assignment]
return values
@@ -1402,7 +1494,9 @@ def soft_convert_objects(
values, convert_datetime=datetime, convert_timedelta=timedelta
)
except (OutOfBoundsDatetime, ValueError):
- return values
+ # error: Incompatible return value type (got "ndarray", expected
+ # "ExtensionArray")
+ return values # type: ignore[return-value]
if numeric and is_object_dtype(values.dtype):
converted = lib.maybe_convert_numeric(values, set(), coerce_numeric=True)
@@ -1411,7 +1505,8 @@ def soft_convert_objects(
values = converted if not isna(converted).all() else values
values = values.copy() if copy else values
- return values
+ # error: Incompatible return value type (got "ndarray", expected "ExtensionArray")
+ return values # type: ignore[return-value]
def convert_dtypes(
@@ -1562,12 +1657,20 @@ def try_datetime(v: np.ndarray) -> ArrayLike:
dta = sequence_to_datetimes(v, require_iso8601=True, allow_object=True)
except (ValueError, TypeError):
# e.g. <class 'numpy.timedelta64'> is not convertible to datetime
- return v.reshape(shape)
+
+ # error: Incompatible return value type (got "ndarray", expected
+ # "ExtensionArray")
+ return v.reshape(shape) # type: ignore[return-value]
else:
# GH#19761 we may have mixed timezones, in which cast 'dta' is
# an ndarray[object]. Only 1 test
# relies on this behavior, see GH#40111
- return dta.reshape(shape)
+
+ # error: Incompatible return value type (got "Union[ndarray,
+ # DatetimeArray]", expected "ExtensionArray")
+ # error: Incompatible return value type (got "Union[ndarray,
+ # DatetimeArray]", expected "ndarray")
+ return dta.reshape(shape) # type: ignore[return-value]
def try_timedelta(v: np.ndarray) -> np.ndarray:
# safe coerce to timedelta64
@@ -1586,14 +1689,18 @@ def try_timedelta(v: np.ndarray) -> np.ndarray:
inferred_type = lib.infer_datetimelike_array(ensure_object(v))
if inferred_type == "datetime":
- value = try_datetime(v)
+ # error: Incompatible types in assignment (expression has type "ExtensionArray",
+ # variable has type "Union[ndarray, List[Any]]")
+ value = try_datetime(v) # type: ignore[assignment]
elif inferred_type == "timedelta":
value = try_timedelta(v)
elif inferred_type == "nat":
# if all NaT, return as datetime
if isna(v).all():
- value = try_datetime(v)
+ # error: Incompatible types in assignment (expression has type
+ # "ExtensionArray", variable has type "Union[ndarray, List[Any]]")
+ value = try_datetime(v) # type: ignore[assignment]
else:
# We have at least a NaT and a string
@@ -1603,7 +1710,10 @@ def try_timedelta(v: np.ndarray) -> np.ndarray:
if lib.infer_dtype(value, skipna=False) in ["mixed"]:
# cannot skip missing values, as NaT implies that the string
# is actually a datetime
- value = try_datetime(v)
+
+ # error: Incompatible types in assignment (expression has type
+ # "ExtensionArray", variable has type "Union[ndarray, List[Any]]")
+ value = try_datetime(v) # type: ignore[assignment]
return value
@@ -1643,10 +1753,16 @@ def maybe_cast_to_datetime(
dta = sequence_to_datetimes(value, allow_object=False)
# GH 25843: Remove tz information since the dtype
# didn't specify one
- if dta.tz is not None:
+
+ # error: Item "ndarray" of "Union[ndarray, DatetimeArray]"
+ # has no attribute "tz"
+ if dta.tz is not None: # type: ignore[union-attr]
# equiv: dta.view(dtype)
# Note: NOT equivalent to dta.astype(dtype)
- dta = dta.tz_localize(None)
+
+ # error: Item "ndarray" of "Union[ndarray,
+ # DatetimeArray]" has no attribute "tz_localize"
+ dta = dta.tz_localize(None) # type: ignore[union-attr]
value = dta
elif is_datetime64tz:
dtype = cast(DatetimeTZDtype, dtype)
@@ -1656,17 +1772,38 @@ def maybe_cast_to_datetime(
# be localized to the timezone.
is_dt_string = is_string_dtype(value.dtype)
dta = sequence_to_datetimes(value, allow_object=False)
- if dta.tz is not None:
- value = dta.astype(dtype, copy=False)
+ # error: Item "ndarray" of "Union[ndarray, DatetimeArray]"
+ # has no attribute "tz"
+ if dta.tz is not None: # type: ignore[union-attr]
+ # error: Argument 1 to "astype" of
+ # "_ArrayOrScalarCommon" has incompatible type
+ # "Union[dtype[Any], ExtensionDtype, None]"; expected
+ # "Union[dtype[Any], None, type, _SupportsDType, str,
+ # Union[Tuple[Any, int], Tuple[Any, Union[int,
+ # Sequence[int]]], List[Any], _DTypeDict, Tuple[Any,
+ # Any]]]"
+ value = dta.astype(
+ dtype, copy=False # type: ignore[arg-type]
+ )
elif is_dt_string:
# Strings here are naive, so directly localize
# equiv: dta.astype(dtype) # though deprecated
- value = dta.tz_localize(dtype.tz)
+
+ # error: Item "ndarray" of "Union[ndarray,
+ # DatetimeArray]" has no attribute "tz_localize"
+ value = dta.tz_localize( # type: ignore[union-attr]
+ dtype.tz
+ )
else:
# Numeric values are UTC at this point,
# so localize and convert
# equiv: Series(dta).astype(dtype) # though deprecated
- value = dta.tz_localize("UTC").tz_convert(dtype.tz)
+
+ # error: Item "ndarray" of "Union[ndarray,
+ # DatetimeArray]" has no attribute "tz_localize"
+ value = dta.tz_localize( # type: ignore[union-attr]
+ "UTC"
+ ).tz_convert(dtype.tz)
elif is_timedelta64:
# if successful, we get a ndarray[td64ns]
value, _ = sequence_to_td64ns(value)
@@ -1703,7 +1840,10 @@ def maybe_cast_to_datetime(
# only do this if we have an array and the dtype of the array is not
# setup already we are not an integer/object, so don't bother with this
# conversion
- value = maybe_infer_to_datetimelike(value)
+
+ # error: Argument 1 to "maybe_infer_to_datetimelike" has incompatible type
+ # "Union[ExtensionArray, List[Any]]"; expected "Union[ndarray, List[Any]]"
+ value = maybe_infer_to_datetimelike(value) # type: ignore[arg-type]
return value
@@ -1820,7 +1960,11 @@ def find_common_type(types: List[DtypeObj]) -> DtypeObj:
if is_integer_dtype(t) or is_float_dtype(t) or is_complex_dtype(t):
return np.dtype("object")
- return np.find_common_type(types, [])
+ # error: Argument 1 to "find_common_type" has incompatible type
+ # "List[Union[dtype, ExtensionDtype]]"; expected "Sequence[Union[dtype,
+ # None, type, _SupportsDtype, str, Tuple[Any, int], Tuple[Any, Union[int,
+ # Sequence[int]]], List[Any], _DtypeDict, Tuple[Any, Any]]]"
+ return np.find_common_type(types, []) # type: ignore[arg-type]
def construct_2d_arraylike_from_scalar(
@@ -1878,7 +2022,9 @@ def construct_1d_arraylike_from_scalar(
dtype = np.dtype(object)
if is_extension_array_dtype(dtype):
- cls = dtype.construct_array_type()
+ # error: Item "dtype" of "Union[dtype, ExtensionDtype]" has no
+ # attribute "construct_array_type"
+ cls = dtype.construct_array_type() # type: ignore[union-attr]
subarr = cls._from_sequence([value] * length, dtype=dtype)
else:
@@ -1895,7 +2041,11 @@ def construct_1d_arraylike_from_scalar(
elif dtype.kind in ["M", "m"]:
value = maybe_unbox_datetimelike(value, dtype)
- subarr = np.empty(length, dtype=dtype)
+ # error: Argument "dtype" to "empty" has incompatible type
+ # "Union[dtype, ExtensionDtype]"; expected "Union[dtype, None, type,
+ # _SupportsDtype, str, Tuple[Any, int], Tuple[Any, Union[int,
+ # Sequence[int]]], List[Any], _DtypeDict, Tuple[Any, Any]]"
+ subarr = np.empty(length, dtype=dtype) # type: ignore[arg-type]
subarr.fill(value)
return subarr
@@ -1967,7 +2117,11 @@ def construct_1d_ndarray_preserving_na(
# TODO(numpy#12550): special-case can be removed
subarr = construct_1d_object_array_from_listlike(list(values))
else:
- subarr = np.array(values, dtype=dtype, copy=copy)
+ # error: Argument "dtype" to "array" has incompatible type
+ # "Union[dtype[Any], ExtensionDtype, None]"; expected "Union[dtype[Any],
+ # None, type, _SupportsDType, str, Union[Tuple[Any, int], Tuple[Any,
+ # Union[int, Sequence[int]]], List[Any], _DTypeDict, Tuple[Any, Any]]]"
+ subarr = np.array(values, dtype=dtype, copy=copy) # type: ignore[arg-type]
return subarr
diff --git a/pandas/core/dtypes/common.py b/pandas/core/dtypes/common.py
index 0966d0b93cc25..68c8d35810b7e 100644
--- a/pandas/core/dtypes/common.py
+++ b/pandas/core/dtypes/common.py
@@ -165,7 +165,10 @@ def ensure_int_or_float(arr: ArrayLike, copy: bool = False) -> np.ndarray:
return arr.astype("uint64", copy=copy, casting="safe") # type: ignore[call-arg]
except TypeError:
if is_extension_array_dtype(arr.dtype):
- return arr.to_numpy(dtype="float64", na_value=np.nan)
+ # error: "ndarray" has no attribute "to_numpy"
+ return arr.to_numpy( # type: ignore[attr-defined]
+ dtype="float64", na_value=np.nan
+ )
return arr.astype("float64", copy=copy)
@@ -1718,7 +1721,10 @@ def infer_dtype_from_object(dtype) -> DtypeObj:
"""
if isinstance(dtype, type) and issubclass(dtype, np.generic):
# Type object from a dtype
- return dtype
+
+ # error: Incompatible return value type (got "Type[generic]", expected
+ # "Union[dtype[Any], ExtensionDtype]")
+ return dtype # type: ignore[return-value]
elif isinstance(dtype, (np.dtype, ExtensionDtype)):
# dtype object
try:
@@ -1726,7 +1732,9 @@ def infer_dtype_from_object(dtype) -> DtypeObj:
except TypeError:
# Should still pass if we don't have a date-like
pass
- return dtype.type
+ # error: Incompatible return value type (got "Union[Type[generic], Type[Any]]",
+ # expected "Union[dtype[Any], ExtensionDtype]")
+ return dtype.type # type: ignore[return-value]
try:
dtype = pandas_dtype(dtype)
@@ -1740,7 +1748,9 @@ def infer_dtype_from_object(dtype) -> DtypeObj:
# TODO(jreback)
# should deprecate these
if dtype in ["datetimetz", "datetime64tz"]:
- return DatetimeTZDtype.type
+ # error: Incompatible return value type (got "Type[Any]", expected
+ # "Union[dtype[Any], ExtensionDtype]")
+ return DatetimeTZDtype.type # type: ignore[return-value]
elif dtype in ["period"]:
raise NotImplementedError
@@ -1837,7 +1847,9 @@ def pandas_dtype(dtype) -> DtypeObj:
# registered extension types
result = registry.find(dtype)
if result is not None:
- return result
+ # error: Incompatible return value type (got "Type[ExtensionDtype]",
+ # expected "Union[dtype, ExtensionDtype]")
+ return result # type: ignore[return-value]
# try a numpy dtype
# raise a consistent TypeError if failed
diff --git a/pandas/core/dtypes/concat.py b/pandas/core/dtypes/concat.py
index 1545b5b106803..06fc1918b5ecf 100644
--- a/pandas/core/dtypes/concat.py
+++ b/pandas/core/dtypes/concat.py
@@ -51,8 +51,12 @@ def _cast_to_common_type(arr: ArrayLike, dtype: DtypeObj) -> ArrayLike:
# problem case: SparseArray.astype(dtype) doesn't follow the specified
# dtype exactly, but converts this to Sparse[dtype] -> first manually
# convert to dense array
- arr = cast(SparseArray, arr)
- return arr.to_dense().astype(dtype, copy=False)
+
+ # error: Incompatible types in assignment (expression has type
+ # "SparseArray", variable has type "ndarray")
+ arr = cast(SparseArray, arr) # type: ignore[assignment]
+ # error: "ndarray" has no attribute "to_dense"
+ return arr.to_dense().astype(dtype, copy=False) # type: ignore[attr-defined]
if (
isinstance(arr, np.ndarray)
@@ -67,7 +71,11 @@ def _cast_to_common_type(arr: ArrayLike, dtype: DtypeObj) -> ArrayLike:
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)
- return arr.astype(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]
def concat_compat(to_concat, axis: int = 0, ea_compat_axis: bool = False):
diff --git a/pandas/core/dtypes/dtypes.py b/pandas/core/dtypes/dtypes.py
index da3a9269cf2c4..d44d2a564fb78 100644
--- a/pandas/core/dtypes/dtypes.py
+++ b/pandas/core/dtypes/dtypes.py
@@ -180,7 +180,9 @@ class CategoricalDtype(PandasExtensionDtype, ExtensionDtype):
type: Type[CategoricalDtypeType] = CategoricalDtypeType
kind: str_type = "O"
str = "|O08"
- base = np.dtype("O")
+ # error: Incompatible types in assignment (expression has type "dtype",
+ # base class "PandasExtensionDtype" defined the type as "None")
+ base = np.dtype("O") # type: ignore[assignment]
_metadata = ("categories", "ordered")
_cache: Dict[str_type, PandasExtensionDtype] = {}
@@ -467,8 +469,14 @@ def _hash_categories(categories, ordered: Ordered = True) -> int:
[cat_array, np.arange(len(cat_array), dtype=cat_array.dtype)]
)
else:
- cat_array = [cat_array]
- hashed = combine_hash_arrays(iter(cat_array), num_items=len(cat_array))
+ # error: Incompatible types in assignment (expression has type
+ # "List[ndarray]", variable has type "ndarray")
+ cat_array = [cat_array] # type: ignore[assignment]
+ # error: Incompatible types in assignment (expression has type "ndarray",
+ # variable has type "int")
+ hashed = combine_hash_arrays( # type: ignore[assignment]
+ iter(cat_array), num_items=len(cat_array)
+ )
return np.bitwise_xor.reduce(hashed)
@classmethod
@@ -668,7 +676,9 @@ class DatetimeTZDtype(PandasExtensionDtype):
kind: str_type = "M"
str = "|M8[ns]"
num = 101
- base = np.dtype("M8[ns]")
+ # 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]
na_value = NaT
_metadata = ("unit", "tz")
_match = re.compile(r"(datetime64|M8)\[(?P<unit>.+), (?P<tz>.+)\]")
@@ -834,7 +844,9 @@ class PeriodDtype(dtypes.PeriodDtypeBase, PandasExtensionDtype):
type: Type[Period] = Period
kind: str_type = "O"
str = "|O08"
- base = np.dtype("O")
+ # error: Incompatible types in assignment (expression has type "dtype",
+ # base class "PandasExtensionDtype" defined the type as "None")
+ base = np.dtype("O") # type: ignore[assignment]
num = 102
_metadata = ("freq",)
_match = re.compile(r"(P|p)eriod\[(?P<freq>.+)\]")
@@ -1034,7 +1046,9 @@ class IntervalDtype(PandasExtensionDtype):
name = "interval"
kind: str_type = "O"
str = "|O08"
- base = np.dtype("O")
+ # error: Incompatible types in assignment (expression has type "dtype",
+ # base class "PandasExtensionDtype" defined the type as "None")
+ base = np.dtype("O") # type: ignore[assignment]
num = 103
_metadata = (
"subtype",
diff --git a/pandas/core/dtypes/missing.py b/pandas/core/dtypes/missing.py
index b4a77337ce9f2..286272b165fb9 100644
--- a/pandas/core/dtypes/missing.py
+++ b/pandas/core/dtypes/missing.py
@@ -164,9 +164,13 @@ def _isna(obj, inf_as_na: bool = False):
elif isinstance(obj, type):
return False
elif isinstance(obj, (np.ndarray, ABCExtensionArray)):
- return _isna_array(obj, inf_as_na=inf_as_na)
+ # error: Value of type variable "ArrayLike" of "_isna_array" cannot be
+ # "Union[ndarray, ExtensionArray]"
+ return _isna_array(obj, inf_as_na=inf_as_na) # type: ignore[type-var]
elif isinstance(obj, (ABCSeries, ABCIndex)):
- result = _isna_array(obj._values, inf_as_na=inf_as_na)
+ # error: Value of type variable "ArrayLike" of "_isna_array" cannot be
+ # "Union[Any, ExtensionArray, ndarray]"
+ result = _isna_array(obj._values, inf_as_na=inf_as_na) # type: ignore[type-var]
# box
if isinstance(obj, ABCSeries):
result = obj._constructor(
@@ -234,19 +238,37 @@ def _isna_array(values: ArrayLike, inf_as_na: bool = False):
if is_extension_array_dtype(dtype):
if inf_as_na and is_categorical_dtype(dtype):
- result = libmissing.isnaobj_old(values.to_numpy())
+ # error: "ndarray" has no attribute "to_numpy"
+ result = libmissing.isnaobj_old(
+ values.to_numpy() # type: ignore[attr-defined]
+ )
else:
- result = values.isna()
+ # error: "ndarray" has no attribute "isna"
+ result = values.isna() # type: ignore[attr-defined]
elif is_string_dtype(dtype):
- result = _isna_string_dtype(values, dtype, inf_as_na=inf_as_na)
+ # error: Argument 1 to "_isna_string_dtype" has incompatible type
+ # "ExtensionArray"; expected "ndarray"
+ # error: Argument 2 to "_isna_string_dtype" has incompatible type
+ # "ExtensionDtype"; expected "dtype[Any]"
+ result = _isna_string_dtype(
+ values, dtype, inf_as_na=inf_as_na # type: ignore[arg-type]
+ )
elif needs_i8_conversion(dtype):
# this is the NaT pattern
result = values.view("i8") == iNaT
else:
if inf_as_na:
- result = ~np.isfinite(values)
+ # error: Argument 1 to "__call__" of "ufunc" has incompatible type
+ # "ExtensionArray"; expected "Union[Union[int, float, complex, str, bytes,
+ # generic], Sequence[Union[int, float, complex, str, bytes, generic]],
+ # Sequence[Sequence[Any]], _SupportsArray]"
+ result = ~np.isfinite(values) # type: ignore[arg-type]
else:
- result = np.isnan(values)
+ # error: Argument 1 to "__call__" of "ufunc" has incompatible type
+ # "ExtensionArray"; expected "Union[Union[int, float, complex, str, bytes,
+ # generic], Sequence[Union[int, float, complex, str, bytes, generic]],
+ # Sequence[Sequence[Any]], _SupportsArray]"
+ result = np.isnan(values) # type: ignore[arg-type]
return result
@@ -573,7 +595,9 @@ def na_value_for_dtype(dtype: DtypeObj, compat: bool = True):
"""
if is_extension_array_dtype(dtype):
- return dtype.na_value
+ # error: Item "dtype[Any]" of "Union[dtype[Any], ExtensionDtype]" has no
+ # attribute "na_value"
+ return dtype.na_value # type: ignore[union-attr]
elif needs_i8_conversion(dtype):
return dtype.type("NaT", "ns")
elif is_float_dtype(dtype):
@@ -626,7 +650,8 @@ def is_valid_na_for_dtype(obj, dtype: DtypeObj) -> bool:
# Numeric
return obj is not NaT and not isinstance(obj, (np.datetime64, np.timedelta64))
- elif dtype == np.dtype(object):
+ # error: Value of type variable "_DTypeScalar" of "dtype" cannot be "object"
+ elif dtype == np.dtype(object): # type: ignore[type-var]
# This is needed for Categorical, but is kind of weird
return True
@@ -650,11 +675,22 @@ def isna_all(arr: ArrayLike) -> bool:
checker = nan_checker
elif dtype.kind in ["m", "M"] or dtype.type is Period:
- checker = lambda x: np.asarray(x.view("i8")) == iNaT
+ # error: Incompatible types in assignment (expression has type
+ # "Callable[[Any], Any]", variable has type "ufunc")
+ checker = lambda x: np.asarray(x.view("i8")) == iNaT # type: ignore[assignment]
else:
- checker = lambda x: _isna_array(x, inf_as_na=INF_AS_NA)
+ # error: Incompatible types in assignment (expression has type "Callable[[Any],
+ # Any]", variable has type "ufunc")
+ checker = lambda x: _isna_array( # type: ignore[assignment]
+ x, inf_as_na=INF_AS_NA
+ )
return all(
- checker(arr[i : i + chunk_len]).all() for i in range(0, total_len, chunk_len)
+ # error: Argument 1 to "__call__" of "ufunc" has incompatible type
+ # "Union[ExtensionArray, Any]"; expected "Union[Union[int, float, complex, str,
+ # bytes, generic], Sequence[Union[int, float, complex, str, bytes, generic]],
+ # Sequence[Sequence[Any]], _SupportsArray]"
+ checker(arr[i : i + chunk_len]).all() # type: ignore[arg-type]
+ for i in range(0, total_len, chunk_len)
)
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index a0c97b0cdd268..de28c04ca0793 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -584,33 +584,84 @@ def __init__(
)
elif isinstance(data, dict):
- mgr = dict_to_mgr(data, index, columns, dtype=dtype, typ=manager)
+ # error: Argument "dtype" to "dict_to_mgr" has incompatible type
+ # "Union[ExtensionDtype, str, dtype[Any], Type[object], None]"; expected
+ # "Union[dtype[Any], ExtensionDtype, None]"
+ mgr = dict_to_mgr(
+ data, index, columns, dtype=dtype, typ=manager # type: ignore[arg-type]
+ )
elif isinstance(data, ma.MaskedArray):
import numpy.ma.mrecords as mrecords
# masked recarray
if isinstance(data, mrecords.MaskedRecords):
- mgr = rec_array_to_mgr(data, index, columns, dtype, copy, typ=manager)
+ # error: Argument 4 to "rec_array_to_mgr" has incompatible type
+ # "Union[ExtensionDtype, str, dtype[Any], Type[object], None]"; expected
+ # "Union[dtype[Any], ExtensionDtype, None]"
+ mgr = rec_array_to_mgr(
+ data,
+ index,
+ columns,
+ dtype, # type: ignore[arg-type]
+ copy,
+ typ=manager,
+ )
# a masked array
else:
data = sanitize_masked_array(data)
mgr = ndarray_to_mgr(
- data, index, columns, dtype=dtype, copy=copy, typ=manager
+ # error: Argument "dtype" to "ndarray_to_mgr" has incompatible type
+ # "Union[ExtensionDtype, str, dtype[Any], Type[object], None]";
+ # expected "Union[dtype[Any], ExtensionDtype, None]"
+ data,
+ index,
+ columns,
+ dtype=dtype, # type: ignore[arg-type]
+ copy=copy,
+ typ=manager,
)
elif isinstance(data, (np.ndarray, Series, Index)):
if data.dtype.names:
# i.e. numpy structured array
- mgr = rec_array_to_mgr(data, index, columns, dtype, copy, typ=manager)
+
+ # error: Argument 4 to "rec_array_to_mgr" has incompatible type
+ # "Union[ExtensionDtype, str, dtype[Any], Type[object], None]"; expected
+ # "Union[dtype[Any], ExtensionDtype, None]"
+ mgr = rec_array_to_mgr(
+ data,
+ index,
+ columns,
+ dtype, # type: ignore[arg-type]
+ copy,
+ typ=manager,
+ )
elif getattr(data, "name", None) is not None:
# i.e. Series/Index with non-None name
mgr = dict_to_mgr(
- {data.name: data}, index, columns, dtype=dtype, typ=manager
+ # error: Item "ndarray" of "Union[ndarray, Series, Index]" has no
+ # attribute "name"
+ # error: Argument "dtype" to "dict_to_mgr" has incompatible type
+ # "Union[ExtensionDtype, str, dtype[Any], Type[object], None]";
+ # expected "Union[dtype[Any], ExtensionDtype, None]"
+ {data.name: data}, # type: ignore[union-attr]
+ index,
+ columns,
+ dtype=dtype, # type: ignore[arg-type]
+ typ=manager,
)
else:
mgr = ndarray_to_mgr(
- data, index, columns, dtype=dtype, copy=copy, typ=manager
+ # error: Argument "dtype" to "ndarray_to_mgr" has incompatible type
+ # "Union[ExtensionDtype, str, dtype[Any], Type[object], None]";
+ # expected "Union[dtype[Any], ExtensionDtype, None]"
+ data,
+ index,
+ columns,
+ dtype=dtype, # type: ignore[arg-type]
+ copy=copy,
+ typ=manager,
)
# For data is list-like, or Iterable (will consume into list)
@@ -622,19 +673,54 @@ def __init__(
data = dataclasses_to_dicts(data)
if treat_as_nested(data):
if columns is not None:
- columns = ensure_index(columns)
+ # error: Value of type variable "AnyArrayLike" of "ensure_index"
+ # cannot be "Collection[Any]"
+ columns = ensure_index(columns) # type: ignore[type-var]
arrays, columns, index = nested_data_to_arrays(
- data, columns, index, dtype
+ # error: Argument 3 to "nested_data_to_arrays" has incompatible
+ # type "Optional[Collection[Any]]"; expected "Optional[Index]"
+ # error: Argument 4 to "nested_data_to_arrays" has incompatible
+ # type "Union[ExtensionDtype, str, dtype[Any], Type[object],
+ # None]"; expected "Union[dtype[Any], ExtensionDtype, None]"
+ data,
+ columns,
+ index, # type: ignore[arg-type]
+ dtype, # type: ignore[arg-type]
)
mgr = arrays_to_mgr(
- arrays, columns, index, columns, dtype=dtype, typ=manager
+ # error: Argument "dtype" to "arrays_to_mgr" has incompatible
+ # type "Union[ExtensionDtype, str, dtype[Any], Type[object],
+ # None]"; expected "Union[dtype[Any], ExtensionDtype, None]"
+ arrays,
+ columns,
+ index,
+ columns,
+ dtype=dtype, # type: ignore[arg-type]
+ typ=manager,
)
else:
mgr = ndarray_to_mgr(
- data, index, columns, dtype=dtype, copy=copy, typ=manager
+ # error: Argument "dtype" to "ndarray_to_mgr" has incompatible
+ # type "Union[ExtensionDtype, str, dtype[Any], Type[object],
+ # None]"; expected "Union[dtype[Any], ExtensionDtype, None]"
+ data,
+ index,
+ columns,
+ dtype=dtype, # type: ignore[arg-type]
+ copy=copy,
+ typ=manager,
)
else:
- mgr = dict_to_mgr({}, index, columns, dtype=dtype, typ=manager)
+ # error: Argument "dtype" to "dict_to_mgr" has incompatible type
+ # "Union[ExtensionDtype, str, dtype[Any], Type[object], None]"; expected
+ # "Union[dtype[Any], ExtensionDtype, None]"
+ mgr = dict_to_mgr(
+ {},
+ index,
+ columns,
+ dtype=dtype, # type: ignore[arg-type]
+ typ=manager,
+ )
# For data is scalar
else:
if index is None or columns is None:
@@ -648,19 +734,39 @@ def __init__(
# TODO(EA2D): special case not needed with 2D EAs
values = [
- construct_1d_arraylike_from_scalar(data, len(index), dtype)
+ # error: Argument 3 to "construct_1d_arraylike_from_scalar"
+ # has incompatible type "Union[ExtensionDtype, str, dtype,
+ # Type[object]]"; expected "Union[dtype, ExtensionDtype]"
+ construct_1d_arraylike_from_scalar(
+ data, len(index), dtype # type: ignore[arg-type]
+ )
for _ in range(len(columns))
]
mgr = arrays_to_mgr(
values, columns, index, columns, dtype=None, typ=manager
)
else:
- values = construct_2d_arraylike_from_scalar(
- data, len(index), len(columns), dtype, copy
+ # error: Incompatible types in assignment (expression has type
+ # "ndarray", variable has type "List[ExtensionArray]")
+ values = construct_2d_arraylike_from_scalar( # type: ignore[assignment]
+ # error: Argument 4 to "construct_2d_arraylike_from_scalar" has
+ # incompatible type "Union[ExtensionDtype, str, dtype[Any],
+ # Type[object]]"; expected "dtype[Any]"
+ data,
+ len(index),
+ len(columns),
+ dtype, # type: ignore[arg-type]
+ copy,
)
mgr = ndarray_to_mgr(
- values, index, columns, dtype=values.dtype, copy=False, typ=manager
+ # error: "List[ExtensionArray]" has no attribute "dtype"
+ values,
+ index,
+ columns,
+ dtype=values.dtype, # type: ignore[attr-defined]
+ copy=False,
+ typ=manager,
)
# ensure correct Manager type according to settings
@@ -1230,17 +1336,19 @@ def __len__(self) -> int:
"""
return len(self.index)
- # error: Overloaded function signatures 1 and 2 overlap with incompatible return
- # types
@overload
- def dot(self, other: Series) -> Series: # type: ignore[misc]
+ def dot(self, other: Series) -> Series:
...
@overload
def dot(self, other: Union[DataFrame, Index, ArrayLike]) -> DataFrame:
...
- def dot(self, other: Union[AnyArrayLike, FrameOrSeriesUnion]) -> FrameOrSeriesUnion:
+ # error: Overloaded function implementation cannot satisfy signature 2 due to
+ # inconsistencies in how they use type variables
+ def dot( # type: ignore[misc]
+ self, other: Union[AnyArrayLike, FrameOrSeriesUnion]
+ ) -> FrameOrSeriesUnion:
"""
Compute the matrix multiplication between the DataFrame and other.
@@ -2085,7 +2193,9 @@ def to_records(
# array of tuples to numpy cols. copy copy copy
ix_vals = list(map(np.array, zip(*self.index._values)))
else:
- ix_vals = [self.index.values]
+ # error: List item 0 has incompatible type "ArrayLike"; expected
+ # "ndarray"
+ ix_vals = [self.index.values] # type: ignore[list-item]
arrays = ix_vals + [
np.asarray(self.iloc[:, i]) for i in range(len(self.columns))
@@ -2152,7 +2262,9 @@ def to_records(
if dtype_mapping is None:
formats.append(v.dtype)
elif isinstance(dtype_mapping, (type, np.dtype, str)):
- formats.append(dtype_mapping)
+ # error: Argument 1 to "append" of "list" has incompatible type
+ # "Union[type, dtype, str]"; expected "dtype"
+ formats.append(dtype_mapping) # type: ignore[arg-type]
else:
element = "row" if i < index_len else "column"
msg = f"Invalid dtype {dtype_mapping} specified for {element} {name}"
@@ -3217,7 +3329,9 @@ def transpose(self, *args, copy: bool = False) -> DataFrame:
)
else:
- new_values = self.values.T
+ # error: Incompatible types in assignment (expression has type
+ # "ndarray", variable has type "List[Any]")
+ new_values = self.values.T # type: ignore[assignment]
if copy:
new_values = new_values.copy()
result = self._constructor(
@@ -3276,7 +3390,9 @@ def _get_column_array(self, i: int) -> ArrayLike:
Get the values of the i'th column (ndarray or ExtensionArray, as stored
in the Block)
"""
- return self._mgr.iget_values(i)
+ # error: Incompatible return value type (got "ExtensionArray", expected
+ # "ndarray")
+ return self._mgr.iget_values(i) # type: ignore[return-value]
def _iter_column_arrays(self) -> Iterator[ArrayLike]:
"""
@@ -3284,7 +3400,9 @@ def _iter_column_arrays(self) -> Iterator[ArrayLike]:
This returns the values as stored in the Block (ndarray or ExtensionArray).
"""
for i in range(len(self.columns)):
- yield self._get_column_array(i)
+ # error: Incompatible types in "yield" (actual type
+ # "ExtensionArray", expected type "ndarray")
+ yield self._get_column_array(i) # type: ignore[misc]
def __getitem__(self, key):
key = lib.item_from_zerodim(key)
@@ -3543,7 +3661,10 @@ def _set_item_frame_value(self, key, value: DataFrame) -> None:
value = value.reindex(cols, axis=1)
# now align rows
- value = _reindex_for_setitem(value, self.index)
+
+ # error: Incompatible types in assignment (expression has type "ExtensionArray",
+ # variable has type "DataFrame")
+ value = _reindex_for_setitem(value, self.index) # type: ignore[assignment]
self._set_item_mgr(key, value)
def _iset_item_mgr(self, loc: int, value) -> None:
@@ -4052,9 +4173,16 @@ def check_int_infer_dtype(dtypes):
# see https://github.com/numpy/numpy/issues/9464
if (isinstance(dtype, str) and dtype == "int") or (dtype is int):
converted_dtypes.append(np.int32)
- converted_dtypes.append(np.int64)
+ # error: Argument 1 to "append" of "list" has incompatible type
+ # "Type[signedinteger[Any]]"; expected "Type[signedinteger[Any]]"
+ converted_dtypes.append(np.int64) # type: ignore[arg-type]
else:
- converted_dtypes.append(infer_dtype_from_object(dtype))
+ # error: Argument 1 to "append" of "list" has incompatible type
+ # "Union[dtype[Any], ExtensionDtype]"; expected
+ # "Type[signedinteger[Any]]"
+ converted_dtypes.append(
+ infer_dtype_from_object(dtype) # type: ignore[arg-type]
+ )
return frozenset(converted_dtypes)
include = check_int_infer_dtype(include)
@@ -4109,7 +4237,8 @@ def extract_unique_dtypes_from_dtypes_set(
)
keep_these &= ~self.dtypes.isin(excluded_dtypes)
- return self.iloc[:, keep_these.values]
+ # error: "ndarray" has no attribute "values"
+ return self.iloc[:, keep_these.values] # type: ignore[attr-defined]
def insert(self, loc, column, value, allow_duplicates: bool = False) -> None:
"""
@@ -4418,7 +4547,11 @@ def _reindex_multi(self, axes, copy: bool, fill_value) -> DataFrame:
if row_indexer is not None and col_indexer is not None:
indexer = row_indexer, col_indexer
- new_values = take_2d_multi(self.values, indexer, fill_value=fill_value)
+ # error: Argument 2 to "take_2d_multi" has incompatible type "Tuple[Any,
+ # Any]"; expected "ndarray"
+ new_values = take_2d_multi(
+ self.values, indexer, fill_value=fill_value # type: ignore[arg-type]
+ )
return self._constructor(new_values, index=new_index, columns=new_columns)
else:
return self._reindex_with_indexers(
@@ -5106,10 +5239,14 @@ def set_index(
arrays.append(col) # type:ignore[arg-type]
names.append(col.name)
elif isinstance(col, (list, np.ndarray)):
- arrays.append(col)
+ # error: Argument 1 to "append" of "list" has incompatible type
+ # "Union[List[Any], ndarray]"; expected "Index"
+ arrays.append(col) # type: ignore[arg-type]
names.append(None)
elif isinstance(col, abc.Iterator):
- arrays.append(list(col))
+ # error: Argument 1 to "append" of "list" has incompatible type
+ # "List[Any]"; expected "Index"
+ arrays.append(list(col)) # type: ignore[arg-type]
names.append(None)
# from here, col can only be a column label
else:
@@ -5853,7 +5990,12 @@ def sort_values( # type: ignore[override]
# need to rewrap columns in Series to apply key function
if key is not None:
- keys = [Series(k, name=name) for (k, name) in zip(keys, by)]
+ # error: List comprehension has incompatible type List[Series];
+ # expected List[ndarray]
+ keys = [
+ Series(k, name=name) # type: ignore[misc]
+ for (k, name) in zip(keys, by)
+ ]
indexer = lexsort_indexer(
keys, orders=ascending, na_position=na_position, key=key
@@ -5866,7 +6008,9 @@ def sort_values( # type: ignore[override]
# need to rewrap column in Series to apply key function
if key is not None:
- k = Series(k, name=by)
+ # error: Incompatible types in assignment (expression has type
+ # "Series", variable has type "ndarray")
+ k = Series(k, name=by) # type: ignore[assignment]
if isinstance(ascending, (tuple, list)):
ascending = ascending[0]
@@ -10024,7 +10168,9 @@ def _reindex_for_setitem(value: FrameOrSeriesUnion, index: Index) -> ArrayLike:
# reindex if necessary
if value.index.equals(index) or not len(index):
- return value._values.copy()
+ # error: Incompatible return value type (got "Union[ndarray, Any]", expected
+ # "ExtensionArray")
+ return value._values.copy() # type: ignore[return-value]
# GH#4107
try:
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index cd5c0159e93cb..d2b63c42d777b 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -666,7 +666,8 @@ def size(self) -> int:
>>> df.size
4
"""
- return np.prod(self.shape)
+ # error: Incompatible return value type (got "number", expected "int")
+ return np.prod(self.shape) # type: ignore[return-value]
@final
@property
@@ -752,11 +753,13 @@ def swapaxes(self: FrameOrSeries, axis1, axis2, copy=True) -> FrameOrSeries:
# ignore needed because of NDFrame constructor is different than
# DataFrame/Series constructors.
return self._constructor(
+ # error: Argument 1 to "NDFrame" has incompatible type "ndarray"; expected
+ # "Union[ArrayManager, BlockManager]"
# error: Argument 2 to "NDFrame" has incompatible type "*Generator[Index,
# None, None]"; expected "bool" [arg-type]
# error: Argument 2 to "NDFrame" has incompatible type "*Generator[Index,
# None, None]"; expected "Optional[Mapping[Optional[Hashable], Any]]"
- new_values,
+ new_values, # type: ignore[arg-type]
*new_axes, # type: ignore[arg-type]
).__finalize__(self, method="swapaxes")
@@ -1985,14 +1988,20 @@ def __array_wrap__(
# ptp also requires the item_from_zerodim
return result
d = self._construct_axes_dict(self._AXIS_ORDERS, copy=False)
- return self._constructor(result, **d).__finalize__(
+ # error: Argument 1 to "NDFrame" has incompatible type "ndarray";
+ # expected "BlockManager"
+ return self._constructor(result, **d).__finalize__( # type: ignore[arg-type]
self, method="__array_wrap__"
)
def __array_ufunc__(
self, ufunc: Callable, method: str, *inputs: Any, **kwargs: Any
):
- return arraylike.array_ufunc(self, ufunc, method, *inputs, **kwargs)
+ # error: Argument 2 to "array_ufunc" has incompatible type "Callable[..., Any]";
+ # expected "ufunc"
+ return arraylike.array_ufunc(
+ self, ufunc, method, *inputs, **kwargs # type: ignore[arg-type]
+ )
# ideally we would define this to avoid the getattr checks, but
# is slower
@@ -6989,7 +6998,10 @@ def interpolate(
f"`limit_direction` must be 'backward' for method `{method}`"
)
- if obj.ndim == 2 and np.all(obj.dtypes == np.dtype(object)):
+ # error: Value of type variable "_DTypeScalar" of "dtype" cannot be "object"
+ if obj.ndim == 2 and np.all(
+ obj.dtypes == np.dtype(object) # type: ignore[type-var]
+ ):
raise TypeError(
"Cannot interpolate with all object-dtype columns "
"in the DataFrame. Try setting at least one "
@@ -8367,7 +8379,8 @@ def last(self: FrameOrSeries, offset) -> FrameOrSeries:
start_date = self.index[-1] - offset
start = self.index.searchsorted(start_date, side="right")
- return self.iloc[start:]
+ # error: Slice index must be an integer or None
+ return self.iloc[start:] # type: ignore[misc]
@final
def rank(
@@ -8475,8 +8488,15 @@ def ranker(data):
na_option=na_option,
pct=pct,
)
- ranks = self._constructor(ranks, **data._construct_axes_dict())
- return ranks.__finalize__(self, method="rank")
+ # error: Incompatible types in assignment (expression has type
+ # "FrameOrSeries", variable has type "ndarray")
+ # error: Argument 1 to "NDFrame" has incompatible type "ndarray"; expected
+ # "Union[ArrayManager, BlockManager]"
+ ranks = self._constructor( # type: ignore[assignment]
+ ranks, **data._construct_axes_dict() # type: ignore[arg-type]
+ )
+ # error: "ndarray" has no attribute "__finalize__"
+ return ranks.__finalize__(self, method="rank") # type: ignore[attr-defined]
# if numeric_only is None, and we can't get anything, we try with
# numeric_only=True
@@ -8958,7 +8978,11 @@ def _where(
# we are the same shape, so create an actual object for alignment
else:
- other = self._constructor(other, **self._construct_axes_dict())
+ # error: Argument 1 to "NDFrame" has incompatible type "ndarray";
+ # expected "BlockManager"
+ other = self._constructor(
+ other, **self._construct_axes_dict() # type: ignore[arg-type]
+ )
if axis is None:
axis = 0
@@ -9885,7 +9909,11 @@ def abs(self: FrameOrSeries) -> FrameOrSeries:
2 6 30 -30
3 7 40 -50
"""
- return np.abs(self)
+ # error: Argument 1 to "__call__" of "ufunc" has incompatible type
+ # "FrameOrSeries"; expected "Union[Union[int, float, complex, str, bytes,
+ # generic], Sequence[Union[int, float, complex, str, bytes, generic]],
+ # Sequence[Sequence[Any]], _SupportsArray]"
+ return np.abs(self) # type: ignore[arg-type]
@final
def describe(
diff --git a/pandas/core/groupby/generic.py b/pandas/core/groupby/generic.py
index af5c92ce82a66..50d04135c9300 100644
--- a/pandas/core/groupby/generic.py
+++ b/pandas/core/groupby/generic.py
@@ -344,7 +344,13 @@ def _aggregate_multiple_funcs(self, arg):
# let higher level handle
return results
- output = self._wrap_aggregated_output(results, index=None)
+ # Argument 1 to "_wrap_aggregated_output" of "SeriesGroupBy" has
+ # incompatible type "Dict[OutputKey, Union[DataFrame,
+ # Series]]";
+ # expected "Mapping[OutputKey, Union[Series, ndarray]]"
+ output = self._wrap_aggregated_output(
+ results, index=None # type: ignore[arg-type]
+ )
return self.obj._constructor_expanddim(output, columns=columns)
# TODO: index should not be Optional - see GH 35490
@@ -759,13 +765,28 @@ def apply_series_value_counts():
# lab is a Categorical with categories an IntervalIndex
lab = cut(Series(val), bins, include_lowest=True)
- lev = lab.cat.categories
- lab = lev.take(lab.cat.codes, allow_fill=True, fill_value=lev._na_value)
+ # error: "ndarray" has no attribute "cat"
+ lev = lab.cat.categories # type: ignore[attr-defined]
+ # error: No overload variant of "take" of "_ArrayOrScalarCommon" matches
+ # argument types "Any", "bool", "Union[Any, float]"
+ lab = lev.take( # type: ignore[call-overload]
+ # error: "ndarray" has no attribute "cat"
+ lab.cat.codes, # type: ignore[attr-defined]
+ allow_fill=True,
+ # error: Item "ndarray" of "Union[ndarray, Index]" has no attribute
+ # "_na_value"
+ fill_value=lev._na_value, # type: ignore[union-attr]
+ )
llab = lambda lab, inc: lab[inc]._multiindex.codes[-1]
if is_interval_dtype(lab.dtype):
# TODO: should we do this inside II?
- sorter = np.lexsort((lab.left, lab.right, ids))
+
+ # error: "ndarray" has no attribute "left"
+ # error: "ndarray" has no attribute "right"
+ sorter = np.lexsort(
+ (lab.left, lab.right, ids) # type: ignore[attr-defined]
+ )
else:
sorter = np.lexsort((lab, ids))
@@ -791,7 +812,11 @@ def apply_series_value_counts():
# multi-index components
codes = self.grouper.reconstructed_codes
codes = [rep(level_codes) for level_codes in codes] + [llab(lab, inc)]
- levels = [ping.group_index for ping in self.grouper.groupings] + [lev]
+ # error: List item 0 has incompatible type "Union[ndarray, Any]";
+ # expected "Index"
+ levels = [ping.group_index for ping in self.grouper.groupings] + [
+ lev # type: ignore[list-item]
+ ]
names = self.grouper.names + [self._selection_name]
if dropna:
@@ -1149,11 +1174,20 @@ def py_fallback(values: ArrayLike) -> ArrayLike:
# We've split an object block! Everything we've assumed
# about a single block input returning a single block output
# is a lie. See eg GH-39329
- return mgr.as_array()
+
+ # error: Incompatible return value type (got "ndarray", expected
+ # "ExtensionArray")
+ return mgr.as_array() # type: ignore[return-value]
else:
# We are a single block from a BlockManager
# or one array from SingleArrayManager
- return arrays[0]
+
+ # error: Incompatible return value type (got "Union[ndarray,
+ # ExtensionArray, ArrayLike]", expected "ExtensionArray")
+ # error: Incompatible return value type (got "Union[ndarray,
+ # ExtensionArray, ArrayLike]", expected
+ # "ndarray")
+ return arrays[0] # type: ignore[return-value]
def array_func(values: ArrayLike) -> ArrayLike:
@@ -1172,7 +1206,9 @@ def array_func(values: ArrayLike) -> ArrayLike:
assert how == "ohlc"
raise
- result = py_fallback(values)
+ # error: Incompatible types in assignment (expression has type
+ # "ExtensionArray", variable has type "ndarray")
+ result = py_fallback(values) # type: ignore[assignment]
return cast_agg_result(result, values, how)
diff --git a/pandas/core/groupby/groupby.py b/pandas/core/groupby/groupby.py
index e11c296783476..e5010da5ccac6 100644
--- a/pandas/core/groupby/groupby.py
+++ b/pandas/core/groupby/groupby.py
@@ -1131,7 +1131,12 @@ def _cython_agg_general(
if not output:
raise DataError("No numeric types to aggregate")
- return self._wrap_aggregated_output(output, index=self.grouper.result_index)
+ # error: Argument 1 to "_wrap_aggregated_output" of "BaseGroupBy" has
+ # incompatible type "Dict[OutputKey, Union[ndarray, DatetimeArray]]";
+ # expected "Mapping[OutputKey, ndarray]"
+ return self._wrap_aggregated_output(
+ output, index=self.grouper.result_index # type: ignore[arg-type]
+ )
@final
def _transform_with_numba(self, data, func, *args, engine_kwargs=None, **kwargs):
@@ -2269,15 +2274,25 @@ def pre_processor(vals: np.ndarray) -> Tuple[np.ndarray, Optional[Type]]:
inference = None
if is_integer_dtype(vals.dtype):
if is_extension_array_dtype(vals.dtype):
- vals = vals.to_numpy(dtype=float, na_value=np.nan)
+ # error: "ndarray" has no attribute "to_numpy"
+ vals = vals.to_numpy( # type: ignore[attr-defined]
+ dtype=float, na_value=np.nan
+ )
inference = np.int64
elif is_bool_dtype(vals.dtype) and is_extension_array_dtype(vals.dtype):
- vals = vals.to_numpy(dtype=float, na_value=np.nan)
+ # error: "ndarray" has no attribute "to_numpy"
+ vals = vals.to_numpy( # type: ignore[attr-defined]
+ dtype=float, na_value=np.nan
+ )
elif is_datetime64_dtype(vals.dtype):
- inference = "datetime64[ns]"
+ # error: Incompatible types in assignment (expression has type
+ # "str", variable has type "Optional[Type[int64]]")
+ inference = "datetime64[ns]" # type: ignore[assignment]
vals = np.asarray(vals).astype(float)
elif is_timedelta64_dtype(vals.dtype):
- inference = "timedelta64[ns]"
+ # error: Incompatible types in assignment (expression has type "str",
+ # variable has type "Optional[Type[signedinteger[Any]]]")
+ inference = "timedelta64[ns]" # type: ignore[assignment]
vals = np.asarray(vals).astype(float)
return vals, inference
diff --git a/pandas/core/groupby/grouper.py b/pandas/core/groupby/grouper.py
index 89becb880c519..51f7b44f6d69d 100644
--- a/pandas/core/groupby/grouper.py
+++ b/pandas/core/groupby/grouper.py
@@ -583,7 +583,9 @@ def indices(self):
def codes(self) -> np.ndarray:
if self._codes is None:
self._make_codes()
- return self._codes
+ # error: Incompatible return value type (got "Optional[ndarray]",
+ # expected "ndarray")
+ return self._codes # type: ignore[return-value]
@cache_readonly
def result_index(self) -> Index:
diff --git a/pandas/core/groupby/ops.py b/pandas/core/groupby/ops.py
index 008ee4dff4f7b..2d7547ff75ca4 100644
--- a/pandas/core/groupby/ops.py
+++ b/pandas/core/groupby/ops.py
@@ -539,7 +539,10 @@ def _ea_wrap_cython_operation(
)
if how in ["rank"]:
# preserve float64 dtype
- return res_values
+
+ # error: Incompatible return value type (got "ndarray", expected
+ # "Tuple[ndarray, Optional[List[str]]]")
+ return res_values # type: ignore[return-value]
res_values = res_values.astype("i8", copy=False)
result = type(orig_values)(res_values, dtype=orig_values.dtype)
@@ -553,9 +556,13 @@ def _ea_wrap_cython_operation(
)
dtype = maybe_cast_result_dtype(orig_values.dtype, how)
if is_extension_array_dtype(dtype):
- cls = dtype.construct_array_type()
+ # error: Item "dtype[Any]" of "Union[dtype[Any], ExtensionDtype]" has no
+ # attribute "construct_array_type"
+ cls = dtype.construct_array_type() # type: ignore[union-attr]
return cls._from_sequence(res_values, dtype=dtype)
- return res_values
+ # error: Incompatible return value type (got "ndarray", expected
+ # "Tuple[ndarray, Optional[List[str]]]")
+ return res_values # type: ignore[return-value]
elif is_float_dtype(values.dtype):
# FloatingArray
@@ -592,7 +599,9 @@ def _cython_operation(
self._disallow_invalid_ops(values, how)
if is_extension_array_dtype(values.dtype):
- return self._ea_wrap_cython_operation(
+ # error: Incompatible return value type (got "Tuple[ndarray,
+ # Optional[List[str]]]", expected "ndarray")
+ return self._ea_wrap_cython_operation( # type: ignore[return-value]
kind, values, how, axis, min_count, **kwargs
)
@@ -680,7 +689,9 @@ def _cython_operation(
# e.g. if we are int64 and need to restore to datetime64/timedelta64
# "rank" is the only member of cython_cast_blocklist we get here
dtype = maybe_cast_result_dtype(orig_values.dtype, how)
- result = maybe_downcast_to_dtype(result, dtype)
+ # error: Argument 2 to "maybe_downcast_to_dtype" has incompatible type
+ # "Union[dtype[Any], ExtensionDtype]"; expected "Union[str, dtype[Any]]"
+ result = maybe_downcast_to_dtype(result, dtype) # type: ignore[arg-type]
return result
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index e3f9f6dbb0025..9543b11ad4de1 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -191,7 +191,8 @@
str_t = str
-_o_dtype = np.dtype(object)
+# error: Value of type variable "_DTypeScalar" of "dtype" cannot be "object"
+_o_dtype = np.dtype(object) # type: ignore[type-var]
_Identity = NewType("_Identity", object)
@@ -404,14 +405,23 @@ def __new__(
# they are actually ints, e.g. '0' and 0.0
# should not be coerced
# GH 11836
- data = _maybe_cast_with_dtype(data, dtype, copy)
+
+ # error: Argument 1 to "_maybe_cast_with_dtype" has incompatible type
+ # "Union[ndarray, Index, Series]"; expected "ndarray"
+ data = _maybe_cast_with_dtype(
+ data, dtype, copy # type: ignore[arg-type]
+ )
dtype = data.dtype
if data.dtype.kind in ["i", "u", "f"]:
# maybe coerce to a sub-class
arr = data
else:
- arr = com.asarray_tuplesafe(data, dtype=object)
+ # error: Argument "dtype" to "asarray_tuplesafe" has incompatible type
+ # "Type[object]"; expected "Union[str, dtype[Any], None]"
+ arr = com.asarray_tuplesafe(
+ data, dtype=object # type: ignore[arg-type]
+ )
if dtype is None:
arr = _maybe_cast_data_without_dtype(arr)
@@ -445,7 +455,10 @@ def __new__(
data, names=name or kwargs.get("names")
)
# other iterable of some kind
- subarr = com.asarray_tuplesafe(data, dtype=object)
+
+ # error: Argument "dtype" to "asarray_tuplesafe" has incompatible type
+ # "Type[object]"; expected "Union[str, dtype[Any], None]"
+ subarr = com.asarray_tuplesafe(data, dtype=object) # type: ignore[arg-type]
return Index(subarr, dtype=dtype, copy=copy, name=name, **kwargs)
@classmethod
@@ -2889,10 +2902,16 @@ def union(self, other, sort=None):
# <T> | <T> -> T
# <T> | <U> -> object
if not (is_integer_dtype(self.dtype) and is_integer_dtype(other.dtype)):
- dtype = "float64"
+ # error: Incompatible types in assignment (expression has type
+ # "str", variable has type "Union[dtype[Any], ExtensionDtype]")
+ dtype = "float64" # type: ignore[assignment]
else:
# one is int64 other is uint64
- dtype = object
+
+ # error: Incompatible types in assignment (expression has type
+ # "Type[object]", variable has type "Union[dtype[Any],
+ # ExtensionDtype]")
+ dtype = object # type: ignore[assignment]
left = self.astype(dtype, copy=False)
right = other.astype(dtype, copy=False)
@@ -2941,7 +2960,11 @@ def _union(self, other: Index, sort):
):
# Both are unique and monotonic, so can use outer join
try:
- return self._outer_indexer(lvals, rvals)[0]
+ # error: Argument 1 to "_outer_indexer" of "Index" has incompatible type
+ # "Union[ExtensionArray, ndarray]"; expected "ndarray"
+ # error: Argument 2 to "_outer_indexer" of "Index" has incompatible type
+ # "Union[ExtensionArray, ndarray]"; expected "ndarray"
+ return self._outer_indexer(lvals, rvals)[0] # type: ignore[arg-type]
except (TypeError, IncompatibleFrequency):
# incomparable objects
value_list = list(lvals)
@@ -2953,7 +2976,12 @@ def _union(self, other: Index, sort):
elif not other.is_unique and not self.is_unique:
# self and other both have duplicates
- result = algos.union_with_duplicates(lvals, rvals)
+
+ # error: Argument 1 to "union_with_duplicates" has incompatible type
+ # "Union[ExtensionArray, ndarray]"; expected "ndarray"
+ # error: Argument 2 to "union_with_duplicates" has incompatible type
+ # "Union[ExtensionArray, ndarray]"; expected "ndarray"
+ result = algos.union_with_duplicates(lvals, rvals) # type: ignore[arg-type]
return _maybe_try_sort(result, sort)
# Either other or self is not unique
@@ -2965,10 +2993,16 @@ def _union(self, other: Index, sort):
missing = algos.unique1d(self.get_indexer_non_unique(other)[1])
if len(missing) > 0:
- other_diff = algos.take_nd(rvals, missing, allow_fill=False)
+ # error: Value of type variable "ArrayLike" of "take_nd" cannot be
+ # "Union[ExtensionArray, ndarray]"
+ other_diff = algos.take_nd(
+ rvals, missing, allow_fill=False # type: ignore[type-var]
+ )
result = concat_compat((lvals, other_diff))
else:
- result = lvals
+ # error: Incompatible types in assignment (expression has type
+ # "Union[ExtensionArray, ndarray]", variable has type "ndarray")
+ result = lvals # type: ignore[assignment]
if not self.is_monotonic or not other.is_monotonic:
result = _maybe_try_sort(result, sort)
@@ -3058,7 +3092,9 @@ def _intersection(self, other: Index, sort=False):
if self.is_monotonic and other.is_monotonic:
try:
- result = self._inner_indexer(lvals, rvals)[0]
+ # error: Argument 1 to "_inner_indexer" of "Index" has incompatible type
+ # "Union[ExtensionArray, ndarray]"; expected "ndarray"
+ result = self._inner_indexer(lvals, rvals)[0] # type: ignore[arg-type]
except TypeError:
pass
else:
@@ -3964,11 +4000,15 @@ def join(self, other, how="left", level=None, return_indexers=False, sort=False)
if return_indexers:
if join_index is self:
- lindexer = None
+ # error: Incompatible types in assignment (expression has type "None",
+ # variable has type "ndarray")
+ lindexer = None # type: ignore[assignment]
else:
lindexer = self.get_indexer(join_index)
if join_index is other:
- rindexer = None
+ # error: Incompatible types in assignment (expression has type "None",
+ # variable has type "ndarray")
+ rindexer = None # type: ignore[assignment]
else:
rindexer = other.get_indexer(join_index)
return join_index, lindexer, rindexer
@@ -4075,7 +4115,11 @@ def _join_non_unique(self, other, how="left", return_indexers=False):
mask = left_idx == -1
np.putmask(join_index, mask, rvalues.take(right_idx))
- join_index = self._wrap_joined_index(join_index, other)
+ # error: Incompatible types in assignment (expression has type "Index", variable
+ # has type "ndarray")
+ join_index = self._wrap_joined_index(
+ join_index, other # type: ignore[assignment]
+ )
if return_indexers:
return join_index, left_idx, right_idx
@@ -4248,23 +4292,61 @@ def _join_monotonic(self, other, how="left", return_indexers=False):
elif how == "right":
join_index = other
lidx = self._left_indexer_unique(ov, sv)
- ridx = None
+ # error: Incompatible types in assignment (expression has type "None",
+ # variable has type "ndarray")
+ ridx = None # type: ignore[assignment]
elif how == "inner":
- join_index, lidx, ridx = self._inner_indexer(sv, ov)
- join_index = self._wrap_joined_index(join_index, other)
+ # error: Incompatible types in assignment (expression has type
+ # "ndarray", variable has type "Index")
+ join_index, lidx, ridx = self._inner_indexer( # type:ignore[assignment]
+ sv, ov
+ )
+ # error: Argument 1 to "_wrap_joined_index" of "Index" has incompatible
+ # type "Index"; expected "ndarray"
+ join_index = self._wrap_joined_index(
+ join_index, other # type: ignore[arg-type]
+ )
elif how == "outer":
- join_index, lidx, ridx = self._outer_indexer(sv, ov)
- join_index = self._wrap_joined_index(join_index, other)
+ # error: Incompatible types in assignment (expression has type
+ # "ndarray", variable has type "Index")
+ join_index, lidx, ridx = self._outer_indexer( # type:ignore[assignment]
+ sv, ov
+ )
+ # error: Argument 1 to "_wrap_joined_index" of "Index" has incompatible
+ # type "Index"; expected "ndarray"
+ join_index = self._wrap_joined_index(
+ join_index, other # type: ignore[arg-type]
+ )
else:
if how == "left":
- join_index, lidx, ridx = self._left_indexer(sv, ov)
+ # error: Incompatible types in assignment (expression has type
+ # "ndarray", variable has type "Index")
+ join_index, lidx, ridx = self._left_indexer( # type: ignore[assignment]
+ sv, ov
+ )
elif how == "right":
- join_index, ridx, lidx = self._left_indexer(ov, sv)
+ # error: Incompatible types in assignment (expression has type
+ # "ndarray", variable has type "Index")
+ join_index, ridx, lidx = self._left_indexer( # type: ignore[assignment]
+ ov, sv
+ )
elif how == "inner":
- join_index, lidx, ridx = self._inner_indexer(sv, ov)
+ # error: Incompatible types in assignment (expression has type
+ # "ndarray", variable has type "Index")
+ join_index, lidx, ridx = self._inner_indexer( # type:ignore[assignment]
+ sv, ov
+ )
elif how == "outer":
- join_index, lidx, ridx = self._outer_indexer(sv, ov)
- join_index = self._wrap_joined_index(join_index, other)
+ # error: Incompatible types in assignment (expression has type
+ # "ndarray", variable has type "Index")
+ join_index, lidx, ridx = self._outer_indexer( # type:ignore[assignment]
+ sv, ov
+ )
+ # error: Argument 1 to "_wrap_joined_index" of "Index" has incompatible type
+ # "Index"; expected "ndarray"
+ join_index = self._wrap_joined_index(
+ join_index, other # type: ignore[arg-type]
+ )
if return_indexers:
lidx = None if lidx is None else ensure_platform_int(lidx)
@@ -4307,7 +4389,11 @@ def values(self) -> ArrayLike:
Index.array : Reference to the underlying data.
Index.to_numpy : A NumPy array representing the underlying data.
"""
- return self._data
+ # error: Incompatible return value type (got "Union[ExtensionArray, ndarray]",
+ # expected "ExtensionArray")
+ # error: Incompatible return value type (got "Union[ExtensionArray, ndarray]",
+ # expected "ndarray")
+ return self._data # type: ignore[return-value]
@cache_readonly
@doc(IndexOpsMixin.array)
@@ -4349,7 +4435,9 @@ def _get_engine_target(self) -> np.ndarray:
"""
Get the ndarray that we can pass to the IndexEngine constructor.
"""
- return self._values
+ # error: Incompatible return value type (got "Union[ExtensionArray,
+ # ndarray]", expected "ndarray")
+ return self._values # type: ignore[return-value]
@doc(IndexOpsMixin.memory_usage)
def memory_usage(self, deep: bool = False) -> int:
@@ -4542,7 +4630,11 @@ def __getitem__(self, key):
result = getitem(key)
if not is_scalar(result):
- if np.ndim(result) > 1:
+ # error: Argument 1 to "ndim" has incompatible type "Union[ExtensionArray,
+ # Any]"; expected "Union[Union[int, float, complex, str, bytes, generic],
+ # Sequence[Union[int, float, complex, str, bytes, generic]],
+ # Sequence[Sequence[Any]], _SupportsArray]"
+ if np.ndim(result) > 1: # type: ignore[arg-type]
deprecate_ndim_indexing(result)
return result
# NB: Using _constructor._simple_new would break if MultiIndex
@@ -4622,7 +4714,9 @@ def putmask(self, mask, value):
numpy.ndarray.putmask : Changes elements of an array
based on conditional and input values.
"""
- mask, noop = validate_putmask(self._values, mask)
+ # error: Value of type variable "ArrayLike" of "validate_putmask" cannot be
+ # "Union[ExtensionArray, ndarray]"
+ mask, noop = validate_putmask(self._values, mask) # type: ignore[type-var]
if noop:
return self.copy()
@@ -4638,7 +4732,11 @@ def putmask(self, mask, value):
return self.astype(dtype).putmask(mask, value)
values = self._values.copy()
- converted = setitem_datetimelike_compat(values, mask.sum(), converted)
+ # error: Argument 1 to "setitem_datetimelike_compat" has incompatible type
+ # "Union[ExtensionArray, ndarray]"; expected "ndarray"
+ converted = setitem_datetimelike_compat(
+ values, mask.sum(), converted # type: ignore[arg-type]
+ )
np.putmask(values, mask, converted)
return type(self)._simple_new(values, name=self.name)
@@ -5502,7 +5600,9 @@ def isin(self, values, level=None):
"""
if level is not None:
self._validate_index_level(level)
- return algos.isin(self._values, values)
+ # error: Value of type variable "AnyArrayLike" of "isin" cannot be
+ # "Union[ExtensionArray, ndarray]"
+ return algos.isin(self._values, values) # type: ignore[type-var]
def _get_string_slice(self, key: str_t):
# this is for partial string indexing,
@@ -5923,7 +6023,11 @@ def _cmp_method(self, other, op):
else:
with np.errstate(all="ignore"):
- result = ops.comparison_op(self._values, other, op)
+ # error: Value of type variable "ArrayLike" of "comparison_op" cannot be
+ # "Union[ExtensionArray, ndarray]"
+ result = ops.comparison_op(
+ self._values, other, op # type: ignore[type-var]
+ )
return result
@@ -5996,7 +6100,11 @@ def any(self, *args, **kwargs):
"""
nv.validate_any(args, kwargs)
self._maybe_disable_logical_methods("any")
- return np.any(self.values)
+ # error: Argument 1 to "any" has incompatible type "ArrayLike"; expected
+ # "Union[Union[int, float, complex, str, bytes, generic], Sequence[Union[int,
+ # float, complex, str, bytes, generic]], Sequence[Sequence[Any]],
+ # _SupportsArray]"
+ return np.any(self.values) # type: ignore[arg-type]
def all(self, *args, **kwargs):
"""
@@ -6053,7 +6161,11 @@ def all(self, *args, **kwargs):
"""
nv.validate_all(args, kwargs)
self._maybe_disable_logical_methods("all")
- return np.all(self.values)
+ # error: Argument 1 to "all" has incompatible type "ArrayLike"; expected
+ # "Union[Union[int, float, complex, str, bytes, generic], Sequence[Union[int,
+ # float, complex, str, bytes, generic]], Sequence[Sequence[Any]],
+ # _SupportsArray]"
+ return np.all(self.values) # type: ignore[arg-type]
@final
def _maybe_disable_logical_methods(self, opname: str_t):
@@ -6340,7 +6452,11 @@ def _maybe_cast_data_without_dtype(subarr):
if inferred == "integer":
try:
- data = _try_convert_to_int_array(subarr, False, None)
+ # error: Argument 3 to "_try_convert_to_int_array" has incompatible type
+ # "None"; expected "dtype[Any]"
+ data = _try_convert_to_int_array(
+ subarr, False, None # type: ignore[arg-type]
+ )
return data
except ValueError:
pass
@@ -6374,7 +6490,11 @@ def _maybe_cast_data_without_dtype(subarr):
pass
elif inferred.startswith("timedelta"):
- data = TimedeltaArray._from_sequence(subarr, copy=False)
+ # error: Incompatible types in assignment (expression has type
+ # "TimedeltaArray", variable has type "ndarray")
+ data = TimedeltaArray._from_sequence( # type: ignore[assignment]
+ subarr, copy=False
+ )
return data
elif inferred == "period":
try:
diff --git a/pandas/core/indexes/category.py b/pandas/core/indexes/category.py
index 869836a3da70c..a38ef55614638 100644
--- a/pandas/core/indexes/category.py
+++ b/pandas/core/indexes/category.py
@@ -193,12 +193,17 @@ def _can_hold_strings(self):
def _engine_type(self):
# self.codes can have dtype int8, int16, int32 or int64, so we need
# to return the corresponding engine type (libindex.Int8Engine, etc.).
+
+ # error: Invalid index type "Type[generic]" for "Dict[Type[signedinteger[Any]],
+ # Any]"; expected type "Type[signedinteger[Any]]"
return {
np.int8: libindex.Int8Engine,
np.int16: libindex.Int16Engine,
np.int32: libindex.Int32Engine,
np.int64: libindex.Int64Engine,
- }[self.codes.dtype.type]
+ }[
+ self.codes.dtype.type # type: ignore[index]
+ ]
_attributes = ["name"]
@@ -484,7 +489,9 @@ def _get_indexer(
if self.equals(target):
return np.arange(len(self), dtype="intp")
- return self._get_indexer_non_unique(target._values)[0]
+ # error: Value of type variable "ArrayLike" of "_get_indexer_non_unique" of
+ # "CategoricalIndex" cannot be "Union[ExtensionArray, ndarray]"
+ return self._get_indexer_non_unique(target._values)[0] # type: ignore[type-var]
@Appender(_index_shared_docs["get_indexer_non_unique"] % _index_doc_kwargs)
def get_indexer_non_unique(self, target):
diff --git a/pandas/core/indexes/datetimelike.py b/pandas/core/indexes/datetimelike.py
index 1dd5b40f7102f..793dd041fbf6f 100644
--- a/pandas/core/indexes/datetimelike.py
+++ b/pandas/core/indexes/datetimelike.py
@@ -136,7 +136,9 @@ def _is_all_dates(self) -> bool:
# Abstract data attributes
@property
- def values(self) -> np.ndarray:
+ # error: Return type "ndarray" of "values" incompatible with return type "ArrayLike"
+ # in supertype "Index"
+ def values(self) -> np.ndarray: # type: ignore[override]
# Note: PeriodArray overrides this to return an ndarray of objects.
return self._data._ndarray
@@ -528,8 +530,10 @@ def shift(self: _T, periods: int = 1, freq=None) -> _T:
PeriodIndex.shift : Shift values of PeriodIndex.
"""
arr = self._data.view()
- arr._freq = self.freq
- result = arr._time_shift(periods, freq=freq)
+ # error: "ExtensionArray" has no attribute "_freq"
+ arr._freq = self.freq # type: ignore[attr-defined]
+ # error: "ExtensionArray" has no attribute "_time_shift"
+ result = arr._time_shift(periods, freq=freq) # type: ignore[attr-defined]
return type(self)(result, name=self.name)
# --------------------------------------------------------------------
@@ -772,7 +776,8 @@ def _fast_union(self: _T, other: _T, sort=None) -> _T:
left, right = self, other
left_start = left[0]
loc = right.searchsorted(left_start, side="left")
- right_chunk = right._values[:loc]
+ # error: Slice index must be an integer or None
+ right_chunk = right._values[:loc] # type: ignore[misc]
dates = concat_compat((left._values, right_chunk))
# With sort being False, we can't infer that result.freq == self.freq
# TODO: no tests rely on the _with_freq("infer"); needed?
@@ -788,7 +793,8 @@ def _fast_union(self: _T, other: _T, sort=None) -> _T:
# concatenate
if left_end < right_end:
loc = right.searchsorted(left_end, side="right")
- right_chunk = right._values[loc:]
+ # error: Slice index must be an integer or None
+ right_chunk = right._values[loc:] # type: ignore[misc]
dates = concat_compat([left._values, right_chunk])
# The can_fast_union check ensures that the result.freq
# should match self.freq
diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index 9ea43d083f5b3..ed0856f3d30a3 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -365,7 +365,10 @@ def _is_dates_only(self) -> bool:
"""
from pandas.io.formats.format import is_dates_only
- return self.tz is None and is_dates_only(self._values)
+ # error: Argument 1 to "is_dates_only" has incompatible type
+ # "Union[ExtensionArray, ndarray]"; expected "Union[ndarray,
+ # DatetimeArray, Index, DatetimeIndex]"
+ return self.tz is None and is_dates_only(self._values) # type: ignore[arg-type]
def __reduce__(self):
@@ -533,7 +536,9 @@ def to_series(self, keep_tz=lib.no_default, index=None, name=None):
# preserve the tz & copy
values = self.copy(deep=True)
else:
- values = self._values.view("M8[ns]").copy()
+ # error: Incompatible types in assignment (expression has type
+ # "Union[ExtensionArray, ndarray]", variable has type "DatetimeIndex")
+ values = self._values.view("M8[ns]").copy() # type: ignore[assignment]
return Series(values, index=index, name=name)
diff --git a/pandas/core/indexes/extension.py b/pandas/core/indexes/extension.py
index a5899f83dd238..4c15e9df534ba 100644
--- a/pandas/core/indexes/extension.py
+++ b/pandas/core/indexes/extension.py
@@ -339,7 +339,9 @@ def astype(self, dtype, copy=True):
@cache_readonly
def _isnan(self) -> np.ndarray:
- return self._data.isna()
+ # error: Incompatible return value type (got "ExtensionArray", expected
+ # "ndarray")
+ return self._data.isna() # type: ignore[return-value]
@doc(Index.equals)
def equals(self, other) -> bool:
diff --git a/pandas/core/indexes/interval.py b/pandas/core/indexes/interval.py
index ad512b8393166..58c5b23d12a35 100644
--- a/pandas/core/indexes/interval.py
+++ b/pandas/core/indexes/interval.py
@@ -1227,8 +1227,16 @@ def interval_range(
else:
# delegate to the appropriate range function
if isinstance(endpoint, Timestamp):
- breaks = date_range(start=start, end=end, periods=periods, freq=freq)
+ # error: Incompatible types in assignment (expression has type
+ # "DatetimeIndex", variable has type "ndarray")
+ breaks = date_range( # type: ignore[assignment]
+ start=start, end=end, periods=periods, freq=freq
+ )
else:
- breaks = timedelta_range(start=start, end=end, periods=periods, freq=freq)
+ # error: Incompatible types in assignment (expression has type
+ # "TimedeltaIndex", variable has type "ndarray")
+ breaks = timedelta_range( # type: ignore[assignment]
+ start=start, end=end, periods=periods, freq=freq
+ )
return IntervalIndex.from_breaks(breaks, name=name, closed=closed)
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index fc3e404998b43..3b538b948ae81 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -711,14 +711,18 @@ def _values(self) -> np.ndarray:
vals, (ABCDatetimeIndex, ABCTimedeltaIndex)
):
vals = vals.astype(object)
- vals = np.array(vals, copy=False)
+ # error: Incompatible types in assignment (expression has type "ndarray",
+ # variable has type "Index")
+ vals = np.array(vals, copy=False) # type: ignore[assignment]
values.append(vals)
arr = lib.fast_zip(values)
return arr
@property
- def values(self) -> np.ndarray:
+ # error: Return type "ndarray" of "values" incompatible with return type "ArrayLike"
+ # in supertype "Index"
+ def values(self) -> np.ndarray: # type: ignore[override]
return self._values
@property
@@ -2218,7 +2222,11 @@ def drop(self, codes, level=None, errors="raise"):
if not isinstance(codes, (np.ndarray, Index)):
try:
- codes = com.index_labels_to_array(codes, dtype=object)
+ # error: Argument "dtype" to "index_labels_to_array" has incompatible
+ # type "Type[object]"; expected "Union[str, dtype[Any], None]"
+ codes = com.index_labels_to_array(
+ codes, dtype=object # type: ignore[arg-type]
+ )
except ValueError:
pass
@@ -3162,10 +3170,14 @@ def convert_indexer(start, stop, step, indexer=indexer, codes=level_codes):
indexer = codes.take(ensure_platform_int(indexer))
result = Series(Index(indexer).isin(r).nonzero()[0])
m = result.map(mapper)
- m = np.asarray(m)
+ # error: Incompatible types in assignment (expression has type
+ # "ndarray", variable has type "Series")
+ m = np.asarray(m) # type: ignore[assignment]
else:
- m = np.zeros(len(codes), dtype=bool)
+ # error: Incompatible types in assignment (expression has type
+ # "ndarray", variable has type "Series")
+ m = np.zeros(len(codes), dtype=bool) # type: ignore[assignment]
m[np.in1d(codes, r, assume_unique=Index(codes).is_unique)] = True
return m
diff --git a/pandas/core/indexes/numeric.py b/pandas/core/indexes/numeric.py
index a581516f23feb..b6f476d864011 100644
--- a/pandas/core/indexes/numeric.py
+++ b/pandas/core/indexes/numeric.py
@@ -253,7 +253,9 @@ def asi8(self) -> np.ndarray:
FutureWarning,
stacklevel=2,
)
- return self._values.view(self._default_dtype)
+ # error: Incompatible return value type (got "Union[ExtensionArray, ndarray]",
+ # expected "ndarray")
+ return self._values.view(self._default_dtype) # type: ignore[return-value]
class Int64Index(IntegerIndex):
@@ -292,7 +294,10 @@ def _convert_arr_indexer(self, keyarr):
):
dtype = np.uint64
- return com.asarray_tuplesafe(keyarr, dtype=dtype)
+ # 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]
_float64_descr_args = {
@@ -328,7 +333,10 @@ def astype(self, dtype, copy=True):
elif is_integer_dtype(dtype) and not is_extension_array_dtype(dtype):
# TODO(jreback); this can change once we have an EA Index type
# GH 13149
- arr = astype_nansafe(self._values, dtype=dtype)
+
+ # error: Argument 1 to "astype_nansafe" has incompatible type
+ # "Union[ExtensionArray, ndarray]"; expected "ndarray"
+ arr = astype_nansafe(self._values, dtype=dtype) # type: ignore[arg-type]
return Int64Index(arr, name=self.name)
return super().astype(dtype, copy=copy)
diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index 0c5dbec2094e5..b15912e4c477b 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -275,7 +275,9 @@ def __new__(
# Data
@property
- def values(self) -> np.ndarray:
+ # error: Return type "ndarray" of "values" incompatible with return type "ArrayLike"
+ # in supertype "Index"
+ def values(self) -> np.ndarray: # type: ignore[override]
return np.asarray(self, dtype=object)
def _maybe_convert_timedelta(self, other):
diff --git a/pandas/core/indexes/range.py b/pandas/core/indexes/range.py
index 56093c2a399c2..05bb32dad6cab 100644
--- a/pandas/core/indexes/range.py
+++ b/pandas/core/indexes/range.py
@@ -111,7 +111,12 @@ def __new__(
name=None,
):
- cls._validate_dtype(dtype)
+ # error: Argument 1 to "_validate_dtype" of "NumericIndex" has incompatible type
+ # "Union[ExtensionDtype, str, dtype[Any], Type[str], Type[float], Type[int],
+ # Type[complex], Type[bool], Type[object], None]"; expected
+ # "Union[ExtensionDtype, Union[str, dtype[Any]], Type[str], Type[float],
+ # Type[int], Type[complex], Type[bool], Type[object]]"
+ cls._validate_dtype(dtype) # type: ignore[arg-type]
name = maybe_extract_name(name, start, cls)
# RangeIndex
@@ -155,7 +160,12 @@ def from_range(
f"range, {repr(data)} was passed"
)
- cls._validate_dtype(dtype)
+ # error: Argument 1 to "_validate_dtype" of "NumericIndex" has incompatible type
+ # "Union[ExtensionDtype, str, dtype[Any], Type[str], Type[float], Type[int],
+ # Type[complex], Type[bool], Type[object], None]"; expected
+ # "Union[ExtensionDtype, Union[str, dtype[Any]], Type[str], Type[float],
+ # Type[int], Type[complex], Type[bool], Type[object]]"
+ cls._validate_dtype(dtype) # type: ignore[arg-type]
return cls._simple_new(data, name=name)
@classmethod
@@ -901,7 +911,8 @@ def _arith_method(self, other, op):
# apply if we have an override
if step:
with np.errstate(all="ignore"):
- rstep = step(left.step, right)
+ # error: "bool" not callable
+ rstep = step(left.step, right) # type: ignore[operator]
# we don't have a representable op
# so return a base index
diff --git a/pandas/core/internals/array_manager.py b/pandas/core/internals/array_manager.py
index bbe71c4977e77..0ab4bc991f468 100644
--- a/pandas/core/internals/array_manager.py
+++ b/pandas/core/internals/array_manager.py
@@ -267,7 +267,11 @@ def reduce(
if res is NaT and is_timedelta64_ns_dtype(arr.dtype):
result_arrays.append(np.array(["NaT"], dtype="timedelta64[ns]"))
else:
- result_arrays.append(sanitize_array([res], None))
+ # error: Argument 1 to "append" of "list" has incompatible type
+ # "ExtensionArray"; expected "ndarray"
+ result_arrays.append(
+ sanitize_array([res], None) # type: ignore[arg-type]
+ )
result_indices.append(i)
index = Index._simple_new(np.array([None], dtype=object)) # placeholder
@@ -278,7 +282,9 @@ def reduce(
indexer = np.arange(self.shape[0])
columns = self.items
- new_mgr = type(self)(result_arrays, [index, columns])
+ # error: Argument 1 to "ArrayManager" has incompatible type "List[ndarray]";
+ # expected "List[Union[ndarray, ExtensionArray]]"
+ new_mgr = type(self)(result_arrays, [index, columns]) # type: ignore[arg-type]
return new_mgr, indexer
def grouped_reduce(self: T, func: Callable, ignore_failures: bool = False) -> T:
@@ -318,7 +324,9 @@ def grouped_reduce(self: T, func: Callable, ignore_failures: bool = False) -> T:
else:
columns = self.items
- return type(self)(result_arrays, [index, columns])
+ # error: Argument 1 to "ArrayManager" has incompatible type "List[ndarray]";
+ # expected "List[Union[ndarray, ExtensionArray]]"
+ return type(self)(result_arrays, [index, columns]) # type: ignore[arg-type]
def operate_blockwise(self, other: ArrayManager, array_op) -> ArrayManager:
"""
@@ -408,7 +416,9 @@ def apply(
if len(result_arrays) == 0:
return self.make_empty(new_axes)
- return type(self)(result_arrays, new_axes)
+ # error: Argument 1 to "ArrayManager" has incompatible type "List[ndarray]";
+ # expected "List[Union[ndarray, ExtensionArray]]"
+ return type(self)(result_arrays, new_axes) # type: ignore[arg-type]
def apply_2d(self: T, f, ignore_failures: bool = False, **kwargs) -> T:
"""
@@ -469,9 +479,8 @@ def apply_with_block(self: T, f, align_keys=None, swap_axis=True, **kwargs) -> T
elif arr.dtype.kind == "m" and not isinstance(arr, np.ndarray):
# TimedeltaArray needs to be converted to ndarray for TimedeltaBlock
- # error: Item "ExtensionArray" of "Union[Any, ExtensionArray]" has no
- # attribute "_data"
- arr = arr._data # type: ignore[union-attr]
+ # error: "ExtensionArray" has no attribute "_data"
+ arr = arr._data # type: ignore[attr-defined]
if self.ndim == 2:
if isinstance(arr, np.ndarray):
@@ -500,9 +509,16 @@ def quantile(
interpolation="linear",
) -> ArrayManager:
- arrs = [ensure_block_shape(x, 2) for x in self.arrays]
+ # error: Value of type variable "ArrayLike" of "ensure_block_shape" cannot be
+ # "Union[ndarray, ExtensionArray]"
+ arrs = [ensure_block_shape(x, 2) for x in self.arrays] # type: ignore[type-var]
assert axis == 1
- new_arrs = [quantile_compat(x, qs, interpolation, axis=axis) for x in arrs]
+ # error: Value of type variable "ArrayLike" of "quantile_compat" cannot be
+ # "object"
+ new_arrs = [
+ quantile_compat(x, qs, interpolation, axis=axis) # type: ignore[type-var]
+ for x in arrs
+ ]
for i, arr in enumerate(new_arrs):
if arr.ndim == 2:
assert arr.shape[0] == 1, arr.shape
@@ -765,7 +781,9 @@ def as_array(
result = np.empty(self.shape_proper, dtype=dtype)
- for i, arr in enumerate(self.arrays):
+ # error: Incompatible types in assignment (expression has type "Union[ndarray,
+ # ExtensionArray]", variable has type "ndarray")
+ for i, arr in enumerate(self.arrays): # type: ignore[assignment]
arr = arr.astype(dtype, copy=copy)
result[:, i] = arr
@@ -827,7 +845,11 @@ def iget_values(self, i: int) -> ArrayLike:
"""
Return the data for column i as the values (ndarray or ExtensionArray).
"""
- return self.arrays[i]
+ # error: Incompatible return value type (got "Union[ndarray, ExtensionArray]",
+ # expected "ExtensionArray")
+ # error: Incompatible return value type (got "Union[ndarray, ExtensionArray]",
+ # expected "ndarray")
+ return self.arrays[i] # type: ignore[return-value]
def idelete(self, indexer):
"""
@@ -870,7 +892,9 @@ def iset(self, loc: Union[int, slice, np.ndarray], value):
assert isinstance(value, (np.ndarray, ExtensionArray))
assert value.ndim == 1
assert len(value) == len(self._axes[0])
- self.arrays[loc] = value
+ # error: Invalid index type "Union[int, slice, ndarray]" for
+ # "List[Union[ndarray, ExtensionArray]]"; expected type "int"
+ self.arrays[loc] = value # type: ignore[index]
return
# multiple columns -> convert slice or array to integer indices
@@ -883,7 +907,9 @@ def iset(self, loc: Union[int, slice, np.ndarray], value):
else:
assert isinstance(loc, np.ndarray)
assert loc.dtype == "bool"
- indices = np.nonzero(loc)[0]
+ # error: Incompatible types in assignment (expression has type "ndarray",
+ # variable has type "range")
+ indices = np.nonzero(loc)[0] # type: ignore[assignment]
assert value.ndim == 2
assert value.shape[0] == len(self._axes[0])
@@ -1002,7 +1028,9 @@ def _reindex_indexer(
else:
validate_indices(indexer, len(self._axes[0]))
new_arrays = [
- take_1d(
+ # error: Value of type variable "ArrayLike" of "take_1d" cannot be
+ # "Union[ndarray, ExtensionArray]" [type-var]
+ take_1d( # type: ignore[type-var]
arr,
indexer,
allow_fill=True,
@@ -1047,7 +1075,11 @@ def _make_na_array(self, fill_value=None):
fill_value = np.nan
dtype, fill_value = infer_dtype_from_scalar(fill_value)
- values = np.empty(self.shape_proper[0], dtype=dtype)
+ # error: Argument "dtype" to "empty" 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]]]"
+ values = np.empty(self.shape_proper[0], dtype=dtype) # type: ignore[arg-type]
values.fill(fill_value)
return values
@@ -1057,7 +1089,9 @@ def _equal_values(self, other) -> bool:
assuming shape and indexes have already been checked.
"""
for left, right in zip(self.arrays, other.arrays):
- if not array_equals(left, right):
+ # error: Value of type variable "ArrayLike" of "array_equals" cannot be
+ # "Union[Any, ndarray, ExtensionArray]"
+ if not array_equals(left, right): # type: ignore[type-var]
return False
else:
return True
@@ -1084,7 +1118,9 @@ def unstack(self, unstacker, fill_value) -> ArrayManager:
new_arrays = []
for arr in self.arrays:
for i in range(unstacker.full_shape[1]):
- new_arr = take_1d(
+ # error: Value of type variable "ArrayLike" of "take_1d" cannot be
+ # "Union[ndarray, ExtensionArray]" [type-var]
+ new_arr = take_1d( # type: ignore[type-var]
arr, new_indexer2D[:, i], allow_fill=True, fill_value=fill_value
)
new_arrays.append(new_arr)
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index f0d7d7e441527..1767b56962db1 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -117,8 +117,10 @@
)
from pandas.core.arrays._mixins import NDArrayBackedExtensionArray
+# comparison is faster than is_object_dtype
-_dtype_obj = np.dtype(object) # comparison is faster than is_object_dtype
+# error: Value of type variable "_DTypeScalar" of "dtype" cannot be "object"
+_dtype_obj = np.dtype(object) # type: ignore[type-var]
class Block(PandasObject):
@@ -277,7 +279,9 @@ def array_values(self) -> ExtensionArray:
"""
The array that Series.array returns. Always an ExtensionArray.
"""
- return PandasArray(self.values)
+ # error: Argument 1 to "PandasArray" has incompatible type "Union[ndarray,
+ # ExtensionArray]"; expected "Union[ndarray, PandasArray]"
+ return PandasArray(self.values) # type: ignore[arg-type]
def get_values(self, dtype: Optional[DtypeObj] = None) -> np.ndarray:
"""
@@ -286,7 +290,9 @@ def get_values(self, dtype: Optional[DtypeObj] = None) -> np.ndarray:
"""
if dtype == _dtype_obj:
return self.values.astype(_dtype_obj)
- return self.values
+ # error: Incompatible return value type (got "Union[ndarray, ExtensionArray]",
+ # expected "ndarray")
+ return self.values # type: ignore[return-value]
@final
def get_block_values_for_json(self) -> np.ndarray:
@@ -474,7 +480,9 @@ def fillna(
inplace = validate_bool_kwarg(inplace, "inplace")
mask = isna(self.values)
- mask, noop = validate_putmask(self.values, mask)
+ # error: Value of type variable "ArrayLike" of "validate_putmask" cannot be
+ # "Union[ndarray, ExtensionArray]"
+ mask, noop = validate_putmask(self.values, mask) # type: ignore[type-var]
if limit is not None:
limit = libalgos.validate_limit(None, limit=limit)
@@ -617,7 +625,9 @@ def downcast(self, dtypes=None) -> List[Block]:
if dtypes is None:
dtypes = "infer"
- nv = maybe_downcast_to_dtype(values, dtypes)
+ # error: Value of type variable "ArrayLike" of "maybe_downcast_to_dtype"
+ # cannot be "Union[ndarray, ExtensionArray]"
+ nv = maybe_downcast_to_dtype(values, dtypes) # type: ignore[type-var]
return [self.make_block(nv)]
# ndim > 1
@@ -661,7 +671,11 @@ def astype(self, dtype, copy: bool = False, errors: str = "raise"):
if values.dtype.kind in ["m", "M"]:
values = self.array_values()
- new_values = astype_array_safe(values, dtype, copy=copy, errors=errors)
+ # error: Value of type variable "ArrayLike" of "astype_array_safe" cannot be
+ # "Union[ndarray, ExtensionArray]"
+ new_values = astype_array_safe(
+ values, dtype, copy=copy, errors=errors # type: ignore[type-var]
+ )
newb = self.make_block(new_values)
if newb.shape != self.shape:
@@ -758,7 +772,9 @@ def replace(
values = self.values
- mask = missing.mask_missing(values, to_replace)
+ # error: Value of type variable "ArrayLike" of "mask_missing" cannot be
+ # "Union[ndarray, ExtensionArray]"
+ mask = missing.mask_missing(values, to_replace) # type: ignore[type-var]
if not mask.any():
# Note: we get here with test_replace_extension_other incorrectly
# bc _can_hold_element is incorrect.
@@ -785,7 +801,9 @@ def replace(
)
blk = self if inplace else self.copy()
- putmask_inplace(blk.values, mask, value)
+ # error: Value of type variable "ArrayLike" of "putmask_inplace" cannot be
+ # "Union[ndarray, ExtensionArray]"
+ putmask_inplace(blk.values, mask, value) # type: ignore[type-var]
blocks = blk.convert(numeric=False, copy=False)
return blocks
@@ -826,7 +844,9 @@ def _replace_regex(
rx = re.compile(to_replace)
new_values = self.values if inplace else self.values.copy()
- replace_regex(new_values, rx, value, mask)
+ # error: Value of type variable "ArrayLike" of "replace_regex" cannot be
+ # "Union[ndarray, ExtensionArray]"
+ replace_regex(new_values, rx, value, mask) # type: ignore[type-var]
block = self.make_block(new_values)
return [block]
@@ -863,14 +883,26 @@ def _replace_list(
# in order to avoid repeating the same computations
mask = ~isna(self.values)
masks = [
- compare_or_regex_search(self.values, s[0], regex=regex, mask=mask)
+ # error: Value of type variable "ArrayLike" of "compare_or_regex_search"
+ # cannot be "Union[ndarray, ExtensionArray]"
+ compare_or_regex_search( # type: ignore[type-var]
+ self.values, s[0], regex=regex, mask=mask
+ )
for s in pairs
]
else:
# GH#38086 faster if we know we dont need to check for regex
- masks = [missing.mask_missing(self.values, s[0]) for s in pairs]
- masks = [extract_bool_array(x) for x in masks]
+ # error: Value of type variable "ArrayLike" of "mask_missing" cannot be
+ # "Union[ndarray, ExtensionArray]"
+ masks = [
+ missing.mask_missing(self.values, s[0]) # type: ignore[type-var]
+ for s in pairs
+ ]
+
+ # error: Value of type variable "ArrayLike" of "extract_bool_array" cannot be
+ # "Union[ndarray, ExtensionArray, bool]"
+ masks = [extract_bool_array(x) for x in masks] # type: ignore[type-var]
rb = [self if inplace else self.copy()]
for i, (src, dest) in enumerate(pairs):
@@ -928,7 +960,9 @@ def _replace_coerce(
nb = self.coerce_to_target_dtype(value)
if nb is self and not inplace:
nb = nb.copy()
- putmask_inplace(nb.values, mask, value)
+ # error: Value of type variable "ArrayLike" of "putmask_inplace" cannot
+ # be "Union[ndarray, ExtensionArray]"
+ putmask_inplace(nb.values, mask, value) # type: ignore[type-var]
return [nb]
else:
regex = should_use_regex(regex, to_replace)
@@ -1001,7 +1035,9 @@ def setitem(self, indexer, value):
# length checking
check_setitem_lengths(indexer, value, values)
- exact_match = is_exact_shape_match(values, arr_value)
+ # error: Value of type variable "ArrayLike" of "is_exact_shape_match" cannot be
+ # "Union[Any, ndarray, ExtensionArray]"
+ exact_match = is_exact_shape_match(values, arr_value) # type: ignore[type-var]
if is_empty_indexer(indexer, arr_value):
# GH#8669 empty indexers
@@ -1040,7 +1076,11 @@ def setitem(self, indexer, value):
values[indexer] = value.to_numpy(values.dtype).reshape(-1, 1)
else:
- value = setitem_datetimelike_compat(values, len(values[indexer]), value)
+ # error: Argument 1 to "setitem_datetimelike_compat" has incompatible type
+ # "Union[ndarray, ExtensionArray]"; expected "ndarray"
+ value = setitem_datetimelike_compat(
+ values, len(values[indexer]), value # type: ignore[arg-type]
+ )
values[indexer] = value
if transpose:
@@ -1065,7 +1105,9 @@ def putmask(self, mask, new) -> List[Block]:
List[Block]
"""
orig_mask = mask
- mask, noop = validate_putmask(self.values.T, mask)
+ # error: Value of type variable "ArrayLike" of "validate_putmask" cannot be
+ # "Union[ndarray, ExtensionArray]"
+ mask, noop = validate_putmask(self.values.T, mask) # type: ignore[type-var]
assert not isinstance(new, (ABCIndex, ABCSeries, ABCDataFrame))
# if we are passed a scalar None, convert it here
@@ -1074,7 +1116,9 @@ def putmask(self, mask, new) -> List[Block]:
if self._can_hold_element(new):
- putmask_without_repeat(self.values.T, mask, new)
+ # error: Argument 1 to "putmask_without_repeat" has incompatible type
+ # "Union[ndarray, ExtensionArray]"; expected "ndarray"
+ putmask_without_repeat(self.values.T, mask, new) # type: ignore[arg-type]
return [self]
elif noop:
@@ -1089,7 +1133,10 @@ def putmask(self, mask, new) -> List[Block]:
elif self.ndim == 1 or self.shape[0] == 1:
# no need to split columns
- nv = putmask_smart(self.values.T, mask, new).T
+
+ # error: Argument 1 to "putmask_smart" has incompatible type "Union[ndarray,
+ # ExtensionArray]"; expected "ndarray"
+ nv = putmask_smart(self.values.T, mask, new).T # type: ignore[arg-type]
return [self.make_block(nv)]
else:
@@ -1285,7 +1332,9 @@ def take_nd(
else:
allow_fill = True
- new_values = algos.take_nd(
+ # error: Value of type variable "ArrayLike" of "take_nd" cannot be
+ # "Union[ndarray, ExtensionArray]"
+ new_values = algos.take_nd( # type: ignore[type-var]
values, indexer, axis=axis, allow_fill=allow_fill, fill_value=fill_value
)
@@ -1309,7 +1358,12 @@ def shift(self, periods: int, axis: int = 0, fill_value: Any = None) -> List[Blo
""" shift the block by periods, possibly upcast """
# convert integer to float if necessary. need to do a lot more than
# that, handle boolean etc also
- new_values, fill_value = maybe_upcast(self.values, fill_value)
+
+ # error: Argument 1 to "maybe_upcast" has incompatible type "Union[ndarray,
+ # ExtensionArray]"; expected "ndarray"
+ new_values, fill_value = maybe_upcast(
+ self.values, fill_value # type: ignore[arg-type]
+ )
new_values = shift(new_values, periods, axis, fill_value)
@@ -1344,7 +1398,9 @@ def where(self, other, cond, errors="raise", axis: int = 0) -> List[Block]:
if transpose:
values = values.T
- icond, noop = validate_putmask(values, ~cond)
+ # error: Value of type variable "ArrayLike" of "validate_putmask" cannot be
+ # "Union[ndarray, ExtensionArray]"
+ icond, noop = validate_putmask(values, ~cond) # type: ignore[type-var]
if is_valid_na_for_dtype(other, self.dtype) and not self.is_object:
other = self.fill_value
@@ -1362,7 +1418,13 @@ def where(self, other, cond, errors="raise", axis: int = 0) -> List[Block]:
blocks = block.where(orig_other, cond, errors=errors, axis=axis)
return self._maybe_downcast(blocks, "infer")
- alt = setitem_datetimelike_compat(values, icond.sum(), other)
+ # error: Argument 1 to "setitem_datetimelike_compat" has incompatible type
+ # "Union[ndarray, ExtensionArray]"; expected "ndarray"
+ # error: Argument 2 to "setitem_datetimelike_compat" has incompatible type
+ # "number[Any]"; expected "int"
+ alt = setitem_datetimelike_compat(
+ values, icond.sum(), other # type: ignore[arg-type]
+ )
if alt is not other:
result = values.copy()
np.putmask(result, icond, alt)
@@ -1449,7 +1511,11 @@ def quantile(
assert axis == 1 # only ever called this way
assert is_list_like(qs) # caller is responsible for this
- result = quantile_compat(self.values, qs, interpolation, axis)
+ # error: Value of type variable "ArrayLike" of "quantile_compat" cannot be
+ # "Union[ndarray, ExtensionArray]"
+ result = quantile_compat( # type: ignore[type-var]
+ self.values, qs, interpolation, axis
+ )
return new_block(result, placement=self.mgr_locs, ndim=2)
@@ -1489,7 +1555,9 @@ def iget(self, col):
elif isinstance(col, slice):
if col != slice(None):
raise NotImplementedError(col)
- return self.values[[loc]]
+ # error: Invalid index type "List[Any]" for "ExtensionArray"; expected
+ # type "Union[int, slice, ndarray]"
+ return self.values[[loc]] # type: ignore[index]
return self.values[loc]
else:
if col != 0:
@@ -1615,7 +1683,9 @@ def to_native_types(self, na_rep="nan", quoting=None, **kwargs):
values = self.values
mask = isna(values)
- values = np.asarray(values.astype(object))
+ # error: Incompatible types in assignment (expression has type "ndarray",
+ # variable has type "ExtensionArray")
+ values = np.asarray(values.astype(object)) # type: ignore[assignment]
values[mask] = na_rep
# TODO(EA2D): reshape not needed with 2D EAs
@@ -1742,7 +1812,10 @@ def where(self, other, cond, errors="raise", axis: int = 0) -> List[Block]:
# The default `other` for Series / Frame is np.nan
# we want to replace that with the correct NA value
# for the type
- other = self.dtype.na_value
+
+ # error: Item "dtype[Any]" of "Union[dtype[Any], ExtensionDtype]" has no
+ # attribute "na_value"
+ other = self.dtype.na_value # type: ignore[union-attr]
if is_sparse(self.values):
# TODO(SparseArray.__setitem__): remove this if condition
@@ -1832,7 +1905,9 @@ def _can_hold_element(self, element: Any) -> bool:
if isinstance(element, (IntegerArray, FloatingArray)):
if element._mask.any():
return False
- return can_hold_element(self.dtype, element)
+ # error: Argument 1 to "can_hold_element" has incompatible type
+ # "Union[dtype[Any], ExtensionDtype]"; expected "dtype[Any]"
+ return can_hold_element(self.dtype, element) # type: ignore[arg-type]
@property
def _can_hold_na(self):
@@ -2317,5 +2392,7 @@ def ensure_block_shape(values: ArrayLike, ndim: int = 1) -> ArrayLike:
# block.shape is incorrect for "2D" ExtensionArrays
# We can't, and don't need to, reshape.
- values = np.asarray(values).reshape(1, -1)
+ # error: Incompatible types in assignment (expression has type "ndarray",
+ # variable has type "ExtensionArray")
+ values = np.asarray(values).reshape(1, -1) # type: ignore[assignment]
return values
diff --git a/pandas/core/internals/concat.py b/pandas/core/internals/concat.py
index 924d2a77e5da5..64777ef31ac6e 100644
--- a/pandas/core/internals/concat.py
+++ b/pandas/core/internals/concat.py
@@ -187,7 +187,9 @@ def _get_mgr_concatenation_plan(mgr: BlockManager, indexers: Dict[int, np.ndarra
blk = mgr.blocks[0]
return [(blk.mgr_locs, JoinUnit(blk, mgr_shape, indexers))]
- ax0_indexer = None
+ # error: Incompatible types in assignment (expression has type "None", variable
+ # has type "ndarray")
+ ax0_indexer = None # type: ignore[assignment]
blknos = mgr.blknos
blklocs = mgr.blklocs
@@ -329,7 +331,9 @@ def get_reindexed_values(self, empty_dtype: DtypeObj, upcasted_na) -> ArrayLike:
if self.is_valid_na_for(empty_dtype):
blk_dtype = getattr(self.block, "dtype", None)
- if blk_dtype == np.dtype(object):
+ # error: Value of type variable "_DTypeScalar" of "dtype" cannot be
+ # "object"
+ if blk_dtype == np.dtype(object): # type: ignore[type-var]
# we want to avoid filling with np.nan if we are
# using None; we already know that we are all
# nulls
@@ -340,11 +344,17 @@ def get_reindexed_values(self, empty_dtype: DtypeObj, upcasted_na) -> ArrayLike:
if is_datetime64tz_dtype(empty_dtype):
# TODO(EA2D): special case unneeded with 2D EAs
i8values = np.full(self.shape[1], fill_value.value)
- return DatetimeArray(i8values, dtype=empty_dtype)
+ # error: Incompatible return value type (got "DatetimeArray",
+ # expected "ndarray")
+ return DatetimeArray( # type: ignore[return-value]
+ i8values, dtype=empty_dtype
+ )
elif is_extension_array_dtype(blk_dtype):
pass
elif is_extension_array_dtype(empty_dtype):
- cls = empty_dtype.construct_array_type()
+ # error: Item "dtype[Any]" of "Union[dtype[Any], ExtensionDtype]"
+ # has no attribute "construct_array_type"
+ cls = empty_dtype.construct_array_type() # type: ignore[union-attr]
missing_arr = cls._from_sequence([], dtype=empty_dtype)
ncols, nrows = self.shape
assert ncols == 1, ncols
@@ -355,7 +365,15 @@ def get_reindexed_values(self, empty_dtype: DtypeObj, upcasted_na) -> ArrayLike:
else:
# NB: we should never get here with empty_dtype integer or bool;
# if we did, the missing_arr.fill would cast to gibberish
- missing_arr = np.empty(self.shape, dtype=empty_dtype)
+
+ # error: Argument "dtype" to "empty" 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]]]"
+ missing_arr = np.empty(
+ self.shape, dtype=empty_dtype # type: ignore[arg-type]
+ )
missing_arr.fill(fill_value)
return missing_arr
@@ -421,14 +439,21 @@ def _concatenate_join_units(
elif any(isinstance(t, ExtensionArray) for t in to_concat):
# concatting with at least one EA means we are concatting a single column
# the non-EA values are 2D arrays with shape (1, n)
- to_concat = [t if isinstance(t, ExtensionArray) else t[0, :] for t in to_concat]
+
+ # error: Invalid index type "Tuple[int, slice]" for "ExtensionArray"; expected
+ # type "Union[int, slice, ndarray]"
+ to_concat = [
+ t if isinstance(t, ExtensionArray) else t[0, :] # type: ignore[index]
+ for t in to_concat
+ ]
concat_values = concat_compat(to_concat, axis=0, ea_compat_axis=True)
concat_values = ensure_block_shape(concat_values, 2)
else:
concat_values = concat_compat(to_concat, axis=concat_axis)
- return concat_values
+ # error: Incompatible return value type (got "ExtensionArray", expected "ndarray")
+ return concat_values # type: ignore[return-value]
def _dtype_to_na_value(dtype: DtypeObj, has_none_blocks: bool):
@@ -436,7 +461,9 @@ def _dtype_to_na_value(dtype: DtypeObj, has_none_blocks: bool):
Find the NA value to go with this dtype.
"""
if is_extension_array_dtype(dtype):
- return dtype.na_value
+ # error: Item "dtype[Any]" of "Union[dtype[Any], ExtensionDtype]" has no
+ # attribute "na_value"
+ return dtype.na_value # type: ignore[union-attr]
elif dtype.kind in ["m", "M"]:
return dtype.type("NaT")
elif dtype.kind in ["f", "c"]:
diff --git a/pandas/core/internals/construction.py b/pandas/core/internals/construction.py
index 0b712267ccf11..0ea8c3eb994a3 100644
--- a/pandas/core/internals/construction.py
+++ b/pandas/core/internals/construction.py
@@ -162,10 +162,17 @@ def rec_array_to_mgr(
if isinstance(data, np.ma.MaskedArray):
new_arrays = fill_masked_arrays(data, arr_columns)
else:
- new_arrays = arrays
+ # error: Incompatible types in assignment (expression has type
+ # "List[ExtensionArray]", variable has type "List[ndarray]")
+ new_arrays = arrays # type: ignore[assignment]
# create the manager
- arrays, arr_columns = reorder_arrays(new_arrays, arr_columns, columns)
+
+ # error: Argument 1 to "reorder_arrays" has incompatible type "List[ndarray]";
+ # expected "List[ExtensionArray]"
+ arrays, arr_columns = reorder_arrays(
+ new_arrays, arr_columns, columns # type: ignore[arg-type]
+ )
if columns is None:
columns = arr_columns
@@ -357,12 +364,22 @@ def dict_to_mgr(
if missing.any() and not is_integer_dtype(dtype):
if dtype is None or (
not is_extension_array_dtype(dtype)
- and np.issubdtype(dtype, np.flexible)
+ # error: Argument 1 to "issubdtype" has incompatible type
+ # "Union[dtype, ExtensionDtype]"; expected "Union[dtype, None,
+ # type, _SupportsDtype, str, Tuple[Any, int], Tuple[Any,
+ # Union[int, Sequence[int]]], List[Any], _DtypeDict, Tuple[Any,
+ # Any]]"
+ and np.issubdtype(dtype, np.flexible) # type: ignore[arg-type]
):
# GH#1783
- nan_dtype = np.dtype(object)
+
+ # error: Value of type variable "_DTypeScalar" of "dtype" cannot be
+ # "object"
+ nan_dtype = np.dtype(object) # type: ignore[type-var]
else:
- nan_dtype = dtype
+ # error: Incompatible types in assignment (expression has type
+ # "Union[dtype, ExtensionDtype]", variable has type "dtype")
+ nan_dtype = dtype # type: ignore[assignment]
val = construct_1d_arraylike_from_scalar(np.nan, len(index), nan_dtype)
arrays.loc[missing] = [val] * missing.sum()
@@ -557,7 +574,9 @@ def extract_index(data) -> Index:
else:
index = ibase.default_index(lengths[0])
- return ensure_index(index)
+ # error: Value of type variable "AnyArrayLike" of "ensure_index" cannot be
+ # "Optional[Index]"
+ return ensure_index(index) # type: ignore[type-var]
def reorder_arrays(
@@ -660,7 +679,9 @@ def to_arrays(
if not len(data):
if isinstance(data, np.ndarray):
- columns = data.dtype.names
+ # error: Incompatible types in assignment (expression has type
+ # "Optional[Tuple[str, ...]]", variable has type "Optional[Index]")
+ columns = data.dtype.names # type: ignore[assignment]
if columns is not None:
# i.e. numpy structured array
arrays = [data[name] for name in columns]
@@ -689,8 +710,17 @@ def to_arrays(
data = [tuple(x) for x in data]
content = _list_to_arrays(data)
- content, columns = _finalize_columns_and_data(content, columns, dtype)
- return content, columns
+ # error: Incompatible types in assignment (expression has type "List[ndarray]",
+ # variable has type "List[Union[Union[str, int, float, bool], Union[Any, Any, Any,
+ # Any]]]")
+ content, columns = _finalize_columns_and_data( # type: ignore[assignment]
+ content, columns, dtype
+ )
+ # error: Incompatible return value type (got "Tuple[ndarray, Index]", expected
+ # "Tuple[List[ExtensionArray], Index]")
+ # error: Incompatible return value type (got "Tuple[ndarray, Index]", expected
+ # "Tuple[List[ndarray], Index]")
+ return content, columns # type: ignore[return-value]
def _list_to_arrays(data: List[Union[Tuple, List]]) -> np.ndarray:
@@ -731,7 +761,11 @@ def _list_of_series_to_arrays(
values = extract_array(s, extract_numpy=True)
aligned_values.append(algorithms.take_nd(values, indexer))
- content = np.vstack(aligned_values)
+ # error: Argument 1 to "vstack" has incompatible type "List[ExtensionArray]";
+ # expected "Sequence[Union[Union[int, float, complex, str, bytes, generic],
+ # Sequence[Union[int, float, complex, str, bytes, generic]],
+ # Sequence[Sequence[Any]], _SupportsArray]]"
+ content = np.vstack(aligned_values) # type: ignore[arg-type]
return content, columns
@@ -781,17 +815,34 @@ def _finalize_columns_and_data(
"""
Ensure we have valid columns, cast object dtypes if possible.
"""
- content = list(content.T)
+ # error: Incompatible types in assignment (expression has type "List[Any]", variable
+ # has type "ndarray")
+ content = list(content.T) # type: ignore[assignment]
try:
- columns = _validate_or_indexify_columns(content, columns)
+ # error: Argument 1 to "_validate_or_indexify_columns" has incompatible type
+ # "ndarray"; expected "List[Any]"
+ columns = _validate_or_indexify_columns(
+ content, columns # type: ignore[arg-type]
+ )
except AssertionError as err:
# GH#26429 do not raise user-facing AssertionError
raise ValueError(err) from err
if len(content) and content[0].dtype == np.object_:
- content = _convert_object_array(content, dtype=dtype)
- return content, columns
+ # error: Incompatible types in assignment (expression has type
+ # "List[Union[Union[str, int, float, bool], Union[Any, Any, Any, Any]]]",
+ # variable has type "ndarray")
+ # error: Argument 1 to "_convert_object_array" has incompatible type "ndarray";
+ # expected "List[Union[Union[str, int, float, bool], Union[Any, Any, Any,
+ # Any]]]"
+ content = _convert_object_array( # type: ignore[assignment]
+ content, dtype=dtype # type: ignore[arg-type]
+ )
+ # error: Incompatible return value type (got "Tuple[ndarray, Union[Index,
+ # List[Union[str, int]]]]", expected "Tuple[List[ndarray], Union[Index,
+ # List[Union[str, int]]]]")
+ return content, columns # type: ignore[return-value]
def _validate_or_indexify_columns(
diff --git a/pandas/core/internals/managers.py b/pandas/core/internals/managers.py
index 2daa1ce8dc9a4..476bd836bf216 100644
--- a/pandas/core/internals/managers.py
+++ b/pandas/core/internals/managers.py
@@ -173,8 +173,12 @@ def __init__(
# Populate known_consolidate, blknos, and blklocs lazily
self._known_consolidated = False
- self._blknos = None
- self._blklocs = None
+ # error: Incompatible types in assignment (expression has type "None",
+ # variable has type "ndarray")
+ self._blknos = None # type: ignore[assignment]
+ # error: Incompatible types in assignment (expression has type "None",
+ # variable has type "ndarray")
+ self._blklocs = None # type: ignore[assignment]
@classmethod
def _simple_new(cls, blocks: Tuple[Block, ...], axes: List[Index]):
@@ -316,7 +320,11 @@ def arrays(self) -> List[ArrayLike]:
Not to be used in actual code, and return value is not the same as the
ArrayManager method (list of 1D arrays vs iterator of 2D ndarrays / 1D EAs).
"""
- return [blk.values for blk in self.blocks]
+ # error: List comprehension has incompatible type List[Union[ndarray,
+ # ExtensionArray]]; expected List[ExtensionArray]
+ # error: List comprehension has incompatible type List[Union[ndarray,
+ # ExtensionArray]]; expected List[ndarray]
+ return [blk.values for blk in self.blocks] # type: ignore[misc]
def __getstate__(self):
block_values = [b.values for b in self.blocks]
@@ -889,13 +897,21 @@ def as_array(
blk = self.blocks[0]
if blk.is_extension:
# Avoid implicit conversion of extension blocks to object
- arr = blk.values.to_numpy(dtype=dtype, na_value=na_value).reshape(
- blk.shape
- )
+
+ # error: Item "ndarray" of "Union[ndarray, ExtensionArray]" has no
+ # attribute "to_numpy"
+ arr = blk.values.to_numpy( # type: ignore[union-attr]
+ dtype=dtype, na_value=na_value
+ ).reshape(blk.shape)
else:
arr = np.asarray(blk.get_values())
if dtype:
- arr = arr.astype(dtype, copy=False)
+ # error: Argument 1 to "astype" of "_ArrayOrScalarCommon" has
+ # incompatible type "Union[ExtensionDtype, str, dtype[Any],
+ # Type[object]]"; expected "Union[dtype[Any], None, type,
+ # _SupportsDType, str, Union[Tuple[Any, int], Tuple[Any, Union[int,
+ # Sequence[int]]], List[Any], _DTypeDict, Tuple[Any, Any]]]"
+ arr = arr.astype(dtype, copy=False) # type: ignore[arg-type]
else:
arr = self._interleave(dtype=dtype, na_value=na_value)
# The underlying data was copied within _interleave
@@ -928,7 +944,12 @@ def _interleave(
elif is_dtype_equal(dtype, str):
dtype = "object"
- result = np.empty(self.shape, dtype=dtype)
+ # error: Argument "dtype" to "empty" has incompatible type
+ # "Union[ExtensionDtype, str, dtype[Any], Type[object], None]"; expected
+ # "Union[dtype[Any], None, type, _SupportsDType, str, Union[Tuple[Any, int],
+ # Tuple[Any, Union[int, Sequence[int]]], List[Any], _DTypeDict, Tuple[Any,
+ # Any]]]"
+ result = np.empty(self.shape, dtype=dtype) # type: ignore[arg-type]
itemmask = np.zeros(self.shape[0])
@@ -936,9 +957,17 @@ def _interleave(
rl = blk.mgr_locs
if blk.is_extension:
# Avoid implicit conversion of extension blocks to object
- arr = blk.values.to_numpy(dtype=dtype, na_value=na_value)
+
+ # error: Item "ndarray" of "Union[ndarray, ExtensionArray]" has no
+ # attribute "to_numpy"
+ arr = blk.values.to_numpy( # type: ignore[union-attr]
+ dtype=dtype, na_value=na_value
+ )
else:
- arr = blk.get_values(dtype)
+ # error: Argument 1 to "get_values" of "Block" has incompatible type
+ # "Union[ExtensionDtype, str, dtype[Any], Type[object], None]"; expected
+ # "Union[dtype[Any], ExtensionDtype, None]"
+ arr = blk.get_values(dtype) # type: ignore[arg-type]
result[rl.indexer] = arr
itemmask[rl.indexer] = 1
@@ -989,7 +1018,12 @@ def fast_xs(self, loc: int) -> ArrayLike:
# we'll eventually construct an ExtensionArray.
result = np.empty(n, dtype=object)
else:
- result = np.empty(n, dtype=dtype)
+ # error: Argument "dtype" to "empty" has incompatible type
+ # "Union[dtype, ExtensionDtype, None]"; expected "Union[dtype,
+ # None, type, _SupportsDtype, str, Tuple[Any, int], Tuple[Any,
+ # Union[int, Sequence[int]]], List[Any], _DtypeDict, Tuple[Any,
+ # Any]]"
+ result = np.empty(n, dtype=dtype) # type: ignore[arg-type]
for blk in self.blocks:
# Such assignment may incorrectly coerce NaT to None
@@ -1000,7 +1034,9 @@ def fast_xs(self, loc: int) -> ArrayLike:
if isinstance(dtype, ExtensionDtype):
result = dtype.construct_array_type()._from_sequence(result, dtype=dtype)
- return result
+ # error: Incompatible return value type (got "ndarray", expected
+ # "ExtensionArray")
+ return result # type: ignore[return-value]
def consolidate(self) -> BlockManager:
"""
@@ -1123,7 +1159,11 @@ def value_getitem(placement):
# We have 6 tests where loc is _not_ an int.
# In this case, get_blkno_placements will yield only one tuple,
# containing (self._blknos[loc], BlockPlacement(slice(0, 1, 1)))
- loc = [loc]
+
+ # error: Incompatible types in assignment (expression has type
+ # "List[Union[int, slice, ndarray]]", variable has type "Union[int,
+ # slice, ndarray]")
+ loc = [loc] # type: ignore[assignment]
# Accessing public blknos ensures the public versions are initialized
blknos = self.blknos[loc]
@@ -1461,7 +1501,11 @@ def _make_na_block(self, placement, fill_value=None):
block_shape[0] = len(placement)
dtype, fill_value = infer_dtype_from_scalar(fill_value)
- block_values = np.empty(block_shape, dtype=dtype)
+ # error: Argument "dtype" to "empty" has incompatible type "Union[dtype,
+ # ExtensionDtype]"; expected "Union[dtype, None, type, _SupportsDtype, str,
+ # Tuple[Any, int], Tuple[Any, Union[int, Sequence[int]]], List[Any], _DtypeDict,
+ # Tuple[Any, Any]]"
+ block_values = np.empty(block_shape, dtype=dtype) # type: ignore[arg-type]
block_values.fill(fill_value)
return new_block(block_values, placement=placement, ndim=block_values.ndim)
@@ -1503,7 +1547,9 @@ def _equal_values(self: T, other: T) -> bool:
return False
left = self.blocks[0].values
right = other.blocks[0].values
- return array_equals(left, right)
+ # error: Value of type variable "ArrayLike" of "array_equals" cannot be
+ # "Union[ndarray, ExtensionArray]"
+ return array_equals(left, right) # type: ignore[type-var]
return blockwise_all(self, other, array_equals)
@@ -1884,7 +1930,12 @@ def _multi_blockify(tuples, dtype: Optional[Dtype] = None):
new_blocks = []
for dtype, tup_block in grouper:
- values, placement = _stack_arrays(list(tup_block), dtype)
+ # error: Argument 2 to "_stack_arrays" has incompatible type
+ # "Union[ExtensionDtype, str, dtype[Any], Type[str], Type[float], Type[int],
+ # Type[complex], Type[bool], Type[object], None]"; expected "dtype[Any]"
+ values, placement = _stack_arrays(
+ list(tup_block), dtype # type: ignore[arg-type]
+ )
block = new_block(values, placement=placement, ndim=2)
new_blocks.append(block)
@@ -1958,7 +2009,11 @@ def _merge_blocks(
# TODO: optimization potential in case all mgrs contain slices and
# combination of those slices is a slice, too.
new_mgr_locs = np.concatenate([b.mgr_locs.as_array for b in blocks])
- new_values = np.vstack([b.values for b in blocks])
+ # error: List comprehension has incompatible type List[Union[ndarray,
+ # ExtensionArray]]; expected List[Union[complex, generic, Sequence[Union[int,
+ # float, complex, str, bytes, generic]], Sequence[Sequence[Any]],
+ # _SupportsArray]]
+ new_values = np.vstack([b.values for b in blocks]) # type: ignore[misc]
argsort = np.argsort(new_mgr_locs)
new_values = new_values[argsort]
diff --git a/pandas/core/internals/ops.py b/pandas/core/internals/ops.py
index dbd309f0836a5..103092ba37b70 100644
--- a/pandas/core/internals/ops.py
+++ b/pandas/core/internals/ops.py
@@ -108,21 +108,35 @@ def _get_same_shape_values(
# TODO(EA2D): with 2D EAs only this first clause would be needed
if not (left_ea or right_ea):
- lvals = lvals[rblk.mgr_locs.indexer, :]
+ # error: Invalid index type "Tuple[Any, slice]" for "Union[ndarray,
+ # ExtensionArray]"; expected type "Union[int, slice, ndarray]"
+ lvals = lvals[rblk.mgr_locs.indexer, :] # type: ignore[index]
assert lvals.shape == rvals.shape, (lvals.shape, rvals.shape)
elif left_ea and right_ea:
assert lvals.shape == rvals.shape, (lvals.shape, rvals.shape)
elif right_ea:
# lvals are 2D, rvals are 1D
- lvals = lvals[rblk.mgr_locs.indexer, :]
+
+ # error: Invalid index type "Tuple[Any, slice]" for "Union[ndarray,
+ # ExtensionArray]"; expected type "Union[int, slice, ndarray]"
+ lvals = lvals[rblk.mgr_locs.indexer, :] # type: ignore[index]
assert lvals.shape[0] == 1, lvals.shape
- lvals = lvals[0, :]
+ # error: Invalid index type "Tuple[int, slice]" for "Union[Any,
+ # ExtensionArray]"; expected type "Union[int, slice, ndarray]"
+ lvals = lvals[0, :] # type: ignore[index]
else:
# lvals are 1D, rvals are 2D
assert rvals.shape[0] == 1, rvals.shape
- rvals = rvals[0, :]
-
- return lvals, rvals
+ # error: Invalid index type "Tuple[int, slice]" for "Union[ndarray,
+ # ExtensionArray]"; expected type "Union[int, slice, ndarray]"
+ rvals = rvals[0, :] # type: ignore[index]
+
+ # error: Incompatible return value type (got "Tuple[Union[ndarray, ExtensionArray],
+ # Union[ndarray, ExtensionArray]]", expected "Tuple[ExtensionArray,
+ # ExtensionArray]")
+ # error: Incompatible return value type (got "Tuple[Union[ndarray, ExtensionArray],
+ # Union[ndarray, ExtensionArray]]", expected "Tuple[ndarray, ndarray]")
+ return lvals, rvals # type: ignore[return-value]
def blockwise_all(left: BlockManager, right: BlockManager, op) -> bool:
diff --git a/pandas/core/missing.py b/pandas/core/missing.py
index dc42a175409c2..48b2084319292 100644
--- a/pandas/core/missing.py
+++ b/pandas/core/missing.py
@@ -75,7 +75,11 @@ def mask_missing(arr: ArrayLike, values_to_mask) -> np.ndarray:
# known to be holdable by arr.
# When called from Series._single_replace, values_to_mask is tuple or list
dtype, values_to_mask = infer_dtype_from(values_to_mask)
- values_to_mask = np.array(values_to_mask, dtype=dtype)
+ # error: Argument "dtype" to "array" 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]]]"
+ values_to_mask = np.array(values_to_mask, dtype=dtype) # type: ignore[arg-type]
na_mask = isna(values_to_mask)
nonna = values_to_mask[~na_mask]
@@ -305,7 +309,12 @@ def interpolate_1d(
if method in NP_METHODS:
# np.interp requires sorted X values, #21037
- indexer = np.argsort(inds[valid])
+
+ # error: Argument 1 to "argsort" has incompatible type "Union[ExtensionArray,
+ # Any]"; expected "Union[Union[int, float, complex, str, bytes, generic],
+ # Sequence[Union[int, float, complex, str, bytes, generic]],
+ # Sequence[Sequence[Any]], _SupportsArray]"
+ indexer = np.argsort(inds[valid]) # type: ignore[arg-type]
result[invalid] = np.interp(
inds[invalid], inds[valid][indexer], yvalues[valid][indexer]
)
@@ -708,7 +717,9 @@ def _pad_1d(
) -> tuple[np.ndarray, np.ndarray]:
mask = _fillna_prep(values, mask)
algos.pad_inplace(values, mask, limit=limit)
- return values, mask
+ # error: Incompatible return value type (got "Tuple[ndarray, Optional[ndarray]]",
+ # expected "Tuple[ndarray, ndarray]")
+ return values, mask # type: ignore[return-value]
@_datetimelike_compat
@@ -719,7 +730,9 @@ def _backfill_1d(
) -> tuple[np.ndarray, np.ndarray]:
mask = _fillna_prep(values, mask)
algos.backfill_inplace(values, mask, limit=limit)
- return values, mask
+ # error: Incompatible return value type (got "Tuple[ndarray, Optional[ndarray]]",
+ # expected "Tuple[ndarray, ndarray]")
+ return values, mask # type: ignore[return-value]
@_datetimelike_compat
@@ -839,4 +852,7 @@ def _rolling_window(a: np.ndarray, window: int):
# https://stackoverflow.com/a/6811241
shape = a.shape[:-1] + (a.shape[-1] - window + 1, window)
strides = a.strides + (a.strides[-1],)
- return np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides)
+ # error: Module has no attribute "stride_tricks"
+ return np.lib.stride_tricks.as_strided( # type: ignore[attr-defined]
+ a, shape=shape, strides=strides
+ )
diff --git a/pandas/core/nanops.py b/pandas/core/nanops.py
index 2592492f1c14c..f17569d114389 100644
--- a/pandas/core/nanops.py
+++ b/pandas/core/nanops.py
@@ -411,7 +411,11 @@ def new_func(
if datetimelike:
result = _wrap_results(result, orig_values.dtype, fill_value=iNaT)
if not skipna:
- result = _mask_datetimelike_result(result, axis, mask, orig_values)
+ # error: Argument 3 to "_mask_datetimelike_result" has incompatible type
+ # "Optional[ndarray]"; expected "ndarray"
+ result = _mask_datetimelike_result(
+ result, axis, mask, orig_values # type: ignore[arg-type]
+ )
return result
@@ -486,7 +490,9 @@ def nanany(
False
"""
values, _, _, _, _ = _get_values(values, skipna, fill_value=False, mask=mask)
- return values.any(axis)
+ # error: Incompatible return value type (got "Union[bool_, ndarray]", expected
+ # "bool")
+ return values.any(axis) # type: ignore[return-value]
def nanall(
@@ -524,7 +530,9 @@ def nanall(
False
"""
values, _, _, _, _ = _get_values(values, skipna, fill_value=True, mask=mask)
- return values.all(axis)
+ # error: Incompatible return value type (got "Union[bool_, ndarray]", expected
+ # "bool")
+ return values.all(axis) # type: ignore[return-value]
@disallow("M8")
@@ -567,12 +575,22 @@ def nansum(
if is_float_dtype(dtype):
dtype_sum = dtype
elif is_timedelta64_dtype(dtype):
- dtype_sum = np.float64
+ # error: Incompatible types in assignment (expression has type
+ # "Type[float64]", variable has type "dtype")
+ dtype_sum = np.float64 # type: ignore[assignment]
the_sum = values.sum(axis, dtype=dtype_sum)
- the_sum = _maybe_null_out(the_sum, axis, mask, values.shape, min_count=min_count)
+ # error: Incompatible types in assignment (expression has type "float", variable has
+ # type "Union[number, ndarray]")
+ # error: Argument 1 to "_maybe_null_out" has incompatible type "Union[number,
+ # ndarray]"; expected "ndarray"
+ the_sum = _maybe_null_out( # type: ignore[assignment]
+ the_sum, axis, mask, values.shape, min_count=min_count # type: ignore[arg-type]
+ )
- return the_sum
+ # error: Incompatible return value type (got "Union[number, ndarray]", expected
+ # "float")
+ return the_sum # type: ignore[return-value]
def _mask_datetimelike_result(
@@ -634,12 +652,18 @@ def nanmean(
# not using needs_i8_conversion because that includes period
if dtype.kind in ["m", "M"]:
- dtype_sum = np.float64
+ # error: Incompatible types in assignment (expression has type "Type[float64]",
+ # variable has type "dtype[Any]")
+ dtype_sum = np.float64 # type: ignore[assignment]
elif is_integer_dtype(dtype):
- dtype_sum = np.float64
+ # error: Incompatible types in assignment (expression has type "Type[float64]",
+ # variable has type "dtype[Any]")
+ dtype_sum = np.float64 # type: ignore[assignment]
elif is_float_dtype(dtype):
dtype_sum = dtype
- dtype_count = dtype
+ # error: Incompatible types in assignment (expression has type "dtype[Any]",
+ # variable has type "Type[float64]")
+ dtype_count = dtype # type: ignore[assignment]
count = _get_counts(values.shape, mask, axis, dtype=dtype_count)
the_sum = _ensure_numeric(values.sum(axis, dtype=dtype_sum))
@@ -791,7 +815,9 @@ def _get_counts_nanvar(
"""
dtype = get_dtype(dtype)
count = _get_counts(value_counts, mask, axis, dtype=dtype)
- d = count - dtype.type(ddof)
+ # error: Unsupported operand types for - ("int" and "generic")
+ # error: Unsupported operand types for - ("float" and "generic")
+ d = count - dtype.type(ddof) # type: ignore[operator]
# always return NaN, never inf
if is_scalar(count):
@@ -799,11 +825,16 @@ def _get_counts_nanvar(
count = np.nan
d = np.nan
else:
- mask2: np.ndarray = count <= ddof
+ # error: Incompatible types in assignment (expression has type
+ # "Union[bool, Any]", variable has type "ndarray")
+ mask2: np.ndarray = count <= ddof # type: ignore[assignment]
if mask2.any():
np.putmask(d, mask2, np.nan)
np.putmask(count, mask2, np.nan)
- return count, d
+ # error: Incompatible return value type (got "Tuple[Union[int, float,
+ # ndarray], Any]", expected "Tuple[Union[int, ndarray], Union[int,
+ # ndarray]]")
+ return count, d # type: ignore[return-value]
@bottleneck_switch(ddof=1)
@@ -958,7 +989,11 @@ def nansem(
if not is_float_dtype(values.dtype):
values = values.astype("f8")
- count, _ = _get_counts_nanvar(values.shape, mask, axis, ddof, values.dtype)
+ # 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]
+ )
var = nanvar(values, axis=axis, skipna=skipna, ddof=ddof)
return np.sqrt(var) / np.sqrt(count)
@@ -1038,7 +1073,8 @@ def nanargmax(
array([2, 2, 1, 1], dtype=int64)
"""
values, mask, _, _, _ = _get_values(values, True, fill_value_typ="-inf", mask=mask)
- result = values.argmax(axis)
+ # error: Need type annotation for 'result'
+ result = values.argmax(axis) # type: ignore[var-annotated]
result = _maybe_arg_null_out(result, axis, mask, skipna)
return result
@@ -1083,7 +1119,8 @@ def nanargmin(
array([0, 0, 1, 1], dtype=int64)
"""
values, mask, _, _, _ = _get_values(values, True, fill_value_typ="+inf", mask=mask)
- result = values.argmin(axis)
+ # error: Need type annotation for 'result'
+ result = values.argmin(axis) # type: ignore[var-annotated]
result = _maybe_arg_null_out(result, axis, mask, skipna)
return result
@@ -1304,7 +1341,13 @@ def nanprod(
values = values.copy()
values[mask] = 1
result = values.prod(axis)
- return _maybe_null_out(result, axis, mask, values.shape, min_count=min_count)
+ # error: Argument 1 to "_maybe_null_out" has incompatible type "Union[number,
+ # ndarray]"; expected "ndarray"
+ # error: Incompatible return value type (got "Union[ndarray, float]", expected
+ # "float")
+ return _maybe_null_out( # type: ignore[return-value]
+ result, axis, mask, values.shape, min_count=min_count # type: ignore[arg-type]
+ )
def _maybe_arg_null_out(
@@ -1317,10 +1360,14 @@ def _maybe_arg_null_out(
if axis is None or not getattr(result, "ndim", False):
if skipna:
if mask.all():
- result = -1
+ # error: Incompatible types in assignment (expression has type
+ # "int", variable has type "ndarray")
+ result = -1 # type: ignore[assignment]
else:
if mask.any():
- result = -1
+ # error: Incompatible types in assignment (expression has type
+ # "int", variable has type "ndarray")
+ result = -1 # type: ignore[assignment]
else:
if skipna:
na_mask = mask.all(axis)
@@ -1361,7 +1408,9 @@ def _get_counts(
n = mask.size - mask.sum()
else:
n = np.prod(values_shape)
- return dtype.type(n)
+ # error: Incompatible return value type (got "Union[Any, generic]",
+ # expected "Union[int, float, ndarray]")
+ return dtype.type(n) # type: ignore[return-value]
if mask is not None:
count = mask.shape[axis] - mask.sum(axis)
@@ -1369,11 +1418,23 @@ def _get_counts(
count = values_shape[axis]
if is_scalar(count):
- return dtype.type(count)
+ # error: Incompatible return value type (got "Union[Any, generic]",
+ # expected "Union[int, float, ndarray]")
+ return dtype.type(count) # type: ignore[return-value]
try:
- return count.astype(dtype)
+ # error: Incompatible return value type (got "Union[ndarray, generic]", expected
+ # "Union[int, float, ndarray]")
+ # error: Argument 1 to "astype" of "_ArrayOrScalarCommon" has incompatible type
+ # "Union[ExtensionDtype, dtype]"; expected "Union[dtype, None, type,
+ # _SupportsDtype, str, Tuple[Any, int], Tuple[Any, Union[int, Sequence[int]]],
+ # List[Any], _DtypeDict, Tuple[Any, Any]]"
+ return count.astype(dtype) # type: ignore[return-value,arg-type]
except AttributeError:
- return np.array(count, dtype=dtype)
+ # error: Argument "dtype" to "array" has incompatible type
+ # "Union[ExtensionDtype, dtype]"; expected "Union[dtype, None, type,
+ # _SupportsDtype, str, Tuple[Any, int], Tuple[Any, Union[int,
+ # Sequence[int]]], List[Any], _DtypeDict, Tuple[Any, Any]]"
+ return np.array(count, dtype=dtype) # type: ignore[arg-type]
def _maybe_null_out(
@@ -1403,7 +1464,9 @@ def _maybe_null_out(
result[null_mask] = None
elif result is not NaT:
if check_below_min_count(shape, mask, min_count):
- result = np.nan
+ # error: Incompatible types in assignment (expression has type
+ # "float", variable has type "ndarray")
+ result = np.nan # type: ignore[assignment]
return result
diff --git a/pandas/core/ops/array_ops.py b/pandas/core/ops/array_ops.py
index 10807dffb026b..9153eb25032e7 100644
--- a/pandas/core/ops/array_ops.py
+++ b/pandas/core/ops/array_ops.py
@@ -88,7 +88,11 @@ def _masked_arith_op(x: np.ndarray, y, op):
assert isinstance(x, np.ndarray), type(x)
if isinstance(y, np.ndarray):
dtype = find_common_type([x.dtype, y.dtype])
- result = np.empty(x.size, dtype=dtype)
+ # error: Argument "dtype" to "empty" has incompatible type
+ # "Union[dtype, ExtensionDtype]"; expected "Union[dtype, None, type,
+ # _SupportsDtype, str, Tuple[Any, int], Tuple[Any, Union[int,
+ # Sequence[int]]], List[Any], _DtypeDict, Tuple[Any, Any]]"
+ result = np.empty(x.size, dtype=dtype) # type: ignore[arg-type]
if len(x) != len(y):
raise ValueError(x.shape, y.shape)
diff --git a/pandas/core/ops/mask_ops.py b/pandas/core/ops/mask_ops.py
index 501bc0159e641..968833cd1ae44 100644
--- a/pandas/core/ops/mask_ops.py
+++ b/pandas/core/ops/mask_ops.py
@@ -109,7 +109,9 @@ def kleene_xor(
if right is libmissing.NA:
result = np.zeros_like(left)
else:
- result = left ^ right
+ # error: Incompatible types in assignment (expression has type
+ # "Union[bool, Any]", variable has type "ndarray")
+ result = left ^ right # type: ignore[assignment]
if right_mask is None:
if right is libmissing.NA:
diff --git a/pandas/core/reshape/melt.py b/pandas/core/reshape/melt.py
index 80a44e8fda39b..09249eba9c3f5 100644
--- a/pandas/core/reshape/melt.py
+++ b/pandas/core/reshape/melt.py
@@ -143,10 +143,17 @@ def melt(
mcolumns = id_vars + var_name + [value_name]
- mdata[value_name] = frame._values.ravel("F")
+ # error: Incompatible types in assignment (expression has type "ndarray",
+ # target has type "Series")
+ mdata[value_name] = frame._values.ravel("F") # type: ignore[assignment]
for i, col in enumerate(var_name):
# asanyarray will keep the columns as an Index
- mdata[col] = np.asanyarray(frame.columns._get_level_values(i)).repeat(N)
+
+ # error: Incompatible types in assignment (expression has type "ndarray", target
+ # has type "Series")
+ mdata[col] = np.asanyarray( # type: ignore[assignment]
+ frame.columns._get_level_values(i)
+ ).repeat(N)
result = frame._constructor(mdata, columns=mcolumns)
diff --git a/pandas/core/reshape/merge.py b/pandas/core/reshape/merge.py
index 9291dcf552786..a048217d6b1f0 100644
--- a/pandas/core/reshape/merge.py
+++ b/pandas/core/reshape/merge.py
@@ -2064,8 +2064,13 @@ def _factorize_keys(
if is_datetime64tz_dtype(lk.dtype) and is_datetime64tz_dtype(rk.dtype):
# Extract the ndarray (UTC-localized) values
# Note: we dont need the dtypes to match, as these can still be compared
- lk = cast("DatetimeArray", lk)._ndarray
- rk = cast("DatetimeArray", rk)._ndarray
+
+ # error: Incompatible types in assignment (expression has type "ndarray",
+ # variable has type "ExtensionArray")
+ lk = cast("DatetimeArray", lk)._ndarray # type: ignore[assignment]
+ # error: Incompatible types in assignment (expression has type "ndarray",
+ # variable has type "ExtensionArray")
+ rk = cast("DatetimeArray", rk)._ndarray # type: ignore[assignment]
elif (
is_categorical_dtype(lk.dtype)
@@ -2075,14 +2080,27 @@ def _factorize_keys(
assert isinstance(lk, Categorical)
assert isinstance(rk, Categorical)
# Cast rk to encoding so we can compare codes with lk
- rk = lk._encode_with_my_categories(rk)
- lk = ensure_int64(lk.codes)
- rk = ensure_int64(rk.codes)
+ # error: <nothing> has no attribute "_encode_with_my_categories"
+ rk = lk._encode_with_my_categories(rk) # type: ignore[attr-defined]
+
+ # error: <nothing> has no attribute "codes"
+ lk = ensure_int64(lk.codes) # type: ignore[attr-defined]
+ # error: "ndarray" has no attribute "codes"
+ rk = ensure_int64(rk.codes) # type: ignore[attr-defined]
elif is_extension_array_dtype(lk.dtype) and is_dtype_equal(lk.dtype, rk.dtype):
- lk, _ = lk._values_for_factorize()
- rk, _ = rk._values_for_factorize()
+ # error: Incompatible types in assignment (expression has type "ndarray",
+ # variable has type "ExtensionArray")
+ # error: Item "ndarray" of "Union[Any, ndarray]" has no attribute
+ # "_values_for_factorize"
+ lk, _ = lk._values_for_factorize() # type: ignore[union-attr,assignment]
+
+ # error: Incompatible types in assignment (expression has type
+ # "ndarray", variable has type "ExtensionArray")
+ # error: Item "ndarray" of "Union[Any, ndarray]" has no attribute
+ # "_values_for_factorize"
+ rk, _ = rk._values_for_factorize() # type: ignore[union-attr,assignment]
if is_integer_dtype(lk.dtype) and is_integer_dtype(rk.dtype):
# GH#23917 TODO: needs tests for case where lk is integer-dtype
diff --git a/pandas/core/reshape/pivot.py b/pandas/core/reshape/pivot.py
index d0026d7acbe65..0c0b37791f883 100644
--- a/pandas/core/reshape/pivot.py
+++ b/pandas/core/reshape/pivot.py
@@ -486,7 +486,11 @@ def pivot(
cols = []
append = index is None
- indexed = data.set_index(cols + columns, append=append)
+ # error: Unsupported operand types for + ("List[Any]" and "ExtensionArray")
+ # error: Unsupported left operand type for + ("ExtensionArray")
+ indexed = data.set_index(
+ cols + columns, append=append # type: ignore[operator]
+ )
else:
if index is None:
index = [Series(data.index, name=data.index.name)]
diff --git a/pandas/core/reshape/reshape.py b/pandas/core/reshape/reshape.py
index f0a2ef0cb1869..13119b9997002 100644
--- a/pandas/core/reshape/reshape.py
+++ b/pandas/core/reshape/reshape.py
@@ -169,7 +169,9 @@ def _make_selectors(self):
self.full_shape = ngroups, stride
selector = self.sorted_labels[-1] + stride * comp_index + self.lift
- mask = np.zeros(np.prod(self.full_shape), dtype=bool)
+ # error: Argument 1 to "zeros" has incompatible type "number"; expected
+ # "Union[int, Sequence[int]]"
+ mask = np.zeros(np.prod(self.full_shape), dtype=bool) # type: ignore[arg-type]
mask.put(selector, True)
if mask.sum() < len(self.index):
@@ -952,7 +954,9 @@ def _get_dummies_1d(
if dtype is None:
dtype = np.uint8
- dtype = np.dtype(dtype)
+ # error: Argument 1 to "dtype" has incompatible type "Union[ExtensionDtype, str,
+ # dtype[Any], Type[object]]"; expected "Type[Any]"
+ dtype = np.dtype(dtype) # type: ignore[arg-type]
if is_object_dtype(dtype):
raise ValueError("dtype=object is not a valid dtype for get_dummies")
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 468c3baca92c3..b92ada9537bd4 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -353,7 +353,9 @@ def __init__(
copy = False
elif isinstance(data, np.ndarray):
- if len(data.dtype):
+ # error: Argument 1 to "len" has incompatible type "dtype"; expected
+ # "Sized"
+ if len(data.dtype): # type: ignore[arg-type]
# GH#13296 we are dealing with a compound dtype, which
# should be treated as 2D
raise ValueError(
@@ -402,7 +404,12 @@ def __init__(
elif copy:
data = data.copy()
else:
- data = sanitize_array(data, index, dtype, copy)
+ # error: Argument 3 to "sanitize_array" has incompatible type
+ # "Union[ExtensionDtype, str, dtype[Any], Type[object], None]"; expected
+ # "Union[dtype[Any], ExtensionDtype, None]"
+ data = sanitize_array(
+ data, index, dtype, copy # type: ignore[arg-type]
+ )
manager = get_option("mode.data_manager")
if manager == "block":
@@ -453,7 +460,10 @@ def _init_dict(self, data, index=None, dtype: Optional[Dtype] = None):
# Input is now list-like, so rely on "standard" construction:
# TODO: passing np.float64 to not break anything yet. See GH-17261
- s = create_series_with_explicit_dtype(
+
+ # error: Value of type variable "ArrayLike" of
+ # "create_series_with_explicit_dtype" cannot be "Tuple[Any, ...]"
+ s = create_series_with_explicit_dtype( # type: ignore[type-var]
values, index=keys, dtype=dtype, dtype_if_empty=np.float64
)
@@ -1053,7 +1063,9 @@ def __setitem__(self, key, value):
def _set_with_engine(self, key, value):
# fails with AttributeError for IntervalIndex
loc = self.index._engine.get_loc(key)
- validate_numeric_casting(self.dtype, value)
+ # error: Argument 1 to "validate_numeric_casting" has incompatible type
+ # "Union[dtype, ExtensionDtype]"; expected "dtype"
+ validate_numeric_casting(self.dtype, value) # type: ignore[arg-type]
self._values[loc] = value
def _set_with(self, key, value):
@@ -2005,7 +2017,9 @@ def drop_duplicates(self, keep="first", inplace=False) -> Optional[Series]:
else:
return result
- def duplicated(self, keep="first") -> Series:
+ # error: Return type "Series" of "duplicated" incompatible with return type
+ # "ndarray" in supertype "IndexOpsMixin"
+ def duplicated(self, keep="first") -> Series: # type: ignore[override]
"""
Indicate duplicate Series values.
@@ -2988,7 +3002,12 @@ def combine(self, other, func, fill_value=None) -> Series:
# TODO: can we do this for only SparseDtype?
# The function can return something of any type, so check
# if the type is compatible with the calling EA.
- new_values = maybe_cast_to_extension_array(type(self._values), new_values)
+
+ # error: Value of type variable "ArrayLike" of
+ # "maybe_cast_to_extension_array" cannot be "List[Any]"
+ new_values = maybe_cast_to_extension_array(
+ type(self._values), new_values # type: ignore[type-var]
+ )
return self._constructor(new_values, index=new_index, name=new_name)
def combine_first(self, other) -> Series:
diff --git a/pandas/core/sorting.py b/pandas/core/sorting.py
index 973fed2c1436f..ba81866602361 100644
--- a/pandas/core/sorting.py
+++ b/pandas/core/sorting.py
@@ -43,6 +43,7 @@
_INT64_MAX = np.iinfo(np.int64).max
+# error: Function "numpy.array" is not valid as a type
def get_indexer_indexer(
target: Index,
level: Union[str, int, List[str], List[int]],
@@ -51,7 +52,7 @@ def get_indexer_indexer(
na_position: str,
sort_remaining: bool,
key: IndexKeyFunc,
-) -> Optional[np.array]:
+) -> Optional[np.array]: # type: ignore[valid-type]
"""
Helper method that return the indexer according to input parameters for
the sort_index method of DataFrame and Series.
@@ -584,11 +585,16 @@ def get_group_index_sorter(
df.groupby(key)[col].transform('first')
"""
if ngroups is None:
- ngroups = 1 + group_index.max()
+ # error: Incompatible types in assignment (expression has type "number[Any]",
+ # variable has type "Optional[int]")
+ ngroups = 1 + group_index.max() # type: ignore[assignment]
count = len(group_index)
alpha = 0.0 # taking complexities literally; there may be
beta = 1.0 # some room for fine-tuning these parameters
- do_groupsort = count > 0 and ((alpha + beta * ngroups) < (count * np.log(count)))
+ # error: Unsupported operand types for * ("float" and "None")
+ do_groupsort = count > 0 and (
+ (alpha + beta * ngroups) < (count * np.log(count)) # type: ignore[operator]
+ )
if do_groupsort:
sorter, _ = algos.groupsort_indexer(ensure_int64(group_index), ngroups)
return ensure_platform_int(sorter)
diff --git a/pandas/core/strings/accessor.py b/pandas/core/strings/accessor.py
index 32a99c0a020b2..3508624e51a9d 100644
--- a/pandas/core/strings/accessor.py
+++ b/pandas/core/strings/accessor.py
@@ -604,15 +604,27 @@ def cat(self, others=None, sep=None, na_rep=None, join="left"):
if isinstance(self._orig, ABCIndex):
# add dtype for case that result is all-NA
- result = Index(result, dtype=object, name=self._orig.name)
+
+ # error: Incompatible types in assignment (expression has type
+ # "Index", variable has type "ndarray")
+ result = Index( # type: ignore[assignment]
+ result, dtype=object, name=self._orig.name
+ )
else: # Series
if is_categorical_dtype(self._orig.dtype):
# We need to infer the new categories.
dtype = None
else:
dtype = self._orig.dtype
- result = Series(result, dtype=dtype, index=data.index, name=self._orig.name)
- result = result.__finalize__(self._orig, method="str_cat")
+ # error: Incompatible types in assignment (expression has type
+ # "Series", variable has type "ndarray")
+ result = Series( # type: ignore[assignment]
+ result, dtype=dtype, index=data.index, name=self._orig.name
+ )
+ # error: "ndarray" has no attribute "__finalize__"
+ result = result.__finalize__( # type: ignore[attr-defined]
+ self._orig, method="str_cat"
+ )
return result
_shared_docs[
@@ -3030,10 +3042,16 @@ def _str_extract_noexpand(arr, pat, flags=0):
names = dict(zip(regex.groupindex.values(), regex.groupindex.keys()))
columns = [names.get(1 + i, i) for i in range(regex.groups)]
if arr.size == 0:
- result = DataFrame(columns=columns, dtype=object)
+ # error: Incompatible types in assignment (expression has type
+ # "DataFrame", variable has type "ndarray")
+ result = DataFrame( # type: ignore[assignment]
+ columns=columns, dtype=object
+ )
else:
dtype = _result_dtype(arr)
- result = DataFrame(
+ # error: Incompatible types in assignment (expression has type
+ # "DataFrame", variable has type "ndarray")
+ result = DataFrame( # type:ignore[assignment]
[groups_or_na(val) for val in arr],
columns=columns,
index=arr.index,
diff --git a/pandas/core/strings/object_array.py b/pandas/core/strings/object_array.py
index 0a4543057c386..edf32bade0657 100644
--- a/pandas/core/strings/object_array.py
+++ b/pandas/core/strings/object_array.py
@@ -63,10 +63,14 @@ def _str_map(self, f, na_value=None, dtype: Optional[Dtype] = None):
na_value = self._str_na_value
if not len(arr):
- return np.ndarray(0, dtype=dtype)
+ # error: Argument 1 to "ndarray" has incompatible type "int";
+ # expected "Sequence[int]"
+ return np.ndarray(0, dtype=dtype) # type: ignore[arg-type]
if not isinstance(arr, np.ndarray):
- arr = np.asarray(arr, dtype=object)
+ # error: Incompatible types in assignment (expression has type "ndarray",
+ # variable has type "ObjectStringArrayMixin")
+ arr = np.asarray(arr, dtype=object) # type: ignore[assignment]
mask = isna(arr)
convert = not np.all(mask)
try:
diff --git a/pandas/core/tools/datetimes.py b/pandas/core/tools/datetimes.py
index d58b5e5ffa83d..f7bb3083b91a9 100644
--- a/pandas/core/tools/datetimes.py
+++ b/pandas/core/tools/datetimes.py
@@ -245,7 +245,9 @@ def _convert_and_box_cache(
from pandas import Series
result = Series(arg).map(cache_array)
- return _box_as_indexlike(result, utc=None, name=name)
+ # error: Value of type variable "ArrayLike" of "_box_as_indexlike" cannot
+ # be "Series"
+ return _box_as_indexlike(result, utc=None, name=name) # type: ignore[type-var]
def _return_parsed_timezone_results(result: np.ndarray, timezones, tz, name) -> Index:
@@ -362,7 +364,9 @@ def _convert_listlike_datetimes(
result = np.array(["NaT"], dtype="datetime64[ns]").repeat(len(arg))
return DatetimeIndex(result, name=name)
elif errors == "ignore":
- result = Index(arg, name=name)
+ # error: Incompatible types in assignment (expression has type
+ # "Index", variable has type "ExtensionArray")
+ result = Index(arg, name=name) # type: ignore[assignment]
return result
raise
@@ -382,10 +386,14 @@ def _convert_listlike_datetimes(
require_iso8601 = not infer_datetime_format
format = None
- result = None
+ # error: Incompatible types in assignment (expression has type "None", variable has
+ # type "ExtensionArray")
+ result = None # type: ignore[assignment]
if format is not None:
- result = _to_datetime_with_format(
+ # error: Incompatible types in assignment (expression has type
+ # "Optional[Index]", variable has type "ndarray")
+ result = _to_datetime_with_format( # type: ignore[assignment]
arg, orig_arg, name, tz, format, exact, errors, infer_datetime_format
)
if result is not None:
@@ -494,7 +502,9 @@ def _to_datetime_with_format(
# fallback
if result is None:
- result = _array_strptime_with_fallback(
+ # error: Incompatible types in assignment (expression has type
+ # "Optional[Index]", variable has type "Optional[ndarray]")
+ result = _array_strptime_with_fallback( # type: ignore[assignment]
arg, name, tz, fmt, exact, errors, infer_datetime_format
)
if result is not None:
@@ -510,7 +520,9 @@ def _to_datetime_with_format(
except (ValueError, TypeError):
raise e
- return result
+ # error: Incompatible return value type (got "Optional[ndarray]", expected
+ # "Optional[Index]")
+ return result # type: ignore[return-value]
def _to_datetime_with_unit(arg, unit, name, tz, errors: Optional[str]) -> Index:
@@ -529,12 +541,18 @@ def _to_datetime_with_unit(arg, unit, name, tz, errors: Optional[str]) -> Index:
if errors == "ignore":
# Index constructor _may_ infer to DatetimeIndex
- result = Index(result, name=name)
+
+ # error: Incompatible types in assignment (expression has type "Index", variable
+ # has type "ExtensionArray")
+ result = Index(result, name=name) # type: ignore[assignment]
else:
- result = DatetimeIndex(result, name=name)
+ # error: Incompatible types in assignment (expression has type "DatetimeIndex",
+ # variable has type "ExtensionArray")
+ result = DatetimeIndex(result, name=name) # type: ignore[assignment]
if not isinstance(result, DatetimeIndex):
- return result
+ # error: Incompatible return value type (got "ExtensionArray", expected "Index")
+ return result # type: ignore[return-value]
# GH#23758: We may still need to localize the result with tz
# GH#25546: Apply tz_parsed first (from arg), then tz (from caller)
@@ -1063,7 +1081,9 @@ def calc_with_mask(carg, mask):
# string with NaN-like
try:
- mask = ~algorithms.isin(arg, list(nat_strings))
+ # error: Value of type variable "AnyArrayLike" of "isin" cannot be
+ # "Iterable[Any]"
+ mask = ~algorithms.isin(arg, list(nat_strings)) # type: ignore[type-var]
return calc_with_mask(arg, mask)
except (ValueError, OverflowError, TypeError):
pass
diff --git a/pandas/core/tools/numeric.py b/pandas/core/tools/numeric.py
index 1032edcb22b46..31ab78e59a556 100644
--- a/pandas/core/tools/numeric.py
+++ b/pandas/core/tools/numeric.py
@@ -168,7 +168,9 @@ def to_numeric(arg, errors="raise", downcast=None):
mask = values._mask
values = values._data[~mask]
else:
- mask = None
+ # error: Incompatible types in assignment (expression has type "None", variable
+ # has type "ndarray")
+ mask = None # type: ignore[assignment]
values_dtype = getattr(values, "dtype", None)
if is_numeric_dtype(values_dtype):
diff --git a/pandas/core/tools/timedeltas.py b/pandas/core/tools/timedeltas.py
index a335146265523..a8378e91f9375 100644
--- a/pandas/core/tools/timedeltas.py
+++ b/pandas/core/tools/timedeltas.py
@@ -181,5 +181,7 @@ def _convert_listlike(arg, unit=None, errors="raise", name=None):
from pandas import TimedeltaIndex
- value = TimedeltaIndex(value, unit="ns", name=name)
+ # error: Incompatible types in assignment (expression has type "TimedeltaIndex",
+ # variable has type "ndarray")
+ value = TimedeltaIndex(value, unit="ns", name=name) # type: ignore[assignment]
return value
diff --git a/pandas/core/util/hashing.py b/pandas/core/util/hashing.py
index 9d488bb13b0f1..7d314d6a6fa1a 100644
--- a/pandas/core/util/hashing.py
+++ b/pandas/core/util/hashing.py
@@ -116,10 +116,14 @@ def hash_pandas_object(
return Series(hash_tuples(obj, encoding, hash_key), dtype="uint64", copy=False)
elif isinstance(obj, ABCIndex):
- h = hash_array(obj._values, encoding, hash_key, categorize).astype(
- "uint64", copy=False
- )
- h = Series(h, index=obj, dtype="uint64", copy=False)
+ # error: Value of type variable "ArrayLike" of "hash_array" cannot be
+ # "Union[ExtensionArray, ndarray]"
+ h = hash_array( # type: ignore[type-var]
+ obj._values, encoding, hash_key, categorize
+ ).astype("uint64", copy=False)
+ # error: Incompatible types in assignment (expression has type "Series",
+ # variable has type "ndarray")
+ h = Series(h, index=obj, dtype="uint64", copy=False) # type: ignore[assignment]
elif isinstance(obj, ABCSeries):
h = hash_array(obj._values, encoding, hash_key, categorize).astype(
@@ -139,7 +143,11 @@ def hash_pandas_object(
arrays = itertools.chain([h], index_iter)
h = combine_hash_arrays(arrays, 2)
- h = Series(h, index=obj.index, dtype="uint64", copy=False)
+ # error: Incompatible types in assignment (expression has type "Series",
+ # variable has type "ndarray")
+ h = Series( # type: ignore[assignment]
+ h, index=obj.index, dtype="uint64", copy=False
+ )
elif isinstance(obj, ABCDataFrame):
hashes = (hash_array(series._values) for _, series in obj.items())
@@ -162,10 +170,15 @@ def hash_pandas_object(
hashes = (x for x in _hashes)
h = combine_hash_arrays(hashes, num_items)
- h = Series(h, index=obj.index, dtype="uint64", copy=False)
+ # error: Incompatible types in assignment (expression has type "Series",
+ # variable has type "ndarray")
+ h = Series( # type: ignore[assignment]
+ h, index=obj.index, dtype="uint64", copy=False
+ )
else:
raise TypeError(f"Unexpected type for hashing {type(obj)}")
- return h
+ # error: Incompatible return value type (got "ndarray", expected "Series")
+ return h # type: ignore[return-value]
def hash_tuples(
@@ -284,12 +297,21 @@ def hash_array(
# hash values. (This check is above the complex check so that we don't ask
# numpy if categorical is a subdtype of complex, as it will choke).
if is_categorical_dtype(dtype):
- vals = cast("Categorical", vals)
- return _hash_categorical(vals, encoding, hash_key)
+ # error: Incompatible types in assignment (expression has type "Categorical",
+ # variable has type "ndarray")
+ vals = cast("Categorical", vals) # type: ignore[assignment]
+ # error: Argument 1 to "_hash_categorical" has incompatible type "ndarray";
+ # expected "Categorical"
+ return _hash_categorical(vals, encoding, hash_key) # type: ignore[arg-type]
elif is_extension_array_dtype(dtype):
- vals, _ = vals._values_for_factorize()
-
- return _hash_ndarray(vals, encoding, hash_key, categorize)
+ # error: Incompatible types in assignment (expression has type "ndarray",
+ # variable has type "ExtensionArray")
+ # error: "ndarray" has no attribute "_values_for_factorize"
+ vals, _ = vals._values_for_factorize() # type: ignore[assignment,attr-defined]
+
+ # error: Argument 1 to "_hash_ndarray" has incompatible type "ExtensionArray";
+ # expected "ndarray"
+ return _hash_ndarray(vals, encoding, hash_key, categorize) # type: ignore[arg-type]
def _hash_ndarray(
diff --git a/pandas/core/window/ewm.py b/pandas/core/window/ewm.py
index 4537e525c5086..4c9222e0805f1 100644
--- a/pandas/core/window/ewm.py
+++ b/pandas/core/window/ewm.py
@@ -261,7 +261,9 @@ def __init__(
self.times = self._selected_obj[self.times]
if not is_datetime64_ns_dtype(self.times):
raise ValueError("times must be datetime64[ns] dtype.")
- if len(self.times) != len(obj):
+ # error: Argument 1 to "len" has incompatible type "Union[str, ndarray,
+ # FrameOrSeries, None]"; expected "Sized"
+ if len(self.times) != len(obj): # type: ignore[arg-type]
raise ValueError("times must be the same length as the object.")
if not isinstance(self.halflife, (str, datetime.timedelta)):
raise ValueError(
@@ -269,7 +271,13 @@ def __init__(
)
if isna(self.times).any():
raise ValueError("Cannot convert NaT values to integer")
- _times = np.asarray(self.times.view(np.int64), dtype=np.float64)
+ # error: Item "str" of "Union[str, ndarray, FrameOrSeries, None]" has no
+ # attribute "view"
+ # error: Item "None" of "Union[str, ndarray, FrameOrSeries, None]" has no
+ # attribute "view"
+ _times = np.asarray(
+ self.times.view(np.int64), dtype=np.float64 # type: ignore[union-attr]
+ )
_halflife = float(Timedelta(self.halflife).value)
self._deltas = np.diff(_times) / _halflife
# Halflife is no longer applicable when calculating COM
@@ -289,7 +297,13 @@ def __init__(
# Without times, points are equally spaced
self._deltas = np.ones(max(len(self.obj) - 1, 0), dtype=np.float64)
self._com = get_center_of_mass(
- self.com, self.span, self.halflife, self.alpha
+ # error: Argument 3 to "get_center_of_mass" has incompatible type
+ # "Union[float, Any, None, timedelta64, signedinteger[_64Bit]]";
+ # expected "Optional[float]"
+ self.com,
+ self.span,
+ self.halflife, # type: ignore[arg-type]
+ self.alpha,
)
def _get_window_indexer(self) -> BaseIndexer:
diff --git a/pandas/core/window/rolling.py b/pandas/core/window/rolling.py
index 503849bf673d5..17d05e81b82bb 100644
--- a/pandas/core/window/rolling.py
+++ b/pandas/core/window/rolling.py
@@ -316,11 +316,17 @@ def _prep_values(self, values: ArrayLike) -> np.ndarray:
raise TypeError(f"cannot handle this type -> {values.dtype}") from err
# Convert inf to nan for C funcs
- inf = np.isinf(values)
+
+ # error: Argument 1 to "__call__" of "ufunc" has incompatible type
+ # "Optional[ndarray]"; expected "Union[bool, int, float, complex,
+ # _SupportsArray, Sequence[Any]]"
+ inf = np.isinf(values) # type: ignore[arg-type]
if inf.any():
values = np.where(inf, np.nan, values)
- return values
+ # error: Incompatible return value type (got "Optional[ndarray]",
+ # expected "ndarray")
+ return values # type: ignore[return-value]
def _insert_on_column(self, result: DataFrame, obj: DataFrame):
# if we have an 'on' column we want to put it back into
@@ -418,7 +424,11 @@ def hfunc(bvalues: ArrayLike) -> ArrayLike:
return getattr(res_values, "T", res_values)
def hfunc2d(values: ArrayLike) -> ArrayLike:
- values = self._prep_values(values)
+ # error: Incompatible types in assignment (expression has type "ndarray",
+ # variable has type "ExtensionArray")
+ # error: Argument 1 to "_prep_values" of "BaseWindow" has incompatible type
+ # "ExtensionArray"; expected "Optional[ndarray]"
+ values = self._prep_values(values) # type: ignore[assignment,arg-type]
return homogeneous_func(values)
if isinstance(mgr, ArrayManager) and self.axis == 1:
diff --git a/pandas/io/formats/format.py b/pandas/io/formats/format.py
index ab8e19d9f8a6f..f54481f527d93 100644
--- a/pandas/io/formats/format.py
+++ b/pandas/io/formats/format.py
@@ -1565,7 +1565,10 @@ def _format_strings(self) -> List[str]:
if is_categorical_dtype(values.dtype):
# Categorical is special for now, so that we can preserve tzinfo
- array = values._internal_get_values()
+
+ # error: Item "ExtensionArray" of "Union[Any, ExtensionArray]" has no
+ # attribute "_internal_get_values"
+ array = values._internal_get_values() # type: ignore[union-attr]
else:
array = np.asarray(values)
@@ -1632,10 +1635,25 @@ def format_percentiles(
raise ValueError("percentiles should all be in the interval [0,1]")
percentiles = 100 * percentiles
- int_idx = np.isclose(percentiles.astype(int), percentiles)
+
+ # error: Item "List[Union[int, float]]" of "Union[ndarray, List[Union[int, float]],
+ # List[float], List[Union[str, float]]]" has no attribute "astype"
+ # error: Item "List[float]" of "Union[ndarray, List[Union[int, float]], List[float],
+ # List[Union[str, float]]]" has no attribute "astype"
+ # error: Item "List[Union[str, float]]" of "Union[ndarray, List[Union[int, float]],
+ # List[float], List[Union[str, float]]]" has no attribute "astype"
+ int_idx = np.isclose(
+ percentiles.astype(int), percentiles # type: ignore[union-attr]
+ )
if np.all(int_idx):
- out = percentiles.astype(int).astype(str)
+ # error: Item "List[Union[int, float]]" of "Union[ndarray, List[Union[int,
+ # float]], List[float], List[Union[str, float]]]" has no attribute "astype"
+ # error: Item "List[float]" of "Union[ndarray, List[Union[int, float]],
+ # List[float], List[Union[str, float]]]" has no attribute "astype"
+ # error: Item "List[Union[str, float]]" of "Union[ndarray, List[Union[int,
+ # float]], List[float], List[Union[str, float]]]" has no attribute "astype"
+ out = percentiles.astype(int).astype(str) # type: ignore[union-attr]
return [i + "%" for i in out]
unique_pcts = np.unique(percentiles)
@@ -1648,8 +1666,19 @@ def format_percentiles(
).astype(int)
prec = max(1, prec)
out = np.empty_like(percentiles, dtype=object)
- out[int_idx] = percentiles[int_idx].astype(int).astype(str)
- out[~int_idx] = percentiles[~int_idx].round(prec).astype(str)
+ # error: No overload variant of "__getitem__" of "list" matches argument type
+ # "Union[bool_, ndarray]"
+ out[int_idx] = (
+ percentiles[int_idx].astype(int).astype(str) # type: ignore[call-overload]
+ )
+
+ # error: Item "float" of "Union[Any, float, str]" has no attribute "round"
+ # error: Item "str" of "Union[Any, float, str]" has no attribute "round"
+ # error: Invalid index type "Union[bool_, Any]" for "Union[ndarray, List[Union[int,
+ # float]], List[float], List[Union[str, float]]]"; expected type "int"
+ out[~int_idx] = (
+ percentiles[~int_idx].round(prec).astype(str) # type: ignore[union-attr,index]
+ )
return [i + "%" for i in out]
@@ -1772,7 +1801,11 @@ def get_format_timedelta64(
one_day_nanos = 86400 * 10 ** 9
even_days = (
- np.logical_and(consider_values, values_int % one_day_nanos != 0).sum() == 0
+ # error: Unsupported operand types for % ("ExtensionArray" and "int")
+ np.logical_and(
+ consider_values, values_int % one_day_nanos != 0 # type: ignore[operator]
+ ).sum()
+ == 0
)
if even_days:
diff --git a/pandas/io/formats/string.py b/pandas/io/formats/string.py
index 622001f280885..84333cfc441b2 100644
--- a/pandas/io/formats/string.py
+++ b/pandas/io/formats/string.py
@@ -117,7 +117,13 @@ def _join_multiline(self, strcols_input: Iterable[List[str]]) -> str:
if self.fmt.index:
idx = strcols.pop(0)
- lwidth -= np.array([self.adj.len(x) for x in idx]).max() + adjoin_width
+ # error: Argument 1 to "__call__" of "_NumberOp" has incompatible type
+ # "None"; expected "Union[int, float, complex, number, bool_]"
+ # error: Incompatible types in assignment (expression has type "number",
+ # variable has type "Optional[int]")
+ lwidth -= ( # type: ignore[assignment,arg-type]
+ np.array([self.adj.len(x) for x in idx]).max() + adjoin_width
+ )
col_widths = [
np.array([self.adj.len(x) for x in col]).max() if len(col) > 0 else 0
@@ -125,7 +131,9 @@ def _join_multiline(self, strcols_input: Iterable[List[str]]) -> str:
]
assert lwidth is not None
- col_bins = _binify(col_widths, lwidth)
+ # error: Argument 1 to "_binify" has incompatible type "List[object]"; expected
+ # "List[int]"
+ col_bins = _binify(col_widths, lwidth) # type: ignore[arg-type]
nbins = len(col_bins)
if self.fmt.is_truncated_vertically:
diff --git a/pandas/io/formats/style.py b/pandas/io/formats/style.py
index ec09a4cc4cd89..cc5f3164385cb 100644
--- a/pandas/io/formats/style.py
+++ b/pandas/io/formats/style.py
@@ -1708,7 +1708,11 @@ def f(data: DataFrame, props: str) -> np.ndarray:
if props is None:
props = f"background-color: {null_color};"
- return self.apply(f, axis=None, subset=subset, props=props)
+ # error: Argument 1 to "apply" of "Styler" has incompatible type
+ # "Callable[[DataFrame, str], ndarray]"; expected "Callable[..., Styler]"
+ return self.apply(
+ f, axis=None, subset=subset, props=props # type: ignore[arg-type]
+ )
def highlight_max(
self,
@@ -1751,7 +1755,11 @@ def f(data: FrameOrSeries, props: str) -> np.ndarray:
if props is None:
props = f"background-color: {color};"
- return self.apply(f, axis=axis, subset=subset, props=props)
+ # error: Argument 1 to "apply" of "Styler" has incompatible type
+ # "Callable[[FrameOrSeries, str], ndarray]"; expected "Callable[..., Styler]"
+ return self.apply(
+ f, axis=axis, subset=subset, props=props # type: ignore[arg-type]
+ )
def highlight_min(
self,
@@ -1794,7 +1802,11 @@ def f(data: FrameOrSeries, props: str) -> np.ndarray:
if props is None:
props = f"background-color: {color};"
- return self.apply(f, axis=axis, subset=subset, props=props)
+ # error: Argument 1 to "apply" of "Styler" has incompatible type
+ # "Callable[[FrameOrSeries, str], ndarray]"; expected "Callable[..., Styler]"
+ return self.apply(
+ f, axis=axis, subset=subset, props=props # type: ignore[arg-type]
+ )
@classmethod
def from_custom_template(cls, searchpath, name):
diff --git a/pandas/io/json/_json.py b/pandas/io/json/_json.py
index aa654e971641f..7c83beca1ae71 100644
--- a/pandas/io/json/_json.py
+++ b/pandas/io/json/_json.py
@@ -570,7 +570,12 @@ def read_json(
raise ValueError("cannot pass both convert_axes and orient='table'")
if dtype is None and orient != "table":
- dtype = True
+ # error: Incompatible types in assignment (expression has type "bool", variable
+ # has type "Union[ExtensionDtype, str, dtype[Any], Type[str], Type[float],
+ # Type[int], Type[complex], Type[bool], Type[object], Dict[Optional[Hashable],
+ # Union[ExtensionDtype, Union[str, dtype[Any]], Type[str], Type[float],
+ # Type[int], Type[complex], Type[bool], Type[object]]], None]")
+ dtype = True # type: ignore[assignment]
if convert_axes is None and orient != "table":
convert_axes = True
@@ -914,7 +919,12 @@ def _try_convert_data(self, name, data, use_dtypes=True, convert_dates=True):
return data, False
return data.fillna(np.nan), True
- elif self.dtype is True:
+ # error: Non-overlapping identity check (left operand type:
+ # "Union[ExtensionDtype, str, dtype[Any], Type[object],
+ # Dict[Optional[Hashable], Union[ExtensionDtype, Union[str, dtype[Any]],
+ # Type[str], Type[float], Type[int], Type[complex], Type[bool],
+ # Type[object]]]]", right operand type: "Literal[True]")
+ elif self.dtype is True: # type: ignore[comparison-overlap]
pass
else:
# dtype to force
@@ -923,7 +933,10 @@ def _try_convert_data(self, name, data, use_dtypes=True, convert_dates=True):
)
if dtype is not None:
try:
- dtype = np.dtype(dtype)
+ # error: Argument 1 to "dtype" has incompatible type
+ # "Union[ExtensionDtype, str, dtype[Any], Type[object]]";
+ # expected "Type[Any]"
+ dtype = np.dtype(dtype) # type: ignore[arg-type]
return data.astype(dtype), True
except (TypeError, ValueError):
return data, False
diff --git a/pandas/io/parsers/base_parser.py b/pandas/io/parsers/base_parser.py
index c05efe9e73c5a..4539ceabbb92f 100644
--- a/pandas/io/parsers/base_parser.py
+++ b/pandas/io/parsers/base_parser.py
@@ -658,7 +658,9 @@ def _infer_types(self, values, na_values, try_num_bool=True):
na_count = 0
if issubclass(values.dtype.type, (np.number, np.bool_)):
mask = algorithms.isin(values, list(na_values))
- na_count = mask.sum()
+ # error: Incompatible types in assignment (expression has type
+ # "number[Any]", variable has type "int")
+ na_count = mask.sum() # type: ignore[assignment]
if na_count > 0:
if is_integer_dtype(values):
values = values.astype(np.float64)
@@ -716,7 +718,10 @@ def _cast_types(self, values, cast_type, column):
# TODO: this is for consistency with
# c-parser which parses all categories
# as strings
- values = astype_nansafe(values, str)
+
+ # error: Argument 2 to "astype_nansafe" has incompatible type
+ # "Type[str]"; expected "Union[dtype[Any], ExtensionDtype]"
+ values = astype_nansafe(values, str) # type: ignore[arg-type]
cats = Index(values).unique().dropna()
values = Categorical._from_inferred_categories(
@@ -909,7 +914,20 @@ def _get_empty_meta(
if not is_dict_like(dtype):
# if dtype == None, default will be object.
default_dtype = dtype or object
- dtype = defaultdict(lambda: default_dtype)
+ # error: Argument 1 to "defaultdict" has incompatible type "Callable[[],
+ # Union[ExtensionDtype, str, dtype[Any], Type[object], Dict[Hashable,
+ # Union[ExtensionDtype, Union[str, dtype[Any]], Type[str], Type[float],
+ # Type[int], Type[complex], Type[bool], Type[object]]]]]"; expected
+ # "Optional[Callable[[], Union[ExtensionDtype, str, dtype[Any],
+ # Type[object]]]]"
+ # error: Incompatible return value type (got "Union[ExtensionDtype, str,
+ # dtype[Any], Type[object], Dict[Hashable, Union[ExtensionDtype, Union[str,
+ # dtype[Any]], Type[str], Type[float], Type[int], Type[complex], Type[bool],
+ # Type[object]]]]", expected "Union[ExtensionDtype, str, dtype[Any],
+ # Type[object]]")
+ dtype = defaultdict(
+ lambda: default_dtype # type: ignore[arg-type, return-value]
+ )
else:
dtype = cast(dict, dtype)
dtype = defaultdict(
diff --git a/pandas/io/pytables.py b/pandas/io/pytables.py
index ceb4900b887f1..24bd2da6cc12e 100644
--- a/pandas/io/pytables.py
+++ b/pandas/io/pytables.py
@@ -2092,7 +2092,9 @@ def convert(self, values: np.ndarray, nan_rep, encoding: str, errors: str):
kwargs["freq"] = None
new_pd_index = factory(values, **kwargs)
- new_pd_index = _set_tz(new_pd_index, self.tz)
+ # error: Incompatible types in assignment (expression has type
+ # "Union[ndarray, DatetimeIndex]", variable has type "Index")
+ new_pd_index = _set_tz(new_pd_index, self.tz) # type: ignore[assignment]
return new_pd_index, new_pd_index
def take_data(self):
@@ -2254,7 +2256,9 @@ def convert(self, values: np.ndarray, nan_rep, encoding: str, errors: str):
"""
assert isinstance(values, np.ndarray), type(values)
- values = Int64Index(np.arange(len(values)))
+ # error: Incompatible types in assignment (expression has type
+ # "Int64Index", variable has type "ndarray")
+ values = Int64Index(np.arange(len(values))) # type: ignore[assignment]
return values, values
def set_attr(self):
@@ -3087,10 +3091,17 @@ def write_array(self, key: str, obj: FrameOrSeries, items: Optional[Index] = Non
elif is_datetime64tz_dtype(value.dtype):
# store as UTC
# with a zone
- self._handle.create_array(self.group, key, value.asi8)
+
+ # error: Item "ExtensionArray" of "Union[Any, ExtensionArray]" has no
+ # attribute "asi8"
+ self._handle.create_array(
+ self.group, key, value.asi8 # type: ignore[union-attr]
+ )
node = getattr(self.group, key)
- node._v_attrs.tz = _get_tz(value.tz)
+ # error: Item "ExtensionArray" of "Union[Any, ExtensionArray]" has no
+ # attribute "tz"
+ node._v_attrs.tz = _get_tz(value.tz) # type: ignore[union-attr]
node._v_attrs.value_type = "datetime64"
elif is_timedelta64_dtype(value.dtype):
self._handle.create_array(self.group, key, value.view("i8"))
@@ -3376,7 +3387,10 @@ def validate_multiindex(
@property
def nrows_expected(self) -> int:
""" based on our axes, compute the expected nrows """
- return np.prod([i.cvalues.shape[0] for i in self.index_axes])
+ # error: Incompatible return value type (got "number", expected "int")
+ return np.prod( # type: ignore[return-value]
+ [i.cvalues.shape[0] for i in self.index_axes]
+ )
@property
def is_exists(self) -> bool:
@@ -3462,8 +3476,12 @@ def write_metadata(self, key: str, values: np.ndarray):
key : str
values : ndarray
"""
- values = Series(values)
- self.parent.put(
+ # error: Incompatible types in assignment (expression has type
+ # "Series", variable has type "ndarray")
+ values = Series(values) # type: ignore[assignment]
+ # error: Value of type variable "FrameOrSeries" of "put" of "HDFStore"
+ # cannot be "ndarray"
+ self.parent.put( # type: ignore[type-var]
self._get_metadata_path(key),
values,
format="table",
@@ -4818,14 +4836,18 @@ def _set_tz(
elif coerce:
values = np.asarray(values, dtype="M8[ns]")
- return values
+ # error: Incompatible return value type (got "Union[ndarray, Index]",
+ # expected "Union[ndarray, DatetimeIndex]")
+ return values # type: ignore[return-value]
def _convert_index(name: str, index: Index, encoding: str, errors: str) -> IndexCol:
assert isinstance(name, str)
index_name = index.name
- converted, dtype_name = _get_data_and_dtype_name(index)
+ # error: Value of type variable "ArrayLike" of "_get_data_and_dtype_name"
+ # cannot be "Index"
+ converted, dtype_name = _get_data_and_dtype_name(index) # type: ignore[type-var]
kind = _dtype_to_kind(dtype_name)
atom = DataIndexableCol._get_atom(converted)
@@ -4966,7 +4988,12 @@ def _maybe_convert_for_string_atom(
)
# itemsize is the maximum length of a string (along any dimension)
- data_converted = _convert_string_array(data, encoding, errors).reshape(data.shape)
+
+ # error: Argument 1 to "_convert_string_array" has incompatible type "Union[ndarray,
+ # ExtensionArray]"; expected "ndarray"
+ data_converted = _convert_string_array(
+ data, encoding, errors # type: ignore[arg-type]
+ ).reshape(data.shape)
itemsize = data_converted.itemsize
# specified min_itemsize?
@@ -5142,20 +5169,26 @@ def _get_data_and_dtype_name(data: ArrayLike):
Convert the passed data into a storable form and a dtype string.
"""
if isinstance(data, Categorical):
- data = data.codes
+ # error: Incompatible types in assignment (expression has type
+ # "ndarray", variable has type "ExtensionArray")
+ data = data.codes # type: ignore[assignment]
# For datetime64tz we need to drop the TZ in tests TODO: why?
dtype_name = data.dtype.name.split("[")[0]
if data.dtype.kind in ["m", "M"]:
- data = np.asarray(data.view("i8"))
+ # error: Incompatible types in assignment (expression has type "ndarray",
+ # variable has type "ExtensionArray")
+ data = np.asarray(data.view("i8")) # type: ignore[assignment]
# TODO: we used to reshape for the dt64tz case, but no longer
# doing that doesn't seem to break anything. why?
elif isinstance(data, PeriodIndex):
data = data.asi8
- data = np.asarray(data)
+ # error: Incompatible types in assignment (expression has type "ndarray", variable
+ # has type "ExtensionArray")
+ data = np.asarray(data) # type: ignore[assignment]
return data, dtype_name
diff --git a/pandas/io/sql.py b/pandas/io/sql.py
index c028e1f5c5dbe..fb08abb6fea45 100644
--- a/pandas/io/sql.py
+++ b/pandas/io/sql.py
@@ -898,7 +898,9 @@ def insert_data(self):
mask = isna(d)
d[mask] = None
- data_list[i] = d
+ # error: No overload variant of "__setitem__" of "list" matches
+ # argument types "int", "ndarray"
+ data_list[i] = d # type: ignore[call-overload]
return column_names, data_list
@@ -1545,7 +1547,13 @@ def to_sql(
"""
if dtype:
if not is_dict_like(dtype):
- dtype = {col_name: dtype for col_name in frame}
+ # error: Value expression in dictionary comprehension has incompatible
+ # type "Union[ExtensionDtype, str, dtype[Any], Type[object],
+ # Dict[Optional[Hashable], Union[ExtensionDtype, Union[str, dtype[Any]],
+ # Type[str], Type[float], Type[int], Type[complex], Type[bool],
+ # Type[object]]]]"; expected type "Union[ExtensionDtype, str,
+ # dtype[Any], Type[object]]"
+ dtype = {col_name: dtype for col_name in frame} # type: ignore[misc]
else:
dtype = cast(dict, dtype)
@@ -2022,7 +2030,13 @@ def to_sql(
"""
if dtype:
if not is_dict_like(dtype):
- dtype = {col_name: dtype for col_name in frame}
+ # error: Value expression in dictionary comprehension has incompatible
+ # type "Union[ExtensionDtype, str, dtype[Any], Type[object],
+ # Dict[Optional[Hashable], Union[ExtensionDtype, Union[str, dtype[Any]],
+ # Type[str], Type[float], Type[int], Type[complex], Type[bool],
+ # Type[object]]]]"; expected type "Union[ExtensionDtype, str,
+ # dtype[Any], Type[object]]"
+ dtype = {col_name: dtype for col_name in frame} # type: ignore[misc]
else:
dtype = cast(dict, dtype)
diff --git a/pandas/io/stata.py b/pandas/io/stata.py
index ebc0395aec0b2..c01a369bf0054 100644
--- a/pandas/io/stata.py
+++ b/pandas/io/stata.py
@@ -1233,7 +1233,9 @@ def g(typ: int) -> Union[str, np.dtype]:
if typ <= 2045:
return str(typ)
try:
- return self.DTYPE_MAP_XML[typ]
+ # error: Incompatible return value type (got "Type[number]", expected
+ # "Union[str, dtype]")
+ return self.DTYPE_MAP_XML[typ] # type: ignore[return-value]
except KeyError as err:
raise ValueError(f"cannot convert stata dtype [{typ}]") from err
@@ -1666,7 +1668,12 @@ def read(
if self.dtyplist[i] is not None:
col = data.columns[i]
dtype = data[col].dtype
- if dtype != np.dtype(object) and dtype != self.dtyplist[i]:
+ # error: Value of type variable "_DTypeScalar" of "dtype" cannot be
+ # "object"
+ if (
+ dtype != np.dtype(object) # type: ignore[type-var]
+ and dtype != self.dtyplist[i]
+ ):
requires_type_conversion = True
data_formatted.append(
(col, Series(data[col], ix, self.dtyplist[i]))
diff --git a/pandas/tests/io/parser/common/test_chunksize.py b/pandas/tests/io/parser/common/test_chunksize.py
index 4bc3f3c38f506..6d5aeaa713687 100644
--- a/pandas/tests/io/parser/common/test_chunksize.py
+++ b/pandas/tests/io/parser/common/test_chunksize.py
@@ -143,7 +143,10 @@ def test_read_chunksize_jagged_names(all_parsers):
parser = all_parsers
data = "\n".join(["0"] * 7 + [",".join(["0"] * 10)])
- expected = DataFrame([[0] + [np.nan] * 9] * 7 + [[0] * 10])
+ # error: List item 0 has incompatible type "float"; expected "int"
+ expected = DataFrame(
+ [[0] + [np.nan] * 9] * 7 + [[0] * 10] # type: ignore[list-item]
+ )
with parser.read_csv(StringIO(data), names=range(10), chunksize=4) as reader:
result = concat(reader)
tm.assert_frame_equal(result, expected)
diff --git a/pandas/tseries/frequencies.py b/pandas/tseries/frequencies.py
index 048d138608ef9..c5b875b8f027e 100644
--- a/pandas/tseries/frequencies.py
+++ b/pandas/tseries/frequencies.py
@@ -385,7 +385,8 @@ def _is_business_daily(self) -> bool:
shifts = np.diff(self.index.asi8)
shifts = np.floor_divide(shifts, _ONE_DAY)
weekdays = np.mod(first_weekday + np.cumsum(shifts), 7)
- return np.all(
+ # error: Incompatible return value type (got "bool_", expected "bool")
+ return np.all( # type: ignore[return-value]
((weekdays == 0) & (shifts == 3))
| ((weekdays > 0) & (weekdays <= 4) & (shifts == 1))
)
diff --git a/pandas/util/_test_decorators.py b/pandas/util/_test_decorators.py
index c39647522aaf1..752ed43849d2b 100644
--- a/pandas/util/_test_decorators.py
+++ b/pandas/util/_test_decorators.py
@@ -212,7 +212,9 @@ def skip_if_np_lt(ver_str: str, *args, reason: Optional[str] = None):
if reason is None:
reason = f"NumPy {ver_str} or greater required"
return pytest.mark.skipif(
- np.__version__ < LooseVersion(ver_str), *args, reason=reason
+ np.__version__ < LooseVersion(ver_str),
+ *args,
+ reason=reason,
)
diff --git a/requirements-dev.txt b/requirements-dev.txt
index 37adbbb8e671f..f60e3bf0daea7 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -1,7 +1,7 @@
# This file is auto-generated from environment.yml, do not modify.
# See that file for comments about the need/usage of each dependency.
-numpy>=1.16.5, <1.20
+numpy>=1.16.5
python-dateutil>=2.7.3
pytz
asv
diff --git a/setup.cfg b/setup.cfg
index fdc0fbdbd6b57..a0b6a0cdfc260 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -192,3 +192,42 @@ check_untyped_defs = False
[mypy-pandas.io.clipboard]
check_untyped_defs = False
+
+[mypy-pandas.io.formats.string]
+ignore_errors = True
+
+[mypy-pandas.tests.apply.test_series_apply]
+ignore_errors = True
+
+[mypy-pandas.tests.arithmetic.conftest]
+ignore_errors = True
+
+[mypy-pandas.tests.arrays.sparse.test_combine_concat]
+ignore_errors = True
+
+[mypy-pandas.tests.dtypes.test_common]
+ignore_errors = True
+
+[mypy-pandas.tests.frame.methods.test_to_records]
+ignore_errors = True
+
+[mypy-pandas.tests.groupby.test_rank]
+ignore_errors = True
+
+[mypy-pandas.tests.groupby.transform.test_transform]
+ignore_errors = True
+
+[mypy-pandas.tests.indexes.interval.test_interval]
+ignore_errors = True
+
+[mypy-pandas.tests.indexing.test_categorical]
+ignore_errors = True
+
+[mypy-pandas.tests.io.excel.test_writers]
+ignore_errors = True
+
+[mypy-pandas.tests.reductions.test_reductions]
+ignore_errors = True
+
+[mypy-pandas.tests.test_expressions]
+ignore_errors = True