From 4340579c303669fa1b2ba70f3c9c875ab6de6d05 Mon Sep 17 00:00:00 2001 From: Bas van Beek Date: Wed, 2 Jun 2021 00:31:52 +0200 Subject: MAINT: Move the `np.testing` annotations to `np.testing._private.utils` --- numpy/testing/__init__.pyi | 143 +++++++++++---------------------------- numpy/testing/_private/utils.pyi | 107 +++++++++++++++++++++++++++++ 2 files changed, 148 insertions(+), 102 deletions(-) create mode 100644 numpy/testing/_private/utils.pyi (limited to 'numpy/testing') diff --git a/numpy/testing/__init__.pyi b/numpy/testing/__init__.pyi index 395626f6b..ae2b14b45 100644 --- a/numpy/testing/__init__.pyi +++ b/numpy/testing/__init__.pyi @@ -1,113 +1,52 @@ -import sys -import warnings -from typing import Any, List, ClassVar, Tuple, Set - -if sys.version_info >= (3, 8): - from typing import Final -else: - from typing_extensions import Final +from typing import List from unittest import ( TestCase as TestCase, ) -from unittest.case import ( +from numpy.testing._private.utils import ( + assert_equal as assert_equal, + assert_almost_equal as assert_almost_equal, + assert_approx_equal as assert_approx_equal, + assert_array_equal as assert_array_equal, + assert_array_less as assert_array_less, + assert_string_equal as assert_string_equal, + assert_array_almost_equal as assert_array_almost_equal, + assert_raises as assert_raises, + build_err_msg as build_err_msg, + decorate_methods as decorate_methods, + jiffies as jiffies, + memusage as memusage, + print_assert_equal as print_assert_equal, + raises as raises, + rundocs as rundocs, + runstring as runstring, + verbose as verbose, + measure as measure, + assert_ as assert_, + assert_array_almost_equal_nulp as assert_array_almost_equal_nulp, + assert_raises_regex as assert_raises_regex, + assert_array_max_ulp as assert_array_max_ulp, + assert_warns as assert_warns, + assert_no_warnings as assert_no_warnings, + assert_allclose as assert_allclose, + IgnoreException as IgnoreException, + clear_and_catch_warnings as clear_and_catch_warnings, SkipTest as SkipTest, + KnownFailureException as KnownFailureException, + temppath as temppath, + tempdir as tempdir, + IS_PYPY as IS_PYPY, + HAS_REFCOUNT as HAS_REFCOUNT, + suppress_warnings as suppress_warnings, + assert_array_compare as assert_array_compare, + _assert_valid_refcount as _assert_valid_refcount, + _gen_alignment_data as _gen_alignment_data, + assert_no_gc_cycles as assert_no_gc_cycles, + break_cycles as break_cycles, + HAS_LAPACK64 as HAS_LAPACK64, ) __all__: List[str] def run_module_suite(file_to_run=..., argv=...): ... - -class KnownFailureException(Exception): ... -class IgnoreException(Exception): ... - -class clear_and_catch_warnings(warnings.catch_warnings): - class_modules: ClassVar[Tuple[str, ...]] - modules: Set[str] - def __init__(self, record=..., modules=...): ... - def __enter__(self): ... - def __exit__(self, *exc_info): ... - -class suppress_warnings: - log: List[warnings.WarningMessage] - def __init__(self, forwarding_rule=...): ... - def filter(self, category=..., message=..., module=...): ... - def record(self, category=..., message=..., module=...): ... - def __enter__(self): ... - def __exit__(self, *exc_info): ... - def __call__(self, func): ... - -verbose: int -IS_PYPY: Final[bool] -HAS_REFCOUNT: Final[bool] -HAS_LAPACK64: Final[bool] - -def assert_(val, msg=...): ... -def memusage(processName=..., instance=...): ... -def jiffies(_proc_pid_stat=..., _load_time=...): ... -def build_err_msg( - arrays, - err_msg, - header=..., - verbose=..., - names=..., - precision=..., -): ... -def assert_equal(actual, desired, err_msg=..., verbose=...): ... -def print_assert_equal(test_string, actual, desired): ... -def assert_almost_equal( - actual, - desired, - decimal=..., - err_msg=..., - verbose=..., -): ... -def assert_approx_equal( - actual, - desired, - significant=..., - err_msg=..., - verbose=..., -): ... -def assert_array_compare( - comparison, - x, - y, - err_msg=..., - verbose=..., - header=..., - precision=..., - equal_nan=..., - equal_inf=..., -): ... -def assert_array_equal(x, y, err_msg=..., verbose=...): ... -def assert_array_almost_equal(x, y, decimal=..., err_msg=..., verbose=...): ... -def assert_array_less(x, y, err_msg=..., verbose=...): ... -def runstring(astr, dict): ... -def assert_string_equal(actual, desired): ... -def rundocs(filename=..., raise_on_error=...): ... -def raises(*args): ... -def assert_raises(*args, **kwargs): ... -def assert_raises_regex(exception_class, expected_regexp, *args, **kwargs): ... -def decorate_methods(cls, decorator, testmatch=...): ... -def measure(code_str, times=..., label=...): ... -def assert_allclose( - actual, - desired, - rtol=..., - atol=..., - equal_nan=..., - err_msg=..., - verbose=..., -): ... -def assert_array_almost_equal_nulp(x, y, nulp=...): ... -def assert_array_max_ulp(a, b, maxulp=..., dtype=...): ... -def assert_warns(warning_class, *args, **kwargs): ... -def assert_no_warnings(*args, **kwargs): ... -def tempdir(*args, **kwargs): ... -def temppath(*args, **kwargs): ... -def assert_no_gc_cycles(*args, **kwargs): ... -def break_cycles(): ... -def _assert_valid_refcount(op): ... -def _gen_alignment_data(dtype=..., type=..., max_size=...): ... diff --git a/numpy/testing/_private/utils.pyi b/numpy/testing/_private/utils.pyi new file mode 100644 index 000000000..efb6bcd91 --- /dev/null +++ b/numpy/testing/_private/utils.pyi @@ -0,0 +1,107 @@ +import sys +import warnings +from typing import Any, List, ClassVar, Tuple, Set + +if sys.version_info >= (3, 8): + from typing import Final +else: + from typing_extensions import Final + +from unittest.case import ( + SkipTest as SkipTest, +) + +__all__: List[str] + +class KnownFailureException(Exception): ... +class IgnoreException(Exception): ... + +class clear_and_catch_warnings(warnings.catch_warnings): + class_modules: ClassVar[Tuple[str, ...]] + modules: Set[str] + def __init__(self, record=..., modules=...): ... + def __enter__(self): ... + def __exit__(self, *exc_info): ... + +class suppress_warnings: + log: List[warnings.WarningMessage] + def __init__(self, forwarding_rule=...): ... + def filter(self, category=..., message=..., module=...): ... + def record(self, category=..., message=..., module=...): ... + def __enter__(self): ... + def __exit__(self, *exc_info): ... + def __call__(self, func): ... + +verbose: int +IS_PYPY: Final[bool] +HAS_REFCOUNT: Final[bool] +HAS_LAPACK64: Final[bool] + +def assert_(val, msg=...): ... +def memusage(processName=..., instance=...): ... +def jiffies(_proc_pid_stat=..., _load_time=...): ... +def build_err_msg( + arrays, + err_msg, + header=..., + verbose=..., + names=..., + precision=..., +): ... +def assert_equal(actual, desired, err_msg=..., verbose=...): ... +def print_assert_equal(test_string, actual, desired): ... +def assert_almost_equal( + actual, + desired, + decimal=..., + err_msg=..., + verbose=..., +): ... +def assert_approx_equal( + actual, + desired, + significant=..., + err_msg=..., + verbose=..., +): ... +def assert_array_compare( + comparison, + x, + y, + err_msg=..., + verbose=..., + header=..., + precision=..., + equal_nan=..., + equal_inf=..., +): ... +def assert_array_equal(x, y, err_msg=..., verbose=...): ... +def assert_array_almost_equal(x, y, decimal=..., err_msg=..., verbose=...): ... +def assert_array_less(x, y, err_msg=..., verbose=...): ... +def runstring(astr, dict): ... +def assert_string_equal(actual, desired): ... +def rundocs(filename=..., raise_on_error=...): ... +def raises(*args): ... +def assert_raises(*args, **kwargs): ... +def assert_raises_regex(exception_class, expected_regexp, *args, **kwargs): ... +def decorate_methods(cls, decorator, testmatch=...): ... +def measure(code_str, times=..., label=...): ... +def assert_allclose( + actual, + desired, + rtol=..., + atol=..., + equal_nan=..., + err_msg=..., + verbose=..., +): ... +def assert_array_almost_equal_nulp(x, y, nulp=...): ... +def assert_array_max_ulp(a, b, maxulp=..., dtype=...): ... +def assert_warns(warning_class, *args, **kwargs): ... +def assert_no_warnings(*args, **kwargs): ... +def tempdir(*args, **kwargs): ... +def temppath(*args, **kwargs): ... +def assert_no_gc_cycles(*args, **kwargs): ... +def break_cycles(): ... +def _assert_valid_refcount(op): ... +def _gen_alignment_data(dtype=..., type=..., max_size=...): ... -- cgit v1.2.1 From 22412b3f46451177286f8fc58509a69bb2d95731 Mon Sep 17 00:00:00 2001 From: Bas van Beek <43369155+BvB93@users.noreply.github.com> Date: Sun, 6 Jun 2021 17:05:48 +0200 Subject: BLD: Add support for *.pyi data-files to `np.testing._private` --- numpy/testing/setup.py | 1 + 1 file changed, 1 insertion(+) (limited to 'numpy/testing') diff --git a/numpy/testing/setup.py b/numpy/testing/setup.py index 7652a94a2..6f203e872 100755 --- a/numpy/testing/setup.py +++ b/numpy/testing/setup.py @@ -7,6 +7,7 @@ def configuration(parent_package='',top_path=None): config.add_subpackage('_private') config.add_subpackage('tests') config.add_data_files('*.pyi') + config.add_data_files('_private/*.pyi') return config if __name__ == '__main__': -- cgit v1.2.1 From 3c8e5da46c1440ea0eb3fe66fdc897d3fbae194d Mon Sep 17 00:00:00 2001 From: Bas van Beek Date: Wed, 2 Jun 2021 02:58:09 +0200 Subject: MAINT: Remove two private functions from `__all__` --- numpy/testing/__init__.py | 1 + numpy/testing/__init__.pyi | 2 -- numpy/testing/_private/utils.py | 4 +--- numpy/testing/utils.py | 3 ++- 4 files changed, 4 insertions(+), 6 deletions(-) (limited to 'numpy/testing') diff --git a/numpy/testing/__init__.py b/numpy/testing/__init__.py index e1f87621f..064a74a16 100644 --- a/numpy/testing/__init__.py +++ b/numpy/testing/__init__.py @@ -8,6 +8,7 @@ away. from unittest import TestCase from ._private.utils import * +from ._private.utils import _assert_valid_refcount, _gen_alignment_data from ._private import decorators as dec from ._private.nosetester import ( run_module_suite, NoseTester as Tester diff --git a/numpy/testing/__init__.pyi b/numpy/testing/__init__.pyi index ae2b14b45..f40c06e9a 100644 --- a/numpy/testing/__init__.pyi +++ b/numpy/testing/__init__.pyi @@ -40,8 +40,6 @@ from numpy.testing._private.utils import ( HAS_REFCOUNT as HAS_REFCOUNT, suppress_warnings as suppress_warnings, assert_array_compare as assert_array_compare, - _assert_valid_refcount as _assert_valid_refcount, - _gen_alignment_data as _gen_alignment_data, assert_no_gc_cycles as assert_no_gc_cycles, break_cycles as break_cycles, HAS_LAPACK64 as HAS_LAPACK64, diff --git a/numpy/testing/_private/utils.py b/numpy/testing/_private/utils.py index 393fedc27..487aa0b4c 100644 --- a/numpy/testing/_private/utils.py +++ b/numpy/testing/_private/utils.py @@ -35,8 +35,7 @@ __all__ = [ 'assert_allclose', 'IgnoreException', 'clear_and_catch_warnings', 'SkipTest', 'KnownFailureException', 'temppath', 'tempdir', 'IS_PYPY', 'HAS_REFCOUNT', 'suppress_warnings', 'assert_array_compare', - '_assert_valid_refcount', '_gen_alignment_data', 'assert_no_gc_cycles', - 'break_cycles', 'HAS_LAPACK64' + 'assert_no_gc_cycles', 'break_cycles', 'HAS_LAPACK64' ] @@ -2518,4 +2517,3 @@ def _no_tracing(func): finally: sys.settrace(original_trace) return wrapper - diff --git a/numpy/testing/utils.py b/numpy/testing/utils.py index 753258c13..20a883304 100644 --- a/numpy/testing/utils.py +++ b/numpy/testing/utils.py @@ -12,6 +12,7 @@ warnings.warn("Importing from numpy.testing.utils is deprecated " DeprecationWarning, stacklevel=2) from ._private.utils import * +from ._private.utils import _assert_valid_refcount, _gen_alignment_data __all__ = [ 'assert_equal', 'assert_almost_equal', 'assert_approx_equal', @@ -24,5 +25,5 @@ __all__ = [ 'assert_allclose', 'IgnoreException', 'clear_and_catch_warnings', 'SkipTest', 'KnownFailureException', 'temppath', 'tempdir', 'IS_PYPY', 'HAS_REFCOUNT', 'suppress_warnings', 'assert_array_compare', - '_assert_valid_refcount', '_gen_alignment_data', 'assert_no_gc_cycles' + 'assert_no_gc_cycles' ] -- cgit v1.2.1 From 085ccdc4876f08b742fcf1fdf79274c24c649e92 Mon Sep 17 00:00:00 2001 From: Bas van Beek Date: Wed, 2 Jun 2021 02:58:54 +0200 Subject: ENH: Add annotations for `np.testing` --- numpy/testing/__init__.pyi | 5 +- numpy/testing/_private/utils.pyi | 412 +++++++++++++++++++++++++++++++-------- 2 files changed, 337 insertions(+), 80 deletions(-) (limited to 'numpy/testing') diff --git a/numpy/testing/__init__.pyi b/numpy/testing/__init__.pyi index f40c06e9a..955dae862 100644 --- a/numpy/testing/__init__.pyi +++ b/numpy/testing/__init__.pyi @@ -47,4 +47,7 @@ from numpy.testing._private.utils import ( __all__: List[str] -def run_module_suite(file_to_run=..., argv=...): ... +def run_module_suite( + file_to_run: None | str = ..., + argv: None | List[str] = ..., +) -> None: ... diff --git a/numpy/testing/_private/utils.pyi b/numpy/testing/_private/utils.pyi index efb6bcd91..a297b3379 100644 --- a/numpy/testing/_private/utils.pyi +++ b/numpy/testing/_private/utils.pyi @@ -1,107 +1,361 @@ +import os import sys +import ast +import types import warnings -from typing import Any, List, ClassVar, Tuple, Set +import unittest +import contextlib +from typing import ( + Any, + AnyStr, + Callable, + ClassVar, + Dict, + Iterable, + List, + NoReturn, + overload, + Pattern, + Sequence, + Set, + Tuple, + Type, + type_check_only, + TypeVar, + Union, +) -if sys.version_info >= (3, 8): - from typing import Final -else: - from typing_extensions import Final +from numpy import generic, dtype, number, object_, bool_ +from numpy.typing import NDArray, ArrayLike, DTypeLike from unittest.case import ( SkipTest as SkipTest, ) +if sys.version_info >= (3, 8): + from typing import Final, SupportsIndex, Literal as L +else: + from typing_extensions import Final, SupportsIndex, Literal as L + +_T = TypeVar("_T") +_ET = TypeVar("_ET", bound=BaseException) +_FT = TypeVar("_FT", bound=Callable[..., Any]) + +# Must return a bool or an ndarray/generic type +# that is supported by `np.logical_and.reduce` +_ComparisonFunc = Callable[ + [NDArray[Any], NDArray[Any]], + Union[ + bool, + bool_, + number[Any], + NDArray[Union[bool_, number[Any], object_]], + ], +] + __all__: List[str] class KnownFailureException(Exception): ... class IgnoreException(Exception): ... class clear_and_catch_warnings(warnings.catch_warnings): - class_modules: ClassVar[Tuple[str, ...]] - modules: Set[str] - def __init__(self, record=..., modules=...): ... - def __enter__(self): ... - def __exit__(self, *exc_info): ... + class_modules: ClassVar[Tuple[types.ModuleType, ...]] + modules: Set[types.ModuleType] + @overload + def __new__( + cls, + record: L[False] = ..., + modules: Iterable[types.ModuleType] = ..., + ) -> _clear_and_catch_warnings_without_records: ... + @overload + def __new__( + cls, + record: L[True], + modules: Iterable[types.ModuleType] = ..., + ) -> _clear_and_catch_warnings_with_records: ... + @overload + def __new__( + cls, + record: bool, + modules: Iterable[types.ModuleType] = ..., + ) -> clear_and_catch_warnings: ... + def __enter__(self) -> None | List[warnings.WarningMessage]: ... + def __exit__( + self, + __exc_type: None | Type[BaseException] = ..., + __exc_val: None | BaseException = ..., + __exc_tb: None | types.TracebackType = ..., + ) -> None: ... + +# Type-check only `clear_and_catch_warnings` subclasses for both values of the +# `record` parameter. Copied from the stdlib `warnings` stubs. + +@type_check_only +class _clear_and_catch_warnings_with_records(clear_and_catch_warnings): + def __enter__(self) -> List[warnings.WarningMessage]: ... + +@type_check_only +class _clear_and_catch_warnings_without_records(clear_and_catch_warnings): + def __enter__(self) -> None: ... class suppress_warnings: log: List[warnings.WarningMessage] - def __init__(self, forwarding_rule=...): ... - def filter(self, category=..., message=..., module=...): ... - def record(self, category=..., message=..., module=...): ... - def __enter__(self): ... - def __exit__(self, *exc_info): ... - def __call__(self, func): ... + def __init__( + self, + forwarding_rule: L["always", "module", "once", "location"] = ..., + ) -> None: ... + def filter( + self, + category: Type[Warning] = ..., + message: str = ..., + module: None | types.ModuleType = ..., + ) -> None: ... + def record( + self, + category: Type[Warning] = ..., + message: str = ..., + module: None | types.ModuleType = ..., + ) -> List[warnings.WarningMessage]: ... + def __enter__(self: _T) -> _T: ... + def __exit__( + self, + __exc_type: None | Type[BaseException] = ..., + __exc_val: None | BaseException = ..., + __exc_tb: None | types.TracebackType = ..., + ) -> None: ... + def __call__(self, func: _FT) -> _FT: ... verbose: int IS_PYPY: Final[bool] HAS_REFCOUNT: Final[bool] HAS_LAPACK64: Final[bool] -def assert_(val, msg=...): ... -def memusage(processName=..., instance=...): ... -def jiffies(_proc_pid_stat=..., _load_time=...): ... +def assert_(val: object, msg: str | Callable[[], str] = ...) -> None: ... + +# Contrary to runtime we can't do `os.name` checks while type checking, +# only `sys.platform` checks +if sys.platform == "win32" or sys.platform == "cygwin": + def memusage(processName: str = ..., instance: int = ...) -> int: ... +elif sys.platform == "linux": + def memusage(_proc_pid_stat: str | bytes | os.PathLike[Any] = ...) -> None | int: ... +else: + def memusage() -> NoReturn: ... + +if sys.platform == "linux": + def jiffies( + _proc_pid_stat: str | bytes | os.PathLike[Any] = ..., + _load_time: List[float] = ..., + ) -> int: ... +else: + def jiffies(_load_time: List[float] = ...) -> int: ... + def build_err_msg( - arrays, - err_msg, - header=..., - verbose=..., - names=..., - precision=..., -): ... -def assert_equal(actual, desired, err_msg=..., verbose=...): ... -def print_assert_equal(test_string, actual, desired): ... + arrays: Iterable[object], + err_msg: str, + header: str = ..., + verbose: bool = ..., + names: Sequence[str] = ..., + precision: None | SupportsIndex = ..., +) -> str: ... + +def assert_equal( + actual: object, + desired: object, + err_msg: str = ..., + verbose: bool = ..., +) -> None: ... + +def print_assert_equal( + test_string: str, + actual: object, + desired: object, +) -> None: ... + def assert_almost_equal( - actual, - desired, - decimal=..., - err_msg=..., - verbose=..., -): ... + actual: ArrayLike, + desired: ArrayLike, + decimal: int = ..., + err_msg: str = ..., + verbose: bool = ..., +) -> None: ... + def assert_approx_equal( - actual, - desired, - significant=..., - err_msg=..., - verbose=..., -): ... + actual: ArrayLike, + desired: ArrayLike, + significant: int = ..., + err_msg: str = ..., + verbose: bool = ..., +) -> None: ... + def assert_array_compare( - comparison, - x, - y, - err_msg=..., - verbose=..., - header=..., - precision=..., - equal_nan=..., - equal_inf=..., -): ... -def assert_array_equal(x, y, err_msg=..., verbose=...): ... -def assert_array_almost_equal(x, y, decimal=..., err_msg=..., verbose=...): ... -def assert_array_less(x, y, err_msg=..., verbose=...): ... -def runstring(astr, dict): ... -def assert_string_equal(actual, desired): ... -def rundocs(filename=..., raise_on_error=...): ... -def raises(*args): ... -def assert_raises(*args, **kwargs): ... -def assert_raises_regex(exception_class, expected_regexp, *args, **kwargs): ... -def decorate_methods(cls, decorator, testmatch=...): ... -def measure(code_str, times=..., label=...): ... + comparison: _ComparisonFunc, + x: ArrayLike, + y: ArrayLike, + err_msg: str = ..., + verbose: bool = ..., + header: str = ..., + precision: SupportsIndex = ..., + equal_nan: bool = ..., + equal_inf: bool = ..., +) -> None: ... + +def assert_array_equal( + x: ArrayLike, + y: ArrayLike, + err_msg: str = ..., + verbose: bool = ..., +) -> None: ... + +def assert_array_almost_equal( + x: ArrayLike, + y: ArrayLike, + decimal: int = ..., + err_msg: str = ..., + verbose: bool = ..., +) -> None: ... + +def assert_array_less( + x: ArrayLike, + y: ArrayLike, + err_msg: str = ..., + verbose: bool = ..., +) -> None: ... + +def runstring( + astr: str | bytes | types.CodeType, + dict: None | Dict[str, Any], +) -> Any: ... + +def assert_string_equal(actual: str, desired: str) -> None: ... + +def rundocs( + filename: None | str | os.PathLike[str] = ..., + raise_on_error: bool = ..., +) -> None: ... + +def raises(*args: Type[BaseException]) -> Callable[[_FT], _FT]: ... + +@overload +def assert_raises( # type: ignore + __expected_exception: Type[BaseException] | Tuple[Type[BaseException], ...], + __callable: Callable[..., Any], + *args: Any, + **kwargs: Any, +) -> None: ... +@overload +def assert_raises( + expected_exception: Type[_ET] | Tuple[Type[_ET], ...], + *, + msg: None | str = ..., +) -> unittest.case._AssertRaisesContext[_ET]: ... + +@overload +def assert_raises_regex( + __expected_exception: Type[BaseException] | Tuple[Type[BaseException], ...], + __expected_regex: str | bytes | Pattern[Any], + __callable: Callable[..., Any], + *args: Any, + **kwargs: Any, +) -> None: ... +@overload +def assert_raises_regex( + expected_exception: Type[_ET] | Tuple[Type[_ET], ...], + expected_regex: str | bytes | Pattern[Any], + *, + msg: None | str = ..., +) -> unittest.case._AssertRaisesContext[_ET]: ... + +def decorate_methods( + cls: Type[Any], + decorator: Callable[[Callable[..., Any]], Any], + testmatch: None | str | bytes | Pattern[Any] = ..., +) -> None: ... + +def measure( + code_str: str | bytes | ast.mod | ast.AST, + times: int = ..., + label: None | str = ..., +) -> float: ... + def assert_allclose( - actual, - desired, - rtol=..., - atol=..., - equal_nan=..., - err_msg=..., - verbose=..., -): ... -def assert_array_almost_equal_nulp(x, y, nulp=...): ... -def assert_array_max_ulp(a, b, maxulp=..., dtype=...): ... -def assert_warns(warning_class, *args, **kwargs): ... -def assert_no_warnings(*args, **kwargs): ... -def tempdir(*args, **kwargs): ... -def temppath(*args, **kwargs): ... -def assert_no_gc_cycles(*args, **kwargs): ... -def break_cycles(): ... -def _assert_valid_refcount(op): ... -def _gen_alignment_data(dtype=..., type=..., max_size=...): ... + actual: ArrayLike, + desired: ArrayLike, + rtol: float = ..., + atol: float = ..., + equal_nan: bool = ..., + err_msg: str = ..., + verbose: bool = ..., +) -> None: ... + +def assert_array_almost_equal_nulp( + x: ArrayLike, + y: ArrayLike, + nulp: float = ..., +) -> None: ... + +def assert_array_max_ulp( + a: ArrayLike, + b: ArrayLike, + maxulp: float = ..., + dtype: DTypeLike = ..., +) -> NDArray[Any]: ... + +@overload +def assert_warns( + warning_class: Type[Warning], +) -> contextlib._GeneratorContextManager[None]: ... +@overload +def assert_warns( + __warning_class: Type[Warning], + __func: Callable[..., _T], + *args: Any, + **kwargs: Any, +) -> _T: ... + +@overload +def assert_no_warnings() -> contextlib._GeneratorContextManager[None]: ... +@overload +def assert_no_warnings( + __func: Callable[..., _T], + *args: Any, + **kwargs: Any, +) -> _T: ... + +@overload +def tempdir( + suffix: None = ..., + prefix: None = ..., + dir: None = ..., +) -> contextlib._GeneratorContextManager[str]: ... +@overload +def tempdir( + suffix: None | AnyStr = ..., + prefix: None | AnyStr = ..., + dir: None | AnyStr | os.PathLike[AnyStr] = ..., +) -> contextlib._GeneratorContextManager[AnyStr]: ... + +@overload +def temppath( + suffix: None = ..., + prefix: None = ..., + dir: None = ..., + text: bool = ..., +) -> contextlib._GeneratorContextManager[str]: ... +@overload +def temppath( + suffix: None | AnyStr = ..., + prefix: None | AnyStr = ..., + dir: None | AnyStr | os.PathLike[AnyStr] = ..., + text: bool = ..., +) -> contextlib._GeneratorContextManager[AnyStr]: ... + +@overload +def assert_no_gc_cycles() -> contextlib._GeneratorContextManager[None]: ... +@overload +def assert_no_gc_cycles( + __func: Callable[..., Any], + *args: Any, + **kwargs: Any, +) -> None: ... + +def break_cycles() -> None: ... -- cgit v1.2.1 From 061f8fe36414f3861cde99c0806fcaca77a5d161 Mon Sep 17 00:00:00 2001 From: Bas van Beek <43369155+BvB93@users.noreply.github.com> Date: Sun, 6 Jun 2021 17:37:00 +0200 Subject: ENH: Add dtype support to `np.testing` --- numpy/testing/_private/utils.pyi | 69 ++++++++++++++++++++++++++++++---------- 1 file changed, 52 insertions(+), 17 deletions(-) (limited to 'numpy/testing') diff --git a/numpy/testing/_private/utils.pyi b/numpy/testing/_private/utils.pyi index a297b3379..29915309f 100644 --- a/numpy/testing/_private/utils.pyi +++ b/numpy/testing/_private/utils.pyi @@ -25,8 +25,16 @@ from typing import ( Union, ) -from numpy import generic, dtype, number, object_, bool_ -from numpy.typing import NDArray, ArrayLike, DTypeLike +from numpy import generic, dtype, number, object_, bool_, _FloatValue +from numpy.typing import ( + NDArray, + ArrayLike, + DTypeLike, + _ArrayLikeNumber_co, + _ArrayLikeObject_co, + _ArrayLikeTD64_co, + _ArrayLikeDT64_co, +) from unittest.case import ( SkipTest as SkipTest, @@ -172,16 +180,17 @@ def print_assert_equal( ) -> None: ... def assert_almost_equal( - actual: ArrayLike, - desired: ArrayLike, + actual: _ArrayLikeNumber_co | _ArrayLikeObject_co, + desired: _ArrayLikeNumber_co | _ArrayLikeObject_co, decimal: int = ..., err_msg: str = ..., verbose: bool = ..., ) -> None: ... +# Anything that can be coerced into `builtins.float` def assert_approx_equal( - actual: ArrayLike, - desired: ArrayLike, + actual: _FloatValue, + desired: _FloatValue, significant: int = ..., err_msg: str = ..., verbose: bool = ..., @@ -207,16 +216,31 @@ def assert_array_equal( ) -> None: ... def assert_array_almost_equal( - x: ArrayLike, - y: ArrayLike, - decimal: int = ..., + x: _ArrayLikeNumber_co | _ArrayLikeObject_co, + y: _ArrayLikeNumber_co | _ArrayLikeObject_co, + decimal: float = ..., err_msg: str = ..., verbose: bool = ..., ) -> None: ... +@overload def assert_array_less( - x: ArrayLike, - y: ArrayLike, + x: _ArrayLikeNumber_co | _ArrayLikeObject_co, + y: _ArrayLikeNumber_co | _ArrayLikeObject_co, + err_msg: str = ..., + verbose: bool = ..., +) -> None: ... +@overload +def assert_array_less( + x: _ArrayLikeTD64_co, + y: _ArrayLikeTD64_co, + err_msg: str = ..., + verbose: bool = ..., +) -> None: ... +@overload +def assert_array_less( + x: _ArrayLikeDT64_co, + y: _ArrayLikeDT64_co, err_msg: str = ..., verbose: bool = ..., ) -> None: ... @@ -277,9 +301,20 @@ def measure( label: None | str = ..., ) -> float: ... +@overload +def assert_allclose( + actual: _ArrayLikeNumber_co | _ArrayLikeObject_co, + desired: _ArrayLikeNumber_co | _ArrayLikeObject_co, + rtol: float = ..., + atol: float = ..., + equal_nan: bool = ..., + err_msg: str = ..., + verbose: bool = ..., +) -> None: ... +@overload def assert_allclose( - actual: ArrayLike, - desired: ArrayLike, + actual: _ArrayLikeTD64_co, + desired: _ArrayLikeTD64_co, rtol: float = ..., atol: float = ..., equal_nan: bool = ..., @@ -288,14 +323,14 @@ def assert_allclose( ) -> None: ... def assert_array_almost_equal_nulp( - x: ArrayLike, - y: ArrayLike, + x: _ArrayLikeNumber_co, + y: _ArrayLikeNumber_co, nulp: float = ..., ) -> None: ... def assert_array_max_ulp( - a: ArrayLike, - b: ArrayLike, + a: _ArrayLikeNumber_co, + b: _ArrayLikeNumber_co, maxulp: float = ..., dtype: DTypeLike = ..., ) -> NDArray[Any]: ... -- cgit v1.2.1