warp-lang 1.1.0__py3-none-macosx_10_13_universal2.whl → 1.2.0__py3-none-macosx_10_13_universal2.whl

warp/tests/unittest_utils.py

@@ -316,70 +316,6 @@ def add_function_test_register_kernel(cls, name, func, devices=None, **kwargs):
     add_function_test(cls, name, func, devices=devices, **kwargs)
 
 
-class TeamCityTestResult(unittest.TextTestResult):
-    """This class will report each test result to TeamCity"""
-
-    def __init__(self, stream, descriptions, verbosity):
-        super(TeamCityTestResult, self).__init__(stream, descriptions, verbosity)
-
-    def addSuccess(self, test):
-        super(TeamCityTestResult, self).addSuccess(test)
-        self.reportSuccess(test)
-
-    def addError(self, test, err):
-        super(TeamCityTestResult, self).addError(test, err)
-        self.reportFailure(test)
-
-    def addFailure(self, test, err):
-        super(TeamCityTestResult, self).addFailure(test, err)
-        self.reportFailure(test)
-
-    def addSkip(self, test, reason):
-        super(TeamCityTestResult, self).addSkip(test, reason)
-
-    def addExpectedFailure(self, test, err):
-        super(TeamCityTestResult, self).addExpectedFailure(test, err)
-        self.reportSuccess(test)
-
-    def addUnexpectedSuccess(self, test):
-        super(TeamCityTestResult, self).addUnexpectedSuccess(test)
-        self.reportFailure(test)
-
-    def reportSuccess(self, test):
-        test_id = test.id()
-        print(f"##teamcity[testStarted name='{test_id}']")
-        print(f"##teamcity[testFinished name='{test_id}']")
-
-    def reportFailure(self, test):
-        test_id = test.id()
-        print(f"##teamcity[testStarted name='{test_id}']")
-        print(f"##teamcity[testFailed name='{test_id}']")
-        print(f"##teamcity[testFinished name='{test_id}']")
-
-
-class TeamCityTestRunner(unittest.TextTestRunner):
-    """Test runner that will report test results to TeamCity if running in TeamCity"""
-
-    def __init__(self, **kwargs):
-        self.running_in_teamcity = os.environ.get("TEAMCITY_VERSION") is not None
-        if self.running_in_teamcity:
-            kwargs["resultclass"] = TeamCityTestResult
-        super(TeamCityTestRunner, self).__init__(**kwargs)
-
-    def run(self, test, name):
-        if self.running_in_teamcity:
-            print(f"##teamcity[testSuiteStarted name='{name}']")
-
-        result = super(TeamCityTestRunner, self).run(test)
-
-        if self.running_in_teamcity:
-            print(f"##teamcity[testSuiteFinished name='{name}']")
-            if not result.wasSuccessful():
-                print("##teamcity[buildStatus status='FAILURE']")
-
-        return result
-
-
 def write_junit_results(
     outfile: str,
     test_records: list,
@@ -397,7 +333,7 @@ def write_junit_results(
     import xml.etree.ElementTree as ET
 
     root = ET.Element(
-        "testsuites",
+        "testsuite",
         name="Warp Tests",
         failures=str(tests_failed),
         errors=str(tests_errored),
@@ -412,11 +348,7 @@ def write_junit_results(
         test_status = test_data[2]
 
         test_case = ET.SubElement(
-            root,
-            "testcase",
-            classname=test.__class__.__name__,
-            name=test._testMethodName,
-            time=f"{test_duration:.3f}",
+            root, "testcase", classname=test.__class__.__name__, name=test._testMethodName, time=f"{test_duration:.3f}"
         )
 
         if test_status == "FAIL":
@@ -500,104 +432,3 @@ class ParallelJunitTestResult(unittest.TextTestResult):
 
     def printErrors(self):
         pass
-
-
-def _tc_escape(s):
-    """Modifies strings so they can be used in TeamCity log messages."""
-    s = s.replace("|", "||")
-    s = s.replace("\n", "|n")
-    s = s.replace("\r", "|r")
-    s = s.replace("'", "|'")
-    s = s.replace("[", "|[")
-    s = s.replace("]", "|]")
-    return s
-
-
-class ParallelTeamCityTestResult(unittest.TextTestResult):
-    def __init__(self, stream, descriptions, verbosity):
-        stream = type(stream)(sys.stderr)
-        super().__init__(stream, descriptions, verbosity)
-        self.test_record = []
-
-    def startTest(self, test):
-        if self.showAll:
-            self.stream.writeln(f"{self.getDescription(test)} ...")
-            self.stream.flush()
-        self.start_time = time.perf_counter_ns()
-        super(unittest.TextTestResult, self).startTest(test)
-
-    def _add_helper(self, test, dots_message, show_all_message):
-        if self.showAll:
-            self.stream.writeln(f"{self.getDescription(test)} ... {show_all_message}")
-        elif self.dots:
-            self.stream.write(dots_message)
-        self.stream.flush()
-
-    def addSuccess(self, test):
-        super(unittest.TextTestResult, self).addSuccess(test)
-        self._add_helper(test, ".", "ok")
-        self.reportSuccess(test)
-
-    def addError(self, test, err):
-        super(unittest.TextTestResult, self).addError(test, err)
-        self._add_helper(test, "E", "ERROR")
-        self.reportFailure(test, err)
-
-    def addFailure(self, test, err):
-        super(unittest.TextTestResult, self).addFailure(test, err)
-        self._add_helper(test, "F", "FAIL")
-        self.reportFailure(test, err)
-
-    def addSkip(self, test, reason):
-        super(unittest.TextTestResult, self).addSkip(test, reason)
-        self._add_helper(test, "s", f"skipped {reason!r}")
-        self.reportIgnored(test, reason)
-
-    def addExpectedFailure(self, test, err):
-        super(unittest.TextTestResult, self).addExpectedFailure(test, err)
-        self._add_helper(test, "x", "expected failure")
-        self.reportSuccess(test)
-
-    def addUnexpectedSuccess(self, test):
-        super(unittest.TextTestResult, self).addUnexpectedSuccess(test)
-        self._add_helper(test, "u", "unexpected success")
-        self.reportFailure(test, "unexpected success")
-
-    def addSubTest(self, test, subtest, err):
-        super(unittest.TextTestResult, self).addSubTest(test, subtest, err)
-        if err is not None:
-            self._add_helper(test, "E", "ERROR")
-            self.reportSubTestFailure(test, err)
-
-    def printErrors(self):
-        pass
-
-    def reportIgnored(self, test, reason):
-        test_id = test.id()
-        self.stream.writeln(f"##teamcity[testIgnored name='{test_id}' message='{_tc_escape(str(reason))}']")
-        self.stream.flush()
-
-    def reportSuccess(self, test):
-        duration = round((time.perf_counter_ns() - self.start_time) / 1e6)  # [ms]
-        test_id = test.id()
-        self.stream.writeln(f"##teamcity[testStarted name='{test_id}']")
-        self.stream.writeln(f"##teamcity[testFinished name='{test_id}' duration='{duration}']")
-        self.stream.flush()
-
-    def reportFailure(self, test, err):
-        test_id = test.id()
-        self.stream.writeln(f"##teamcity[testStarted name='{test_id}']")
-        self.stream.writeln(
-            f"##teamcity[testFailed name='{test_id}' message='{_tc_escape(str(err[1]))}' details='{_tc_escape(self._exc_info_to_string(err, test))}']"
-        )
-        self.stream.writeln(f"##teamcity[testFinished name='{test_id}']")
-        self.stream.flush()
-
-    def reportSubTestFailure(self, test, err):
-        test_id = test.id()
-        self.stream.writeln(f"##teamcity[testStarted name='{test_id}']")
-        self.stream.writeln(
-            f"##teamcity[testFailed name='{test_id}' message='{_tc_escape(str(err[1]))}' details='{_tc_escape(self._exc_info_to_string(err, test))}']"
-        )
-        self.stream.writeln(f"##teamcity[testFinished name='{test_id}']")
-        self.stream.flush()

warp/tests/unused_test_misc.py

@@ -9,8 +9,6 @@ import numpy as np
 
 import warp as wp
 
-wp.init()
-
 
 @wp.kernel
 def arange(out: wp.array(dtype=int)):

warp/tests/walkthrough_debug.py

@@ -26,7 +26,7 @@
 },
 {
     "name": "Python: Current File",
-    "type": "python",
+    "type": "debugpy",
     "request": "launch",
     "program": "${file}",
     "console": "integratedTerminal",

warp/thirdparty/unittest_parallel.py

@@ -29,7 +29,6 @@ from io import StringIO
 import warp.tests.unittest_suites  # NVIDIA Modification
 from warp.tests.unittest_utils import (  # NVIDIA modification
     ParallelJunitTestResult,
-    ParallelTeamCityTestResult,
     write_junit_results,
 )
 
@@ -42,8 +41,6 @@ except ImportError:
 
 
 # The following variables are NVIDIA Modifications
-RUNNING_IN_TEAMCITY = os.environ.get("TEAMCITY_VERSION") is not None
-TEST_SUITE_NAME = "WarpTests"
 START_DIRECTORY = os.path.dirname(__file__)  # The directory to start test discovery
 
 
@@ -154,6 +151,10 @@ def main(argv=None):
     group_coverage.add_argument(
         "--coverage-fail-under", metavar="MIN", type=float, help="Fail if coverage percentage under min"
     )
+    group_warp = parser.add_argument_group("NVIDIA Warp options")  # NVIDIA Modification
+    group_warp.add_argument(
+        "--no-shared-cache", action="store_true", help="Use a separate kernel cache per test process."
+    )
     args = parser.parse_args(args=argv)
 
     if args.coverage_branch:
@@ -169,6 +170,12 @@ def main(argv=None):
         process_count = multiprocessing.cpu_count()
     process_count = min(process_count, args.maxjobs)  # NVIDIA Modification
 
+    import warp as wp  # NVIDIA Modification
+
+    # Clear the Warp cache (NVIDIA Modification)
+    wp.build.clear_kernel_cache()
+    print("Cleared Warp kernel cache")
+
     # Create the temporary directory (for coverage files)
     with tempfile.TemporaryDirectory() as temp_dir:
         # Discover tests
@@ -201,9 +208,6 @@ def main(argv=None):
         # Don't use more processes than test suites
         process_count = max(1, min(len(test_suites), process_count))
 
-        if RUNNING_IN_TEAMCITY:
-            print(f"##teamcity[testSuiteStarted name='{TEST_SUITE_NAME}']")  # NVIDIA Modification for TC
-
         if not args.serial_fallback:
             # Report test suites and processes
             print(
@@ -226,7 +230,7 @@ def main(argv=None):
                 with multiprocessing_context.Pool(
                     process_count,
                     maxtasksperchild=maxtasksperchild,
-                    initializer=set_worker_cache,
+                    initializer=initialize_test_process,
                     initargs=(manager.Lock(), shared_index, args, temp_dir),
                 ) as pool:
                     test_manager = ParallelTestManager(manager, args, temp_dir)
@@ -236,7 +240,7 @@ def main(argv=None):
                 with concurrent.futures.ProcessPoolExecutor(
                     max_workers=process_count,
                     mp_context=multiprocessing.get_context(method="spawn"),
-                    initializer=set_worker_cache,
+                    initializer=initialize_test_process,
                     initargs=(manager.Lock(), shared_index, args, temp_dir),
                 ) as executor:
                     test_manager = ParallelTestManager(manager, args, temp_dir)
@@ -249,14 +253,6 @@ def main(argv=None):
             if args.verbose > 1:
                 print(file=sys.stderr)
 
-            import warp as wp
-
-            wp.init()
-
-            # force rebuild of all kernels
-            wp.build.clear_kernel_cache()
-            print("Cleared Warp kernel cache")
-
             # Run the tests in serial
             start_time = time.perf_counter()
 
@@ -267,9 +263,6 @@ def main(argv=None):
         stop_time = time.perf_counter()
         test_duration = stop_time - start_time
 
-        if RUNNING_IN_TEAMCITY:
-            print(f"##teamcity[testSuiteFinished name='{TEST_SUITE_NAME}']")  # NVIDIA Modification for TC
-
         # Aggregate parallel test run results
         tests_run = 0
         errors = []
@@ -331,8 +324,6 @@ def main(argv=None):
 
         # Return an error status on failure
         if not is_success:
-            if RUNNING_IN_TEAMCITY:
-                print("##teamcity[buildStatus status='FAILURE']")  # NVIDIA Modification for TC
             parser.exit(status=len(errors) + len(failures) + unexpected_successes)
 
         # Coverage?
@@ -435,18 +426,16 @@ class ParallelTestManager:
     def run_tests(self, test_suite):
         # Fail fast?
         if self.failfast.is_set():
-            return [0, [], [], 0, 0, 0]
+            return [0, [], [], 0, 0, 0, []]  # NVIDIA Modification
 
-        # NVIDIA Modification for TeamCity and GitLab
+        # NVIDIA Modification for GitLab
         import warp.tests.unittest_utils
 
         warp.tests.unittest_utils.coverage_enabled = self.args.coverage
         warp.tests.unittest_utils.coverage_temp_dir = self.temp_dir
         warp.tests.unittest_utils.coverage_branch = self.args.coverage_branch
 
-        if RUNNING_IN_TEAMCITY:
-            resultclass = ParallelTeamCityTestResult
-        elif self.args.junit_report_xml:
+        if self.args.junit_report_xml:
             resultclass = ParallelJunitTestResult
         else:
             resultclass = ParallelTextTestResult
@@ -455,7 +444,7 @@ class ParallelTestManager:
         with _coverage(self.args, self.temp_dir):
             runner = unittest.TextTestRunner(
                 stream=StringIO(),
-                resultclass=resultclass,  # NVIDIA Modification for TC
+                resultclass=resultclass,  # NVIDIA Modification
                 verbosity=self.args.verbose,
                 failfast=self.args.failfast,
                 buffer=self.args.buffer,
@@ -536,10 +525,13 @@ class ParallelTextTestResult(unittest.TextTestResult):
         pass
 
 
-def set_worker_cache(lock, shared_index, args, temp_dir):
-    """Change the Warp cache to avoid conflicts.
-    This function is run at the start of every new process. (NVIDIA modification)
+def initialize_test_process(lock, shared_index, args, temp_dir):
+    """Necessary operations to be executed at the start of every test process.
+
+    Currently this function can be used to set a separate Warp cache. (NVIDIA modification)
     If the environment variable `WARP_CACHE_ROOT` is detected, the cache will be placed in the provided path.
+
+    It also ensures that Warp is initialized prior to running any tests.
     """
 
     with lock:
@@ -548,18 +540,23 @@ def set_worker_cache(lock, shared_index, args, temp_dir):
 
     with _coverage(args, temp_dir):
         import warp as wp
-        from warp.thirdparty import appdirs
 
-        if "WARP_CACHE_ROOT" in os.environ:
-            cache_root_dir = os.path.join(os.getenv("WARP_CACHE_ROOT"), f"{wp.config.version}-{worker_index:03d}")
-        else:
-            cache_root_dir = appdirs.user_cache_dir(
-                appname="warp", appauthor="NVIDIA", version=f"{wp.config.version}-{worker_index:03d}"
-            )
+        if args.no_shared_cache:
+            from warp.thirdparty import appdirs
+
+            if "WARP_CACHE_ROOT" in os.environ:
+                cache_root_dir = os.path.join(os.getenv("WARP_CACHE_ROOT"), f"{wp.config.version}-{worker_index:03d}")
+            else:
+                cache_root_dir = appdirs.user_cache_dir(
+                    appname="warp", appauthor="NVIDIA", version=f"{wp.config.version}-{worker_index:03d}"
+                )
+
+            wp.config.kernel_cache_dir = cache_root_dir
 
-        wp.config.kernel_cache_dir = cache_root_dir
-        wp.init()
-        wp.build.clear_kernel_cache()
+            wp.build.clear_kernel_cache()
+        else:
+            # Initialize Warp is if hasn't been initialized already
+            wp.init()
 
 
 if __name__ == "__main__":  # pragma: no cover