warp-lang 1.9.0__py3-none-win_amd64.whl → 1.10.0rc2__py3-none-win_amd64.whl

warp/tests/test_tuple.py

@@ -13,6 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import sys
 import unittest
 from typing import Any, Tuple
 
@@ -208,6 +209,92 @@ def test_loop_variadic_ellipsis():
     wp.expect_eq(res, 22)
 
 
+# Test for Python 3.10 tuple type compatibility issue
+# Only define these functions on Python 3.9+ where lowercase tuple is supported
+if sys.version_info >= (3, 9):
+
+    @wp.func
+    def complex_tuple_function(scale: float, offset: wp.vec3) -> tuple[float, wp.vec3f, wp.vec3f]:
+        """
+        Function that returns a complex tuple with mixed types.
+        This specifically tests the tuple[float, wp.vec3f, wp.vec3f] case
+        that was problematic on Python 3.10.
+        """
+        # Create some computed values
+        scaled_value = scale * 2.5
+        position = wp.vec3f(offset.x + 1.0, offset.y + 2.0, offset.z + 3.0)
+        velocity = wp.vec3f(scale * 0.1, scale * 0.2, scale * 0.3)
+
+        return (scaled_value, position, velocity)
+
+    @wp.func
+    def mixed_types_tuple_function() -> tuple[wp.vec3f, wp.vec3f, float, wp.mat33f]:
+        """
+        Function returning mixed types in a tuple.
+        Tests tuple[vec3f, vec3f, float, mat33f] type annotation.
+        """
+        return (
+            wp.vec3f(1.0, 2.0, 3.0),
+            wp.vec3f(4.0, 5.0, 6.0),
+            42.0,
+            wp.mat33f(1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0),
+        )
+
+    @wp.func
+    def homogeneous_tuple_function() -> tuple[wp.vec3f, wp.vec3f, wp.vec3f]:
+        """
+        Function returning fixed-size homogeneous tuple.
+        Tests tuple[wp.vec3f, wp.vec3f, wp.vec3f] type annotation.
+        """
+        return (wp.vec3f(1.0, 2.0, 3.0), wp.vec3f(4.0, 5.0, 6.0), wp.vec3f(7.0, 8.0, 9.0))
+
+    @wp.kernel
+    def test_complex_tuple_functions():
+        """
+        Kernel that tests complex tuple return types that were problematic on Python 3.10.
+        """
+        # Test the main problematic case: tuple[float, wp.vec3f, wp.vec3f]
+        result1 = complex_tuple_function(4.0, wp.vec3(10.0, 20.0, 30.0))
+
+        # Unpack and verify
+        scale_result, pos_result, vel_result = result1
+        wp.expect_near(scale_result, 10.0)  # 4.0 * 2.5
+        wp.expect_eq(pos_result, wp.vec3f(11.0, 22.0, 33.0))
+        wp.expect_eq(vel_result, wp.vec3f(0.4, 0.8, 1.2))
+
+        # Test access by index
+        wp.expect_near(result1[0], 10.0)
+        wp.expect_eq(result1[1], wp.vec3f(11.0, 22.0, 33.0))
+        wp.expect_eq(result1[2], wp.vec3f(0.4, 0.8, 1.2))
+
+        # Test more complex tuple: tuple[vec3f, vec3f, float, mat33f]
+        mixed_result = mixed_types_tuple_function()
+        result_pos, result_vel, result_energy, result_transform = mixed_result
+
+        # Verify known values
+        wp.expect_eq(result_pos, wp.vec3f(1.0, 2.0, 3.0))
+        wp.expect_eq(result_vel, wp.vec3f(4.0, 5.0, 6.0))
+        wp.expect_eq(result_energy, 42.0)
+
+        # Verify transform matrix is identity
+        wp.expect_eq(result_transform[0, 0], 1.0)
+        wp.expect_eq(result_transform[1, 1], 1.0)
+        wp.expect_eq(result_transform[2, 2], 1.0)
+
+        # Test fixed-size homogeneous tuple: tuple[wp.vec3f, wp.vec3f, wp.vec3f]
+        homo_result = homogeneous_tuple_function()
+        wp.expect_eq(len(homo_result), 3)
+        wp.expect_eq(homo_result[0], wp.vec3f(1.0, 2.0, 3.0))
+        wp.expect_eq(homo_result[1], wp.vec3f(4.0, 5.0, 6.0))
+        wp.expect_eq(homo_result[2], wp.vec3f(7.0, 8.0, 9.0))
+
+        # Test unpacking
+        vec1, vec2, vec3 = homo_result
+        wp.expect_eq(vec1, wp.vec3f(1.0, 2.0, 3.0))
+        wp.expect_eq(vec2, wp.vec3f(4.0, 5.0, 6.0))
+        wp.expect_eq(vec3, wp.vec3f(7.0, 8.0, 9.0))
+
+
 devices = get_test_devices()
 
 
@@ -258,6 +345,15 @@ add_kernel_test(
     dim=1,
     devices=devices,
 )
+# Only register the test for lowercase tuple syntax on Python 3.9+
+if sys.version_info >= (3, 9):
+    add_kernel_test(
+        TestTuple,
+        name="test_complex_tuple_functions",
+        kernel=test_complex_tuple_functions,
+        dim=1,
+        devices=devices,
+    )
 
 
 if __name__ == "__main__":

warp/tests/test_types.py

@@ -13,6 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import sys
 import unittest
 
 from warp.tests.unittest_utils import *
@@ -79,13 +80,13 @@ def test_floats(test, device, dtype):
 def test_vector(test, device, dtype):
     def make_scalar(x):
         # Cast to the correct integer type to simulate wrapping.
-        if dtype in wp.types.int_types:
+        if dtype in wp._src.types.int_types:
             return dtype._type_(x).value
 
         return x
 
     def make_vec(*args):
-        if dtype in wp.types.int_types:
+        if dtype in wp._src.types.int_types:
             # Cast to the correct integer type to simulate wrapping.
             return tuple(dtype._type_(x).value for x in args)
 
@@ -143,6 +144,12 @@ def test_vector(test, device, dtype):
     test.assertTrue(v != vec3_cls(1, 2, 3))
     test.assertEqual(str(v), "[{}]".format(", ".join(str(x) for x in v)))
 
+    # Copy constructor.
+    v_copy = vec3_cls(v)
+    v_copy[0] = 123
+    test.assertSequenceEqual(v, make_vec(2, 4, 6))
+    test.assertSequenceEqual(v_copy, make_vec(123, 4, 6))
+
     # Check added purely for coverage reasons but is this really a desired
     # behaviour? Not allowing to define new attributes using systems like
     # `__slots__` could help improving memory usage.
@@ -281,24 +288,24 @@ class TestTypes(unittest.TestCase):
             v2[:1] = (v2,)
 
     def test_matrix(self):
-        for dtype in (*wp.types.float_types, float):
+        for dtype in (*wp._src.types.float_types, float):
 
             def make_scalar(x, dtype=dtype):
                 # Cast to the correct integer type to simulate wrapping.
-                if dtype in wp.types.int_types:
+                if dtype in wp._src.types.int_types:
                     return dtype._type_(x).value
 
                 return x
 
             def make_vec(*args, dtype=dtype):
-                if dtype in wp.types.int_types:
+                if dtype in wp._src.types.int_types:
                     # Cast to the correct integer type to simulate wrapping.
                     return tuple(dtype._type_(x).value for x in args)
 
                 return args
 
             def make_mat(*args, dtype=dtype):
-                if dtype in wp.types.int_types:
+                if dtype in wp._src.types.int_types:
                     # Cast to the correct integer type to simulate wrapping.
                     return tuple(tuple(dtype._type_(x).value for x in row) for row in args)
 
@@ -419,6 +426,12 @@ class TestTypes(unittest.TestCase):
                 "[{}]".format(",\n ".join("[{}]".format(", ".join(str(y) for y in m[x])) for x in range(m._shape_[0]))),
             )
 
+            # Copy constructor.
+            m_copy = mat22_cls(m)
+            m_copy[0, 0] = 123
+            self.assertSequenceEqual(m, make_mat((2, 4), (6, 8)))
+            self.assertSequenceEqual(m_copy, make_mat((123, 4), (6, 8)))
+
             # Check added purely for coverage reasons but is this really a desired
             # behaviour? Not allowing to define new attributes using systems like
             # `__slots__` could help improving memory usage.
@@ -527,14 +540,74 @@ class TestTypes(unittest.TestCase):
         test_conversions(wp.uint64, np.uint64)
         test_conversions(wp.bool, np.bool_)
 
+    # Only define this test method on Python 3.9+ where lowercase tuple is supported
+    if sys.version_info >= (3, 9):
+
+        def test_tuple_type_code_generation(self):
+            """Test that tuple type annotations generate correct type codes, especially on Python 3.10."""
+            import sys
+            import types
+            from typing import get_origin
+
+            # Test basic tuple types
+            tuple_float_float = tuple[float, float]
+            result = wp._src.types.get_type_code(tuple_float_float)
+            self.assertEqual(result, "tpl2f4f4", "tuple[float, float] should generate 'tpl2f4f4'")
+
+            # Test tuple with Warp vector types - the problematic case from Python 3.10
+            tuple_mixed = tuple[float, wp.vec3f, wp.vec3f]
+            result = wp._src.types.get_type_code(tuple_mixed)
+            self.assertEqual(result, "tpl3f4v3f4v3f4", "tuple[float, vec3f, vec3f] should generate 'tpl3f4v3f4v3f4'")
+
+            # Test homogeneous tuple with ellipsis
+            tuple_homogeneous = tuple[wp.vec3f, ...]
+            result = wp._src.types.get_type_code(tuple_homogeneous)
+            self.assertEqual(result, "tpl2v3f4?", "tuple[vec3f, ...] should generate 'tpl2v3f4?'")
+
+            # Test single element tuple
+            tuple_single = tuple[wp.int32]
+            result = wp._src.types.get_type_code(tuple_single)
+            self.assertEqual(result, "tpl1i4", "tuple[int32] should generate 'tpl1i4'")
+
+            # Test tuple with multiple Warp types
+            tuple_multi_warp = tuple[wp.vec3f, wp.mat33f, wp.quatf]
+            result = wp._src.types.get_type_code(tuple_multi_warp)
+            self.assertEqual(
+                result, "tpl3v3f4m33f4qf4", "tuple[vec3f, mat33f, quatf] should generate 'tpl3v3f4m33f4qf4'"
+            )
 
-for dtype in wp.types.int_types:
+            # Verify the fix works on Python 3.9-3.10 specifically
+            if sys.version_info < (3, 11) and hasattr(types, "GenericAlias"):
+                # On Python 3.9-3.10, tuple[...] creates types.GenericAlias
+                self.assertIsInstance(
+                    tuple_mixed, types.GenericAlias, "On Python 3.9-3.10, tuple[...] should create types.GenericAlias"
+                )
+                self.assertIs(tuple_mixed.__origin__, tuple, "GenericAlias origin should be tuple")
+
+                # Verify our fix catches this case
+                self.assertEqual(get_origin(tuple_mixed), tuple, "get_origin should return tuple")
+            elif sys.version_info >= (3, 11):
+                # On Python 3.11+, the existing code path should handle it
+                self.assertEqual(get_origin(tuple_mixed), tuple, "get_origin should return tuple on Python 3.11+")
+
+            # Test that the fix doesn't break existing functionality
+            # Test with built-in Python types
+            tuple_builtin = tuple[int, str, bool]
+            try:
+                # This might fail because str and bool aren't Warp types, but it shouldn't crash
+                wp._src.types.get_type_code(tuple_builtin)
+            except TypeError as e:
+                # Expected to fail for non-Warp types, but should be a clean TypeError
+                self.assertIn("Unrecognized type", str(e))
+
+
+for dtype in wp._src.types.int_types:
     add_function_test(TestTypes, f"test_integers_{dtype.__name__}", test_integers, devices=devices, dtype=dtype)
 
-for dtype in wp.types.float_types:
+for dtype in wp._src.types.float_types:
     add_function_test(TestTypes, f"test_floats_{dtype.__name__}", test_floats, devices=devices, dtype=dtype)
 
-for dtype in (*wp.types.scalar_types, int, float):
+for dtype in (*wp._src.types.scalar_types, int, float):
     add_function_test(TestTypes, f"test_vector_{dtype.__name__}", test_vector, devices=devices, dtype=dtype)
 
 if __name__ == "__main__":

warp/tests/test_utils.py

@@ -18,8 +18,8 @@ import inspect
 import io
 import unittest
 
+from warp._src.types import type_scalar_type
 from warp.tests.unittest_utils import *
-from warp.types import type_scalar_type
 
 
 def test_array_scan(test, device):
@@ -37,8 +37,8 @@ def test_array_scan(test, device):
         result_inc = wp.zeros_like(values)
         result_exc = wp.zeros_like(values)
 
-        wp.utils.array_scan(values, result_inc, True)
-        wp.utils.array_scan(values, result_exc, False)
+        wp._src.utils.array_scan(values, result_inc, True)
+        wp._src.utils.array_scan(values, result_exc, False)
 
         tolerance = 0 if dtype == int else 1e-3
 
@@ -54,7 +54,7 @@ def test_array_scan(test, device):
 def test_array_scan_empty(test, device):
     values = wp.array((), dtype=int, device=device)
     result = wp.array((), dtype=int, device=device)
-    wp.utils.array_scan(values, result)
+    wp._src.utils.array_scan(values, result)
 
 
 def test_array_scan_error_sizes_mismatch(test, device):
@@ -64,7 +64,7 @@ def test_array_scan_error_sizes_mismatch(test, device):
         RuntimeError,
         r"In and out array storage sizes do not match \(123 vs 234\)$",
     ):
-        wp.utils.array_scan(values, result, True)
+        wp._src.utils.array_scan(values, result, True)
 
 
 def test_array_scan_error_dtypes_mismatch(test, device):
@@ -74,7 +74,7 @@ def test_array_scan_error_dtypes_mismatch(test, device):
         RuntimeError,
         r"In and out array data types do not match \(int32 vs float32\)$",
     ):
-        wp.utils.array_scan(values, result, True)
+        wp._src.utils.array_scan(values, result, True)
 
 
 def test_array_scan_error_unsupported_dtype(test, device):
@@ -84,7 +84,7 @@ def test_array_scan_error_unsupported_dtype(test, device):
         RuntimeError,
         r"Unsupported data type: vec3f$",
     ):
-        wp.utils.array_scan(values, result, True)
+        wp._src.utils.array_scan(values, result, True)
 
 
 def test_radix_sort_pairs(test, device):
@@ -93,7 +93,7 @@ def test_radix_sort_pairs(test, device):
     for keyType in keyTypes:
         keys = wp.array((7, 2, 8, 4, 1, 6, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0), dtype=keyType, device=device)
         values = wp.array((1, 2, 3, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0), dtype=int, device=device)
-        wp.utils.radix_sort_pairs(keys, values, 8)
+        wp._src.utils.radix_sort_pairs(keys, values, 8)
         assert_np_equal(keys.numpy()[:8], np.array((1, 2, 3, 4, 5, 6, 7, 8)))
         assert_np_equal(values.numpy()[:8], np.array((5, 2, 8, 4, 7, 6, 1, 3)))
 
@@ -104,7 +104,7 @@ def test_segmented_sort_pairs(test, device):
     for keyType in keyTypes:
         keys = wp.array((7, 2, 8, 4, 1, 6, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0), dtype=keyType, device=device)
         values = wp.array((1, 2, 3, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0), dtype=int, device=device)
-        wp.utils.segmented_sort_pairs(
+        wp._src.utils.segmented_sort_pairs(
             keys,
             values,
             8,
@@ -121,7 +121,7 @@ def test_radix_sort_pairs_empty(test, device):
     for keyType in keyTypes:
         keys = wp.array((), dtype=keyType, device=device)
         values = wp.array((), dtype=int, device=device)
-        wp.utils.radix_sort_pairs(keys, values, 0)
+        wp._src.utils.radix_sort_pairs(keys, values, 0)
 
 
 def test_segmented_sort_pairs_empty(test, device):
@@ -130,7 +130,7 @@ def test_segmented_sort_pairs_empty(test, device):
     for keyType in keyTypes:
         keys = wp.array((), dtype=keyType, device=device)
         values = wp.array((), dtype=int, device=device)
-        wp.utils.segmented_sort_pairs(
+        wp._src.utils.segmented_sort_pairs(
             keys, values, 0, wp.array((), dtype=int, device=device), wp.array((), dtype=int, device=device)
         )
 
@@ -145,7 +145,7 @@ def test_radix_sort_pairs_error_insufficient_storage(test, device):
             RuntimeError,
             r"Keys and values array storage must be large enough to contain 2\*count elements$",
         ):
-            wp.utils.radix_sort_pairs(keys, values, 3)
+            wp._src.utils.radix_sort_pairs(keys, values, 3)
 
 
 def test_segmented_sort_pairs_error_insufficient_storage(test, device):
@@ -158,7 +158,7 @@ def test_segmented_sort_pairs_error_insufficient_storage(test, device):
             RuntimeError,
             r"Array storage must be large enough to contain 2\*count elements$",
         ):
-            wp.utils.segmented_sort_pairs(
+            wp._src.utils.segmented_sort_pairs(
                 keys,
                 values,
                 3,
@@ -177,7 +177,7 @@ def test_radix_sort_pairs_error_unsupported_dtype(test, device):
             RuntimeError,
             rf"Unsupported keys and values data types: {keyType.__name__}, float32$",
         ):
-            wp.utils.radix_sort_pairs(keys, values, 1)
+            wp._src.utils.radix_sort_pairs(keys, values, 1)
 
 
 def test_segmented_sort_pairs_error_unsupported_dtype(test, device):
@@ -190,7 +190,7 @@ def test_segmented_sort_pairs_error_unsupported_dtype(test, device):
             RuntimeError,
             rf"Unsupported data type: {keyType.__name__}$",
         ):
-            wp.utils.segmented_sort_pairs(
+            wp._src.utils.segmented_sort_pairs(
                 keys,
                 values,
                 1,
@@ -203,11 +203,11 @@ def test_array_sum(test, device):
     for dtype in (wp.float32, wp.float64):
         with test.subTest(dtype=dtype):
             values = wp.array((1.0, 2.0, 3.0), dtype=dtype, device=device)
-            test.assertEqual(wp.utils.array_sum(values), 6.0)
+            test.assertEqual(wp._src.utils.array_sum(values), 6.0)
 
             values = wp.array((1.0, 2.0, 3.0), dtype=dtype, device=device)
             result = wp.empty(shape=(1,), dtype=dtype, device=device)
-            wp.utils.array_sum(values, out=result)
+            wp._src.utils.array_sum(values, out=result)
             test.assertEqual(result.numpy()[0], 6.0)
 
 
@@ -218,7 +218,7 @@ def test_array_sum_error_out_dtype_mismatch(test, device):
         RuntimeError,
         r"out array should have type float32$",
     ):
-        wp.utils.array_sum(values, out=result)
+        wp._src.utils.array_sum(values, out=result)
 
 
 def test_array_sum_error_out_shape_mismatch(test, device):
@@ -228,7 +228,7 @@ def test_array_sum_error_out_shape_mismatch(test, device):
         RuntimeError,
         r"out array should have shape \(1,\)$",
     ):
-        wp.utils.array_sum(values, out=result)
+        wp._src.utils.array_sum(values, out=result)
 
 
 def test_array_sum_error_unsupported_dtype(test, device):
@@ -237,25 +237,25 @@ def test_array_sum_error_unsupported_dtype(test, device):
         RuntimeError,
         r"Unsupported data type: int32$",
     ):
-        wp.utils.array_sum(values)
+        wp._src.utils.array_sum(values)
 
 
 def test_array_inner(test, device):
     for dtype in (wp.float32, wp.float64, wp.vec3):
         a = wp.array((1.0, 2.0, 3.0), dtype=dtype, device=device)
         b = wp.array((1.0, 2.0, 3.0), dtype=dtype, device=device)
-        test.assertEqual(wp.utils.array_inner(a, b), 14.0)
+        test.assertEqual(wp._src.utils.array_inner(a, b), 14.0)
 
         a = wp.array((1.0, 2.0, 3.0), dtype=dtype, device=device)
         b = wp.array((1.0, 2.0, 3.0), dtype=dtype, device=device)
         result = wp.empty(shape=(1,), dtype=type_scalar_type(dtype), device=device)
-        wp.utils.array_inner(a, b, out=result)
+        wp._src.utils.array_inner(a, b, out=result)
         test.assertEqual(result.numpy()[0], 14.0)
 
     # test with different instances of same type
     a = wp.array((1.0, 2.0, 3.0), dtype=wp.vec3, device=device)
     b = wp.array((1.0, 2.0, 3.0), dtype=wp.vec(3, float), device=device)
-    test.assertEqual(wp.utils.array_inner(a, b), 14.0)
+    test.assertEqual(wp._src.utils.array_inner(a, b), 14.0)
 
 
 def test_array_inner_error_sizes_mismatch(test, device):
@@ -265,7 +265,7 @@ def test_array_inner_error_sizes_mismatch(test, device):
         RuntimeError,
         r"A and b array storage sizes do not match \(2 vs 3\)$",
     ):
-        wp.utils.array_inner(a, b)
+        wp._src.utils.array_inner(a, b)
 
 
 def test_array_inner_error_dtypes_mismatch(test, device):
@@ -275,7 +275,7 @@ def test_array_inner_error_dtypes_mismatch(test, device):
         RuntimeError,
         r"A and b array data types do not match \(float32 vs float64\)$",
     ):
-        wp.utils.array_inner(a, b)
+        wp._src.utils.array_inner(a, b)
 
 
 def test_array_inner_error_out_dtype_mismatch(test, device):
@@ -286,7 +286,7 @@ def test_array_inner_error_out_dtype_mismatch(test, device):
         RuntimeError,
         r"out array should have type float32$",
     ):
-        wp.utils.array_inner(a, b, result)
+        wp._src.utils.array_inner(a, b, result)
 
 
 def test_array_inner_error_out_shape_mismatch(test, device):
@@ -297,7 +297,7 @@ def test_array_inner_error_out_shape_mismatch(test, device):
         RuntimeError,
         r"out array should have shape \(1,\)$",
     ):
-        wp.utils.array_inner(a, b, result)
+        wp._src.utils.array_inner(a, b, result)
 
 
 def test_array_inner_error_unsupported_dtype(test, device):
@@ -307,34 +307,34 @@ def test_array_inner_error_unsupported_dtype(test, device):
         RuntimeError,
         r"Unsupported data type: int32$",
     ):
-        wp.utils.array_inner(a, b)
+        wp._src.utils.array_inner(a, b)
 
 
 def test_array_cast(test, device):
     values = wp.array((1, 2, 3), dtype=int, device=device)
     result = wp.empty(3, dtype=float, device=device)
-    wp.utils.array_cast(values, result)
+    wp._src.utils.array_cast(values, result)
     test.assertEqual(result.dtype, wp.float32)
     test.assertEqual(result.shape, (3,))
     assert_np_equal(result.numpy(), np.array((1.0, 2.0, 3.0), dtype=float))
 
     values = wp.array((1, 2, 3, 4), dtype=int, device=device)
     result = wp.empty((2, 2), dtype=float, device=device)
-    wp.utils.array_cast(values, result)
+    wp._src.utils.array_cast(values, result)
     test.assertEqual(result.dtype, wp.float32)
     test.assertEqual(result.shape, (2, 2))
     assert_np_equal(result.numpy(), np.array(((1.0, 2.0), (3.0, 4.0)), dtype=float))
 
     values = wp.array(((1, 2), (3, 4)), dtype=wp.vec2, device=device)
     result = wp.zeros(2, dtype=float, device=device)
-    wp.utils.array_cast(values, result, count=1)
+    wp._src.utils.array_cast(values, result, count=1)
     test.assertEqual(result.dtype, wp.float32)
     test.assertEqual(result.shape, (2,))
     assert_np_equal(result.numpy(), np.array((1.0, 2.0), dtype=float))
 
     values = wp.array(((1, 2), (3, 4)), dtype=int, device=device)
     result = wp.zeros((2, 2), dtype=int, device=device)
-    wp.utils.array_cast(values, result)
+    wp._src.utils.array_cast(values, result)
     test.assertEqual(result.dtype, wp.int32)
     test.assertEqual(result.shape, (2, 2))
     assert_np_equal(result.numpy(), np.array(((1, 2), (3, 4)), dtype=int))
@@ -347,7 +347,7 @@ def test_array_cast_error_unsupported_partial_cast(test, device):
         RuntimeError,
         r"Partial cast is not supported for arrays with more than one dimension$",
     ):
-        wp.utils.array_cast(values, result, count=1)
+        wp._src.utils.array_cast(values, result, count=1)
 
 
 devices = get_test_devices()
@@ -357,8 +357,8 @@ class TestUtils(unittest.TestCase):
     def test_warn(self):
         # Multiple warnings get printed out each time.
         with contextlib.redirect_stdout(io.StringIO()) as f:
-            wp.utils.warn("hello, world!")
-            wp.utils.warn("hello, world!")
+            wp._src.utils.warn("hello, world!")
+            wp._src.utils.warn("hello, world!")
 
         expected = "Warp UserWarning: hello, world!\nWarp UserWarning: hello, world!\n"
 
@@ -370,14 +370,14 @@ class TestUtils(unittest.TestCase):
             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!")
+                wp._src.utils.warn("hello, world!")
+                wp._src.utils.warn("hello, world!")
 
             expected = (
                 f"Warp UserWarning: hello, world! ({frame_info.filename}:{frame_info.lineno + 1})\n"
-                '  wp.utils.warn("hello, world!")\n'
+                '  wp._src.utils.warn("hello, world!")\n'
                 f"Warp UserWarning: hello, world! ({frame_info.filename}:{frame_info.lineno + 2})\n"
-                '  wp.utils.warn("hello, world!")\n'
+                '  wp._src.utils.warn("hello, world!")\n'
             )
 
             self.assertEqual(f.getvalue(), expected)
@@ -388,8 +388,8 @@ class TestUtils(unittest.TestCase):
 
         # Multiple similar deprecation warnings get printed out only once.
         with contextlib.redirect_stdout(io.StringIO()) as f:
-            wp.utils.warn("hello, world!", category=DeprecationWarning)
-            wp.utils.warn("hello, world!", category=DeprecationWarning)
+            wp._src.utils.warn("hello, world!", category=DeprecationWarning)
+            wp._src.utils.warn("hello, world!", category=DeprecationWarning)
 
         expected = "Warp DeprecationWarning: hello, world!\n"
 
@@ -397,8 +397,8 @@ class TestUtils(unittest.TestCase):
 
         # Multiple different deprecation warnings get printed out each time.
         with contextlib.redirect_stdout(io.StringIO()) as f:
-            wp.utils.warn("foo", category=DeprecationWarning)
-            wp.utils.warn("bar", category=DeprecationWarning)
+            wp._src.utils.warn("foo", category=DeprecationWarning)
+            wp._src.utils.warn("bar", category=DeprecationWarning)
 
         expected = "Warp DeprecationWarning: foo\nWarp DeprecationWarning: bar\n"
 
@@ -407,7 +407,7 @@ class TestUtils(unittest.TestCase):
     def test_transform_expand(self):
         t = (1.0, 2.0, 3.0, 4.0, 3.0, 2.0, 1.0)
         self.assertEqual(
-            wp.utils.transform_expand(t),
+            wp._src.utils.transform_expand(t),
             wp.transformf(p=(1.0, 2.0, 3.0), q=(4.0, 3.0, 2.0, 1.0)),
         )
 
@@ -419,7 +419,7 @@ class TestUtils(unittest.TestCase):
             RuntimeError,
             r"In and out array storage devices do not match \(cpu vs cuda:0\)$",
         ):
-            wp.utils.array_scan(values, result, True)
+            wp._src.utils.array_scan(values, result, True)
 
     @unittest.skipUnless(wp.is_cuda_available(), "Requires CUDA")
     def test_radix_sort_pairs_error_devices_mismatch(self):
@@ -429,7 +429,7 @@ class TestUtils(unittest.TestCase):
             RuntimeError,
             r"Keys and values array storage devices do not match \(cpu vs cuda:0\)$",
         ):
-            wp.utils.radix_sort_pairs(keys, values, 1)
+            wp._src.utils.radix_sort_pairs(keys, values, 1)
 
     @unittest.skipUnless(wp.is_cuda_available(), "Requires CUDA")
     def test_array_inner_error_out_device_mismatch(self):
@@ -440,7 +440,7 @@ class TestUtils(unittest.TestCase):
             RuntimeError,
             r"out storage device should match values array$",
         ):
-            wp.utils.array_inner(a, b, result)
+            wp._src.utils.array_inner(a, b, result)
 
     @unittest.skipUnless(wp.is_cuda_available(), "Requires CUDA")
     def test_array_sum_error_out_device_mismatch(self):
@@ -450,7 +450,7 @@ class TestUtils(unittest.TestCase):
             RuntimeError,
             r"out storage device should match values array$",
         ):
-            wp.utils.array_sum(values, out=result)
+            wp._src.utils.array_sum(values, out=result)
 
     @unittest.skipUnless(wp.is_cuda_available(), "Requires CUDA")
     def test_array_inner_error_devices_mismatch(self):
@@ -460,7 +460,7 @@ class TestUtils(unittest.TestCase):
             RuntimeError,
             r"A and b array storage devices do not match \(cpu vs cuda:0\)$",
         ):
-            wp.utils.array_inner(a, b)
+            wp._src.utils.array_inner(a, b)
 
     @unittest.skipUnless(wp.is_cuda_available(), "Requires CUDA")
     def test_array_cast_error_devices_mismatch(self):
@@ -470,14 +470,14 @@ class TestUtils(unittest.TestCase):
             RuntimeError,
             r"Array storage devices do not match \(cpu vs cuda:0\)$",
         ):
-            wp.utils.array_cast(values, result)
+            wp._src.utils.array_cast(values, result)
 
     def test_mesh_adjacency(self):
         triangles = (
             (0, 3, 1),
             (0, 2, 3),
         )
-        adj = wp.utils.MeshAdjacency(triangles, len(triangles))
+        adj = wp._src.utils.MeshAdjacency(triangles, len(triangles))
         expected_edges = {
             (0, 3): (0, 3, 1, 2, 0, 1),
             (1, 3): (3, 1, 0, -1, 0, -1),
@@ -496,7 +496,7 @@ class TestUtils(unittest.TestCase):
         )
 
         with contextlib.redirect_stdout(io.StringIO()) as f:
-            wp.utils.MeshAdjacency(triangles, len(triangles))
+            wp._src.utils.MeshAdjacency(triangles, len(triangles))
 
         self.assertEqual(f.getvalue(), "Detected non-manifold edge\n")