warp-lang 1.2.1__py3-none-manylinux2014_x86_64.whl → 1.3.0__py3-none-manylinux2014_x86_64.whl

warp/tests/test_implicit_init.py

@@ -0,0 +1,354 @@
+# 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 unittest
+
+import warp as wp
+from warp.tests.unittest_utils import *
+
+#   Array Initialization
+# ------------------------------------------------------------------------------
+
+
+def test_array_from_data(test, device):
+    wp.array((1.0, 2.0, 3.0), dtype=float)
+
+
+class TestImplicitInitArrayFromData(unittest.TestCase):
+    pass
+
+
+add_function_test(
+    TestImplicitInitArrayFromData,
+    "test_array_from_data",
+    test_array_from_data,
+    check_output=False,
+)
+
+
+def test_array_from_ptr(test, device):
+    wp.array(ptr=0, shape=(123,), dtype=float)
+
+
+class TestImplicitInitArrayFromPtr(unittest.TestCase):
+    pass
+
+
+add_function_test(
+    TestImplicitInitArrayFromPtr,
+    "test_array_from_ptr",
+    test_array_from_ptr,
+    check_output=False,
+)
+
+
+#   Builtin Call
+# ------------------------------------------------------------------------------
+
+
+def test_builtin_call(test, device):
+    wp.sin(1.23)
+
+
+class TestImplicitInitBuiltinCall(unittest.TestCase):
+    pass
+
+
+add_function_test(
+    TestImplicitInitBuiltinCall,
+    "test_builtin_call",
+    test_builtin_call,
+    check_output=False,
+)
+
+
+#   Devices
+# ------------------------------------------------------------------------------
+
+
+def test_get_cuda_device_count(test, device):
+    wp.get_cuda_device_count()
+
+
+class TestImplicitInitGetCudaDeviceCount(unittest.TestCase):
+    pass
+
+
+add_function_test(
+    TestImplicitInitGetCudaDeviceCount,
+    "test_get_cuda_device_count",
+    test_get_cuda_device_count,
+    check_output=False,
+)
+
+
+def test_get_cuda_devices(test, device):
+    wp.get_cuda_devices()
+
+
+class TestImplicitInitGetCudaDevices(unittest.TestCase):
+    pass
+
+
+add_function_test(
+    TestImplicitInitGetCudaDevices,
+    "test_get_cuda_devices",
+    test_get_cuda_devices,
+    check_output=False,
+)
+
+
+def test_get_device(test, device):
+    wp.get_device("cpu")
+
+
+class TestImplicitInitGetDevice(unittest.TestCase):
+    pass
+
+
+add_function_test(
+    TestImplicitInitGetDevice,
+    "test_get_device",
+    test_get_device,
+    check_output=False,
+)
+
+
+def test_get_devices(test, device):
+    wp.get_devices()
+
+
+class TestImplicitInitGetDevices(unittest.TestCase):
+    pass
+
+
+add_function_test(
+    TestImplicitInitGetDevices,
+    "test_get_devices",
+    test_get_devices,
+    check_output=False,
+)
+
+
+def test_get_preferred_device(test, device):
+    wp.get_preferred_device()
+
+
+class TestImplicitInitGetPreferredDevice(unittest.TestCase):
+    pass
+
+
+add_function_test(
+    TestImplicitInitGetPreferredDevice,
+    "test_get_preferred_device",
+    test_get_preferred_device,
+    check_output=False,
+)
+
+
+def test_is_cpu_available(test, device):
+    wp.is_cpu_available()
+
+
+class TestImplicitInitIsCpuAvailable(unittest.TestCase):
+    pass
+
+
+add_function_test(
+    TestImplicitInitIsCpuAvailable,
+    "test_is_cpu_available",
+    test_is_cpu_available,
+    check_output=False,
+)
+
+
+def test_is_cuda_available(test, device):
+    wp.is_cuda_available()
+
+
+class TestImplicitInitIsCudaAvailable(unittest.TestCase):
+    pass
+
+
+add_function_test(
+    TestImplicitInitIsCudaAvailable,
+    "test_is_cuda_available",
+    test_is_cuda_available,
+    check_output=False,
+)
+
+
+def test_is_device_available(test, device):
+    wp.is_device_available("cpu")
+
+
+class TestImplicitInitIsDeviceAvailable(unittest.TestCase):
+    pass
+
+
+add_function_test(
+    TestImplicitInitIsDeviceAvailable,
+    "test_is_device_available",
+    test_is_device_available,
+    check_output=False,
+)
+
+
+def test_set_device(test, device):
+    wp.set_device("cpu")
+
+
+class TestImplicitInitSetDevice(unittest.TestCase):
+    pass
+
+
+add_function_test(
+    TestImplicitInitSetDevice,
+    "test_set_device",
+    test_set_device,
+    check_output=False,
+)
+
+
+#   Launch
+# ------------------------------------------------------------------------------
+
+
+@wp.kernel
+def launch_kernel():
+    pass
+
+
+def test_launch(test, device):
+    wp.launch(launch_kernel, dim=1)
+
+
+class TestImplicitInitLaunch(unittest.TestCase):
+    pass
+
+
+add_function_test(
+    TestImplicitInitLaunch,
+    "test_launch",
+    test_launch,
+    check_output=False,
+)
+
+
+#   Mempool
+# ------------------------------------------------------------------------------
+
+
+def test_is_mempool_enabled(test, device):
+    wp.is_mempool_enabled("cpu")
+
+
+class TestImplicitInitIsMempoolEnabled(unittest.TestCase):
+    pass
+
+
+add_function_test(
+    TestImplicitInitIsMempoolEnabled,
+    "test_is_mempool_enabled",
+    test_is_mempool_enabled,
+    check_output=False,
+)
+
+
+def test_is_mempool_supported(test, device):
+    wp.is_mempool_supported("cpu")
+
+
+class TestImplicitInitIsMempoolSupported(unittest.TestCase):
+    pass
+
+
+add_function_test(
+    TestImplicitInitIsMempoolSupported,
+    "test_is_mempool_supported",
+    test_is_mempool_supported,
+    check_output=False,
+)
+
+
+#   Mempool Access
+# ------------------------------------------------------------------------------
+
+
+def test_is_mempool_access_enabled(test, device):
+    wp.is_mempool_access_enabled("cpu", "cpu")
+
+
+class TestImplicitInitIsMempoolAccessEnabled(unittest.TestCase):
+    pass
+
+
+add_function_test(
+    TestImplicitInitIsMempoolAccessEnabled,
+    "test_is_mempool_access_enabled",
+    test_is_mempool_access_enabled,
+    check_output=False,
+)
+
+
+def test_is_mempool_access_supported(test, device):
+    wp.is_mempool_access_supported("cpu", "cpu")
+
+
+class TestImplicitInitIsMempoolAccessSupported(unittest.TestCase):
+    pass
+
+
+add_function_test(
+    TestImplicitInitIsMempoolAccessSupported,
+    "test_is_mempool_access_supported",
+    test_is_mempool_access_supported,
+    check_output=False,
+)
+
+
+#   Peer Access
+# ------------------------------------------------------------------------------
+
+
+def test_is_peer_access_enabled(test, device):
+    wp.is_peer_access_enabled("cpu", "cpu")
+
+
+class TestImplicitInitIsPeerAccessEnabled(unittest.TestCase):
+    pass
+
+
+add_function_test(
+    TestImplicitInitIsPeerAccessEnabled,
+    "test_is_peer_access_enabled",
+    test_is_peer_access_enabled,
+    check_output=False,
+)
+
+
+def test_is_peer_access_supported(test, device):
+    wp.is_peer_access_supported("cpu", "cpu")
+
+
+class TestImplicitInitIsPeerAccessSupported(unittest.TestCase):
+    pass
+
+
+add_function_test(
+    TestImplicitInitIsPeerAccessSupported,
+    "test_is_peer_access_supported",
+    test_is_peer_access_supported,
+    check_output=False,
+)
+
+
+if __name__ == "__main__":
+    # Do not clear the kernel cache or call anything that would initialize Warp
+    # since these tests are specifically aiming to catch issues where Warp isn't
+    # correctly initialized upon calling certain public APIs.
+    unittest.main(verbosity=2, failfast=True)

warp/tests/test_import.py

@@ -33,5 +33,5 @@ add_kernel_test(TestImport, kernel=test_import_func, name="test_import_func", di
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_indexedarray.py

@@ -1128,5 +1128,5 @@ add_function_test(TestIndexedArray, "test_indexedarray_fill_struct", test_indexe
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_intersect.py

@@ -61,5 +61,5 @@ add_function_test(TestIntersect, "test_intersect_tri", test_intersect_tri, devic
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2, failfast=False)

warp/tests/test_jax.py

@@ -301,5 +301,5 @@ except Exception as e:
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_large.py

@@ -165,5 +165,5 @@ add_function_test(TestLarge, "test_large_array_excessive_numpy", test_large_arra
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_launch.py

@@ -348,5 +348,5 @@ add_function_test(TestLaunch, "test_launch_tuple_args", test_launch_tuple_args,
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_lerp.py

@@ -213,5 +213,5 @@ add_function_test(TestLerp, "test_lerp", test_lerp, devices=devices)
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_linear_solvers.py

@@ -185,5 +185,5 @@ add_function_test(TestLinearSolvers, "test_bicgstab", test_bicgstab, devices=dev
 add_function_test(TestLinearSolvers, "test_gmres", test_gmres, devices=devices)
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_lvalue.py

@@ -415,5 +415,5 @@ add_function_test(TestLValue, "test_slice", test_slice, devices=devices)
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_marching_cubes.py

@@ -52,12 +52,15 @@ devices = get_selected_cuda_test_devices()
 
 
 class TestMarchingCubes(unittest.TestCase):
-    pass
+    def test_marching_cubes_new_del(self):
+        # test the scenario in which a MarchingCubes instance is created but not initialized before gc
+        instance = wp.MarchingCubes.__new__(wp.MarchingCubes)
+        instance.__del__()
 
 
 add_function_test(TestMarchingCubes, "test_marching_cubes", test_marching_cubes, devices=devices)
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_mat.py

@@ -52,14 +52,14 @@ def get_select_kernel(dtype):
     return getkernel(output_select_kernel_fn, suffix=dtype.__name__)
 
 
-def test_anon_constructor_error_shape_keyword_missing(test, device):
+def test_anon_constructor_error_shape_arg_missing(test, device):
     @wp.kernel
     def kernel():
         wp.matrix(1.0, 2.0, 3.0)
 
     with test.assertRaisesRegex(
         RuntimeError,
-        r"shape keyword must be specified when calling matrix\(\) function$",
+        r"the `shape` argument must be specified when initializing a matrix by value$",
     ):
         wp.launch(
             kernel,
@@ -69,14 +69,18 @@ def test_anon_constructor_error_shape_keyword_missing(test, device):
         )
 
 
-def test_anon_constructor_error_dtype_keyword_missing(test, device):
+def test_anon_constructor_error_shape_mismatch(test, device):
     @wp.kernel
     def kernel():
-        wp.matrix(shape=(3, 3))
+        wp.matrix(
+            wp.matrix(shape=(1, 2), dtype=float),
+            shape=(3, 4),
+            dtype=float,
+        )
 
     with test.assertRaisesRegex(
         RuntimeError,
-        r"matrix\(\) must have dtype as a keyword argument if it has no " r"positional arguments$",
+        r"incompatible matrix of shape \(3, 4\) given when copy constructing a matrix of shape \(1, 2\)$",
     ):
         wp.launch(
             kernel,
@@ -86,18 +90,14 @@ def test_anon_constructor_error_dtype_keyword_missing(test, device):
         )
 
 
-def test_anon_constructor_error_shape_mismatch(test, device):
+def test_anon_constructor_error_type_mismatch(test, device):
     @wp.kernel
     def kernel():
-        wp.matrix(
-            wp.matrix(shape=(1, 2), dtype=float),
-            shape=(3, 4),
-            dtype=float,
-        )
+        wp.matrix(1.0, shape=(3, 2), dtype=wp.float16)
 
     with test.assertRaisesRegex(
         RuntimeError,
-        r"Incompatible matrix sizes for casting copy constructor, " r"\(3, 4\) vs \(1, 2\)$",
+        r"the value used to fill this matrix is expected to be of the type `float16`$",
     ):
         wp.launch(
             kernel,
@@ -114,8 +114,7 @@ def test_anon_constructor_error_invalid_arg_count(test, device):
 
     with test.assertRaisesRegex(
         RuntimeError,
-        r"Wrong number of arguments for matrix\(\) function, must initialize "
-        r"with either a scalar value, or m\*n values$",
+        r"incompatible number of values given \(3\) when constructing a matrix of shape \(2, 2\)$",
     ):
         wp.launch(
             kernel,
@@ -125,14 +124,14 @@ def test_anon_constructor_error_invalid_arg_count(test, device):
         )
 
 
-def test_tpl_constructor_error_incompatible_sizes(test, device):
+def test_anon_xform_constructor_error_type_mismatch(test, device):
     @wp.kernel
     def kernel():
-        wp.mat33(wp.mat22(1.0, 2.0, 3.0, 4.0))
+        wp.matrix(wp.vec3(1.0, 2.0, 3.0), wp.quat(0.0, 0.0, 0.0, 1.0), wp.vec3(2.0, 2.0, 2.0), wp.float64)
 
     with test.assertRaisesRegex(
         RuntimeError,
-        r"Incompatible matrix sizes for casting copy constructor, " r"\(3, 3\) vs \(2, 2\)$",
+        r"all values used to initialize this transformation matrix are expected to be of the type `float64`$",
     ):
         wp.launch(
             kernel,
@@ -142,14 +141,14 @@ def test_tpl_constructor_error_incompatible_sizes(test, device):
         )
 
 
-def test_tpl_constructor_error_invalid_scalar_type(test, device):
+def test_tpl_constructor_error_incompatible_sizes(test, device):
     @wp.kernel
     def kernel():
-        wp.mat22(1, 2, 3, 4)
+        wp.mat33(wp.mat22(1.0, 2.0, 3.0, 4.0))
 
     with test.assertRaisesRegex(
         RuntimeError,
-        r"Wrong scalar type for mat 2,2,<class 'warp.types.float32'> constructor$",
+        r"incompatible matrix of shape \(3, 3\) given when copy constructing a matrix of shape \(2, 2\)$",
     ):
         wp.launch(
             kernel,
@@ -162,11 +161,11 @@ def test_tpl_constructor_error_invalid_scalar_type(test, device):
 def test_tpl_constructor_error_invalid_vector_count(test, device):
     @wp.kernel
     def kernel():
-        wp.mat22(wp.vec3(1.0, 2.0, 3.0))
+        wp.mat33(wp.vec3(1.0, 2.0, 3.0), wp.vec3(1.0, 2.0, 3.0))
 
     with test.assertRaisesRegex(
         RuntimeError,
-        r"Wrong number of vectors when attempting to construct a matrix " r"with column vectors$",
+        r"incompatible number of column vectors given \(2\) when constructing a matrix of shape \(3, 3\)$",
     ):
         wp.launch(
             kernel,
@@ -183,7 +182,7 @@ def test_tpl_constructor_error_invalid_vector_shape(test, device):
 
     with test.assertRaisesRegex(
         RuntimeError,
-        r"Wrong vector row count when attempting to construct a matrix " r"with column vectors$",
+        r"incompatible column vector lengths given when constructing a matrix of shape \(2, 2\)$",
     ):
         wp.launch(
             kernel,
@@ -200,7 +199,7 @@ def test_tpl_constructor_error_invalid_arg_count(test, device):
 
     with test.assertRaisesRegex(
         RuntimeError,
-        r"Wrong number of scalars when attempting to construct a matrix " r"from a list of components$",
+        r"incompatible number of values given \(3\) when constructing a matrix of shape \(2, 2\)$",
     ):
         wp.launch(
             kernel,
@@ -1716,20 +1715,20 @@ for dtype in np_signed_int_types + np_float_types:
 
 add_function_test(
     TestMat,
-    "test_anon_constructor_error_shape_keyword_missing",
-    test_anon_constructor_error_shape_keyword_missing,
+    "test_anon_constructor_error_shape_arg_missing",
+    test_anon_constructor_error_shape_arg_missing,
     devices=devices,
 )
 add_function_test(
     TestMat,
-    "test_anon_constructor_error_dtype_keyword_missing",
-    test_anon_constructor_error_dtype_keyword_missing,
+    "test_anon_constructor_error_shape_mismatch",
+    test_anon_constructor_error_shape_mismatch,
     devices=devices,
 )
 add_function_test(
     TestMat,
-    "test_anon_constructor_error_shape_mismatch",
-    test_anon_constructor_error_shape_mismatch,
+    "test_anon_constructor_error_type_mismatch",
+    test_anon_constructor_error_type_mismatch,
     devices=devices,
 )
 add_function_test(
@@ -1740,14 +1739,14 @@ add_function_test(
 )
 add_function_test(
     TestMat,
-    "test_tpl_constructor_error_incompatible_sizes",
-    test_tpl_constructor_error_incompatible_sizes,
+    "test_anon_xform_constructor_error_type_mismatch",
+    test_anon_xform_constructor_error_type_mismatch,
     devices=devices,
 )
 add_function_test(
     TestMat,
-    "test_tpl_constructor_error_invalid_scalar_type",
-    test_tpl_constructor_error_invalid_scalar_type,
+    "test_tpl_constructor_error_incompatible_sizes",
+    test_tpl_constructor_error_incompatible_sizes,
     devices=devices,
 )
 add_function_test(
@@ -1795,5 +1794,5 @@ for dtype in np_float_types:
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2, failfast=True)

warp/tests/test_mat_lite.py

@@ -24,6 +24,7 @@ def test_matrix_constructor_value_func():
         wp.vec3d(wp.float64(1.0), wp.float64(2.0), wp.float64(3.0)),
         wp.vec3d(wp.float64(1.0), wp.float64(2.0), wp.float64(3.0)),
     )
+    g = wp.matrix(1.0, shape=(3, 2))
 
 
 # Test matrix constructors using explicit type (float16)
@@ -109,5 +110,5 @@ add_kernel_test(TestMatLite, test_constructors_default_precision, dim=1, devices
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2, failfast=True)

warp/tests/test_mat_scalar_ops.py

@@ -2901,5 +2901,5 @@ for dtype in np_scalar_types:
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2, failfast=True)

warp/tests/test_math.py

@@ -120,5 +120,5 @@ add_function_test(TestMath, "test_scalar_math", test_scalar_math, devices=device
 
 
 if __name__ == "__main__":
-    wp.build.clear_kernel_cache()
+    wp.clear_kernel_cache()
     unittest.main(verbosity=2)