style: apply ruff auto-fixes for pre-commit

Author: AdityaGupta716

fury/ui/event_recorder.py

@@ -17,12 +17,11 @@
 
 from __future__ import annotations
 
+from dataclasses import asdict, dataclass, field
 import json
 import time
-from dataclasses import asdict, dataclass, field
 from typing import Any, Callable, Dict, List, Optional
 
-
 # ---------------------------------------------------------------------------
 # Rendercanvas event types that we observe by default (lowercase strings used
 # by rendercanvas._enums.EventType).
@@ -44,6 +43,7 @@
 # RecordedEvent
 # ---------------------------------------------------------------------------
 
+
 @dataclass(frozen=True)
 class RecordedEvent:
     """Immutable snapshot of a single rendercanvas UI event.
@@ -131,16 +131,22 @@ def from_rendercanvas_event(cls, event: Any) -> "RecordedEvent":
         RecordedEvent
         """
         if isinstance(event, dict):
+
             def _get(key: str, default: Any = None) -> Any:
                 return event.get(key, default)
+
             raw = dict(event)
         else:
+
             def _get(key: str, default: Any = None) -> Any:  # type: ignore[misc]
                 return getattr(event, key, default)
+
             # Serialise object to a dict so raw is always JSON-safe.
             try:
                 raw = {
-                    "event_type": getattr(event, "event_type", getattr(event, "type", "")),
+                    "event_type": getattr(
+                        event, "event_type", getattr(event, "type", "")
+                    ),
                     "x": float(getattr(event, "x", 0)),
                     "y": float(getattr(event, "y", 0)),
                     "button": int(getattr(event, "button", 0)),
@@ -149,7 +155,9 @@ def _get(key: str, default: Any = None) -> Any:  # type: ignore[misc]
                     "modifiers": list(getattr(event, "modifiers", [])),
                     "dx": float(getattr(event, "dx", 0)),
                     "dy": float(getattr(event, "dy", 0)),
-                    "time_stamp": float(getattr(event, "time_stamp", time.perf_counter())),
+                    "time_stamp": float(
+                        getattr(event, "time_stamp", time.perf_counter())
+                    ),
                 }
             except Exception:
                 raw = {}
@@ -160,7 +168,9 @@ def _get(key: str, default: Any = None) -> Any:  # type: ignore[misc]
 
         return cls(
             event_type=str(et),
-            timestamp=float(ts if (ts := _get("time_stamp")) is not None else time.perf_counter()),
+            timestamp=float(
+                ts if (ts := _get("time_stamp")) is not None else time.perf_counter()
+            ),
             x=float(_get("x") or 0),
             y=float(_get("y") or 0),
             button=int(_get("button") or 0),
@@ -205,6 +215,7 @@ def to_rendercanvas_event(self) -> Dict[str, Any]:
 # EventRecorder
 # ---------------------------------------------------------------------------
 
+
 class EventRecorder:
     """Records UI events from a FURY v2 ShowManager.
 
@@ -380,6 +391,7 @@ def _resolve_renderer(show_manager: Any) -> Any:
 # EventCounter
 # ---------------------------------------------------------------------------
 
+
 class EventCounter(EventRecorder):
     """Records events *and* maintains per-type counts.
 
@@ -432,8 +444,12 @@ def clear(self) -> None:
     # ------------------------------------------------------------------
 
     def _on_event(self, event: Any) -> None:
-        et = event.get("event_type", "unknown") if isinstance(event, dict) else (
-            getattr(event, "event_type", None) or getattr(event, "type", "unknown")
+        et = (
+            event.get("event_type", "unknown")
+            if isinstance(event, dict)
+            else (
+                getattr(event, "event_type", None) or getattr(event, "type", "unknown")
+            )
         )
         self._counts[et] = self._counts.get(et, 0) + 1
         super()._on_event(event)
@@ -443,6 +459,7 @@ def _on_event(self, event: Any) -> None:
 # EventPlayer
 # ---------------------------------------------------------------------------
 
+
 class EventPlayer:
     """Replays a sequence of :class:`RecordedEvent` objects into a ShowManager.
 
@@ -524,14 +541,14 @@ def play(self, show_manager: Any) -> None:
         # 3. renderer.dispatch_event — last resort (expects Event object, not dict)
         if hasattr(renderer, "emit"):
             _dispatch = renderer.emit
-        elif hasattr(show_manager, "window") and hasattr(show_manager.window, "_events"):
+        elif hasattr(show_manager, "window") and hasattr(
+            show_manager.window, "_events"
+        ):
             _dispatch = show_manager.window._events.emit
         elif hasattr(renderer, "dispatch_event"):
             _dispatch = renderer.dispatch_event
         else:
-            raise AttributeError(
-                "Cannot find a dict-compatible event dispatch path."
-            )
+            raise AttributeError("Cannot find a dict-compatible event dispatch path.")
 
         prev_ts: Optional[float] = None
         for idx, evt in enumerate(events):

fury/ui/tests/test_event_recorder.py

@@ -12,7 +12,7 @@
 import json
 import os
 import time
-from unittest.mock import MagicMock, patch
+from unittest.mock import MagicMock
 
 import pytest
 
@@ -24,11 +24,11 @@
     RecordedEvent,
 )
 
-
 # ---------------------------------------------------------------------------
 # Helpers — fake rendercanvas Renderer
 # ---------------------------------------------------------------------------
 
+
 def _make_renderer() -> MagicMock:
     """Minimal rendercanvas Renderer mock.
 
@@ -93,8 +93,10 @@ def _key(et="key_down", key="a", modifiers=None, ts=None):
 def _wheel(x=0.0, y=0.0, dx=0.0, dy=-3.0, ts=None):
     return {
         "event_type": "wheel",
-        "x": x, "y": y,
-        "dx": dx, "dy": dy,
+        "x": x,
+        "y": y,
+        "dx": dx,
+        "dy": dy,
         "modifiers": [],
         "time_stamp": ts if ts is not None else time.perf_counter(),
     }
@@ -104,8 +106,8 @@ def _wheel(x=0.0, y=0.0, dx=0.0, dy=-3.0, ts=None):
 # RecordedEvent tests
 # ---------------------------------------------------------------------------
 
-class TestRecordedEvent:
 
+class TestRecordedEvent:
     def test_defaults(self):
         e = RecordedEvent(event_type="pointer_down")
         assert e.event_type == "pointer_down"
@@ -203,8 +205,8 @@ def test_modifiers_preserved_as_tuple(self):
 # EventRecorder tests
 # ---------------------------------------------------------------------------
 
-class TestEventRecorder:
 
+class TestEventRecorder:
     def test_attach_registers_handler(self):
         renderer = _make_renderer()
         sm = _make_show_manager(renderer)
@@ -380,8 +382,8 @@ def test_resolve_renderer_raises_for_unknown(self):
 # EventCounter tests
 # ---------------------------------------------------------------------------
 
-class TestEventCounter:
 
+class TestEventCounter:
     def test_counts_by_type(self):
         renderer = _make_renderer()
         sm = _make_show_manager(renderer)
@@ -442,13 +444,15 @@ def test_is_subclass_of_recorder(self):
 # EventPlayer tests
 # ---------------------------------------------------------------------------
 
-class TestEventPlayer:
 
+class TestEventPlayer:
     def _recorded(self, n=3, base_ts=1000.0):
         return [
             RecordedEvent.from_rendercanvas_event(
-                {**_ptr("pointer_down", x=float(i * 10), y=float(i * 10)),
-                 "time_stamp": base_ts + i * 0.1}
+                {
+                    **_ptr("pointer_down", x=float(i * 10), y=float(i * 10)),
+                    "time_stamp": base_ts + i * 0.1,
+                }
             )
             for i in range(n)
         ]
@@ -480,7 +484,9 @@ def test_play_correct_event_types(self):
         assert dispatched == ["pointer_down", "key_up"]
 
     def test_play_correct_coordinates(self):
-        events = [RecordedEvent.from_rendercanvas_event(_ptr("pointer_move", x=55, y=77))]
+        events = [
+            RecordedEvent.from_rendercanvas_event(_ptr("pointer_move", x=55, y=77))
+        ]
         player = EventPlayer(recorder=self._recorder_with(events), speed_factor=0.0)
         dispatched = []
         renderer = _make_renderer()
@@ -527,7 +533,9 @@ def test_load_then_play(self, tmp_path):
     def test_speed_factor_zero_no_sleep(self, monkeypatch):
         slept = []
         monkeypatch.setattr(time, "sleep", lambda s: slept.append(s))
-        player = EventPlayer(recorder=self._recorder_with(self._recorded(3)), speed_factor=0.0)
+        player = EventPlayer(
+            recorder=self._recorder_with(self._recorded(3)), speed_factor=0.0
+        )
         player.play(_make_show_manager())
         assert slept == []
 
@@ -552,10 +560,16 @@ def test_falls_back_to_dispatch_event(self):
         events = self._recorded(2)
         player = EventPlayer(recorder=self._recorder_with(events), speed_factor=0.0)
 
-        renderer = MagicMock(spec=["add_event_handler", "remove_handler", "dispatch_event"])
+        renderer = MagicMock(
+            spec=["add_event_handler", "remove_handler", "dispatch_event"]
+        )
         dispatched = []
-        renderer.dispatch_event.side_effect = lambda e: dispatched.append(e["event_type"])
-        sm = MagicMock(spec=["renderer"])  # no 'window' attr → forces dispatch_event fallback
+        renderer.dispatch_event.side_effect = lambda e: dispatched.append(
+            e["event_type"]
+        )
+        sm = MagicMock(
+            spec=["renderer"]
+        )  # no 'window' attr → forces dispatch_event fallback
         sm.renderer = renderer
         player.play(sm)
         assert len(dispatched) == 2
@@ -565,8 +579,8 @@ def test_falls_back_to_dispatch_event(self):
 # Integration tests
 # ---------------------------------------------------------------------------
 
-class TestIntegration:
 
+class TestIntegration:
     def test_record_save_load_replay(self, tmp_path):
         """Full round-trip: record → save JSON → load → replay."""
         renderer_src = _make_renderer()
@@ -639,6 +653,7 @@ def test_wheel_round_trip(self, tmp_path):
 
     def test_multiple_sessions_independent(self, tmp_path):
         """Loading a second session replaces the first."""
+
         def _make_session(fname, event_type, n):
             rec = EventRecorder()
             rec._events = [