pyglet 3.0.dev1__py3-none-any.whl → 3.0.dev3__py3-none-any.whl

pyglet/__init__.py

@@ -11,12 +11,14 @@ import warnings
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Literal, Sequence
 
+from .enums import GraphicsAPI
+
 if TYPE_CHECKING:
     from types import FrameType
     from typing import Any, Callable, ItemsView, Sized
 
 #: The release version
-version = '3.0.dev1'
+version = '3.0.dev3'
 __version__ = version
 
 MIN_PYTHON_VERSION = 3, 8
@@ -286,9 +288,16 @@ class Options:
     .. versionadded:: 3.0.0
     """
 
-    backend: Literal["opengl", "gl2", "gles3", "gles2", "webgl"] = "opengl"
+    backend: Literal["opengl", "gl2", "gles3", "gles2", "webgl"] | GraphicsAPI = GraphicsAPI.OPENGL
     """Specify the graphics API backend."""
 
+    opengl_persistent_buffers: bool = False
+    """If ``True``, the OpenGL backend uses persistent mapped vertex buffers when supported.
+
+    Requires OpenGL 4.4 or the ``GL_ARB_buffer_storage`` extension. If unavailable or ``False``, pyglet
+    falls back to normal backed buffer objects.
+    """
+
     optimize_states: bool = True
     """Runs a second pass on the draw list to remove any redundant states.
 

pyglet/__init__.pyi

@@ -7,6 +7,7 @@ from . import clock as clock
 from . import config as config
 from . import customtypes as customtypes
 from . import display as display
+from . import enums as enums
 from . import event as event
 from . import font as font
 from . import graphics as graphics
@@ -72,6 +73,7 @@ class Options:
     wayland: bool
     backend: str | None
     optimize_states: bool
+    opengl_persistent_buffers: bool
     pyodide: PyodideOptions
 
     def get(self, item: str, default: Any = None) -> Any:

pyglet/app/__init__.py

@@ -46,8 +46,10 @@ if _is_pyglet_doc_run:
 else:
     if compat_platform == 'darwin':
         from pyglet.app.cocoa import CocoaPlatformEventLoop as PlatformEventLoop
+        from pyglet.libs.darwin.cocoapy.runtime import get_chip_model
 
-        if platform.machine() == 'arm64' or pyglet.options.osx_alt_loop:
+        # Use alternate loop only if forced, or using an M1 chip.
+        if (platform.machine() == 'arm64' and "M1" in get_chip_model()) or pyglet.options.osx_alt_loop:
             from pyglet.app.cocoa import CocoaAlternateEventLoop as EventLoop
     elif compat_platform in ('win32', 'cygwin'):
         from pyglet.app.win32 import Win32EventLoop as PlatformEventLoop

pyglet/app/base.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import queue
 import sys
 import threading
+from queue import Queue
 from typing import TYPE_CHECKING, Any, Callable
 
 from pyglet import app, clock, event
@@ -19,6 +20,8 @@ class PlatformEventLoop:
 
     .. versionadded:: 1.2
     """
+    _event_queue: Queue[tuple[EventDispatcher, str, Any]]
+
     def __init__(self) -> None:  # noqa: D107
         self._event_queue = queue.Queue()
         self._is_running = threading.Event()
@@ -96,8 +99,8 @@ class EventLoop(event.EventDispatcher):
     this method contains platform-specific code that ensures the application
     remains responsive to the user while keeping CPU usage to a minimum.
     """
-
-    _has_exit_condition = None
+    _interval: float | None
+    _has_exit_condition: threading.Condition
     _has_exit = False
 
     def __init__(self) -> None:  # noqa: D107

pyglet/config/__init__.py

@@ -1,101 +1,41 @@
+"""Configuration options for the Graphics Context."""
+
 from __future__ import annotations
 
-from dataclasses import dataclass
-from typing import Any, TYPE_CHECKING
+from typing import TYPE_CHECKING, NamedTuple
+
+from pyglet.enums import GraphicsAPI
 
+from .base import SurfaceConfig, UserConfig  # noqa: TC001
+from .gl import OpenGLUserConfig, WebGLUserConfig
 
 if TYPE_CHECKING:
     from pyglet.window import Window
 
 
+class Config:
+    """A container for backend specific user configuration."""
+    opengl: OpenGLUserConfig
+    gl2: OpenGLUserConfig
+    gles2: OpenGLUserConfig
+    gles3: OpenGLUserConfig
+    webgl: WebGLUserConfig
 
-class SurfaceConfig:
-    """Surface configuration information returned by a platform.
-
-    This describes the information a desired surface or window can support.
-    """
-    def __init__(self, window: Window, config: UserConfig, handle: Any) -> None:
-        """A config representing the capabilities of a specific surface.
-
-        This is returned by the platform on a specific window and is not meant to be created by users.
-
-        Args:
-            window:
-                The current window or display.
-            config:
-                The requested user configuration.
-            handle:
-                A handle to the underlying configuration unique to each platform.
-        """
-        self._window = window
-        self.config = config
-        self.handle = handle
+    __slots__ = 'gl2', 'gles2', 'gles3', 'opengl', 'vulkan', 'webgl'
 
-    @property
-    def attributes(self) -> dict[str, Any]:
-        """The public attributes of this configuration."""
-        return {attrib: value for attrib, value in self.__dict__.items() if attrib[0] != '_'}
-
-    def is_finalized(self) -> bool:
-        return True
-
-class UserConfig:
-    """User configuration information."""
-
-@dataclass
-class OpenGLConfig(UserConfig):
-    """An OpenGL Graphics configuration."""
-    #: Specify the presence of a back-buffer for every color buffer.
-    double_buffer: bool | None = None
-    #: Specify the presence of separate left and right buffer sets.
-    stereo: bool | None = None
-    #: Total bits per sample per color buffer.
-    buffer_size: int | None = None
-    #: The number of auxiliary color buffers.
-    aux_buffers: int | None = None
-    #: The number of multisample buffers.
-    sample_buffers: int | None = None
-    #: The number of samples per pixel, or 0 if there are no multisample buffers.
-    samples: int | None = None
-    #: Bits per sample per buffer devoted to the red component.
-    red_size: int | None = None
-    #: Bits per sample per buffer devoted to the green component.
-    green_size: int | None = None
-    #: Bits per sample per buffer devoted to the blue component.
-    blue_size: int | None = None
-    #: Bits per sample per buffer devoted to the alpha component.
-    alpha_size: int | None = None
-    #: Bits per sample in the depth buffer.
-    depth_size: int | None = None
-    #: Bits per sample in the stencil buffer.
-    stencil_size: int | None = None
-    #: Bits per pixel devoted to the red component in the accumulation buffer. Deprecated.
-    accum_red_size: int | None = None
-    #: Bits per pixel devoted to the green component in the accumulation buffer. Deprecated.
-    accum_green_size: int | None = None
-    #: Bits per pixel devoted to the blue component in the accumulation buffer. Deprecated.
-    accum_blue_size: int | None = None
-    #: Bits per pixel devoted to the alpha component in the accumulation buffer. Deprecated.
-    accum_alpha_size: int | None = None
-    #: The OpenGL major version.
-    major_version: int | None = None
-    #: The OpenGL minor version.
-    minor_version: int | None = None
-    #: Whether to use forward compatibility mode.
-    forward_compatible: bool | None = None
-    opengl_api: str | None = "gl"
-    #: Debug mode.
-    debug: bool | None = None
-    #: If the framebuffer should be transparent.
-    transparent_framebuffer: bool | None = None
-
-    @property
-    def is_finalized(self) -> bool:
-        return False
+    def __init__(self):
+        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)
+        self.gles3: OpenGLUserConfig = OpenGLUserConfig(major_version=3, minor_version=2, api=GraphicsAPI.OPENGL_ES_3)
+        self.webgl: WebGLUserConfig = WebGLUserConfig()
+        # self.vulkan: TBD
 
 
 def match_surface_config(config: UserConfig, surface: Window) -> SurfaceConfig | None:
-    if isinstance(config, OpenGLConfig):
+    if isinstance(config, (OpenGLUserConfig, WebGLUserConfig)):
         from pyglet.config.gl import get_surface_config  # noqa: PLC0415
         return get_surface_config(config, surface)
-    return None
+
+    msg = f"Matching for '{config.__class__}' is not yet implemented."
+    raise NotImplementedError(msg)

pyglet/config/base.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from typing import Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pyglet.window import Window
+    from pyglet.enums import GraphicsAPI
+
+
+class UserConfig:
+    """User configuration information."""
+    api: GraphicsAPI
+
+    @property
+    def is_finalized(self) -> bool:
+        return False
+
+
+class SurfaceConfig:
+    """Surface configuration information returned by a platform.
+
+    This describes the information a desired surface or window can support.
+    """
+    def __init__(self, window: Window, config: UserConfig, handle: Any) -> None:
+        """A config representing the capabilities of a specific surface.
+
+        This is returned by the platform on a specific window and is not meant to be created by users.
+
+        Args:
+            window:
+                The current window or display.
+            config:
+                The requested user configuration.
+            handle:
+                A handle to the underlying configuration unique to each platform.
+        """
+        self._window = window
+        self.config = config
+        self.handle = handle
+
+    @property
+    def attributes(self) -> dict[str, Any]:
+        """The public attributes of this configuration."""
+        return {attrib: value for attrib, value in self.__dict__.items() if attrib[0] != '_'}
+
+    @property
+    def is_finalized(self) -> bool:
+        return True

pyglet/config/gl/__init__.py

@@ -1,30 +1,128 @@
 from __future__ import annotations
+
+from dataclasses import dataclass
+
 import pyglet
-from pyglet.config import UserConfig, SurfaceConfig, OpenGLConfig
+
+from pyglet.enums import GraphicsAPI
+from pyglet.config.base import UserConfig, SurfaceConfig
 
 
 class GLSurfaceConfig(SurfaceConfig):
-    config: OpenGLConfig
+    config: OpenGLUserConfig
+
+
+# Platform Specific Configurations
+
+@dataclass
+class OpenGLUserConfig(UserConfig):
+    """An OpenGL Graphics configuration."""
+    #: Specify the presence of a back-buffer for every color buffer.
+    double_buffer: bool | None = None
+    #: Specify the presence of separate left and right buffer sets.
+    stereo: bool | None = None
+    #: Total bits per sample per color buffer.
+    buffer_size: int | None = None
+    #: The number of auxiliary color buffers.
+    aux_buffers: int | None = None
+    #: The number of multisample buffers.
+    sample_buffers: int | None = None
+    #: The number of samples per pixel, or 0 if there are no multisample buffers.
+    samples: int | None = None
+    #: Bits per sample per buffer devoted to the red component.
+    red_size: int | None = None
+    #: Bits per sample per buffer devoted to the green component.
+    green_size: int | None = None
+    #: Bits per sample per buffer devoted to the blue component.
+    blue_size: int | None = None
+    #: Bits per sample per buffer devoted to the alpha component.
+    alpha_size: int | None = None
+    #: Bits per sample in the depth buffer.
+    depth_size: int | None = None
+    #: Bits per sample in the stencil buffer.
+    stencil_size: int | None = None
+    #: Bits per pixel devoted to the red component in the accumulation buffer. Deprecated.
+    accum_red_size: int | None = None
+    #: Bits per pixel devoted to the green component in the accumulation buffer. Deprecated.
+    accum_green_size: int | None = None
+    #: Bits per pixel devoted to the blue component in the accumulation buffer. Deprecated.
+    accum_blue_size: int | None = None
+    #: Bits per pixel devoted to the alpha component in the accumulation buffer. Deprecated.
+    accum_alpha_size: int | None = None
+    #: The OpenGL major version.
+    major_version: int | None = None
+    #: The OpenGL minor version.
+    minor_version: int | None = None
+    #: Whether to use forward compatibility mode.
+    forward_compatible: bool | None = None
+    #: Debug mode.
+    debug: bool | None = None
+    #: If the framebuffer should be transparent.
+    transparent_framebuffer: bool | None = None
+    #: Which rendering API is being used (GL, ES, etc.).
+    api: GraphicsAPI = GraphicsAPI.OPENGL
+
+    @property
+    def is_finalized(self) -> bool:
+        return False
+
+
+@dataclass
+class WebGLUserConfig(UserConfig):
+    """A WebGL Graphics configuration."""
+    #: Whether the drawing buffer has an alpha channel (pyglet defaults to False).
+    alpha: bool = False
+    #: Whether the drawing buffer has a depth buffer (default True).
+    depth: bool | None = None
+    #: Whether the drawing buffer has a stencil buffer (default False).
+    stencil: bool | None = None
+    #: Whether antialiasing is enabled (default True).
+    antialias: bool | None = None
+    #: Whether color values are pre-multiplied by alpha (default True).
+    premultipliedAlpha: bool | None = None
+    #: Whether the drawing buffer is preserved after rendering (default False).
+    preserveDrawingBuffer: bool | None = None
+    #: Whether context creation fails if performance is low (default False).
+    failIfMajorPerformanceCaveat: bool | None = None
+    #: Hints GPU preference: "default", "low-power", or "high-performance" (default "default").
+    powerPreference: str | None = None
+    #: Hints to reduce latency by desynchronizing canvas painting (default False).
+    desynchronized: bool | None = None
+
+    @property
+    def api(self):
+        return GraphicsAPI.WEBGL
+
+    @property
+    def is_finalized(self) -> bool:
+        return False
 
 
 def get_surface_config(user_config: UserConfig, surface: pyglet.window.Window) -> SurfaceConfig | None:
+
     if pyglet.options.headless or pyglet.options.wayland:
         from pyglet.config.gl.egl import match
 
         return match(user_config, surface)
+
     if pyglet.compat_platform == "win32":
         from pyglet.config.gl.windows import match  # noqa: PLC0415
 
         return match(user_config, surface)
+
     if pyglet.compat_platform.startswith("linux"):
         from pyglet.config.gl.x11 import match  # noqa: PLC0415
 
         return match(user_config, surface)
+
     if pyglet.compat_platform == "darwin":
         from pyglet.config.gl.macos import match  # noqa: PLC0415
 
         return match(user_config, surface)
 
     if pyglet.compat_platform == "emscripten":
-        return GLSurfaceConfig(surface, user_config, None)
+        from pyglet.config.gl.webgl import match  # noqa: PLC0415
+
+        return match(user_config, surface)
+
     return None

pyglet/config/gl/egl.py

@@ -8,10 +8,11 @@ from pyglet import options
 from pyglet.graphics.api.gl.egl.context import EGLContext
 from pyglet.libs import egl
 from pyglet.config import SurfaceConfig
+from pyglet.enums import GraphicsAPI
 
 if TYPE_CHECKING:
     from pyglet.graphics.api import OpenGLBackend
-    from pyglet.config import OpenGLConfig
+    from pyglet.config import OpenGLUserConfig
     from pyglet.window.headless import HeadlessWindow
     from pyglet.window.wayland import WaylandWindow
 
@@ -26,7 +27,7 @@ _fake_gl_attributes = {
 }
 
 
-def match(config: OpenGLConfig, window: HeadlessWindow | WaylandWindow) -> EGLSurfaceConfig:
+def match(config: OpenGLUserConfig, window: HeadlessWindow | WaylandWindow) -> EGLSurfaceConfig:
     display_connection = window.egl_display_connection  # noqa: SLF001
     assert display_connection is not None
 
@@ -49,12 +50,14 @@ def match(config: OpenGLConfig, window: HeadlessWindow | WaylandWindow) -> EGLSu
         attrs.extend([egl.EGL_ALPHA_SIZE, 8])
         attrs.extend([egl.EGL_DEPTH_SIZE, 8])
 
-    if config.opengl_api == "gl":
+    if config.api == GraphicsAPI.OPENGL:
         attrs.extend([egl.EGL_RENDERABLE_TYPE, egl.EGL_OPENGL_BIT])
-    elif config.opengl_api == "gles":
+    elif config.api == GraphicsAPI.OPENGL_ES_2:
+        attrs.extend([egl.EGL_RENDERABLE_TYPE, egl.EGL_OPENGL_ES2_BIT])
+    elif config.api == GraphicsAPI.OPENGL_ES_3:
         attrs.extend([egl.EGL_RENDERABLE_TYPE, egl.EGL_OPENGL_ES3_BIT])
     else:
-        msg = f"Unknown OpenGL API: {config.opengl_api}"
+        msg = f"Unknown OpenGL API: {config.api}"
         raise ValueError(msg)
 
     attrs.extend([egl.EGL_NONE])
@@ -65,7 +68,7 @@ def match(config: OpenGLConfig, window: HeadlessWindow | WaylandWindow) -> EGLSu
     configs = (egl.EGLConfig * num_config.value)()
     egl.eglChooseConfig(display_connection, attrs_list, configs, num_config.value, byref(num_config))
 
-    result = [EGLSurfaceConfig(window, c, config) for c in configs]
+    result = [EGLSurfaceConfig(window, config, c) for c in configs]
     return result[0]
 
 
@@ -85,14 +88,14 @@ class EGLSurfaceConfig(SurfaceConfig):
         'samples': egl.EGL_SAMPLES,
     }
 
-    def __init__(self, window: HeadlessWindow | WaylandWindow, egl_config: egl.EGLConfig, config: OpenGLConfig) -> None:
+    def __init__(self, window: HeadlessWindow | WaylandWindow, config: OpenGLUserConfig, egl_config: egl.EGLConfig) -> None:
         super().__init__(window, config, egl_config)
         self._egl_config = egl_config
 
         context_attribs = [egl.EGL_CONTEXT_MAJOR_VERSION, config.major_version or 2,
                            egl.EGL_CONTEXT_MINOR_VERSION, config.minor_version or 0]
 
-        if config.opengl_api == "gl" and config.forward_compatible:
+        if config.api == GraphicsAPI.OPENGL and config.forward_compatible:
             context_attribs.extend([egl.EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE, 1])
 
         if config.debug:

pyglet/config/gl/macos.py

@@ -6,12 +6,11 @@ from dataclasses import asdict
 from ctypes import byref, c_uint32, c_int
 
 from pyglet.config.gl import GLSurfaceConfig
-
 from pyglet.libs.darwin import cocoapy, quartz
 
 from typing import TYPE_CHECKING
 if TYPE_CHECKING:
-    from pyglet.config import OpenGLConfig
+    from pyglet.config import OpenGLUserConfig
     from pyglet.graphics.api.gl.cocoa.context import NSOpenGLPixelFormat, CocoaContext
     from pyglet.window.cocoa import CocoaWindow
     from pyglet.graphics.api import OpenGLBackend
@@ -41,7 +40,7 @@ catalina:       19.0 -> 19.6
 big_sur:        20.0 ->
 """
 
-os_x_release: dict[str, tuple[float] | tuple[float, float] | tuple[float, float, float]] = {
+os_x_release: dict[str, tuple[float, ...]] = {
     'pre-release': (0, 1),
     'kodiak': (1, 2, 1),
     'cheetah': (1, 3, 1),
@@ -64,13 +63,13 @@ os_x_release: dict[str, tuple[float] | tuple[float, float] | tuple[float, float,
 }
 
 
-def os_x_version() -> tuple[int, ...] | tuple[tuple[int, ...]]:
+def os_x_version() -> tuple[int, ...]:
     version = tuple([int(v) for v in platform.release().split('.')])
 
     # ensure we return a tuple
     if len(version) > 0:
         return version
-    return (version,)
+    return (0,)
 
 
 _os_x_version = os_x_version()
@@ -132,7 +131,7 @@ _fake_gl_attributes = {
 }
 
 
-def match(config: OpenGLConfig, window: CocoaWindow) -> CocoaGLSurfaceConfig | None:
+def match(config: OpenGLUserConfig, window: CocoaWindow) -> CocoaGLSurfaceConfig | None:
     # Construct array of attributes for NSOpenGLPixelFormat
     attrs = []
     for name, value in asdict(config).items():
@@ -199,7 +198,7 @@ def match(config: OpenGLConfig, window: CocoaWindow) -> CocoaGLSurfaceConfig | N
 
 class CocoaGLSurfaceConfig(GLSurfaceConfig):
 
-    def __init__(self, window: CocoaWindow, config: OpenGLConfig, pixel_format: NSOpenGLPixelFormat) -> None:
+    def __init__(self, window: CocoaWindow, config: OpenGLUserConfig, pixel_format: NSOpenGLPixelFormat) -> None:
         super().__init__(window, config, pixel_format)
         self._pixel_format = pixel_format
 

pyglet/config/gl/webgl.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from dataclasses import asdict
+from pyglet.config import SurfaceConfig, WebGLUserConfig
+
+if TYPE_CHECKING:
+    from pyglet.window import BaseWindow, Any
+
+
+def match(config: WebGLUserConfig, window: BaseWindow) -> WebGLSurfaceConfig:
+    return WebGLSurfaceConfig(window, config, None)
+
+
+class WebGLSurfaceConfig(SurfaceConfig):
+    def __init__(self, window: BaseWindow, config: WebGLUserConfig, handle=None):
+        for name, value in asdict(config).items():
+            setattr(self, name, value)
+        super().__init__(window, config, handle)
+
+    @property
+    def attributes(self) -> dict[str, Any]:
+        # Only return the WebGL specific attributes
+        return asdict(self.config)

pyglet/config/gl/windows.py

@@ -13,7 +13,7 @@ from pyglet.libs.win32.wgl import WGLFunctions
 from pyglet.util import asstr
 
 if TYPE_CHECKING:
-    from pyglet.config import OpenGLConfig
+    from pyglet.config import OpenGLUserConfig
     from pyglet.window.win32 import Win32Window
     from pyglet.graphics.api import OpenGLBackend
     from pyglet.graphics.api.gl.win32.context import Win32ARBContext, Win32Context
@@ -99,7 +99,7 @@ class _WGL:
 # A global WGL instance object that has retrieved all the proc addresses for WGL functions.
 _global_wgl = _WGL()
 
-def match(config: OpenGLConfig, window: Win32Window) -> GLSurfaceConfig | None:
+def match(config: OpenGLUserConfig, window: Win32Window) -> GLSurfaceConfig | None:
     if not _global_wgl.loaded:
         _global_wgl.create()
 
@@ -110,7 +110,7 @@ def match(config: OpenGLConfig, window: Win32Window) -> GLSurfaceConfig | None:
 
     return finalized_config
 
-def _get_pixel_format_descriptor_matching_configs(config: OpenGLConfig, window: Win32Window) -> GLLegacyConfig | None:
+def _get_pixel_format_descriptor_matching_configs(config: OpenGLUserConfig, window: Win32Window) -> GLLegacyConfig | None:
     """Get matching configs using standard PIXELFORMATDESCRIPTOR technique."""
     pfd = PIXELFORMATDESCRIPTOR()
     pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR)
@@ -152,7 +152,7 @@ def _get_pixel_format_descriptor_matching_configs(config: OpenGLConfig, window:
 
     return None
 
-def _get_arb_pixel_format_matching_configs(config: OpenGLConfig, window: Win32Window) -> GLSurfaceConfig | None:
+def _get_arb_pixel_format_matching_configs(config: OpenGLUserConfig, window: Win32Window) -> GLSurfaceConfig | None:
     """Get configs using the WGL_ARB_pixel_format extension.
 
     This method assumes a (dummy) GL context is already created.
@@ -187,7 +187,7 @@ def _get_arb_pixel_format_matching_configs(config: OpenGLConfig, window: Win32Wi
 
 
 class GLLegacyConfig(GLSurfaceConfig):
-    def __init__(self, window: Win32Window, pf: int, user_config: OpenGLConfig) -> None:
+    def __init__(self, window: Win32Window, pf: int, user_config: OpenGLUserConfig) -> None:
         super().__init__(window, user_config, pf)
         self._pf = pf
         self._pfd = PIXELFORMATDESCRIPTOR()
@@ -239,7 +239,7 @@ class GLSurfaceConfig(GLSurfaceConfig):
         'accum_alpha_size': wglext_arb.WGL_ACCUM_ALPHA_BITS_ARB,
     }
 
-    def __init__(self, window: Win32Window, pf: int, user_config: OpenGLConfig) -> None:
+    def __init__(self, window: Win32Window, pf: int, user_config: OpenGLUserConfig) -> None:
         super().__init__(window, user_config, pf)
         self._pf = pf
 

pyglet/config/gl/x11.py

@@ -13,12 +13,12 @@ from pyglet.config import SurfaceConfig
 if TYPE_CHECKING:
     from pyglet.graphics.api.gl.xlib.context import XlibContext
     from pyglet.graphics.api import OpenGLBackend
-    from pyglet.config import OpenGLConfig
+    from pyglet.config import OpenGLUserConfig
     from pyglet.graphics.api.gl.xlib import glx_info
     from pyglet.window.xlib import XlibWindow
 
 
-def match(config: OpenGLConfig, window: XlibWindow) -> XlibGLSurfaceConfig | None:
+def match(config: OpenGLUserConfig, window: XlibWindow) -> XlibGLSurfaceConfig | None:
     x_display = window._x_display  # noqa: SLF001
     x_screen = window._x_screen_id  # noqa: SLF001
 
@@ -96,7 +96,7 @@ class XlibGLSurfaceConfig(SurfaceConfig):
     }
 
     def __init__(self, window: XlibWindow, fbconfig: glx.GLXFBConfig,
-                 config: OpenGLConfig) -> None:
+                 config: OpenGLUserConfig) -> None:
         super().__init__(window, config, fbconfig)
 
         self.fbconfig = fbconfig
@@ -122,7 +122,7 @@ class XlibGLSurfaceConfig(SurfaceConfig):
         if not XRenderFindVisualFormat:
             return False
 
-        xrender_format = XRenderFindVisualFormat(self.canvas.display._display, visual)
+        xrender_format = XRenderFindVisualFormat(self.display._display, visual)
         return xrender_format and xrender_format.contents.direct.alphaMask != 0
 
     def get_visual_info(self) -> glx.XVisualInfo:

pyglet/customtypes.py

@@ -18,6 +18,8 @@ AnchorX = Literal["left", "center", "right"]
 AnchorY = Literal["top", "bottom", "center", "baseline"]
 ContentVAlign = Literal["bottom", "center", "top"]
 
+MediaTypes = Literal["audio", "video", "image"]
+
 Number = Union[int, float]
 
 RGBColor = Tuple[Number, Number, Number]
@@ -59,6 +61,7 @@ __all__ = [
     "ContentVAlign",
     "DataTypes",
     "HorizontalAlign",
+    "MediaTypes",
     "RGBAColor",
     "RGBColor",
 ]

pyglet/display/base.py

@@ -18,7 +18,7 @@ class Display:
     x_screen: int = None
     """The X11 screen number of this display, if applicable."""
 
-    def __init__(self, name: str = None, x_screen: int = None) -> None:
+    def __init__(self, name: str | None = None, x_screen: int | None = None) -> None:
         """Create a display connection for the given name and screen.
 
         On X11, :attr:`name` is of the form ``"hostname:display"``, where the