Updated support prompt to indicate free-threaded builds, and GIL status on free-threaded builds

Author: oddbookworm

src_py/__init__.py

@@ -399,9 +399,20 @@ def __color_reduce(c):
 copyreg.pickle(Color, __color_reduce, __color_constructor)
 
 if "PYGAME_HIDE_SUPPORT_PROMPT" not in os.environ:
+    python_implementation = sys.version
+    python_version = platform.python_version()
+    from packaging import version
+
+    if (
+        sys.platform not in ("wasi", "wasm")
+        and (version.parse(python_version) >= version.parse("3.13.0"))
+        and "free-threading" in python_implementation
+    ):
+        python_version += f"t, {'' if sys._is_gil_enabled() else 'No '}GIL"
+
     print(
         f"pygame-ce {ver} (SDL {'.'.join(map(str, get_sdl_version()))}, "
-        f"Python {platform.python_version()})"
+        f"Python {python_version})"
     )
 
 # cleanup namespace

src_py/gpusprite.py

@@ -0,0 +1,269 @@
+import types
+from typing import Optional
+
+import pygame
+from pygame._sdl2.video import Renderer, Texture
+
+
+class Sprite:
+    __slots__ = {"__image", "__rect", "__g"}
+
+    def __init__(self, *groups):
+        self.__g = {}
+        self.__rect: Optional[pygame.Rect] = None
+        self.__image: Optional[Texture] = None
+
+        for g in groups:
+            self.add(g)
+
+    @property
+    def image(self):
+        return self.__image
+
+    @image.setter
+    def image(self, value: Optional[Texture]):
+        self.__image = value
+
+    @property
+    def rect(self):
+        return self.__rect
+
+    @rect.setter
+    def rect(self, value: Optional[pygame.Rect]):
+        self.__rect = value
+
+    def add(self, *groups):
+        has = self.__g.__contains__
+        for group in groups:
+            if hasattr(group, "_spritegroup"):
+                if not has(group):
+                    group.add_internal(self)
+                    self.add_internal(group)
+            else:
+                self.add(*group)
+
+    def remove(self, *groups):
+        has = self.__g.__contains__
+        for group in groups:
+            if hasattr(group, "_spritegroup"):
+                if has(group):
+                    group.remove_internal(self)
+                    self.remove_internal(group)
+            else:
+                self.remove(*group)
+
+    def add_internal(self, group):
+        self.__g[group] = 0
+
+    def remove_internal(self, group):
+        del self.__g[group]
+
+    def update(self, *args, **kwargs):
+        pass
+
+    def kill(self):
+        for group in self.__g:
+            group.remove_internal(self)
+        self.__g.clear()
+
+    def groups(self):
+        return list(self.__g)
+
+    def alive(self):
+        return bool(self.__g)
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__} Sprite(in {len(self.__g)} groups)>"
+
+    @property
+    def layer(self):
+        return getattr(self, "_layer")
+
+    @layer.setter
+    def layer(self, value):
+        if not self.alive():
+            setattr(self, "_layer", value)
+        else:
+            raise AttributeError(
+                "Can't set layer directly after "
+                "adding to group. Use "
+                "group.change_layer(sprite, new_layer) "
+                "instead."
+            )
+
+
+class AbstractGroup:
+    __slots__ = ["spritedict", "lostsprites"]
+    __class_getitem__ = classmethod(types.GenericAlias)
+
+    # protected identifier value to identify sprite groups, and avoid infinite recursion
+    _spritegroup = True
+
+    def __init__(self):
+        self.spritedict = {}
+        self.lostsprites = []
+
+    def sprites(self):
+        return list(self.spritedict)
+
+    def add_internal(
+        self,
+        sprite,
+    ):
+        self.spritedict[sprite] = None
+
+    def remove_internal(self, sprite):
+        if lost_rect := self.spritedict[sprite]:
+            self.lostsprites.append(lost_rect)
+        del self.spritedict[sprite]
+
+    def has_internal(self, sprite):
+        return sprite in self.spritedict
+
+    def copy(self):
+        return self.__class__(  # noqa pylint: disable=too-many-function-args
+            self.sprites()  # Needed because copy() won't work on AbstractGroup
+        )
+
+    def __iter__(self):
+        return iter(self.sprites())
+
+    def __contains__(self, sprite):
+        return self.has(sprite)
+
+    def add(self, *sprites):
+        for sprite in sprites:
+            # It's possible that some sprite is also an iterator.
+            # If this is the case, we should add the sprite itself,
+            # and not the iterator object.
+            if isinstance(sprite, Sprite):
+                if not self.has_internal(sprite):
+                    self.add_internal(sprite)
+                    sprite.add_internal(self)
+            else:
+                try:
+                    # See if sprite is an iterator, like a list or sprite
+                    # group.
+                    self.add(*sprite)
+                except (TypeError, AttributeError):
+                    # Not iterable. This is probably a sprite that is not an
+                    # instance of the Sprite class or is not an instance of a
+                    # subclass of the Sprite class. Alternately, it could be an
+                    # old-style sprite group.
+                    if hasattr(sprite, "_spritegroup"):
+                        for spr in sprite.sprites():
+                            if not self.has_internal(spr):
+                                self.add_internal(spr)
+                                spr.add_internal(self)
+                    elif not self.has_internal(sprite):
+                        self.add_internal(sprite)
+                        sprite.add_internal(self)
+
+    def remove(self, *sprites):
+        # This function behaves essentially the same as Group.add. It first
+        # tries to handle each argument as an instance of the Sprite class. If
+        # that fails, then it tries to handle the argument as an iterable
+        # object. If that fails, then it tries to handle the argument as an
+        # old-style sprite group. Lastly, if that fails, it assumes that the
+        # normal Sprite methods should be used.
+        for sprite in sprites:
+            if isinstance(sprite, Sprite):
+                if self.has_internal(sprite):
+                    self.remove_internal(sprite)
+                    sprite.remove_internal(self)
+            else:
+                try:
+                    self.remove(*sprite)
+                except (TypeError, AttributeError):
+                    if hasattr(sprite, "_spritegroup"):
+                        for spr in sprite.sprites():
+                            if self.has_internal(spr):
+                                self.remove_internal(spr)
+                                spr.remove_internal(self)
+                    elif self.has_internal(sprite):
+                        self.remove_internal(sprite)
+                        sprite.remove_internal(self)
+
+    def has(self, *sprites):
+        if not sprites:
+            return False  # return False if no sprites passed in
+
+        for sprite in sprites:
+            if isinstance(sprite, Sprite):
+                # Check for Sprite instance's membership in this group
+                if not self.has_internal(sprite):
+                    return False
+            else:
+                try:
+                    if not self.has(*sprite):
+                        return False
+                except (TypeError, AttributeError):
+                    if hasattr(sprite, "_spritegroup"):
+                        for spr in sprite.sprites():
+                            if not self.has_internal(spr):
+                                return False
+                    else:
+                        if not self.has_internal(sprite):
+                            return False
+
+        return True
+
+    def update(self, *args, **kwargs):
+        for sprite in self.sprites():
+            sprite.update(*args, **kwargs)
+
+    def draw(self, surface, bgd=None, special_flags=0):  # noqa pylint: disable=unused-argument; bgd arg used in LayeredDirty
+        sprites = self.sprites()
+        if hasattr(surface, "blits"):
+            self.spritedict.update(
+                zip(
+                    sprites,
+                    surface.blits(
+                        (spr.image, spr.rect, None, special_flags) for spr in sprites
+                    ),
+                )
+            )
+        else:
+            for spr in sprites:
+                self.spritedict[spr] = surface.blit(
+                    spr.image, spr.rect, None, special_flags
+                )
+        self.lostsprites = []
+        dirty = self.lostsprites
+
+        return dirty
+
+    def clear(self, surface, bgd):
+        if callable(bgd):
+            for lost_clear_rect in self.lostsprites:
+                bgd(surface, lost_clear_rect)
+            for clear_rect in self.spritedict.values():
+                if clear_rect:
+                    bgd(surface, clear_rect)
+        else:
+            surface_blit = surface.blit
+            for lost_clear_rect in self.lostsprites:
+                surface_blit(bgd, lost_clear_rect, lost_clear_rect)
+            for clear_rect in self.spritedict.values():
+                if clear_rect:
+                    surface_blit(bgd, clear_rect, clear_rect)
+
+    def empty(self):
+        for sprite in self.sprites():
+            self.remove_internal(sprite)
+            sprite.remove_internal(self)
+
+    def __bool__(self):
+        return bool(self.sprites())
+
+    def __len__(self):
+        return len(self.sprites())
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__}({len(self)} sprites)>"
+
+
+class Group(AbstractGroup):
+    def __init__(self, *sprites):
+        AbstractGroup.__init__(self)
+        self.add(*sprites)