pyglet 2.1.dev3__py3-none-any.whl → 2.1.dev5__py3-none-any.whl

pyglet/__init__.py

@@ -6,12 +6,16 @@ from __future__ import annotations
 
 import os
 import sys
-
+from collections.abc import ItemsView, Sequence
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, ItemsView
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from types import FrameType
+    from typing import Any, Callable, ItemsView, Sized
 
 #: The release version
-version = '2.1.dev3'
+version = '2.1.dev5'
 __version__ = version
 
 MIN_PYTHON_VERSION = 3, 8
@@ -34,11 +38,21 @@ 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),
+}
+
+_OPTION_TYPE_VALIDATORS = {
+    "bool": lambda x: isinstance(x, bool),
+    "int": lambda x: isinstance(x, int),
+}
+
 @dataclass
 class Options:
     """Dataclass for global pyglet options."""
 
-    audio: tuple[str] = ("xaudio2", "directsound", "openal", "pulse", "silent")
+    audio: Sequence[str] = ("xaudio2", "directsound", "openal", "pulse", "silent")
     """A :py:class:`~typing.Sequence` of valid audio modules names. They will
      be tried from first to last until either a driver loads or no entries
      remain. See :ref:`guide-audio-driver-order` for more information.
@@ -122,12 +136,13 @@ class Options:
      must be loaded after the window using them was created).  Recommended
      for advanced developers only.
 
-     .. versionadded:: 1.1"""
+     .. versionadded:: 1.1
+     """
 
     vsync: bool | None = None
-    """If set to ``True`` or ``False``, this option takes overrides the
-     ``vsync`` argument passed to :py:class:`~pyglet.window.Window`. This
-     allows forcing vsync on or off.  If set to None (the default), the
+    """If set, the `pyglet.window.Window.vsync` property is ignored, and
+     this option overrides it (to either force vsync on or off).  If unset,
+     or set to None, the `pyglet.window.Window.vsync` property behaves
      as documented.
      """
 
@@ -170,7 +185,7 @@ class Options:
 
     headless_device: int = 0
     """If using ``headless`` mode (``pyglet.options['headless'] = True``), this option allows you to set which
-    GPU to use. This is only useful on multi-GPU systems. 
+    GPU to use. This is only useful on multi-GPU systems.
     """
 
     win32_disable_shaping: bool = False
@@ -246,6 +261,16 @@ class Options:
     number of pixels requested.
     """
 
+    shader_bind_management: bool = True
+    """If ``True``, this will enable internal management of Uniform Block bindings for
+     :py:class:`~pyglet.graphics.shader.ShaderProgram`'s.
+
+    If ``False``, bindings will not be managed by Pyglet. The user will be responsible for either setting the binding
+    points through GLSL layouts (4.2 required) or manually through ``UniformBlock.set_binding``.
+
+    .. versionadded:: 2.0.16
+    """
+
     def get(self, item: str, default: Any = None) -> Any:
         return self.__dict__.get(item, default)
 
@@ -257,12 +282,13 @@ class Options:
 
     def __setitem__(self, key: str, value: Any) -> None:
         assert key in self.__annotations__, f"Invalid option name: '{key}'"
-        assert type(value).__name__ == self.__annotations__[key], f"Invalid type: '{type(value)}' for '{key}'"
+        assert (_SPECIAL_OPTION_VALIDATORS.get(key, None) 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: Options = Options()
 
 
 for _key, _type in options.__annotations__.items():
@@ -282,10 +308,10 @@ if compat_platform == "cygwin":
     # DirectSound support.
     import ctypes
 
-    ctypes.windll = ctypes.cdll  # type: ignore
-    ctypes.oledll = ctypes.cdll  # type: ignore
+    ctypes.windll = ctypes.cdll
+    ctypes.oledll = ctypes.cdll
     ctypes.WINFUNCTYPE = ctypes.CFUNCTYPE
-    ctypes.HRESULT = ctypes.c_long  # type: ignore
+    ctypes.HRESULT = ctypes.c_long
 
 # Call tracing
 # ------------
@@ -297,17 +323,17 @@ _trace_depth = options["debug_trace_depth"]
 _trace_flush = options["debug_trace_flush"]
 
 
-def _trace_repr(value, size=40):
+def _trace_repr(value: Sized, size: int=40) -> str:
     value = repr(value)
     if len(value) > size:
         value = value[:size // 2 - 2] + "..." + value[-size // 2 - 1:]
     return value
 
 
-def _trace_frame(thread, frame, indent):
-    if frame.f_code is lib._TraceFunction.__call__.__code__:
+def _trace_frame(thread: int, frame: FrameType, indent: str) -> None:
+    if frame.f_code is lib._TraceFunction.__call__.__code__: # noqa: SLF001
         is_ctypes = True
-        func = frame.f_locals["self"]._func
+        func = frame.f_locals["self"]._func # noqa: SLF001
         name = func.__name__
         location = "[ctypes]"
     else:
@@ -348,23 +374,23 @@ def _trace_frame(thread, frame, indent):
                 try:
                     argvalue = _trace_repr(frame.f_locals[argname])
                     print(f"  {indent}{argname}={argvalue}")
-                except:
+                except: # noqa: S110, E722, PERF203
                     pass
 
     if _trace_flush:
         sys.stdout.flush()
 
 
-def _thread_trace_func(thread):
-    def _trace_func(frame, event, arg):
+def _thread_trace_func(thread: int) -> Callable[[FrameType, str, Any], object]:
+    def _trace_func(frame: FrameType, event: str, arg: Any) -> None:
         if event == "call":
             indent = ""
-            for i in range(_trace_depth):
+            for _ in range(_trace_depth):
                 _trace_frame(thread, frame, indent)
                 indent += "  "
-                frame = frame.f_back
-                if not frame:
+                if frame.f_back is None:
                     break
+                frame = frame.f_back
 
         elif event == "exception":
             (exception, value, traceback) = arg
@@ -373,8 +399,8 @@ def _thread_trace_func(thread):
     return _trace_func
 
 
-def _install_trace():
-    global _trace_thread_count
+def _install_trace() -> None:
+    global _trace_thread_count # noqa: PLW0603
     sys.setprofile(_thread_trace_func(_trace_thread_count))
     _trace_thread_count += 1
 
@@ -385,10 +411,10 @@ def _install_trace():
 class _ModuleProxy:
     _module = None
 
-    def __init__(self, name: str):
+    def __init__(self, name: str) -> None:
         self.__dict__["_module_name"] = name
 
-    def __getattr__(self, name):
+    def __getattr__(self, name: str): # noqa: ANN204
         try:
             return getattr(self._module, name)
         except AttributeError:
@@ -402,7 +428,7 @@ class _ModuleProxy:
             globals()[self._module_name] = module
             return getattr(module, name)
 
-    def __setattr__(self, name, value):
+    def __setattr__(self, name: str, value: Any): # noqa: ANN204
         try:
             setattr(self._module, name, value)
         except AttributeError:

pyglet/__init__.pyi

@@ -1,4 +1,7 @@
 
+from dataclasses import dataclass
+from typing import Sequence
+
 from . import app as app
 from . import clock as clock
 from . import customtypes as customtypes
@@ -26,4 +29,39 @@ MIN_PYTHON_VERSION_STR: str
 compat_platform: str
 env: str
 value: str
+
+@dataclass
+class Options:
+    audio: Sequence[str]
+    debug_font: bool
+    debug_gl: bool
+    debug_gl_trace: bool
+    debug_gl_trace_args: bool
+    debug_gl_shaders: bool
+    debug_graphics_batch: bool
+    debug_lib: bool
+    debug_media: bool
+    debug_texture: bool
+    debug_trace: bool
+    debug_trace_args: bool
+    debug_trace_depth: int
+    debug_trace_flush: bool
+    debug_win32: bool
+    debug_input: bool
+    debug_x11: bool
+    shadow_window: bool
+    vsync: bool | None
+    xsync: bool
+    xlib_fullscreen_override_redirect: bool
+    search_local_libs: bool
+    win32_gdi_font: bool
+    headless: bool
+    headless_device: int
+    win32_disable_shaping: bool
+    dw_legacy_naming: bool
+    win32_disable_xinput: bool
+    com_mta: bool
+    osx_alt_loop: bool
+    shader_bind_management: bool
+
 options: Options

pyglet/app/win32.py

@@ -3,7 +3,7 @@ import ctypes
 from .base import PlatformEventLoop
 
 from pyglet.libs.win32 import _kernel32, _user32, types, constants
-from pyglet.libs.win32.types import *
+from pyglet.libs.win32.types import HANDLE, TIMECAPS
 
 
 class Win32EventLoop(PlatformEventLoop):

pyglet/display/__init__.py

@@ -20,7 +20,7 @@ The size of a screen is determined by its current mode, which can be changed
 by the application; see the documentation for :class:`Screen`.
 
 .. versionadded:: 1.2
-"""
+"""  # noqa: I002
 
 import sys
 import weakref
@@ -71,4 +71,6 @@ def get_display() -> Display:
         return display
 
     # Otherwise, create a new display and return it.
-    return Display()
+    return Display()
+
+__all__ = ['Display', 'Screen', 'Canvas', 'ScreenMode', 'get_display']

pyglet/display/cocoa.py

@@ -1,9 +1,9 @@
 # Note: The display mode API used here is Mac OS 10.6 only.
+from __future__ import annotations
 
-from ctypes import *
-
-from .base import Display, Screen, ScreenMode, Canvas
+from ctypes import c_uint32, c_void_p, byref
 
+from .base import Canvas, Display, Screen, ScreenMode
 from pyglet.libs.darwin.cocoapy import CGDirectDisplayID, quartz, cf, ObjCClass, get_NSString
 from pyglet.libs.darwin.cocoapy import cfstring_to_string, cfarray_to_list
 from pyglet.libs.darwin import NSDeviceResolution
@@ -142,6 +142,6 @@ class CocoaScreenMode(ScreenMode):
 class CocoaCanvas(Canvas):
 
     def __init__(self, display, screen, nsview):
-        super(CocoaCanvas, self).__init__(display)
+        super().__init__(display)
         self.screen = screen
         self.nsview = nsview

pyglet/display/headless.py

@@ -4,7 +4,7 @@ import warnings
 from .base import Display, Screen, ScreenMode, Canvas
 
 
-from ctypes import *
+from ctypes import byref
 from pyglet.libs.egl import egl
 from pyglet.libs.egl import eglext
 

pyglet/display/win32.py

@@ -1,8 +1,28 @@
 from .base import Display, Screen, ScreenMode, Canvas
 
 from pyglet.libs.win32 import _user32, _shcore, _gdi32
-from pyglet.libs.win32.constants import *
-from pyglet.libs.win32.types import *
+from pyglet.libs.win32.constants import (
+    CDS_FULLSCREEN,
+    DISP_CHANGE_SUCCESSFUL,
+    ENUM_CURRENT_SETTINGS,
+    WINDOWS_8_1_OR_GREATER,
+    WINDOWS_VISTA_OR_GREATER,
+    WINDOWS_10_CREATORS_UPDATE_OR_GREATER,
+    USER_DEFAULT_SCREEN_DPI,
+    LOGPIXELSX,
+    LOGPIXELSY,
+
+)
+from pyglet.libs.win32.types import (
+    DEVMODE,
+    DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2,
+    MONITORINFOEX,
+    MONITORENUMPROC,
+    PROCESS_PER_MONITOR_DPI_AWARE,
+    UINT,
+    sizeof,
+    byref
+)
 from pyglet.libs.win32.context_managers import device_context
 
 

pyglet/display/xlib.py

@@ -1,13 +1,16 @@
+from __future__ import annotations
+
 import ctypes
-from ctypes import *
+from ctypes import c_int, c_char_p, c_buffer, POINTER, byref, cast
 
 from pyglet.util import asbytes
 
 from pyglet import app
 from pyglet.app.xlib import XlibSelectDevice
-from .base import Display, Screen, ScreenMode, Canvas
 
+from ..libs.x11.xlib import Window
 from . import xlib_vidmoderestore
+from .base import Canvas, Display, Screen, ScreenMode
 
 
 # XXX
@@ -176,7 +179,7 @@ class XlibScreen(Screen):
     _initial_mode = None
 
     def __init__(self, display, x, y, width, height, xinerama):
-        super(XlibScreen, self).__init__(display, x, y, width, height)
+        super().__init__(display, x, y, width, height)
         self._xinerama = xinerama
 
     def get_dpi(self):
@@ -252,7 +255,7 @@ class XlibScreen(Screen):
 
         xf86vmode.XF86VidModeSwitchToMode(self.display._display, self.display.x_screen, mode.info)
         xlib.XFlush(self.display._display)
-        xf86vmode.XF86VidModeSetViewPort(self.display._display,  self.display.x_screen, 0, 0)
+        xf86vmode.XF86VidModeSetViewPort(self.display._display, self.display.x_screen, 0, 0)
         xlib.XFlush(self.display._display)
 
         self.width = mode.width
@@ -267,10 +270,9 @@ class XlibScreen(Screen):
                f"width={self.width}, height={self.height}, xinerama={self._xinerama})"
 
 
-
 class XlibScreenMode(ScreenMode):
     def __init__(self, screen, info):
-        super(XlibScreenMode, self).__init__(screen)
+        super().__init__(screen)
         self.info = info
         self.width = info.hdisplay
         self.height = info.vdisplay
@@ -278,7 +280,9 @@ class XlibScreenMode(ScreenMode):
         self.depth = None
 
 
-class XlibCanvas(Canvas):
-    def __init__(self, display, x_window):
-        super(XlibCanvas, self).__init__(display)
+class XlibCanvas(Canvas):  # noqa: D101
+    display: XlibDisplay
+
+    def __init__(self, display: XlibDisplay, x_window: Window) -> None:  # noqa: D107
+        super().__init__(display)
         self.x_window = x_window

pyglet/event.py

@@ -126,14 +126,19 @@ from typing import TYPE_CHECKING
 from weakref import WeakMethod
 
 if TYPE_CHECKING:
+    import sys
     from typing import Any, Callable, Generator
+    if sys.version_info >= (3, 11):
+        from typing import Self
+    else:
+        Self = Any
 
 
 EVENT_HANDLED = True
 EVENT_UNHANDLED = None
 
 
-class EventException(Exception):
+class EventException(Exception):  # noqa: N818
     """An exception raised when an event handler could not be attached."""
 
 
@@ -147,7 +152,7 @@ class EventDispatcher:
     _event_stack: tuple | list = ()
 
     @classmethod
-    def register_event_type(cls: EventDispatcher, name: str) -> str:
+    def register_event_type(cls: type[Self], name: str) -> str:
         """Register an event type with the dispatcher.
 
         Before dispatching events, they must first be registered by name.
@@ -179,14 +184,15 @@ class EventDispatcher:
         self._event_stack.insert(0, {})
         self.set_handlers(*args, **kwargs)
 
-    def _get_handlers(self, args: Any, kwargs: Any) -> Generator[str, Callable]:
+    def _get_handlers(self, args: list, kwargs: dict) -> Generator[str, Callable]:
         """Implement handler matching on arguments for set_handlers and remove_handlers."""
         for obj in args:
             if inspect.isroutine(obj):
                 # Single magically named function
                 name = obj.__name__
                 if name not in self.event_types:
-                    raise EventException(f'Unknown event "{name}"')
+                    msg = f'Unknown event "{name}"'
+                    raise EventException(msg)
                 if inspect.ismethod(obj):
                     yield name, WeakMethod(obj, partial(self._remove_handler, name))
                 else:
@@ -201,7 +207,8 @@ class EventDispatcher:
         for name, handler in kwargs.items():
             # Function for handling given event (no magic)
             if name not in self.event_types:
-                raise EventException(f'Unknown event "{name}"')
+                msg = f'Unknown event "{name}"'
+                raise EventException(msg)
             if inspect.ismethod(handler):
                 yield name, WeakMethod(handler, partial(self._remove_handler, name))
             else:
@@ -230,7 +237,7 @@ class EventDispatcher:
 
     def pop_handlers(self) -> None:
         """Pop the top level of event handlers off the stack."""
-        assert self._event_stack and 'No handlers pushed'
+        assert self._event_stack, 'No handlers pushed'
 
         del self._event_stack[0]
 
@@ -251,13 +258,14 @@ class EventDispatcher:
         handlers = list(self._get_handlers(args, kwargs))
 
         # Find the first stack frame containing any of the handlers
-        def find_frame():
+        def find_frame() -> dict | None:
             for _frame in self._event_stack:
                 for _name, _handler in handlers:
                     if _name not in _frame:
                         continue
                     if _frame[_name] == _handler:
                         return _frame
+            return None
 
         frame = find_frame()
 
@@ -270,7 +278,7 @@ class EventDispatcher:
             try:
                 if frame[name] == handler:
                     del frame[name]
-            except KeyError:
+            except KeyError:  # noqa: PERF203
                 pass
 
         # Remove the frame if it's empty.
@@ -302,7 +310,6 @@ class EventDispatcher:
         This is normally called from a dead ``WeakMethod`` to remove itself from the
         event stack.
         """
-
         # Iterate over a copy as we might mutate the list
         for frame in list(self._event_stack):
 
@@ -428,13 +435,13 @@ class EventDispatcher:
 
         raise exception
 
-    def _dump_handlers(self):
+    def _dump_handlers(self) -> None:
 
         for level, handlers in enumerate(self._event_stack):
-            print(f"level: {level}")
+            print(f"level: {level}") 
 
             for event_type, handler in handlers.items():
-                print(f" - '{event_type}': {handler}")
+                print(f" - '{event_type}': {handler}") 
 
     # Decorator
 
@@ -488,5 +495,5 @@ class EventDispatcher:
 
             return decorator
 
-        else:
-            raise TypeError("Argument must be the name of the event as a `str`.")
+        msg = "Argument must be the name of the event as a `str`."
+        raise TypeError(msg)