pyglet 3.0.dev10__py3-none-any.whl → 3.0.dev12__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,10 +20,10 @@ if TYPE_CHECKING:
     from typing import Any, Callable, ItemsView, Sized
 
 #: The release version
-version = '3.0.dev10'
+version = '3.0.dev12'
 __version__ = version
 
-MIN_PYTHON_VERSION = 3, 10
+MIN_PYTHON_VERSION = 3, 11
 MIN_PYTHON_VERSION_STR = ".".join([str(v) for v in MIN_PYTHON_VERSION])
 
 #: The Pyodide release used to develop and test pyglet's browser support.

pyglet/__init__.pyi

@@ -1,6 +1,9 @@
 
 from dataclasses import dataclass
 from typing import Any, ItemsView, Literal, Sequence
+from .enums import GraphicsAPI
+
+def _install_trace() -> None: ...
 
 from . import app as app
 from . import clock as clock
@@ -24,6 +27,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
@@ -72,7 +77,7 @@ class Options:
     dpi_scaling: Literal["platform", "stretch"]
     shader_bind_management: bool
     wayland: bool
-    backend: str | None
+    backend: Literal['opengl', 'gl2', 'gles3', 'gles2', 'webgl'] | GraphicsAPI
     optimize_states: bool
     opengl_persistent_buffers: bool
     pyodide: PyodideOptions

pyglet/app/__init__.py

@@ -31,17 +31,21 @@ default policy is to wait until all windows are closed)::
 
 from __future__ import annotations
 
-import platform
 import sys
+import signal
+import platform
 import weakref
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pyglet.window import BaseWindow
 
 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 TYPE_CHECKING or pyglet.IS_DOC_BUILD:
     from pyglet.app.base import PlatformEventLoop
 else:
     if compat_platform == 'darwin':
@@ -67,7 +71,7 @@ class AppException(Exception):
     pass
 
 
-windows = weakref.WeakSet()
+windows: weakref.WeakSet[BaseWindow] = weakref.WeakSet()
 """Set of all open windows (including invisible windows).  Instances of
 :class:`pyglet.window.Window` are automatically added to this set upon 
 construction. The set uses weak references, so windows are removed from 
@@ -82,7 +86,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)
 
 
@@ -108,4 +116,4 @@ event_loop = EventLoop()
 
 #: The platform-dependent event loop. Applications are strongly discouraged
 #: from subclassing or replacing this :class:`PlatformEventLoop` object.
-platform_event_loop = PlatformEventLoop()
+platform_event_loop: PlatformEventLoop = PlatformEventLoop()

pyglet/app/async_app.py

@@ -4,13 +4,15 @@ from __future__ import annotations
 import asyncio
 from contextlib import suppress
 import sys
-from typing import Any, Callable, TYPE_CHECKING
+from typing import Any, TYPE_CHECKING
 
 import pyglet
 from pyglet import app, clock, event
 from pyglet.app.base import ClockWindowDrawSource, WindowDrawSource
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     from pyglet.event import EventDispatcher
     from pyglet.window import BaseWindow
 
@@ -22,13 +24,57 @@ except ImportError as exc:
 from pyglet.libs.emscripten.proxies import ProxyRegistry
 
 
+class _AsyncClock(clock.Clock):
+    """Wake the event loop when new clock work is due sooner."""
+
+    def __init__(self, time_function: Callable[[], float], on_schedule: Callable[[float | None], None]) -> None:
+        """Bind the clock to the event loop's deadline notification callback."""
+        super().__init__(time_function)
+        self._schedule_callback = on_schedule
+
+    def _next_interval_deadline(self) -> float:
+        if self._schedule_interval_items:
+            return self._schedule_interval_items[0].next_ts
+        return float('inf')
+
+    def _notify_earlier_deadline(self, previous_deadline: float) -> None:
+        deadline = self._next_interval_deadline()
+        if deadline < previous_deadline:
+            self._schedule_callback(deadline)
+
+    def schedule(self, func: Callable, *args: Any, **kwargs: Any) -> None:
+        super().schedule(func, *args, **kwargs)
+        self._schedule_callback(None)
+
+    def schedule_once(self, func: Callable, delay: float, *args: Any, **kwargs: Any) -> None:
+        previous_deadline = self._next_interval_deadline()
+        super().schedule_once(func, delay, *args, **kwargs)
+        self._notify_earlier_deadline(previous_deadline)
+
+    def schedule_interval(self, func: Callable, interval: float, *args: Any, **kwargs: Any) -> None:
+        previous_deadline = self._next_interval_deadline()
+        super().schedule_interval(func, interval, *args, **kwargs)
+        self._notify_earlier_deadline(previous_deadline)
+
+    def schedule_interval_fixed_delay(self, func: Callable, interval: float, *args: Any, **kwargs: Any) -> None:
+        previous_deadline = self._next_interval_deadline()
+        super().schedule_interval_fixed_delay(func, interval, *args, **kwargs)
+        self._notify_earlier_deadline(previous_deadline)
+
+    def schedule_interval_soft(self, func: Callable, interval: float, *args: Any, **kwargs: Any) -> None:
+        previous_deadline = self._next_interval_deadline()
+        super().schedule_interval_soft(func, interval, *args, **kwargs)
+        self._notify_earlier_deadline(previous_deadline)
+
+
 class AsyncEventLoop(event.EventDispatcher):
     """Browser event loop which preserves pyglet's normal clock semantics."""
 
     def __init__(self) -> None:
         """Create the browser clock and callback state."""
         self._has_exit_event = asyncio.Event()
-        self.clock = clock.Clock(self._get_js_time)
+        self._clock_wait_deadline: float | None = None
+        self.clock = _AsyncClock(self._get_js_time, self._on_clock_schedule)
         pyglet.clock.set_default(self.clock)
         self.is_running = False
         self._interval: float | None = None
@@ -36,6 +82,12 @@ class AsyncEventLoop(event.EventDispatcher):
         self._window_draw_source: WindowDrawSource | None = None
         self._window_draw_exception: tuple[type[BaseException], BaseException, Any] | None = None
 
+    def _on_clock_schedule(self, next_ts: float | None) -> None:
+        """Wake the loop if new work is due before its next wakeup."""
+        deadline = self._clock_wait_deadline
+        if deadline is not None and (next_ts is None or next_ts < deadline):
+            app.platform_event_loop.notify()
+
     def _get_js_time(self) -> float:
         """Use Javascripts performance.now for the clock accuracy.
 
@@ -51,7 +103,7 @@ class AsyncEventLoop(event.EventDispatcher):
         try:
             window.draw(dt)
         except BaseException:  # noqa: BLE001 - JS callbacks cannot unwind Python exceptions.
-            self._window_draw_exception = sys.exc_info()
+            self._window_draw_exception = sys.exc_info()  # type: ignore[assignment]
             self.exit()
 
     def _raise_window_draw_exception(self) -> None:
@@ -104,6 +156,7 @@ class AsyncEventLoop(event.EventDispatcher):
         self._interval = interval
         self._has_exit_event.clear()
         platform_event_loop = app.platform_event_loop
+        assert isinstance(platform_event_loop, AsyncPlatformEventLoop)
 
         try:
             platform_event_loop.start()
@@ -113,7 +166,16 @@ class AsyncEventLoop(event.EventDispatcher):
 
             while not self._has_exit_event.is_set():
                 timeout = self.idle()
-                await platform_event_loop.wait(timeout)
+                # idle finishes before wait() yields, so its timeout includes
+                # any work scheduled during that clock tick.
+                if timeout is None:
+                    self._clock_wait_deadline = float('inf')
+                elif timeout > 0:
+                    self._clock_wait_deadline = self.clock.time() + timeout
+                try:
+                    await platform_event_loop.wait(timeout)
+                finally:
+                    self._clock_wait_deadline = None
                 platform_event_loop.dispatch_posted_events()
         finally:
             self.is_running = False
@@ -195,20 +257,21 @@ class AsyncPlatformEventLoop:
         self._is_running = True
 
     async def wait(self, timeout: float | None) -> None:
-        if not self._event_queue.empty():
-            return
-
+        # Keep a wakeup sent before the wait(), so the loop can process it now.
+        if self._event_queue.empty() and not self._wake_event.is_set():
+            if timeout is None:
+                await self._wake_event.wait()
+            elif timeout > 0:
+                # wait_for() uses call_at(); Pyodide rejects its deadline if
+                # it expires during timer setup. Keep the delay relative.
+                timer = asyncio.get_running_loop().call_later(timeout, self._wake_event.set)
+                try:
+                    await self._wake_event.wait()
+                finally:
+                    timer.cancel()
+            else:
+                await asyncio.sleep(0)
         self._wake_event.clear()
-        if not self._event_queue.empty():
-            return
-
-        if timeout is None:
-            await self._wake_event.wait()
-        elif timeout > 0:
-            with suppress(asyncio.TimeoutError):
-                await asyncio.wait_for(self._wake_event.wait(), timeout)
-        else:
-            await asyncio.sleep(0)
 
     async def step(self, timeout: float | None = None) -> None:
         await self.wait(timeout)

pyglet/app/base.py

@@ -5,18 +5,20 @@ import sys
 import threading
 from abc import ABC, abstractmethod
 from queue import Queue
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any, Callable, Generic, TypeVar
 
-from pyglet import app, clock, event
+from pyglet import app, clock, event, IS_DOC_BUILD
+from pyglet.customtypes import WindowT
 
 if TYPE_CHECKING:
+    from types import TracebackType
+
     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):
+class WindowDrawSource(ABC, Generic[WindowT]):
     """Control the source of automatic window draw opportunities.
 
     Application-driven backends (Win32 and X11) use
@@ -41,17 +43,20 @@ class WindowDrawSource(ABC):
     def stop(self) -> None:
         """Stop automatic drawing and release native resources."""
 
-    def add_window(self, window: BaseWindow) -> bool:
+    def add_window(self, window: WindowT) -> bool:
         """Add a window created while this source is running."""
         return True
 
-    def remove_window(self, window: BaseWindow) -> None:
+    def remove_window(self, window: WindowT) -> None:
         """Remove a window before its platform resources are destroyed."""
 
 
-class ClockWindowDrawSource(WindowDrawSource):
+class ClockWindowDrawSource(WindowDrawSource['BaseWindow']):
     """Application-driven drawing scheduled by the pyglet Clock."""
 
+    _clock: clock.Clock
+    _draw_windows: Callable[[float], None]
+
     def __init__(self, app_clock: clock.Clock, draw_windows: Callable[[float], None]) -> None:
         self._clock = app_clock
         self._draw_windows = draw_windows
@@ -67,12 +72,19 @@ class ClockWindowDrawSource(WindowDrawSource):
         self._clock.unschedule(self._draw_windows)
 
 
-class PlatformEventLoop:
+_EventLoopT = TypeVar('_EventLoopT', bound=event.EventDispatcher)
+
+
+class PlatformEventLoop(Generic[_EventLoopT]):
     """Abstract class, implementation depends on platform.
 
+    The type parameter identifies the application loop accepted by the
+    platform's window draw source.
+
     .. versionadded:: 1.2
     """
-    _event_queue: Queue[tuple[EventDispatcher, str, Any]]
+    _event_queue: Queue[tuple[EventDispatcher, str, tuple[Any, ...]]]
+    _is_running: threading.Event
 
     def __init__(self) -> None:  # noqa: D107
         self._event_queue = queue.Queue()
@@ -127,13 +139,13 @@ class PlatformEventLoop:
     def start(self) -> None:
         pass
 
-    def step(self, timeout: None | float = None) -> None:
+    def step(self, timeout: float | None = None) -> bool | None:
         raise NotImplementedError('abstract')
 
-    def set_timer(self, func: Callable, interval: float) -> None:
+    def set_timer(self, func: Callable[[], None] | None, interval: float | None) -> None:
         pass
 
-    def create_window_draw_source(self, event_loop: EventLoop) -> WindowDrawSource | None:
+    def create_window_draw_source(self, event_loop: _EventLoopT) -> WindowDrawSource[BaseWindow] | None:
         """Create a display-driven draw source, or return ``None``.
 
         Returning ``None`` selects application-driven Clock drawing.
@@ -159,7 +171,11 @@ class EventLoop(event.EventDispatcher):
     """
     _interval: float | None
     _has_exit_condition: threading.Condition
-    _has_exit = False
+    _has_exit: bool = False
+    _window_draw_source: WindowDrawSource[BaseWindow] | None
+    _window_draw_exception: tuple[type[BaseException] | None, BaseException | None, TracebackType | None] | None
+    clock: clock.Clock
+    is_running: bool
 
     def __init__(self) -> None:  # noqa: D107
         self._has_exit_condition = threading.Condition()
@@ -319,7 +335,7 @@ class EventLoop(event.EventDispatcher):
         timeout = self.clock.get_sleep_time(True)
         app.platform_event_loop.set_timer(self._blocking_timer, timeout)
 
-    def idle(self) -> None | float:
+    def idle(self) -> float | None:
         """Called during each iteration of the event loop.
 
         The method is called immediately after any window events (i.e., after
@@ -406,7 +422,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/app/cocoa.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import signal
 import time
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, cast
 
 import pyglet
 from pyglet import app
@@ -60,7 +60,7 @@ def create_menu():
         appMenuItem.release()
 
 
-class _AppDelegate(NSObject):
+class _AppDelegate(NSObject):  # type: ignore[valid-type, misc]
 
     @objc_method(b'@' + PyObjectEncoding)
     def init(self, pyglet_loop):
@@ -163,16 +163,20 @@ class CocoaAlternateEventLoop(EventLoop):
             self.platform_event_loop.nsapp_stop()
 
 
-class CocoaWindowDrawSource(WindowDrawSource):
+class CocoaWindowDrawSource(WindowDrawSource['CocoaWindow']):
     """Display driven drawing backed by one CADisplayLink."""
 
+    _active: bool
+    _interval: float | None
+
     def __init__(self) -> None:
         self._active = False
         self._interval = None
 
     def start(self, interval: float) -> bool:
-        started_windows = []
-        for window in app.windows:
+        started_windows: list[CocoaWindow] = []
+        for candidate in app.windows:
+            window = cast('CocoaWindow', candidate)
             if not window._start_display_link(interval):  # noqa: SLF001
                 for started_window in started_windows:
                     started_window._stop_display_link()  # noqa: SLF001
@@ -190,10 +194,10 @@ class CocoaWindowDrawSource(WindowDrawSource):
         self._active = False
         self._interval = None
         for window in app.windows:
-            window._stop_display_link()  # noqa: SLF001
+            cast('CocoaWindow', window)._stop_display_link()  # noqa: SLF001
 
     def add_window(self, window: CocoaWindow) -> bool:
-        return not self._active or window._start_display_link(self._interval)  # noqa: SLF001
+        return not self._active or (self._interval is not None and window._start_display_link(self._interval))  # noqa: SLF001
 
     def remove_window(self, window: CocoaWindow) -> None:
         window._stop_display_link()  # noqa: SLF001
@@ -251,7 +255,7 @@ class CocoaPlatformEventLoop(PlatformEventLoop):
                 self.NSApp.activateIgnoringOtherApps_(True)
                 self._finished_launching = True
 
-    def create_window_draw_source(self, _event_loop: EventLoop) -> WindowDrawSource | None:
+    def create_window_draw_source(self, event_loop: EventLoop) -> WindowDrawSource | None:  # noqa: ARG002
         if pyglet.options.osx_displaylink and self._display_link_supported:
             return CocoaWindowDrawSource()
         return None

pyglet/app/ios.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import os
+from typing import Any
 
 from pyglet import app
 from pyglet.app.base import EventLoop, PlatformEventLoop, WindowDrawSource
@@ -31,10 +32,10 @@ NSRunLoop = ObjCClass('NSRunLoop')
 CADisplayLink = ObjCClass('CADisplayLink')
 
 
-class _PygletIOSDisplayLinkTarget(NSObject):
+class _PygletIOSDisplayLinkTarget(NSObject):  # type: ignore[valid-type, misc]
 
     @objc_method(b'@' + PyObjectEncoding)
-    def initWithDrawSource_(self, draw_source: IOSDisplayLinkDrawSource) -> ObjCInstance | None:
+    def initWithDrawSource_(self: Any, draw_source: IOSDisplayLinkDrawSource) -> ObjCInstance | None:
         self = ObjCInstance(send_super(self, 'init'))
         if not self:
             return None
@@ -49,6 +50,10 @@ class _PygletIOSDisplayLinkTarget(NSObject):
 class IOSDisplayLinkDrawSource(WindowDrawSource):
     """One UIKit display link that paces all pyglet window drawing."""
 
+    _target: ObjCInstance | None
+    _display_link: ObjCInstance | None
+    _event_loop: IOSEventLoop
+
     def __init__(self, event_loop: IOSEventLoop) -> None:
         self._event_loop = event_loop
         self._display_link = None
@@ -98,7 +103,7 @@ class IOSDisplayLinkDrawSource(WindowDrawSource):
         self._last_timestamp, dt = get_display_link_dt(display_link, self._last_timestamp)
         self._event_loop._tick_app(dt)  # noqa: SLF001
 
-class IOSPlatformEventLoop(PlatformEventLoop):
+class IOSPlatformEventLoop(PlatformEventLoop['IOSEventLoop']):
     """Schedules pyglet work from UIKit's already-running main run loop."""
 
     def __init__(self) -> None:
@@ -116,7 +121,7 @@ class IOSPlatformEventLoop(PlatformEventLoop):
     def stop(self) -> None:
         self._is_running.clear()
 
-    def create_window_draw_source(self, event_loop: EventLoop) -> WindowDrawSource:
+    def create_window_draw_source(self, event_loop: IOSEventLoop) -> IOSDisplayLinkDrawSource:
         return IOSDisplayLinkDrawSource(event_loop)
 
 

pyglet/clock.py

@@ -1125,7 +1125,7 @@ def chain(
             raise TypeError(
                 msg,
             )
-        return Chain(generator, clock=clock)
+        return Chain(generator, clock=clock)  # type: ignore[arg-type]
 
     return wrapper
 

pyglet/config/__init__.py

@@ -2,7 +2,9 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, NamedTuple
+from typing import TYPE_CHECKING, NamedTuple, cast
+
+import pyglet
 
 from pyglet.enums import GraphicsAPI
 
@@ -10,7 +12,8 @@ from .base import SurfaceConfig, UserConfig  # noqa: TC001
 from .gl import OpenGLUserConfig, WebGLUserConfig
 
 if TYPE_CHECKING:
-    from pyglet.window import Window
+    from pyglet.window import BaseWindow
+    from pyglet.window.emscripten import EmscriptenWindow
 
 
 class Config:
@@ -23,19 +26,33 @@ class Config:
 
     __slots__ = 'gl2', 'gles2', 'gles3', 'opengl', 'vulkan', 'webgl'
 
-    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)
+    def __init__(self) -> None:  # noqa: D107
+        self.opengl: OpenGLUserConfig = OpenGLUserConfig(
+            double_buffer=True, depth_size=24, major_version=3, minor_version=3, api=GraphicsAPI.OPENGL,
+        )
+        self.gl2: OpenGLUserConfig = OpenGLUserConfig(
+            double_buffer=True, depth_size=24, major_version=2, minor_version=0, api=GraphicsAPI.OPENGL_2,
+        )
+        self.gles2: OpenGLUserConfig = OpenGLUserConfig(
+            double_buffer=True, depth_size=24, major_version=2, minor_version=0, api=GraphicsAPI.OPENGL_ES_2,
+        )
+        self.gles3: OpenGLUserConfig = OpenGLUserConfig(
+            double_buffer=True, depth_size=24, 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, (OpenGLUserConfig, WebGLUserConfig)):
+def match_surface_config(config: UserConfig, surface: BaseWindow) -> SurfaceConfig | None:
+    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, cast('EmscriptenWindow', surface))
+        return None
+
     msg = f"Matching for '{config.__class__}' is not yet implemented."
     raise NotImplementedError(msg)

pyglet/config/base.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
-from typing import Any, TYPE_CHECKING
+from typing import Any, Generic, TYPE_CHECKING
+
+from pyglet.customtypes import WindowT
 
 if TYPE_CHECKING:
-    from pyglet.window import Window
     from pyglet.enums import GraphicsAPI
 
 
@@ -16,12 +17,16 @@ class UserConfig:
         return False
 
 
-class SurfaceConfig:
+class SurfaceConfig(Generic[WindowT]):
     """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:
+    _window: WindowT
+    config: UserConfig
+    handle: Any
+
+    def __init__(self, window: WindowT, 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.

pyglet/config/gl/__init__.py

@@ -1,16 +1,35 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from typing import Any, TYPE_CHECKING, cast
 
 import pyglet
 
 from pyglet.enums import GraphicsAPI
 from pyglet.config.base import UserConfig, SurfaceConfig
+from pyglet.customtypes import WindowT
 
+if TYPE_CHECKING:
+    from pyglet.graphics.api.gl.context import OpenGLSurfaceContext
+    from pyglet.graphics.api.gl.global_opengl import OpenGLBackend
+    from pyglet.window import BaseWindow
+    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):
+
+class GLSurfaceConfig(SurfaceConfig[WindowT]):
     config: OpenGLUserConfig
 
+    def __init__(self, window: WindowT, config: OpenGLUserConfig, handle: Any) -> None:
+        super().__init__(window, config, handle)
+
+    def create_context(self, opengl_backend: OpenGLBackend, share: Any) -> OpenGLSurfaceContext:
+        raise NotImplementedError
+
 
 # Platform Specific Configurations
 
@@ -98,36 +117,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: BaseWindow) -> 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