pyglet 3.0.dev10__py3-none-any.whl → 3.0.dev11__py3-none-any.whl

pyglet/__init__.py

@@ -8,6 +8,8 @@ import os
 import sys
 import warnings
 
+IS_DOC_BUILD = os.environ.get("PYGLET_DOC_BUILD") == "1"
+
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Literal, Sequence
 
@@ -18,7 +20,7 @@ if TYPE_CHECKING:
     from typing import Any, Callable, ItemsView, Sized
 
 #: The release version
-version = '3.0.dev10'
+version = '3.0.dev11'
 __version__ = version
 
 MIN_PYTHON_VERSION = 3, 10

pyglet/__init__.pyi

@@ -24,6 +24,8 @@ from . import sprite as sprite
 from . import text as text
 from . import window as window
 
+IS_DOC_BUILD: bool
+
 version: str
 MIN_PYTHON_VERSION: tuple[int, int]
 MIN_PYTHON_VERSION_STR: str

pyglet/app/__init__.py

@@ -31,17 +31,17 @@ default policy is to wait until all windows are closed)::
 
 from __future__ import annotations
 
-import platform
 import sys
+import signal
+import platform
 import weakref
 
 import pyglet
 from pyglet import compat_platform
 from pyglet.app.base import EventLoop
 
-_is_pyglet_doc_run = hasattr(sys, "is_pyglet_doc_run") and sys.is_pyglet_doc_run
 
-if _is_pyglet_doc_run:
+if pyglet.IS_DOC_BUILD:
     from pyglet.app.base import PlatformEventLoop
 else:
     if compat_platform == 'darwin':
@@ -82,7 +82,11 @@ def run(interval: float | None = 1 / 60) -> None:
 
         pyglet.app.event_loop.run(interval)
 
+    ..note: This convenience function also adds a SIGINT signal handler
+            to automatically call ``pyglet.app.exit`` when this signal
+            is detected.
     """
+    signal.signal(signal.SIGINT, lambda _s, _f: event_loop.exit())
     event_loop.run(interval)
 
 

pyglet/app/base.py

@@ -7,13 +7,12 @@ from abc import ABC, abstractmethod
 from queue import Queue
 from typing import TYPE_CHECKING, Any, Callable
 
-from pyglet import app, clock, event
+from pyglet import app, clock, event, IS_DOC_BUILD
 
 if TYPE_CHECKING:
     from pyglet.event import EventDispatcher
     from pyglet.window import BaseWindow
 
-_is_pyglet_doc_run = hasattr(sys, "is_pyglet_doc_run") and sys.is_pyglet_doc_run
 
 
 class WindowDrawSource(ABC):
@@ -406,7 +405,7 @@ class EventLoop(event.EventDispatcher):
         if len(app.windows) == 0:
             self.exit()
 
-    if _is_pyglet_doc_run:
+    if IS_DOC_BUILD:
         # Events
 
         def on_window_close(self, window: BaseWindow) -> None:

pyglet/config/__init__.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, NamedTuple
 
+import pyglet
+
 from pyglet.enums import GraphicsAPI
 
 from .base import SurfaceConfig, UserConfig  # noqa: TC001
@@ -23,7 +25,7 @@ class Config:
 
     __slots__ = 'gl2', 'gles2', 'gles3', 'opengl', 'vulkan', 'webgl'
 
-    def __init__(self):
+    def __init__(self) -> None:  # noqa: D107
         self.opengl: OpenGLUserConfig = OpenGLUserConfig(major_version=3, minor_version=3, api=GraphicsAPI.OPENGL)
         self.gl2: OpenGLUserConfig = OpenGLUserConfig(major_version=2, minor_version=0, api=GraphicsAPI.OPENGL_2)
         self.gles2: OpenGLUserConfig = OpenGLUserConfig(major_version=2, minor_version=0, api=GraphicsAPI.OPENGL_ES_2)
@@ -33,9 +35,15 @@ class Config:
 
 
 def match_surface_config(config: UserConfig, surface: Window) -> SurfaceConfig | None:
-    if isinstance(config, (OpenGLUserConfig, WebGLUserConfig)):
+    if isinstance(config, OpenGLUserConfig):
         from pyglet.config.gl import get_surface_config  # noqa: PLC0415
         return get_surface_config(config, surface)
 
+    if isinstance(config, WebGLUserConfig):
+        if pyglet.compat_platform == 'emscripten':
+            from pyglet.config.gl.webgl import match  # noqa: PLC0415
+            return match(config, surface)
+        return None
+
     msg = f"Matching for '{config.__class__}' is not yet implemented."
     raise NotImplementedError(msg)

pyglet/config/gl/__init__.py

@@ -1,12 +1,21 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from typing import TYPE_CHECKING, cast
 
 import pyglet
 
 from pyglet.enums import GraphicsAPI
 from pyglet.config.base import UserConfig, SurfaceConfig
 
+if TYPE_CHECKING:
+    from pyglet.window.apple.cocoa import CocoaWindow
+    from pyglet.window.apple.ios import IOSWindow
+    from pyglet.window.headless import HeadlessWindow
+    from pyglet.window.wayland import WaylandWindow
+    from pyglet.window.win32 import Win32Window
+    from pyglet.window.xlib import XlibWindow
+
 
 class GLSurfaceConfig(SurfaceConfig):
     config: OpenGLUserConfig
@@ -98,36 +107,31 @@ class WebGLUserConfig(UserConfig):
         return False
 
 
-def get_surface_config(user_config: UserConfig, surface: pyglet.window.Window) -> SurfaceConfig | None:
+def get_surface_config(user_config: OpenGLUserConfig, surface: pyglet.window.Window) -> SurfaceConfig | None:
 
     if pyglet.options.headless or pyglet.options.wayland:
-        from pyglet.config.gl.egl import match
+        from pyglet.config.gl.egl import match as match_egl  # noqa: PLC0415
 
-        return match(user_config, surface)
+        return match_egl(user_config, cast("HeadlessWindow | WaylandWindow", surface))
 
     if pyglet.compat_platform == "win32":
-        from pyglet.config.gl.windows import match  # noqa: PLC0415
+        from pyglet.config.gl.windows import match as match_windows  # noqa: PLC0415
 
-        return match(user_config, surface)
+        return match_windows(user_config, cast("Win32Window", surface))
 
     if pyglet.compat_platform.startswith("linux"):
-        from pyglet.config.gl.x11 import match  # noqa: PLC0415
+        from pyglet.config.gl.x11 import match as match_x11  # noqa: PLC0415
 
-        return match(user_config, surface)
+        return match_x11(user_config, cast("XlibWindow", surface))
 
     if pyglet.compat_platform == "darwin":
-        from pyglet.config.gl.macos import match  # noqa: PLC0415
+        from pyglet.config.gl.macos import match as match_macos  # noqa: PLC0415
 
-        return match(user_config, surface)
+        return match_macos(user_config, cast("CocoaWindow", surface))
 
     if pyglet.compat_platform == "ios":
-        from pyglet.config.gl.ios import match  # noqa: PLC0415
-
-        return match(user_config, surface)
-
-    if pyglet.compat_platform == "emscripten":
-        from pyglet.config.gl.webgl import match  # noqa: PLC0415
+        from pyglet.config.gl.ios import match as match_ios  # noqa: PLC0415
 
-        return match(user_config, surface)
+        return match_ios(user_config, cast("IOSWindow", surface))
 
     return None

pyglet/display/__init__.py

@@ -22,13 +22,12 @@ by the application; see the documentation for :class:`Screen`.
 .. versionadded:: 1.2
 """  # noqa: I002
 
-import sys
 import weakref
 
-_is_pyglet_doc_run = hasattr(sys, "is_pyglet_doc_run") and sys.is_pyglet_doc_run
+from pyglet import IS_DOC_BUILD
 
 
-if _is_pyglet_doc_run:
+if IS_DOC_BUILD:
     from pyglet.display.base import Display, Screen, ScreenMode
 else:
     from pyglet import compat_platform, options

pyglet/display/base.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import abc
-from typing import TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING, Literal, Sequence
 
 from pyglet import app, display
 
@@ -12,10 +12,10 @@ if TYPE_CHECKING:
 class Display:
     """A display device supporting one or more screens."""
 
-    name: str = None
+    name: str | None = None
     """Name of this display, if applicable."""
 
-    x_screen: int = None
+    x_screen: int | None = None
     """The X11 screen number of this display, if applicable."""
 
     def __init__(self, name: str | None = None, x_screen: int | None = None) -> None:
@@ -35,7 +35,7 @@ class Display:
         On platforms other than X11, :attr:`name` and :attr:`x_screen` are 
         ignored; there is only a single display device on these systems.
         """
-        display._displays.add(self)
+        display._displays.add(self)  # type: ignore[attr-defined]  # noqa: SLF001
 
     def get_screens(self) -> list[Screen]:
         """Get the available screens.
@@ -55,7 +55,7 @@ class Display:
         """Get the default (primary) screen as specified by the user's operating system preferences."""
         screens = self.get_screens()
         for screen in screens:
-            if screen.x == 0 and screen.y == 0:
+            if screen.is_primary:
                 return screen
 
         # No Primary screen found?
@@ -96,24 +96,31 @@ class Screen(abc.ABC):
         self.height = height
         """Height of the screen, in pixels."""
 
+    @property
+    @abc.abstractmethod
+    def is_primary(self) -> bool:
+        """Whether this is the operating system's primary screen."""
+
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}(x={self.x}, y={self.y}, width={self.width}, height={self.height})"
 
-    def get_modes(self) -> list[ScreenMode]:
+    @abc.abstractmethod
+    def get_modes(self) -> Sequence[ScreenMode]:
         """Get a list of screen modes supported by this screen.
 
         .. versionadded:: 1.2
         """
         raise NotImplementedError('abstract')
 
-    def get_mode(self) -> ScreenMode:
+    @abc.abstractmethod
+    def get_mode(self) -> ScreenMode | None:
         """Get the current display mode for this screen.
 
         .. versionadded:: 1.2
         """
         raise NotImplementedError('abstract')
 
-    def get_closest_mode(self, width: int, height: int) -> ScreenMode:
+    def get_closest_mode(self, width: int, height: int) -> ScreenMode | None:
         """Get the screen mode that best matches a given size.
 
         If no supported mode exactly equals the requested size, a larger one
@@ -154,6 +161,7 @@ class Screen(abc.ABC):
                     best = mode
         return best
 
+    @abc.abstractmethod
     def set_mode(self, mode: ScreenMode) -> None:
         """Set the display mode for this screen.
 
@@ -162,14 +170,17 @@ class Screen(abc.ABC):
         """
         raise NotImplementedError('abstract')
 
+    @abc.abstractmethod
     def restore_mode(self) -> None:
         """Restore the screen mode to the user's default."""
         raise NotImplementedError('abstract')
 
+    @abc.abstractmethod
     def get_dpi(self) -> int:
         """Get the DPI of the screen."""
         raise NotImplementedError('abstract')
 
+    @abc.abstractmethod
     def get_scale(self) -> float:
         """Get the pixel scale ratio of the screen."""
         raise NotImplementedError('abstract')
@@ -208,16 +219,16 @@ class ScreenMode:
     .. versionadded:: 1.2
     """
 
-    width: int = None
+    width: int
     """Width of screen, in pixels."""
 
-    height: int = None
+    height: int
     """Height of screen, in pixels."""
 
-    depth: int = None
+    depth: int | None
     """Pixel color depth, in bits per pixel."""
 
-    rate: int = None
+    rate: int | None
     """Screen refresh rate in Hz."""
 
     def __init__(self, screen: Screen) -> None:

pyglet/display/cocoa.py

@@ -54,6 +54,10 @@ class CocoaScreen(Screen):
             if screen_name:
                 self._friendly_name = cfstring_to_string(screen_name)
 
+    @property
+    def is_primary(self) -> bool:
+        return self._cg_display_id == quartz.CGMainDisplayID()
+
     def get_nsscreen(self):
         """Return the current NSScreen associated with this display framebuffer."""
         # Get a list of all currently active NSScreens and then search through

pyglet/display/emscripten.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from typing import Literal
 
 from pyglet.display.base import Display, Screen
-import js  # noqa: F821
+import js  # type: ignore[import-not-found]  # noqa: F821
 
 class EmscriptenDisplay(Display):
 
@@ -20,6 +20,10 @@ class EmscriptenScreen(Screen):
         height = js.window.screen.height
         super().__init__(display, 0, 0, width, height)
 
+    @property
+    def is_primary(self) -> bool:
+        return True
+
     def get_display_id(self) -> int:
         return 0
 
@@ -37,3 +41,9 @@ class EmscriptenScreen(Screen):
 
     def restore_mode(self):
         pass
+
+    def get_dpi(self) -> int:
+        return round(96 * self.get_scale())
+
+    def get_scale(self) -> float:
+        return js.window.devicePixelRatio

pyglet/display/headless.py

@@ -72,6 +72,10 @@ class HeadlessScreen(Screen):
     def __init__(self, display, x, y, width, height):
         super().__init__(display, x, y, width, height)
 
+    @property
+    def is_primary(self) -> bool:
+        return True
+
     def get_modes(self):
         pass
 

pyglet/display/ios.py

@@ -22,6 +22,10 @@ class IOSScreen(Screen):
         scale = ui_screen.nativeScale()
         super().__init__(display, 0, 0, round(bounds.size.width * scale), round(bounds.size.height * scale))
 
+    @property
+    def is_primary(self) -> bool:
+        return True
+
     def get_modes(self) -> list[ScreenMode]:
         return [self.get_mode()]
 

pyglet/display/wayland.py

@@ -69,7 +69,9 @@ class WaylandDisplay(Display):
             self.client.sync()
             self._query_done.wait()
             # Make Screen instance with the now-filled-in values:
-            self._screens.append(WaylandScreen(self, self._geo, self._modes, self._scale, self._name, self._descript))
+            self._screens.append(
+                WaylandScreen(self, self._geo, self._modes, self._scale, self._name, self._descript, i == 0),
+            )
             wl_output.release()
 
     # Start Wayland Event handlers
@@ -106,13 +108,8 @@ class WaylandDisplay(Display):
 
 class WaylandScreen(Screen):
 
-    def get_display_id(self) -> str | int:
-        return self.name
-
-    def get_monitor_name(self) -> str | Literal["Unknown"]:
-        return self.description
-
-    def __init__(self, display, geometry, modes, scale, name, description):
+    def __init__(self, display, geometry, modes, scale, name, description, is_primary):
+        self._is_primary = is_primary
         self.name = name
         self.description = description
         self._scale = scale
@@ -132,6 +129,16 @@ class WaylandScreen(Screen):
 
         super().__init__(display, self._geo.x, self._geo.y, _width_pixels, _height_pixels)
 
+    @property
+    def is_primary(self) -> bool:
+        return self._is_primary
+
+    def get_display_id(self) -> str | int:
+        return self.name
+
+    def get_monitor_name(self) -> str | Literal["Unknown"]:
+        return self.description
+
     def get_modes(self):
         return self._modes
 

pyglet/display/win32.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import ctypes
 from ctypes import byref, sizeof
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Sequence
 
 from pyglet.libs.win32 import _gdi32, _user32
 from pyglet.libs.win32.constants import (
@@ -42,9 +42,6 @@ if TYPE_CHECKING:
 if WINDOWS_8_1_OR_GREATER:
     from pyglet.libs.win32 import _shcore
 
-if TYPE_CHECKING:
-    from ctypes.wintypes import HDC, HMONITOR, LPARAM, LPRECT
-
 
 def set_dpi_awareness() -> None:
     """Setting DPI varies per Windows version.
@@ -66,13 +63,13 @@ class Win32Display(Display):  # noqa: D101
     def get_default_screen(self) -> Screen:
         screens = self.get_screens()
         for screen in screens:
-            if screen.is_primary:
+            if isinstance(screen, Win32Screen) and screen.is_primary:
                 return screen
 
         return screens[0]
 
-    def get_screens(self) -> list[Win32Screen]:
-        screens = []
+    def get_screens(self) -> list[Screen]:
+        screens: list[Screen] = []
 
         def enum_proc(hMonitor: HMONITOR, hdcMonitor: HDC, lprcMonitor: LPRECT, dwData: LPARAM) -> bool:  # noqa: N803, ARG001
             r = lprcMonitor.contents
@@ -89,7 +86,7 @@ class Win32Display(Display):  # noqa: D101
 
 class Win32Screen(Screen):  # noqa: D101
     _handle: HMONITOR
-    _initial_mode = None
+    _initial_mode: Win32ScreenMode | None = None
 
     def __init__(self, display: Win32Display, handle: HMONITOR, x: int, y: int, width: int, height: int) -> None:  # noqa: D107
         super().__init__(display, x, y, width, height)
@@ -101,7 +98,7 @@ class Win32Screen(Screen):  # noqa: D101
     def is_primary(self) -> bool:
         """If the screen is considered the primary according to the operating system."""
         info = self._get_monitor_info()
-        return info.dwFlags & MONITORINFOF_PRIMARY
+        return bool(info.dwFlags & MONITORINFOF_PRIMARY)
 
     def _get_friendly_name_display_config_api(self) -> str:
         """Get the friendly name of a monitor using the newer Display Configuration API.
@@ -188,23 +185,23 @@ class Win32Screen(Screen):  # noqa: D101
 
     def get_dpi(self) -> int:
         if WINDOWS_8_1_OR_GREATER:
-            xdpi = UINT()
+            xdpi_value = UINT()
             ydpi = UINT()
-            _shcore.GetDpiForMonitor(self._handle, 0, byref(xdpi), byref(ydpi))
-            xdpi, ydpi = xdpi.value, ydpi.value
+            _shcore.GetDpiForMonitor(self._handle, 0, byref(xdpi_value), byref(ydpi))
+            xdpi = xdpi_value.value
         else:
             dc = _user32.GetDC(None)
             xdpi = _gdi32.GetDeviceCaps(dc, LOGPIXELSX)
             ydpi = _gdi32.GetDeviceCaps(dc, LOGPIXELSY)
             _user32.ReleaseDC(0, dc)
 
-        return xdpi
+        return int(xdpi)
 
     def get_scale(self) -> float:
         xdpi = self.get_dpi()
         return xdpi / USER_DEFAULT_SCREEN_DPI
 
-    def get_modes(self) -> list[Win32ScreenMode]:
+    def get_modes(self) -> Sequence[Win32ScreenMode]:
         device_name = self.get_device_name()
         i = 0
         modes = []
@@ -228,7 +225,8 @@ class Win32Screen(Screen):  # noqa: D101
                                      byref(mode))
         return Win32ScreenMode(self, mode)
 
-    def set_mode(self, mode: Win32ScreenMode) -> None:
+    def set_mode(self, mode: ScreenMode) -> None:
+        assert isinstance(mode, Win32ScreenMode)
         assert mode.screen is self
 
         if not self._initial_mode:

pyglet/display/xlib.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import ctypes
 import warnings
-from typing import TYPE_CHECKING
 from ctypes import POINTER, byref, c_buffer, c_char_p, c_int, cast
 
 import pyglet
@@ -22,8 +21,6 @@ class NoSuchDisplayException(Exception):
 
 
 from pyglet.libs.linux.x11 import xlib
-if TYPE_CHECKING:
-    from pyglet.gl import Config
 
 try:
     from pyglet.libs.linux.x11 import xinerama
@@ -47,17 +44,13 @@ except:
     _have_xf86vmode = False
 
 try:
-    from pyglet.libs.x11 import xrandr
+    from pyglet.libs.x11 import xrandr  # type: ignore[import-not-found]
 
     _have_xrandr = True
 except ImportError:
     _have_xrandr = False
 
 
-class NoSuchDisplayException(Exception):
-    pass
-
-
 # Set up error handler
 def _error_handler(display, event):
     # By default, all errors are silently ignored: this has a better chance
@@ -94,7 +87,7 @@ class XlibDisplay(LinuxSelectDevice, Display):
     _x_im = None  # X input method
     # TODO close _x_im when display connection closed.
     _enable_xsync = False
-    _screens: list[XlibScreen | XlibScreenXrandr | XlibScreenXinerama]
+    _screens: list[Screen]
 
     def __init__(self, name=None, x_screen=None):
         self._screens = []
@@ -143,7 +136,7 @@ class XlibDisplay(LinuxSelectDevice, Display):
         # Couldn't find a default screen, use the first in the list.
         return self._screens[0]
 
-    def get_screens(self) -> list[XlibScreen]:
+    def get_screens(self) -> list[Screen]:
         self._screens = []
 
         # Use XRandr if available, as it appears more maintained and widely supported.
@@ -240,6 +233,10 @@ class XlibScreen(Screen):
     def __init__(self, display: XlibDisplay, x: int, y: int, width: int, height: int):
         super().__init__(display, x, y, width, height)
 
+    @property
+    def is_primary(self) -> bool:
+        return True
+
     def get_dpi(self) -> int:
         resource = xlib.XResourceManagerString(self.display._display)
         dpi = 96
@@ -288,13 +285,14 @@ class XlibScreen(Screen):
 
         return modes
 
-    def get_mode(self) -> XlibScreenMode:
+    def get_mode(self) -> XlibScreenMode | None:
         modes = self.get_modes()
         if modes:
             return modes[0]
         return None
 
-    def set_mode(self, mode: XlibScreenModeXF86):
+    def set_mode(self, mode: ScreenMode) -> None:
+        assert isinstance(mode, XlibScreenModeXF86)
         assert mode.screen is self
 
         if not self._initial_mode:
@@ -334,6 +332,10 @@ class XlibScreenXinerama(XlibScreen):
         self._xinerama = using_xinerama
         self.idx = idx
 
+    @property
+    def is_primary(self) -> bool:
+        return self.idx == 0
+
     def get_display_id(self) -> int:
         # No real unique ID is available, just hash together the properties.
         return hash((self.idx, self.x, self.y, self.width, self.height))
@@ -369,7 +371,7 @@ class XlibScreenXrandr(XlibScreen):
         self._is_primary = is_primary
 
     @property
-    def is_primary(self):
+    def is_primary(self) -> bool:
         return self._is_primary
 
     @staticmethod
@@ -380,7 +382,8 @@ class XlibScreenXrandr(XlibScreen):
 
         return None
 
-    def set_mode(self, mode: XlibScreenModeXrandr) -> None:
+    def set_mode(self, mode: ScreenMode) -> None:
+        assert isinstance(mode, XlibScreenModeXrandr)
         assert mode.screen is self
 
         if not self._initial_mode:

pyglet/event.py

@@ -159,8 +159,8 @@ class EventDispatcher:
         for suitable handlers.
         """
         if not hasattr(cls, 'event_types'):
-            cls.event_types = []  # type: ignore reportAttributeAccessIssue
-        cls.event_types.append(name)  # type: ignore reportAttributeAccessIssue
+            cls.event_types = []  # type: ignore[attr-defined]
+        cls.event_types.append(name)  # type: ignore[attr-defined]
         return name
 
     def push_handlers(self, *args: Any, **kwargs: Any) -> None:
@@ -179,10 +179,10 @@ class EventDispatcher:
             self._event_stack = []
 
         # Place dict full of new handlers at beginning of stack
-        self._event_stack.insert(0, {})  # type: ignore reportAttributeAccessIssue
+        self._event_stack.insert(0, {})  # type: ignore[attr-defined]
         self.set_handlers(*args, **kwargs)
 
-    def _get_handlers(self, args: list, kwargs: dict) -> Generator[tuple[str, Callable], None, None]:
+    def _get_handlers(self, args: tuple[Any, ...] | list[Any], kwargs: dict) -> Generator[tuple[str, Callable], None, None]:
         """Implement handler matching on arguments for set_handlers and remove_handlers."""
         for obj in args:
             if inspect.isroutine(obj):
@@ -371,7 +371,7 @@ class EventDispatcher:
 
         return False
 
-    def post_event(self, event_type: str, *args: Any) -> bool | None:
+    def post_event(self, event_type: str, *args: Any) -> None:
         """Post an event to the main application thread.
 
         Unlike the :py:meth:`~pyglet.event.EventDispatcher.dispatch_event`