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

warp/tests/test_types.py

@@ -80,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)
 
@@ -144,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.
@@ -282,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)
 
@@ -420,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.
@@ -539,27 +551,27 @@ class TestTypes(unittest.TestCase):
 
             # Test basic tuple types
             tuple_float_float = tuple[float, float]
-            result = wp.types.get_type_code(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.types.get_type_code(tuple_mixed)
+            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.types.get_type_code(tuple_homogeneous)
+            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.types.get_type_code(tuple_single)
+            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.types.get_type_code(tuple_multi_warp)
+            result = wp._src.types.get_type_code(tuple_multi_warp)
             self.assertEqual(
                 result, "tpl3v3f4m33f4qf4", "tuple[vec3f, mat33f, quatf] should generate 'tpl3v3f4m33f4qf4'"
             )
@@ -583,19 +595,19 @@ class TestTypes(unittest.TestCase):
             tuple_builtin = tuple[int, str, bool]
             try:
                 # This might fail because str and bool aren't Warp types, but it shouldn't crash
-                wp.types.get_type_code(tuple_builtin)
+                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.types.int_types:
+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")
 

warp/tests/test_vec.py

@@ -83,11 +83,11 @@ def test_negation(test, device, dtype, register_kernels=False):
         np.float64: 1.0e-8,
     }.get(dtype, 0)
 
-    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
-    vec2 = wp.types.vector(length=2, dtype=wptype)
-    vec3 = wp.types.vector(length=3, dtype=wptype)
-    vec4 = wp.types.vector(length=4, dtype=wptype)
-    vec5 = wp.types.vector(length=5, dtype=wptype)
+    wptype = wp._src.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    vec2 = wp._src.types.vector(length=2, dtype=wptype)
+    vec3 = wp._src.types.vector(length=3, dtype=wptype)
+    vec4 = wp._src.types.vector(length=4, dtype=wptype)
+    vec5 = wp._src.types.vector(length=5, dtype=wptype)
 
     def check_negation(
         v2: wp.array(dtype=vec2),
@@ -198,11 +198,11 @@ def test_negation(test, device, dtype, register_kernels=False):
 
 
 def test_subtraction_unsigned(test, device, dtype, register_kernels=False):
-    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
-    vec2 = wp.types.vector(length=2, dtype=wptype)
-    vec3 = wp.types.vector(length=3, dtype=wptype)
-    vec4 = wp.types.vector(length=4, dtype=wptype)
-    vec5 = wp.types.vector(length=5, dtype=wptype)
+    wptype = wp._src.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    vec2 = wp._src.types.vector(length=2, dtype=wptype)
+    vec3 = wp._src.types.vector(length=3, dtype=wptype)
+    vec4 = wp._src.types.vector(length=4, dtype=wptype)
+    vec5 = wp._src.types.vector(length=5, dtype=wptype)
 
     def check_subtraction_unsigned():
         wp.expect_eq(vec2(wptype(3), wptype(4)) - vec2(wptype(1), wptype(2)), vec2(wptype(2), wptype(2)))
@@ -237,11 +237,11 @@ def test_subtraction(test, device, dtype, register_kernels=False):
         np.float64: 1.0e-8,
     }.get(dtype, 0)
 
-    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
-    vec2 = wp.types.vector(length=2, dtype=wptype)
-    vec3 = wp.types.vector(length=3, dtype=wptype)
-    vec4 = wp.types.vector(length=4, dtype=wptype)
-    vec5 = wp.types.vector(length=5, dtype=wptype)
+    wptype = wp._src.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    vec2 = wp._src.types.vector(length=2, dtype=wptype)
+    vec3 = wp._src.types.vector(length=3, dtype=wptype)
+    vec4 = wp._src.types.vector(length=4, dtype=wptype)
+    vec5 = wp._src.types.vector(length=5, dtype=wptype)
 
     def check_subtraction(
         s2: wp.array(dtype=vec2),
@@ -374,11 +374,11 @@ def test_length(test, device, dtype, register_kernels=False):
         np.float64: 1.0e-7,
     }.get(dtype, 0)
 
-    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
-    vec2 = wp.types.vector(length=2, dtype=wptype)
-    vec3 = wp.types.vector(length=3, dtype=wptype)
-    vec4 = wp.types.vector(length=4, dtype=wptype)
-    vec5 = wp.types.vector(length=5, dtype=wptype)
+    wptype = wp._src.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    vec2 = wp._src.types.vector(length=2, dtype=wptype)
+    vec3 = wp._src.types.vector(length=3, dtype=wptype)
+    vec4 = wp._src.types.vector(length=4, dtype=wptype)
+    vec5 = wp._src.types.vector(length=5, dtype=wptype)
 
     def check_length(
         v2: wp.array(dtype=vec2),
@@ -496,11 +496,11 @@ def test_normalize(test, device, dtype, register_kernels=False):
         np.float64: 1.0e-8,
     }.get(dtype, 0)
 
-    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
-    vec2 = wp.types.vector(length=2, dtype=wptype)
-    vec3 = wp.types.vector(length=3, dtype=wptype)
-    vec4 = wp.types.vector(length=4, dtype=wptype)
-    vec5 = wp.types.vector(length=5, dtype=wptype)
+    wptype = wp._src.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    vec2 = wp._src.types.vector(length=2, dtype=wptype)
+    vec3 = wp._src.types.vector(length=3, dtype=wptype)
+    vec4 = wp._src.types.vector(length=4, dtype=wptype)
+    vec5 = wp._src.types.vector(length=5, dtype=wptype)
 
     def check_normalize(
         v2: wp.array(dtype=vec2),
@@ -703,8 +703,8 @@ def test_crossproduct(test, device, dtype, register_kernels=False):
         np.float64: 1.0e-8,
     }.get(dtype, 0)
 
-    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
-    vec3 = wp.types.vector(length=3, dtype=wptype)
+    wptype = wp._src.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    vec3 = wp._src.types.vector(length=3, dtype=wptype)
 
     def check_cross(
         s3: wp.array(dtype=vec3),
@@ -790,7 +790,7 @@ def test_crossproduct(test, device, dtype, register_kernels=False):
 
 
 @wp.kernel(module="unique")
-def test_vector_mutation(expected: wp.types.vector(length=10, dtype=float)):
+def test_vector_mutation(expected: wp._src.types.vector(length=10, dtype=float)):
     v = wp.vector(length=10, dtype=float)
 
     # test element indexing
@@ -1349,7 +1349,7 @@ class TestVec(unittest.TestCase):
         self.assertSequenceEqual(v, (0, 1, 2))
 
 
-vec10 = wp.types.vector(length=10, dtype=float)
+vec10 = wp._src.types.vector(length=10, dtype=float)
 add_kernel_test(
     TestVec,
     test_vector_mutation,

warp/tests/test_vec_constructors.py

@@ -105,17 +105,17 @@ def test_tpl_constructor_error_numeric_args_mismatch(test, device):
 
 def test_casting_constructors(test, device, dtype, register_kernels=False):
     np_type = np.dtype(dtype)
-    wp_type = wp.types.np_dtype_to_warp_type[np_type]
-    vec3 = wp.types.vector(length=3, dtype=wp_type)
+    wp_type = wp._src.types.np_dtype_to_warp_type[np_type]
+    vec3 = wp._src.types.vector(length=3, dtype=wp_type)
 
     np16 = np.dtype(np.float16)
-    wp16 = wp.types.np_dtype_to_warp_type[np16]
+    wp16 = wp._src.types.np_dtype_to_warp_type[np16]
 
     np32 = np.dtype(np.float32)
-    wp32 = wp.types.np_dtype_to_warp_type[np32]
+    wp32 = wp._src.types.np_dtype_to_warp_type[np32]
 
     np64 = np.dtype(np.float64)
-    wp64 = wp.types.np_dtype_to_warp_type[np64]
+    wp64 = wp._src.types.np_dtype_to_warp_type[np64]
 
     def cast_float16(a: wp.array(dtype=wp_type, ndim=2), b: wp.array(dtype=wp16, ndim=2)):
         tid = wp.tid()