pyglet 2.1.5__py3-none-any.whl → 2.1.8__py3-none-any.whl

pyglet/__init__.py

@@ -6,16 +6,16 @@ from __future__ import annotations
 
 import os
 import sys
-from collections.abc import ItemsView, Sequence
+import warnings
+from collections.abc import Sequence
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Literal
-
 if TYPE_CHECKING:
     from types import FrameType
     from typing import Any, Callable, ItemsView, Sized
 
 #: The release version
-version = '2.1.5'
+version = '2.1.8'
 __version__ = version
 
 MIN_PYTHON_VERSION = 3, 8
@@ -30,20 +30,16 @@ compat_platform = sys.platform
 if "bsd" in compat_platform:
     compat_platform = "linux-compat"
 
-_enable_optimisations = not __debug__
-if getattr(sys, "frozen", None):
-    _enable_optimisations = True
-
-
-_SPECIAL_OPTION_VALIDATORS = {
-    "audio": lambda x: isinstance(x, Sequence),
-    "vsync": lambda x: x is None or isinstance(x, bool),
-}
+if compat_platform == "cygwin":
+    # This hack pretends that the posix-like ctypes provides windows
+    # functionality.  COM does not work with this hack, so there is no
+    # DirectSound support.
+    import ctypes
 
-_OPTION_TYPE_VALIDATORS = {
-    "bool": lambda x: isinstance(x, bool),
-    "int": lambda x: isinstance(x, int),
-}
+    ctypes.windll = ctypes.cdll
+    ctypes.oledll = ctypes.cdll
+    ctypes.WINFUNCTYPE = ctypes.CFUNCTYPE
+    ctypes.HRESULT = ctypes.c_long
 
 
 @dataclass
@@ -115,7 +111,7 @@ class Options:
     that utilize COM calls. Only applies to the Windows platform."""
 
     debug_win32: bool = False
-    """If ``True``, prints error messages related to Windows library calls. Usually get's information from
+    """If ``True``, prints error messages related to Windows library calls. Usually gets information from
     ``Kernel32.GetLastError``. This information is output to a file called ``debug_win32.log``."""
 
     debug_input: bool = False
@@ -311,42 +307,31 @@ class Options:
         return self.__dict__[item]
 
     def __setitem__(self, key: str, value: Any) -> None:
-        assert key in self.__annotations__, f"Invalid option name: '{key}'"
-        assert (_SPECIAL_OPTION_VALIDATORS.get(key) or _OPTION_TYPE_VALIDATORS[self.__annotations__[key]])(value), \
-            f"Invalid type: '{type(value)}' for '{key}'"
         self.__dict__[key] = value
 
 
 #: Instance of :py:class:`~pyglet.Options` used to set runtime options.
 options: Options = Options()
 
-_OPTION_TYPE_REMAPS = {
-    "audio": "sequence",
-    "vsync": "bool",
-}
 
-for _key, _type in options.__annotations__.items():
+for _option_name, _type_str in options.__annotations__.items():
     """Check Environment Variables for pyglet options"""
-    if _value := os.environ.get(f"PYGLET_{_key.upper()}"):
-        _type = _OPTION_TYPE_REMAPS.get(_key, _type)
-        if _type == 'sequence':
-            options[_key] = _value.split(",")
-        elif _type == 'bool':
-            options[_key] = _value in ("true", "TRUE", "True", "1")
-        elif _type == 'int':
-            options[_key] = int(_value)
+    if _value := os.environ.get(f"PYGLET_{_option_name.upper()}"):
+        if 'Sequence' in _type_str:
+            setattr(options, _option_name, _value.split(","))
+        elif 'bool' in _type_str:
+            setattr(options, _option_name, _value in ("true", "TRUE", "True", "1"))
+        elif 'int' in _type_str:
+            setattr(options, _option_name, int(_value))
+        elif 'Literal' in _type_str and _value in _type_str:
+            setattr(options, _option_name, _value)
+        else:
+            warnings.warn(f"Invalid value '{_value}' for {_option_name}. Expecting {_type_str}")
 
 
-if compat_platform == "cygwin":
-    # This hack pretends that the posix-like ctypes provides windows
-    # functionality.  COM does not work with this hack, so there is no
-    # DirectSound support.
-    import ctypes
+if (__debug__ is False) or getattr(sys, "frozen", False):
+    options.debug_gl = False
 
-    ctypes.windll = ctypes.cdll
-    ctypes.oledll = ctypes.cdll
-    ctypes.WINFUNCTYPE = ctypes.CFUNCTYPE
-    ctypes.HRESULT = ctypes.c_long
 
 # Call tracing
 # ------------

pyglet/app/base.py

@@ -199,7 +199,7 @@ class EventLoop(event.EventDispatcher):
         if self._interval is None:
             self._redraw_windows(dt)
 
-        # Update timout
+        # Update timeout
         timeout = self.clock.get_sleep_time(True)
         app.platform_event_loop.set_timer(self._blocking_timer, timeout)
 
@@ -231,7 +231,7 @@ class EventLoop(event.EventDispatcher):
         dt = self.clock.update_time()
         self.clock.call_scheduled_functions(dt)
 
-        # Update timout
+        # Update timeout
         return self.clock.get_sleep_time(True)
 
     @property

pyglet/clock.py

@@ -303,7 +303,7 @@ class Clock:
 
         The result is the average of a sliding window of the last "n" updates,
         where "n" is some number designed to cover approximately 1 second.
-        This is the clock frequence, **not** the Window redraw rate (fps).
+        This is the clock frequency, **not** the Window redraw rate (fps).
         """
         if not self.cumulative_time:
             return 0

pyglet/display/base.py

@@ -1,11 +1,9 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+import abc
+from typing import TYPE_CHECKING, Literal
 
-from pyglet import gl
-from pyglet import app
-from pyglet import window
-from pyglet import display
+from pyglet import app, display, gl, window
 
 if TYPE_CHECKING:
     from pyglet.gl import Config
@@ -55,9 +53,7 @@ class Display:
         raise NotImplementedError('abstract')
 
     def get_default_screen(self) -> Screen:
-        """Get the default (primary) screen as specified by the user's operating system
-        preferences.
-        """
+        """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:
@@ -71,7 +67,7 @@ class Display:
         return [win for win in app.windows if win.display is self]
 
 
-class Screen:
+class Screen(abc.ABC):
     """A virtual monitor that supports fullscreen windows.
 
     Screens typically map onto a physical display such as a
@@ -84,12 +80,12 @@ class Screen:
     give the global location of the top-left corner of the screen.  This is 
     useful for determining if screens are arranged above or next to one 
     another.
-    
+
     Use :func:`~Display.get_screens` or :func:`~Display.get_default_screen`
     to obtain an instance of this class.
     """
 
-    def __init__(self, display: Display, x: int, y: int, width: int, height: int):
+    def __init__(self, display: Display, x: int, y: int, width: int, height: int) -> None:
         self.display = display
         """Display this screen belongs to."""
         self.x = x
@@ -208,29 +204,43 @@ class Screen:
     def set_mode(self, mode: ScreenMode) -> None:
         """Set the display mode for this screen.
 
-        The mode must be one previously returned by :meth:`get_mode` or 
+        The mode must be one previously returned by :meth:`get_mode` or
         :meth:`get_modes`.
         """
         raise NotImplementedError('abstract')
 
     def restore_mode(self) -> None:
-        """Restore the screen mode to the user's default.
-        """
+        """Restore the screen mode to the user's default."""
         raise NotImplementedError('abstract')
 
     def get_dpi(self):
-        """Get the DPI of the screen.
+        """Get the DPI of the screen."""
+        raise NotImplementedError('abstract')
 
-        :rtype: int
-        """
+    def get_scale(self) -> float:
+        """Get the pixel scale ratio of the screen."""
         raise NotImplementedError('abstract')
 
-    def get_scale(self):
-        """Get the pixel scale ratio of the screen.
+    @abc.abstractmethod
+    def get_display_id(self) -> str | int:
+        """Get a unique identifier for the screen.
 
-        :rtype: float
+        .. versionadded: 2.1.8
+        """
+
+    @abc.abstractmethod
+    def get_monitor_name(self) -> str | Literal["Unknown"]:
+        """Get a friendly name for the screen if available.
+
+        Windows and Mac OSX report what the system will see the screen as.
+
+        On Linux, there is no API for retrieving the monitor name, other than manually decoding the EDID information.
+        Instead, it will return the connection name.
+
+        If no name can be queried, a default name of Unknown will be returned.
+
+        .. versionadded: 2.1.8
         """
-        raise NotImplementedError('abstract')
 
 
 class ScreenMode:

pyglet/display/cocoa.py

@@ -19,8 +19,17 @@ class CocoaDisplay(Display):
         activeDisplays = (CGDirectDisplayID * maxDisplays)()
         count = c_uint32()
         quartz.CGGetActiveDisplayList(maxDisplays, activeDisplays, byref(count))
-        return [CocoaScreen(self, displayID) for displayID in list(activeDisplays)[:count.value]]
+        return [CocoaScreen(self, displayID) for displayID in list(activeDisplays)[: count.value]]
 
+    def get_default_screen(self) -> Screen:
+        main_id = quartz.CGMainDisplayID()
+
+        screens = self.get_screens()
+        for screen in screens:
+            if screen.get_display_id() == main_id:
+                return screen
+
+        return screens[0]
 
 class CocoaScreen(Screen):
 
@@ -36,6 +45,11 @@ class CocoaScreen(Screen):
         # Save the default mode so we can restore to it.
         self._default_mode = self.get_mode()
         self._ns_screen = self.get_nsscreen()
+        self._friendly_name = "Unknown"
+        if self._ns_screen is not None:
+            screen_name = self._ns_screen.localizedName()
+            if screen_name:
+                self._friendly_name = cfstring_to_string(screen_name)
 
     def get_nsscreen(self):
         """Returns the NSScreen instance that matches our CGDirectDisplayID."""
@@ -107,6 +121,16 @@ class CocoaScreen(Screen):
     def release_display(self):
         quartz.CGDisplayRelease(self._cg_display_id)
 
+    def get_display_id(self) -> str:
+        """Get a unique identifier for the screen."""
+        return self._cg_display_id
+
+    def get_monitor_name(self) -> str:
+        """Get a friendly name, if available.
+
+        For example, the make and model of the screen: Dell S2716DG
+        """
+        return self._friendly_name
 
 class CocoaScreenMode(ScreenMode):
 

pyglet/display/headless.py

@@ -21,7 +21,7 @@ class HeadlessDisplay(Display):
         if num_devices.value > 0:
             headless_device = pyglet.options['headless_device']
             if headless_device < 0 or headless_device >= num_devices.value:
-                raise ValueError(f'Invalid EGL devide id: {headless_device}')
+                raise ValueError(f'Invalid EGL device id: {headless_device}')
             devices = (eglext.EGLDeviceEXT * num_devices.value)()
             eglext.eglQueryDevicesEXT(num_devices.value, devices, byref(num_devices))
             self._display_connection = eglext.eglGetPlatformDisplayEXT(

pyglet/display/win32.py

@@ -1,12 +1,20 @@
+from __future__ import annotations
+
+import ctypes
 from ctypes import byref, sizeof
+from typing import TYPE_CHECKING
 
 from pyglet.libs.win32 import _gdi32, _shcore, _user32
 from pyglet.libs.win32.constants import (
     CDS_FULLSCREEN,
     DISP_CHANGE_SUCCESSFUL,
+    DISPLAYCONFIG_DEVICE_INFO_GET_SOURCE_NAME,
+    DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_NAME,
     ENUM_CURRENT_SETTINGS,
     LOGPIXELSX,
     LOGPIXELSY,
+    MONITORINFOF_PRIMARY,
+    QDC_ONLY_ACTIVE_PATHS,
     USER_DEFAULT_SCREEN_DPI,
     WINDOWS_8_1_OR_GREATER,
     WINDOWS_10_CREATORS_UPDATE_OR_GREATER,
@@ -15,15 +23,23 @@ from pyglet.libs.win32.constants import (
 from pyglet.libs.win32.context_managers import device_context
 from pyglet.libs.win32.types import (
     DEVMODE,
+    DISPLAY_DEVICEW,
+    DISPLAYCONFIG_PATH_INFO,
+    DISPLAYCONFIG_SOURCE_DEVICE_NAME,
+    DISPLAYCONFIG_TARGET_DEVICE_NAME,
     DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2,
     MONITORENUMPROC,
     MONITORINFOEX,
     PROCESS_PER_MONITOR_DPI_AWARE,
     UINT,
+    UINT32,
 )
 
 from .base import Canvas, Display, Screen, ScreenMode
 
+if TYPE_CHECKING:
+    from ctypes.wintypes import HDC, HMONITOR, LPARAM, LPRECT
+
 
 def set_dpi_awareness() -> None:
     """Setting DPI varies per Windows version.
@@ -41,11 +57,19 @@ def set_dpi_awareness() -> None:
 set_dpi_awareness()
 
 
-class Win32Display(Display):
-    def get_screens(self):
+class Win32Display(Display):  # noqa: D101
+    def get_default_screen(self) -> Screen:
+        screens = self.get_screens()
+        for screen in screens:
+            if screen.is_primary:
+                return screen
+
+        return screens[0]
+
+    def get_screens(self) -> list[Win32Screen]:
         screens = []
 
-        def enum_proc(hMonitor, hdcMonitor, lprcMonitor, dwData):
+        def enum_proc(hMonitor: HMONITOR, hdcMonitor: HDC, lprcMonitor: LPRECT, dwData: LPARAM) -> bool:  # noqa: N803, ARG001
             r = lprcMonitor.contents
             width = r.right - r.left
             height = r.bottom - r.top
@@ -58,12 +82,88 @@ class Win32Display(Display):
         return screens
 
 
-class Win32Screen(Screen):
+class Win32Screen(Screen):  # noqa: D101
+    _handle: HMONITOR
     _initial_mode = None
 
-    def __init__(self, display, handle, x, y, width, height):
+    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)
         self._handle = handle
+        self._device_name = self.get_device_name()  # \\.\DISPLAY1
+        self._friendly_name = self._get_friendly_name()
+
+    @property
+    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
+
+    def _get_friendly_name_display_config_api(self) -> str:
+        """Get the friendly name of a monitor using the newer Display Configuration API.
+
+        This API is meant to replace EnumDisplayDevicesW, and should be more accurate.
+
+        Requires Windows Vista or higher.
+        """
+        path_count = UINT32()
+        mode_count = UINT32()
+
+        result = _user32.GetDisplayConfigBufferSizes(
+            QDC_ONLY_ACTIVE_PATHS, ctypes.byref(path_count), ctypes.byref(mode_count),
+        )
+        if result != 0:
+            return "Unknown"
+
+        paths = (DISPLAYCONFIG_PATH_INFO * path_count.value)()
+        modes = ctypes.create_string_buffer(64 * mode_count.value)  # dummy buffer
+
+        result = _user32.QueryDisplayConfig(
+            QDC_ONLY_ACTIVE_PATHS, ctypes.byref(path_count), paths, ctypes.byref(mode_count), modes, 0,
+        )
+        if result != 0:
+            return "Unknown"
+
+        for i in range(path_count.value):
+            path = paths[i]
+
+            source_name = DISPLAYCONFIG_SOURCE_DEVICE_NAME()
+            source_name.header.adapterId = path.sourceInfo.adapterId
+            source_name.header.id = path.sourceInfo.id
+            source_name.header.type = DISPLAYCONFIG_DEVICE_INFO_GET_SOURCE_NAME
+            source_name.header.size = ctypes.sizeof(source_name)
+
+            result = _user32.DisplayConfigGetDeviceInfo(ctypes.byref(source_name.header))
+            if result != 0:
+                continue
+
+            if source_name.viewGdiDeviceName != self._device_name:
+                continue
+
+            if not path.targetInfo.targetAvailable:
+                  continue
+
+            target_name = DISPLAYCONFIG_TARGET_DEVICE_NAME()
+
+            target_name.header.adapterId = path.targetInfo.adapterId
+            target_name.header.id = path.targetInfo.id
+            target_name.header.type = DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_NAME
+            target_name.header.size = ctypes.sizeof(target_name)
+
+            if _user32.DisplayConfigGetDeviceInfo(ctypes.byref(target_name.header)) == 0:
+                return target_name.monitorFriendlyDeviceName
+
+        return "Unknown"
+
+    def _get_friendly_name(self) -> str:
+        if WINDOWS_VISTA_OR_GREATER:
+            return self._get_friendly_name_display_config_api()
+
+        dd = DISPLAY_DEVICEW()
+        dd.cb = ctypes.sizeof(dd)
+        if _user32.EnumDisplayDevicesW(self._device_name, 0, ctypes.byref(dd), 0):
+            return dd.DeviceString
+
+        return "Unknown"
 
     def get_matching_configs(self, template):
         with device_context(None) as hdc:
@@ -75,13 +175,23 @@ class Win32Screen(Screen):
 
         return configs
 
-    def get_device_name(self):
+    def _get_monitor_info(self) -> MONITORINFOEX:
         info = MONITORINFOEX()
         info.cbSize = sizeof(MONITORINFOEX)
         _user32.GetMonitorInfoW(self._handle, byref(info))
+        return info
+
+    def get_display_id(self) -> str:
+        return self._device_name
+
+    def get_monitor_name(self) -> str:
+        return self._friendly_name
+
+    def get_device_name(self) -> str:
+        info = self._get_monitor_info()
         return info.szDevice
 
-    def get_dpi(self):
+    def get_dpi(self) -> int:
         if WINDOWS_8_1_OR_GREATER:
             xdpi = UINT()
             ydpi = UINT()
@@ -95,11 +205,11 @@ class Win32Screen(Screen):
 
         return xdpi
 
-    def get_scale(self):
+    def get_scale(self) -> float:
         xdpi = self.get_dpi()
         return xdpi / USER_DEFAULT_SCREEN_DPI
 
-    def get_modes(self):
+    def get_modes(self) -> list[Win32ScreenMode]:
         device_name = self.get_device_name()
         i = 0
         modes = []
@@ -115,7 +225,7 @@ class Win32Screen(Screen):
 
         return modes
 
-    def get_mode(self):
+    def get_mode(self) -> Win32ScreenMode:
         mode = DEVMODE()
         mode.dmSize = sizeof(DEVMODE)
         _user32.EnumDisplaySettingsW(self.get_device_name(),
@@ -123,7 +233,7 @@ class Win32Screen(Screen):
                                      byref(mode))
         return Win32ScreenMode(self, mode)
 
-    def set_mode(self, mode):
+    def set_mode(self, mode: Win32ScreenMode) -> None:
         assert mode.screen is self
 
         if not self._initial_mode:
@@ -137,13 +247,18 @@ class Win32Screen(Screen):
             self.width = mode.width
             self.height = mode.height
 
-    def restore_mode(self):
+    def restore_mode(self) -> None:
         if self._initial_mode:
             self.set_mode(self._initial_mode)
 
 
-class Win32ScreenMode(ScreenMode):
-    def __init__(self, screen, mode):
+_win32_scale_name = {
+    0: "default",
+    1: "center",
+    2: "stretch",
+}
+class Win32ScreenMode(ScreenMode):  # noqa: D101
+    def __init__(self, screen: Win32Screen, mode: DEVMODE) -> None:  # noqa: D107
         super().__init__(screen)
         self._mode = mode
         self.width = mode.dmPelsWidth
@@ -152,11 +267,12 @@ class Win32ScreenMode(ScreenMode):
         self.rate = mode.dmDisplayFrequency
         self.scaling = mode.dmDisplayFixedOutput
 
-    def __repr__(self):
-        return f'{self.__class__.__name__}(width={self.width!r}, height={self.height!r}, depth={self.depth!r}, rate={self.rate}, scaling={self.scaling})'
+    def __repr__(self) -> str:
+        return (f'{self.__class__.__name__}(width={self.width!r}, height={self.height!r}, depth={self.depth!r},'
+                f'rate={self.rate}, scaling={_win32_scale_name.get(self.scaling)})')
 
-class Win32Canvas(Canvas):
-    def __init__(self, display, hwnd, hdc):
+class Win32Canvas(Canvas):  # noqa: D101
+    def __init__(self, display: Win32Display, hwnd: HWND, hdc: HDC) -> None:  # noqa: D107
         super().__init__(display)
         self.hwnd = hwnd
         self.hdc = hdc