497 lines
13 KiB
Python
497 lines
13 KiB
Python
import ast
|
|
import sys
|
|
import types
|
|
import unittest
|
|
import warnings
|
|
from collections.abc import Callable, Iterable, Sequence
|
|
from contextlib import _GeneratorContextManager
|
|
from pathlib import Path
|
|
from re import Pattern
|
|
from typing import (
|
|
Any,
|
|
AnyStr,
|
|
ClassVar,
|
|
Final,
|
|
Generic,
|
|
NoReturn,
|
|
SupportsIndex,
|
|
TypeAlias,
|
|
overload,
|
|
type_check_only,
|
|
)
|
|
from typing import Literal as L
|
|
from unittest.case import SkipTest
|
|
|
|
from _typeshed import ConvertibleToFloat, GenericPath, StrOrBytesPath, StrPath
|
|
from typing_extensions import ParamSpec, Self, TypeVar, TypeVarTuple, Unpack
|
|
|
|
import numpy as np
|
|
from numpy._typing import (
|
|
ArrayLike,
|
|
DTypeLike,
|
|
NDArray,
|
|
_ArrayLikeDT64_co,
|
|
_ArrayLikeNumber_co,
|
|
_ArrayLikeObject_co,
|
|
_ArrayLikeTD64_co,
|
|
)
|
|
|
|
__all__ = [ # noqa: RUF022
|
|
"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",
|
|
]
|
|
|
|
###
|
|
|
|
_T = TypeVar("_T")
|
|
_Ts = TypeVarTuple("_Ts")
|
|
_Tss = ParamSpec("_Tss")
|
|
_ET = TypeVar("_ET", bound=BaseException, default=BaseException)
|
|
_FT = TypeVar("_FT", bound=Callable[..., Any])
|
|
_W_co = TypeVar("_W_co", bound=_WarnLog | None, default=_WarnLog | None, covariant=True)
|
|
_T_or_bool = TypeVar("_T_or_bool", default=bool)
|
|
|
|
_StrLike: TypeAlias = str | bytes
|
|
_RegexLike: TypeAlias = _StrLike | Pattern[Any]
|
|
_NumericArrayLike: TypeAlias = _ArrayLikeNumber_co | _ArrayLikeObject_co
|
|
|
|
_ExceptionSpec: TypeAlias = type[_ET] | tuple[type[_ET], ...]
|
|
_WarningSpec: TypeAlias = type[Warning]
|
|
_WarnLog: TypeAlias = list[warnings.WarningMessage]
|
|
_ToModules: TypeAlias = Iterable[types.ModuleType]
|
|
|
|
# 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 | np.number | NDArray[np.bool | np.number | np.object_],
|
|
]
|
|
|
|
# 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: ...
|
|
|
|
###
|
|
|
|
verbose: int = 0
|
|
NUMPY_ROOT: Final[Path] = ...
|
|
IS_INSTALLED: Final[bool] = ...
|
|
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] = ...
|
|
|
|
class KnownFailureException(Exception): ...
|
|
class IgnoreException(Exception): ...
|
|
|
|
# NOTE: `warnings.catch_warnings` is incorrectly defined as invariant in typeshed
|
|
class clear_and_catch_warnings(warnings.catch_warnings[_W_co], Generic[_W_co]): # type: ignore[type-var] # pyright: ignore[reportInvalidTypeArguments]
|
|
class_modules: ClassVar[tuple[types.ModuleType, ...]] = ()
|
|
modules: Final[set[types.ModuleType]]
|
|
@overload # record: True
|
|
def __init__(self: clear_and_catch_warnings[_WarnLog], /, record: L[True], modules: _ToModules = ()) -> None: ...
|
|
@overload # record: False (default)
|
|
def __init__(self: clear_and_catch_warnings[None], /, record: L[False] = False, modules: _ToModules = ()) -> None: ...
|
|
@overload # record; bool
|
|
def __init__(self, /, record: bool, modules: _ToModules = ()) -> None: ...
|
|
|
|
class suppress_warnings:
|
|
log: Final[_WarnLog]
|
|
def __init__(self, /, forwarding_rule: L["always", "module", "once", "location"] = "always") -> None: ...
|
|
def __enter__(self) -> Self: ...
|
|
def __exit__(self, cls: type[BaseException] | None, exc: BaseException | None, tb: types.TracebackType | None, /) -> None: ...
|
|
def __call__(self, /, func: _FT) -> _FT: ...
|
|
|
|
#
|
|
def filter(self, /, category: type[Warning] = ..., message: str = "", module: types.ModuleType | None = None) -> None: ...
|
|
def record(self, /, category: type[Warning] = ..., message: str = "", module: types.ModuleType | None = None) -> _WarnLog: ...
|
|
|
|
# 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 = ...) -> int | None: ...
|
|
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: object,
|
|
header: str = ...,
|
|
verbose: bool = ...,
|
|
names: Sequence[str] = ...,
|
|
precision: SupportsIndex | None = ...,
|
|
) -> str: ...
|
|
|
|
#
|
|
def print_assert_equal(test_string: str, actual: object, desired: object) -> None: ...
|
|
|
|
#
|
|
def assert_(val: object, msg: str | Callable[[], str] = "") -> None: ...
|
|
|
|
#
|
|
def assert_equal(
|
|
actual: object,
|
|
desired: object,
|
|
err_msg: object = "",
|
|
verbose: bool = True,
|
|
*,
|
|
strict: bool = False,
|
|
) -> None: ...
|
|
|
|
def assert_almost_equal(
|
|
actual: _NumericArrayLike,
|
|
desired: _NumericArrayLike,
|
|
decimal: int = 7,
|
|
err_msg: object = "",
|
|
verbose: bool = True,
|
|
) -> None: ...
|
|
|
|
#
|
|
def assert_approx_equal(
|
|
actual: ConvertibleToFloat,
|
|
desired: ConvertibleToFloat,
|
|
significant: int = 7,
|
|
err_msg: object = "",
|
|
verbose: bool = True,
|
|
) -> None: ...
|
|
|
|
#
|
|
def assert_array_compare(
|
|
comparison: _ComparisonFunc,
|
|
x: ArrayLike,
|
|
y: ArrayLike,
|
|
err_msg: object = "",
|
|
verbose: bool = True,
|
|
header: str = "",
|
|
precision: SupportsIndex = 6,
|
|
equal_nan: bool = True,
|
|
equal_inf: bool = True,
|
|
*,
|
|
strict: bool = False,
|
|
names: tuple[str, str] = ("ACTUAL", "DESIRED"),
|
|
) -> None: ...
|
|
|
|
#
|
|
def assert_array_equal(
|
|
actual: object,
|
|
desired: object,
|
|
err_msg: object = "",
|
|
verbose: bool = True,
|
|
*,
|
|
strict: bool = False,
|
|
) -> None: ...
|
|
|
|
#
|
|
def assert_array_almost_equal(
|
|
actual: _NumericArrayLike,
|
|
desired: _NumericArrayLike,
|
|
decimal: float = 6,
|
|
err_msg: object = "",
|
|
verbose: bool = True,
|
|
) -> None: ...
|
|
|
|
@overload
|
|
def assert_array_less(
|
|
x: _ArrayLikeDT64_co,
|
|
y: _ArrayLikeDT64_co,
|
|
err_msg: object = "",
|
|
verbose: bool = True,
|
|
*,
|
|
strict: bool = False,
|
|
) -> None: ...
|
|
@overload
|
|
def assert_array_less(
|
|
x: _ArrayLikeTD64_co,
|
|
y: _ArrayLikeTD64_co,
|
|
err_msg: object = "",
|
|
verbose: bool = True,
|
|
*,
|
|
strict: bool = False,
|
|
) -> None: ...
|
|
@overload
|
|
def assert_array_less(
|
|
x: _NumericArrayLike,
|
|
y: _NumericArrayLike,
|
|
err_msg: object = "",
|
|
verbose: bool = True,
|
|
*,
|
|
strict: bool = False,
|
|
) -> None: ...
|
|
|
|
#
|
|
def assert_string_equal(actual: str, desired: str) -> None: ...
|
|
|
|
#
|
|
@overload
|
|
def assert_raises(
|
|
exception_class: _ExceptionSpec[_ET],
|
|
/,
|
|
*,
|
|
msg: str | None = None,
|
|
) -> unittest.case._AssertRaisesContext[_ET]: ...
|
|
@overload
|
|
def assert_raises(
|
|
exception_class: _ExceptionSpec,
|
|
callable: Callable[_Tss, Any],
|
|
/,
|
|
*args: _Tss.args,
|
|
**kwargs: _Tss.kwargs,
|
|
) -> None: ...
|
|
|
|
#
|
|
@overload
|
|
def assert_raises_regex(
|
|
exception_class: _ExceptionSpec[_ET],
|
|
expected_regexp: _RegexLike,
|
|
*,
|
|
msg: str | None = None,
|
|
) -> unittest.case._AssertRaisesContext[_ET]: ...
|
|
@overload
|
|
def assert_raises_regex(
|
|
exception_class: _ExceptionSpec,
|
|
expected_regexp: _RegexLike,
|
|
callable: Callable[_Tss, Any],
|
|
*args: _Tss.args,
|
|
**kwargs: _Tss.kwargs,
|
|
) -> None: ...
|
|
|
|
#
|
|
@overload
|
|
def assert_allclose(
|
|
actual: _ArrayLikeTD64_co,
|
|
desired: _ArrayLikeTD64_co,
|
|
rtol: float = 1e-7,
|
|
atol: float = 0,
|
|
equal_nan: bool = True,
|
|
err_msg: object = "",
|
|
verbose: bool = True,
|
|
*,
|
|
strict: bool = False,
|
|
) -> None: ...
|
|
@overload
|
|
def assert_allclose(
|
|
actual: _NumericArrayLike,
|
|
desired: _NumericArrayLike,
|
|
rtol: float = 1e-7,
|
|
atol: float = 0,
|
|
equal_nan: bool = True,
|
|
err_msg: object = "",
|
|
verbose: bool = True,
|
|
*,
|
|
strict: bool = False,
|
|
) -> None: ...
|
|
|
|
#
|
|
def assert_array_almost_equal_nulp(
|
|
x: _ArrayLikeNumber_co,
|
|
y: _ArrayLikeNumber_co,
|
|
nulp: float = 1,
|
|
) -> None: ...
|
|
|
|
#
|
|
def assert_array_max_ulp(
|
|
a: _ArrayLikeNumber_co,
|
|
b: _ArrayLikeNumber_co,
|
|
maxulp: float = 1,
|
|
dtype: DTypeLike | None = None,
|
|
) -> NDArray[Any]: ...
|
|
|
|
#
|
|
@overload
|
|
def assert_warns(warning_class: _WarningSpec) -> _GeneratorContextManager[None]: ...
|
|
@overload
|
|
def assert_warns(warning_class: _WarningSpec, func: Callable[_Tss, _T], *args: _Tss.args, **kwargs: _Tss.kwargs) -> _T: ...
|
|
|
|
#
|
|
@overload
|
|
def assert_no_warnings() -> _GeneratorContextManager[None]: ...
|
|
@overload
|
|
def assert_no_warnings(func: Callable[_Tss, _T], /, *args: _Tss.args, **kwargs: _Tss.kwargs) -> _T: ...
|
|
|
|
#
|
|
@overload
|
|
def assert_no_gc_cycles() -> _GeneratorContextManager[None]: ...
|
|
@overload
|
|
def assert_no_gc_cycles(func: Callable[_Tss, Any], /, *args: _Tss.args, **kwargs: _Tss.kwargs) -> None: ...
|
|
|
|
###
|
|
|
|
#
|
|
@overload
|
|
def tempdir(
|
|
suffix: None = None,
|
|
prefix: None = None,
|
|
dir: None = None,
|
|
) -> _GeneratorContextManager[str]: ...
|
|
@overload
|
|
def tempdir(
|
|
suffix: AnyStr | None = None,
|
|
prefix: AnyStr | None = None,
|
|
*,
|
|
dir: GenericPath[AnyStr],
|
|
) -> _GeneratorContextManager[AnyStr]: ...
|
|
@overload
|
|
def tempdir(
|
|
suffix: AnyStr | None = None,
|
|
*,
|
|
prefix: AnyStr,
|
|
dir: GenericPath[AnyStr] | None = None,
|
|
) -> _GeneratorContextManager[AnyStr]: ...
|
|
@overload
|
|
def tempdir(
|
|
suffix: AnyStr,
|
|
prefix: AnyStr | None = None,
|
|
dir: GenericPath[AnyStr] | None = None,
|
|
) -> _GeneratorContextManager[AnyStr]: ...
|
|
|
|
#
|
|
@overload
|
|
def temppath(
|
|
suffix: None = None,
|
|
prefix: None = None,
|
|
dir: None = None,
|
|
text: bool = False,
|
|
) -> _GeneratorContextManager[str]: ...
|
|
@overload
|
|
def temppath(
|
|
suffix: AnyStr | None,
|
|
prefix: AnyStr | None,
|
|
dir: GenericPath[AnyStr],
|
|
text: bool = False,
|
|
) -> _GeneratorContextManager[AnyStr]: ...
|
|
@overload
|
|
def temppath(
|
|
suffix: AnyStr | None = None,
|
|
prefix: AnyStr | None = None,
|
|
*,
|
|
dir: GenericPath[AnyStr],
|
|
text: bool = False,
|
|
) -> _GeneratorContextManager[AnyStr]: ...
|
|
@overload
|
|
def temppath(
|
|
suffix: AnyStr | None,
|
|
prefix: AnyStr,
|
|
dir: GenericPath[AnyStr] | None = None,
|
|
text: bool = False,
|
|
) -> _GeneratorContextManager[AnyStr]: ...
|
|
@overload
|
|
def temppath(
|
|
suffix: AnyStr | None = None,
|
|
*,
|
|
prefix: AnyStr,
|
|
dir: GenericPath[AnyStr] | None = None,
|
|
text: bool = False,
|
|
) -> _GeneratorContextManager[AnyStr]: ...
|
|
@overload
|
|
def temppath(
|
|
suffix: AnyStr,
|
|
prefix: AnyStr | None = None,
|
|
dir: GenericPath[AnyStr] | None = None,
|
|
text: bool = False,
|
|
) -> _GeneratorContextManager[AnyStr]: ...
|
|
|
|
#
|
|
def check_support_sve(__cache: list[_T_or_bool] = []) -> _T_or_bool: ... # noqa: PYI063
|
|
|
|
#
|
|
def decorate_methods(
|
|
cls: type,
|
|
decorator: Callable[[Callable[..., Any]], Any],
|
|
testmatch: _RegexLike | None = None,
|
|
) -> None: ...
|
|
|
|
#
|
|
@overload
|
|
def run_threaded(
|
|
func: Callable[[], None],
|
|
max_workers: int = 8,
|
|
pass_count: bool = False,
|
|
pass_barrier: bool = False,
|
|
outer_iterations: int = 1,
|
|
prepare_args: None = None,
|
|
) -> None: ...
|
|
@overload
|
|
def run_threaded(
|
|
func: Callable[[Unpack[_Ts]], None],
|
|
max_workers: int,
|
|
pass_count: bool,
|
|
pass_barrier: bool,
|
|
outer_iterations: int,
|
|
prepare_args: tuple[Unpack[_Ts]],
|
|
) -> None: ...
|
|
@overload
|
|
def run_threaded(
|
|
func: Callable[[Unpack[_Ts]], None],
|
|
max_workers: int = 8,
|
|
pass_count: bool = False,
|
|
pass_barrier: bool = False,
|
|
outer_iterations: int = 1,
|
|
*,
|
|
prepare_args: tuple[Unpack[_Ts]],
|
|
) -> None: ...
|
|
|
|
#
|
|
def runstring(astr: _StrLike | types.CodeType, dict: dict[str, Any] | None) -> Any: ... # noqa: ANN401
|
|
def rundocs(filename: StrPath | None = None, raise_on_error: bool = True) -> None: ...
|
|
def measure(code_str: _StrLike | ast.AST, times: int = 1, label: str | None = None) -> float: ...
|
|
def break_cycles() -> None: ...
|