""" Tests related to deprecation warnings. Also a convenient place to document how deprecations should eventually be turned into errors. """ import contextlib import warnings import numpy._core._struct_ufunc_tests as struct_ufunc import pytest from numpy._core._multiarray_tests import fromstring_null_term_c_api # noqa: F401 import numpy as np from numpy.testing import assert_raises, temppath try: import pytz # noqa: F401 _has_pytz = True except ImportError: _has_pytz = False class _DeprecationTestCase: # Just as warning: warnings uses re.match, so the start of this message # must match. message = '' warning_cls = DeprecationWarning def setup_method(self): self.warn_ctx = warnings.catch_warnings(record=True) self.log = self.warn_ctx.__enter__() # Do *not* ignore other DeprecationWarnings. Ignoring warnings # can give very confusing results because of # https://bugs.python.org/issue4180 and it is probably simplest to # try to keep the tests cleanly giving only the right warning type. # (While checking them set to "error" those are ignored anyway) # We still have them show up, because otherwise they would be raised warnings.filterwarnings("always", category=self.warning_cls) warnings.filterwarnings("always", message=self.message, category=self.warning_cls) def teardown_method(self): self.warn_ctx.__exit__() def assert_deprecated(self, function, num=1, ignore_others=False, function_fails=False, exceptions=np._NoValue, args=(), kwargs={}): """Test if DeprecationWarnings are given and raised. This first checks if the function when called gives `num` DeprecationWarnings, after that it tries to raise these DeprecationWarnings and compares them with `exceptions`. The exceptions can be different for cases where this code path is simply not anticipated and the exception is replaced. Parameters ---------- function : callable The function to test num : int Number of DeprecationWarnings to expect. This should normally be 1. ignore_others : bool Whether warnings of the wrong type should be ignored (note that the message is not checked) function_fails : bool If the function would normally fail, setting this will check for warnings inside a try/except block. exceptions : Exception or tuple of Exceptions Exception to expect when turning the warnings into an error. The default checks for DeprecationWarnings. If exceptions is empty the function is expected to run successfully. args : tuple Arguments for `function` kwargs : dict Keyword arguments for `function` """ __tracebackhide__ = True # Hide traceback for py.test # reset the log self.log[:] = [] if exceptions is np._NoValue: exceptions = (self.warning_cls,) if function_fails: context_manager = contextlib.suppress(Exception) else: context_manager = contextlib.nullcontext() with context_manager: function(*args, **kwargs) # just in case, clear the registry num_found = 0 for warning in self.log: if warning.category is self.warning_cls: num_found += 1 elif not ignore_others: raise AssertionError( "expected %s but got: %s" % (self.warning_cls.__name__, warning.category)) if num is not None and num_found != num: msg = f"{len(self.log)} warnings found but {num} expected." lst = [str(w) for w in self.log] raise AssertionError("\n".join([msg] + lst)) with warnings.catch_warnings(): warnings.filterwarnings("error", message=self.message, category=self.warning_cls) try: function(*args, **kwargs) if exceptions != (): raise AssertionError( "No error raised during function call") except exceptions: if exceptions == (): raise AssertionError( "Error raised during function call") def assert_not_deprecated(self, function, args=(), kwargs={}): """Test that warnings are not raised. This is just a shorthand for: self.assert_deprecated(function, num=0, ignore_others=True, exceptions=tuple(), args=args, kwargs=kwargs) """ self.assert_deprecated(function, num=0, ignore_others=True, exceptions=(), args=args, kwargs=kwargs) class _VisibleDeprecationTestCase(_DeprecationTestCase): warning_cls = np.exceptions.VisibleDeprecationWarning class TestTestDeprecated: def test_assert_deprecated(self): test_case_instance = _DeprecationTestCase() test_case_instance.setup_method() assert_raises(AssertionError, test_case_instance.assert_deprecated, lambda: None) def foo(): warnings.warn("foo", category=DeprecationWarning, stacklevel=2) test_case_instance.assert_deprecated(foo) test_case_instance.teardown_method() class TestBincount(_DeprecationTestCase): # 2024-07-29, 2.1.0 @pytest.mark.parametrize('badlist', [[0.5, 1.2, 1.5], ['0', '1', '1']]) def test_bincount_bad_list(self, badlist): self.assert_deprecated(lambda: np.bincount(badlist)) class TestGeneratorSum(_DeprecationTestCase): # 2018-02-25, 1.15.0 def test_generator_sum(self): self.assert_deprecated(np.sum, args=((i for i in range(5)),)) class BuiltInRoundComplexDType(_DeprecationTestCase): # 2020-03-31 1.19.0 deprecated_types = [np.csingle, np.cdouble, np.clongdouble] not_deprecated_types = [ np.int8, np.int16, np.int32, np.int64, np.uint8, np.uint16, np.uint32, np.uint64, np.float16, np.float32, np.float64, ] def test_deprecated(self): for scalar_type in self.deprecated_types: scalar = scalar_type(0) self.assert_deprecated(round, args=(scalar,)) self.assert_deprecated(round, args=(scalar, 0)) self.assert_deprecated(round, args=(scalar,), kwargs={'ndigits': 0}) def test_not_deprecated(self): for scalar_type in self.not_deprecated_types: scalar = scalar_type(0) self.assert_not_deprecated(round, args=(scalar,)) self.assert_not_deprecated(round, args=(scalar, 0)) self.assert_not_deprecated(round, args=(scalar,), kwargs={'ndigits': 0}) class FlatteningConcatenateUnsafeCast(_DeprecationTestCase): # NumPy 1.20, 2020-09-03 message = "concatenate with `axis=None` will use same-kind casting" def test_deprecated(self): self.assert_deprecated(np.concatenate, args=(([0.], [1.]),), kwargs={'axis': None, 'out': np.empty(2, dtype=np.int64)}) def test_not_deprecated(self): self.assert_not_deprecated(np.concatenate, args=(([0.], [1.]),), kwargs={'axis': None, 'out': np.empty(2, dtype=np.int64), 'casting': "unsafe"}) with assert_raises(TypeError): # Tests should notice if the deprecation warning is given first... np.concatenate(([0.], [1.]), out=np.empty(2, dtype=np.int64), casting="same_kind") class TestCtypesGetter(_DeprecationTestCase): # Deprecated 2021-05-18, Numpy 1.21.0 warning_cls = DeprecationWarning ctypes = np.array([1]).ctypes @pytest.mark.parametrize( "name", ["get_data", "get_shape", "get_strides", "get_as_parameter"] ) def test_deprecated(self, name: str) -> None: func = getattr(self.ctypes, name) self.assert_deprecated(func) @pytest.mark.parametrize( "name", ["data", "shape", "strides", "_as_parameter_"] ) def test_not_deprecated(self, name: str) -> None: self.assert_not_deprecated(lambda: getattr(self.ctypes, name)) class TestMachAr(_DeprecationTestCase): # Deprecated 2022-11-22, NumPy 1.25 warning_cls = DeprecationWarning def test_deprecated_module(self): self.assert_deprecated(lambda: np._core.MachAr) class TestQuantileInterpolationDeprecation(_DeprecationTestCase): # Deprecated 2021-11-08, NumPy 1.22 @pytest.mark.parametrize("func", [np.percentile, np.quantile, np.nanpercentile, np.nanquantile]) def test_deprecated(self, func): self.assert_deprecated( lambda: func([0., 1.], 0., interpolation="linear")) self.assert_deprecated( lambda: func([0., 1.], 0., interpolation="nearest")) @pytest.mark.parametrize("func", [np.percentile, np.quantile, np.nanpercentile, np.nanquantile]) def test_both_passed(self, func): with warnings.catch_warnings(): # catch the DeprecationWarning so that it does not raise: warnings.simplefilter("always", DeprecationWarning) with pytest.raises(TypeError): func([0., 1.], 0., interpolation="nearest", method="nearest") class TestScalarConversion(_DeprecationTestCase): # 2023-01-02, 1.25.0 def test_float_conversion(self): self.assert_deprecated(float, args=(np.array([3.14]),)) def test_behaviour(self): b = np.array([[3.14]]) c = np.zeros(5) with pytest.warns(DeprecationWarning): c[0] = b class TestPyIntConversion(_DeprecationTestCase): message = r".*stop allowing conversion of out-of-bound.*" @pytest.mark.parametrize("dtype", np.typecodes["AllInteger"]) def test_deprecated_scalar(self, dtype): dtype = np.dtype(dtype) info = np.iinfo(dtype) # Cover the most common creation paths (all end up in the # same place): def scalar(value, dtype): dtype.type(value) def assign(value, dtype): arr = np.array([0, 0, 0], dtype=dtype) arr[2] = value def create(value, dtype): np.array([value], dtype=dtype) for creation_func in [scalar, assign, create]: try: self.assert_deprecated( lambda: creation_func(info.min - 1, dtype)) except OverflowError: pass # OverflowErrors always happened also before and are OK. try: self.assert_deprecated( lambda: creation_func(info.max + 1, dtype)) except OverflowError: pass # OverflowErrors always happened also before and are OK. @pytest.mark.parametrize("name", ["str", "bytes", "object"]) def test_future_scalar_attributes(name): # FutureWarning added 2022-11-17, NumPy 1.24, assert name not in dir(np) # we may want to not add them with pytest.warns(FutureWarning, match=f"In the future .*{name}"): assert not hasattr(np, name) # Unfortunately, they are currently still valid via `np.dtype()` np.dtype(name) name in np._core.sctypeDict # Ignore the above future attribute warning for this test. @pytest.mark.filterwarnings("ignore:In the future:FutureWarning") class TestRemovedGlobals: # Removed 2023-01-12, NumPy 1.24.0 # Not a deprecation, but the large error was added to aid those who missed # the previous deprecation, and should be removed similarly to one # (or faster). @pytest.mark.parametrize("name", ["object", "float", "complex", "str", "int"]) def test_attributeerror_includes_info(self, name): msg = f".*\n`np.{name}` was a deprecated alias for the builtin" with pytest.raises(AttributeError, match=msg): getattr(np, name) class TestDeprecatedFinfo(_DeprecationTestCase): # Deprecated in NumPy 1.25, 2023-01-16 def test_deprecated_none(self): self.assert_deprecated(np.finfo, args=(None,)) class TestMathAlias(_DeprecationTestCase): def test_deprecated_np_lib_math(self): self.assert_deprecated(lambda: np.lib.math) class TestLibImports(_DeprecationTestCase): # Deprecated in Numpy 1.26.0, 2023-09 def test_lib_functions_deprecation_call(self): from numpy import in1d, row_stack, trapz from numpy._core.numerictypes import maximum_sctype from numpy.lib._function_base_impl import disp from numpy.lib._npyio_impl import recfromcsv, recfromtxt from numpy.lib._shape_base_impl import get_array_wrap from numpy.lib._utils_impl import safe_eval from numpy.lib.tests.test_io import TextIO self.assert_deprecated(lambda: safe_eval("None")) data_gen = lambda: TextIO('A,B\n0,1\n2,3') kwargs = {'delimiter': ",", 'missing_values': "N/A", 'names': True} self.assert_deprecated(lambda: recfromcsv(data_gen())) self.assert_deprecated(lambda: recfromtxt(data_gen(), **kwargs)) self.assert_deprecated(lambda: disp("test")) self.assert_deprecated(get_array_wrap) self.assert_deprecated(lambda: maximum_sctype(int)) self.assert_deprecated(lambda: in1d([1], [1])) self.assert_deprecated(lambda: row_stack([[]])) self.assert_deprecated(lambda: trapz([1], [1])) self.assert_deprecated(lambda: np.chararray) class TestDeprecatedDTypeAliases(_DeprecationTestCase): def _check_for_warning(self, func): with warnings.catch_warnings(record=True) as caught_warnings: func() assert len(caught_warnings) == 1 w = caught_warnings[0] assert w.category is DeprecationWarning assert "alias 'a' was deprecated in NumPy 2.0" in str(w.message) def test_a_dtype_alias(self): for dtype in ["a", "a10"]: f = lambda: np.dtype(dtype) self._check_for_warning(f) self.assert_deprecated(f) f = lambda: np.array(["hello", "world"]).astype("a10") self._check_for_warning(f) self.assert_deprecated(f) class TestDeprecatedArrayWrap(_DeprecationTestCase): message = "__array_wrap__.*" def test_deprecated(self): class Test1: def __array__(self, dtype=None, copy=None): return np.arange(4) def __array_wrap__(self, arr, context=None): self.called = True return 'pass context' class Test2(Test1): def __array_wrap__(self, arr): self.called = True return 'pass' test1 = Test1() test2 = Test2() self.assert_deprecated(lambda: np.negative(test1)) assert test1.called self.assert_deprecated(lambda: np.negative(test2)) assert test2.called class TestDeprecatedDTypeParenthesizedRepeatCount(_DeprecationTestCase): message = "Passing in a parenthesized single number" @pytest.mark.parametrize("string", ["(2)i,", "(3)3S,", "f,(2)f"]) def test_parenthesized_repeat_count(self, string): self.assert_deprecated(np.dtype, args=(string,)) class TestDeprecatedSaveFixImports(_DeprecationTestCase): # Deprecated in Numpy 2.1, 2024-05 message = "The 'fix_imports' flag is deprecated and has no effect." def test_deprecated(self): with temppath(suffix='.npy') as path: sample_args = (path, np.array(np.zeros((1024, 10)))) self.assert_not_deprecated(np.save, args=sample_args) self.assert_deprecated(np.save, args=sample_args, kwargs={'fix_imports': True}) self.assert_deprecated(np.save, args=sample_args, kwargs={'fix_imports': False}) for allow_pickle in [True, False]: self.assert_not_deprecated(np.save, args=sample_args, kwargs={'allow_pickle': allow_pickle}) self.assert_deprecated(np.save, args=sample_args, kwargs={'allow_pickle': allow_pickle, 'fix_imports': True}) self.assert_deprecated(np.save, args=sample_args, kwargs={'allow_pickle': allow_pickle, 'fix_imports': False}) class TestAddNewdocUFunc(_DeprecationTestCase): # Deprecated in Numpy 2.2, 2024-11 def test_deprecated(self): self.assert_deprecated( lambda: np._core.umath._add_newdoc_ufunc( struct_ufunc.add_triplet, "new docs" ) )