More renames, removing inappropriate refs to wgpu

Author: almarklein

docs/conf.py

@@ -47,7 +47,7 @@
 intersphinx_mapping = {
     "python": ("https://docs.python.org/3", None),
     "numpy": ("https://numpy.org/doc/stable", None),
-    "wgpu": ("https://wgpu-py.readthedocs.io/en/latest", None),
+    "wgpu": ("https://wgpu-py.readthedocs.io/en/stable", None),
 }
 
 # Add any paths that contain templates here, relative to this directory.

docs/start.rst

@@ -25,6 +25,6 @@ GUI libraries
 Multiple GUI backends are supported, see :doc:`the GUI API <gui>` for details:
 
 * `glfw <https://github.com/FlorianRhiem/pyGLFW>`_: a lightweight GUI for the desktop
-* `jupyter_rfb <https://jupyter-rfb.readthedocs.io>`_: only needed if you plan on using wgpu in Jupyter
+* `jupyter_rfb <https://jupyter-rfb.readthedocs.io>`_: only needed if you plan on using Jupyter
 * qt (PySide6, PyQt6, PySide2, PyQt5)
 * wx

examples/events.py

@@ -5,7 +5,7 @@
 from rendercanvas.auto import RenderCanvas, run
 
 
-canvas = RenderCanvas(size=(640, 480), title="wgpu events")
+canvas = RenderCanvas(size=(640, 480), title="RenderCanvas events")
 
 
 @canvas.add_event_handler("*")

rendercanvas/_events.py

@@ -10,7 +10,7 @@ class EventType(BaseEnum):
 
     This includes the events from the jupyter_rfb event spec (see
     https://jupyter-rfb.readthedocs.io/en/stable/events.html) plus some
-    wgpu-specific events.
+    rendercanvas-specific events.
     """
 
     # Jupter_rfb spec
@@ -207,7 +207,7 @@ def emit(self, event):
             with log_exception(f"Error during handling {event_type} event"):
                 callback(event)
 
-    def _wgpu_close(self):
+    def _rc_close(self):
         """Wrap up when the scheduler detects the canvas is closed/dead."""
         # This is a little feature because detecting a widget from closing can be tricky.
         if not self._closed:

rendercanvas/_loop.py

@@ -135,7 +135,7 @@ def __init__(self):
         #   loop usually stops when the last window is closed, so the close event may
         #   not be fired.
         # * Keep the GUI going even when the canvas loop is on pause e.g. because its
-        #   minimized (applies to backends that implement _wgpu_gui_poll).
+        #   minimized (applies to backends that implement _rc_gui_poll).
         self._gui_timer = self._TimerClass(self, self._tick, one_shot=False)
 
     def _register_scheduler(self, scheduler):
@@ -145,7 +145,7 @@ def _register_scheduler(self, scheduler):
 
     def _tick(self):
         # Keep the GUI alive on every tick
-        self._wgpu_gui_poll()
+        self._rc_gui_poll()
 
         # Check all schedulers
         schedulers_to_close = []
@@ -235,7 +235,7 @@ def _call_soon(self, callback, *args):
         """
         self.call_later(0, callback, *args)
 
-    def _wgpu_gui_poll(self):
+    def _rc_gui_poll(self):
         """For the subclass to implement:
 
         Some event loops (e.g. asyncio) are just that and dont have a GUI to update.
@@ -343,7 +343,7 @@ def _get_canvas(self):
         canvas = self._canvas_ref()
         if canvas is None or canvas.is_closed():
             # Pretty nice, we can send a close event, even if the canvas no longer exists
-            self._events._wgpu_close()
+            self._events._rc_close()
             return None
         else:
             return canvas

rendercanvas/asyncio.py

@@ -10,7 +10,7 @@
 
 
 class AsyncioTimer(BaseTimer):
-    """Wgpu timer based on asyncio."""
+    """Timer based on asyncio."""
 
     _handle = None
 

rendercanvas/auto.py

@@ -14,7 +14,7 @@
 
 
 # Note that wx is not in here, because it does not (yet) fully implement base.BaseRenderCanvas
-WGPU_GUI_BACKEND_NAMES = ["glfw", "qt", "jupyter", "offscreen"]
+BACKEND_NAMES = ["glfw", "qt", "jupyter", "offscreen"]
 
 
 def _load_backend(backend_name):
@@ -30,7 +30,7 @@ def _load_backend(backend_name):
     elif backend_name == "offscreen":
         from . import offscreen as module
     else:  # no-cover
-        raise ImportError("Unknown wgpu gui backend: '{backend_name}'")
+        raise ImportError("Unknown rendercanvas backend: '{backend_name}'")
     return module
 
 
@@ -53,18 +53,18 @@ def select_backend():
 
     # Always report failed backends, because we only try them when it looks like we can.
     if failed_backends:
-        msg = "WGPU could not load some backends:"
+        msg = "rendercanvas could not load some backends:"
         for key, val in failed_backends.items():
             msg += f"\n{key}: {val}"
         logger.warning(msg)
 
     # Return or raise
     if module is not None:
         log = logger.warning if failed_backends else logger.info
-        log(f"WGPU selected {backend_name} gui because {reason}.")
+        log(f"Rendercanvas selected {backend_name} backend because {reason}.")
         return module
     else:
-        msg = "WGPU Could not load any of the supported GUI backends."
+        msg = "Rendercanvas could not load any of the supported backends."
         if "jupyter" in failed_backends:
             msg += "\n  You may need to ``pip install -U jupyter_rfb``."
         else:
@@ -94,9 +94,9 @@ def backends_by_env_vars():
     # Env var to force a backend for general use
     backend_name = os.getenv("WGPU_GUI_BACKEND", "").lower().strip() or None
     if backend_name:
-        if backend_name not in WGPU_GUI_BACKEND_NAMES:
+        if backend_name not in BACKEND_NAMES:
             logger.warning(
-                f"Ignoring invalid WGPU_GUI_BACKEND '{backend_name}', must be one of {WGPU_GUI_BACKEND_NAMES}"
+                f"Ignoring invalid WGPU_GUI_BACKEND '{backend_name}', must be one of {BACKEND_NAMES}"
             )
             backend_name = None
     if backend_name:

rendercanvas/base.py

@@ -173,7 +173,7 @@ def _process_events(self):
         # Get events from the GUI into our event mechanism.
         loop = self._get_loop()
         if loop:
-            loop._wgpu_gui_poll()
+            loop._rc_gui_poll()
 
         # Flush our events, so downstream code can update stuff.
         # Maybe that downstream code request a new draw.
@@ -245,7 +245,7 @@ def force_draw(self):
     def _draw_frame_and_present(self):
         """Draw the frame and present the result.
 
-        Errors are logged to the "wgpu" logger. Should be called by the
+        Errors are logged to the "rendercanvas" logger. Should be called by the
         subclass at its draw event.
         """
 

rendercanvas/glfw.py

@@ -22,13 +22,13 @@
 # Make sure that glfw is new enough
 glfw_version_info = tuple(int(i) for i in glfw.__version__.split(".")[:2])
 if glfw_version_info < (1, 9):
-    raise ImportError("wgpu-py requires glfw 1.9 or higher.")
+    raise ImportError("rendercanvas requires glfw 1.9 or higher.")
 
 # Do checks to prevent pitfalls on hybrid Xorg/Wayland systems
 is_wayland = False
 if sys.platform.startswith("linux") and SYSTEM_IS_WAYLAND:
     if not hasattr(glfw, "get_x11_window"):
-        # Probably glfw was imported before we wgpu was, so we missed our chance
+        # Probably glfw was imported before this module, so we missed our chance
         # to set the env var to make glfw use x11.
         is_wayland = True
         logger.warning("Using GLFW with Wayland, which is experimental.")
@@ -142,7 +142,7 @@ def get_physical_size(window):
 
 
 class GlfwRenderCanvas(BaseRenderCanvas):
-    """A glfw window providing a wgpu canvas."""
+    """A glfw window providing a render canvas."""
 
     # See https://www.glfw.org/docs/latest/group__window.html
 
@@ -201,7 +201,7 @@ def __init__(self, *, size=None, title=None, **kwargs):
         self.set_logical_size(*size)
         self.set_title(title)
 
-    # Callbacks to provide a minimal working canvas for wgpu
+    # Callbacks to provide a minimal working canvas
 
     def _on_pixelratio_change(self, *args):
         if self._changing_pixel_ratio:
@@ -539,7 +539,7 @@ def init_glfw(self):
             self._glfw_initialized = True
             atexit.register(glfw.terminate)
 
-    def _wgpu_gui_poll(self):
+    def _rc_gui_poll(self):
         glfw.post_empty_event()  # Awake the event loop, if it's in wait-mode
         glfw.poll_events()
         if self.stop_if_no_more_canvases and not tuple(self.all_glfw_canvases):

rendercanvas/jupyter.py

@@ -15,7 +15,7 @@
 
 
 class JupyterRenderCanvas(BaseRenderCanvas, RemoteFrameBuffer):
-    """An ipywidgets widget providing a wgpu canvas. Needs the jupyter_rfb library."""
+    """An ipywidgets widget providing a render canvas. Needs the jupyter_rfb library."""
 
     def __init__(self, *, size=None, title=None, **kwargs):
         super().__init__(**kwargs)
@@ -131,7 +131,7 @@ def __init__(self):
         super().__init__()
         self._pending_jupyter_canvases = []
 
-    def _wgpu_gui_poll(self):
+    def _rc_gui_poll(self):
         pass  # Jupyter is running in a separate process :)
 
     def run(self):