Fix some linter errors

Author: skogler

mapbox_earcut/__init__.pyi

@@ -46,8 +46,6 @@ requires = ["nanobind>=2.9.2", "scikit-build-core>=0.11.6"]
 build-backend = "scikit_build_core.build"
 
 [tool.cibuildwheel]
-# These crash on GitHub Actions but work locally, skip for now
-test-skip = "pp310-win*"
 test-requires = ["pytest"]
 test-command = "pytest {package}/tests"
 

mapbox_earcut/py.typed

@@ -0,0 +1,9 @@
+{
+  "pythonVersion": "3.9",
+  "typeCheckingMode": "basic",
+  "include": [
+    "mapbox_earcut",
+    "tests"
+  ],
+  "reportInvalidTypeForm": "none"
+}

pyproject.toml

@@ -6,10 +6,9 @@
 """
 
 import sys
-from collections.abc import Callable
 from concurrent.futures import ThreadPoolExecutor
 import threading
-from typing import Any
+from typing import Any, Callable, List, Optional, Tuple, Union
 
 import mapbox_earcut as earcut
 import numpy as np
@@ -23,7 +22,7 @@ def run_threaded(
     pass_count: bool = False,
     pass_barrier: bool = False,
     outer_iterations: int = 1,
-    prepare_args: Callable[[], list[Any]] | None = None,
+    prepare_args: Optional[Callable[[], List[Any]]] = None,
 ) -> None:
     """
     Runs a function many times in parallel.
@@ -48,16 +47,19 @@ def run_threaded(
             if pass_barrier:
                 barrier = threading.Barrier(num_threads)
                 args.append(barrier)
+            else:
+                barrier = None
             if pass_count:
                 all_args = [(func, i, *args) for i in range(num_threads)]
             else:
                 all_args = [(func, *args) for i in range(num_threads)]
+
+            futures = []
             try:
-                futures = []
                 for arg in all_args:
                     futures.append(tpe.submit(*arg))
             finally:
-                if len(futures) < num_threads and pass_barrier:
+                if len(futures) < num_threads and barrier is not None:
                     barrier.abort()
             for f in futures:
                 f.result()
@@ -68,15 +70,15 @@ def run_threaded(
 
 def test_parallel_triangulate_float32_simple() -> None:
     """Test that multiple threads can triangulate simple polygons simultaneously."""
-    results: list[NDArray[np.uint32] | None] = [None] * 8
+    results: List[Optional[NDArray[np.uint32]]] = [None] * 8
 
     def closure(i: int, b: threading.Barrier) -> None:
         # Create per-thread data to avoid sharing arrays
         verts = np.array([[0, 0], [1, 0], [1, 1]], dtype=np.float32).reshape(-1, 2)
         rings = np.array([3])
 
         # Synchronize all threads to maximize chance of race condition
-        b.wait()
+        _ = b.wait()
 
         # Perform triangulation
         result = earcut.triangulate_float32(verts, rings)
@@ -92,17 +94,17 @@ def closure(i: int, b: threading.Barrier) -> None:
         assert result is not None, f"Thread {i} didn't produce a result"
         assert result.dtype == np.uint32
         assert result.shape == (3,)
-        assert np.all(result == expected), f"Thread {i} got incorrect result"
+        assert np.array_equal(result, expected), f"Thread {i} got incorrect result"
 
 
 def test_parallel_triangulate_float64_simple() -> None:
     """Test that multiple threads can triangulate with float64 simultaneously."""
-    results: list[NDArray[np.uint32] | None] = [None] * 8
+    results: List[Optional[NDArray[np.uint32]]] = [None] * 8
 
     def closure(i: int, b: threading.Barrier) -> None:
         verts = np.array([[0, 0], [1, 0], [1, 1]], dtype=np.float64).reshape(-1, 2)
         rings = np.array([3])
-        b.wait()
+        _ = b.wait()
         result = earcut.triangulate_float64(verts, rings)
         results[i] = result
 
@@ -111,17 +113,17 @@ def closure(i: int, b: threading.Barrier) -> None:
     expected = np.array([1, 2, 0])
     for result in results:
         assert result is not None
-        assert np.all(result == expected)
+        assert np.array_equal(result, expected)
 
 
 def test_parallel_triangulate_int32_simple() -> None:
     """Test that multiple threads can triangulate with int32 simultaneously."""
-    results: list[NDArray[np.uint32] | None] = [None] * 8
+    results: List[Optional[NDArray[np.uint32]]] = [None] * 8
 
     def closure(i: int, b: threading.Barrier) -> None:
         verts = np.array([[0, 0], [1, 0], [1, 1]], dtype=np.int32).reshape(-1, 2)
         rings = np.array([3])
-        b.wait()
+        _ = b.wait()
         result = earcut.triangulate_int32(verts, rings)
         results[i] = result
 
@@ -130,17 +132,17 @@ def closure(i: int, b: threading.Barrier) -> None:
     expected = np.array([1, 2, 0])
     for result in results:
         assert result is not None
-        assert np.all(result == expected)
+        assert np.array_equal(result, expected)
 
 
 def test_parallel_triangulate_int64_simple() -> None:
     """Test that multiple threads can triangulate with int64 simultaneously."""
-    results: list[NDArray[np.uint32] | None] = [None] * 8
+    results: List[Optional[NDArray[np.uint32]]] = [None] * 8
 
     def closure(i: int, b: threading.Barrier) -> None:
         verts = np.array([[0, 0], [1, 0], [1, 1]], dtype=np.int64).reshape(-1, 2)
         rings = np.array([3])
-        b.wait()
+        _ = b.wait()
         result = earcut.triangulate_int64(verts, rings)
         results[i] = result
 
@@ -149,15 +151,15 @@ def closure(i: int, b: threading.Barrier) -> None:
     expected = np.array([1, 2, 0])
     for result in results:
         assert result is not None
-        assert np.all(result == expected)
+        assert np.array_equal(result, expected)
 
 
 # Complex polygon thread safety tests
 
 
 def test_parallel_triangulate_square() -> None:
     """Test parallel triangulation of a square."""
-    results: list[NDArray[np.uint32] | None] = [None] * 16
+    results: List[Optional[NDArray[np.uint32]]] = [None] * 16
 
     def closure(i: int, b: threading.Barrier) -> None:
         # Square polygon
@@ -166,7 +168,7 @@ def closure(i: int, b: threading.Barrier) -> None:
         ).reshape(-1, 2)
         rings = np.array([4])
 
-        b.wait()
+        _ = b.wait()
         result = earcut.triangulate_float32(verts, rings)
         results[i] = result
 
@@ -183,7 +185,7 @@ def closure(i: int, b: threading.Barrier) -> None:
 
 def test_parallel_triangulate_with_hole() -> None:
     """Test parallel triangulation of a polygon with a hole."""
-    results: list[NDArray[np.uint32] | None] = [None] * 8
+    results: List[Optional[NDArray[np.uint32]]] = [None] * 8
 
     def closure(i: int, b: threading.Barrier) -> None:
         # Outer square
@@ -195,7 +197,7 @@ def closure(i: int, b: threading.Barrier) -> None:
         verts = np.vstack([outer, inner]).reshape(-1, 2)
         rings = np.array([4, 8])  # First ring ends at 4, second at 8
 
-        b.wait()
+        _ = b.wait()
         result = earcut.triangulate_float32(verts, rings)
         results[i] = result
 
@@ -207,20 +209,20 @@ def closure(i: int, b: threading.Barrier) -> None:
     for result in results[1:]:
         assert result is not None
         assert result.shape == first_result.shape
-        assert np.all(result == first_result)
+        assert np.array_equal(result, first_result)
 
 
 def test_parallel_triangulate_complex_shape() -> None:
     """Test parallel triangulation with a more complex polygon."""
-    results: list[NDArray[np.uint32] | None] = [None] * 12
+    results: List[Optional[NDArray[np.uint32]]] = [None] * 12
 
     def closure(i: int, b: threading.Barrier) -> None:
         # Hexagon
         angles = np.linspace(0, 2 * np.pi, 7)[:-1]  # 6 points
         verts = np.column_stack([np.cos(angles), np.sin(angles)]).astype(np.float64)
         rings = np.array([6])
 
-        b.wait()
+        _ = b.wait()
         result = earcut.triangulate_float64(verts, rings)
         results[i] = result
 
@@ -245,15 +247,16 @@ def test_high_contention_same_shape() -> None:
     to maximize the chance of exposing race conditions.
     """
     num_threads = 32
-    results: list[NDArray[np.uint32] | None] = [None] * num_threads
+    results: List[Optional[NDArray[np.uint32]]] = [None] * num_threads
 
     def closure(i: int, b: threading.Barrier) -> None:
         verts = np.array([[0, 0], [5, 0], [5, 5], [0, 5]], dtype=np.float32).reshape(
             -1, 2
         )
         rings = np.array([4])
 
-        b.wait()
+        _ = b.wait()
+        result = None
         # Run multiple times in each thread
         for _ in range(10):
             result = earcut.triangulate_float32(verts, rings)
@@ -275,12 +278,12 @@ def closure(i: int, b: threading.Barrier) -> None:
 
 def test_mixed_operations() -> None:
     """Test mixing different data types in parallel."""
-    results: list[NDArray[np.uint32] | None] = [None] * 16
+    results: List[Optional[NDArray[np.uint32]]] = [None] * 16
 
     def closure(i: int, b: threading.Barrier) -> None:
         # Each thread uses a different dtype based on its index
         dtypes = [np.float32, np.float64, np.int32, np.int64]
-        funcs: list[Callable[[Any, Any], NDArray[np.uint32]]] = [
+        funcs: List[Callable[[Any, Any], NDArray[np.uint32]]] = [
             earcut.triangulate_float32,
             earcut.triangulate_float64,
             earcut.triangulate_int32,
@@ -293,7 +296,7 @@ def closure(i: int, b: threading.Barrier) -> None:
         verts = np.array([[0, 0], [1, 0], [1, 1]], dtype=dtype).reshape(-1, 2)
         rings = np.array([3])
 
-        b.wait()
+        _ = b.wait()
         result = func(verts, rings)
         results[i] = result
 
@@ -304,12 +307,12 @@ def closure(i: int, b: threading.Barrier) -> None:
     expected = np.array([1, 2, 0])
     for result in results:
         assert result is not None
-        assert np.all(result == expected)
+        assert np.array_equal(result, expected)
 
 
 def test_varying_sizes() -> None:
     """Test with varying polygon sizes across threads."""
-    results: list[NDArray[np.uint32] | None] = [None] * 20
+    results: List[Optional[NDArray[np.uint32]]] = [None] * 20
 
     def closure(i: int, b: threading.Barrier) -> None:
         # Create polygons of different sizes based on thread index
@@ -318,7 +321,7 @@ def closure(i: int, b: threading.Barrier) -> None:
         verts = np.column_stack([np.cos(angles), np.sin(angles)]).astype(np.float32)
         rings = np.array([num_sides])
 
-        b.wait()
+        _ = b.wait()
         result = earcut.triangulate_float32(verts, rings)
         results[i] = result
 
@@ -342,15 +345,15 @@ def closure(i: int, b: threading.Barrier) -> None:
 
 def test_parallel_invalid_rings() -> None:
     """Test that multiple threads can handle invalid input simultaneously."""
-    exceptions: list[ValueError | None] = [None] * 8
+    exceptions: List[Optional[ValueError]] = [None] * 8
 
     def closure(i: int, b: threading.Barrier) -> None:
         verts = np.array([[0, 0], [1, 0], [1, 1]], dtype=np.float32).reshape(-1, 2)
         rings = np.array([5])  # Invalid: larger than verts
 
-        b.wait()
+        _ = b.wait()
         try:
-            earcut.triangulate_float32(verts, rings)
+            _ = earcut.triangulate_float32(verts, rings)
             exceptions[i] = None
         except ValueError as e:
             exceptions[i] = e
@@ -365,7 +368,9 @@ def closure(i: int, b: threading.Barrier) -> None:
 
 def test_parallel_mixed_valid_invalid() -> None:
     """Test mixing valid and invalid inputs across threads."""
-    results: list[tuple[str, NDArray[np.uint32] | ValueError] | None] = [None] * 16
+    results: List[Optional[Tuple[str, Union[NDArray[np.uint32], ValueError]]]] = [
+        None
+    ] * 16
 
     def closure(i: int, b: threading.Barrier) -> None:
         verts = np.array([[0, 0], [1, 0], [1, 1]], dtype=np.float32).reshape(-1, 2)