This commit is contained in:
wittmannzl103469 committed 2026-11-05 15:08:42 +01:00
1 parent de41a02749
commit 9af09cebd3
764 files changed
+54218 -78859

No files matched your search

@@ -1,165 +1,238 @@
import sys
import types
from collections.abc import Callable, Iterable, Iterator
from typing import (
Any,
Callable,
Dict,
Generic,
Protocol,
Iterable,
Iterator,
List,
Literal,
Optional,
SupportsFloat,
TypeAlias,
Tuple,
TypeVar,
Union,
)
# use typing_extensions for compatibility with older Python versions
if sys.version_info >= (3, 13):
from warnings import deprecated
else:
from typing_extensions import deprecated
# Protocol added in python 3.8
from typing_extensions import Protocol
if sys.version_info >= (3, 11):
from typing import Self
else:
from typing_extensions import Self
from pygame.mask import Mask
from pygame.rect import FRect, Rect
from pygame.rect import Rect
from pygame.surface import Surface
from pygame.typing import Point, RectLike
from pygame.mask import Mask
# Some sprite functions only need objects with certain attributes, not always a sprite
class _HasRect(Protocol):
@property
def rect(self) -> FRect | Rect | None: ...
from ._common import RectValue, Coordinate
# image in addition to rect
class _HasImageAndRect(_HasRect, Protocol):
@property
def image(self) -> Surface | None: ...
# non-generic Group, used in Sprite
_Group = AbstractGroup[_SpriteSupportsGroup]
# mask in addition to rect
class _HasMaskAndRect(_HasRect, Protocol):
@property
def mask(self) -> Mask: ...
class Sprite(_HasImageAndRect):
@property
def image(self) -> Surface | None: ...
@image.setter
def image(self, value: Surface | None) -> None: ...
@property
def rect(self) -> FRect | Rect | None: ...
@rect.setter
def rect(self, value: FRect | Rect | None) -> None: ...
# protocol helps with structural subtyping for typevars in sprite group generics
class _SupportsSprite(Protocol):
@property
def layer(self) -> int: ...
@layer.setter
def layer(self, value: int) -> None: ...
def __init__(self, *groups: _GroupOrGroups[Any]) -> None: ...
def add_internal(self, group: AbstractGroup[Any]) -> None: ...
def remove_internal(self, group: AbstractGroup[Any]) -> None: ...
def __init__(self, *groups: _Group) -> None: ...
def add_internal(self, group: _Group) -> None: ...
def remove_internal(self, group: _Group) -> None: ...
def update(self, *args: Any, **kwargs: Any) -> None: ...
def add(self, *groups: _GroupOrGroups[Any]) -> None: ...
def remove(self, *groups: _GroupOrGroups[Any]) -> None: ...
def add(self, *groups: _Group) -> None: ...
def remove(self, *groups: _Group) -> None: ...
def kill(self) -> None: ...
def alive(self) -> bool: ...
def groups(self) -> list[AbstractGroup[Sprite]]: ...
def groups(self) -> List[_Group]: ...
class DirtySprite(Sprite):
# also a protocol
class _SupportsDirtySprite(_SupportsSprite, Protocol):
dirty: int
blendmode: int
source_rect: FRect | Rect
source_rect: Rect
visible: int
_layer: int
def _set_visible(self, val: int) -> None: ...
def _get_visible(self) -> int: ...
_SpriteT = TypeVar("_SpriteT", bound=Sprite)
_SpriteT2 = TypeVar("_SpriteT2", bound=Sprite)
_DirtySpriteT = TypeVar("_DirtySpriteT", bound=DirtySprite)
# concrete sprite implementation class
class Sprite(_SupportsSprite):
@property
def layer(self) -> int: ...
@layer.setter
def layer(self, value: int) -> None: ...
def __init__(self, *groups: _Group) -> None: ...
def add_internal(self, group: _Group) -> None: ...
def remove_internal(self, group: _Group) -> None: ...
def update(self, *args: Any, **kwargs: Any) -> None: ...
def add(self, *groups: _Group) -> None: ...
def remove(self, *groups: _Group) -> None: ...
def kill(self) -> None: ...
def alive(self) -> bool: ...
def groups(self) -> List[_Group]: ...
_GroupOrGroups: TypeAlias = AbstractGroup[_SpriteT] | Iterable[_GroupOrGroups[_SpriteT]]
_SpriteOrSprites: TypeAlias = _SpriteT | Iterable[_SpriteOrSprites[_SpriteT]]
class WeakSprite(Sprite):
...
class AbstractGroup(Generic[_SpriteT]):
spritedict: dict[_SpriteT, FRect | Rect | None]
lostsprites: list[FRect | Rect]
def __class_getitem__(cls, item: Any, /) -> types.GenericAlias: ...
# concrete dirty sprite implementation class
class DirtySprite(_SupportsDirtySprite):
dirty: int
blendmode: int
source_rect: Rect
visible: int
_layer: int
def _set_visible(self, val: int) -> None: ...
def _get_visible(self) -> int: ...
class WeakDirtySprite(WeakSprite, DirtySprite):
...
# used as a workaround for typing.Self because it is added in python 3.11
_TGroup = TypeVar("_TGroup", bound=AbstractGroup)
# define some useful protocols first, which sprite functions accept
# sprite functions don't need all sprite attributes to be present in the
# arguments passed, they only use a few which are marked in the below protocols
class _HasRect(Protocol):
rect: Rect
# image in addition to rect
class _HasImageAndRect(_HasRect, Protocol):
image: Surface
# mask in addition to rect
class _HasMaskAndRect(_HasRect, Protocol):
mask: Mask
# radius in addition to rect
class _HasRadiusAndRect(_HasRect, Protocol):
radius: float
class _SpriteSupportsGroup(_SupportsSprite, _HasImageAndRect, Protocol): ...
class _DirtySpriteSupportsGroup(_SupportsDirtySprite, _HasImageAndRect, Protocol): ...
# typevar bound to Sprite, _SpriteSupportsGroup Protocol ensures sprite
# subclass passed to group has image and rect attributes
_TSprite = TypeVar("_TSprite", bound=_SpriteSupportsGroup)
_TSprite2 = TypeVar("_TSprite2", bound=_SpriteSupportsGroup)
# almost the same as _TSprite but bound to DirtySprite
_TDirtySprite = TypeVar("_TDirtySprite", bound=_DirtySpriteSupportsGroup)
# Below code demonstrates the advantages of the _SpriteSupportsGroup protocol
# typechecker should error, regular Sprite does not support Group.draw due to
# missing image and rect attributes
# a = Group(Sprite())
# typechecker should error, other Sprite attributes are also needed for Group
# class MySprite:
# image: Surface
# rect: Rect
#
# b = Group(MySprite())
# typechecker should pass
# class MySprite(Sprite):
# image: Surface
# rect: Rect
#
# b = Group(MySprite())
class AbstractGroup(Generic[_TSprite]):
spritedict: Dict[_TSprite, Optional[Rect]]
lostsprites: List[Rect]
def __init__(self) -> None: ...
def __len__(self) -> int: ...
def __iter__(self) -> Iterator[_SpriteT]: ...
def __iter__(self) -> Iterator[_TSprite]: ...
def __bool__(self) -> bool: ...
def __contains__(self, item: Any) -> bool: ...
def add_internal(self, sprite: _SpriteT, layer: int | None = None) -> None: ...
def remove_internal(self, sprite: _SpriteT) -> None: ...
def has_internal(self, sprite: _SpriteT) -> bool: ...
def copy(self) -> Self: ...
def sprites(self) -> list[_SpriteT]: ...
def add(self, *sprites: _SpriteOrSprites[_SpriteT]) -> None: ...
def remove(self, *sprites: _SpriteOrSprites[_SpriteT]) -> None: ...
def has(self, *sprites: _SpriteOrSprites[_SpriteT]) -> bool: ...
def add_internal(self, sprite: _TSprite, layer: None = None) -> None: ...
def remove_internal(self, sprite: _TSprite) -> None: ...
def has_internal(self, sprite: _TSprite) -> bool: ...
def copy(self: _TGroup) -> _TGroup: ... # typing.Self is py3.11+
def sprites(self) -> List[_TSprite]: ...
def add(
self, *sprites: Union[_TSprite, AbstractGroup[_TSprite], Iterable[_TSprite]]
) -> None: ...
def remove(
self, *sprites: Union[_TSprite, AbstractGroup[_TSprite], Iterable[_TSprite]]
) -> None: ...
def has(
self, *sprites: Union[_TSprite, AbstractGroup[_TSprite], Iterable[_TSprite]]
) -> bool: ...
def update(self, *args: Any, **kwargs: Any) -> None: ...
def draw(
self, surface: Surface, bgd: Surface | None = None, special_flags: int = 0
) -> list[FRect | Rect]: ...
self, surface: Surface, bgsurf: Optional[Surface] = None, special_flags: int = 0
) -> List[Rect]: ...
def clear(
self,
surface: Surface,
bgd: Surface | Callable[[Surface, FRect | Rect], Any],
self, surface: Surface, bgd: Union[Surface, Callable[[Surface, Rect], Any]]
) -> None: ...
def empty(self) -> None: ...
class Group(AbstractGroup[_SpriteT]):
def __init__(self, *sprites: _SpriteOrSprites[_SpriteT]) -> None: ...
class Group(AbstractGroup[_TSprite]):
def __init__(
self, *sprites: Union[_TSprite, AbstractGroup[_TSprite], Iterable[_TSprite]]
) -> None: ...
# These deprecated types are just aliases in the code too
@deprecated("Use `pygame.sprite.Group` instead")
class RenderPlain(Group[_SpriteT]): ...
# these are aliased in the code too
RenderPlain = Group
RenderClear = Group
@deprecated("Use `pygame.sprite.Group` instead")
class RenderClear(Group[_SpriteT]): ...
class RenderUpdates(Group[_TSprite]): ...
class OrderedUpdates(RenderUpdates[_TSprite]): ...
class RenderUpdates(Group[_SpriteT]): ...
@deprecated("Use `pygame.sprite.RenderUpdates` instead")
class OrderedUpdates(RenderUpdates[_SpriteT]): ...
class LayeredUpdates(AbstractGroup[_SpriteT]):
def __init__(self, *sprites: _SpriteOrSprites[_SpriteT], **kwargs: Any) -> None: ...
def add(self, *sprites: _SpriteOrSprites[_SpriteT], **kwargs: Any) -> None: ...
def get_sprites_at(self, pos: Point) -> list[_SpriteT]: ...
def get_sprite(self, idx: int) -> _SpriteT: ...
def remove_sprites_of_layer(self, layer_nr: int) -> list[_SpriteT]: ...
def layers(self) -> list[int]: ...
def change_layer(self, sprite: _SpriteT, new_layer: int) -> None: ...
def get_layer_of_sprite(self, sprite: _SpriteT) -> int: ...
class LayeredUpdates(AbstractGroup[_TSprite]):
def __init__(
self,
*sprites: Union[
_TSprite,
AbstractGroup[_TSprite],
Iterable[Union[_TSprite, AbstractGroup[_TSprite]]],
],
**kwargs: Any
) -> None: ...
def add(
self,
*sprites: Union[
_TSprite,
AbstractGroup[_TSprite],
Iterable[Union[_TSprite, AbstractGroup[_TSprite]]],
],
**kwargs: Any
) -> None: ...
def get_sprites_at(self, pos: Coordinate) -> List[_TSprite]: ...
def get_sprite(self, idx: int) -> _TSprite: ...
def remove_sprites_of_layer(self, layer_nr: int) -> List[_TSprite]: ...
def layers(self) -> List[int]: ...
def change_layer(self, sprite: _TSprite, new_layer: int) -> None: ...
def get_layer_of_sprite(self, sprite: _TSprite) -> int: ...
def get_top_layer(self) -> int: ...
def get_bottom_layer(self) -> int: ...
def move_to_front(self, sprite: _SpriteT) -> None: ...
def move_to_back(self, sprite: _SpriteT) -> None: ...
def get_top_sprite(self) -> _SpriteT: ...
def get_sprites_from_layer(self, layer: int) -> list[_SpriteT]: ...
def move_to_front(self, sprite: _TSprite) -> None: ...
def move_to_back(self, sprite: _TSprite) -> None: ...
def get_top_sprite(self) -> _TSprite: ...
def get_sprites_from_layer(self, layer: int) -> List[_TSprite]: ...
def switch_layer(self, layer1_nr: int, layer2_nr: int) -> None: ...
class LayeredDirty(LayeredUpdates[_DirtySpriteT]):
class LayeredDirty(LayeredUpdates[_TDirtySprite]):
def __init__(self, *sprites: _TDirtySprite, **kwargs: Any) -> None: ...
def draw(
self,
surface: Surface,
bgd: Surface | None = None,
special_flags: int | None = None,
) -> list[FRect | Rect]: ...
self, surface: Surface, bgsurf: Optional[Surface] = None, special_flags: Optional[int] = None
) -> List[Rect]: ...
# clear breaks Liskov substitution principle in code
def clear(self, surface: Surface, bgd: Surface) -> None: ... # type: ignore[override]
def repaint_rect(self, screen_rect: RectLike) -> None: ...
def set_clip(self, screen_rect: RectLike | None = None) -> None: ...
def get_clip(self) -> FRect | Rect: ...
def set_timing_threshold(self, time_ms: SupportsFloat) -> None: ...
@deprecated(
"since 2.1.1. Use `pygame.sprite.LayeredDirty.set_timing_threshold` instead"
)
def set_timing_treshold(self, time_ms: SupportsFloat) -> None: ...
def repaint_rect(self, screen_rect: RectValue) -> None: ...
def set_clip(self, screen_rect: Optional[RectValue] = None) -> None: ...
def get_clip(self) -> Rect: ...
def set_timing_threshold(
self, time_ms: SupportsFloat
) -> None: ... # This actually accept any value
# deprecated alias
set_timing_treshold = set_timing_threshold
class GroupSingle(AbstractGroup[_SpriteT]):
sprite: _SpriteT | None
def __init__(self, sprite: _SpriteT | None = None) -> None: ...
class GroupSingle(AbstractGroup[_TSprite]):
sprite: _TSprite
def __init__(self, sprite: Optional[_TSprite] = None) -> None: ...
# argument to collide_rect must have rect attribute
def collide_rect(left: _HasRect, right: _HasRect) -> bool: ...
class collide_rect_ratio:
@@ -167,8 +240,8 @@ class collide_rect_ratio:
def __init__(self, ratio: float) -> None: ...
def __call__(self, left: _HasRect, right: _HasRect) -> bool: ...
# Must have rect attribute, may optionally have radius attribute
_SupportsCollideCircle: TypeAlias = _HasRect
# must have rect attribute, may optionally have radius attribute
_SupportsCollideCircle = Union[_HasRect, _HasRadiusAndRect]
def collide_circle(
left: _SupportsCollideCircle, right: _SupportsCollideCircle
@@ -181,31 +254,34 @@ class collide_circle_ratio:
self, left: _SupportsCollideCircle, right: _SupportsCollideCircle
) -> bool: ...
# Arguments to collide_mask must either have mask or have image attribute, in
# argument to collide_mask must either have mask or have image attribute, in
# addition to mandatorily having a rect attribute
_SupportsCollideMask: TypeAlias = _HasImageAndRect | _HasMaskAndRect
_SupportsCollideMask = Union[_HasImageAndRect, _HasMaskAndRect]
def collide_mask(
left: _SupportsCollideMask, right: _SupportsCollideMask
) -> tuple[int, int] | None: ...
_HasRectT = TypeVar("_HasRectT", bound=_HasRect)
) -> Optional[Tuple[int, int]]: ...
def spritecollide(
sprite: _HasRectT,
group: AbstractGroup[_SpriteT],
dokill: bool,
collided: Callable[[_HasRectT, _SpriteT], bool] | None = None,
) -> list[_SpriteT]: ...
sprite: _TSprite,
group: AbstractGroup[_TSprite2],
dokill: bool | Literal[1] | Literal[0],
collided: Optional[
Callable[[_TSprite, _TSprite2], bool | Optional[Tuple[int, int]]]
] = None,
) -> List[_TSprite2]: ...
def groupcollide(
groupa: AbstractGroup[_SpriteT],
groupb: AbstractGroup[_SpriteT2],
dokilla: bool,
dokillb: bool,
collided: Callable[[_SpriteT, _SpriteT2], bool] | None = None,
) -> dict[_SpriteT, list[_SpriteT2]]: ...
groupa: AbstractGroup[_TSprite],
groupb: AbstractGroup[_TSprite2],
dokilla: bool | Literal[1] | Literal[0],
dokillb: bool | Literal[1] | Literal[0],
collided: Optional[
Callable[[_TSprite, _TSprite2], bool | Optional[Tuple[int, int]]]
] = None,
) -> Dict[_TSprite, List[_TSprite2]]: ...
def spritecollideany(
sprite: _HasRectT,
group: AbstractGroup[_SpriteT],
collided: Callable[[_HasRectT, _SpriteT], bool] | None = None,
) -> _SpriteT | None: ...
sprite: _TSprite,
group: AbstractGroup[_TSprite2],
collided: Optional[
Callable[[_TSprite, _TSprite2], bool | Optional[Tuple[int, int]]]
] = None,
) -> Optional[_TSprite2]: ...