From 2c705800b0372dfc7415ec4b8fdb0e3eb8c27bd9 Mon Sep 17 00:00:00 2001 From: Johan Vergeer Date: Sun, 24 Nov 2019 20:26:59 +0100 Subject: [PATCH 1/6] Add type hinting for numeric.py --- .gitignore | 2 + numpy-stubs/__init__.pyi | 2 + numpy-stubs/core/numeric.pyi | 155 +++++++++++++++++++++++++++++++++++ 3 files changed, 159 insertions(+) create mode 100644 numpy-stubs/core/numeric.pyi diff --git a/.gitignore b/.gitignore index e11cb63..0f19c2d 100644 --- a/.gitignore +++ b/.gitignore @@ -2,3 +2,5 @@ .pytest_cache __pycache__ numpy_stubs.egg-info/ +venv +.idea \ No newline at end of file diff --git a/numpy-stubs/__init__.pyi b/numpy-stubs/__init__.pyi index 43f7c6d..92fad96 100644 --- a/numpy-stubs/__init__.pyi +++ b/numpy-stubs/__init__.pyi @@ -82,6 +82,8 @@ _DtypeLike = Union[ _NdArraySubClass = TypeVar("_NdArraySubClass", bound=ndarray) +_ArrayLike = TypeVar("_ArrayLike", str, int, float, bool, object, ByteString, Iterable, Container, ndarray) + class dtype: names: Optional[Tuple[str, ...]] def __init__( diff --git a/numpy-stubs/core/numeric.pyi b/numpy-stubs/core/numeric.pyi new file mode 100644 index 0000000..a15d755 --- /dev/null +++ b/numpy-stubs/core/numeric.pyi @@ -0,0 +1,155 @@ +from types import ModuleType +from typing import Sequence, Optional, TypeVar, Union, Tuple, List, Iterable, Callable, Any + +from numpy import (ndarray, dtype, _ArrayLike, _ShapeLike) + +T = TypeVar('T') + + +def zeros_like( + a: _ArrayLike, + dtype: Optional[dtype] = None, + order: str = 'K', + subok: bool = True, + shape: Optional[Union[int, Sequence[int]]] = None) -> ndarray[int]: ... + + +def ones( + shape: _ShapeLike, + dtype: Optional[dtype] = None, + order: str = 'C') -> ndarray[int]: ... + + +def ones_like( + a: _ArrayLike, + dtype: Optional[dtype] = None, + order: str = 'K', + subok: bool = True, + shape: Optional[_ShapeLike] = None) -> ndarray[int]: ... + + +def full( + shape: _ShapeLike, + fill_value: T, + dtype: Optional[dtype] = None, + order: str = 'C') -> ndarray[T]: ... + + +def full_like( + a: _ArrayLike, + fill_value: T, + dtype: Optional[dtype] = None, + order: str = 'K', + subok: bool = True, + shape: Optional[_ShapeLike] = None) -> ndarray[T]: ... + + +def count_nonzero( + a: _ArrayLike, + axis: Optional[Union[int, Tuple[int], Tuple[int, int]]] = None) -> Union[int, ndarray[int]]: ... + + +def isfortran(a: ndarray) -> bool: ... + + +def argwhere(a: _ArrayLike) -> ndarray: ... + + +def flatnonzero(a: _ArrayLike) -> ndarray: ... + + +def correlate(a: _ArrayLike, v: _ArrayLike, mode: str = 'valid') -> ndarray: ... + + +def convolve(a: _ArrayLike, v: _ArrayLike, mode: str = 'full') -> ndarray: ... + + +def outer(a: _ArrayLike, b: _ArrayLike, out: ndarray = None) -> ndarray: ... + + +def tensordot( + a: _ArrayLike, + b: _ArrayLike, + axes: Union[int, Tuple[int, int], Tuple[Tuple[int, int], ...], Tuple[List[int, int], ...]] = 2) -> ndarray: ... + + +def roll(a: _ArrayLike, + shift: Union[int, Tuple[int, ...]], + axis: Optional[Union[int, Tuple[int, ...]]] = None) -> T: ... + + +def rollaxis( + a: _ArrayLike, + axis: int, + start: int = 0) -> ndarray: ... + + +def normalize_axis_tuple( + axis: Union[int, Iterable[int]], + ndim: int, + argname: Optional[str] = None, + allow_duplicate: bool = False) -> Tuple[int, ...]: ... + + +def moveaxis( + a: ndarray, + source: Union[int, Sequence[int]], + destination: Union[int, Sequence[int]]) -> ndarray: ... + + +def cross( + a: _ArrayLike, + b: _ArrayLike, + axisa: int = -1, + axisb: int = -1, + axisc: int = -1, + axis: Optional[int] = None) -> ndarray: ... + + +def indices( + dimensions: Sequence[int], + dtype: dtype = int, + sparse: bool = False) -> Union[ndarray, Tuple[ndarray, ...]]: ... + + +def fromfunction( + function: Callable, + shape: Tuple[int, int], + **kwargs) -> Any: ... + + +def isscalar(element: Any) -> bool: ... + + +def binary_repr(num: int, width: Optional[int] = None) -> str: ... + + +def base_repr(number: int, base: int = 2, padding: int = 0) -> str: ... + + +def identity(n: int, dtype: Optional[dtype] = None) -> ndarray: ... + + +def allclose( + a: _ArrayLike, + b: _ArrayLike, + rtol: float = 1.e-5, + atol: float = 1.e-8, + equal_nan: bool = False) -> bool: ... + + +def isclose( + a: _ArrayLike, + b: _ArrayLike, + rtol: float = 1.e-5, + atol: float = 1.e-8, + equal_nan: bool = False) -> _ArrayLike: ... + + +def array_equal(a1: _ArrayLike, a2: _ArrayLike) -> bool: ... + + +def array_equiv(a1: _ArrayLike, a2: _ArrayLike) -> bool: ... + + +def extend_all(module: ModuleType): ... From 58bc28dcd173cb0b6d4b83d42d1d26e27f7b65e2 Mon Sep 17 00:00:00 2001 From: Johan Vergeer Date: Sun, 24 Nov 2019 20:33:45 +0100 Subject: [PATCH 2/6] Code cleanup using Black --- numpy-stubs/__init__.pyi | 13 ++- numpy-stubs/core/numeric.pyi | 214 ++++++++++++++--------------------- 2 files changed, 97 insertions(+), 130 deletions(-) diff --git a/numpy-stubs/__init__.pyi b/numpy-stubs/__init__.pyi index 92fad96..f97f051 100644 --- a/numpy-stubs/__init__.pyi +++ b/numpy-stubs/__init__.pyi @@ -82,7 +82,18 @@ _DtypeLike = Union[ _NdArraySubClass = TypeVar("_NdArraySubClass", bound=ndarray) -_ArrayLike = TypeVar("_ArrayLike", str, int, float, bool, object, ByteString, Iterable, Container, ndarray) +_ArrayLike = TypeVar( + "_ArrayLike", + str, + int, + float, + bool, + object, + ByteString, + Iterable, + Container, + ndarray, +) class dtype: names: Optional[Tuple[str, ...]] diff --git a/numpy-stubs/core/numeric.pyi b/numpy-stubs/core/numeric.pyi index a15d755..63efc77 100644 --- a/numpy-stubs/core/numeric.pyi +++ b/numpy-stubs/core/numeric.pyi @@ -1,155 +1,111 @@ from types import ModuleType -from typing import Sequence, Optional, TypeVar, Union, Tuple, List, Iterable, Callable, Any - -from numpy import (ndarray, dtype, _ArrayLike, _ShapeLike) - -T = TypeVar('T') - +from typing import ( + Sequence, + Optional, + TypeVar, + Union, + Tuple, + List, + Iterable, + Callable, + Any, +) + +from numpy import ndarray, dtype, _ArrayLike, _ShapeLike + +T = TypeVar("T") def zeros_like( - a: _ArrayLike, - dtype: Optional[dtype] = None, - order: str = 'K', - subok: bool = True, - shape: Optional[Union[int, Sequence[int]]] = None) -> ndarray[int]: ... - - + a: _ArrayLike, + dtype: Optional[dtype] = None, + order: str = "K", + subok: bool = True, + shape: Optional[Union[int, Sequence[int]]] = None, +) -> ndarray[int]: ... def ones( - shape: _ShapeLike, - dtype: Optional[dtype] = None, - order: str = 'C') -> ndarray[int]: ... - - + shape: _ShapeLike, dtype: Optional[dtype] = None, order: str = "C" +) -> ndarray[int]: ... def ones_like( - a: _ArrayLike, - dtype: Optional[dtype] = None, - order: str = 'K', - subok: bool = True, - shape: Optional[_ShapeLike] = None) -> ndarray[int]: ... - - + a: _ArrayLike, + dtype: Optional[dtype] = None, + order: str = "K", + subok: bool = True, + shape: Optional[_ShapeLike] = None, +) -> ndarray[int]: ... def full( - shape: _ShapeLike, - fill_value: T, - dtype: Optional[dtype] = None, - order: str = 'C') -> ndarray[T]: ... - - + shape: _ShapeLike, fill_value: T, dtype: Optional[dtype] = None, order: str = "C" +) -> ndarray[T]: ... def full_like( - a: _ArrayLike, - fill_value: T, - dtype: Optional[dtype] = None, - order: str = 'K', - subok: bool = True, - shape: Optional[_ShapeLike] = None) -> ndarray[T]: ... - - + a: _ArrayLike, + fill_value: T, + dtype: Optional[dtype] = None, + order: str = "K", + subok: bool = True, + shape: Optional[_ShapeLike] = None, +) -> ndarray[T]: ... def count_nonzero( - a: _ArrayLike, - axis: Optional[Union[int, Tuple[int], Tuple[int, int]]] = None) -> Union[int, ndarray[int]]: ... - - + a: _ArrayLike, axis: Optional[Union[int, Tuple[int], Tuple[int, int]]] = None +) -> Union[int, ndarray[int]]: ... def isfortran(a: ndarray) -> bool: ... - - def argwhere(a: _ArrayLike) -> ndarray: ... - - def flatnonzero(a: _ArrayLike) -> ndarray: ... - - -def correlate(a: _ArrayLike, v: _ArrayLike, mode: str = 'valid') -> ndarray: ... - - -def convolve(a: _ArrayLike, v: _ArrayLike, mode: str = 'full') -> ndarray: ... - - +def correlate(a: _ArrayLike, v: _ArrayLike, mode: str = "valid") -> ndarray: ... +def convolve(a: _ArrayLike, v: _ArrayLike, mode: str = "full") -> ndarray: ... def outer(a: _ArrayLike, b: _ArrayLike, out: ndarray = None) -> ndarray: ... - - def tensordot( - a: _ArrayLike, - b: _ArrayLike, - axes: Union[int, Tuple[int, int], Tuple[Tuple[int, int], ...], Tuple[List[int, int], ...]] = 2) -> ndarray: ... - - -def roll(a: _ArrayLike, - shift: Union[int, Tuple[int, ...]], - axis: Optional[Union[int, Tuple[int, ...]]] = None) -> T: ... - - -def rollaxis( - a: _ArrayLike, - axis: int, - start: int = 0) -> ndarray: ... - - + a: _ArrayLike, + b: _ArrayLike, + axes: Union[ + int, Tuple[int, int], Tuple[Tuple[int, int], ...], Tuple[List[int, int], ...] + ] = 2, +) -> ndarray: ... +def roll( + a: _ArrayLike, + shift: Union[int, Tuple[int, ...]], + axis: Optional[Union[int, Tuple[int, ...]]] = None, +) -> T: ... +def rollaxis(a: _ArrayLike, axis: int, start: int = 0) -> ndarray: ... def normalize_axis_tuple( - axis: Union[int, Iterable[int]], - ndim: int, - argname: Optional[str] = None, - allow_duplicate: bool = False) -> Tuple[int, ...]: ... - - + axis: Union[int, Iterable[int]], + ndim: int, + argname: Optional[str] = None, + allow_duplicate: bool = False, +) -> Tuple[int, ...]: ... def moveaxis( - a: ndarray, - source: Union[int, Sequence[int]], - destination: Union[int, Sequence[int]]) -> ndarray: ... - - + a: ndarray, + source: Union[int, Sequence[int]], + destination: Union[int, Sequence[int]], +) -> ndarray: ... def cross( - a: _ArrayLike, - b: _ArrayLike, - axisa: int = -1, - axisb: int = -1, - axisc: int = -1, - axis: Optional[int] = None) -> ndarray: ... - - + a: _ArrayLike, + b: _ArrayLike, + axisa: int = -1, + axisb: int = -1, + axisc: int = -1, + axis: Optional[int] = None, +) -> ndarray: ... def indices( - dimensions: Sequence[int], - dtype: dtype = int, - sparse: bool = False) -> Union[ndarray, Tuple[ndarray, ...]]: ... - - -def fromfunction( - function: Callable, - shape: Tuple[int, int], - **kwargs) -> Any: ... - - + dimensions: Sequence[int], dtype: dtype = int, sparse: bool = False +) -> Union[ndarray, Tuple[ndarray, ...]]: ... +def fromfunction(function: Callable, shape: Tuple[int, int], **kwargs) -> Any: ... def isscalar(element: Any) -> bool: ... - - def binary_repr(num: int, width: Optional[int] = None) -> str: ... - - def base_repr(number: int, base: int = 2, padding: int = 0) -> str: ... - - def identity(n: int, dtype: Optional[dtype] = None) -> ndarray: ... - - def allclose( - a: _ArrayLike, - b: _ArrayLike, - rtol: float = 1.e-5, - atol: float = 1.e-8, - equal_nan: bool = False) -> bool: ... - - + a: _ArrayLike, + b: _ArrayLike, + rtol: float = 1.0e-5, + atol: float = 1.0e-8, + equal_nan: bool = False, +) -> bool: ... def isclose( - a: _ArrayLike, - b: _ArrayLike, - rtol: float = 1.e-5, - atol: float = 1.e-8, - equal_nan: bool = False) -> _ArrayLike: ... - - + a: _ArrayLike, + b: _ArrayLike, + rtol: float = 1.0e-5, + atol: float = 1.0e-8, + equal_nan: bool = False, +) -> _ArrayLike: ... def array_equal(a1: _ArrayLike, a2: _ArrayLike) -> bool: ... - - def array_equiv(a1: _ArrayLike, a2: _ArrayLike) -> bool: ... - - def extend_all(module: ModuleType): ... From 3c81e70699e7f828fdadf8b8590cdec0ec279a35 Mon Sep 17 00:00:00 2001 From: Johan Vergeer Date: Sun, 24 Nov 2019 20:43:48 +0100 Subject: [PATCH 3/6] Add ByteString dependency --- numpy-stubs/__init__.pyi | 1 + 1 file changed, 1 insertion(+) diff --git a/numpy-stubs/__init__.pyi b/numpy-stubs/__init__.pyi index f97f051..3f86e76 100644 --- a/numpy-stubs/__init__.pyi +++ b/numpy-stubs/__init__.pyi @@ -5,6 +5,7 @@ import datetime as dt from numpy.core._internal import _ctypes from typing import ( Any, + ByteString, Container, Dict, IO, From 1b7afd7c9e4c850462c48f7bbb2d77ee33900de3 Mon Sep 17 00:00:00 2001 From: Johan Vergeer Date: Sun, 24 Nov 2019 20:44:13 +0100 Subject: [PATCH 4/6] Replace default values with "..." to satisfy Flake8 --- numpy-stubs/core/numeric.pyi | 84 ++++++++++++++++++------------------ 1 file changed, 42 insertions(+), 42 deletions(-) diff --git a/numpy-stubs/core/numeric.pyi b/numpy-stubs/core/numeric.pyi index 63efc77..1e43676 100644 --- a/numpy-stubs/core/numeric.pyi +++ b/numpy-stubs/core/numeric.pyi @@ -13,63 +13,63 @@ from typing import ( from numpy import ndarray, dtype, _ArrayLike, _ShapeLike -T = TypeVar("T") +_T = TypeVar("_T") def zeros_like( a: _ArrayLike, - dtype: Optional[dtype] = None, - order: str = "K", - subok: bool = True, - shape: Optional[Union[int, Sequence[int]]] = None, + dtype: Optional[dtype] = ..., + order: str = ..., + subok: bool = ..., + shape: Optional[Union[int, Sequence[int]]] = ..., ) -> ndarray[int]: ... def ones( - shape: _ShapeLike, dtype: Optional[dtype] = None, order: str = "C" + shape: _ShapeLike, dtype: Optional[dtype] = ..., order: str = ... ) -> ndarray[int]: ... def ones_like( a: _ArrayLike, - dtype: Optional[dtype] = None, - order: str = "K", - subok: bool = True, - shape: Optional[_ShapeLike] = None, + dtype: Optional[dtype] = ..., + order: str = ..., + subok: bool = ..., + shape: Optional[_ShapeLike] = ..., ) -> ndarray[int]: ... def full( - shape: _ShapeLike, fill_value: T, dtype: Optional[dtype] = None, order: str = "C" -) -> ndarray[T]: ... + shape: _ShapeLike, fill_value: _T, dtype: Optional[dtype] = ..., order: str = ... +) -> ndarray[_T]: ... def full_like( a: _ArrayLike, - fill_value: T, - dtype: Optional[dtype] = None, - order: str = "K", - subok: bool = True, - shape: Optional[_ShapeLike] = None, -) -> ndarray[T]: ... + fill_value: _T, + dtype: Optional[dtype] = ..., + order: str = ..., + subok: bool = ..., + shape: Optional[_ShapeLike] = ..., +) -> ndarray[_T]: ... def count_nonzero( - a: _ArrayLike, axis: Optional[Union[int, Tuple[int], Tuple[int, int]]] = None + a: _ArrayLike, axis: Optional[Union[int, Tuple[int], Tuple[int, int]]] = ... ) -> Union[int, ndarray[int]]: ... def isfortran(a: ndarray) -> bool: ... def argwhere(a: _ArrayLike) -> ndarray: ... def flatnonzero(a: _ArrayLike) -> ndarray: ... -def correlate(a: _ArrayLike, v: _ArrayLike, mode: str = "valid") -> ndarray: ... -def convolve(a: _ArrayLike, v: _ArrayLike, mode: str = "full") -> ndarray: ... -def outer(a: _ArrayLike, b: _ArrayLike, out: ndarray = None) -> ndarray: ... +def correlate(a: _ArrayLike, v: _ArrayLike, mode: str = ...) -> ndarray: ... +def convolve(a: _ArrayLike, v: _ArrayLike, mode: str = ...) -> ndarray: ... +def outer(a: _ArrayLike, b: _ArrayLike, out: ndarray = ...) -> ndarray: ... def tensordot( a: _ArrayLike, b: _ArrayLike, axes: Union[ int, Tuple[int, int], Tuple[Tuple[int, int], ...], Tuple[List[int, int], ...] - ] = 2, + ] = ..., ) -> ndarray: ... def roll( a: _ArrayLike, shift: Union[int, Tuple[int, ...]], - axis: Optional[Union[int, Tuple[int, ...]]] = None, -) -> T: ... -def rollaxis(a: _ArrayLike, axis: int, start: int = 0) -> ndarray: ... + axis: Optional[Union[int, Tuple[int, ...]]] = ..., +) -> _T: ... +def rollaxis(a: _ArrayLike, axis: int, start: int = ...) -> ndarray: ... def normalize_axis_tuple( axis: Union[int, Iterable[int]], ndim: int, - argname: Optional[str] = None, - allow_duplicate: bool = False, + argname: Optional[str] = ..., + allow_duplicate: bool = ..., ) -> Tuple[int, ...]: ... def moveaxis( a: ndarray, @@ -79,32 +79,32 @@ def moveaxis( def cross( a: _ArrayLike, b: _ArrayLike, - axisa: int = -1, - axisb: int = -1, - axisc: int = -1, - axis: Optional[int] = None, + axisa: int = ..., + axisb: int = ..., + axisc: int = ..., + axis: Optional[int] = ..., ) -> ndarray: ... def indices( - dimensions: Sequence[int], dtype: dtype = int, sparse: bool = False + dimensions: Sequence[int], dtype: dtype = ..., sparse: bool = ... ) -> Union[ndarray, Tuple[ndarray, ...]]: ... def fromfunction(function: Callable, shape: Tuple[int, int], **kwargs) -> Any: ... def isscalar(element: Any) -> bool: ... -def binary_repr(num: int, width: Optional[int] = None) -> str: ... -def base_repr(number: int, base: int = 2, padding: int = 0) -> str: ... -def identity(n: int, dtype: Optional[dtype] = None) -> ndarray: ... +def binary_repr(num: int, width: Optional[int] = ...) -> str: ... +def base_repr(number: int, base: int = ..., padding: int = ...) -> str: ... +def identity(n: int, dtype: Optional[dtype] = ...) -> ndarray: ... def allclose( a: _ArrayLike, b: _ArrayLike, - rtol: float = 1.0e-5, - atol: float = 1.0e-8, - equal_nan: bool = False, + rtol: float = ..., + atol: float = ..., + equal_nan: bool = ..., ) -> bool: ... def isclose( a: _ArrayLike, b: _ArrayLike, - rtol: float = 1.0e-5, - atol: float = 1.0e-8, - equal_nan: bool = False, + rtol: float = ..., + atol: float = ..., + equal_nan: bool = ..., ) -> _ArrayLike: ... def array_equal(a1: _ArrayLike, a2: _ArrayLike) -> bool: ... def array_equiv(a1: _ArrayLike, a2: _ArrayLike) -> bool: ... From 015f47bada8be38a6a5748cf514ee6fdc7f0c218 Mon Sep 17 00:00:00 2001 From: Johan Vergeer Date: Sun, 24 Nov 2019 21:05:23 +0100 Subject: [PATCH 5/6] Add core/numerictypes.pyi --- numpy-stubs/core/numerictypes.pyi | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 numpy-stubs/core/numerictypes.pyi diff --git a/numpy-stubs/core/numerictypes.pyi b/numpy-stubs/core/numerictypes.pyi new file mode 100644 index 0000000..be01533 --- /dev/null +++ b/numpy-stubs/core/numerictypes.pyi @@ -0,0 +1,20 @@ +from typing import Any, Optional, Union, Tuple, List + +from numpy import dtype + +def maximum_sctype(t: dtype) -> dtype: ... +def issctype(rep: Any) -> bool: ... +def obj2sctype(rep: Any, default: Optional[Any] = ...) -> type: ... +def issubclass_( + arg1: type, arg2: Union[type, Tuple[Union[type, Tuple], ...]] +) -> bool: ... +def issubsctype( + arg1: type, arg2: Union[type, Tuple[Union[type, Tuple], ...]] +) -> bool: ... +def issubdtype( + arg1: Union[object, type], arg2: Union[type, Tuple[Union[type, Tuple], ...]] +) -> bool: ... +def sctype2char(sctype: Any) -> str: ... +def find_common_type( + array_types: Union[dtype, List[dtype]], scalar_types: Union[dtype, List[dtype]] +) -> dtype: ... From b5272fb7d4c497fb5a24119b38277f844d6fb3f4 Mon Sep 17 00:00:00 2001 From: Johan Vergeer Date: Thu, 28 Nov 2019 08:30:37 +0100 Subject: [PATCH 6/6] Make _ArrayLike TypeVar a lot simpler since an array_like can be just about anything. --- numpy-stubs/__init__.pyi | 13 +------------ 1 file changed, 1 insertion(+), 12 deletions(-) diff --git a/numpy-stubs/__init__.pyi b/numpy-stubs/__init__.pyi index 3f86e76..f7d0c70 100644 --- a/numpy-stubs/__init__.pyi +++ b/numpy-stubs/__init__.pyi @@ -83,18 +83,7 @@ _DtypeLike = Union[ _NdArraySubClass = TypeVar("_NdArraySubClass", bound=ndarray) -_ArrayLike = TypeVar( - "_ArrayLike", - str, - int, - float, - bool, - object, - ByteString, - Iterable, - Container, - ndarray, -) +_ArrayLike = TypeVar("_ArrayLike") class dtype: names: Optional[Tuple[str, ...]]