fix: resolve CI failures (ruff formatting and E501 ignore)

Author: LikhinMN

pymiro/app.py

@@ -1,21 +1,23 @@
 """
 App entry point for pymiro.
 """
-import sys
+
 import asyncio
-from typing import Callable
+import sys
+from collections.abc import Callable
 
-from PySide6.QtWidgets import QApplication, QMainWindow, QWidget, QVBoxLayout
-import qasync # type: ignore
+import qasync  # type: ignore
+from PySide6.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget
 
-from pymiro.core.vnode import VNode
-from pymiro.core.reconciler import reconcile
 from pymiro.backends.qt.renderer import QtRenderer
+from pymiro.core.reconciler import reconcile
 from pymiro.core.signals import effect
-from pymiro.dev import DevLogger, install_error_handler, HotReloader
+from pymiro.core.vnode import VNode
+from pymiro.dev import DevLogger, HotReloader, install_error_handler
+from pymiro.theme.presets import DARK_THEME, DEFAULT_THEME
 from pymiro.theme.provider import ThemeProvider
 from pymiro.theme.theme import Theme
-from pymiro.theme.presets import DEFAULT_THEME, DARK_THEME
+
 
 class App:
     def __init__(
@@ -24,7 +26,7 @@ def __init__(
         width: int = 800,
         height: int = 600,
         dev: bool = False,
-        theme: str | Theme = "default"
+        theme: str | Theme = "default",
     ) -> None:
         self.title = title
         self.width = width
@@ -34,12 +36,12 @@ def __init__(
         self.current_tree: VNode | None = None
         self.logger = DevLogger(enabled=dev)
         self.reloader: HotReloader | None = None
-        
+
         if isinstance(theme, str):
             self.theme = DARK_THEME if theme == "dark" else DEFAULT_THEME
         else:
             self.theme = theme
-        
+
         if self.dev:
             install_error_handler()
             version = sys.version.split(" ")[0]
@@ -50,37 +52,38 @@ def run(self, component: Callable[[], VNode]) -> None:
         app = QApplication.instance()
         if app is None:
             app = QApplication(sys.argv)
-            
+
         ThemeProvider.set(self.theme)
-            
+
         # 2. create main QMainWindow
         main_window = QMainWindow()
         main_window.setWindowTitle(self.title)
         main_window.resize(self.width, self.height)
-        
+
         central_widget = QWidget()
         central_layout = QVBoxLayout()
         central_widget.setLayout(central_layout)
         main_window.setCentralWidget(central_widget)
-        
+
         # 3. setup qasync event loop
         loop = qasync.QEventLoop(app)
         asyncio.set_event_loop(loop)
-        
+
         # 4. setup renderer
         self.renderer = QtRenderer(root_widget=central_widget, logger=self.logger)
-        
+
         if self.dev:
             self.logger.mount(component.__name__)
             self.reloader = HotReloader(
                 root_component=component,
                 reconciler_fn=lambda old, new: reconcile(old, new, logger=self.logger),
                 renderer=self.renderer,
                 watch_dir=".",
-                logger=self.logger
+                logger=self.logger,
             )
-        
+
         is_render_pending = False
+
         def render_cycle() -> None:
             nonlocal is_render_pending
             is_render_pending = False
@@ -100,20 +103,21 @@ def schedule_render() -> None:
 
         # initial render
         self._root_dispose = effect(schedule_render)
-        
+
         if self.reloader:
             self.reloader.start()
-        
+
         # Cleanup on exit
         if hasattr(app, "aboutToQuit"):
             app.aboutToQuit.connect(self._root_dispose)
             if self.reloader:
                 app.aboutToQuit.connect(self.reloader.stop)
-        
+
         main_window.show()
-        
+
         # 6. start event loop
         with loop:
             loop.run_forever()
 
+
 __all__ = ["App"]

pymiro/backends/qt/renderer.py

@@ -1,18 +1,29 @@
 """
 Qt Renderer for pymiro.
 """
+
 from typing import Any
+
+from PySide6.QtCore import QMetaObject, QObject, Qt, Slot
 from PySide6.QtWidgets import QWidget
-from PySide6.QtCore import QObject, QMetaObject, Qt, Slot
 
-from pymiro.core.reconciler import CreateNode, UpdateProps, DestroyNode, SetChildren, MoveNode, Patch
-from pymiro.backends.qt.widgets import create_widget, apply_prop, remove_prop
+from pymiro.backends.qt.widgets import apply_prop, create_widget, remove_prop
+from pymiro.core.reconciler import (
+    CreateNode,
+    DestroyNode,
+    MoveNode,
+    Patch,
+    SetChildren,
+    UpdateProps,
+)
+
 
 class QtRenderer(QObject):
     """
     Implements the Renderer protocol for Qt.
     Mutates Qt widgets based on reconciler patches.
     """
+
     def __init__(self, root_widget: QWidget | None = None, logger: Any = None) -> None:
         super().__init__()
         self.logger = logger
@@ -23,11 +34,7 @@ def __init__(self, root_widget: QWidget | None = None, logger: Any = None) -> No
         self._pending_patches: list[Patch] = []
 
     def create(
-        self,
-        node_id: str,
-        type: str,
-        props: dict[str, Any],
-        parent_id: str | None
+        self, node_id: str, type: str, props: dict[str, Any], parent_id: str | None
     ) -> None:
         widget = create_widget(type)
         self.registry[node_id] = widget
@@ -51,12 +58,7 @@ def create(
                 if layout is not None:
                     layout.addWidget(widget)
 
-    def update(
-        self,
-        node_id: str,
-        changed: dict[str, Any],
-        removed: list[str]
-    ) -> None:
+    def update(self, node_id: str, changed: dict[str, Any], removed: list[str]) -> None:
         widget = self.registry.get(node_id)
         if widget is None:
             return
@@ -77,8 +79,10 @@ def destroy(self, node_id: str) -> None:
         widget = self.registry.pop(node_id, None)
         if widget is None:
             return
-            
-        events_to_unbind = [evt for (nid, evt) in list(self.event_connections.keys()) if nid == node_id]
+
+        events_to_unbind = [
+            evt for (nid, evt) in list(self.event_connections.keys()) if nid == node_id
+        ]
         for evt in events_to_unbind:
             self.unbind_event(node_id, evt)
 
@@ -87,88 +91,86 @@ def destroy(self, node_id: str) -> None:
             layout = parent_widget.layout()
             if layout is not None:
                 layout.removeWidget(widget)
-        
+
         widget.deleteLater()
 
-    def set_children(
-        self,
-        parent_id: str,
-        child_ids: list[str]
-    ) -> None:
+    def set_children(self, parent_id: str, child_ids: list[str]) -> None:
         parent = self.registry.get(parent_id)
         if parent is None:
             return
         layout = parent.layout()
         if layout is None:
             return
-            
+
         for i in reversed(range(layout.count())):
             item = layout.itemAt(i)
             if item is not None:
                 w = item.widget()
                 if w is not None:
                     layout.removeWidget(w)
-                    
-        is_grid = hasattr(layout, "addWidget") and parent.property("grid_cols") is not None
+
+        is_grid = (
+            hasattr(layout, "addWidget") and parent.property("grid_cols") is not None
+        )
         cols = parent.property("grid_cols") or 2
-                    
+
         for idx, cid in enumerate(child_ids):
             child = self.registry.get(cid)
             if child is not None:
                 if is_grid:
-                    layout.addWidget(child, idx // cols, idx % cols) # type: ignore
+                    layout.addWidget(child, idx // cols, idx % cols)  # type: ignore
                 else:
                     layout.addWidget(child)
 
-    def move(
-        self,
-        node_id: str,
-        new_parent_id: str
-    ) -> None:
+    def move(self, node_id: str, new_parent_id: str) -> None:
         widget = self.registry.get(node_id)
         new_parent = self.registry.get(new_parent_id)
         if widget is None or new_parent is None:
             return
-            
+
         old_parent = widget.parentWidget()
         if old_parent is not None:
             old_layout = old_parent.layout()
             if old_layout is not None:
                 old_layout.removeWidget(widget)
-                
+
         new_layout = new_parent.layout()
         if new_layout is not None:
-            is_grid = hasattr(new_layout, "addWidget") and new_parent.property("grid_cols") is not None
+            is_grid = (
+                hasattr(new_layout, "addWidget")
+                and new_parent.property("grid_cols") is not None
+            )
             if is_grid:
                 # Approximate move appending to the end
                 idx = new_layout.count()
                 cols = new_parent.property("grid_cols") or 2
-                new_layout.addWidget(widget, idx // cols, idx % cols) # type: ignore
+                new_layout.addWidget(widget, idx // cols, idx % cols)  # type: ignore
             else:
                 new_layout.addWidget(widget)
 
-    def bind_event(
-        self,
-        node_id: str,
-        event: str,
-        handler: Any
-    ) -> None:
+    def bind_event(self, node_id: str, event: str, handler: Any) -> None:
         widget = self.registry.get(node_id)
         if widget is None:
             return
-            
+
         if (node_id, event) in self.event_connections:
             # Update the existing wrapper without disconnecting Qt signal
             self.event_connections[(node_id, event)]["state"]["handler"] = handler
             return
-            
+
         state = {"handler": handler}
-        
+
         def wrapper(*args: Any, **kwargs: Any) -> None:
             state["handler"](*args, **kwargs)
-            
-        from PySide6.QtWidgets import QLineEdit, QCheckBox, QComboBox, QSlider, QTabWidget
-            
+
+        from PySide6.QtWidgets import (
+            QCheckBox,
+            QComboBox,
+            QLineEdit,
+            QSlider,
+            QTabWidget,
+        )
+
         conn = None
         if event == "on_click" and hasattr(widget, "clicked"):
             conn = widget.clicked.connect(wrapper)
@@ -183,22 +185,29 @@ def wrapper(*args: Any, **kwargs: Any) -> None:
                 conn = widget.valueChanged.connect(wrapper)
             elif isinstance(widget, QTabWidget):
                 conn = widget.currentChanged.connect(wrapper)
-            
+
         if conn is not None:
-            self.event_connections[(node_id, event)] = {"conn": conn, "wrapper": wrapper, "state": state}
+            self.event_connections[(node_id, event)] = {
+                "conn": conn,
+                "wrapper": wrapper,
+                "state": state,
+            }
 
-    def unbind_event(
-        self,
-        node_id: str,
-        event: str
-    ) -> None:
+    def unbind_event(self, node_id: str, event: str) -> None:
         data = self.event_connections.pop((node_id, event), None)
         if data is not None:
             conn = data["conn"]
             widget = self.registry.get(node_id)
             if widget is not None:
                 try:
-                    from PySide6.QtWidgets import QLineEdit, QCheckBox, QComboBox, QSlider, QTabWidget
+                    from PySide6.QtWidgets import (
+                        QCheckBox,
+                        QComboBox,
+                        QLineEdit,
+                        QSlider,
+                        QTabWidget,
+                    )
+
                     if event == "on_click" and hasattr(widget, "clicked"):
                         widget.clicked.disconnect(conn)
                     elif event == "on_change":
@@ -236,6 +245,9 @@ def commit(self, patches: list[Patch]) -> None:
             for patch in patches:
                 self.logger.commit(patch)
         self._pending_patches.extend(patches)
-        QMetaObject.invokeMethod(self, "_apply_patches", Qt.ConnectionType.QueuedConnection)
+        QMetaObject.invokeMethod(
+            self, "_apply_patches", Qt.ConnectionType.QueuedConnection
+        )
+
 
 __all__ = ["QtRenderer"]