Try debug hanging process

tests/utilities/test_parallel_map.py

@@ -1,65 +1,65 @@
-# import unittest
+import unittest
 
-# import pytest
+import pytest
 
-# from src.great_ai.utilities import parallel_map
+from src.great_ai.utilities import parallel_map
 
-# COUNT = int(1e5) + 3
+COUNT = int(1e5) + 3
 
 
-# class TestParallelMap(unittest.TestCase):
+class TestParallelMap(unittest.TestCase):
-#     def test_simple_case_with_progress_bar(self) -> None:
+    def test_simple_case_with_progress_bar(self) -> None:
-#         assert list(parallel_map(lambda v: v**2, range(COUNT), concurrency=4)) == [
+        assert list(parallel_map(lambda v: v**2, range(COUNT), concurrency=4)) == [
-#             v**2 for v in range(COUNT)
+            v**2 for v in range(COUNT)
-#         ]
+        ]
 
-#     def test_with_iterable(self) -> None:
+    def test_with_iterable(self) -> None:
-#         from time import sleep
+        from time import sleep
 
-#         def my_generator():
+        def my_generator():
-#             for i in range(10):
+            for i in range(10):
-#                 yield i
+                yield i
-#                 sleep(0.1)
+                sleep(0.1)
 
-#         expected = [v**3 for v in range(10)]
+        expected = [v**3 for v in range(10)]
 
-#         assert (
+        assert (
-#             list(parallel_map(lambda x: x**3, my_generator(), chunk_size=1))
+            list(parallel_map(lambda x: x**3, my_generator(), chunk_size=1))
-#             == expected
+            == expected
-#         )
+        )
 
-#     def test_simple_case_without_progress_bar(self) -> None:
+    def test_simple_case_without_progress_bar(self) -> None:
-#         assert list(parallel_map(lambda v: v**2, range(COUNT), concurrency=2)) == [
+        assert list(parallel_map(lambda v: v**2, range(COUNT), concurrency=2)) == [
-#             v**2 for v in range(COUNT)
+            v**2 for v in range(COUNT)
-#         ]
+        ]
 
-#     def test_simple_case_invalid_values(self) -> None:
+    def test_simple_case_invalid_values(self) -> None:
-#         with pytest.raises(AssertionError):
+        with pytest.raises(AssertionError):
-#             list(parallel_map(lambda v: v**2, range(COUNT), concurrency=0))
+            list(parallel_map(lambda v: v**2, range(COUNT), concurrency=0))
 
-#         with pytest.raises(AssertionError):
+        with pytest.raises(AssertionError):
-#             list(parallel_map(lambda v: v**2, range(COUNT), chunk_size=0))
+            list(parallel_map(lambda v: v**2, range(COUNT), chunk_size=0))
 
-#     def test_this_process_exception(self) -> None:
+    def test_this_process_exception(self) -> None:
-#         def my_generator():
+        def my_generator():
-#             yield 1
+            yield 1
-#             yield 2
+            yield 2
-#             yield 3
+            yield 3
-#             assert False
+            assert False
 
-#         with pytest.raises(AssertionError):
+        with pytest.raises(AssertionError):
-#             list(
+            list(
-#                 parallel_map(
+                parallel_map(
-#                     lambda v: v**2, my_generator(), concurrency=2, chunk_size=2
+                    lambda v: v**2, my_generator(), concurrency=2, chunk_size=2
-#                 )
+                )
-#             )
+            )
 
-#         with pytest.raises(AssertionError):
+        with pytest.raises(AssertionError):
-#             list(
+            list(
-#                 parallel_map(
+                parallel_map(
-#                     lambda v: v**2, my_generator(), concurrency=1, chunk_size=2
+                    lambda v: v**2, my_generator(), concurrency=1, chunk_size=2
-#                 )
+                )
-#             )
+            )
 
     # def test_ignore_this_process_exception(self) -> None:
     #     def my_generator():
@@ -87,30 +87,30 @@
     #         )
     #     ) == [1, 4, 9]
 
-#     def test_worker_process_exception(self) -> None:
+    def test_worker_process_exception(self) -> None:
-#         def oh_no(_):
+        def oh_no(_):
-#             raise ValueError("hi")
+            raise ValueError("hi")
 
-#         with pytest.raises(ValueError):
+        with pytest.raises(ValueError):
-#             list(parallel_map(oh_no, range(COUNT), concurrency=2))
+            list(parallel_map(oh_no, range(COUNT), concurrency=2))
 
-#         with pytest.raises(ValueError):
+        with pytest.raises(ValueError):
-#             list(parallel_map(oh_no, range(COUNT), concurrency=1))
+            list(parallel_map(oh_no, range(COUNT), concurrency=1))
 
-#     def test_ignore_worker_process_exception(self) -> None:
+    def test_ignore_worker_process_exception(self) -> None:
-#         def oh_no(_):
+        def oh_no(_):
-#             raise ValueError("hi")
+            raise ValueError("hi")
 
-#         assert (
+        assert (
-#             list(parallel_map(oh_no, range(3), concurrency=2, ignore_exceptions=True))
+            list(parallel_map(oh_no, range(3), concurrency=2, ignore_exceptions=True))
-#             == [None] * 3
+            == [None] * 3
-#         )
+        )
-#         assert (
+        assert (
-#             list(parallel_map(oh_no, range(3), concurrency=1, ignore_exceptions=True))
+            list(parallel_map(oh_no, range(3), concurrency=1, ignore_exceptions=True))
-#             == [None] * 3
+            == [None] * 3
-#         )
+        )
 
-#     def test_no_op(self) -> None:
+    def test_no_op(self) -> None:
-#         assert list(parallel_map(lambda v: v**2, [])) == []
+        assert list(parallel_map(lambda v: v**2, [])) == []
-#         assert list(parallel_map(lambda v: v**2, [], chunk_size=100)) == []
+        assert list(parallel_map(lambda v: v**2, [], chunk_size=100)) == []
-#         assert list(parallel_map(lambda v: v**2, [], concurrency=100)) == []
+        assert list(parallel_map(lambda v: v**2, [], concurrency=100)) == []