warp-lang 0.15.0__py3-none-manylinux2014_x86_64.whl → 1.0.0__py3-none-manylinux2014_x86_64.whl

warp/tests/test_grad_customs.py

@@ -22,6 +22,7 @@ wp.init()
 def reversible_increment(
     counter: wp.array(dtype=int), counter_index: int, value: int, thread_values: wp.array(dtype=int), tid: int
 ):
+    """This is a docstring"""
     next_index = wp.atomic_add(counter, counter_index, value)
     thread_values[tid] = next_index
     return next_index
@@ -31,6 +32,7 @@ def reversible_increment(
 def replay_reversible_increment(
     counter: wp.array(dtype=int), counter_index: int, value: int, thread_values: wp.array(dtype=int), tid: int
 ):
+    """This is a docstring"""
     return thread_values[tid]
 
 
@@ -64,28 +66,33 @@ def test_custom_replay_grad(test, device):
 
 @wp.func
 def overload_fn(x: float, y: float):
+    """This is a docstring"""
     return x * 3.0 + y / 3.0, y**2.5
 
 
 @wp.func_grad(overload_fn)
 def overload_fn_grad(x: float, y: float, adj_ret0: float, adj_ret1: float):
+    """This is a docstring"""
     wp.adjoint[x] += x * adj_ret0 * 42.0 + y * adj_ret1 * 10.0
     wp.adjoint[y] += y * adj_ret1 * 3.0
 
 
 @wp.struct
 class MyStruct:
+    """This is a docstring"""
     scalar: float
     vec: wp.vec3
 
 
 @wp.func
 def overload_fn(x: MyStruct):
+    """This is a docstring"""
     return x.vec[0] * x.vec[1] * x.vec[2] * 4.0, wp.length(x.vec), x.scalar**0.5
 
 
 @wp.func_grad(overload_fn)
 def overload_fn_grad(x: MyStruct, adj_ret0: float, adj_ret1: float, adj_ret2: float):
+    """This is a docstring"""
     wp.adjoint[x.scalar] += x.scalar * adj_ret0 * 10.0
     wp.adjoint[x.vec][0] += adj_ret0 * x.vec[1] * x.vec[2] * 20.0
     wp.adjoint[x.vec][1] += adj_ret1 * x.vec[0] * x.vec[2] * 30.0
@@ -96,6 +103,7 @@ def overload_fn_grad(x: MyStruct, adj_ret0: float, adj_ret1: float, adj_ret2: fl
 def run_overload_float_fn(
     xs: wp.array(dtype=float), ys: wp.array(dtype=float), output0: wp.array(dtype=float), output1: wp.array(dtype=float)
 ):
+    """This is a docstring"""
     i = wp.tid()
     out0, out1 = overload_fn(xs[i], ys[i])
     output0[i] = out0
@@ -197,6 +205,118 @@ def test_custom_import_grad(test, device):
     assert_np_equal(ys_float.grad.numpy(), ys_float.numpy() * 3.0)
 
 
+@wp.func
+def sigmoid(x: float):
+    return 1.0 / (1.0 + wp.exp(-x))
+
+
+@wp.func_grad(sigmoid)
+def adj_sigmoid(x: float, adj: float):
+    # unused function to test that we don't run into infinite recursion when calling
+    # the forward function from within the gradient function
+    wp.adjoint[x] += adj * sigmoid(x) * (1.0 - sigmoid(x))
+
+
+@wp.func
+def sigmoid_no_return(i: int, xs: wp.array(dtype=float), ys: wp.array(dtype=float)):
+    # test function that does not return anything
+    ys[i] = sigmoid(xs[i])
+
+
+@wp.func_grad(sigmoid_no_return)
+def adj_sigmoid_no_return(i: int, xs: wp.array(dtype=float), ys: wp.array(dtype=float)):
+    wp.adjoint[xs][i] += ys[i] * (1.0 - ys[i])
+
+
+@wp.kernel
+def eval_sigmoid(xs: wp.array(dtype=float), ys: wp.array(dtype=float)):
+    i = wp.tid()
+    sigmoid_no_return(i, xs, ys)
+
+
+def test_custom_grad_no_return(test, device):
+    xs = wp.array([1.0, 2.0, 3.0, 4.0], dtype=wp.float32, requires_grad=True)
+    ys = wp.zeros_like(xs)
+    ys.grad.fill_(1.0)
+
+    tape = wp.Tape()
+    with tape:
+        wp.launch(eval_sigmoid, dim=len(xs), inputs=[xs], outputs=[ys])
+    tape.backward()
+
+    sigmoids = ys.numpy()
+    grad = xs.grad.numpy()
+    assert_np_equal(grad, sigmoids * (1.0 - sigmoids))
+
+
+def test_wrapped_docstring(test, device):
+    assert "This is a docstring" in reversible_increment.__doc__
+    assert "This is a docstring" in replay_reversible_increment.__doc__
+    assert "This is a docstring" in overload_fn.__doc__
+    assert "This is a docstring" in overload_fn_grad.__doc__
+    assert "This is a docstring" in run_overload_float_fn.__doc__
+    assert "This is a docstring" in MyStruct.__doc__
+
+
+@wp.func
+def dense_gemm(
+    m: int,
+    n: int,
+    p: int,
+    transpose_A: bool,
+    transpose_B: bool,
+    add_to_C: bool,
+    A: wp.array(dtype=float),
+    B: wp.array(dtype=float),
+    # outputs
+    C: wp.array(dtype=float),
+):
+    # this function doesn't get called but it is an important test for code generation
+    # multiply a `m x p` matrix A by a `p x n` matrix B to produce a `m x n` matrix C
+    for i in range(m):
+        for j in range(n):
+            sum = float(0.0)
+            for k in range(p):
+                if transpose_A:
+                    a_i = k * m + i
+                else:
+                    a_i = i * p + k
+                if transpose_B:
+                    b_j = j * p + k
+                else:
+                    b_j = k * n + j
+                sum += A[a_i] * B[b_j]
+
+            if add_to_C:
+                C[i * n + j] += sum
+            else:
+                C[i * n + j] = sum
+
+
+@wp.func_grad(dense_gemm)
+def adj_dense_gemm(
+    m: int,
+    n: int,
+    p: int,
+    transpose_A: bool,
+    transpose_B: bool,
+    add_to_C: bool,
+    A: wp.array(dtype=float),
+    B: wp.array(dtype=float),
+    # outputs
+    C: wp.array(dtype=float),
+):
+    # code generation would break here if we didn't defer building the custom grad
+    # function until after the forward functions + kernels of the module have been built
+    add_to_C = True
+    if transpose_A:
+        dense_gemm(p, m, n, False, True, add_to_C, B, wp.adjoint[C], wp.adjoint[A])
+        dense_gemm(p, n, m, False, False, add_to_C, A, wp.adjoint[C], wp.adjoint[B])
+    else:
+        dense_gemm(m, p, n, False, not transpose_B, add_to_C, wp.adjoint[C], B, wp.adjoint[A])
+        dense_gemm(p, n, m, True, False, add_to_C, A, wp.adjoint[C], wp.adjoint[B])
+
+
 devices = get_test_devices()
 
 
@@ -207,6 +327,8 @@ class TestGradCustoms(unittest.TestCase):
 add_function_test(TestGradCustoms, "test_custom_replay_grad", test_custom_replay_grad, devices=devices)
 add_function_test(TestGradCustoms, "test_custom_overload_grad", test_custom_overload_grad, devices=devices)
 add_function_test(TestGradCustoms, "test_custom_import_grad", test_custom_import_grad, devices=devices)
+add_function_test(TestGradCustoms, "test_custom_grad_no_return", test_custom_grad_no_return, devices=devices)
+add_function_test(TestGradCustoms, "test_wrapped_docstring", test_wrapped_docstring, devices=devices)
 
 
 if __name__ == "__main__":

warp/tests/test_jax.py

@@ -0,0 +1,254 @@
+# Copyright (c) 2024 NVIDIA CORPORATION.  All rights reserved.
+# NVIDIA CORPORATION and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto.  Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION is strictly prohibited.
+
+import numpy as np
+import os
+import unittest
+from typing import Any
+
+import warp as wp
+from warp.tests.unittest_utils import *
+
+wp.init()
+
+
+# basic kernel with one input and output
+@wp.kernel
+def triple_kernel(input: wp.array(dtype=float), output: wp.array(dtype=float)):
+    tid = wp.tid()
+    output[tid] = 3.0 * input[tid]
+
+
+# generic kernel with one scalar input and output
+@wp.kernel
+def triple_kernel_scalar(input: wp.array(dtype=Any), output: wp.array(dtype=Any)):
+    tid = wp.tid()
+    output[tid] = input.dtype(3) * input[tid]
+
+
+# generic kernel with one vector/matrix input and output
+@wp.kernel
+def triple_kernel_vecmat(input: wp.array(dtype=Any), output: wp.array(dtype=Any)):
+    tid = wp.tid()
+    output[tid] = input.dtype.dtype(3) * input[tid]
+
+
+# kernel with multiple inputs and outputs
+@wp.kernel
+def multiarg_kernel(
+    # inputs
+    a: wp.array(dtype=float),
+    b: wp.array(dtype=float),
+    c: wp.array(dtype=float),
+    # outputs
+    ab: wp.array(dtype=float),
+    bc: wp.array(dtype=float),
+):
+    tid = wp.tid()
+    ab[tid] = a[tid] + b[tid]
+    bc[tid] = b[tid] + c[tid]
+
+
+# various types for testing
+scalar_types = wp.types.scalar_types
+vector_types = []
+matrix_types = []
+for dim in [2, 3, 4]:
+    for T in scalar_types:
+        vector_types.append(wp.vec(dim, T))
+        matrix_types.append(wp.mat((dim, dim), T))
+
+# explicitly overload generic kernels to avoid module reloading during tests
+for T in scalar_types:
+    wp.overload(triple_kernel_scalar, [wp.array(dtype=T), wp.array(dtype=T)])
+for T in [*vector_types, *matrix_types]:
+    wp.overload(triple_kernel_vecmat, [wp.array(dtype=T), wp.array(dtype=T)])
+
+
+def _jax_version():
+    try:
+        import jax
+        return jax.__version_info__
+    except ImportError:
+        return (0, 0, 0)
+
+
+@unittest.skipUnless(_jax_version() >= (0, 4, 25), "Jax version too old")
+def test_jax_kernel_basic(test, device):
+    import jax.numpy as jp
+    from warp.jax_experimental import jax_kernel
+
+    n = 64
+
+    jax_triple = jax_kernel(triple_kernel)
+
+    @jax.jit
+    def f():
+        x = jp.arange(n, dtype=jp.float32)
+        return jax_triple(x)
+
+    # run on the given device
+    with jax.default_device(wp.device_to_jax(device)):
+        y = f()
+    
+    result = np.asarray(y)
+    expected = 3 * np.arange(n, dtype=np.float32)
+
+    assert_np_equal(result, expected)
+
+
+@unittest.skipUnless(_jax_version() >= (0, 4, 25), "Jax version too old")
+def test_jax_kernel_scalar(test, device):
+    import jax.numpy as jp
+    from warp.jax_experimental import jax_kernel
+
+    n = 64
+        
+    for T in scalar_types:
+
+        jp_dtype = wp.jax.dtype_to_jax(T)
+        np_dtype = wp.types.warp_type_to_np_dtype[T]
+
+        with test.subTest(msg=T.__name__):
+
+            # get the concrete overload
+            kernel_instance = triple_kernel_scalar.get_overload([wp.array(dtype=T), wp.array(dtype=T)])
+
+            jax_triple = jax_kernel(kernel_instance)
+
+            @jax.jit
+            def f():
+                x = jp.arange(n, dtype=jp_dtype)
+                return jax_triple(x)
+
+            # run on the given device
+            with jax.default_device(wp.device_to_jax(device)):
+                y = f()
+            
+            result = np.asarray(y)
+            expected = 3 * np.arange(n, dtype=np_dtype)
+
+            assert_np_equal(result, expected)
+
+
+@unittest.skipUnless(_jax_version() >= (0, 4, 25), "Jax version too old")
+def test_jax_kernel_vecmat(test, device):
+    import jax.numpy as jp
+    from warp.jax_experimental import jax_kernel
+
+    for T in [*vector_types, *matrix_types]:
+
+        jp_dtype = wp.jax.dtype_to_jax(T._wp_scalar_type_)
+        np_dtype = wp.types.warp_type_to_np_dtype[T._wp_scalar_type_]
+
+        n = 64 // T._length_
+        scalar_shape = (n, *T._shape_)
+        scalar_len = n * T._length_
+
+        with test.subTest(msg=T.__name__):
+
+            # get the concrete overload
+            kernel_instance = triple_kernel_vecmat.get_overload([wp.array(dtype=T), wp.array(dtype=T)])
+
+            jax_triple = jax_kernel(kernel_instance)
+
+            @jax.jit
+            def f():
+                x = jp.arange(scalar_len, dtype=jp_dtype).reshape(scalar_shape)
+                return jax_triple(x)
+
+            # run on the given device
+            with jax.default_device(wp.device_to_jax(device)):
+                y = f()
+            
+            result = np.asarray(y)
+            expected = 3 * np.arange(scalar_len, dtype=np_dtype).reshape(scalar_shape)
+
+            assert_np_equal(result, expected)
+
+
+@unittest.skipUnless(_jax_version() >= (0, 4, 25), "Jax version too old")
+def test_jax_kernel_multiarg(test, device):
+    import jax.numpy as jp
+    from warp.jax_experimental import jax_kernel
+
+    n = 64
+
+    jax_multiarg = jax_kernel(multiarg_kernel)
+
+    @jax.jit
+    def f():
+        a = jp.full(n, 1, dtype=jp.float32)
+        b = jp.full(n, 2, dtype=jp.float32)
+        c = jp.full(n, 3, dtype=jp.float32)
+        return jax_multiarg(a, b, c)
+
+    # run on the given device
+    with jax.default_device(wp.device_to_jax(device)):
+        x, y = f()
+    
+    result_x, result_y = np.asarray(x), np.asarray(y)
+    expected_x = np.full(n, 3, dtype=np.float32)
+    expected_y = np.full(n, 5, dtype=np.float32)
+
+    assert_np_equal(result_x, expected_x)
+    assert_np_equal(result_y, expected_y)
+
+
+class TestJax(unittest.TestCase):
+    pass
+
+
+# try adding Jax tests if Jax is installed correctly
+try:
+    # prevent Jax from gobbling up GPU memory
+    os.environ["XLA_PYTHON_CLIENT_PREALLOCATE"] = "false"
+    os.environ["XLA_PYTHON_CLIENT_ALLOCATOR"] = "platform"
+
+    import jax
+    import jax.dlpack
+
+    # NOTE: we must enable 64-bit types in Jax to test the full gamut of types
+    jax.config.update("jax_enable_x64", True)
+
+    # check which Warp devices work with Jax
+    # CUDA devices may fail if Jax cannot find a CUDA Toolkit
+    test_devices = get_test_devices()
+    jax_compatible_devices = []
+    jax_compatible_cuda_devices = []
+    for d in test_devices:
+        try:
+            with jax.default_device(wp.device_to_jax(d)):
+                j = jax.numpy.arange(10, dtype=jax.numpy.float32)
+                j += 1
+            jax_compatible_devices.append(d)
+            if d.is_cuda:
+                jax_compatible_cuda_devices.append(d)
+        except Exception as e:
+            print(f"Skipping Jax DLPack tests on device '{d}' due to exception: {e}")
+
+    if jax_compatible_cuda_devices:
+        add_function_test(
+            TestJax, "test_jax_kernel_basic", test_jax_kernel_basic, devices=jax_compatible_cuda_devices
+        )
+        add_function_test(
+            TestJax, "test_jax_kernel_scalar", test_jax_kernel_scalar, devices=jax_compatible_cuda_devices
+        )
+        add_function_test(
+            TestJax, "test_jax_kernel_vecmat", test_jax_kernel_vecmat, devices=jax_compatible_cuda_devices
+        )
+        add_function_test(
+            TestJax, "test_jax_kernel_multiarg", test_jax_kernel_multiarg, devices=jax_compatible_cuda_devices
+        )
+
+except Exception as e:
+    print(f"Skipping Jax tests due to exception: {e}")
+
+
+if __name__ == "__main__":
+    wp.build.clear_kernel_cache()
+    unittest.main(verbosity=2)

warp/tests/test_options.py

@@ -6,6 +6,8 @@
 # license agreement from NVIDIA CORPORATION is strictly prohibited.
 
 import unittest
+import contextlib
+import io
 
 import warp as wp
 from warp.tests.unittest_utils import *
@@ -49,7 +51,12 @@ def test_options_1(test, device):
     with tape:
         wp.launch(scale, dim=1, inputs=[x, y], device=device)
 
-    tape.backward(y)
+    with contextlib.redirect_stdout(io.StringIO()) as f:
+        tape.backward(y)
+
+    expected = f"Warp UserWarning: Running the tape backwards may produce incorrect gradients because recorded kernel {scale.key} is defined in a module with the option 'enable_backward=False' set.\n"
+
+    assert f.getvalue() == expected
     assert_np_equal(tape.gradients[x].numpy(), np.array(0.0))
 
 
@@ -91,58 +98,13 @@ def test_options_4(test, device):
     with tape:
         wp.launch(scale_2, dim=1, inputs=[x, y], device=device)
 
-    tape.backward(y)
-    assert_np_equal(tape.gradients[x].numpy(), np.array(0.0))
-
-
-@unittest.skipUnless(runtime.core.is_cutlass_enabled(), "Warp was not built with CUTLASS support")
-def test_options_5(test, device):
-    wp.set_module_options({"enable_backward": True})
-
-    @wp.kernel
-    def loss_kernel(y: wp.array(dtype=float), loss: wp.array(dtype=float)):
-        tid = wp.tid()
-        wp.atomic_add(loss, 0, y[tid])
-
-    A = wp.array(np.ones((2, 2), dtype=float), dtype=float, requires_grad=True, device=device)
-    x = wp.array([[1.0], [2.0]], dtype=float, requires_grad=True, device=device)
-    b = wp.zeros_like(x)
-    y = wp.zeros_like(x)
-    loss = wp.zeros(1, requires_grad=True, device=device)
-
-    tape = wp.Tape()
-
-    with tape:
-        wp.matmul(A, x, b, y)
-        wp.launch(loss_kernel, dim=2, inputs=[y.flatten(), loss], device=device)
-
-    tape.backward(loss)
-    assert_np_equal(x.grad.numpy(), np.array([[2.0], [2.0]]))
+    with contextlib.redirect_stdout(io.StringIO()) as f:
+        tape.backward(y)
 
+    expected = f"Warp UserWarning: Running the tape backwards may produce incorrect gradients because recorded kernel {scale_2.key} is configured with the option 'enable_backward=False'.\n"
 
-@unittest.skipUnless(runtime.core.is_cutlass_enabled(), "Warp was not built with CUTLASS support")
-def test_options_6(test, device):
-    wp.set_module_options({"enable_backward": False})
-
-    @wp.kernel
-    def loss_kernel(y: wp.array(dtype=float), loss: wp.array(dtype=float)):
-        tid = wp.tid()
-        wp.atomic_add(loss, 0, y[tid])
-
-    A = wp.array(np.ones((2, 2), dtype=float), dtype=float, requires_grad=True, device=device)
-    x = wp.array([[1.0], [2.0]], dtype=float, requires_grad=True, device=device)
-    b = wp.zeros_like(x)
-    y = wp.zeros_like(x)
-    loss = wp.zeros(1, requires_grad=True, device=device)
-
-    tape = wp.Tape()
-
-    with tape:
-        wp.matmul(A, x, b, y)
-        wp.launch(loss_kernel, dim=2, inputs=[y.flatten(), loss], device=device)
-
-    tape.backward(loss)
-    assert_np_equal(x.grad.numpy(), np.array([[0.0], [0.0]]))
+    assert f.getvalue() == expected
+    assert_np_equal(tape.gradients[x].numpy(), np.array(0.0))
 
 
 devices = get_test_devices()
@@ -156,8 +118,6 @@ add_function_test(TestOptions, "test_options_1", test_options_1, devices=devices
 add_function_test(TestOptions, "test_options_2", test_options_2, devices=devices)
 add_function_test(TestOptions, "test_options_3", test_options_3, devices=devices)
 add_function_test(TestOptions, "test_options_4", test_options_4, devices=devices)
-add_function_test(TestOptions, "test_options_5", test_options_5, devices=devices)
-add_function_test(TestOptions, "test_options_6", test_options_6, devices=devices)
 
 
 if __name__ == "__main__":

warp/tests/test_quat.py

@@ -11,6 +11,7 @@ import numpy as np
 
 import warp as wp
 from warp.tests.unittest_utils import *
+import warp.sim
 
 wp.init()
 
@@ -1871,6 +1872,21 @@ def test_quat_identity(test, device, dtype, register_kernels=False):
     assert_np_equal(output.numpy(), expected)
 
 
+############################################################
+
+
+def test_quat_euler_conversion(test, device, dtype, register_kernels=False):
+    rng = np.random.default_rng(123)
+    N = 3
+
+    rpy_arr = rng.uniform(low=-np.pi, high=np.pi, size=(N, 3))
+
+    quats_from_euler = [list(wp.sim.quat_from_euler(wp.vec3(*rpy), 0, 1, 2)) for rpy in rpy_arr]
+    quats_from_rpy = [list(wp.quat_rpy(rpy[0], rpy[1], rpy[2])) for rpy in rpy_arr]
+
+    assert_np_equal(np.array(quats_from_euler), np.array(quats_from_rpy), tol=1e-4)
+
+
 def test_anon_type_instance(test, device, dtype, register_kernels=False):
     rng = np.random.default_rng(123)
     wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
@@ -2053,6 +2069,13 @@ for dtype in np_float_types:
     add_function_test_register_kernel(
         TestQuat, f"test_quat_to_matrix_{dtype.__name__}", test_quat_to_matrix, devices=devices, dtype=dtype
     )
+    add_function_test_register_kernel(
+        TestQuat,
+        f"test_quat_euler_conversion_{dtype.__name__}",
+        test_quat_euler_conversion,
+        devices=devices,
+        dtype=dtype,
+    )
     add_function_test(
         TestQuat, f"test_py_arithmetic_ops_{dtype.__name__}", test_py_arithmetic_ops, devices=None, dtype=dtype
     )

warp/tests/test_snippet.py

@@ -86,6 +86,7 @@ def test_shared_memory(test, device):
 
     @wp.func_native(snippet)
     def reverse(d: wp.array(dtype=int), N: int, tid: int):
+        """Reverse the array d in place using shared memory."""
         return
 
     @wp.kernel
@@ -100,6 +101,7 @@ def test_shared_memory(test, device):
     wp.launch(kernel=reverse_kernel, dim=N, inputs=[x, N], device=device)
 
     assert_np_equal(x.numpy(), y)
+    assert reverse.__doc__ == "Reverse the array d in place using shared memory."
 
 
 def test_cpu_snippet(test, device):

warp/tests/test_utils.py

@@ -267,55 +267,60 @@ class TestUtils(unittest.TestCase):
     def test_warn(self):
         # Multiple warnings get printed out each time.
         with contextlib.redirect_stdout(io.StringIO()) as f:
-            frame_info = inspect.getframeinfo(inspect.currentframe())
             wp.utils.warn("hello, world!")
             wp.utils.warn("hello, world!")
 
         expected = (
-            "{}:{}: {}\n"
-            "{}:{}: {}\n"
-        ).format(
-            frame_info.filename,
-            frame_info.lineno + 1,
-            "UserWarning: hello, world!\n  wp.utils.warn(\"hello, world!\")",
-            frame_info.filename,
-            frame_info.lineno + 2,
-            "UserWarning: hello, world!\n  wp.utils.warn(\"hello, world!\")",
+            "Warp UserWarning: hello, world!\n"
+            "Warp UserWarning: hello, world!\n"
         )
+
         self.assertEqual(f.getvalue(), expected)
 
+        # Test verbose warnings
+        saved_verbosity = wp.config.verbose_warnings
+        try:
+            wp.config.verbose_warnings = True
+            with contextlib.redirect_stdout(io.StringIO()) as f:
+                frame_info = inspect.getframeinfo(inspect.currentframe())
+                wp.utils.warn("hello, world!")
+                wp.utils.warn("hello, world!")
+
+            expected = (
+                f"Warp UserWarning: hello, world! ({frame_info.filename}:{frame_info.lineno + 1})\n"
+                "  wp.utils.warn(\"hello, world!\")\n"
+                f"Warp UserWarning: hello, world! ({frame_info.filename}:{frame_info.lineno + 2})\n"
+                "  wp.utils.warn(\"hello, world!\")\n"
+            )
+
+            self.assertEqual(f.getvalue(), expected)
+
+        finally:
+            # make sure to restore warning verbosity
+            wp.config.verbose_warnings = saved_verbosity
+
+
         # Multiple similar deprecation warnings get printed out only once.
         with contextlib.redirect_stdout(io.StringIO()) as f:
-            frame_info = inspect.getframeinfo(inspect.currentframe())
             wp.utils.warn("hello, world!", category=DeprecationWarning)
             wp.utils.warn("hello, world!", category=DeprecationWarning)
 
         expected = (
-            "{}:{}: {}\n"
-        ).format(
-            frame_info.filename,
-            frame_info.lineno + 1,
-            "DeprecationWarning: hello, world!\n  wp.utils.warn(\"hello, world!\", category=DeprecationWarning)",
+            "Warp DeprecationWarning: hello, world!\n"
         )
+
         self.assertEqual(f.getvalue(), expected)
 
         # Multiple different deprecation warnings get printed out each time.
         with contextlib.redirect_stdout(io.StringIO()) as f:
-            frame_info = inspect.getframeinfo(inspect.currentframe())
             wp.utils.warn("foo", category=DeprecationWarning)
             wp.utils.warn("bar", category=DeprecationWarning)
 
         expected = (
-            "{}:{}: {}\n"
-            "{}:{}: {}\n"
-        ).format(
-            frame_info.filename,
-            frame_info.lineno + 1,
-            "DeprecationWarning: foo\n  wp.utils.warn(\"foo\", category=DeprecationWarning)",
-            frame_info.filename,
-            frame_info.lineno + 2,
-            "DeprecationWarning: bar\n  wp.utils.warn(\"bar\", category=DeprecationWarning)",
+            "Warp DeprecationWarning: foo\n"
+            "Warp DeprecationWarning: bar\n"
         )
+
         self.assertEqual(f.getvalue(), expected)
 
     def test_transform_expand(self):