pydisplay: Release v0.0.26 (380c2e8).

Signed-off-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

Author: github-actions[bot]

micropython/pydisplay/displaysys/displaysys/displaysys/__init__.py

@@ -27,12 +27,12 @@ def _mp_native(f):
 
 
 def _install_byteswap():
-    """Prefer GitHub ``add_ons/byteswap`` (numpy/ulab/viper); else portable Python.
+    """Prefer GitHub ``utils/byteswap`` (numpy/ulab/viper); else portable Python.
 
     No in-tree ``@viper`` here: micropython-lib MIP packaging compiles every
     ``.py`` with ``mpy-cross`` without ``-march``, so viper/native emitters in
     this package would break the index build. Fast swap on SPI boards comes
-    from installing ``add_ons`` (GitHub MIP), not from the displaysys package.
+    from installing ``utils`` (GitHub MIP), not from the displaysys package.
     """
     try:
         from byteswap import byteswap as _byteswap_native
@@ -68,6 +68,7 @@ def byteswap(buf):
     "color_rgb",
     "desktop_work_area",
     "env_bool",
+    "env_float",
     "env_get",
     "env_int",
     "env_set",
@@ -145,6 +146,17 @@ def env_int(name, default=0):
         return int(default)
 
 
+def env_float(name, default=0.0):
+    """Read a floating-point environment variable portably."""
+    raw = _env_raw(name)
+    if raw is None:
+        return float(default)
+    try:
+        return float(str(raw).strip())
+    except (TypeError, ValueError):
+        return float(default)
+
+
 def _env_raw(name):
     if name in _overrides:
         return _overrides[name]
@@ -560,7 +572,7 @@ def __init__(self, *, quiet=False):
                 if _BYTESWAP_BACKEND == "pure_python":
                     print(
                         f"{self.__class__.__name__}: warning: slow byteswap fallback; "
-                        "install add_ons/byteswap (GitHub MIP) for viper/numpy swap"
+                        "install utils/byteswap (GitHub MIP) for viper/numpy swap"
                     )
 
     def __del__(self):

micropython/pydisplay/displaysys/displaysys/displaysys/jndisplay.py

@@ -13,7 +13,7 @@
 
 from displaysys import DisplayDriver, color_rgb
 from eventsys import events
-from eventsys.keys import Keys, default_quit_chord, key_to_keycode, mod_mask
+from eventsys.keys import Keys, default_quit_chord, enrich_mod, key_to_keycode, mod_mask
 
 _JN_DEPS = "pip install ipywidgets ipyevents"
 
@@ -246,7 +246,7 @@ def _on_wheel(self, event):
 
     def _on_key(self, event, kind):
         keycode = key_to_keycode(event.get("key", ""), event.get("location", 0))
-        mod = mod_mask(
+        base_mod = mod_mask(
             event.get("ctrlKey"),
             event.get("shiftKey"),
             event.get("altKey"),
@@ -256,10 +256,10 @@ def _on_key(self, event, kind):
             if event.get("repeat"):  # ignore auto-repeat
                 return
             self._pressed.add(keycode)
-            self._enqueue_key(events.KEYDOWN, keycode, mod)
+            self._enqueue_key(events.KEYDOWN, keycode, enrich_mod(base_mod, self._pressed))
         else:
             self._pressed.discard(keycode)
-            self._enqueue_key(events.KEYUP, keycode, mod)
+            self._enqueue_key(events.KEYUP, keycode, enrich_mod(base_mod, self._pressed))
 
     def _enqueue_key(self, type, keycode, mod):
         self._queue.append(events.Key(type, Keys.keyname(keycode), keycode, mod, 0, None))

micropython/pydisplay/displaysys/displaysys/displaysys/pgdisplay.py

@@ -20,79 +20,7 @@
 from eventsys import events
 from eventsys.keys import default_quit_chord
 
-__all__ = ["FFmpegFrameRecorder", "PGDisplay", "get_events", "poll_event"]
-
-
-class FFmpegFrameRecorder:
-    """Pipe fixed-size RGB24 frames to ffmpeg for MP4 output."""
-
-    __slots__ = ("_closed", "_frame_bytes", "_frames", "_proc", "fps", "height", "path", "width")
-
-    def __init__(self, path, width, height, fps=12):
-        import subprocess
-
-        self.path = path
-        self.width = width
-        self.height = height
-        self.fps = fps
-        self._frames = 0
-        self._closed = False
-        self._frame_bytes = width * height * 3
-        self._proc = subprocess.Popen(
-            [
-                "ffmpeg",
-                "-y",
-                "-f",
-                "rawvideo",
-                "-pix_fmt",
-                "rgb24",
-                "-s",
-                f"{width}x{height}",
-                "-r",
-                str(fps),
-                "-i",
-                "pipe:0",
-                "-an",
-                "-c:v",
-                "libx264",
-                "-pix_fmt",
-                "yuv420p",
-                path,
-            ],
-            stdin=subprocess.PIPE,
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.PIPE,
-        )
-
-    def write(self, rgb_bytes):
-        if self._closed:
-            return
-        if len(rgb_bytes) != self._frame_bytes:
-            raise ValueError(
-                f"frame size {len(rgb_bytes)} != expected {self._frame_bytes} "
-                f"for {self.width}x{self.height} RGB24"
-            )
-        self._proc.stdin.write(rgb_bytes)
-        self._frames += 1
-
-    def close(self):
-        if self._closed:
-            return self._frames
-        self._closed = True
-        try:
-            self._proc.stdin.close()
-        except Exception:
-            pass
-        err = self._proc.stderr.read().decode("utf-8", errors="replace")
-        try:
-            self._proc.stderr.close()
-        except Exception:
-            pass
-        rc = self._proc.wait()
-        if rc != 0:
-            tail = "\n".join(err.strip().splitlines()[-8:])
-            raise RuntimeError(f"ffmpeg exited {rc} for {self.path}:\n{tail}")
-        return self._frames
+__all__ = ["PGDisplay", "get_events", "poll_event"]
 
 
 def _pg_key_name(key):
@@ -170,7 +98,7 @@ def _handle_window_close(window):
     return None
 
 
-def _convert(e):
+def _convert(e):  # noqa: PLR0911 — one return per pygame event type
     """Convert a pygame event to an eventsys namedtuple."""
     t = e.type
     if t == pg.QUIT:
@@ -215,6 +143,9 @@ def _convert(e):
             win,
         )
     if t in (pg.KEYDOWN, pg.KEYUP):
+        # Match browser / SDL backends: drop OS auto-repeat KEYDOWNs.
+        if t == pg.KEYDOWN and getattr(e, "repeat", False):
+            return None
         return events.Key(t, _pg_key_name(e.key), e.key, e.mod, getattr(e, "scancode", 0), win)
     if t == pg.JOYAXISMOTION:
         return events.JoyAxisMotion(t, e.instance_id, e.axis, e.value / 32767.0)
@@ -522,11 +453,19 @@ def _video_active(self) -> bool:
         except pg.error:
             return False
 
-    def _buffer_rgb(self) -> bytes:
-        """Export the logical framebuffer as packed RGB24 bytes."""
-        if hasattr(pg.image, "tostring"):
-            return pg.image.tostring(self._buffer, "RGB")
-        return pg.image.tobytes(self._buffer, "RGB")
+    def capture_rgb(self):
+        """Return the visible window as ``(RGB24 bytes, width, height)``."""
+        if not self._video_active():
+            raise RuntimeError("pygame display is not active")
+        self.show()
+        width, height = self._window.get_size()
+        return self._window_rgb(), width, height
+
+    def _window_rgb(self):
+        """Export the composed visible window as packed RGB24 bytes."""
+        if hasattr(pg.image, "tobytes"):
+            return pg.image.tobytes(self._window, "RGB")
+        return pg.image.tostring(self._window, "RGB")
 
     @property
     def frame_recording(self) -> bool:
@@ -535,9 +474,11 @@ def frame_recording(self) -> bool:
 
     def open_frame_recorder(self, path, *, fps=12, width=None, height=None):
         """Attach an ffmpeg-backed recorder that receives one RGB24 frame per ``show()``."""
+        from frame_recorder import FFmpegFrameRecorder
+
         self.close_frame_recorder()
-        w = self.width if width is None else width
-        h = self.height if height is None else height
+        w = int(self.width * self._scale) if width is None else width
+        h = int(self.height * self._scale) if height is None else height
         self._frame_recorder = FFmpegFrameRecorder(path, w, h, fps)
         return self._frame_recorder
 
@@ -546,11 +487,13 @@ def close_frame_recorder(self):
         recorder = self._frame_recorder
         self._frame_recorder = None
         if recorder is not None:
-            recorder.close()
+            return recorder.close()
+        return 0
 
     def _record_frame(self, rgb_bytes) -> None:
-        if self._frame_recorder is not None:
-            self._frame_recorder.write(rgb_bytes)
+        recorder = self._frame_recorder
+        if recorder is not None:
+            recorder.write(rgb_bytes)
 
     def render(self, renderRect=None) -> None:
         """
@@ -604,7 +547,7 @@ def show(self, _timer=None) -> None:
             self.render()
             self._render_dirty = False
         if self._frame_recorder is not None:
-            self._record_frame(self._buffer_rgb())
+            self._record_frame(self._window_rgb())
         try:
             self._pg_window.flip()
         except pg.error:

micropython/pydisplay/displaysys/displaysys/displaysys/psdisplay.py

@@ -11,7 +11,14 @@
 
 from displaysys import DisplayDriver, color_rgb
 from eventsys import events
-from eventsys.keys import Keys, default_quit_chord, dom_key_scrolls_page, key_to_keycode, mod_mask
+from eventsys.keys import (
+    Keys,
+    default_quit_chord,
+    dom_key_scrolls_page,
+    enrich_mod,
+    key_to_keycode,
+    mod_mask,
+)
 
 try:  # Gamepad polling is optional and only available in a browser.
     from js import navigator
@@ -254,18 +261,18 @@ def _suppress_browser_scroll(self, e, keycode):
 
     def _on_keydown(self, e):
         keycode = key_to_keycode(e.key, e.location)
-        mod = mod_mask(e.ctrlKey, e.shiftKey, e.altKey, e.metaKey)
         self._suppress_browser_scroll(e, keycode)
         if e.repeat:  # ignore auto-repeat
             return
         self._pressed.add(keycode)
+        mod = enrich_mod(mod_mask(e.ctrlKey, e.shiftKey, e.altKey, e.metaKey), self._pressed)
         self._enqueue_key(events.KEYDOWN, keycode, mod)
 
     def _on_keyup(self, e):
         keycode = key_to_keycode(e.key, e.location)
-        mod = mod_mask(e.ctrlKey, e.shiftKey, e.altKey, e.metaKey)
         self._suppress_browser_scroll(e, keycode)
         self._pressed.discard(keycode)
+        mod = enrich_mod(mod_mask(e.ctrlKey, e.shiftKey, e.altKey, e.metaKey), self._pressed)
         self._enqueue_key(events.KEYUP, keycode, mod)
 
     ############### Gamepad ################