Minor type cleanup

Author: viblo

pymunk/arbiter.py

@@ -245,7 +245,7 @@ def _contact_to_dict(_contact: ffi.CData) -> dict[str, Any]:
     return d
 
 
-def _contacts_from_dicts(ds: Sequence[dict[str, Any]]) -> dist[ffi.CData]:
+def _contacts_from_dicts(ds: Sequence[dict[str, Any]]) -> ffi.CData:
     _contacts = lib.cpContactArrAlloc(len(ds))
     for i in range(len(ds)):
         _contact = _contacts[i]

pymunk/shapes.py

@@ -211,7 +211,7 @@ def _get_surface_velocity(self) -> Vec2d:
         v = cp.cpShapeGetSurfaceVelocity(self._shape)
         return Vec2d(v.x, v.y)
 
-    def _set_surface_velocity(self, surface_v: Tuple[float, float]) -> None:
+    def _set_surface_velocity(self, surface_v: tuple[float, float]) -> None:
         assert len(surface_v) == 2
         cp.cpShapeSetSurfaceVelocity(self._shape, surface_v)
 
@@ -276,12 +276,12 @@ def bb(self) -> BB:
         _bb = cp.cpShapeGetBB(self._shape)
         return BB(_bb.l, _bb.b, _bb.r, _bb.t)
 
-    def point_query(self, p: Tuple[float, float]) -> PointQueryInfo:
+    def point_query(self, p: tuple[float, float]) -> PointQueryInfo:
         """Check if the given point lies within the shape.
 
         A negative distance means the point is within the shape.
 
-        :return: Tuple of (distance, info)
+        :return: tuple of (distance, info)
         :rtype: (float, :py:class:`PointQueryInfo`)
         """
         assert len(p) == 2
@@ -298,7 +298,7 @@ def point_query(self, p: Tuple[float, float]) -> PointQueryInfo:
         )
 
     def segment_query(
-        self, start: Tuple[float, float], end: Tuple[float, float], radius: float = 0
+        self, start: tuple[float, float], end: tuple[float, float], radius: float = 0
     ) -> Optional[SegmentQueryInfo]:
         """Check if the line segment from start to end intersects the shape.
 
@@ -380,7 +380,7 @@ def __init__(
         self,
         body: Optional["Body"],
         radius: float,
-        offset: Tuple[float, float] = (0, 0),
+        offset: tuple[float, float] = (0, 0),
     ) -> None:
         """body is the body attach the circle to, offset is the offset from the
         body's center of gravity in body local coordinates.
@@ -410,7 +410,7 @@ def radius(self) -> float:
         """The Radius of the circle."""
         return cp.cpCircleShapeGetRadius(self._shape)
 
-    def unsafe_set_offset(self, o: Tuple[float, float]) -> None:
+    def unsafe_set_offset(self, o: tuple[float, float]) -> None:
         """Unsafe set the offset of the circle.
 
         .. note::
@@ -441,8 +441,8 @@ class Segment(Shape):
     def __init__(
         self,
         body: Optional["Body"],
-        a: Tuple[float, float],
-        b: Tuple[float, float],
+        a: tuple[float, float],
+        b: tuple[float, float],
         radius: float,
     ) -> None:
         """Create a Segment.
@@ -476,7 +476,7 @@ def b(self) -> Vec2d:
         return Vec2d(v.x, v.y)
 
     def unsafe_set_endpoints(
-        self, a: Tuple[float, float], b: Tuple[float, float]
+        self, a: tuple[float, float], b: tuple[float, float]
     ) -> None:
         """Set the two endpoints for this segment.
 
@@ -513,7 +513,7 @@ def radius(self) -> float:
         return cp.cpSegmentShapeGetRadius(self._shape)
 
     def set_neighbors(
-        self, prev: Tuple[float, float], next: Tuple[float, float]
+        self, prev: tuple[float, float], next: tuple[float, float]
     ) -> None:
         """When you have a number of segment shapes that are all joined
         together, things can still collide with the "cracks" between the
@@ -534,7 +534,7 @@ class Poly(Shape):
     def __init__(
         self,
         body: Optional["Body"],
-        vertices: Sequence[Tuple[float, float]],
+        vertices: Sequence[tuple[float, float]],
         transform: Optional[Transform] = None,
         radius: float = 0,
     ) -> None:
@@ -616,7 +616,7 @@ def radius(self) -> float:
 
     @staticmethod
     def create_box(
-        body: Optional["Body"], size: Tuple[float, float] = (10, 10), radius: float = 0
+        body: Optional["Body"], size: tuple[float, float] = (10, 10), radius: float = 0
     ) -> "Poly":
         """Convenience function to create a box with given width and height.
 
@@ -665,7 +665,7 @@ def create_box_bb(body: Optional["Body"], bb: BB, radius: float = 0) -> "Poly":
 
         return self
 
-    def get_vertices(self) -> List[Vec2d]:
+    def get_vertices(self) -> list[Vec2d]:
         """Get the vertices in local coordinates for the polygon.
 
         If you need the vertices in world coordinates then the vertices can be
@@ -696,7 +696,7 @@ def get_vertices(self) -> List[Vec2d]:
 
     def unsafe_set_vertices(
         self,
-        vertices: Sequence[Tuple[float, float]],
+        vertices: Sequence[tuple[float, float]],
         transform: Optional[Transform] = None,
     ) -> None:
         """Unsafe set the vertices of the poly.

pymunk/space.py

@@ -687,7 +687,7 @@ def add_wildcard_collision_handler(self, collision_type_a: int) -> CollisionHand
         self._handlers[collision_type_a] = ch
         return ch
 
-    def add_all_collision_handler(self) -> CollisionHandler:
+    def add_global_collision_handler(self) -> CollisionHandler:
         """Return a reference to the default collision handler or that is
         used to process all collisions that don't have a more specific
         handler.

pymunk/tests/test_arbiter.py

@@ -23,7 +23,7 @@ def testRestitution(self) -> None:
 
         s.add(b1, c1, b2, c2)
 
-        def pre_solve(arb: p.Arbiter, space: p.Space, data: Any):
+        def pre_solve(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             self.assertEqual(arb.restitution, 0.18)
             arb.restitution = 1
 
@@ -51,7 +51,7 @@ def testFriction(self) -> None:
 
         s.add(b1, c1, b2, c2)
 
-        def pre_solve(arb: p.Arbiter, space: p.Space, data: Any):
+        def pre_solve(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             self.assertEqual(arb.friction, 0.18)
             arb.friction = 1
 
@@ -79,7 +79,7 @@ def testSurfaceVelocity(self) -> None:
 
         s.add(b1, c1, b2, c2)
 
-        def pre_solve(arb: p.Arbiter, space: p.Space, data: Any):
+        def pre_solve(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             self.assertAlmostEqual(arb.surface_velocity.x, 1.38461538462)
             self.assertAlmostEqual(arb.surface_velocity.y, -0.923076923077)
 
@@ -105,7 +105,7 @@ def testContactPointSet(self) -> None:
 
         s.add(b1, c1, b2, c2)
 
-        def pre_solve(arb: p.Arbiter, space: p.Space, data: Any):
+        def pre_solve(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             # check inital values
             ps: p.ContactPointSet = arb.contact_point_set
             self.assertEqual(len(ps.points), 1)
@@ -216,17 +216,15 @@ def testIsFirstContact(self) -> None:
 
         s.add(b1, c1, b2, c2)
 
-        def pre_solve1(arb: p.Arbiter, space: p.Space, data: Any) -> bool:
+        def pre_solve1(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             self.assertTrue(arb.is_first_contact)
-            return True
 
         s.add_collision_handler(1, 2).pre_solve = pre_solve1
 
         s.step(0.1)
 
-        def pre_solve2(arb: p.Arbiter, space: p.Space, data: Any) -> bool:
+        def pre_solve2(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             self.assertFalse(arb.is_first_contact)
-            return True
 
         s.add_collision_handler(1, 2).pre_solve = pre_solve2
 
@@ -243,7 +241,7 @@ def testNormal(self) -> None:
 
         s.add(b1, c1, c2)
 
-        def pre_solve1(arb: p.Arbiter, space: p.Space, data: Any):
+        def pre_solve1(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             self.assertAlmostEqual(arb.normal.x, 0.44721359)
             self.assertAlmostEqual(arb.normal.y, 0.89442719)
 
@@ -313,14 +311,13 @@ def testShapesAndBodies(self) -> None:
 
         self.called = False
 
-        def pre_solve(arb: p.Arbiter, space: p.Space, data: Any) -> bool:
+        def pre_solve(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             self.called = True
             self.assertEqual(len(arb.shapes), 2)
             self.assertEqual(arb.shapes[0], c1)
             self.assertEqual(arb.shapes[1], c2)
             self.assertEqual(arb.bodies[0], arb.shapes[0].body)
             self.assertEqual(arb.bodies[1], arb.shapes[1].body)
-            return True
 
         s.add_collision_handler(1, 2).pre_solve = pre_solve
 

pymunk/tests/test_body.py

@@ -398,5 +398,5 @@ def pf(body: p.Body, dt: float) -> None:
     body.pf = True
 
 
-def vf(body: p.Body, gravity: Tuple[float, float], damping: float, dt: float) -> None:
+def vf(body: p.Body, gravity: tuple[float, float], damping: float, dt: float) -> None:
     body.vf = True

pymunk/tests/test_shape.py

@@ -298,7 +298,7 @@ def testSegmentSegmentCollision(self) -> None:
 
         self.num_of_begins = 0
 
-        def begin(arb: p.Arbiter, space: p.Space, data: Any):
+        def begin(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             self.num_of_begins += 1
 
         s.add_global_collision_handler().begin = begin

pymunk/tests/test_space.py

@@ -509,7 +509,7 @@ def testCollisionHandlerBegin(self) -> None:
 
         self.hits = 0
 
-        def begin(arb: p.Arbiter, space: p.Space, data: Any):
+        def begin(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             self.hits += h.data["test"]
 
         h = s.add_collision_handler(0, 0)
@@ -532,7 +532,7 @@ def testCollisionHandlerPreSolve(self) -> None:
 
         d = {}
 
-        def pre_solve(arb: p.Arbiter, space: p.Space, data: Any):
+        def pre_solve(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             d["shapes"] = arb.shapes
             d["space"] = space  # type: ignore
             d["test"] = data["test"]
@@ -761,13 +761,13 @@ def testCollisionHandlerAddRemoveInStep(self) -> None:
         b = p.Body(1, 2)
         c = p.Circle(b, 2)
 
-        def pre_solve_add(arb: p.Arbiter, space: p.Space, data: Any):
+        def pre_solve_add(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             space.add(b, c)
             space.add(c, b)
             self.assertTrue(b not in s.bodies)
             self.assertTrue(c not in s.shapes)
 
-        def pre_solve_remove(arb: p.Arbiter, space: p.Space, data: Any):
+        def pre_solve_remove(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             space.remove(b, c)
             space.remove(c, b)
             self.assertTrue(b in s.bodies)
@@ -791,7 +791,7 @@ def testCollisionHandlerRemoveInStep(self) -> None:
         self._setUp()
         s = self.s
 
-        def pre_solve(arb: p.Arbiter, space: p.Space, data: Any):
+        def pre_solve(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             space.remove(*arb.shapes)
 
         s.add_collision_handler(0, 0).pre_solve = pre_solve
@@ -819,7 +819,7 @@ def testWildcardCollisionHandler(self) -> None:
 
         d = {}
 
-        def pre_solve(arb: p.Arbiter, space: p.Space, data: Any):
+        def pre_solve(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             d["shapes"] = arb.shapes
             d["space"] = space  # type: ignore
 
@@ -847,7 +847,7 @@ def testDefaultCollisionHandler(self) -> None:
 
         d = {}
 
-        def pre_solve(arb: p.Arbiter, space: p.Space, data: Any):
+        def pre_solve(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             d["shapes"] = arb.shapes
             d["space"] = space  # type: ignore
 
@@ -879,7 +879,7 @@ def callback(
                 s.remove(shape)
             test_self.calls += 1
 
-        def pre_solve(arb: p.Arbiter, space: p.Space, data: Any):
+        def pre_solve(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             # note that we dont pass on the whole arbiters object, instead
             # we take only the shapes.
             space.add_post_step_callback(callback, 0, arb.shapes, test_self=self)