CI: unpin numpy for CI / Checks github action

.github/workflows/ci.yml

@@ -136,3 +136,41 @@ jobs:
     - name: Upload dev docs
       run: rsync -az --delete doc/build/html/ docs@${{ secrets.server_ip }}:/usr/share/nginx/pandas/pandas-docs/dev
       if: github.event_name == 'push'
+
+  numpy-types:
+    name: Numpy Type Annotations
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    steps:
+    - name: Update for build environment
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y build-essential
+        sudo apt-get clean
+    - name: Setting conda path
+      run: echo ::add-path::$CONDA/bin
+    - name: Update conda
+      run: |
+        conda config --set quiet true --set always_yes true
+        conda update -n base -c defaults conda
+        conda list
+    - name: Checkout pandas
+      uses: actions/checkout@v2
+    - name: Update conda environment
+      run: |
+        conda env update -n pandas-dev --file=environment.yml
+        conda list
+    - name: Update numpy using wheel from nightly
+      run: |
+        source activate pandas-dev
+        pip install -U --extra-index-url https://pypi.anaconda.org/scipy-wheels-nightly/simple --pre numpy
+        conda list
+    - name: Remove pandas
+      run: |
+        source activate pandas-dev
+        conda uninstall -y --force pandas || true
+        conda list
+    - name: Typing validation
+      run: |
+        source activate pandas-dev
+        ci/code_checks.sh typing

pandas/_testing.py

@@ -15,6 +15,7 @@
 import zipfile
 
 import numpy as np
+
 from numpy.random import rand, randn
 
 from pandas._config.localization import (  # noqa:F401
@@ -103,9 +104,18 @@
     + STRING_DTYPES
     + DATETIME64_DTYPES
     + TIMEDELTA64_DTYPES
-    + BOOL_DTYPES
-    + OBJECT_DTYPES
-    + BYTES_DTYPES
+    # error: Unsupported operand types for + ("List[Union[ExtensionDtype, str,
+    # dtype, Type[str], Type[float], Type[int], Type[complex], Type[bool],
+    # Type[object]]]" and "List[object]")
+    + BOOL_DTYPES  # type: ignore[operator]
+    # error: Unsupported operand types for + ("List[Union[ExtensionDtype, str,
+    # dtype, Type[str], Type[float], Type[int], Type[complex], Type[bool],
+    # Type[object]]]" and "List[object]")
+    + OBJECT_DTYPES  # type: ignore[operator]
+    # error: Unsupported operand types for + ("List[Union[ExtensionDtype, str,
+    # dtype, Type[str], Type[float], Type[int], Type[complex], Type[bool],
+    # Type[object]]]" and "List[object]")
+    + BYTES_DTYPES  # type: ignore[operator]
 )
 
 

pandas/compat/numpy/__init__.py

@@ -6,7 +6,9 @@
 import numpy as np
 
 # numpy versioning
-_np_version = np.__version__
+# pandas\compat\numpy\__init__.py:9: error: Module has no attribute
+# "__version__"; maybe "version"?  [attr-defined]
+_np_version = np.__version__  # type: ignore[attr-defined]
 _nlv = LooseVersion(_np_version)
 np_version_under1p17 = _nlv < LooseVersion("1.17")
 np_version_under1p18 = _nlv < LooseVersion("1.18")
@@ -43,7 +45,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):

pandas/compat/numpy/function.py

@@ -18,7 +18,9 @@
 from distutils.version import LooseVersion
 from typing import Any, Dict, Optional, Union
 
-from numpy import __version__, ndarray
+# pandas\compat\numpy\function.py:23: error: Module 'numpy' has no attribute
+# '__version__'; maybe "version"?  [attr-defined]
+from numpy import __version__, ndarray  # type: ignore[attr-defined]
 
 from pandas._libs.lib import is_bool, is_integer
 from pandas.errors import UnsupportedFunctionCall

pandas/core/aggregation.py

@@ -183,7 +183,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(

pandas/core/algorithms.py

@@ -151,14 +151,20 @@ def _ensure_data(
                 # 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)
             dtype = values.dtype
 
-        return values.asi8, dtype
+        # error: Incompatible return value type (got "Tuple[Any, Union[dtype,
+        # ExtensionDtype, None]]", expected "Tuple[ndarray, Union[dtype,
+        # ExtensionDtype]]")
+        return values.asi8, dtype  # type: ignore[return-value]
 
     elif is_categorical_dtype(vals_dtype) and (
         is_categorical_dtype(dtype) or dtype is None
@@ -194,20 +200,37 @@ def _reconstruct_data(
     ExtensionArray or np.ndarray
     """
     if is_extension_array_dtype(dtype):
-        values = dtype.construct_array_type()._from_sequence(values)
+        # error: Item "dtype" of "Union[dtype, ExtensionDtype]" has no
+        # attribute "construct_array_type"
+        tmp = dtype.construct_array_type()  # type: ignore[union-attr]
+        values = tmp._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, ABCIndexClass):
             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
 
@@ -421,17 +444,60 @@ def isin(comps: AnyArrayLike, values: AnyArrayLike) -> np.ndarray:
         )
 
     if not isinstance(values, (ABCIndex, ABCSeries, ABCExtensionArray, np.ndarray)):
-        values = construct_1d_object_array_from_listlike(list(values))
+        # pandas\core\algorithms.py:424: error: Incompatible types in
+        # assignment (expression has type "ndarray", variable has type
+        # "ExtensionArray")  [assignment]
+
+        # pandas\core\algorithms.py:424: error: Incompatible types in
+        # assignment (expression has type "ndarray", variable has type "Index")
+        # [assignment]
+
+        # pandas\core\algorithms.py:424: error: Incompatible types in
+        # assignment (expression has type "ndarray", variable has type
+        # "Series")  [assignment]
+        values = construct_1d_object_array_from_listlike(  # type: ignore[assignment]
+            list(values)
+        )
         # TODO: could use ensure_arraylike here
 
-    comps = extract_array(comps, extract_numpy=True)
+    # pandas\core\algorithms.py:457: error: Incompatible types in assignment
+    # (expression has type "ExtensionArray", variable has type "Index")
+    # [assignment]
+
+    # pandas\core\algorithms.py:457: error: Incompatible types in assignment
+    # (expression has type "ExtensionArray", variable has type "Series")
+    # [assignment]
+
+    # pandas\core\algorithms.py:457: error: Incompatible types in assignment
+    # (expression has type "ExtensionArray", variable has type "ndarray")
+    # [assignment]
+    comps = extract_array(comps, extract_numpy=True)  # type: ignore[assignment]
     if is_categorical_dtype(comps):
         # TODO(extension)
         # handle categoricals
         return cast("Categorical", comps).isin(values)
 
-    comps, dtype = _ensure_data(comps)
-    values, _ = _ensure_data(values, dtype=dtype)
+    # pandas\core\algorithms.py:463: error: Incompatible types in assignment
+    # (expression has type "ndarray", variable has type "ExtensionArray")
+    # [assignment]
+
+    # pandas\core\algorithms.py:463: error: Incompatible types in assignment
+    # (expression has type "ndarray", variable has type "Index")  [assignment]
+
+    # pandas\core\algorithms.py:463: error: Incompatible types in assignment
+    # (expression has type "ndarray", variable has type "Series")  [assignment]
+    comps, dtype = _ensure_data(comps)  # type: ignore[assignment]
+
+    # pandas\core\algorithms.py:490: error: Incompatible types in assignment
+    # (expression has type "ndarray", variable has type "ExtensionArray")
+    # [assignment]
+
+    # pandas\core\algorithms.py:490: error: Incompatible types in assignment
+    # (expression has type "ndarray", variable has type "Index")  [assignment]
+
+    # pandas\core\algorithms.py:490: error: Incompatible types in assignment
+    # (expression has type "ndarray", variable has type "Series")  [assignment]
+    values, _ = _ensure_data(values, dtype=dtype)  # type: ignore[assignment]
 
     # faster for larger cases to use np.in1d
     f = htable.ismember_object
@@ -1114,7 +1180,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
 
 
@@ -1187,14 +1255,24 @@ def compute(self, method: str) -> Series:
         # fast method
         arr, pandas_dtype = _ensure_data(dropped.values)
         if method == "nlargest":
-            arr = -arr
+            # pandas\core\algorithms.py:1264: error: Incompatible types in
+            # assignment (expression has type "Union[ndarray, generic]",
+            # variable has type "ndarray")  [assignment]
+            arr = -arr  # type: ignore[assignment]
             if is_integer_dtype(pandas_dtype):
                 # GH 21426: ensure reverse ordering at boundaries
                 arr -= 1
 
             elif is_bool_dtype(pandas_dtype):
                 # GH 26154: ensure False is smaller than True
-                arr = 1 - (-arr)
+
+                # pandas\core\algorithms.py:1269: error: Incompatible types in
+                # assignment (expression has type "Union[ndarray, generic]",
+                # variable has type "ndarray")  [assignment]
+
+                # pandas\core\algorithms.py:1275: error: Unsupported operand
+                # types for - ("int" and "generic")  [operator]
+                arr = 1 - (-arr)  # type: ignore[assignment,operator]
 
         if self.keep == "last":
             arr = arr[::-1]
@@ -2136,7 +2214,9 @@ def _sort_mixed(values):
     return np.concatenate([nums, np.asarray(strs, dtype=object)])
 
 
-def _sort_tuples(values: np.ndarray[tuple]):
+# pandas\core\algorithms.py:2217: error: "ndarray" expects no type arguments,
+# but 1 given  [type-arg]
+def _sort_tuples(values: np.ndarray[tuple]):  # type: ignore[type-arg]
     """
     Convert array of tuples (1d) to array or array (2d).
     We need to keep the columns separately as they contain different types and

pandas/core/array_algos/replace.py

@@ -69,7 +69,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

pandas/core/arrays/_mixins.py

@@ -107,7 +107,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:
@@ -230,7 +231,8 @@ def fillna(self: _T, value=None, method=None, limit=None) -> _T:
                 )
             value = value[mask]
 
-        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._ndarray.copy(), limit=limit, mask=mask)

pandas/core/arrays/_ranges.py

@@ -105,7 +105,13 @@ def _generate_range_overflow_safe(
         # if periods * strides cannot be multiplied within the *uint64* bounds,
         #  we cannot salvage the operation by recursing, so raise
         try:
-            addend = np.uint64(periods) * np.uint64(np.abs(stride))
+            # pandas\core\arrays\_ranges.py:108: error: Argument 1 to
+            # "unsignedinteger" has incompatible type "Union[ndarray,
+            # generic]"; expected "Union[SupportsInt, Union[str, bytes],
+            # SupportsIndex]"  [arg-type]
+            addend = np.uint64(periods) * np.uint64(
+                np.abs(stride)  # type: ignore[arg-type]
+            )
         except FloatingPointError as err:
             raise OutOfBoundsDatetime(msg) from err
 
@@ -150,7 +156,9 @@ def _generate_range_overflow_safe_signed(
         addend = np.int64(periods) * np.int64(stride)
         try:
             # easy case with no overflows
-            return np.int64(endpoint) + addend
+            # pandas\core\arrays\_ranges.py:153: error: Incompatible return
+            # value type (got "signedinteger", expected "int")  [return-value]
+            return np.int64(endpoint) + addend  # type: ignore[return-value]
         except (FloatingPointError, OverflowError):
             # with endpoint negative and addend positive we risk
             #  FloatingPointError; with reversed signed we risk OverflowError
@@ -168,7 +176,10 @@ def _generate_range_overflow_safe_signed(
             i64max = np.uint64(np.iinfo(np.int64).max)
             assert result > i64max
             if result <= i64max + np.uint64(stride):
-                return result
+                # pandas\core\arrays\_ranges.py:171: error: Incompatible return
+                # value type (got "unsignedinteger", expected "int")
+                # [return-value]
+                return result  # type: ignore[return-value]
 
     raise OutOfBoundsDatetime(
         f"Cannot generate range with {side}={endpoint} and periods={periods}"