Use list/tuple instead of typing.Tuple etc

Author: viblo

pymunk/__init__.py

@@ -30,10 +30,10 @@
 This is the main containing module of Pymunk. It contains among other things
 the very central Space, Body and Shape classes.
 
-Pymunk uses the standard logging module to log helpful information. It does 
+Pymunk uses the standard logging module to log helpful information. It does
 that under the "pymunk" name. If you do not do anything setup, it will print
-WARNING and higher messages to stderr. (Note that you most likely do not want 
-to set logLevel to DEBUG, since Pymunk might log a lot of debug level 
+WARNING and higher messages to stderr. (Note that you most likely do not want
+to set logLevel to DEBUG, since Pymunk might log a lot of debug level
 messages mostly useful during development of Pymunk itself.)
 
 """
@@ -68,7 +68,7 @@
     "Vec2d",
 ]
 
-from typing import Sequence, Tuple, cast
+from typing import Sequence, cast
 
 from . import _chipmunk_cffi
 
@@ -119,7 +119,7 @@ def moment_for_circle(
     mass: float,
     inner_radius: float,
     outer_radius: float,
-    offset: Tuple[float, float] = (0, 0),
+    offset: tuple[float, float] = (0, 0),
 ) -> float:
     """Calculate the moment of inertia for a hollow circle
 
@@ -131,7 +131,7 @@ def moment_for_circle(
 
 
 def moment_for_segment(
-    mass: float, a: Tuple[float, float], b: Tuple[float, float], radius: float
+    mass: float, a: tuple[float, float], b: tuple[float, float], radius: float
 ) -> float:
     """Calculate the moment of inertia for a line segment
 
@@ -143,7 +143,7 @@ def moment_for_segment(
     return cp.cpMomentForSegment(mass, a, b, radius)
 
 
-def moment_for_box(mass: float, size: Tuple[float, float]) -> float:
+def moment_for_box(mass: float, size: tuple[float, float]) -> float:
     """Calculate the moment of inertia for a solid box centered on the body.
 
     size should be a tuple of (width, height)
@@ -154,8 +154,8 @@ def moment_for_box(mass: float, size: Tuple[float, float]) -> float:
 
 def moment_for_poly(
     mass: float,
-    vertices: Sequence[Tuple[float, float]],
-    offset: Tuple[float, float] = (0, 0),
+    vertices: Sequence[tuple[float, float]],
+    offset: tuple[float, float] = (0, 0),
     radius: float = 0,
 ) -> float:
     """Calculate the moment of inertia for a solid polygon shape.
@@ -174,7 +174,7 @@ def area_for_circle(inner_radius: float, outer_radius: float) -> float:
 
 
 def area_for_segment(
-    a: Tuple[float, float], b: Tuple[float, float], radius: float
+    a: tuple[float, float], b: tuple[float, float], radius: float
 ) -> float:
     """Area of a beveled segment.
 
@@ -186,7 +186,7 @@ def area_for_segment(
     return cp.cpAreaForSegment(a, b, radius)
 
 
-def area_for_poly(vertices: Sequence[Tuple[float, float]], radius: float = 0) -> float:
+def area_for_poly(vertices: Sequence[tuple[float, float]], radius: float = 0) -> float:
     """Signed area of a polygon shape.
 
     Returns a negative number for polygons with a clockwise winding.

pymunk/_pickle.py

@@ -1,18 +1,18 @@
 import copy
-from typing import Any, ClassVar, Dict, List, Tuple, TypeVar
+from typing import Any, ClassVar, TypeVar
 
 T = TypeVar("T", bound="PickleMixin")
-_State = Dict[str, List[Tuple[str, Any]]]
+_State = dict[str, list[tuple[str, Any]]]
 
 
 class PickleMixin:
     """PickleMixin is used to provide base functionality for pickle/unpickle
     and copy.
     """
 
-    _pickle_attrs_init: ClassVar[List[str]] = []
-    _pickle_attrs_general: ClassVar[List[str]] = []
-    _pickle_attrs_skip: ClassVar[List[str]] = []
+    _pickle_attrs_init: ClassVar[list[str]] = []
+    _pickle_attrs_general: ClassVar[list[str]] = []
+    _pickle_attrs_skip: ClassVar[list[str]] = []
 
     def __getstate__(self) -> _State:
         """Return the state of this object
@@ -46,7 +46,7 @@ def __setstate__(self, state: _State) -> None:
         modules with this class.
         """
 
-        init_attrs: List[str] = []
+        init_attrs: list[str] = []
 
         init_args = [v for k, v in state["init"]]
         self.__init__(*init_args)  # type: ignore

pymunk/_pyglet15_util.py

@@ -21,20 +21,20 @@
 # SOFTWARE.
 # ----------------------------------------------------------------------------
 
-"""This submodule contains helper functions to help with quick prototyping 
+"""This submodule contains helper functions to help with quick prototyping
 using pymunk together with pyglet.
 
 Intended to help with debugging and prototyping, not for actual production use
-in a full application. The methods contained in this module is opinionated 
-about your coordinate system and not very optimized (they use batched 
-drawing, but there is probably room for optimizations still). 
+in a full application. The methods contained in this module is opinionated
+about your coordinate system and not very optimized (they use batched
+drawing, but there is probably room for optimizations still).
 """
 
 __docformat__ = "reStructuredText"
 
 import math
 import warnings
-from typing import TYPE_CHECKING, Any, List, Optional, Sequence, Type
+from typing import TYPE_CHECKING, Any, Optional, Sequence, Type
 
 import pyglet  # type: ignore
 
@@ -92,7 +92,7 @@ def __init__(self, **kwargs: Any) -> None:
 
         """
         self.new_batch = False
-        self.draw_shapes: List[Any] = []
+        self.draw_shapes: list[Any] = []
 
         if "batch" not in kwargs:
             self.new_batch = True

pymunk/_types.py

@@ -1,7 +1,7 @@
-from typing import TYPE_CHECKING, List, Tuple, Union
+from typing import TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
     from .vec2d import Vec2d
 
-_Vec2dOrTuple = Union[Tuple[float, float], List[float], "Vec2d"]
-_Vec2dOrFloat = Union[Tuple[float, float], List[float], "Vec2d", float]
+_Vec2dOrTuple = Union[tuple[float, float], list[float], "Vec2d"]
+_Vec2dOrFloat = Union[tuple[float, float], list[float], "Vec2d", float]

pymunk/arbiter.py

@@ -1,7 +1,7 @@
 __docformat__ = "reStructuredText"
 
 
-from typing import TYPE_CHECKING, Any, Dict, List, Sequence, Tuple
+from typing import TYPE_CHECKING, Any, Sequence
 
 if TYPE_CHECKING:
     from .space import Space
@@ -91,7 +91,7 @@ def contact_point_set(self, point_set: ContactPointSet) -> None:
         lib.cpArbiterSetContactPointSet(self._arbiter, ffi.addressof(_set))
 
     @property
-    def bodies(self) -> Tuple["Body", "Body"]:
+    def bodies(self) -> tuple["Body", "Body"]:
         """The the bodies in the order their corresponding shapes were defined
         in the collision handler associated with this arbiter.
 
@@ -109,7 +109,7 @@ def bodies(self) -> Tuple["Body", "Body"]:
         return a.body, b.body
 
     @property
-    def shapes(self) -> Tuple["Shape", "Shape"]:
+    def shapes(self) -> tuple["Shape", "Shape"]:
         """Get the shapes in the order that they were defined in the
         collision handler associated with this arbiter
         """
@@ -156,7 +156,7 @@ def _get_surface_velocity(self) -> Vec2d:
         v = lib.cpArbiterGetSurfaceVelocity(self._arbiter)
         return Vec2d(v.x, v.y)
 
-    def _set_surface_velocity(self, velocity: Tuple[float, float]) -> None:
+    def _set_surface_velocity(self, velocity: tuple[float, float]) -> None:
         lib.cpArbiterSetSurfaceVelocity(self._arbiter, velocity)
 
     surface_velocity = property(
@@ -223,14 +223,14 @@ def normal(self) -> Vec2d:
 
 def _contacts_to_dicts(
     _contacts: Sequence[ffi.CData], count: int
-) -> List[Dict[str, Any]]:
+) -> list[dict[str, Any]]:
     res = []
     for i in range(count):
         res.append(_contact_to_dict(_contacts[i]))
     return res
 
 
-def _contact_to_dict(_contact: ffi.CData) -> Dict[str, Any]:
+def _contact_to_dict(_contact: ffi.CData) -> dict[str, Any]:
     d = {}
     d["r1"] = _contact.r1.x, _contact.r1.y
     d["r2"] = _contact.r2.x, _contact.r2.y
@@ -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]]) -> List[ffi.CData]:
+def _contacts_from_dicts(ds: Sequence[dict[str, Any]]) -> dist[ffi.CData]:
     _contacts = lib.cpContactArrAlloc(len(ds))
     for i in range(len(ds)):
         _contact = _contacts[i]
@@ -265,7 +265,7 @@ def _contacts_from_dicts(ds: Sequence[Dict[str, Any]]) -> List[ffi.CData]:
     return _contacts
 
 
-def _arbiter_from_dict(d: Dict[str, Any], space: "Space") -> ffi.CData:
+def _arbiter_from_dict(d: dict[str, Any], space: "Space") -> ffi.CData:
     _arb = lib.cpArbiterNew(
         d["a"]._shape, d["b"]._shape
     )  # this will also set the bodies
@@ -285,7 +285,7 @@ def _arbiter_from_dict(d: Dict[str, Any], space: "Space") -> ffi.CData:
     return _arb
 
 
-def _arbiter_to_dict(_arbiter: ffi.CData, space: "Space") -> Dict[str, Any]:
+def _arbiter_to_dict(_arbiter: ffi.CData, space: "Space") -> dict[str, Any]:
     d = {}
     d["e"] = _arbiter.e
     d["u"] = _arbiter.u

pymunk/autogeometry.py

@@ -39,7 +39,7 @@
 
 __docformat__ = "reStructuredText"
 
-from typing import TYPE_CHECKING, Callable, List, Sequence, Tuple, Union, overload
+from typing import TYPE_CHECKING, Callable, Sequence, Union, overload
 
 if TYPE_CHECKING:
     from .bb import BB
@@ -48,11 +48,11 @@
 from ._chipmunk_cffi import ffi, lib
 from .vec2d import Vec2d
 
-_SampleFunc = Callable[[Tuple[float, float]], float]
+_SampleFunc = Callable[[tuple[float, float]], float]
 
-_Polyline = Union[List[Tuple[float, float]], List[Vec2d]]
+_Polyline = Union[list[tuple[float, float]], list[Vec2d]]
 # Union is needed since List is invariant
-# and Sequence cant be used since CFFI requires a List (or Tuple)
+# and Sequence cant be used since CFFI requires a list (or tuple)
 
 
 def _to_chipmunk(polyline: _Polyline) -> ffi.CData:
@@ -64,7 +64,7 @@ def _to_chipmunk(polyline: _Polyline) -> ffi.CData:
     return _line
 
 
-def _from_polyline_set(_set: ffi.CData) -> List[List[Vec2d]]:
+def _from_polyline_set(_set: ffi.CData) -> list[list[Vec2d]]:
     lines = []
     for i in range(_set.count):
         line = []
@@ -85,7 +85,7 @@ def is_closed(polyline: _Polyline) -> bool:
     return bool(lib.cpPolylineIsClosed(_to_chipmunk(polyline)))
 
 
-def simplify_curves(polyline: _Polyline, tolerance: float) -> List[Vec2d]:
+def simplify_curves(polyline: _Polyline, tolerance: float) -> list[Vec2d]:
     """Returns a copy of a polyline simplified by using the Douglas-Peucker
     algorithm.
 
@@ -105,7 +105,7 @@ def simplify_curves(polyline: _Polyline, tolerance: float) -> List[Vec2d]:
     return simplified
 
 
-def simplify_vertexes(polyline: _Polyline, tolerance: float) -> List[Vec2d]:
+def simplify_vertexes(polyline: _Polyline, tolerance: float) -> list[Vec2d]:
     """Returns a copy of a polyline simplified by discarding "flat" vertexes.
 
     This works well on straight edged or angular shapes, not as well on smooth
@@ -123,7 +123,7 @@ def simplify_vertexes(polyline: _Polyline, tolerance: float) -> List[Vec2d]:
     return simplified
 
 
-def to_convex_hull(polyline: _Polyline, tolerance: float) -> List[Vec2d]:
+def to_convex_hull(polyline: _Polyline, tolerance: float) -> list[Vec2d]:
     """Get the convex hull of a polyline as a looped polyline.
 
     :param polyline: Polyline to simplify.
@@ -138,7 +138,7 @@ def to_convex_hull(polyline: _Polyline, tolerance: float) -> List[Vec2d]:
     return hull
 
 
-def convex_decomposition(polyline: _Polyline, tolerance: float) -> List[List[Vec2d]]:
+def convex_decomposition(polyline: _Polyline, tolerance: float) -> list[list[Vec2d]]:
     """Get an approximate convex decomposition from a polyline.
 
     Returns a list of convex hulls that match the original shape to within
@@ -164,7 +164,7 @@ def convex_decomposition(polyline: _Polyline, tolerance: float) -> List[List[Vec
     return _from_polyline_set(_set)
 
 
-class PolylineSet(Sequence[List[Vec2d]]):
+class PolylineSet(Sequence[list[Vec2d]]):
     """A set of Polylines.
 
     Mainly intended to be used for its :py:meth:`collect_segment` function
@@ -180,7 +180,7 @@ def free(_set: ffi.CData) -> None:
 
         self._set = ffi.gc(lib.cpPolylineSetNew(), free)
 
-    def collect_segment(self, v0: Tuple[float, float], v1: Tuple[float, float]) -> None:
+    def collect_segment(self, v0: tuple[float, float], v1: tuple[float, float]) -> None:
         """Add a line segment to a polyline set.
 
         A segment will either start a new polyline, join two others, or add to
@@ -201,14 +201,14 @@ def __len__(self) -> int:
         return self._set.count
 
     @overload
-    def __getitem__(self, index: int) -> List[Vec2d]: ...
+    def __getitem__(self, index: int) -> list[Vec2d]: ...
 
     @overload
     def __getitem__(self, index: slice) -> "PolylineSet": ...
 
     def __getitem__(
         self, index: Union[int, slice]
-    ) -> Union[List[Vec2d], "PolylineSet"]:
+    ) -> Union[list[Vec2d], "PolylineSet"]:
         assert not isinstance(index, slice), "Slice indexing not supported"
         if index >= self._set.count:
             raise IndexError
@@ -238,7 +238,7 @@ def march_soft(
     :param sample_func: The sample function will be called for
         x_samples * y_samples spread across the bounding box area, and should
         return a float.
-    :type sample_func: ``func(point: Tuple[float, float]) -> float``
+    :type sample_func: ``func(point: tuple[float, float]) -> float``
     :return: PolylineSet with the polylines found.
     """
     pl_set = PolylineSet()
@@ -278,7 +278,7 @@ def march_hard(
     :param sample_func: The sample function will be called for
         x_samples * y_samples spread across the bounding box area, and should
         return a float.
-    :type sample_func: ``func(point: Tuple[float, float]) -> float``
+    :type sample_func: ``func(point: tuple[float, float]) -> float``
     :return: PolylineSet with the polylines found.
     """