pyglet 2.1.13__py3-none-any.whl → 3.0.dev1__py3-none-any.whl

pyglet/__init__.py

@@ -7,15 +7,16 @@ from __future__ import annotations
 import os
 import sys
 import warnings
-from collections.abc import Sequence
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Literal
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Literal, Sequence
+
 if TYPE_CHECKING:
     from types import FrameType
     from typing import Any, Callable, ItemsView, Sized
 
 #: The release version
-version = '2.1.13'
+version = '3.0.dev1'
 __version__ = version
 
 MIN_PYTHON_VERSION = 3, 8
@@ -42,6 +43,18 @@ if compat_platform == "cygwin":
     ctypes.HRESULT = ctypes.c_long
 
 
+@dataclass
+class PyodideOptions:
+    """Dataclass for Pyodide related options."""
+
+    canvas_id: str = "pygletCanvas"
+    """Pyglet will need to target a specific canvas ID to use for javascript canvas detection.
+
+    If the ID is not detected, a canvas will be created with the above. If you have a canvas already embedded in your
+    page, and do not want to alter your code, then modify this option.
+    """
+
+
 @dataclass
 class Options:
     """Dataclass for global pyglet options."""
@@ -65,7 +78,7 @@ class Options:
     debug_font: bool = False
     """If ``True``, will print more verbose information when :py:class:`~pyglet.font.base.Font`'s are loaded."""
 
-    debug_gl: bool = True
+    debug_api: bool = True
     """If ``True``, all calls to OpenGL functions are checked afterwards for
      errors using ``glGetError``.  This will severely impact performance,
      but provides useful exceptions at the point of failure.  By default,
@@ -73,22 +86,22 @@ class Options:
      with the -O option).  It is disabled by default when pyglet is "frozen", such as
      within pyinstaller or nuitka."""
 
-    debug_gl_trace: bool = False
+    debug_api_trace: bool = False
     """If ``True``, will print the names of OpenGL calls being executed. For example, ``glBlendFunc``"""
 
-    debug_gl_trace_args: bool = False
+    debug_api_trace_args: bool = False
     """If ``True``, in addition to printing the names of OpenGL calls, it will also print the arguments passed
     into those calls. For example, ``glBlendFunc(770, 771)``
 
-    .. note:: Requires ``debug_gl_trace`` to be enabled."""
+    .. note:: Requires ``debug_api_trace`` to be enabled."""
 
-    debug_gl_shaders: bool = False
+    debug_api_shaders: bool = False
     """If ``True``, prints shader compilation information such as creation and deletion of shader's. Also includes
     information on shader ID's, attributes, and uniforms."""
 
     debug_graphics_batch: bool = False
     """If ``True``, prints batch information being drawn, including :py:class:`~pyglet.graphics.Group`'s, VertexDomains,
-    and :py:class:`~pyglet.image.Texture` information. This can be useful to see how many Group's are being
+    and :py:class:`~pyglet.graphics.Texture` information. This can be useful to see how many Group's are being
     consolidated."""
 
     debug_lib: bool = False
@@ -97,19 +110,11 @@ class Options:
     debug_media: bool = False
     """If ``True``, prints more detailed media information for audio codecs and drivers. Will be very verbose."""
 
-    debug_texture: bool = False
-    """If ``True``, prints information on :py:class:`~pyglet.image.Texture` size (in bytes) when they are allocated and
-    deleted."""
-
     debug_trace: bool = False
     debug_trace_args: bool = False
     debug_trace_depth: int = 1
     debug_trace_flush: bool = True
 
-    debug_com: bool = False
-    """If ``True``, prints information on COM calls. This can potentially help narrow down issues with certain libraries
-    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 gets information from
     ``Kernel32.GetLastError``. This information is output to a file called ``debug_win32.log``."""
@@ -121,21 +126,12 @@ class Options:
     """If ``True``, prints information related to Linux X11 calls. This can potentially help narrow down driver or
     operating system issues."""
 
-    shadow_window: bool = True
-    """By default, pyglet creates a hidden window with a GL context when
-     pyglet.gl is imported.  This allows resources to be loaded before
-     the application window is created, and permits GL objects to be
-     shared between windows even after they've been closed.  You can
-     disable the creation of the shadow window by setting this option to
-     False.
-
-     Some OpenGL driver implementations may not support shared OpenGL
-     contexts and may require disabling the shadow window (and all resources
-     must be loaded after the window using them was created).  Recommended
-     for advanced developers only.
+    debug_wayland: bool = False
+    """If ``True``, prints information related to communications with the Wayland compositor."""
 
-     .. versionadded:: 1.1
-     """
+    debug_com: bool = False
+    """If ``True``, prints information on COM calls. This can potentially help narrow down issues with certain libraries
+    that utilize COM calls. Only applies to the Windows platform."""
 
     vsync: bool | None = None
     """If set, the `pyglet.window.Window.vsync` property is ignored, and
@@ -187,7 +183,7 @@ class Options:
     """
 
     headless_device: int = 0
-    """If using ``headless`` mode (``pyglet.options['headless'] = True``), this option allows you to set which
+    """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.
     """
 
@@ -255,41 +251,28 @@ class Options:
 
     .. versionadded:: 2.0.5"""
 
-    dpi_scaling: Literal["real", "scaled", "stretch", "platform"] = "platform"
+    dpi_scaling: Literal["platform", "stretch"] = "platform"
     """For 'HiDPI' displays, Window behavior can differ between operating systems. Defaults to `'platform'`.
 
     The current options are an attempt to create consistent behavior across all of the operating systems.
 
-    `'real'` (default): Provides a 1:1 pixel for Window frame size and framebuffer. Primarily used for game applications
-    to ensure you are getting the exact pixels for the resolution. If you provide an 800x600 window, you can ensure it
-    will be 800x600 pixels when the user chooses it.
+    `'platform'`: A DPI aware window is created. Framebuffer and window sizes are dictated by the platform the window
+    was created on. In most systems, the window size will be in DIPs (Device Independent Pixels). It is up to the user
+    to make any further adjustments to the framebuffer or window size for their application.
 
-    `'scaled'`: Window size is scaled based on the DPI ratio. Window size and content (projection) size matches the full
-    framebuffer. Primarily used for any applications that wish to become DPI aware. You must rescale and reposition your
-    content to take advantage of the larger framebuffer. An 800x600 with a 150% DPI scaling would be changed to
-    1200x900 for both `window.get_size` and `window.get_framebuffer_size()`.
+    On Windows and X11, the framebuffer and the requested window size will always match 1:1. On MacOS, depending
+    on a Hi-DPI display, you may get a larger sized framebuffer than the window size.
 
-    Keep in mind that pyglet objects may not be scaled proportionately, so this is left up to the developer.
-    The :py:attr:`~pyglet.window.Window.scale` & :py:attr:`~pyglet.window.Window.dpi` attributes can be queried as a
-    reference when determining object creation.
-
-    `'stretch'`:  Window is scaled based on the DPI ratio. However, content size matches original requested size of the
-    window, and is stretched to fit the full framebuffer. This mimics behavior of having no DPI scaling at all. No
-    rescaling and repositioning of content will be necessary, but at the cost of blurry content depending on the extent
-    of the stretch. For example, 800x600 at 150% DPI will be 800x600 for `window.get_size()` and 1200x900 for
+    `'stretch'`:  This mimics behavior of having no DPI scaling at all. Window is scaled based on the DPI ratio.
+    However, content size matches original requested size of the window, and is stretched to fit the full framebuffer.
+    No rescaling and repositioning of content will be necessary, but at the cost of blurry content depending on the
+    extent of the stretch. For example, 800x600 at 150% DPI will be 800x600 for `window.get_size()` and 1200x900 for
     `window.get_framebuffer_size()`.
-
-    `'platform'`: A DPI aware window is created, however window sizing and framebuffer sizing is not interfered with
-    by Pyglet. Final sizes are dictated by the platform the window was created on. It is up to the user to make any
-    platform adjustments themselves such as sizing on a platform, mouse coordinate adjustments, or framebuffer size
-    handling. On Windows and X11, the framebuffer and the requested window size will always match in pixels 1:1. On
-    MacOS, depending on a Hi-DPI display, you may get a different sized framebuffer than the window size. This option
-    does allow `window.dpi` and `window.scale` to return their respective values.
     """
 
     shader_bind_management: bool = True
     """If ``True``, this will enable internal management of Uniform Block bindings for
-     :py:class:`~pyglet.graphics.shader.ShaderProgram`'s.
+     :py:class:`~pyglet.graphics.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``.
@@ -297,6 +280,27 @@ class Options:
     .. versionadded:: 2.0.16
     """
 
+    wayland: bool = False
+    """If ``True``, use Wayland instead of Xlib on Linux.
+
+    .. versionadded:: 3.0.0
+    """
+
+    backend: Literal["opengl", "gl2", "gles3", "gles2", "webgl"] = "opengl"
+    """Specify the graphics API backend."""
+
+    optimize_states: bool = True
+    """Runs a second pass on the draw list to remove any redundant states.
+
+    This option is mostly meant for debugging, as this should not significantly impact the draw list creation time
+    or impact drawing states.
+
+    .. versionadded:: 3.0.0
+    """
+
+    pyodide: PyodideOptions = field(default_factory=PyodideOptions)
+    """Pyodide specific options."""
+
     def get(self, item: str, default: Any = None) -> Any:
         return self.__dict__.get(item, default)
 
@@ -323,7 +327,7 @@ for _option_name, _type_str in options.__annotations__.items():
             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:
+        elif 'str' in _type_str or ('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}")
@@ -434,7 +438,7 @@ class _ModuleProxy:
     def __init__(self, name: str) -> None:
         self.__dict__["_module_name"] = name
 
-    def __getattr__(self, name: str): # noqa: ANN204
+    def __getattr__(self, name: str):  # noqa: ANN204
         try:
             return getattr(self._module, name)
         except AttributeError:
@@ -468,11 +472,12 @@ if TYPE_CHECKING:
     from . import (
         app,
         clock,
+        config,
         customtypes,
         display,
+        enums,
         event,
         font,
-        gl,
         graphics,
         gui,
         image,
@@ -489,12 +494,13 @@ if TYPE_CHECKING:
     )
 else:
     app = _ModuleProxy("app")  # type: ignore
+    config = _ModuleProxy("config")  # type: ignore
     clock = _ModuleProxy("clock")  # type: ignore
     customtypes = _ModuleProxy("customtypes")  # type: ignore
     display = _ModuleProxy("display")  # type: ignore
+    enums = _ModuleProxy("enums")   # type: ignore
     event = _ModuleProxy("event")  # type: ignore
     font = _ModuleProxy("font")  # type: ignore
-    gl = _ModuleProxy("gl")  # type: ignore
     graphics = _ModuleProxy("graphics")  # type: ignore
     gui = _ModuleProxy("gui")  # type: ignore
     image = _ModuleProxy("image")  # type: ignore

pyglet/__init__.pyi

@@ -4,11 +4,11 @@ from typing import Any, ItemsView, Literal, Sequence
 
 from . import app as app
 from . import clock as clock
+from . import config as config
 from . import customtypes as customtypes
 from . import display as display
 from . import event as event
 from . import font as font
-from . import gl as gl
 from . import graphics as graphics
 from . import gui as gui
 from . import image as image
@@ -30,18 +30,21 @@ compat_platform: str
 env: str
 value: str
 
+@dataclass
+class PyodideOptions:
+    canvas_id: 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_api: bool
+    debug_api_trace: bool
+    debug_api_trace_args: bool
+    debug_api_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
@@ -49,8 +52,8 @@ class Options:
     debug_win32: bool
     debug_input: bool
     debug_x11: bool
+    debug_wayland: bool
     debug_com: bool
-    shadow_window: bool
     vsync: bool | None
     xsync: bool
     xlib_fullscreen_override_redirect: bool
@@ -64,8 +67,12 @@ class Options:
     win32_disable_xinput: bool
     com_mta: bool
     osx_alt_loop: bool
-    dpi_scaling: Literal["real", "scaled", "stretch"]
+    dpi_scaling: Literal["platform", "stretch"]
     shader_bind_management: bool
+    wayland: bool
+    backend: str | None
+    optimize_states: bool
+    pyodide: PyodideOptions
 
     def get(self, item: str, default: Any = None) -> Any:
         ...

pyglet/app/__init__.py

@@ -3,8 +3,8 @@
 Applications
 ------------
 
-Most applications need only call :func:`run` after creating one or more 
-windows to begin processing events.  For example, a simple application 
+Most applications need only call :func:`run` after creating one or more
+windows to begin processing events.  For example, a simple application
 consisting of one window is::
 
     import pyglet
@@ -28,18 +28,17 @@ default policy is to wait until all windows are closed)::
 
 .. versionadded:: 1.1
 """
+
 from __future__ import annotations
 
+import platform
 import sys
 import weakref
-import platform
 
 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:
@@ -47,15 +46,16 @@ 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
 
-        # 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:
+        if platform.machine() == 'arm64' 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
-    else:
-        from pyglet.app.xlib import XlibEventLoop as PlatformEventLoop
+    elif compat_platform == 'linux':
+        from pyglet.app.linux import LinuxEventLoop as PlatformEventLoop
+    elif compat_platform == 'emscripten':
+        from pyglet.app.async_app import AsyncEventLoop as EventLoop
+        from pyglet.app.async_app import AsyncPlatformEventLoop as PlatformEventLoop
 
 
 class AppException(Exception):
@@ -78,7 +78,11 @@ def run(interval: float | None = 1 / 60) -> None:
         pyglet.app.event_loop.run(interval)
 
     """
-    event_loop.run(interval)
+    if pyglet.compat_platform == "emscripten":
+        import asyncio
+        asyncio.create_task(event_loop.run(interval))  # noqa: RUF006
+    else:
+        event_loop.run(interval)
 
 
 def exit() -> None:
@@ -93,11 +97,16 @@ def exit() -> None:
         pyglet.app.event_loop.exit()
 
     """
-    event_loop.exit()
+    if pyglet.compat_platform == "emscripten":
+        import asyncio
+
+        asyncio.create_task(event_loop.exit())
+    else:
+        event_loop.exit()
 
 
 #: The global event loop. Applications can replace this
-#: with their own subclass of :class:`EventLoop` before calling 
+#: with their own subclass of :class:`EventLoop` before calling
 #: :meth:`EventLoop.run`.
 event_loop = EventLoop()
 

pyglet/app/async_app.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+
+import asyncio
+import sys
+from typing import Any, Callable, TYPE_CHECKING
+
+import pyglet
+from pyglet import app, clock, event
+
+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
+try:
+    from js import requestAnimationFrame, performance
+    from pyodide.ffi import create_proxy
+except ImportError:
+    raise ImportError('Pyodide not available.')
+
+
+class AsyncEventLoop(event.EventDispatcher):
+    """Asyncio-based event loop for Pyglet."""
+
+    def __init__(self) -> None:
+        self._has_exit_event = asyncio.Event()
+        # Change the default clock to use the javascript performance timer.
+        self.clock = clock.Clock(self._get_js_time)
+        pyglet.clock.set_default(self.clock)
+        self.is_running = False
+        self._interval = None
+        self._last_ts = 0.0
+        self._frame_dt = 0.0
+
+        self._frame_future = None
+        self._frame_proxy = create_proxy(self._frame_cb)
+
+    def _get_js_time(self) -> float:
+        """Use Javascripts performance.now for the clock accuracy.
+
+        May not be needed, but just to be accurate.
+        """
+        return performance.now() / 1000
+
+    @staticmethod
+    def _redraw_windows(dt: float) -> None:
+        # Redraw all windows
+        for window in app.windows:
+            window.draw(dt)
+
+    def _frame_cb(self, ts: float) -> None:
+        """Callback for the requestAnimationFrame."""
+        now = ts / 1000.0
+        _frame_dt = now - self._last_ts
+
+        self._last_ts = now
+
+        if self._frame_future:
+            self._frame_future.set_result(_frame_dt)
+            self._frame_future = None
+
+    async def _next_animation_frame(self) -> float:
+        self._frame_future = asyncio.Future()
+        requestAnimationFrame(self._frame_proxy)
+        return await self._frame_future
+
+    async def draw_frame(self) -> None:
+        frame_dt = await self._next_animation_frame()
+        self._redraw_windows(frame_dt)
+
+    async def run(self, interval: float | None = 1/60) -> None:
+        try:
+            """Begin processing events asynchronously."""
+            self._interval = interval
+
+            self._has_exit_event.clear()
+            platform_event_loop = app.platform_event_loop
+
+            await platform_event_loop.start()
+            self.dispatch_event('on_enter')
+            self.is_running = True
+
+            # Use the browser's requestAnimationFrame for the loop if None is used.
+            if self._interval is None:
+                while not self._has_exit_event.is_set():
+                    await self.draw_frame()
+                    self.idle()  # Ticks clock and runs scheduled functions.
+                    await platform_event_loop.dispatch_posted_events()
+            else:
+                _schedule_rate = self._interval / 1000.0
+
+                # Separate draw loop so clock timeout doesn't block rendering if it's slower.
+                async def _draw_loop() -> None:
+                    while not self._has_exit_event.is_set():
+                        await self.draw_frame()
+
+                asyncio.create_task(_draw_loop())  # noqa: RUF006
+
+                while not self._has_exit_event.is_set():
+                    timeout = self.idle()
+                    await platform_event_loop.dispatch_posted_events()
+                    await asyncio.sleep(0 if timeout is None else timeout)
+
+            self.is_running = False
+            self.dispatch_event('on_exit')
+            await platform_event_loop.stop()
+        except Exception as err:
+            import traceback
+            print("Error in wrapped task", err)
+            traceback.print_exc()
+
+    async def enter_blocking(self) -> None:
+        """Ensure `idle()` continues to be called during blocking operations."""
+        timeout = self.idle()
+        await app.platform_event_loop.set_timer(self._blocking_timer, timeout)
+
+    async def exit_blocking(self) -> None:
+        """Stop the blocking timer."""
+        await app.platform_event_loop.set_timer(None, None)
+
+    async def _blocking_timer(self) -> None:
+        """Called to process scheduled events during blocking operations."""
+        dt = self.clock.update_time()
+        self.clock.call_scheduled_functions(dt)
+        if self._interval is None:
+            self._redraw_windows(dt)
+
+        timeout = self.clock.get_sleep_time(True)
+        await app.platform_event_loop.set_timer(self._blocking_timer, timeout)
+
+    def idle(self) -> float | None:
+        """Called each iteration to process events."""
+        dt = self.clock.update_time()
+        self.clock.call_scheduled_functions(dt)
+        return self.clock.get_sleep_time(True)
+
+    async def exit(self) -> None:
+        """Exit the event loop asynchronously."""
+        self._has_exit_event.set()
+        app.platform_event_loop.notify()
+
+    async def sleep(self, timeout: float) -> bool:
+        """Pause execution for a given time unless `exit()` is called."""
+        try:
+            await asyncio.wait_for(self._has_exit_event.wait(), timeout)
+            return True
+        except asyncio.TimeoutError:
+            return False
+
+    async def on_window_close(self, _window: BaseWindow) -> None:
+        """Exit when the last window is closed."""
+        if len(app.windows) == 0:
+            await self.exit()
+
+AsyncEventLoop.register_event_type('on_window_close')
+AsyncEventLoop.register_event_type('on_enter')
+AsyncEventLoop.register_event_type('on_exit')
+
+class AsyncPlatformEventLoop:
+    """An asyncio-based platform event loop."""
+
+    def __init__(self) -> None:
+        """Initialize the event loop with an asyncio queue and event."""
+        self._event_queue = asyncio.Queue()
+        self._is_running = asyncio.Event()
+
+    def is_running(self) -> bool:
+        """Check if the event loop is currently processing."""
+        return self._is_running.is_set()
+
+    async def post_event(self, dispatcher: EventDispatcher, event: str, *args: Any) -> None:
+        """Post an event into the main application thread asynchronously."""
+        await self._event_queue.put((dispatcher, event, args))
+        self.notify()
+
+    async def dispatch_posted_events(self) -> None:
+        """Dispatch all pending events asynchronously."""
+        while not self._event_queue.empty():
+            try:
+                dispatcher, evnt, args = await self._event_queue.get()
+                dispatcher.dispatch_event(evnt, *args)
+            except asyncio.CancelledError:
+                break
+            except ReferenceError:
+                # weakly-referenced object no longer exists
+                pass
+
+    def notify(self) -> None:
+        """Trigger an iteration of the asyncio event loop."""
+        if self.is_running():
+            asyncio.create_task(self.dispatch_posted_events())
+
+    async def start(self) -> None:
+        """Start the asyncio-based event loop."""
+        self._is_running.set()
+
+    async def step(self, timeout: float | None = None) -> None:
+        """Run one iteration of the asyncio event loop with a timeout."""
+        try:
+            await asyncio.wait_for(self.dispatch_posted_events(), timeout)
+        except asyncio.TimeoutError:
+            pass
+
+    async def set_timer(self, func: Callable, interval: float) -> None:
+        """Schedule a timer function asynchronously."""
+        while self.is_running():
+            await asyncio.sleep(interval)
+            func()
+
+    async def stop(self) -> None:
+        """Stop the asyncio-based event loop."""
+        self._is_running.clear()

pyglet/app/base.py

@@ -152,7 +152,7 @@ class EventLoop(event.EventDispatcher):
 
         # Dispatch pending events
         for window in app.windows:
-            window.switch_to()
+            #window.switch_to()
             window.dispatch_pending_events()
 
         platform_event_loop = app.platform_event_loop
@@ -264,6 +264,7 @@ class EventLoop(event.EventDispatcher):
         interrupted (see :py:meth:`sleep`).
         """
         self.has_exit = True
+        self.clock.unschedule(self._redraw_windows)
         app.platform_event_loop.notify()
 
     def sleep(self, timeout: float) -> bool:

pyglet/app/{xlib.py → linux.py}

@@ -6,7 +6,7 @@ from pyglet import app
 from pyglet.app.base import PlatformEventLoop
 
 
-class XlibSelectDevice:
+class LinuxSelectDevice:
     def fileno(self):
         """Get the file handle for ``select()`` for this device.
 
@@ -31,7 +31,7 @@ class XlibSelectDevice:
         return False
 
 
-class NotificationDevice(XlibSelectDevice):
+class NotificationDevice(LinuxSelectDevice):
     def __init__(self):
         self._sync_file_read, self._sync_file_write = os.pipe()
         self._event = threading.Event()
@@ -52,7 +52,7 @@ class NotificationDevice(XlibSelectDevice):
         return self._event.is_set()
 
 
-class XlibEventLoop(PlatformEventLoop):
+class LinuxEventLoop(PlatformEventLoop):
     def __init__(self):
         super().__init__()
         self._notification_device = NotificationDevice()