Merge branch 'master' into release

Author: tmke8

.github/workflows/test_correctness.yml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [3.6, 3.8]
+        python-version: [3.6, 3.9]
 
     steps:
     - uses: actions/checkout@v1
@@ -22,7 +22,7 @@ jobs:
     - name: Install pytest and dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install pytest numpy pandas matplotlib
+        pip install pytest numpy pandas matplotlib kiwisolver>=1.3.1
     - name: Test with pytest
       run: |
         python -m pytest -vv tests/

matplotlib-stubs/artist.pyi

@@ -1,5 +1,6 @@
 class Artist:
     def set_label(self, s: str) -> None: ...
+    def remove(self) -> None: ...
 
 class Line2D(Artist): ...
 class Collection(Artist): ...

matplotlib-stubs/backend_bases.pyi

@@ -1,3 +1,8 @@
+from typing import Optional
+
 class Event: ...
 class LocationEvent(Event): ...
 class MouseEvent(LocationEvent): ...
+
+class KeyEvent(Event):
+    key: Optional[str]

matplotlib-stubs/pyplot.pyi.in

@@ -136,13 +136,14 @@ class Figure:
     ) -> None: ...
     def add_subplot(
         self,
-        nrows: int,
-        ncols: int,
-        index: int,
+        nrows: int = ...,
+        ncols: int = ...,
+        index: int = ...,
         polar: bool = ...,
         sharex: Axes = ...,
         sharey: Axes = ...,
         label: str = ...,
+        **kwargs: Any,
     ) -> SubplotBase: ...
     def legend(self, *args: Any, **kwargs: Any) -> Legend: ...
     def clf(self) -> None: ...
@@ -214,7 +215,7 @@ def subplots_adjust(
     wspace: Optional[float] = ...,
     hspace: Optional[float] = ...,
 ) -> None: ...
-def close(fig: Union[Figure, Literal["all"]]) -> None: ...
+def close(fig: Union[None, Figure, Literal["all"]] = ...) -> None: ...
 def clf() -> None: ...
 def plot(
     x: Data,

numpy-stubs/__init__.pyi

@@ -1,4 +1,5 @@
 """Public API of numpy"""
+import os
 from typing import (
     Any,
     Callable,
@@ -578,7 +579,7 @@ def linspace(
 def linspace(
     start: float, stop: float, *, dtype: Type[_DType], num: int = ..., endpoint: bool = ...
 ) -> ndarray[_DType]: ...
-def load(file: Union[Path, IO], encoding: str = ...) -> Dict[str, ndarray]: ...
+def load(file: Union[str, os.PathLike, IO], encoding: str = ...) -> Dict[str, ndarray]: ...
 def loadtxt(
     fname: Any,
     dtype: Type[_DType] = ...,
@@ -805,7 +806,10 @@ def ravel(a: ndarray[_DType]) -> ndarray[_DType]: ...
 def reshape(a: ndarray[_DType], newshape: _ShapeType) -> ndarray[_DType]: ...
 def round(a: ndarray[_DType], decimals: _IntLike = ...) -> ndarray[_DType]: ...
 def save(
-    file: Union[str, Path], arr: ndarray, allow_pickle: bool = ..., fix_imports: bool = ...
+    file: Union[str, os.PathLike, IO],
+    arr: ndarray,
+    allow_pickle: bool = ...,
+    fix_imports: bool = ...,
 ) -> None: ...
 @overload
 def searchsorted(a: ndarray[_DType], v: _DType, side: str = ...) -> int64: ...
@@ -928,6 +932,24 @@ class finfo(Generic[_Float]):
     @overload
     def __init__(self: finfo[float64], dtype: Union[float, Type[float]]): ...
 
+#
+# module functions
+#
+def set_printoptions(
+    precision: Any = ...,
+    threshold: Any = ...,
+    edgeitems: Any = ...,
+    linewidth: Any = ...,
+    suppress: Any = ...,
+    nanstr: Any = ...,
+    infstr: Any = ...,
+    formatter: Any = ...,
+    sign: Any = ...,
+    floatmode: Any = ...,
+    *,
+    legacy: Any = ...,
+) -> None: ...
+
 #
 # Specific values
 #

pandas-stubs/__init__.pyi

@@ -1,27 +1,38 @@
 """Pandas public API"""
+from pathlib import Path
 from typing import (
-    Tuple,
-    List,
-    Union,
     IO,
-    Optional,
     Any,
-    overload,
     Callable,
     Dict,
+    List,
+    Mapping,
+    Optional,
     Sequence,
+    Tuple,
     Type,
     TypeVar,
-    Mapping,
+    Union,
+    overload,
 )
-from typing_extensions import Literal
-from pathlib import Path
+
 import numpy as _np
+from typing_extensions import Literal
+
 from . import testing
-from .core.frame import DataFrame as DataFrame, _ListLike
-from .core.frame import _AxisType
+from .core.arrays.integer import Int8Dtype as Int8Dtype
+from .core.arrays.integer import Int16Dtype as Int16Dtype
+from .core.arrays.integer import Int32Dtype as Int32Dtype
+from .core.arrays.integer import Int64Dtype as Int64Dtype
+from .core.arrays.integer import UInt8Dtype as UInt8Dtype
+from .core.arrays.integer import UInt16Dtype as UInt16Dtype
+from .core.arrays.integer import UInt32Dtype as UInt32Dtype
+from .core.arrays.integer import UInt64Dtype as UInt64Dtype
+from .core.frame import DataFrame as DataFrame
+from .core.frame import _AxisType, _ListLike
+from .core.indexes import Index as Index
+from .core.indexes import MultiIndex as MultiIndex
 from .core.series import Series as Series
-from .core.indexes import Index as Index, MultiIndex as MultiIndex
 
 def concat(
     dataframes: Union[Sequence[DataFrame], Mapping[str, DataFrame]],

pandas-stubs/core/api.pyi

@@ -0,0 +1,10 @@
+from .arrays.integer import (
+    Int8Dtype,
+    Int16Dtype,
+    Int32Dtype,
+    Int64Dtype,
+    UInt8Dtype,
+    UInt16Dtype,
+    UInt32Dtype,
+    UInt64Dtype,
+)

pandas-stubs/core/arrays/__init__.pyi

@@ -0,0 +1 @@
+from .base import ExtensionArray, ExtensionOpsMixin

pandas-stubs/core/arrays/base.pyi

@@ -0,0 +1,25 @@
+from typing import Any, Callable, TypeVar
+
+import numpy as np
+
+# This is normally where ExtensionArray would be defined,
+# but we can't do conditional TYPE_CHECKING imports like pandas does.
+# So this will work for now.
+from ..dtypes.base import _ArrayLike
+from ..dtypes.base import _ExtensionArray as ExtensionArray
+
+class ExtensionOpsMixin:
+    @classmethod
+    def _create_arithmetic_method(
+        cls, op: Callable[..., Any]
+    ) -> Callable[[Any, Any], ExtensionArray]: ...
+    @classmethod
+    def _add_arithmetic_ops(cls) -> None: ...
+    @classmethod
+    def _create_comparison_method(cls, op: Callable[..., Any]) -> Callable[..., bool]: ...
+    @classmethod
+    def _add_comparison_ops(cls) -> None: ...
+    @classmethod
+    def _create_logical_method(cls, op: Callable[..., Any]) -> Callable[..., bool]: ...
+    @classmethod
+    def _add_logical_ops(cls) -> None: ...

pandas-stubs/core/arrays/integer.pyi

@@ -0,0 +1,69 @@
+from typing import Any, Callable, List, Optional, Sequence, Type, Union, Tuple
+from typing_extensions import Literal
+import numpy as np
+from numpy import _ScalarLike
+
+from ..dtypes.base import _ArrayLike, _DtypeObj
+from .masked import BaseMaskedArray, BaseMaskedDtype
+
+class _IntegerDtype(BaseMaskedDtype):
+    def __repr__(self) -> str: ...
+    def is_signed_integer(self) -> bool: ...
+    def is_unsigned_integer(self) -> bool: ...
+    @property
+    def _is_numeric(self) -> bool: ...
+    def numpy_dtype(self) -> np.dtype: ...
+    def kind(self) -> str: ...
+    def itemsize(self) -> int: ...
+    @classmethod
+    def construct_array_type(cls) -> Type[IntegerArray]: ...
+    def _get_common_dtype(self, dtypes: List[_DtypeObj]) -> Optional[_DtypeObj]: ...
+    def __from_arrow__(
+        self,
+        array: Any,  # Union[pyarrow.Array, pyarrow.ChunkedArray]
+    ) -> IntegerArray: ...
+
+class IntegerArray(BaseMaskedArray):
+    def dtype(self) -> _IntegerDtype: ...
+    def __init__(self, values: np.ndarray, mask: np.ndarray, copy: bool = ...) -> None: ...
+    @classmethod
+    def _from_sequence(
+        cls, scalars: Sequence[_ScalarLike], dtype: Optional[_DtypeObj] = ..., copy: bool = ...
+    ) -> IntegerArray: ...
+    @classmethod
+    def _from_sequence_of_strings(
+        cls, strings: Sequence[str], dtype: Optional[_DtypeObj] = ..., copy: bool = ...
+    ) -> IntegerArray: ...
+    def __array_ufunc__(
+        self,
+        ufunc: Callable[..., Any],
+        method: Literal["reduce", "accumulate", "reduceat", "outer", "at", "__call__"],
+        *inputs: Any,
+        **kwargs: Any,
+    ) -> Any: ...
+    def _coerce_to_array(self, value: Any) -> Tuple[np.ndarray, np.ndarray]: ...
+    def astype(self, dtype: Union[str, _DtypeObj], copy: bool = ...) -> _ArrayLike: ...
+    def _values_for_argsort(self) -> np.ndarray: ...
+    @classmethod
+    def _create_comparison_method(cls, op: Callable[..., Any]) -> Callable[..., bool]: ...
+    def sum(self, skipna: bool = ..., min_count: int = ..., **kwargs: Any) -> _IntegerDtype: ...
+    def _maybe_mask_result(
+        self,
+        result: _ArrayLike,
+        mask: _ArrayLike,
+        other: Union[_ScalarLike, _ArrayLike],
+        op_name: str,
+    ) -> Callable[[Any, Any], IntegerArray]: ...
+    @classmethod
+    def _create_arithmetic_method(
+        cls, op: Callable[..., Any]
+    ) -> Callable[[Any, Any], IntegerArray]: ...
+
+class Int8Dtype(_IntegerDtype): ...
+class Int16Dtype(_IntegerDtype): ...
+class Int32Dtype(_IntegerDtype): ...
+class Int64Dtype(_IntegerDtype): ...
+class UInt8Dtype(_IntegerDtype): ...
+class UInt16Dtype(_IntegerDtype): ...
+class UInt32Dtype(_IntegerDtype): ...
+class UInt64Dtype(_IntegerDtype): ...

pandas-stubs/core/arrays/masked.pyi

@@ -0,0 +1,52 @@
+from typing import Any, Generator, Iterable, Optional, Sequence, Tuple, Type, TypeVar, Union
+
+import numpy as np
+from numpy import _ScalarLike
+
+from ..arrays.base import ExtensionArray, ExtensionOpsMixin
+from ..dtypes.base import ExtensionDtype, _ArrayLike, _DtypeObj
+from ..series import Series
+
+_BaseMaskedArrayT = TypeVar("_BaseMaskedArrayT", bound=BaseMaskedArray)
+
+class BaseMaskedDtype(ExtensionDtype):
+    @property
+    def numpy_dtype(self) -> np.dtype: ...
+    @classmethod
+    def construct_array_type(cls) -> Type[BaseMaskedArray]: ...
+
+class BaseMaskedArray(ExtensionArray, ExtensionOpsMixin):
+    def __init__(self, values: np.ndarray, mask: np.ndarray, copy: bool = ...) -> None: ...
+    @property
+    def dtype(self) -> BaseMaskedDtype: ...
+    def _coerce_to_array(self, values: Any) -> Tuple[np.ndarray, np.ndarray]: ...
+    def __setitem__(self, key: Union[int, slice, np.ndarray], value: Any) -> None: ...
+    def __iter__(self) -> Generator[Any, None, None]: ...
+    def __len__(self) -> int: ...
+    def __invert__(self: _BaseMaskedArrayT) -> _BaseMaskedArrayT: ...
+    def to_numpy(
+        self, dtype: Optional[_DtypeObj] = ..., copy: bool = ..., na_value: _ScalarLike = ...
+    ) -> np.ndarray: ...
+    def __array__(self, dtype: _DtypeObj = ...) -> np.ndarray: ...
+    def __arrow_array__(self, type: Optional[Any] = ...) -> Any: ...  # pyarrow.array: ...
+    @property
+    def _hasna(self) -> bool: ...
+    def isna(self) -> _ArrayLike: ...
+    @property
+    def _na_value(self) -> Any: ...
+    @property
+    def nbytes(self) -> int: ...
+    @classmethod
+    def _concat_same_type(
+        cls: Type[_BaseMaskedArrayT], to_concat: Iterable
+    ) -> _BaseMaskedArrayT: ...
+    def take(
+        self: _BaseMaskedArrayT,
+        indexer: Sequence,
+        allow_fill: bool = ...,
+        fill_value: Optional[_ScalarLike] = ...,
+    ) -> _BaseMaskedArrayT: ...
+    def copy(self: _BaseMaskedArrayT) -> _BaseMaskedArrayT: ...
+    def factorize(self, na_sentinel: int = ...) -> Tuple[np.ndarray, ExtensionArray]: ...
+    def value_counts(self, dropna: bool = ...) -> Series: ...
+    def _reduce(self, name: str, skipna: bool = ..., **kwargs: Any) -> _ScalarLike: ...