rendercanvas 2.2.0__tar.gz → 2.2.1__tar.gz

{rendercanvas-2.2.0 → rendercanvas-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rendercanvas
-Version: 2.2.0
+Version: 2.2.1
 Summary: One canvas API, multiple backends
 Keywords: canvas,rendering,graphics,wgpu,qt,wx,glfw,jupyter
 Author: Almar Klein, Korijn van Golen

{rendercanvas-2.2.0 → rendercanvas-2.2.1}/rendercanvas/_loop.py

@@ -372,7 +372,7 @@ class BaseLoop:
         This method is optional. A subclass must either implement ``_rc_add_task`` or ``_rc_call_later``.
 
         * If you implememt this, make ``_rc_add_task()`` call ``super()._rc_add_task()``.
-        * If delay is zero, this should behave like "call_later".
+        * If delay is zero, this should behave like "call_soon".
         * No need to catch errors from the callback; that's dealt with internally.
         * Return None.
         """

{rendercanvas-2.2.0 → rendercanvas-2.2.1}/rendercanvas/_scheduler.py

@@ -2,6 +2,7 @@
 The scheduler class/loop.
 """
 
+import sys
 import time
 import weakref
 
@@ -9,6 +10,9 @@ from ._coreutils import BaseEnum
 from .utils.asyncs import sleep, Event
 
 
+IS_WIN = sys.platform.startswith("win")
+
+
 class UpdateMode(BaseEnum):
     """The UpdateMode enum specifies the different modes to schedule draws for the canvas."""
 
@@ -123,14 +127,23 @@ class Scheduler:
                 delay = 1 / self._max_fps
                 delay = 0 if delay < 0 else delay  # 0 means cannot keep up
 
-            # Offset delay for time spent on processing events, etc.
-            time_since_tick_start = time.perf_counter() - last_tick_time
-            delay -= time_since_tick_start
-            delay = max(0, delay)
-
-            # Wait. Even if delay is zero, it gives control back to the loop,
-            # allowing other tasks to do work.
-            await sleep(delay)
+            # Determine amount of sleep
+            sleep_time = delay - (time.perf_counter() - last_tick_time)
+
+            if IS_WIN:
+                # On Windows OS-level timers have an in accuracy of 15.6 ms.
+                # This can cause sleep to take longer than intended. So we sleep
+                # less, and then do a few small sync-sleeps that have high accuracy.
+                await sleep(max(0, sleep_time - 0.0156))
+                sleep_time = delay - (time.perf_counter() - last_tick_time)
+                while sleep_time > 0:
+                    time.sleep(min(sleep_time, 0.001))  # sleep hard for at most 1ms
+                    await sleep(0)  # Allow other tasks to run but don't wait
+                    sleep_time = delay - (time.perf_counter() - last_tick_time)
+            else:
+                # Wait. Even if delay is zero, it gives control back to the loop,
+                # allowing other tasks to do work.
+                await sleep(max(0, sleep_time))
 
             # Below is the "tick"
 

rendercanvas-2.2.1/rendercanvas/_version.py

@@ -0,0 +1,194 @@
+"""
+_version.py v1.4
+
+Simple version string management, using a hard-coded version string
+for simplicity and compatibility, while adding git info at runtime.
+See https://github.com/pygfx/_version for more info.
+This code is subject to The Unlicense (public domain).
+
+Any updates to this file should be done in https://github.com/pygfx/_version
+
+Usage in short:
+
+* Add this file to the root of your library (next to the `__init__.py`).
+* On a new release, you just update the __version__.
+"""
+
+# ruff: noqa: RUF100, S310, PLR2004, D212, D400, D415, S603, BLE001, COM812
+
+import logging
+import subprocess
+from pathlib import Path
+
+# This is the base version number, to be bumped before each release.
+# The build system detects this definition when building a distribution.
+__version__ = "2.2.1"
+
+# Set this to your library name
+project_name = "rendercanvas"
+
+
+logger = logging.getLogger(project_name)
+
+# Get whether this is a repo. If so, repo_dir is the path, otherwise None.
+# .git is a dir in a normal repo and a file when in a submodule.
+repo_dir = Path(__file__).parents[1]
+repo_dir = repo_dir if repo_dir.joinpath(".git").exists() else None
+
+
+def get_version() -> str:
+    """Get the version string."""
+    if repo_dir:
+        return get_extended_version()
+    return __version__
+
+
+def get_extended_version() -> str:
+    """Get an extended version string with information from git."""
+    release, post, labels = get_version_info_from_git()
+
+    # Sample first 3 parts of __version__
+    base_release = ".".join(__version__.split(".")[:3])
+
+    # Check release
+    if not release:
+        release = base_release
+    elif release != base_release:
+        warning(
+            f"{project_name} version from git ({release})"
+            f" and __version__ ({base_release}) don't match."
+        )
+
+    # Build the total version
+    version = release
+    if post and post != "0":
+        version += f".post{post}"
+        if labels:
+            version += "+" + ".".join(labels)
+    elif labels and labels[-1] == "dirty":
+        version += "+" + ".".join(labels)
+
+    return version
+
+
+def get_version_info_from_git() -> str:
+    """
+    Get (release, post, labels) from Git.
+
+    With `release` the version number from the latest tag, `post` the
+    number of commits since that tag, and `labels` a tuple with the
+    git-hash and optionally a dirty flag.
+    """
+    # Call out to Git
+    command = [
+        "git",
+        "describe",
+        "--long",
+        "--always",
+        "--tags",
+        "--dirty",
+        "--first-parent",
+    ]
+    try:
+        p = subprocess.run(command, check=False, cwd=repo_dir, capture_output=True)
+    except Exception as e:
+        warning(f"Could not get {project_name} version: {e}")
+        p = None
+
+    # Parse the result into parts
+    if p is None:
+        parts = (None, None, "unknown")
+    else:
+        output = p.stdout.decode(errors="ignore")
+        if p.returncode:
+            stderr = p.stderr.decode(errors="ignore")
+            warning(
+                f"Could not get {project_name} version.\n\nstdout: "
+                + output
+                + "\n\nstderr: "
+                + stderr
+            )
+            parts = (None, None, "unknown")
+        else:
+            parts = output.strip().lstrip("v").split("-")
+            if len(parts) <= 2:
+                # No tags (and thus no post). Only git hash and maybe 'dirty'.
+                parts = (None, None, *parts)
+
+    # Return unpacked parts
+    release, post, *labels = parts
+    return release, post, labels
+
+
+def version_to_tuple(v: str) -> tuple:
+    v = __version__.split("+")[0]  # remove hash
+    return tuple(int(i) if i.isnumeric() else i for i in v.split("."))
+
+
+def prnt(m: str) -> None:
+    sys.stdout.write(m + "\n")
+
+
+def warning(m: str) -> None:
+    logger.warning(m)
+
+
+# Apply the versioning
+base_version = __version__
+__version__ = get_version()
+version_info = version_to_tuple(__version__)
+
+
+# The CLI part
+
+CLI_USAGE = """
+_version.py
+
+help            - Show this message.
+version         - Show the current version.
+bump VERSION    - Bump the __version__ to the given VERSION.
+update          - Self-update the _version.py module by downloading the
+                  reference code and replacing version number and project name.
+""".lstrip()
+
+if __name__ == "__main__":
+    import sys
+    import urllib.request
+
+    _, *args = sys.argv
+    this_file = Path(__file__)
+
+    if not args or args[0] == "version":
+        prnt(f"{project_name} v{__version__}")
+
+    elif args[0] == "bump":
+        if len(args) != 2:
+            sys.exit("Expected a version number to bump to.")
+        new_version = args[1].lstrip("v")  # allow '1.2.3' and 'v1.2.3'
+        if new_version.count(".") != 2:
+            sys.exit("Expected two dots in new version string.")
+        if not all(s.isnumeric() for s in new_version.split(".")):
+            sys.exit("Expected only numbers in new version string.")
+        with this_file.open("rb") as f:
+            text = ref_text = f.read().decode()
+        text = text.replace(base_version, new_version, 1)
+        with this_file.open("wb") as f:
+            f.write(text.encode())
+        prnt(f"Bumped version from '{base_version}' to '{new_version}'.")
+
+    elif args[0] == "update":
+        u = "https://raw.githubusercontent.com/pygfx/_version/main/_version.py"
+        with urllib.request.urlopen(u) as f:
+            text = ref_text = f.read().decode()
+        text = text.replace("0.0.0", base_version, 1)
+        text = text.replace("PROJECT_NAME", project_name, 1)
+        with this_file.open("wb") as f:
+            f.write(text.encode())
+        prnt("Updated to the latest _version.py.")
+
+    elif args[0].lstrip("-") in ["h", "help"]:
+        prnt(CLI_USAGE)
+
+    else:
+        prnt(f"Unknown command for _version.py: {args[0]!r}")
+        prnt("Use ``python _version.py help`` to see a list of options.")

{rendercanvas-2.2.0 → rendercanvas-2.2.1}/rendercanvas/base.py

@@ -476,11 +476,22 @@ class BaseRenderCanvas:
     # %% Primary canvas management methods
 
     def get_logical_size(self) -> Tuple[float]:
-        """Get the logical size (width, height) in float pixels."""
+        """Get the logical size (width, height) in float pixels.
+
+        The logical size can be smaller than the physical size, e.g. on HiDPI
+        monitors or when the user's system has the display-scale set to e.g. 125%.
+        """
         return self._rc_get_logical_size()
 
     def get_pixel_ratio(self) -> float:
-        """Get the float ratio between logical and physical pixels."""
+        """Get the float ratio between logical and physical pixels.
+
+        The pixel ratio is typically 1.0 for normal screens and 2.0 for HiDPI
+        screens, but fractional values are also possible if the system
+        display-scale is set to e.g. 125%. An HiDPI screen can be assumed if the
+        pixel ratio >= 2.0. On MacOS (with a Retina screen) the pixel ratio is
+        always 2.0.
+        """
         return self._rc_get_pixel_ratio()
 
     def close(self) -> None:

{rendercanvas-2.2.0 → rendercanvas-2.2.1}/rendercanvas/glfw.py

@@ -25,12 +25,12 @@ if glfw_version_info < (1, 9):
     raise ImportError("rendercanvas requires glfw 1.9 or higher.")
 
 # Do checks to prevent pitfalls on hybrid Xorg/Wayland systems
-is_wayland = False
+api_is_wayland = False
 if sys.platform.startswith("linux") and SYSTEM_IS_WAYLAND:
     if not hasattr(glfw, "get_x11_window"):
         # 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
+        api_is_wayland = True
         logger.warning("Using GLFW with Wayland, which is experimental.")
 
 
@@ -135,7 +135,7 @@ def get_glfw_present_methods(window):
             }
         }
     elif sys.platform.startswith("linux"):
-        if is_wayland:
+        if api_is_wayland:
             return {
                 "screen": {
                     "platform": "wayland",
@@ -262,6 +262,8 @@ class GlfwRenderCanvas(BaseRenderCanvas):
     def _determine_size(self):
         if self._window is None:
             return
+        # Note: On Wayland  glfw.get_window_content_scale() produces (1.0, 1.0) regardless of the OS settings.
+
         # Because the value of get_window_size is in physical-pixels
         # on some systems and in logical-pixels on other, we use the
         # framebuffer size and pixel ratio to derive the logical size.
@@ -305,21 +307,13 @@ class GlfwRenderCanvas(BaseRenderCanvas):
         psize = glfw.get_framebuffer_size(self._window)
 
         # Apply
-        if is_wayland:
-            # Not sure why, but on Wayland things work differently
-            screen_ratio = ssize[0] / new_logical_size[0]
-            glfw.set_window_size(
-                self._window,
-                int(new_logical_size[0] / screen_ratio),
-                int(new_logical_size[1] / screen_ratio),
-            )
-        else:
-            screen_ratio = ssize[0] / psize[0]
-            glfw.set_window_size(
-                self._window,
-                int(new_logical_size[0] * pixel_ratio * screen_ratio),
-                int(new_logical_size[1] * pixel_ratio * screen_ratio),
-            )
+        screen_ratio = ssize[0] / psize[0]
+        glfw.set_window_size(
+            self._window,
+            int(new_logical_size[0] * pixel_ratio * screen_ratio),
+            int(new_logical_size[1] * pixel_ratio * screen_ratio),
+        )
+
         self._screen_size_is_logical = screen_ratio != 1
         # If this causes the widget size to change, then _on_size_change will
         # be called, but we may want force redetermining the size.

{rendercanvas-2.2.0 → rendercanvas-2.2.1}/rendercanvas/qt.py

@@ -31,7 +31,6 @@ if libname:
         WA_PaintOnScreen = QtCore.Qt.WidgetAttribute.WA_PaintOnScreen
         WA_DeleteOnClose = QtCore.Qt.WidgetAttribute.WA_DeleteOnClose
         WA_InputMethodEnabled = QtCore.Qt.WidgetAttribute.WA_InputMethodEnabled
-        PreciseTimer = QtCore.Qt.TimerType.PreciseTimer
         KeyboardModifiers = QtCore.Qt.KeyboardModifier
         FocusPolicy = QtCore.Qt.FocusPolicy
         CursorShape = QtCore.Qt.CursorShape
@@ -42,7 +41,6 @@ if libname:
         WA_PaintOnScreen = QtCore.Qt.WA_PaintOnScreen
         WA_DeleteOnClose = QtCore.Qt.WA_DeleteOnClose
         WA_InputMethodEnabled = QtCore.Qt.WA_InputMethodEnabled
-        PreciseTimer = QtCore.Qt.PreciseTimer
         KeyboardModifiers = QtCore.Qt
         FocusPolicy = QtCore.Qt
         CursorShape = QtCore.Qt

{rendercanvas-2.2.0 → rendercanvas-2.2.1}/rendercanvas/raw.py

@@ -60,6 +60,7 @@ class RawLoop(BaseLoop):
                 break
             else:
                 # Wait until its time for it to be called
+                # Note that on Windows, the accuracy of the timeout is 15.6 ms
                 wait_time = wrapper.time - time.perf_counter()
                 self._event.wait(max(wait_time, 0))
 

rendercanvas-2.2.0/rendercanvas/_version.py

@@ -1,113 +0,0 @@
-"""
-Versioning: we use a hard-coded version number, because it's simple and always
-works. For dev installs we add extra version info from Git.
-"""
-
-import logging
-import subprocess
-from pathlib import Path
-
-
-# This is the reference version number, to be bumped before each release.
-# The build system detects this definition when building a distribution.
-__version__ = "2.2.0"
-
-# Allow using nearly the same code in different projects
-project_name = "rendercanvas"
-
-
-logger = logging.getLogger(project_name.lower())
-
-# Get whether this is a repo. If so, repo_dir is the path, otherwise repo_dir is None.
-repo_dir = Path(__file__).parents[1]
-repo_dir = repo_dir if repo_dir.joinpath(".git").is_dir() else None
-
-
-def get_version():
-    """Get the version string."""
-    if repo_dir:
-        return get_extended_version()
-    else:
-        return __version__
-
-
-def get_extended_version():
-    """Get an extended version string with information from git."""
-
-    release, post, labels = get_version_info_from_git()
-
-    # Sample first 3 parts of __version__
-    base_release = ".".join(__version__.split(".")[:3])
-
-    # Check release
-    if not release:
-        release = base_release
-    elif release != base_release:
-        logger.warning(
-            f"{project_name} version from git ({release}) and __version__ ({base_release}) don't match."
-        )
-
-    # Build the total version
-    version = release
-    if post and post != "0":
-        version += f".post{post}"
-    if labels:
-        version += "+" + ".".join(labels)
-
-    return version
-
-
-def get_version_info_from_git():
-    """Get (release, post, labels) from Git.
-
-    With `release` the version number from the latest tag, `post` the
-    number of commits since that tag, and `labels` a tuple with the
-    git-hash and optionally a dirty flag.
-    """
-
-    # Call out to Git
-    command = [
-        "git",
-        "describe",
-        "--long",
-        "--always",
-        "--tags",
-        "--dirty",
-        "--first-parent",
-    ]
-    try:
-        p = subprocess.run(command, cwd=repo_dir, capture_output=True)
-    except Exception as e:
-        logger.warning(f"Could not get {project_name} version: {e}")
-        p = None
-
-    # Parse the result into parts
-    if p is None:
-        parts = (None, None, "unknown")
-    else:
-        output = p.stdout.decode(errors="ignore")
-        if p.returncode:
-            stderr = p.stderr.decode(errors="ignore")
-            logger.warning(
-                f"Could not get {project_name} version.\n\nstdout: "
-                + output
-                + "\n\nstderr: "
-                + stderr
-            )
-            parts = (None, None, "unknown")
-        else:
-            parts = output.strip().lstrip("v").split("-")
-            if len(parts) <= 2:
-                # No tags (and thus also no post). Only git hash and maybe 'dirty'
-                parts = (None, None, *parts)
-
-    # Return unpacked parts
-    release, post, *labels = parts
-    return release, post, labels
-
-
-__version__ = get_version()
-
-version_info = tuple(
-    int(i) if i.isnumeric() else i for i in __version__.split("+")[0].split(".")
-)