| import sys | |
| import ast | |
| import types | |
| import warnings | |
| import unittest | |
| from _typeshed import GenericPath, StrOrBytesPath, StrPath | |
| from collections.abc import Callable, Iterable, Sequence | |
| from contextlib import _GeneratorContextManager | |
| from re import Pattern | |
| from typing import ( | |
| Literal as L, | |
| Any, | |
| AnyStr, | |
| ClassVar, | |
| NoReturn, | |
| TypeAlias, | |
| overload, | |
| type_check_only, | |
| TypeVar, | |
| Final, | |
| SupportsIndex, | |
| ParamSpec | |
| ) | |
| import numpy as np | |
| from numpy import number, object_, _ConvertibleToFloat | |
| from numpy._typing import ( | |
| NDArray, | |
| ArrayLike, | |
| DTypeLike, | |
| _ArrayLikeNumber_co, | |
| _ArrayLikeObject_co, | |
| _ArrayLikeTD64_co, | |
| _ArrayLikeDT64_co, | |
| ) | |
| from unittest.case import SkipTest | |
| __all__ = [ | |
| "IS_EDITABLE", | |
| "IS_MUSL", | |
| "IS_PYPY", | |
| "IS_PYSTON", | |
| "IS_WASM", | |
| "HAS_LAPACK64", | |
| "HAS_REFCOUNT", | |
| "NOGIL_BUILD", | |
| "assert_", | |
| "assert_array_almost_equal_nulp", | |
| "assert_raises_regex", | |
| "assert_array_max_ulp", | |
| "assert_warns", | |
| "assert_no_warnings", | |
| "assert_allclose", | |
| "assert_equal", | |
| "assert_almost_equal", | |
| "assert_approx_equal", | |
| "assert_array_equal", | |
| "assert_array_less", | |
| "assert_string_equal", | |
| "assert_array_almost_equal", | |
| "assert_raises", | |
| "build_err_msg", | |
| "decorate_methods", | |
| "jiffies", | |
| "memusage", | |
| "print_assert_equal", | |
| "rundocs", | |
| "runstring", | |
| "verbose", | |
| "measure", | |
| "IgnoreException", | |
| "clear_and_catch_warnings", | |
| "SkipTest", | |
| "KnownFailureException", | |
| "temppath", | |
| "tempdir", | |
| "suppress_warnings", | |
| "assert_array_compare", | |
| "assert_no_gc_cycles", | |
| "break_cycles", | |
| "check_support_sve", | |
| "run_threaded", | |
| ] | |
| _P = ParamSpec("_P") | |
| _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: TypeAlias = Callable[ | |
| [NDArray[Any], NDArray[Any]], | |
| ( | |
| bool | |
| | np.bool | |
| | number[Any] | |
| | NDArray[np.bool | number[Any] | object_] | |
| ) | |
| ] | |
| class KnownFailureException(Exception): ... | |
| class IgnoreException(Exception): ... | |
| class clear_and_catch_warnings(warnings.catch_warnings[list[warnings.WarningMessage]]): | |
| 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: 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_EDITABLE: Final[bool] | |
| IS_MUSL: Final[bool] | |
| IS_PYPY: Final[bool] | |
| IS_PYSTON: Final[bool] | |
| IS_WASM: Final[bool] | |
| HAS_REFCOUNT: Final[bool] | |
| HAS_LAPACK64: Final[bool] | |
| NOGIL_BUILD: Final[bool] | |
| 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: StrOrBytesPath = ...) -> None | int: ... | |
| else: | |
| def memusage() -> NoReturn: ... | |
| if sys.platform == "linux": | |
| def jiffies( | |
| _proc_pid_stat: StrOrBytesPath = ..., | |
| _load_time: list[float] = ..., | |
| ) -> int: ... | |
| else: | |
| def jiffies(_load_time: list[float] = ...) -> int: ... | |
| def build_err_msg( | |
| 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: object = ..., | |
| verbose: bool = ..., | |
| *, | |
| strict: bool = ... | |
| ) -> None: ... | |
| def print_assert_equal( | |
| test_string: str, | |
| actual: object, | |
| desired: object, | |
| ) -> None: ... | |
| def assert_almost_equal( | |
| actual: _ArrayLikeNumber_co | _ArrayLikeObject_co, | |
| desired: _ArrayLikeNumber_co | _ArrayLikeObject_co, | |
| decimal: int = ..., | |
| err_msg: object = ..., | |
| verbose: bool = ..., | |
| ) -> None: ... | |
| # Anything that can be coerced into `builtins.float` | |
| def assert_approx_equal( | |
| actual: _ConvertibleToFloat, | |
| desired: _ConvertibleToFloat, | |
| significant: int = ..., | |
| err_msg: object = ..., | |
| verbose: bool = ..., | |
| ) -> None: ... | |
| def assert_array_compare( | |
| comparison: _ComparisonFunc, | |
| x: ArrayLike, | |
| y: ArrayLike, | |
| err_msg: object = ..., | |
| verbose: bool = ..., | |
| header: str = ..., | |
| precision: SupportsIndex = ..., | |
| equal_nan: bool = ..., | |
| equal_inf: bool = ..., | |
| *, | |
| strict: bool = ... | |
| ) -> None: ... | |
| def assert_array_equal( | |
| x: ArrayLike, | |
| y: ArrayLike, | |
| /, | |
| err_msg: object = ..., | |
| verbose: bool = ..., | |
| *, | |
| strict: bool = ... | |
| ) -> None: ... | |
| def assert_array_almost_equal( | |
| x: _ArrayLikeNumber_co | _ArrayLikeObject_co, | |
| y: _ArrayLikeNumber_co | _ArrayLikeObject_co, | |
| /, | |
| decimal: float = ..., | |
| err_msg: object = ..., | |
| verbose: bool = ..., | |
| ) -> None: ... | |
| @overload | |
| def assert_array_less( | |
| x: _ArrayLikeNumber_co | _ArrayLikeObject_co, | |
| y: _ArrayLikeNumber_co | _ArrayLikeObject_co, | |
| err_msg: object = ..., | |
| verbose: bool = ..., | |
| *, | |
| strict: bool = ... | |
| ) -> None: ... | |
| @overload | |
| def assert_array_less( | |
| x: _ArrayLikeTD64_co, | |
| y: _ArrayLikeTD64_co, | |
| err_msg: object = ..., | |
| verbose: bool = ..., | |
| *, | |
| strict: bool = ... | |
| ) -> None: ... | |
| @overload | |
| def assert_array_less( | |
| x: _ArrayLikeDT64_co, | |
| y: _ArrayLikeDT64_co, | |
| err_msg: object = ..., | |
| verbose: bool = ..., | |
| *, | |
| strict: 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: StrPath | None = ..., | |
| raise_on_error: bool = ..., | |
| ) -> None: ... | |
| def check_support_sve(__cache: list[_T]) -> _T: ... | |
| def raises(*args: type[BaseException]) -> Callable[[_FT], _FT]: ... | |
| @overload | |
| def assert_raises( # type: ignore | |
| expected_exception: type[BaseException] | tuple[type[BaseException], ...], | |
| callable: Callable[_P, Any], | |
| /, | |
| *args: _P.args, | |
| **kwargs: _P.kwargs, | |
| ) -> 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[_P, Any], | |
| /, | |
| *args: _P.args, | |
| **kwargs: _P.kwargs, | |
| ) -> 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: ... | |
| @overload | |
| def assert_allclose( | |
| actual: _ArrayLikeNumber_co | _ArrayLikeObject_co, | |
| desired: _ArrayLikeNumber_co | _ArrayLikeObject_co, | |
| rtol: float = ..., | |
| atol: float = ..., | |
| equal_nan: bool = ..., | |
| err_msg: object = ..., | |
| verbose: bool = ..., | |
| *, | |
| strict: bool = ... | |
| ) -> None: ... | |
| @overload | |
| def assert_allclose( | |
| actual: _ArrayLikeTD64_co, | |
| desired: _ArrayLikeTD64_co, | |
| rtol: float = ..., | |
| atol: float = ..., | |
| equal_nan: bool = ..., | |
| err_msg: object = ..., | |
| verbose: bool = ..., | |
| *, | |
| strict: bool = ... | |
| ) -> None: ... | |
| def assert_array_almost_equal_nulp( | |
| x: _ArrayLikeNumber_co, | |
| y: _ArrayLikeNumber_co, | |
| nulp: float = ..., | |
| ) -> None: ... | |
| def assert_array_max_ulp( | |
| a: _ArrayLikeNumber_co, | |
| b: _ArrayLikeNumber_co, | |
| maxulp: float = ..., | |
| dtype: DTypeLike = ..., | |
| ) -> NDArray[Any]: ... | |
| @overload | |
| def assert_warns(warning_class: type[Warning]) -> _GeneratorContextManager[None]: ... | |
| @overload | |
| def assert_warns( | |
| warning_class: type[Warning], | |
| func: Callable[_P, _T], | |
| /, | |
| *args: _P.args, | |
| **kwargs: _P.kwargs, | |
| ) -> _T: ... | |
| @overload | |
| def assert_no_warnings() -> _GeneratorContextManager[None]: ... | |
| @overload | |
| def assert_no_warnings( | |
| func: Callable[_P, _T], | |
| /, | |
| *args: _P.args, | |
| **kwargs: _P.kwargs, | |
| ) -> _T: ... | |
| @overload | |
| def tempdir( | |
| suffix: None = ..., | |
| prefix: None = ..., | |
| dir: None = ..., | |
| ) -> _GeneratorContextManager[str]: ... | |
| @overload | |
| def tempdir( | |
| suffix: AnyStr | None = ..., | |
| prefix: AnyStr | None = ..., | |
| dir: GenericPath[AnyStr] | None = ..., | |
| ) -> _GeneratorContextManager[AnyStr]: ... | |
| @overload | |
| def temppath( | |
| suffix: None = ..., | |
| prefix: None = ..., | |
| dir: None = ..., | |
| text: bool = ..., | |
| ) -> _GeneratorContextManager[str]: ... | |
| @overload | |
| def temppath( | |
| suffix: AnyStr | None = ..., | |
| prefix: AnyStr | None = ..., | |
| dir: GenericPath[AnyStr] | None = ..., | |
| text: bool = ..., | |
| ) -> _GeneratorContextManager[AnyStr]: ... | |
| @overload | |
| def assert_no_gc_cycles() -> _GeneratorContextManager[None]: ... | |
| @overload | |
| def assert_no_gc_cycles( | |
| func: Callable[_P, Any], | |
| /, | |
| *args: _P.args, | |
| **kwargs: _P.kwargs, | |
| ) -> None: ... | |
| def break_cycles() -> None: ... | |
| def run_threaded(func: Callable[[], None], iters: int, pass_count: bool = False) -> None: ... | |