Changed Space.shapes/bodies/constraints to return a KeysView #275

Author: viblo

CHANGELOG.rst

@@ -2,6 +2,8 @@
 Changelog 
 =========
 .. Pymunk 7.0.0
+   Changed Space.shapes, Space.bodies and Space.constraints to return a KeysView of instead of a list of the items. Note that this means its no longer a copy. To get the old behavior, do list(space.shapes) etc.
+
    Breaking: At least one of the two bodies attached to constraint/joint must be dynamic. 
    New feature: Vec2d supports bool to test if zero. (bool(Vec2d(2,3) == True) Note this is a breaking change.
    Added Vec2d.length_squared, and depreacted Vec2d.get_length_sqrd()
@@ -14,7 +16,7 @@ Changelog
    Changed body.shapes to return a KeysView instead of a set of the shapes.
    Changed Shape.segment_query to return None in case the query did not hit the shape.
    Changed ContactPointSet.points to be a tuple and not list to make it clear its length is fixed.
-
+   
    Added default do_nothing and always_collide callback functions to the CollisionHandler, so that its clear how to reset and align with other callbacks.
    If in old code you did handler.begin = None, you should now instead to handler.begin = CollisionHandler.always_collide etc.
 

pymunk/space.py

@@ -3,6 +3,7 @@
 import math
 import platform
 import weakref
+from collections.abc import KeysView
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -148,22 +149,47 @@ def spacefree(cp_space: ffi.CData) -> None:
         self._bodies_to_check: Set[Body] = set()
 
     @property
-    def shapes(self) -> List[Shape]:
-        """A list of all the shapes added to this space
+    def shapes(self) -> KeysView[Shape]:
+        """The shapes added to this space returned as a KeysView.
 
-        (includes both static and non-static)
+        Since its a view that is returned it will update as shapes are added::
+
+        >>> import pymunk
+        >>> s = pymunk.Space()
+        >>> s.add(pymunk.Circle(s.static_body, 1))
+        >>> shapes_view = s.shapes
+        >>> len(shapes_view)
+        1
+        >>> s.add(pymunk.Circle(s.static_body, 2))
+        >>> len(shapes_view)
+        2
         """
-        return list(self._shapes)
+        return self._shapes.keys()
 
     @property
-    def bodies(self) -> List[Body]:
-        """A list of the bodies added to this space"""
-        return list(self._bodies)
+    def bodies(self) -> KeysView[Body]:
+        """The bodies added to this space returned as a KeysView.
+
+        This includes both static and non-static bodies added to the Space.
+
+        Since its a view that is returned it will update as bodies are added::
+
+        >>> import pymunk
+        >>> s = pymunk.Space()
+        >>> s.add(pymunk.Body())
+        >>> bodies_view = s.bodies
+        >>> len(bodies_view)
+        1
+        >>> s.add(pymunk.Body())
+        >>> len(bodies_view)
+        2
+        """
+        return self._bodies.keys()
 
     @property
-    def constraints(self) -> List[Constraint]:
-        """A list of the constraints added to this space"""
-        return list(self._constraints)
+    def constraints(self) -> KeysView[Constraint]:
+        """The constraints added to this space as a KeysView."""
+        return self._constraints.keys()
 
     def _setup_static_body(self, static_body: Body) -> None:
         static_body._space = weakref.ref(self)
@@ -968,13 +994,13 @@ def __getstate__(self) -> _State:
 
         d["special"].append(("pymunk_version", _version.version))
         # bodies needs to be added to the state before their shapes.
-        d["special"].append(("bodies", self.bodies))
+        d["special"].append(("bodies", list(self.bodies)))
         if self._static_body != None:
             # print("getstate", self._static_body)
             d["special"].append(("_static_body", self._static_body))
 
-        d["special"].append(("shapes", self.shapes))
-        d["special"].append(("constraints", self.constraints))
+        d["special"].append(("shapes", list(self.shapes)))
+        d["special"].append(("constraints", list(self.constraints)))
 
         handlers = []
         for k, v in self._handlers.items():

pymunk/tests/test_space.py

@@ -102,18 +102,18 @@ def testSpatialHash(self) -> None:
     def testAddRemove(self) -> None:
         s = p.Space()
 
-        self.assertEqual(s.bodies, [])
-        self.assertEqual(s.shapes, [])
+        self.assertTrue(len(s.bodies) == 0)
+        self.assertTrue(len(s.shapes) == 0)
 
         b = p.Body(1, 2)
         s.add(b)
-        self.assertEqual(s.bodies, [b])
-        self.assertEqual(s.shapes, [])
+        self.assertEqual(list(s.bodies), [b])
+        self.assertTrue(len(s.shapes) == 0)
 
         c1 = p.Circle(b, 10)
         s.add(c1)
-        self.assertEqual(s.bodies, [b])
-        self.assertEqual(s.shapes, [c1])
+        self.assertEqual(list(s.bodies), [b])
+        self.assertEqual(list(s.shapes), [c1])
 
         c2 = p.Circle(b, 15)
         s.add(c2)
@@ -122,16 +122,16 @@ def testAddRemove(self) -> None:
         self.assertTrue(c2 in s.shapes)
 
         s.remove(c1)
-        self.assertEqual(s.shapes, [c2])
+        self.assertEqual(list(s.shapes), [c2])
 
         s.remove(c2, b)
-        self.assertEqual(s.bodies, [])
-        self.assertEqual(s.shapes, [])
+        self.assertEqual(len(s.bodies), 0)
+        self.assertEqual(len(s.shapes), 0)
 
         # note that shape is before the body, which is something to test
         s.add(c2, b)
-        self.assertEqual(s.bodies, [b])
-        self.assertEqual(s.shapes, [c2])
+        self.assertEqual(list(s.bodies), [b])
+        self.assertEqual(list(s.shapes), [c2])
 
     def testAddShapeAsserts(self) -> None:
         s1 = p.Space()
@@ -937,7 +937,7 @@ def pre_solve(arb: p.Arbiter, space: p.Space, data: Any) -> bool:
         ch = s.add_collision_handler(0, 0).pre_solve = pre_solve
 
         s.step(0.1)
-        self.assertEqual([], s.shapes)
+        self.assertEqual(len(s.shapes), 0)
         self.assertEqual(self.calls, 1)
 
         s.step(0.1)
@@ -1164,9 +1164,10 @@ def testPickleCachedArbiters(self) -> None:
 
         # TODO: to assert that everything is working as it should all
         # properties on the cached the arbiters should be asserted.
-
-        self.assertAlmostEqual(s.bodies[0].position.x, s_copy.bodies[0].position.x)
-        self.assertAlmostEqual(s.bodies[0].position.y, s_copy.bodies[0].position.y)
+        bodies = list(s.bodies)
+        copy_bodies = list(s_copy.bodies)
+        self.assertAlmostEqual(bodies[0].position.x, copy_bodies[0].position.x)
+        self.assertAlmostEqual(bodies[0].position.y, copy_bodies[0].position.y)
 
     def testDeleteSpaceWithObjects(self) -> None:
         s = p.Space()