From c54bf3ac6c5e93b223f54ec377c907b77beaf0f6 Mon Sep 17 00:00:00 2001 From: Brock Date: Fri, 2 Apr 2021 11:37:00 -0700 Subject: [PATCH] TYP: libalgos.pyi --- pandas/_libs/algos.pyi | 293 ++++++++++++++++++++++++++ pandas/_libs/algos.pyx | 2 +- pandas/core/algorithms.py | 17 +- pandas/core/array_algos/transforms.py | 8 +- pandas/core/arrays/categorical.py | 8 +- pandas/core/dtypes/cast.py | 4 +- pandas/core/indexes/base.py | 3 +- pandas/core/indexes/multi.py | 4 +- pandas/core/reshape/merge.py | 6 +- pandas/core/sorting.py | 7 +- pandas/core/strings/accessor.py | 4 +- pandas/core/tools/datetimes.py | 2 +- pandas/core/window/indexers.py | 2 + pandas/core/window/rolling.py | 6 +- 14 files changed, 331 insertions(+), 35 deletions(-) create mode 100644 pandas/_libs/algos.pyi diff --git a/pandas/_libs/algos.pyi b/pandas/_libs/algos.pyi new file mode 100644 index 0000000000000..30a31d17fc947 --- /dev/null +++ b/pandas/_libs/algos.pyi @@ -0,0 +1,293 @@ +# Note: this covers algos.pyx and algos_common_helper but NOT algos_take_helper +from typing import Any + +import numpy as np + +class Infinity: + """ + Provide a positive Infinity comparison method for ranking. + """ + def __eq__(self, other) -> bool: ... + def __ne__(self, other) -> bool: ... + def __lt__(self, other) -> bool: ... + def __le__(self, other) -> bool: ... + def __gt__(self, other) -> bool: ... + def __ge__(self, other) -> bool: ... + + +class NegInfinity: + """ + Provide a negative Infinity comparison method for ranking. + """ + def __eq__(self, other) -> bool: ... + def __ne__(self, other) -> bool: ... + def __lt__(self, other) -> bool: ... + def __le__(self, other) -> bool: ... + def __gt__(self, other) -> bool: ... + def __ge__(self, other) -> bool: ... + + +def unique_deltas( + arr: np.ndarray, # const int64_t[:] +) -> np.ndarray: ... # np.ndarray[np.int64, ndim=1] + + +def is_lexsorted(list_of_arrays: list[np.ndarray]) -> bool: ... + + +def groupsort_indexer( + index: np.ndarray, # const int64_t[:] + ngroups: int, +) -> tuple[ + np.ndarray, # ndarray[int64_t, ndim=1] + np.ndarray, # ndarray[int64_t, ndim=1] +]: + ... + + +def kth_smallest( + a: np.ndarray, # numeric[:] + k: int, +) -> Any: ... # numeric + + +# ---------------------------------------------------------------------- +# Pairwise correlation/covariance + + + +def nancorr( + mat: np.ndarray, # const float64_t[:, :] + cov: bool = False, + minp=None, +) -> np.ndarray: # np.ndarray[float64_t, ndim=2] + ... + + +def nancorr_spearman( + mat: np.ndarray, # ndarray[float64_t, ndim=2] + minp: int = 1, +) -> np.ndarray: # np.ndarray[np.float64, ndim=2] + ... + + +def nancorr_kendall( + mat: np.ndarray, # ndarray[float64_t, ndim=2] + minp: int = 1, +) -> np.ndarray: # np.ndarray[float64, ndim=2] + ... + +# ---------------------------------------------------------------------- + +# ctypedef fused algos_t: +# float64_t +# float32_t +# object +# int64_t +# int32_t +# int16_t +# int8_t +# uint64_t +# uint32_t +# uint16_t +# uint8_t + + +def validate_limit(nobs: int | None, limit=None) -> int: ... + + +def pad( + old: np.ndarray, # ndarray[algos_t] + new: np.ndarray, # ndarray[algos_t] + limit=None, +) -> np.ndarray: ... # np.ndarray[np.intp, ndim=1] + + +def pad_inplace( + values: np.ndarray, # algos_t[:] + mask: np.ndarray, # uint8_t[:] + limit=None, +) -> None: ... + + +def pad_2d_inplace( + values: np.ndarray, # algos_t[:, :] + mask: np.ndarray, # const uint8_t[:, :] + limit=None, +) -> None: + ... + + +def backfill( + old: np.ndarray, # ndarray[algos_t] + new: np.ndarray, # ndarray[algos_t] + limit=None, +) -> np.ndarray: # np.ndarray[np.intp, ndim=1] + ... + +def backfill_inplace( + values: np.ndarray, # algos_t[:] + mask: np.ndarray, # uint8_t[:] + limit=None, +) -> None: ... + + +def backfill_2d_inplace( + values: np.ndarray, # algos_t[:, :] + mask: np.ndarray, # const uint8_t[:, :] + limit=None, +) -> None: ... + + +def is_monotonic( + arr: np.ndarray, # ndarray[algos_t, ndim=1] + timelike: bool +) -> tuple[bool, bool, bool]: + ... + +# ---------------------------------------------------------------------- +# rank_1d, rank_2d +# ---------------------------------------------------------------------- + +# ctypedef fused rank_t: +# object +# float64_t +# uint64_t +# int64_t + + +def rank_1d( + values: np.ndarray, # ndarray[rank_t, ndim=1] + labels: np.ndarray, # const int64_t[:] + is_datetimelike: bool = ..., + ties_method=..., + ascending: bool = ..., + pct: bool = ..., + na_option=..., +) -> np.ndarray: ... # np.ndarray[float64_t, ndim=1] + + +def rank_2d( + in_arr: np.ndarray, # ndarray[rank_t, ndim=2] + axis: int = ..., + is_datetimelike: bool = ..., + ties_method=..., + ascending: bool = ..., + na_option=..., + pct: bool = ..., +) -> np.ndarray: ... # np.ndarray[float64_t, ndim=1] + + +def diff_2d( + arr: np.ndarray, # ndarray[diff_t, ndim=2] + out: np.ndarray, # ndarray[out_t, ndim=2] + periods: int, + axis: int, + datetimelike: bool = ..., +) -> None: ... + + +def ensure_platform_int(arr: object) -> np.ndarray: ... + +def ensure_object(arr: object) -> np.ndarray: ... + +def ensure_float64(arr: object, copy=True) -> np.ndarray: ... + +def ensure_float32(arr: object, copy=True) -> np.ndarray: ... + +def ensure_int8(arr: object, copy=True) -> np.ndarray: ... + +def ensure_int16(arr: object, copy=True) -> np.ndarray: ... + +def ensure_int32(arr: object, copy=True) -> np.ndarray: ... + +def ensure_int64(arr: object, copy=True) -> np.ndarray: ... + +def ensure_uint8(arr: object, copy=True) -> np.ndarray: ... + +def ensure_uint16(arr: object, copy=True) -> np.ndarray: ... + +def ensure_uint32(arr: object, copy=True) -> np.ndarray: ... + +def ensure_uint64(arr: object, copy=True) -> np.ndarray: ... + + +def take_1d_int8_int8(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_1d_int8_int32(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_1d_int8_int64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_1d_int8_float64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_1d_int16_int16(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_1d_int16_int32(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_1d_int16_int64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_1d_int16_float64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_1d_int32_int32(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_1d_int32_int64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_1d_int32_float64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_1d_int64_int64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_1d_int64_float64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_1d_float32_float32(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_1d_float32_float64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_1d_float64_float64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_1d_object_object(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_1d_bool_bool(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_1d_bool_object(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... + +def take_2d_axis0_int8_int8(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis0_int8_int32(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis0_int8_int64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis0_int8_float64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis0_int16_int16(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis0_int16_int32(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis0_int16_int64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis0_int16_float64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis0_int32_int32(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis0_int32_int64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis0_int32_float64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis0_int64_int64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis0_int64_float64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis0_float32_float32(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis0_float32_float64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis0_float64_float64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis0_object_object(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis0_bool_bool(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis0_bool_object(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... + +def take_2d_axis1_int8_int8(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis1_int8_int32(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis1_int8_int64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis1_int8_float64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis1_int16_int16(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis1_int16_int32(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis1_int16_int64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis1_int16_float64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis1_int32_int32(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis1_int32_int64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis1_int32_float64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis1_int64_int64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis1_int64_float64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis1_float32_float32(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis1_float32_float64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis1_float64_float64(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis1_object_object(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis1_bool_bool(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_axis1_bool_object(values: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=...) -> None: ... + +def take_2d_multi_int8_int8(values: np.ndarray, indexer, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_multi_int8_int32(values: np.ndarray, indexer, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_multi_int8_int64(values: np.ndarray, indexer, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_multi_int8_float64(values: np.ndarray, indexer, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_multi_int16_int16(values: np.ndarray, indexer, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_multi_int16_int32(values: np.ndarray, indexer, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_multi_int16_int64(values: np.ndarray, indexer, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_multi_int16_float64(values: np.ndarray, indexer, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_multi_int32_int32(values: np.ndarray, indexer, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_multi_int32_int64(values: np.ndarray, indexer, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_multi_int32_float64(values: np.ndarray, indexer, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_multi_int64_float64(values: np.ndarray, indexer, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_multi_float32_float32(values: np.ndarray, indexer, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_multi_float32_float64(values: np.ndarray, indexer, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_multi_float64_float64(values: np.ndarray, indexer, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_multi_object_object(values: np.ndarray, indexer, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_multi_bool_bool(values: np.ndarray, indexer, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_multi_bool_object(values: np.ndarray, indexer, out: np.ndarray, fill_value=...) -> None: ... +def take_2d_multi_int64_int64(values: np.ndarray, indexer, out: np.ndarray, fill_value=...) -> None: ... diff --git a/pandas/_libs/algos.pyx b/pandas/_libs/algos.pyx index a28f4929995c6..6cc55648b9cf4 100644 --- a/pandas/_libs/algos.pyx +++ b/pandas/_libs/algos.pyx @@ -563,7 +563,7 @@ ctypedef fused algos_t: uint8_t -def validate_limit(nobs: int, limit=None) -> int: +def validate_limit(nobs: int | None, limit=None) -> int: """ Check that the `limit` argument is a positive integer. diff --git a/pandas/core/algorithms.py b/pandas/core/algorithms.py index 0c8a5bbc33c91..8f80088b4f3bc 100644 --- a/pandas/core/algorithms.py +++ b/pandas/core/algorithms.py @@ -158,10 +158,7 @@ def _ensure_data(values: ArrayLike) -> Tuple[np.ndarray, DtypeObj]: with catch_warnings(): simplefilter("ignore", np.ComplexWarning) values = ensure_float64(values) - # 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] + return values, np.dtype("float64") except (TypeError, ValueError, OverflowError): # if we are trying to coerce to a dtype @@ -205,11 +202,7 @@ def _ensure_data(values: ArrayLike) -> Tuple[np.ndarray, DtypeObj]: # we are actually coercing to int64 # until our algos support int* directly (not all do) values = ensure_int64(values) - - # 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] + return values, dtype # we have failed, return object values = np.asarray(values, dtype=object) @@ -303,7 +296,7 @@ def _get_hashtable_algo(values: np.ndarray): return htable, values -def _get_values_for_rank(values: ArrayLike): +def _get_values_for_rank(values: ArrayLike) -> np.ndarray: if is_categorical_dtype(values): values = cast("Categorical", values)._values_for_rank() @@ -314,9 +307,7 @@ def _get_values_for_rank(values: ArrayLike): def get_data_algo(values: ArrayLike): values = _get_values_for_rank(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] + ndtype = _check_object_for_strings(values) htable = _hashtables.get(ndtype, _hashtables["object"]) return htable, values diff --git a/pandas/core/array_algos/transforms.py b/pandas/core/array_algos/transforms.py index 1dde9b221a90b..27aebb9911e83 100644 --- a/pandas/core/array_algos/transforms.py +++ b/pandas/core/array_algos/transforms.py @@ -4,8 +4,6 @@ import numpy as np -from pandas.core.dtypes.common import ensure_platform_int - def shift(values: np.ndarray, periods: int, axis: int, fill_value) -> np.ndarray: new_values = values @@ -20,7 +18,11 @@ def shift(values: np.ndarray, periods: int, axis: int, fill_value) -> np.ndarray axis = new_values.ndim - axis - 1 if new_values.size: - new_values = np.roll(new_values, ensure_platform_int(periods), axis=axis) + new_values = np.roll( + new_values, + np.intp(periods), + axis=axis, + ) axis_indexer = [slice(None)] * values.ndim if periods > 0: diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py index 32c3095c3e6ee..bbff208790ca5 100644 --- a/pandas/core/arrays/categorical.py +++ b/pandas/core/arrays/categorical.py @@ -2580,10 +2580,14 @@ def _get_codes_for_values(values, categories: Index) -> np.ndarray: if not isinstance(values, cls): # exception raised in _from_sequence values = ensure_object(values) - categories = ensure_object(categories) + # error: Incompatible types in assignment (expression has type + # "ndarray", variable has type "Index") + categories = ensure_object(categories) # type: ignore[assignment] elif not dtype_equal: values = ensure_object(values) - categories = ensure_object(categories) + # error: Incompatible types in assignment (expression has type "ndarray", + # variable has type "Index") + categories = ensure_object(categories) # type: ignore[assignment] if isinstance(categories, ABCIndex): return coerce_indexer_dtype(categories.get_indexer_for(values), categories) diff --git a/pandas/core/dtypes/cast.py b/pandas/core/dtypes/cast.py index 3f3d9f9f2833b..9c0f6698af613 100644 --- a/pandas/core/dtypes/cast.py +++ b/pandas/core/dtypes/cast.py @@ -1235,9 +1235,7 @@ def astype_nansafe( from pandas import to_datetime return astype_nansafe( - # error: No overload variant of "to_datetime" matches argument type - # "ndarray" - to_datetime(arr).values, # type: ignore[call-overload] + to_datetime(arr).values, dtype, copy=copy, ) diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py index 5163c55036fd0..2e93023d77044 100644 --- a/pandas/core/indexes/base.py +++ b/pandas/core/indexes/base.py @@ -4224,8 +4224,7 @@ def _get_leaf_sorter(labels: List[np.ndarray]) -> np.ndarray: ) # missing values are placed first; drop them! - # error: Value of type "Optional[ndarray]" is not indexable - left_indexer = left_indexer[counts[0] :] # type: ignore[index] + left_indexer = left_indexer[counts[0] :] new_codes = [lab[left_indexer] for lab in new_codes] else: # sort the leaves diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py index 9751e12c373cd..f9217bf0d19b6 100644 --- a/pandas/core/indexes/multi.py +++ b/pandas/core/indexes/multi.py @@ -2188,7 +2188,9 @@ def argsort(self, *args, **kwargs) -> np.ndarray: @Appender(_index_shared_docs["repeat"] % _index_doc_kwargs) def repeat(self, repeats: int, axis=None) -> MultiIndex: nv.validate_repeat((), {"axis": axis}) - repeats = ensure_platform_int(repeats) + # error: Incompatible types in assignment (expression has type "ndarray", + # variable has type "int") + repeats = ensure_platform_int(repeats) # type: ignore[assignment] return MultiIndex( levels=self.levels, codes=[ diff --git a/pandas/core/reshape/merge.py b/pandas/core/reshape/merge.py index a9faf0098b6d4..800dc0295c824 100644 --- a/pandas/core/reshape/merge.py +++ b/pandas/core/reshape/merge.py @@ -1931,8 +1931,10 @@ def flip(xs) -> np.ndarray: # upcast 'by' parameter because HashTable is limited by_type = _get_cython_type_upcast(left_by_values.dtype) by_type_caster = _type_casters[by_type] - left_by_values = by_type_caster(left_by_values) - right_by_values = by_type_caster(right_by_values) + # error: Cannot call function of unknown type + left_by_values = by_type_caster(left_by_values) # type: ignore[operator] + # error: Cannot call function of unknown type + right_by_values = by_type_caster(right_by_values) # type: ignore[operator] # choose appropriate function by type func = _asof_by_function(self.direction) diff --git a/pandas/core/sorting.py b/pandas/core/sorting.py index 816c1d9195778..5e2669289fa63 100644 --- a/pandas/core/sorting.py +++ b/pandas/core/sorting.py @@ -623,7 +623,12 @@ def get_group_index_sorter( (alpha + beta * ngroups) < (count * np.log(count)) # type: ignore[operator] ) if do_groupsort: - sorter, _ = algos.groupsort_indexer(ensure_platform_int(group_index), ngroups) + # Argument 2 to "groupsort_indexer" has incompatible type + # "Optional[int]"; expected "int" + sorter, _ = algos.groupsort_indexer( + ensure_platform_int(group_index), + ngroups, # type: ignore[arg-type] + ) # sorter _should_ already be intp, but mypy is not yet able to verify else: sorter = group_index.argsort(kind="mergesort") diff --git a/pandas/core/strings/accessor.py b/pandas/core/strings/accessor.py index 14c77ec2fdf8f..85da954ec842e 100644 --- a/pandas/core/strings/accessor.py +++ b/pandas/core/strings/accessor.py @@ -548,7 +548,9 @@ def cat(self, others=None, sep=None, na_rep=None, join="left"): # concatenate Series/Index with itself if no "others" if others is None: - data = ensure_object(data) + # error: Incompatible types in assignment (expression has type + # "ndarray", variable has type "Series") + data = ensure_object(data) # type: ignore[assignment] na_mask = isna(data) if na_rep is None and na_mask.any(): data = data[~na_mask] diff --git a/pandas/core/tools/datetimes.py b/pandas/core/tools/datetimes.py index 7619623bb9eda..52f7892fc6957 100644 --- a/pandas/core/tools/datetimes.py +++ b/pandas/core/tools/datetimes.py @@ -674,7 +674,7 @@ def to_datetime( @overload def to_datetime( - arg: Union[List, Tuple], + arg: Union[List, Tuple, np.ndarray], errors: str = ..., dayfirst: bool = ..., yearfirst: bool = ..., diff --git a/pandas/core/window/indexers.py b/pandas/core/window/indexers.py index f8e2734b99e20..2cf68fc8995ee 100644 --- a/pandas/core/window/indexers.py +++ b/pandas/core/window/indexers.py @@ -320,6 +320,8 @@ def get_window_bounds( end_arrays = [] window_indicies_start = 0 for key, indices in self.groupby_indicies.items(): + index_array: np.ndarray | None + if self.index_array is not None: index_array = self.index_array.take(ensure_platform_int(indices)) else: diff --git a/pandas/core/window/rolling.py b/pandas/core/window/rolling.py index b90722857938e..2d1c518fc6fea 100644 --- a/pandas/core/window/rolling.py +++ b/pandas/core/window/rolling.py @@ -316,11 +316,7 @@ 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 - - # 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] + inf = np.isinf(values) if inf.any(): values = np.where(inf, np.nan, values)