[Tests] cleanup

masque/test/test_shape_advanced.py

@@ -1,16 +1,17 @@
+from pathlib import Path
 import pytest
 import numpy
 from numpy.testing import assert_equal, assert_allclose
 from numpy import pi
-import os
 
-from ..shapes import Arc, Ellipse, Circle, Polygon, Path, Text, PolyCollection
+from ..shapes import Arc, Ellipse, Circle, Polygon, Path as MPath, Text, PolyCollection
 from ..error import PatternError
 
+
 # 1. Text shape tests
-def test_text_to_polygons():
+def test_text_to_polygons() -> None:
     font_path = "/usr/share/fonts/truetype/dejavu/DejaVuMathTeXGyre.ttf"
-    if not os.path.exists(font_path):
+    if not Path(font_path).exists():
         pytest.skip("Font file not found")
 
     t = Text("Hi", height=10, font_path=font_path)
@@ -24,8 +25,9 @@ def test_text_to_polygons():
     char_x_means = [p.vertices[:, 0].mean() for p in polys]
     assert len(set(char_x_means)) >= 2
 
+
 # 2. Manhattanization tests
-def test_manhattanize():
+def test_manhattanize() -> None:
     # Diamond shape
     poly = Polygon([[0, 5], [5, 10], [10, 5], [5, 0]])
     grid = numpy.arange(0, 11, 1)
@@ -38,39 +40,43 @@ def test_manhattanize():
         # For each segment, either dx or dy must be zero
         assert numpy.all((dv[:, 0] == 0) | (dv[:, 1] == 0))
 
+
 # 3. Comparison and Sorting tests
-def test_shape_comparisons():
+def test_shape_comparisons() -> None:
     c1 = Circle(radius=10)
     c2 = Circle(radius=20)
     assert c1 < c2
     assert not (c2 < c1)
 
     p1 = Polygon([[0, 0], [10, 0], [10, 10]])
-    p2 = Polygon([[0, 0], [10, 0], [10, 11]]) # Different vertex
+    p2 = Polygon([[0, 0], [10, 0], [10, 11]])  # Different vertex
     assert p1 < p2
 
     # Different types
     assert c1 < p1 or p1 < c1
     assert (c1 < p1) != (p1 < c1)
 
+
 # 4. Arc/Path Edge Cases
-def test_arc_edge_cases():
+def test_arc_edge_cases() -> None:
     # Wrapped arc (> 360 deg)
-    a = Arc(radii=(10, 10), angles=(0, 3*pi), width=2)
-    polys = a.to_polygons(num_vertices=64)
+    a = Arc(radii=(10, 10), angles=(0, 3 * pi), width=2)
+    a.to_polygons(num_vertices=64)
     # Should basically be a ring
     bounds = a.get_bounds_single()
     assert_allclose(bounds, [[-11, -11], [11, 11]], atol=1e-10)
 
-def test_path_edge_cases():
+
+def test_path_edge_cases() -> None:
     # Zero-length segments
-    p = Path(vertices=[[0, 0], [0, 0], [10, 0]], width=2)
+    p = MPath(vertices=[[0, 0], [0, 0], [10, 0]], width=2)
     polys = p.to_polygons()
     assert len(polys) == 1
     assert_equal(polys[0].get_bounds_single(), [[0, -1], [10, 1]])
 
+
 # 5. PolyCollection with holes
-def test_poly_collection_holes():
+def test_poly_collection_holes() -> None:
     # Outer square, inner square hole
     # PolyCollection doesn't explicitly support holes, but its constituents (Polygons) do?
     # wait, Polygon in masque is just a boundary. Holes are usually handled by having multiple
@@ -80,8 +86,14 @@ def test_poly_collection_holes():
 
     # Let's test PolyCollection with multiple polygons
     verts = [
-        [0, 0], [10, 0], [10, 10], [0, 10], # Poly 1
-        [2, 2], [2, 8], [8, 8], [8, 2]      # Poly 2
+        [0, 0],
+        [10, 0],
+        [10, 10],
+        [0, 10],  # Poly 1
+        [2, 2],
+        [2, 8],
+        [8, 8],
+        [8, 2],  # Poly 2
     ]
     offsets = [0, 4]
     pc = PolyCollection(verts, offsets)
@@ -90,17 +102,23 @@ def test_poly_collection_holes():
     assert_equal(polys[0].vertices, [[0, 0], [10, 0], [10, 10], [0, 10]])
     assert_equal(polys[1].vertices, [[2, 2], [2, 8], [8, 8], [8, 2]])
 
-def test_poly_collection_constituent_empty():
+
+def test_poly_collection_constituent_empty() -> None:
     # One real triangle, one "empty" polygon (0 vertices), one real square
     # Note: Polygon requires 3 vertices, so "empty" here might mean just some junk
     # that to_polygons should handle.
     # Actually PolyCollection doesn't check vertex count per polygon.
     verts = [
-        [0, 0], [1, 0], [0, 1], # Tri
+        [0, 0],
+        [1, 0],
+        [0, 1],  # Tri
         # Empty space
-        [10, 10], [11, 10], [11, 11], [10, 11] # Square
+        [10, 10],
+        [11, 10],
+        [11, 11],
+        [10, 11],  # Square
     ]
-    offsets = [0, 3, 3] # Index 3 is start of "empty", Index 3 is also start of Square?
+    offsets = [0, 3, 3]  # Index 3 is start of "empty", Index 3 is also start of Square?
     # No, offsets should be strictly increasing or handle 0-length slices.
     # vertex_slices uses zip(offsets, chain(offsets[1:], [len(verts)]))
     # if offsets = [0, 3, 3], slices are [0:3], [3:3], [3:7]
@@ -113,22 +131,14 @@ def test_poly_collection_constituent_empty():
     with pytest.raises(PatternError):
         pc.to_polygons()
 
-def test_poly_collection_valid():
-    verts = [
-        [0, 0], [1, 0], [0, 1],
-        [10, 10], [11, 10], [11, 11], [10, 11]
-    ]
+
+def test_poly_collection_valid() -> None:
+    verts = [[0, 0], [1, 0], [0, 1], [10, 10], [11, 10], [11, 11], [10, 11]]
     offsets = [0, 3]
     pc = PolyCollection(verts, offsets)
     assert len(pc.to_polygons()) == 2
-    shapes = [
-        Circle(radius=20),
-        Circle(radius=10),
-        Polygon([[0, 0], [10, 0], [10, 10]]),
-        Ellipse(radii=(5, 5))
-    ]
+    shapes = [Circle(radius=20), Circle(radius=10), Polygon([[0, 0], [10, 0], [10, 10]]), Ellipse(radii=(5, 5))]
     sorted_shapes = sorted(shapes)
     assert len(sorted_shapes) == 4
     # Just verify it doesn't crash and is stable
     assert sorted(sorted_shapes) == sorted_shapes
-