Merge branch 'master' into release

Author: tmke8

.gitignore

@@ -12,3 +12,9 @@ __pycache__/
 
 # generated pyi files
 /matplotlib-stubs/pyplot.pyi
+
+# virtual environments
+venv
+
+# vscode
+.vscode

README.md

@@ -1,5 +1,7 @@
 # Mypy type stubs for numpy, pandas and matplotlib
 
+[![Join the chat at https://gitter.im/data-science-types/community](https://badges.gitter.im/data-science-types/community.svg)](https://gitter.im/data-science-types/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
 This is a [PEP-561][pep-561]-compliant stub-only package
 which provides type information for [matplotlib][matplotlib], [numpy][numpy] and [pandas][pandas].
 The [mypy][mypy] type checker (or pytype or PyCharm) can [recognize][mypy-docs] the types in these packages by installing this package.
@@ -86,16 +88,24 @@ All pull requests are subject to CI checks.
 We check for compliance with Mypy and that the file formatting conforms to our Black specification.
 
 You can install these dev dependencies via
-```
-pip install -e .[dev]
+
+```bash
+pip install -e '.[dev]'
 ```
 
 This will also install numpy, pandas and matplotlib to be able to run the tests.
 
 ### Running CI locally (recommended)
 
 We include a script that runs the CI checks that will be run when a PR is opened.
-To test these out locally, use the `check_all.sh` script.
+To test these out locally, you need to install the type stubs in your environment.
+Typically, you would do this with
+
+```bash
+pip install -e .
+```
+
+Then use the `check_all.sh` script to run all tests:
 
 ```bash
 ./check_all.sh

matplotlib-stubs/pyplot.pyi.in

@@ -145,6 +145,7 @@ class Figure:
         label: str = ...,
     ) -> SubplotBase: ...
     def legend(self, *args: Any, **kwargs: Any) -> Legend: ...
+    def clf(self) -> None: ...
 
 @overload
 def subplots(

numpy-stubs/__init__.pyi

@@ -309,6 +309,8 @@ class ndarray(Generic[_DType]):
     def __add__(self, value: ndarray[_DType]) -> ndarray[_DType]: ...
     @overload
     def __add__(self, value: _DType) -> ndarray[_DType]: ...
+    @overload
+    def __add__(self, value: float) -> ndarray[float64]: ...
     def __and__(self, value: object) -> ndarray[_DType]: ...
     @overload
     def __array__(self) -> ndarray[_DType]: ...
@@ -352,6 +354,8 @@ class ndarray(Generic[_DType]):
     def __iadd__(self, value: ndarray[_DType]) -> ndarray[_DType]: ...
     @overload
     def __iadd__(self, value: _DType) -> ndarray[_DType]: ...
+    @overload
+    def __iadd__(self, value: float) -> ndarray[float64]: ...
     def __iand__(self, value: object) -> ndarray[bool_]: ...
     def __ifloordiv__(self, value: object) -> None: ...
     def __ilshift__(self, value: object) -> None: ...
@@ -500,15 +504,22 @@ def array(object: _NestedList[float]) -> ndarray[float64]: ...
 @overload
 def array(object: _NestedList[str]) -> ndarray[str_]: ...
 @overload
+def array(object: str) -> ndarray[str_]: ...
+@overload
 def array(object: Union[ndarray[_DType], _NestedList[ndarray[_DType]]]) -> ndarray[_DType]: ...
 @overload
+def array(object: Tuple) -> ndarray[bool_]: ...
+@overload
 def arange(stop: int, start: int = ..., step: int = ...) -> ndarray[int64]: ...
 @overload
 def arange(range_: int, dtype: Type[_DType]) -> ndarray[_DType]: ...
 @overload
 def arange(range_: float) -> ndarray[float64]: ...
 def ascontiguousarray(a: Any, dtype: Optional[Type[_DType]] = ...) -> ndarray: ...
 def copy(a: Any, order: Optional[str] = ...) -> ndarray: ...
+def cumsum(
+    a: ndarray[_DType], axis: Optional[int] = ..., dtype: Optional[Type[_DType]] = ...
+) -> ndarray[_DType]: ...
 def delete(
     arr: ndarray[_DType], object: Union[int, List[int], slice], axis: Optional[int] = ...
 ) -> ndarray[_DType]: ...
@@ -667,7 +678,17 @@ def concatenate(arrays: Sequence[_ArrayLike[_DType]], axis: _AxesType = ...) ->
 def corrcoef(
     x: ndarray[_DType], y: Optional[ndarray[_DType]] = ..., rowvar: Optional[bool] = ...
 ) -> ndarray[float64]: ...
+def cos(
+    x: Union[_DType, ndarray[_DType], int, float, List[int], List[float]],
+    out: Optional[Union[ndarray[_DType], Tuple[ndarray[_DType], None]]] = ...,
+    where: Optional[_ArrayLike] = ...,
+) -> Union[_DType, ndarray[_DType]]: ...
 def cov(m: ndarray[_DType], rowvar: Optional[bool]) -> ndarray[float64]: ...
+def deg2rad(
+    x: Union[_DType, ndarray[_DType], int, float, List[int], List[float]],
+    out: Optional[Union[ndarray[_DType], Tuple[ndarray[_DType], None]]] = ...,
+    where: Optional[_ArrayLike] = ...,
+) -> Union[_DType, ndarray[_DType]]: ...
 def diag(a: ndarray[_DType]) -> ndarray[_DType]: ...
 def diff(
     a: ndarray[_DType],
@@ -752,11 +773,6 @@ def min(a: ndarray[_DType], axis: None = ...) -> _DType: ...
 @overload
 def min(a: ndarray[_DType], axis: _AxesType, keepdims: bool = ...) -> ndarray[_DType]: ...
 def minimum(a: ndarray[_DType], b: ndarray[_DType]) -> ndarray[_DType]: ...
-@overload
-def nanstd(a: ndarray[_Float]) -> _Float: ...
-@overload
-def nanstd(a: ndarray[_Float], axis: _AxesType, keepdims: bool = ...) -> ndarray[_Float]: ...
-def nansum(a: ndarray[_DType]) -> ndarray[_DType]: ...
 def nan_to_num(
     x: ndarray[_DType],
     copy: bool = ...,
@@ -796,8 +812,15 @@ def searchsorted(a: ndarray[_DType], v: _DType, side: str = ...) -> int64: ...
 @overload
 def searchsorted(a: ndarray[_DType], v: ndarray[_DType], side: str = ...) -> ndarray[int64]: ...
 def setdiff1d(
-    ar1: ndarray[_DType], ar2: ndarray[_DType], assume_unique: bool = ...
+    ar1: Union[ndarray[_DType], List[_ScalarLike]],
+    ar2: Union[ndarray[_DType], List[_ScalarLike]],
+    assume_unique: bool = ...,
 ) -> ndarray[_DType]: ...
+def sin(
+    x: Union[_DType, ndarray[_DType], int, float, List[int], List[float]],
+    out: Optional[Union[ndarray[_DType], Tuple[ndarray[_DType], None]]] = ...,
+    where: Optional[_ArrayLike] = ...,
+) -> Union[_DType, ndarray[_DType]]: ...
 def sign(x: ndarray[_DType]) -> ndarray[_DType]: ...
 def sort(a: ndarray[_DType]) -> ndarray[_DType]: ...
 def split(
@@ -825,6 +848,11 @@ def take(a: ndarray[_DType], indices: ndarray[_Int], axis: _AxesType = ...) -> n
 def take_along_axis(
     arr: ndarray[_DType], indices: ndarray[_Int], axis: _AxesType = ...
 ) -> ndarray[_DType]: ...
+def tan(
+    x: Union[_DType, ndarray[_DType], int, float, List[int], List[float]],
+    out: Optional[Union[ndarray[_DType], Tuple[ndarray[_DType], None]]] = ...,
+    where: Optional[_ArrayLike] = ...,
+) -> Union[_DType, ndarray[_DType]]: ...
 def tile(a: ndarray[_DType], reps: Union[_NestedList[int], ndarray[_Int]]) -> ndarray[_DType]: ...
 def trace(a: ndarray[_DType]) -> _DType: ...
 def transpose(a: ndarray[_DType]) -> ndarray[_DType]: ...
@@ -857,6 +885,14 @@ def where(condition: _ConditionType, x: float, y: float) -> ndarray[float64]: ..
 @overload
 def where(condition: _ConditionType) -> Tuple[ndarray[int64], ...]: ...
 
+#
+# nan series methods
+#
+nancumsum = cumsum
+nanmean = mean
+nanstd = std
+nansum = sum
+
 #
 # Saving methods
 #

numpy-stubs/random.pyi

@@ -71,6 +71,7 @@ def normal(loc: float, scale: float, size: Union[int, Tuple[int, ...]]) -> ndarr
 def permutation(size: int) -> ndarray[int64]: ...
 @overload
 def permutation(size: Iterable[_DType]) -> ndarray[_DType]: ...
+def rand(*args: int) -> ndarray[_Float]: ...
 def randn(*args: int) -> ndarray[_Float]: ...
 @overload
 def randint(low: int, high: int = ...) -> int64: ...

pandas-stubs/__init__.pyi

@@ -11,6 +11,7 @@ from typing import (
     Dict,
     Sequence,
     Type,
+    TypeVar,
     Mapping,
 )
 from typing_extensions import Literal
@@ -30,7 +31,22 @@ def concat(
 ) -> DataFrame: ...
 def cut(arr: _np.ndarray, bins: int) -> Tuple[Union[Series, _np.ndarray], _np.ndarray]: ...
 def get_dummies(df: Union[DataFrame, Series], columns: Optional[_ListLike] = ...) -> DataFrame: ...
-def isnull(df: Union[DataFrame, Series]) -> _np.ndarray: ...
+@overload
+def isna(obj: Union[float, str]) -> bool: ...
+@overload
+def isna(obj: DataFrame) -> DataFrame: ...
+@overload
+def isna(obj: Series) -> Series[bool]: ...
+@overload
+def isna(obj: Union[Index, _np.ndarray]) -> _np.ndarray[_np.bool_]: ...
+@overload
+def isnull(obj: Union[None, float, str]) -> bool: ...
+@overload
+def isnull(obj: DataFrame) -> DataFrame: ...
+@overload
+def isnull(obj: Series) -> Series[bool]: ...
+@overload
+def isnull(obj: Union[Index, _np.ndarray]) -> _np.ndarray[_np.bool_]: ...
 @overload
 def merge(left: DataFrame, right: DataFrame, on: str = ...) -> DataFrame: ...
 @overload

pandas-stubs/core/frame.pyi

@@ -1,34 +1,35 @@
+import sre_compile
+import sys
 from pathlib import Path
 from typing import (
     Any,
-    Tuple,
-    List,
-    Union,
     Callable,
     Dict,
+    Hashable,
+    Iterable,
+    Iterator,
+    List,
     Mapping,
     NamedTuple,
     Optional,
+    Pattern,
+    Sequence,
+    Tuple,
     Type,
-    TypeVar,
+    Union,
     overload,
-    Iterator,
-    Sequence,
-    Generator,
-    Iterable,
-    Hashable,
 )
-from typing_extensions import Literal
+
 import matplotlib
 import numpy as _np
+from typing_extensions import Literal
 
-from .groupby.generic import DataFrameGroupBy, SeriesGroupBy
+from .groupby.generic import DataFrameGroupBy
 from .indexes import Index
-from .indexing import _iLocIndexerFrame, _LocIndexerFrame, _AtIndexerFrame
+from .indexing import _AtIndexerFrame, _iLocIndexerFrame, _LocIndexerFrame
 from .series import Series, _DTypeNp
-from .strings import StringMethods
 
-_str = str  # needed because DataFrame has a property called "str"...
+_str = str  # needed because Series has a property called "str"...
 
 _AxisType = Literal["columns", "index", 0, 1]
 
@@ -98,8 +99,6 @@ class DataFrame:
     @property
     def size(self) -> int: ...
     @property
-    def str(self) -> StringMethods: ...
-    @property
     def T(self) -> DataFrame: ...
     # this function is deprecated:
     @property
@@ -123,10 +122,10 @@ class DataFrame:
     def append(
         self, s: Union[DataFrame, Dict[_str, Any]], ignore_index: bool = ..., sort: bool = ...
     ) -> DataFrame: ...
-    @overload
-    def apply(self, f: Callable[..., int]) -> Series: ...
-    @overload
-    def apply(self, f: Callable[..., _ListLike], axis: _AxisType = ...) -> DataFrame: ...
+    def apply(
+        self, f: Callable[[Series], Any], axis: _AxisType = ...
+    ) -> Union[Series, DataFrame]: ...
+    def assign(self, **kwargs: Any) -> DataFrame: ...
     def astype(
         self,
         dtype: Union[_TypeLike, Dict[Hashable, _TypeLike]],
@@ -137,12 +136,15 @@ class DataFrame:
     def corr(self, method: Optional[_str] = ..., min_periods: Optional[int] = ...) -> DataFrame: ...
     def count(self) -> Series: ...
     @overload
-    def drop(self, labels: Union[List[_str], Index], axis: _AxisType = ...) -> DataFrame: ...
+    def drop(
+        self, labels: Union[_str, List[_str], Index], axis: _AxisType = ..., inplace: bool = ...
+    ) -> DataFrame: ...
     @overload
     def drop(self, *, index: Union[List[_str], Index]) -> DataFrame: ...
     @overload
     def drop(self, *, columns: Union[_str, List[_str], Index]) -> DataFrame: ...
     def drop_duplicates(self, keep: Union[_str, bool] = ...) -> DataFrame: ...
+    def transpose(self, *args: int, copy: bool = ...) -> DataFrame: ...
     @overload
     def dropna(
         self,
@@ -176,6 +178,16 @@ class DataFrame:
         downcast: Dict = ...,
     ) -> None: ...
     @overload
+    def filter(
+        self,
+        items: List[_str],
+        axis: _AxisType = ...,
+    ) -> DataFrame: ...
+    @overload
+    def filter(self, *, like: _str, axis: _AxisType = ...) -> DataFrame: ...
+    @overload
+    def filter(self, *, regex: _str, axis: _AxisType = ...) -> DataFrame: ...
+    @overload
     def groupby(
         self,
         by: Union[
@@ -221,6 +233,23 @@ class DataFrame:
     def itertuples(self, index: bool = ...) -> Iterator[NamedTuple]: ...
     def max(self) -> Series: ...
     def mean(self) -> Series: ...
+    @overload
+    def merge(
+        self,
+        right: DataFrame,
+        on: Union[_str, List[_str]],
+        how: Literal["left", "right", "inner", "outer"] = ...,
+        suffixes: Iterable[_str] = ...,
+    ) -> DataFrame: ...
+    @overload
+    def merge(
+        self,
+        right: DataFrame,
+        left_on: Union[_str, List[_str]],
+        right_on: Union[_str, List[_str]],
+        how: Literal["left", "right", "inner", "outer"] = ...,
+        suffixes: Iterable[_str] = ...,
+    ) -> DataFrame: ...
     def min(self) -> Series: ...
     def mode(self, axis: _AxisType = ...) -> DataFrame: ...
     def median(
@@ -233,14 +262,17 @@ class DataFrame:
     def query(self, expr: _str) -> DataFrame: ...
     def rank(
         self,
-        axis: int,
-        method: _str,
-        numeric_only: Optional[bool],
-        na_option: _str,
-        ascending: bool,
-        pct: bool,
+        axis: _AxisType = ...,
+        method: _str = ...,
+        numeric_only: Optional[bool] = ...,
+        na_option: _str = ...,
+        ascending: bool = ...,
+        pct: bool = ...,
     ) -> DataFrame: ...
+    @overload
     def reindex(self, index: Index) -> DataFrame: ...
+    @overload
+    def reindex(self, columns: List[_str]) -> DataFrame: ...
     # rename specifying mapper= and axis=
     @overload
     def rename(
@@ -261,7 +293,11 @@ class DataFrame:
     @overload
     def rename(self, *, index: _Renamer, inplace: Literal[False] = ...) -> DataFrame: ...
     def replace(
-        self, a: Union[_np.dtype, _str], b: Union[_np.dtype, float, _str], regex: bool = ...
+        self,
+        a: Union[_np.dtype, _str, Pattern[_str]],
+        b: Union[_np.dtype, float, _str],
+        regex: bool = ...,
+        inplace: bool = ...,
     ) -> DataFrame: ...
     @overload
     def reset_index(self, drop: bool = ...) -> DataFrame: ...